src/ui/FUi_AccessibilityTtsPlayer.cpp

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