// limitations under the License.
//
-#include <dlfcn.h>
-#include <FLclLocale.h>
+#include <FBaseColArrayList.h>
+#include <FBaseString.h>
#include <FBaseSysLog.h>
-#include <FBaseColLinkedList.h>
-#include <FUixSpeechTextToSpeech.h>
+#include <FBaseUtilStringTokenizer.h>
+#include <FLclLocale.h>
+#include <FBase_StringConverter.h>
#include "FUi_AccessibilityTtsPlayer.h"
+#include "FUi_AccessibilityManager.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
using namespace Tizen::Locales;
-using namespace Tizen::Uix::Speech;
namespace Tizen { namespace Ui {
_AccessibilityTtsPlayer::_AccessibilityTtsPlayer(_AccessibilityManager& manager)
- : __pTts(null)
- , __grammar(L"")
- , __localeString(L"")
+ : __initialized(false)
+ , __ttsHandle(0)
+ , __localeIdx(-1)
+ , __speed(TTS_SPEED_AUTO)
, __status(ACCESSIBILITY_SCREEN_READER_STATUS_ERROR)
- , __ttsRequestMode(TEXT_TO_SPEECH_REQUEST_MODE_REPLACE)
+ , __grammar(L"")
+ , __pCurrentLocale(null)
+ , __pSupportedLocaleList(null)
, __pManager(&manager)
{
}
+
_AccessibilityTtsPlayer::~_AccessibilityTtsPlayer(void)
{
- delete __pTts;
- __pTts = null;
-}
-result
-_AccessibilityTtsPlayer::ReadGrammar(const String& grammar, bool bInit)
-{
- if(grammar.GetLength() == 0)
+ tts_state_e ttsState = TTS_STATE_READY;
+
+ int ttsError = tts_get_state(__ttsHandle, &ttsState);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get the current state.", GetEngineErrorMessage(ttsError));
+
+ if (ttsState == TTS_STATE_PLAYING || ttsState == TTS_STATE_PAUSED)
{
- return E_SUCCESS;
+ ttsError = tts_stop(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to stop.", GetEngineErrorMessage(ttsError));
}
-// if(bInit && GetStatus() == ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING)
-// {
-// StopReading();
-// }
- SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
- __grammar = grammar;
- if (__pTts)
+
+ if (__initialized)
+ {
+ ttsError = tts_unprepare(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unprepare.", GetEngineErrorMessage(ttsError));
+
+ ttsError = tts_unset_utterance_completed_cb(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance completed callback.", GetEngineErrorMessage(ttsError));
+
+ ttsError = tts_unset_utterance_started_cb(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the utterance started callback.", GetEngineErrorMessage(ttsError));
+
+ ttsError = tts_unset_state_changed_cb(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the state changed callback.", GetEngineErrorMessage(ttsError));
+
+ ttsError = tts_unset_error_cb(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to unset the error callback.", GetEngineErrorMessage(ttsError));
+
+ ttsError = tts_destroy(__ttsHandle);
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to destroy.", GetEngineErrorMessage(ttsError));
+ }
+
+ delete __pCurrentLocale;
+
+ if (__pSupportedLocaleList != null)
{
- SysLog(NID_UI, "Read Element : %ls", grammar.GetPointer());
- __pTts->Speak(grammar, __ttsRequestMode);
+ __pSupportedLocaleList->RemoveAll(true);
+ delete __pSupportedLocaleList;
}
- return E_SUCCESS;
}
+
result
-_AccessibilityTtsPlayer::StopReading(void)
+_AccessibilityTtsPlayer::Construct(void)
{
- if (__pTts)
- {
- __pTts->Stop();
- }
+ Locale *pLocale = new (std::nothrow) Locale(LANGUAGE_INVALID, COUNTRY_INVALID);
+ SysTryReturnResult(NID_UI, pLocale != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
- return E_SUCCESS;
+ ArrayList* pLocaleList = new (std::nothrow) ArrayList();
+ SysTryReturnResult(NID_UI, pLocaleList != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
+
+ result r = pLocaleList->Construct();
+ SysTryReturnResult(NID_UI, r == E_SUCCESS, E_OUT_OF_MEMORY, "The memory is insufficient.");
+
+ __pCurrentLocale = pLocale;
+ __pSupportedLocaleList = pLocaleList;
+
+ return Activate();
}
-AccessibilityScreenReaderStatus
-_AccessibilityTtsPlayer::GetStatus(void)
+
+result
+_AccessibilityTtsPlayer::Activate(void)
{
- return __status;
+ SysAssertf(__initialized != true,
+ "Already calling Initialize() twice or more on a same instance is not allowed for this class.");
+
+ int ttsError = tts_create(&__ttsHandle);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to create.");
+
+ ttsError = tts_set_error_cb(__ttsHandle, TtsErrorReceiver, (void*)(this));
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ ttsError = tts_set_state_changed_cb(__ttsHandle, TtsStateChangedReceiver, (void*)(this));
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ ttsError = tts_set_utterance_started_cb(__ttsHandle, TtsStartedReceiver, (void*)(this));
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ ttsError = tts_set_utterance_completed_cb(__ttsHandle, TtsCompletedReceiver, (void*)(this));
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ ttsError = tts_prepare(__ttsHandle);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ return E_SUCCESS;
}
-String
-_AccessibilityTtsPlayer::GetCurrentGrammar(void)
+
+const char*
+_AccessibilityTtsPlayer::GetEngineStateMessage(const tts_state_e state)
{
- return __grammar;
+ switch (state)
+ {
+ case TTS_STATE_CREATED:
+ return "CREATED";
+
+ case TTS_STATE_READY:
+ return "READY";
+
+ case TTS_STATE_PLAYING:
+ return "PLAYING";
+
+ case TTS_STATE_PAUSED:
+ return "PAUSED";
+
+ default:
+ return "UNKNOWN";
+ }
}
-result
-_AccessibilityTtsPlayer::Activate(void)
+
+const char*
+_AccessibilityTtsPlayer::GetEngineErrorMessage(const int errorType)
{
- result r = E_FAILURE;
- if (__pTts)
+ switch (errorType)
{
- return E_SUCCESS;
+ case TTS_ERROR_NONE:
+ return "TTS_ERROR_NONE";
+
+ case TTS_ERROR_OUT_OF_MEMORY:
+ return "TTS_ERROR_OUT_OF_MEMORY";
+
+ case TTS_ERROR_IO_ERROR:
+ return "TTS_ERROR_IO_ERROR";
+
+ case TTS_ERROR_INVALID_PARAMETER:
+ return "TTS_ERROR_INVALID_PARAMETER";
+
+ case TTS_ERROR_INVALID_STATE:
+ return "TTS_ERROR_INVALID_STATE";
+
+ case TTS_ERROR_INVALID_VOICE:
+ return "TTS_ERROR_INVALID_VOICE";
+
+ case TTS_ERROR_ENGINE_NOT_FOUND:
+ return "TTS_ERROR_ENGINE_NOT_FOUND";
+
+ case TTS_ERROR_TIMED_OUT:
+ return "TTS_ERROR_TIMED_OUT";
+
+ case TTS_ERROR_OPERATION_FAILED:
+ return "TTS_ERROR_OPERATION_FAILED";
+
+ default:
+ return "TTS_ERROR_UNKNOWN_ERROR";
}
- __pTts = new (std::nothrow) TextToSpeech;
- SysTryReturn(NID_UI, __pTts != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed");
- r = __pTts->Construct(*this);
- SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] System error");
- __pTts->Initialize();
+}
- return E_SUCCESS;
+void
+_AccessibilityTtsPlayer::TtsStateChangedReceiver(tts_h ttsHandle, tts_state_e previousState, tts_state_e currentState, void* pTtsInstance)
+{
+ SysLog(NID_UI, "[Accessibility TTS] [%s] ---> [%s]", GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
+
+ if ((previousState == TTS_STATE_CREATED) && (currentState == TTS_STATE_READY))
+ {
+ char *pDefaultLang = null;
+ tts_voice_type_e defaultVoiceType;
+
+ int ttsError = tts_get_default_voice(ttsHandle, &pDefaultLang, &defaultVoiceType);
+ if (ttsError == TTS_ERROR_NONE)
+ {
+ SysLog(NID_UI, "Default language[%s] and voice[%d]", pDefaultLang, defaultVoiceType);
+ const Locale* pDefaultLocale = ConvertEngineLocaleToNativeN(pDefaultLang);
+ if(pDefaultLocale)
+ {
+ delete static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale;
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pCurrentLocale = const_cast<Locale*>(pDefaultLocale);
+ }
+ delete pDefaultLang;
+ }
+
+ ttsError = tts_foreach_supported_voices(ttsHandle, TtsSupportedLocaleListGetter, (void*)(static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__pSupportedLocaleList));
+ SysTryLog(NID_UI, ttsError == TTS_ERROR_NONE, "[%s] Failed to get supported voices", GetEngineErrorMessage(ttsError));
-CATCH:
- delete __pTts;
- __pTts = null;
- return E_SYSTEM;
+ tts_set_mode(ttsHandle, TTS_MODE_SCREEN_READER);
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->__initialized = true;
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
+ }
+ else if ((previousState == TTS_STATE_READY || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_PLAYING))
+ {
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
+ }
+ else if ((previousState == TTS_STATE_PLAYING) && (currentState == TTS_STATE_PAUSED))
+ {
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PAUSE);
+ }
+ else if ((previousState == TTS_STATE_PLAYING || previousState == TTS_STATE_PAUSED) && (currentState == TTS_STATE_READY))
+ {
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
+ }
+ else
+ {
+ SysLog(NID_UI, "[CB] Unknown state. / [%s] ---> [%s]",
+ GetEngineStateMessage(previousState), GetEngineStateMessage(currentState));
+ }
}
-result
-_AccessibilityTtsPlayer::Deactivate(void)
+void
+_AccessibilityTtsPlayer::TtsStartedReceiver(tts_h ttsHandle, int utteranceId, void* pListener)
{
- StopReading();
- delete __pTts;
- __pTts = null;
- return E_SUCCESS;
+ SysLog(NID_UI, "Accessibility TTS reader is started", utteranceId);
}
-
void
-_AccessibilityTtsPlayer::SetMode(_AccessibilityTtsMode mode)
+_AccessibilityTtsPlayer::TtsCompletedReceiver(tts_h ttsHandle, int utteranceId, void* pTtsInstance)
{
- if (mode == _ACCESSIBILITY_TTS_MODE_APPEND)
+ int ttsError = tts_stop(ttsHandle);
+ SysTryReturnVoidResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM,
+ "[CB] Failed to stop, error[%s]", GetEngineErrorMessage(ttsError));
+ _AccessibilityTtsPlayer* pPlayer = static_cast<_AccessibilityTtsPlayer*>(pTtsInstance);
+ pPlayer->SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
+ pPlayer->__pManager->OnFinishReading(pPlayer->__grammar);
+}
+void
+_AccessibilityTtsPlayer::TtsErrorReceiver(tts_h ttsHandle, int ttsUtteranceId, tts_error_e error, void* pTtsInstance)
+{
+ Tizen::Base::String errorMessage =L"";
+ switch (error)
{
- __ttsRequestMode = TEXT_TO_SPEECH_REQUEST_MODE_APPEND;
+ case TTS_ERROR_OUT_OF_MEMORY:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_OUT_OF_MEMORY";
+ break;
+ case TTS_ERROR_IO_ERROR:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_IO_ERROR";
+ break;
+ case TTS_ERROR_OUT_OF_NETWORK:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_NETWORK_ERROR";
+ break;
+ case TTS_ERROR_ENGINE_NOT_FOUND:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_UNSUPPORTED_SERVICE";
+ break;
+ case TTS_ERROR_TIMED_OUT:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_TIME_OUT";
+ break;
+ default:
+ errorMessage = L"TEXT_TO_SPEECH_ERROR_SYSTEM_ERROR";
+ break;
+ }
+ static_cast<_AccessibilityTtsPlayer*>(pTtsInstance)->OnErrorOccurred(errorMessage);
+}
+bool
+_AccessibilityTtsPlayer::TtsSupportedLocaleListGetter(tts_h ttsHandle, const char* pLanguage, tts_voice_type_e voiceType, void* pLocaleList)
+{
+ const Locale* pLocale = ConvertEngineLocaleToNativeN(String(pLanguage));
+ if (pLocale == null)
+ {
+ static_cast <ArrayList*>(pLocaleList)->RemoveAll(true);
+ return false;
+ }
+
+ if (pLocale->GetLanguageCode() == LANGUAGE_INVALID)
+ {
+ SysLog(NID_UI, "[CB] Not support language[%s]", pLanguage);
+ delete pLocale;
}
else
{
- __ttsRequestMode = TEXT_TO_SPEECH_REQUEST_MODE_REPLACE;
+ result r = static_cast<ArrayList*>(pLocaleList)->Add(*pLocale);
+ if (IsFailed(r))
+ {
+ static_cast<ArrayList*>(pLocaleList)->RemoveAll(true);
+ return false;
+ }
}
+ return true;
}
+const char*
+_AccessibilityTtsPlayer::ConvertTizenLocaleToEngineN(const Tizen::Locales::Locale& locale)
+{
+ String strLanguageCode = Locale::LanguageCodeToTwoLetterLanguageCodeString(locale.GetLanguageCode());
+ String strCountryCode = Locale::CountryCodeToString(locale.GetCountryCode());
+ String strLanguage = strLanguageCode + L"_" + strCountryCode;
-void
-_AccessibilityTtsPlayer::ApplyLocale(void)
+ return _StringConverter::CopyToCharArrayN(strLanguage);
+}
+const Tizen::Locales::Locale*
+_AccessibilityTtsPlayer::ConvertEngineLocaleToNativeN(const Tizen::Base::String& strSource)
{
- if (__pTts)
+ String strDelim(L"_");
+ String strLanguageCode;
+ String strCountryCode;
+
+ LanguageCode languageCode = LANGUAGE_INVALID;
+ CountryCode countryCode = COUNTRY_INVALID;
+
+ Utility::StringTokenizer toknizer(strSource, strDelim);
+ if (toknizer.GetTokenCount() == 2)
{
- Locale locale = GetCurrentLocale();
- __pTts->SetLocale(locale);
+ toknizer.GetNextToken(strLanguageCode);
+ toknizer.GetNextToken(strCountryCode);
+
+ languageCode = Locale::TwoLetterLanguageCodeStringToLanguageCode(strLanguageCode);
+ countryCode = Locale::StringToCountryCode(strCountryCode);
}
+
+ return new (std::nothrow) Locale(languageCode, countryCode);
}
-void
-_AccessibilityTtsPlayer::SetLocale(const Tizen::Base::String& localeString)
+result
+_AccessibilityTtsPlayer::Speak(const String& text)
{
- __localeString = localeString;
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+
+ result r = E_SUCCESS;
+ tts_state_e ttsState = TTS_STATE_READY;
+
+ int ttsError = tts_get_state(__ttsHandle, &ttsState);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
+
+ const char* pLanguage = ConvertTizenLocaleToEngineN(*__pCurrentLocale);
+ SysTryReturnResult(NID_UI, pLanguage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
+
+// if (ttsState != TTS_STATE_READY)
+// {
+// Stop();
+// }
+ Stop();
+ const char* pTextN = _StringConverter::CopyToCharArrayN(text);
+ int ttsUtteranceId = 0;
+
+ SysTryCatchLabel(NID_UI, pTextN != null, r = E_OUT_OF_MEMORY, CATCH_LANG, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+ ttsError = tts_add_text(__ttsHandle, pTextN, pLanguage, TTS_VOICE_TYPE_AUTO, __speed, &ttsUtteranceId);
+ SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_OUT_OF_MEMORY, E_SYSTEM, "[E_SYSTEM] Failed to add a text.");
+ ttsError = tts_play(__ttsHandle);
+ SysTryCatch(NID_UI, ttsError == TTS_ERROR_NONE, r = E_SYSTEM, E_SYSTEM, "[%s] Failed to play.", GetEngineErrorMessage(ttsError));
+
+ OnStatusChanged(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
+
+ CATCH:
+ delete[] pTextN;
+
+ CATCH_LANG:
+ delete[] pLanguage;
+
+ return r;
}
-Locale
-_AccessibilityTtsPlayer::GetCurrentLocale(void)
+result
+_AccessibilityTtsPlayer::Stop(void)
{
- Locale locale(LANGUAGE_INVALID, COUNTRY_INVALID);
- if (__pTts)
- {
- const LinkedList* pList = static_cast<const LinkedList*>(__pTts->GetSupportedLocales());
- if (pList && pList->GetCount() > 0)
- {
- int count = pList->GetCount();
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
- bool supportedLanguage = false;
- for (int i = 0 ; i < count ; i++)
- {
- const Locale* pTempLocale = static_cast<const Locale*>(pList->GetAt(i));
- String tempLocaleCode = L"";
- tempLocaleCode.Append(pTempLocale->GetLanguageCodeString());
- tempLocaleCode.Append(L"_");
- tempLocaleCode.Append(pTempLocale->GetCountryCodeString());
- if (tempLocaleCode == __localeString)
- {
- locale = *pTempLocale;
- supportedLanguage = true;
- break;
- }
- }
- if(!supportedLanguage)
- {
- locale = Locale(Tizen::Locales::LANGUAGE_ENG,Tizen::Locales::COUNTRY_US);
- }
- }
- else
- {
- delete __pTts;
- __pTts = null;
- SysLog(NID_UI, "System error was occured.");
- }
+ tts_state_e ttsState = TTS_STATE_READY;
- }
- return locale;
+ int ttsError = tts_get_state(__ttsHandle, &ttsState);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
+ ttsError = tts_stop(__ttsHandle);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to stop.");
+
+ return E_SUCCESS;
}
-void
-_AccessibilityTtsPlayer::OnTextToSpeechInitialized(void)
+result
+_AccessibilityTtsPlayer::Pause(void)
{
- ApplyLocale();
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+
+ tts_state_e ttsState = TTS_STATE_READY;
+
+ int ttsError = tts_get_state(__ttsHandle, &ttsState);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
+ SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PLAYING, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PLAYING.");
+
+ ttsError = tts_pause(__ttsHandle);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to pause.");
+
+ return E_SUCCESS;
}
-void
-_AccessibilityTtsPlayer::OnTextToSpeechCompleted(void)
+result
+_AccessibilityTtsPlayer::Resume(void)
+{
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+
+ tts_state_e ttsState = TTS_STATE_READY;
+
+ int ttsError = tts_get_state(__ttsHandle, &ttsState);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");
+ SysTryReturnResult(NID_UI, ttsState == TTS_STATE_PAUSED, E_INVALID_OPERATION, "The TTS state should be TTS_STATUS_PAUSED.");
+
+ ttsError = tts_play(__ttsHandle);
+ SysTryReturnResult(NID_UI, ttsError == TTS_ERROR_NONE, E_SYSTEM, "Failed to resume.");
+
+ return E_SUCCESS;
+}
+
+result
+_AccessibilityTtsPlayer::SetLocale(const Locale& locale)
{
- __pManager->OnFinishReading(__grammar);
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+ SysTryReturnResult(NID_UI, __pSupportedLocaleList->Contains(locale), E_UNSUPPORTED_LOCALE, "This locale is not supported.");
+
+ *__pCurrentLocale = locale;
+ return E_SUCCESS;
+}
+
+Tizen::Locales::Locale
+_AccessibilityTtsPlayer::GetLocale(void) const
+{
+ SysTryReturn(NID_UI, __initialized, Locale(LANGUAGE_INVALID, COUNTRY_INVALID), E_INVALID_STATE,
+ "[E_INVALID_STATE] Not yet initialized! This method should be called after initialized.");
+
+ SetLastResult(E_SUCCESS);
+ return *__pCurrentLocale;
}
+const Tizen::Base::Collection::IList*
+_AccessibilityTtsPlayer::GetSupportedLocales(void) const
+{
+ SysTryReturnResult(NID_UI, __initialized , null,
+ "Not yet initialized! This method should be called after initialized.");
+
+ SetLastResult(E_SUCCESS);
+ return __pSupportedLocaleList->GetCount() > 0 ? __pSupportedLocaleList : null;
+}
+
+bool
+_AccessibilityTtsPlayer::IsLocaleSupported(const Tizen::Locales::Locale& locale) const
+{
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+
+ SetLastResult(E_SUCCESS);
+ return __pSupportedLocaleList->Contains(locale);
+}
+
+result
+_AccessibilityTtsPlayer::SetSpeechRate(tts_speed_e speechRate)
+{
+ SysTryReturnResult(NID_UI, __initialized , E_INVALID_STATE,
+ "Not yet initialized! This method should be called after initialized.");
+
+ __speed = speechRate;
+
+ return E_SUCCESS;
+}
+
+result
+_AccessibilityTtsPlayer::ReadGrammar(const Tizen::Base::String& grammar, bool init)
+{
+ if(grammar.GetLength() == 0)
+ {
+ return E_SUCCESS;
+ }
+ if(init && GetStatus() == ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING)
+ {
+ StopReading();
+ }
+ SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
+ Speak(grammar);
+ __grammar = grammar;
+ return E_SUCCESS;
+}
+result
+_AccessibilityTtsPlayer::StopReading(void)
+{
+ Stop();
+ return E_SUCCESS;
+}
+AccessibilityScreenReaderStatus
+_AccessibilityTtsPlayer::GetStatus(void)
+{
+ return __status;
+}
+Tizen::Base::String
+_AccessibilityTtsPlayer::GetCurrentGrammar(void)
+{
+ return __grammar;
+}
+
+result
+_AccessibilityTtsPlayer::Deactivate(void)
+{
+ StopReading();
+ return E_SUCCESS;
+}
void
-_AccessibilityTtsPlayer::OnTextToSpeechErrorOccurred (TextToSpeechError error)
+_AccessibilityTtsPlayer::OnErrorOccurred(Tizen::Base::String& errorString)
{
- Deactivate();
- Activate();
}
void
-_AccessibilityTtsPlayer::OnTextToSpeechStatusChanged (TextToSpeechStatus status)
+_AccessibilityTtsPlayer::OnStatusChanged(AccessibilityScreenReaderStatus status)
{
switch(status)
{
- case TEXT_TO_SPEECH_STATUS_SYNTHESIZING:
- SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
+ case ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING:
__pManager->OnStartReading(__grammar);
break;
- case TEXT_TO_SPEECH_STATUS_PLAYING:
- SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_PLAYING);
- break;
- case TEXT_TO_SPEECH_STATUS_PAUSED:
- break;
- case TEXT_TO_SPEECH_STATUS_READY:
- if (__status == ACCESSIBILITY_SCREEN_READER_STATUS_ERROR)
- {
- __pManager->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_FIRST_ITEM);
- }
- SetStatus(ACCESSIBILITY_SCREEN_READER_STATUS_READY);
- break;
default:
break;
}
+ SetStatus(status);
}
+
void
_AccessibilityTtsPlayer::SetStatus(AccessibilityScreenReaderStatus status)
{
__status = status;
}
-
}}
projects / platform / framework / native / uifw.git / commitdiff