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     tts_set_mode(__ttsHandle, TTS_MODE_SCREEN_READER);
 102
 103         ttsError = tts_prepare(__ttsHandle);
 104         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 105
 106         __activated = true;
 107         return E_SUCCESS;
 108 }
 109
 110 const char*
 111 _AccessibilityTtsPlayer::GetEngineStateMessage(const tts_state_e state)
 112 {
 113         switch (state)
 114         {
 115         case TTS_STATE_CREATED:
 116                 return "CREATED";
 117
 118         case TTS_STATE_READY:
 119                 return "READY";
 120
 121         case TTS_STATE_PLAYING:
 122                 return "PLAYING";
 123
 124         case TTS_STATE_PAUSED:
 125                 return "PAUSED";
 126
 127         default:
 128                 return "UNKNOWN";
 129         }
 130 }
 131
 132 const char*
 133 _AccessibilityTtsPlayer::GetEngineErrorMessage(const int errorType)
 134 {
 135         switch (errorType)
 136         {
 137         case TTS_ERROR_NONE:
 138                 return "TTS_ERROR_NONE";
 139
 140         case TTS_ERROR_OUT_OF_MEMORY:
 141                 return "TTS_ERROR_OUT_OF_MEMORY";
 142
 143         case TTS_ERROR_IO_ERROR:
 144                 return "TTS_ERROR_IO_ERROR";
 145
 146         case TTS_ERROR_INVALID_PARAMETER:
 147                 return "TTS_ERROR_INVALID_PARAMETER";
 148
 149         case TTS_ERROR_INVALID_STATE:
 150                 return "TTS_ERROR_INVALID_STATE";
 151
 152         case TTS_ERROR_INVALID_VOICE:
 153                 return "TTS_ERROR_INVALID_VOICE";
 154
 155         case TTS_ERROR_ENGINE_NOT_FOUND:
 156                 return "TTS_ERROR_ENGINE_NOT_FOUND";
 157
 158         case TTS_ERROR_TIMED_OUT:
 159                 return "TTS_ERROR_TIMED_OUT";
 160
 161         case TTS_ERROR_OPERATION_FAILED:
 162                 return "TTS_ERROR_OPERATION_FAILED";
 163
 164         default:
 165                 return "TTS_ERROR_UNKNOWN_ERROR";
 166         }
 167 }
 168
 169 void
 170 _AccessibilityTtsPlayer::TtsStateChangedReceiver(tts_h ttsHandle, tts_state_e previousState, tts_state_e currentState, void* pTtsInstance)
 171 {
 172         SysLog(NID_UI, "[Accessibility TTS] [%s] ---> [%s]", GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
 173
 174         if ((previousState == TTS_STATE_CREATED) && (currentState == TTS_STATE_READY))
 175         {
 176                 char *pDefaultLang = null;
 177                 tts_voice_type_e defaultVoiceType;
 178
 179                 int ttsError = tts_get_default_voice(ttsHandle, &pDefaultLang, &defaultVoiceType);
 180                 if (ttsError == TTS_ERROR_NONE)
 181                 {
 182                         SysLog(NID_UI, "Default language[%s] and voice[%d]", pDefaultLang, defaultVoiceType);
 183                         const Locale* pDefaultLocale = ConvertEngineLocaleToNativeN(pDefaultLang);
 184                         if(pDefaultLocale)
 185                         {
 186                                 delete static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale;
 187                                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale = const_cast<Locale*>(pDefaultLocale);
 188                         }
 189                         free(pDefaultLang);
 190                 }
 191
 192                 ttsError = tts_foreach_supported_voices(ttsHandle, TtsSupportedLocaleListGetter, (void*)(static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pSupportedLocaleList));
 193                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get supported voices", GetEngineErrorMessage(ttsError));
 194
 195         static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__initialized = true;
 196                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 197         }
 198         else if ((previousState == TTS_STATE_READY || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_PLAYING))
 199         {
 200                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 201         }
 202         else if ((previousState == TTS_STATE_PLAYING) && (currentState == TTS_STATE_PAUSED))
 203         {
 204                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PAUSE);
 205         }
 206         else if ((previousState == TTS_STATE_PLAYING || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_READY))
 207         {
 208                 static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 209         }
 210         else
 211         {
 212                 SysLog(NID_UI, "[CB] Unknown state. / [%s] ---> [%s]",
 213                 GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
 214         }
 215 }
 216 void
 217 _AccessibilityTtsPlayer::TtsStartedReceiver(tts_h ttsHandle, int utteranceId, void* pListener)
 218 {
 219         SysLog(NID_UI, "Accessibility TTS reader is started", utteranceId);
 220 }
 221 void
 222 _AccessibilityTtsPlayer::TtsCompletedReceiver(tts_h ttsHandle, int utteranceId, void* pTtsInstance)
 223 {
 224         int ttsError = tts_stop(ttsHandle);
 225         SysTryReturnVoidResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM,
 226         "[CB] Failed to stop, error[%s]", GetEngineErrorMessage(ttsError));
 227         _AccessibilityTtsPlayer* pPlayer = static_cast<_AccessibilityTtsPlayer*>(pTtsInstance);
 228         pPlayer->SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
 229         pPlayer->__pManager->OnFinishReading(pPlayer->__grammar);
 230 }
 231 void
 232 _AccessibilityTtsPlayer::TtsErrorReceiver(tts_h ttsHandle, int ttsUtteranceId, tts_error_e error, void* pTtsInstance)
 233 {
 234         Tizen::Base::String errorMessage =L"";
 235         switch (error)
 236         {
 237         case TTS_ERROR_OUT_OF_MEMORY:
 238                 errorMessage = L"TEXT_TO_SPEECH_ERROR_OUT_OF_MEMORY";
 239                 break;
 240         case TTS_ERROR_IO_ERROR:
 241                 errorMessage = L"TEXT_TO_SPEECH_ERROR_IO_ERROR";
 242                 break;
 243         case TTS_ERROR_OUT_OF_NETWORK:
 244                 errorMessage = L"TEXT_TO_SPEECH_ERROR_NETWORK_ERROR";
 245                 break;
 246         case TTS_ERROR_ENGINE_NOT_FOUND:
 247                 errorMessage = L"TEXT_TO_SPEECH_ERROR_UNSUPPORTED_SERVICE";
 248                 break;
 249         case TTS_ERROR_TIMED_OUT:
 250                 errorMessage = L"TEXT_TO_SPEECH_ERROR_TIME_OUT";
 251                 break;
 252         default:
 253                 errorMessage = L"TEXT_TO_SPEECH_ERROR_SYSTEM_ERROR";
 254                 break;
 255         }
 256         static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnErrorOccurred(errorMessage);
 257 }
 258 bool
 259 _AccessibilityTtsPlayer::TtsSupportedLocaleListGetter(tts_h ttsHandle, const char* pLanguage, tts_voice_type_e voiceType, void* pLocaleList)
 260 {
 261         const Locale* pLocale = ConvertEngineLocaleToNativeN(String(pLanguage));
 262         if (pLocale == null)
 263         {
 264                 static_cast <ArrayList*>(pLocaleList)->RemoveAll(true);
 265                 return false;
 266         }
 267
 268         if (pLocale->GetLanguageCode() == LANGUAGE_INVALID)
 269         {
 270                 SysLog(NID_UI, "[CB] Not support language[%s]", pLanguage);
 271                 delete pLocale;
 272         }
 273         else
 274         {
 275                 result r = static_cast<ArrayList*>(pLocaleList)->Add(*pLocale);
 276                 if (IsFailed(r))
 277                 {
 278                         static_cast<ArrayList*>(pLocaleList)->RemoveAll(true);
 279                         return false;
 280                 }
 281         }
 282         return true;
 283 }
 284 const char*
 285 _AccessibilityTtsPlayer::ConvertTizenLocaleToEngineN(const Tizen::Locales::Locale& locale)
 286 {
 287         String strLanguageCode = Locale::LanguageCodeToTwoLetterLanguageCodeString(locale.GetLanguageCode());
 288         String strCountryCode = Locale::CountryCodeToString(locale.GetCountryCode());
 289         String strLanguage = strLanguageCode + L"_" + strCountryCode;
 290
 291         return _StringConverter::CopyToCharArrayN(strLanguage);
 292 }
 293 const Tizen::Locales::Locale*
 294 _AccessibilityTtsPlayer::ConvertEngineLocaleToNativeN(const Tizen::Base::String& strSource)
 295 {
 296         String strDelim(L"_");
 297         String strLanguageCode;
 298         String strCountryCode;
 299
 300         LanguageCode languageCode = LANGUAGE_INVALID;
 301         CountryCode countryCode = COUNTRY_INVALID;
 302
 303         Utility::StringTokenizer toknizer(strSource, strDelim);
 304         if (toknizer.GetTokenCount() == 2)
 305         {
 306                 toknizer.GetNextToken(strLanguageCode);
 307                 toknizer.GetNextToken(strCountryCode);
 308
 309                 languageCode = Locale::TwoLetterLanguageCodeStringToLanguageCode(strLanguageCode);
 310                 countryCode = Locale::StringToCountryCode(strCountryCode);
 311         }
 312
 313         return new (std::nothrow) Locale(languageCode, countryCode);
 314 }
 315
 316 result
 317 _AccessibilityTtsPlayer::Speak(const String& text)
 318 {
 319         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 320         "Not yet initialized! This method should be called after initialized.");
 321
 322         result r = E_SUCCESS;
 323         tts_state_e ttsState = TTS_STATE_READY;
 324
 325         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 326         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 327
 328         Stop();
 329         const char* pTextN = _StringConverter::CopyToCharArrayN(text);
 330         int ttsUtteranceId = 0;
 331
 332         ttsError = tts_add_text(__ttsHandle, pTextN, null, TTS_VOICE_TYPE_AUTO, __speed, &ttsUtteranceId);
 333         SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_OUT_OF_MEMORY, E_SYSTEM, "[E_SYSTEM] Failed to add a text.");
 334         ttsError = tts_play(__ttsHandle);
 335         SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to play.", GetEngineErrorMessage(ttsError));
 336
 337         OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 338
 339         CATCH:
 340         delete[] pTextN;
 341
 342         return r;
 343 }
 344
 345 result
 346 _AccessibilityTtsPlayer::Stop(void)
 347 {
 348         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 349                         "Not yet initialized! This method should be called after initialized.");
 350
 351         tts_state_e ttsState = TTS_STATE_READY;
 352
 353         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 354         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 355         ttsError = tts_stop(__ttsHandle);
 356         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to stop.");
 357
 358         return E_SUCCESS;
 359 }
 360
 361 result
 362 _AccessibilityTtsPlayer::Pause(void)
 363 {
 364         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 365                         "Not yet initialized! This method should be called after initialized.");
 366
 367         tts_state_e ttsState = TTS_STATE_READY;
 368
 369         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 370         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 371         SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PLAYING, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PLAYING.");
 372
 373         ttsError = tts_pause(__ttsHandle);
 374         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to pause.");
 375
 376         return E_SUCCESS;
 377 }
 378
 379 result
 380 _AccessibilityTtsPlayer::Resume(void)
 381 {
 382         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 383                         "Not yet initialized! This method should be called after initialized.");
 384
 385         tts_state_e ttsState = TTS_STATE_READY;
 386
 387         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 388         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
 389         SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PAUSED, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PAUSED.");
 390
 391         ttsError = tts_play(__ttsHandle);
 392         SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to resume.");
 393
 394         return E_SUCCESS;
 395 }
 396
 397 result
 398 _AccessibilityTtsPlayer::SetLocale(const Locale& locale)
 399 {
 400         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 401                 "Not yet initialized! This method should be called after initialized.");
 402         SysTryReturnResult(NID_UI, __pSupportedLocaleList->Contains(locale), E_UNSUPPORTED_LOCALE, "This locale is not supported.");
 403
 404         *__pCurrentLocale = locale;
 405         return E_SUCCESS;
 406 }
 407
 408 Tizen::Locales::Locale
 409 _AccessibilityTtsPlayer::GetLocale(void) const
 410 {
 411         SysTryReturn(NID_UI, __initialized, Locale(LANGUAGE_INVALID, COUNTRY_INVALID), E_INVALID_STATE,
 412         "[E_INVALID_STATE] Not yet initialized! This method should be called after initialized.");
 413
 414         SetLastResult(E_SUCCESS);
 415         return *__pCurrentLocale;
 416 }
 417
 418 const Tizen::Base::Collection::IList*
 419 _AccessibilityTtsPlayer::GetSupportedLocales(void) const
 420 {
 421         SysTryReturnResult(NID_UI, __initialized , null,
 422                 "Not yet initialized! This method should be called after initialized.");
 423
 424         SetLastResult(E_SUCCESS);
 425         return __pSupportedLocaleList->GetCount() > 0 ? __pSupportedLocaleList : null;
 426 }
 427
 428 bool
 429 _AccessibilityTtsPlayer::IsLocaleSupported(const Tizen::Locales::Locale& locale) const
 430 {
 431         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 432                 "Not yet initialized! This method should be called after initialized.");
 433
 434         SetLastResult(E_SUCCESS);
 435         return __pSupportedLocaleList->Contains(locale);
 436 }
 437
 438 result
 439 _AccessibilityTtsPlayer::SetSpeechRate(tts_speed_e speechRate)
 440 {
 441         SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
 442                 "Not yet initialized! This method should be called after initialized.");
 443
 444         __speed = speechRate;
 445
 446         return E_SUCCESS;
 447 }
 448
 449 result
 450 _AccessibilityTtsPlayer::ReadGrammar(const Tizen::Base::String& grammar, bool init)
 451 {
 452         if(grammar.GetLength() == 0)
 453         {
 454                 return E_SUCCESS;
 455         }
 456         if(init && GetStatus() == ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING)
 457         {
 458                 StopReading();
 459         }
 460         SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
 461         Speak(grammar);
 462         __grammar = grammar;
 463         return E_SUCCESS;
 464 }
 465 result
 466 _AccessibilityTtsPlayer::StopReading(void)
 467 {
 468         Stop();
 469         return E_SUCCESS;
 470 }
 471 AccessibilityScreenReaderStatus
 472 _AccessibilityTtsPlayer::GetStatus(void)
 473 {
 474         return __status;
 475 }
 476 Tizen::Base::String
 477 _AccessibilityTtsPlayer::GetCurrentGrammar(void)
 478 {
 479         return __grammar;
 480 }
 481
 482 result
 483 _AccessibilityTtsPlayer::Deactivate(void)
 484 {
 485         __initialized = false;
 486         tts_state_e ttsState = TTS_STATE_READY;
 487
 488         int ttsError = tts_get_state(__ttsHandle, &ttsState);
 489         SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get the current state.", GetEngineErrorMessage(ttsError));
 490
 491         if (ttsState == TTS_STATE_PLAYING || ttsState == TTS_STATE_PAUSED)
 492         {
 493                 ttsError = tts_stop(__ttsHandle);
 494                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to stop.", GetEngineErrorMessage(ttsError));
 495         }
 496         if (__activated)
 497         {
 498                 ttsError = tts_unprepare(__ttsHandle);
 499                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unprepare.", GetEngineErrorMessage(ttsError));
 500
 501                 ttsError = tts_unset_utterance_completed_cb(__ttsHandle);
 502                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance completed callback.", GetEngineErrorMessage(ttsError));
 503
 504                 ttsError = tts_unset_utterance_started_cb(__ttsHandle);
 505                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance started callback.", GetEngineErrorMessage(ttsError));
 506
 507                 ttsError = tts_unset_state_changed_cb(__ttsHandle);
 508                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the state changed callback.", GetEngineErrorMessage(ttsError));
 509
 510                 ttsError = tts_unset_error_cb(__ttsHandle);
 511                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the error callback.", GetEngineErrorMessage(ttsError));
 512
 513                 ttsError = tts_destroy(__ttsHandle);
 514                 SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to destroy.", GetEngineErrorMessage(ttsError));
 515
 516                 __ttsHandle = 0;
 517         }
 518         __activated = false;
 519         return E_SUCCESS;
 520 }
 521 void
 522 _AccessibilityTtsPlayer::OnErrorOccurred(Tizen::Base::String& errorString)
 523 {
 524 }
 525 void
 526 _AccessibilityTtsPlayer::OnStatusChanged(AccessibilityScreenReaderStatus status)
 527 {
 528         switch(status)
 529         {
 530                 case ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING:
 531                         __pManager->OnStartReading(__grammar);
 532                         break;
 533                 default:
 534                         break;
 535         }
 536         SetStatus(status);
 537 }
 538
 539 void
 540 _AccessibilityTtsPlayer::SetStatus(AccessibilityScreenReaderStatus status)
 541 {
 542         __status = status;
 543 }
 544 }}
 545