src/ui/FUi_AccessibilityTtsPlayer.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an ”AS IS” BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <FBaseColArrayList.h>
  19 #include <FBaseString.h>
  20 #include <FBaseSysLog.h>
  21 #include <FBaseUtilStringTokenizer.h>
  22 #include <FLclLocale.h>
  23 #include <FBase_StringConverter.h>
  24 #include "FUi_AccessibilityTtsPlayer.h"
  25 #include "FUi_AccessibilityManager.h"
  26
  27 using namespace Tizen::Base;
  28 using namespace Tizen::Base::Collection;
  29 using namespace Tizen::Locales;
  30
  31 namespace Tizen { namespace Ui {
  32
  33 _AccessibilityTtsPlayer::_AccessibilityTtsPlayer(_AccessibilityManager& manager)
  34         : __initialized(false)
  35         , __activated(false)
  36         , __ttsHandle(0)
  37         , __localeIdx(-1)
  38         , __speed(TTS_SPEED_AUTO)
  39         , __status(ACCESSIBILITY_SCREEN_READER_STATUS_ERROR)
  40         , __grammar(L"")
  41         , __pCurrentLocale(null)
  42         , __pSupportedLocaleList(null)
  43         , __pManager(&manager)
  44 {
  45 }
  46
  47 _AccessibilityTtsPlayer::~_AccessibilityTtsPlayer(void)
  48 {
  49         Deactivate();
  50         delete __pCurrentLocale;
  51
  52         if (__pSupportedLocaleList != null)
  53         {
  54                 __pSupportedLocaleList->RemoveAll(true);
  55                 delete __pSupportedLocaleList;
  56         }
  57 }
  58
  59 result
  60 _AccessibilityTtsPlayer::Construct(void)
  61 {
  62         Locale *pLocale = new (std::nothrow) Locale(LANGUAGE_INVALID, COUNTRY_INVALID);
  63         SysTryReturnResult(NID_UI, pLocale != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
  64
  65         ArrayList* pLocaleList = new (std::nothrow) ArrayList();
  66         SysTryReturnResult(NID_UI, pLocaleList != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
  67
  68         result r = pLocaleList->Construct();
  69         SysTryReturnResult(NID_UI, r == E_SUCCESS, E_OUT_OF_MEMORY, "The memory is insufficient.");
  70
  71         __pCurrentLocale = pLocale;
  72         __pSupportedLocaleList = pLocaleList;
  73
  74         return r;
  75 }
  76
  77 result
  78 _AccessibilityTtsPlayer::Activate(void)
  79 {
  80         if (__activated)
  81         {
  82                 SysLog(NID_UI, "TTS player was already activated.");
  83                 return E_SUCCESS;
  84         }
  85
  86         int ttsError = tts_create(&__ttsHandle);
  87         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to create.");
  88
  89         ttsError = tts_set_error_cb(__ttsHandle, TtsErrorReceiver, (void*)(this));
  90         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  91
  92         ttsError = tts_set_state_changed_cb(__ttsHandle, TtsStateChangedReceiver, (void*)(this));
  93         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  94
  95         ttsError = tts_set_utterance_started_cb(__ttsHandle, TtsStartedReceiver, (void*)(this));
  96         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  97
  98         ttsError = tts_set_utterance_completed_cb(__ttsHandle, TtsCompletedReceiver, (void*)(this));
  99         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 100
 101         ttsError = tts_prepare(__ttsHandle);
 102         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 103
 104         __activated = true;
 105         return E_SUCCESS;
 106 }
 107
 108 const char*
 109 _AccessibilityTtsPlayer::GetEngineStateMessage(const tts_state_e state)
 110 {
 111         switch (state)
 112         {
 113         case TTS_STATE_CREATED:
 114                 return "CREATED";
 115
 116         case TTS_STATE_READY:
 117                 return "READY";
 118
 119         case TTS_STATE_PLAYING:
 120                 return "PLAYING";
 121
 122         case TTS_STATE_PAUSED:
 123                 return "PAUSED";
 124
 125         default:
 126                 return "UNKNOWN";
 127         }
 128 }
 129
 130 const char*
 131 _AccessibilityTtsPlayer::GetEngineErrorMessage(const int errorType)
 132 {
 133         switch (errorType)
 134         {
 135         case TTS_ERROR_NONE:
 136                 return "TTS_ERROR_NONE";
 137
 138         case TTS_ERROR_OUT_OF_MEMORY:
 139                 return "TTS_ERROR_OUT_OF_MEMORY";
 140
 141         case TTS_ERROR_IO_ERROR:
 142                 return "TTS_ERROR_IO_ERROR";
 143
 144         case TTS_ERROR_INVALID_PARAMETER:
 145                 return "TTS_ERROR_INVALID_PARAMETER";
 146
 147         case TTS_ERROR_INVALID_STATE:
 148                 return "TTS_ERROR_INVALID_STATE";
 149
 150         case TTS_ERROR_INVALID_VOICE:
 151                 return "TTS_ERROR_INVALID_VOICE";
 152
 153         case TTS_ERROR_ENGINE_NOT_FOUND:
 154                 return "TTS_ERROR_ENGINE_NOT_FOUND";
 155
 156         case TTS_ERROR_TIMED_OUT:
 157                 return "TTS_ERROR_TIMED_OUT";
 158
 159         case TTS_ERROR_OPERATION_FAILED:
 160                 return "TTS_ERROR_OPERATION_FAILED";
 161
 162         default:
 163                 return "TTS_ERROR_UNKNOWN_ERROR";
 164         }
 165 }
 166
 167 void
 168 _AccessibilityTtsPlayer::TtsStateChangedReceiver(tts_h ttsHandle, tts_state_e previousState, tts_state_e currentState, void* pTtsInstance)
 169 {
 170         SysLog(NID_UI, "[Accessibility TTS] [%s] ---> [%s]", GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
 171
 172         if ((previousState == TTS_STATE_CREATED) && (currentState == TTS_STATE_READY))
 173         {
 174                 char *pDefaultLang = null;
 175                 tts_voice_type_e defaultVoiceType;
 176
 177                 int ttsError = tts_get_default_voice(ttsHandle, &pDefaultLang, &defaultVoiceType);
 178                 if (ttsError == TTS_ERROR_NONE)
 179                 {
 180                         SysLog(NID_UI, "Default language[%s] and voice[%d]", pDefaultLang, defaultVoiceType);
 181                         const Locale* pDefaultLocale = ConvertEngineLocaleToNativeN(pDefaultLang);
 182                         if(pDefaultLocale)
 183                         {
 184                                 delete static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale;
 185                                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale = const_cast<Locale*>(pDefaultLocale);
 186                         }
 187                         free(pDefaultLang);
 188                 }
 189
 190                 ttsError = tts_foreach_supported_voices(ttsHandle, TtsSupportedLocaleListGetter, (void*)(static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pSupportedLocaleList));
 191                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get supported voices", GetEngineErrorMessage(ttsError));
 192
 193                 tts_set_mode(ttsHandle, TTS_MODE_SCREEN_READER);
 194                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__initialized = true;
 195                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 196         }
 197         else if ((previousState == TTS_STATE_READY || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_PLAYING))
 198         {
 199                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 200         }
 201         else if ((previousState == TTS_STATE_PLAYING) && (currentState == TTS_STATE_PAUSED))
 202         {
 203                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PAUSE);
 204         }
 205         else if ((previousState == TTS_STATE_PLAYING || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_READY))
 206         {
 207                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 208         }
 209         else
 210         {
 211                 SysLog(NID_UI, "[CB] Unknown state. / [%s] ---> [%s]",
 212                 GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
 213         }
 214 }
 215 void
 216 _AccessibilityTtsPlayer::TtsStartedReceiver(tts_h ttsHandle, int utteranceId, void* pListener)
 217 {
 218         SysLog(NID_UI, "Accessibility TTS reader is started", utteranceId);
 219 }
 220 void
 221 _AccessibilityTtsPlayer::TtsCompletedReceiver(tts_h ttsHandle, int utteranceId, void* pTtsInstance)
 222 {
 223         int ttsError = tts_stop(ttsHandle);
 224         SysTryReturnVoidResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM,
 225         "[CB] Failed to stop, error[%s]", GetEngineErrorMessage(ttsError));
 226         _AccessibilityTtsPlayer* pPlayer = static_cast<_AccessibilityTtsPlayer*>(pTtsInstance);
 227         pPlayer->SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 228         pPlayer->__pManager->OnFinishReading(pPlayer->__grammar);
 229 }
 230 void
 231 _AccessibilityTtsPlayer::TtsErrorReceiver(tts_h ttsHandle, int ttsUtteranceId, tts_error_e error, void* pTtsInstance)
 232 {
 233         Tizen::Base::String errorMessage =L"";
 234         switch (error)
 235         {
 236         case TTS_ERROR_OUT_OF_MEMORY:
 237                 errorMessage = L"TEXT_TO_SPEECH_ERROR_OUT_OF_MEMORY";
 238                 break;
 239         case TTS_ERROR_IO_ERROR:
 240                 errorMessage = L"TEXT_TO_SPEECH_ERROR_IO_ERROR";
 241                 break;
 242         case TTS_ERROR_OUT_OF_NETWORK:
 243                 errorMessage = L"TEXT_TO_SPEECH_ERROR_NETWORK_ERROR";
 244                 break;
 245         case TTS_ERROR_ENGINE_NOT_FOUND:
 246                 errorMessage = L"TEXT_TO_SPEECH_ERROR_UNSUPPORTED_SERVICE";
 247                 break;
 248         case TTS_ERROR_TIMED_OUT:
 249                 errorMessage = L"TEXT_TO_SPEECH_ERROR_TIME_OUT";
 250                 break;
 251         default:
 252                 errorMessage = L"TEXT_TO_SPEECH_ERROR_SYSTEM_ERROR";
 253                 break;
 254         }
 255         static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnErrorOccurred(errorMessage);
 256 }
 257 bool
 258 _AccessibilityTtsPlayer::TtsSupportedLocaleListGetter(tts_h ttsHandle, const char* pLanguage, tts_voice_type_e voiceType, void* pLocaleList)
 259 {
 260         const Locale* pLocale = ConvertEngineLocaleToNativeN(String(pLanguage));
 261         if (pLocale == null)
 262         {
 263                 static_cast <ArrayList*>(pLocaleList)->RemoveAll(true);
 264                 return false;
 265         }
 266
 267         if (pLocale->GetLanguageCode() == LANGUAGE_INVALID)
 268         {
 269                 SysLog(NID_UI, "[CB] Not support language[%s]", pLanguage);
 270                 delete pLocale;
 271         }
 272         else
 273         {
 274                 result r = static_cast<ArrayList*>(pLocaleList)->Add(*pLocale);
 275                 if (IsFailed(r))
 276                 {
 277                         static_cast<ArrayList*>(pLocaleList)->RemoveAll(true);
 278                         return false;
 279                 }
 280         }
 281         return true;
 282 }
 283 const char*
 284 _AccessibilityTtsPlayer::ConvertTizenLocaleToEngineN(const Tizen::Locales::Locale& locale)
 285 {
 286         String strLanguageCode = Locale::LanguageCodeToTwoLetterLanguageCodeString(locale.GetLanguageCode());
 287         String strCountryCode = Locale::CountryCodeToString(locale.GetCountryCode());
 288         String strLanguage = strLanguageCode + L"_" + strCountryCode;
 289
 290         return _StringConverter::CopyToCharArrayN(strLanguage);
 291 }
 292 const Tizen::Locales::Locale*
 293 _AccessibilityTtsPlayer::ConvertEngineLocaleToNativeN(const Tizen::Base::String& strSource)
 294 {
 295         String strDelim(L"_");
 296         String strLanguageCode;
 297         String strCountryCode;
 298
 299         LanguageCode languageCode = LANGUAGE_INVALID;
 300         CountryCode countryCode = COUNTRY_INVALID;
 301
 302         Utility::StringTokenizer toknizer(strSource, strDelim);
 303         if (toknizer.GetTokenCount() == 2)
 304         {
 305                 toknizer.GetNextToken(strLanguageCode);
 306                 toknizer.GetNextToken(strCountryCode);
 307
 308                 languageCode = Locale::TwoLetterLanguageCodeStringToLanguageCode(strLanguageCode);
 309                 countryCode = Locale::StringToCountryCode(strCountryCode);
 310         }
 311
 312         return new (std::nothrow) Locale(languageCode, countryCode);
 313 }
 314
 315 result
 316 _AccessibilityTtsPlayer::Speak(const String& text)
 317 {
 318         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 319         "Not yet initialized! This method should be called after initialized.");
 320
 321         result r = E_SUCCESS;
 322         tts_state_e ttsState = TTS_STATE_READY;
 323
 324         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 325         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 326
 327         const char* pLanguage = ConvertTizenLocaleToEngineN(*__pCurrentLocale);
 328         SysTryReturnResult(NID_UI, pLanguage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 329
 330 //      if (ttsState != TTS_STATE_READY)
 331 //      {
 332 //              Stop();
 333 //      }
 334         Stop();
 335         const char* pTextN = _StringConverter::CopyToCharArrayN(text);
 336         int ttsUtteranceId = 0;
 337
 338         SysTryCatchLabel(NID_UI, pTextN != null, r = E_OUT_OF_MEMORY, CATCH_LANG, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 339
 340         ttsError = tts_add_text(__ttsHandle, pTextN, pLanguage, TTS_VOICE_TYPE_AUTO, __speed, &ttsUtteranceId);
 341         SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_OUT_OF_MEMORY, E_SYSTEM, "[E_SYSTEM] Failed to add a text.");
 342         ttsError = tts_play(__ttsHandle);
 343         SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to play.", GetEngineErrorMessage(ttsError));
 344
 345         OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 346
 347         CATCH:
 348         delete[] pTextN;
 349
 350         CATCH_LANG:
 351         delete[] pLanguage;
 352
 353         return r;
 354 }
 355
 356 result
 357 _AccessibilityTtsPlayer::Stop(void)
 358 {
 359         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 360                         "Not yet initialized! This method should be called after initialized.");
 361
 362         tts_state_e ttsState = TTS_STATE_READY;
 363
 364         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 365         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 366         ttsError = tts_stop(__ttsHandle);
 367         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to stop.");
 368
 369         return E_SUCCESS;
 370 }
 371
 372 result
 373 _AccessibilityTtsPlayer::Pause(void)
 374 {
 375         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 376                         "Not yet initialized! This method should be called after initialized.");
 377
 378         tts_state_e ttsState = TTS_STATE_READY;
 379
 380         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 381         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 382         SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PLAYING, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PLAYING.");
 383
 384         ttsError = tts_pause(__ttsHandle);
 385         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to pause.");
 386
 387         return E_SUCCESS;
 388 }
 389
 390 result
 391 _AccessibilityTtsPlayer::Resume(void)
 392 {
 393         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 394                         "Not yet initialized! This method should be called after initialized.");
 395
 396         tts_state_e ttsState = TTS_STATE_READY;
 397
 398         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 399         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 400         SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PAUSED, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PAUSED.");
 401
 402         ttsError = tts_play(__ttsHandle);
 403         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to resume.");
 404
 405         return E_SUCCESS;
 406 }
 407
 408 result
 409 _AccessibilityTtsPlayer::SetLocale(const Locale& locale)
 410 {
 411         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 412                 "Not yet initialized! This method should be called after initialized.");
 413         SysTryReturnResult(NID_UI, __pSupportedLocaleList->Contains(locale), E_UNSUPPORTED_LOCALE, "This locale is not supported.");
 414
 415         *__pCurrentLocale = locale;
 416         return E_SUCCESS;
 417 }
 418
 419 Tizen::Locales::Locale
 420 _AccessibilityTtsPlayer::GetLocale(void) const
 421 {
 422         SysTryReturn(NID_UI, __initialized, Locale(LANGUAGE_INVALID, COUNTRY_INVALID), E_INVALID_STATE,
 423         "[E_INVALID_STATE] Not yet initialized! This method should be called after initialized.");
 424
 425         SetLastResult(E_SUCCESS);
 426         return *__pCurrentLocale;
 427 }
 428
 429 const Tizen::Base::Collection::IList*
 430 _AccessibilityTtsPlayer::GetSupportedLocales(void) const
 431 {
 432         SysTryReturnResult(NID_UI, __initialized , null,
 433                 "Not yet initialized! This method should be called after initialized.");
 434
 435         SetLastResult(E_SUCCESS);
 436         return __pSupportedLocaleList->GetCount() > 0 ? __pSupportedLocaleList : null;
 437 }
 438
 439 bool
 440 _AccessibilityTtsPlayer::IsLocaleSupported(const Tizen::Locales::Locale& locale) const
 441 {
 442         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 443                 "Not yet initialized! This method should be called after initialized.");
 444
 445         SetLastResult(E_SUCCESS);
 446         return __pSupportedLocaleList->Contains(locale);
 447 }
 448
 449 result
 450 _AccessibilityTtsPlayer::SetSpeechRate(tts_speed_e speechRate)
 451 {
 452         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 453                 "Not yet initialized! This method should be called after initialized.");
 454
 455         __speed = speechRate;
 456
 457         return E_SUCCESS;
 458 }
 459
 460 result
 461 _AccessibilityTtsPlayer::ReadGrammar(const Tizen::Base::String& grammar, bool init)
 462 {
 463         if(grammar.GetLength() == 0)
 464         {
 465                 return E_SUCCESS;
 466         }
 467         if(init && GetStatus() == ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING)
 468         {
 469                 StopReading();
 470         }
 471         SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 472         Speak(grammar);
 473         __grammar = grammar;
 474         return E_SUCCESS;
 475 }
 476 result
 477 _AccessibilityTtsPlayer::StopReading(void)
 478 {
 479         Stop();
 480         return E_SUCCESS;
 481 }
 482 AccessibilityScreenReaderStatus
 483 _AccessibilityTtsPlayer::GetStatus(void)
 484 {
 485         return __status;
 486 }
 487 Tizen::Base::String
 488 _AccessibilityTtsPlayer::GetCurrentGrammar(void)
 489 {
 490         return __grammar;
 491 }
 492
 493 result
 494 _AccessibilityTtsPlayer::Deactivate(void)
 495 {
 496         __initialized = false;
 497         tts_state_e ttsState = TTS_STATE_READY;
 498
 499         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 500         SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get the current state.", GetEngineErrorMessage(ttsError));
 501
 502         if (ttsState == TTS_STATE_PLAYING || ttsState == TTS_STATE_PAUSED)
 503         {
 504                 ttsError = tts_stop(__ttsHandle);
 505                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to stop.", GetEngineErrorMessage(ttsError));
 506         }
 507         if (__activated)
 508         {
 509                 ttsError = tts_unprepare(__ttsHandle);
 510                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unprepare.", GetEngineErrorMessage(ttsError));
 511
 512                 ttsError = tts_unset_utterance_completed_cb(__ttsHandle);
 513                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance completed callback.", GetEngineErrorMessage(ttsError));
 514
 515                 ttsError = tts_unset_utterance_started_cb(__ttsHandle);
 516                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance started callback.", GetEngineErrorMessage(ttsError));
 517
 518                 ttsError = tts_unset_state_changed_cb(__ttsHandle);
 519                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the state changed callback.", GetEngineErrorMessage(ttsError));
 520
 521                 ttsError = tts_unset_error_cb(__ttsHandle);
 522                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the error callback.", GetEngineErrorMessage(ttsError));
 523
 524                 ttsError = tts_destroy(__ttsHandle);
 525                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to destroy.", GetEngineErrorMessage(ttsError));
 526
 527                 __ttsHandle = 0;
 528         }
 529         __activated = false;
 530         return E_SUCCESS;
 531 }
 532 void
 533 _AccessibilityTtsPlayer::OnErrorOccurred(Tizen::Base::String& errorString)
 534 {
 535 }
 536 void
 537 _AccessibilityTtsPlayer::OnStatusChanged(AccessibilityScreenReaderStatus status)
 538 {
 539         switch(status)
 540         {
 541                 case ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING:
 542                         __pManager->OnStartReading(__grammar);
 543                         break;
 544                 default:
 545                         break;
 546         }
 547         SetStatus(status);
 548 }
 549
 550 void
 551 _AccessibilityTtsPlayer::SetStatus(AccessibilityScreenReaderStatus status)
 552 {
 553         __status = status;
 554 }
 555 }}
 556