From b377d4cd59636753ad0b0065cb1988bec2a323b2 Mon Sep 17 00:00:00 2001 From: Bumseung Cho Date: Mon, 8 Apr 2013 21:24:07 +0900 Subject: [PATCH] Uix::Speech::TextToSpeech class is replaced by tts c apis. Change-Id: Ia06bf9c22e7c41f8e28719953e9e2ab2ca9efd7f Signed-off-by: Bumseung Cho --- packaging/osp-uifw.spec | 3 - src/ui/FUi_AccessibilityManager.cpp | 19 +- src/ui/FUi_AccessibilitySystemSettingLoader.cpp | 19 +- src/ui/FUi_AccessibilityTtsPlayer.cpp | 582 +++++++++++++++++----- src/ui/controls/FUiCtrl_Toolbar.cpp | 4 +- src/ui/inc/FUi_AccessibilitySystemSettingLoader.h | 7 +- src/ui/inc/FUi_AccessibilityTtsPlayer.h | 70 +-- src/uifw/CMakeLists.txt | 1 - 8 files changed, 514 insertions(+), 191 deletions(-) diff --git a/packaging/osp-uifw.spec b/packaging/osp-uifw.spec index 71026bb..79753a3 100644 --- a/packaging/osp-uifw.spec +++ b/packaging/osp-uifw.spec @@ -41,7 +41,6 @@ BuildRequires: pkgconfig(libtbm) BuildRequires: pkgconfig(libpng) BuildRequires: pkgconfig(libwbxml2) BuildRequires: pkgconfig(osp-appfw) -BuildRequires: pkgconfig(osp-speech) BuildRequires: osp-appfw-internal-devel BuildRequires: pkgconfig(osp-image-core) BuildRequires: osp-image-core-internal-devel @@ -64,8 +63,6 @@ Requires: capi-appfw-application Requires: capi-system-info Requires: osp-appfw Requires: osp-image-core -Requires: osp-speech - Provides: libosp-uifw.so.1 Requires(post): /sbin/ldconfig diff --git a/src/ui/FUi_AccessibilityManager.cpp b/src/ui/FUi_AccessibilityManager.cpp index ecb2933..ce4f3a8 100755 --- a/src/ui/FUi_AccessibilityManager.cpp +++ b/src/ui/FUi_AccessibilityManager.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -129,8 +130,8 @@ public: { __start = false; Start(__mode); - return; SysLog(NID_UI, "AccessibilityManager::AutoReadingTimer is started again because tts is not initialized."); + return; } __start = false; __pAccessibilityManager->ReadElement(__mode); @@ -320,15 +321,15 @@ _AccessibilityManager::Initialize(void) SysTryReturn(NID_UI, __pAccGesture, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed"); __pTtsPlayer = new (std::nothrow) _AccessibilityTtsPlayer(*this); SysTryCatch(NID_UI, __pTtsPlayer, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed"); + __pTtsPlayer->Construct(); __pSettingLoader = new (std::nothrow) _AccessibilitySystemSettingLoader(*this); SysTryCatch(NID_UI, __pSettingLoader, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed"); if (IsScreenReaderActivated()) { - __pTtsPlayer->SetLocale(__pSettingLoader->GetLocaleString()); + __pTtsPlayer->SetLocale(__pSettingLoader->GetLocale()); __pTtsPlayer->Activate(); } - pGuidePopupTimer = new (std::nothrow) GuidePopupTimer; SysTryCatch(NID_UI, pGuidePopupTimer, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed"); pAutoReadingTimer = new (std::nothrow) AutoReadingTimer(this); @@ -1016,7 +1017,6 @@ _AccessibilityManager::ShowPopup() float x = 0; float y = 0; float popupHeight = topMargin + bottomMargin + titleHeight + textTopMargin + textHeight * 8; - Frame* pFrame = UiApp::GetInstance()->GetAppFrame()->GetFrame(); Form* pForm = pFrame->GetCurrentForm(); FloatDimension screen = Tizen::Ui::_ControlManager::GetInstance()->GetScreenSizeF(); @@ -1650,7 +1650,7 @@ _AccessibilityManager::SetTtsMode(_AccessibilityTtsMode mode) { if (__pTtsPlayer) { - __pTtsPlayer->SetMode(mode); + //__pTtsPlayer->SetMode(mode); } } @@ -1704,7 +1704,6 @@ _AccessibilityManager::DrawFocusUi(const _AccessibilityElement& element) __pFocusVe->SetName("Accessibility focus ui"); __pFocusVe->SetImplicitAnimationEnabled(false); - __pFocusVe->SetShowState(true); __focusedControlHandle = pControl->GetHandle(); pControlVe->AttachChild(*__pFocusVe); @@ -1713,7 +1712,7 @@ _AccessibilityManager::DrawFocusUi(const _AccessibilityElement& element) __pFocusVe->SetBounds(FloatRectangle(rectangle.x, rectangle.y, rectangle.width, rectangle.height)); pCanvas = __pFocusVe->GetCanvasN(); SysTryCatch(NID_UI, pCanvas, , E_SYSTEM, "[E_SYSTEM] System error"); - pCanvas->SetBackgroundColor(0x55555555); + pCanvas->SetBackgroundColor(0x00000000); pCanvas->Clear(); Bitmap* pBitmap = null; result r = GET_BITMAP_CONFIG_N(ACCESSIBILITY::FOCUS, BITMAP_PIXEL_FORMAT_ARGB8888, pBitmap); @@ -1730,6 +1729,7 @@ _AccessibilityManager::DrawFocusUi(const _AccessibilityElement& element) SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] System error"); } } + __pFocusVe->SetShowState(true); delete pCanvas; } @@ -2077,8 +2077,7 @@ _AccessibilityManager::OnChangedLocale(void) { if (__pTtsPlayer && __pSettingLoader) { - __pTtsPlayer->SetLocale(__pSettingLoader->GetLocaleString()); - __pTtsPlayer->ApplyLocale(); + __pTtsPlayer->SetLocale(__pSettingLoader->GetLocale()); } } @@ -2096,7 +2095,7 @@ _AccessibilityManager::OnAccessibilityScreenReaderIsActivated(bool set) { if (__pTtsPlayer) { - __pTtsPlayer->SetLocale(__pSettingLoader->GetLocaleString()); + __pTtsPlayer->SetLocale(__pSettingLoader->GetLocale()); __pTtsPlayer->Activate(); } } diff --git a/src/ui/FUi_AccessibilitySystemSettingLoader.cpp b/src/ui/FUi_AccessibilitySystemSettingLoader.cpp index a9e7dbd..c730d88 100644 --- a/src/ui/FUi_AccessibilitySystemSettingLoader.cpp +++ b/src/ui/FUi_AccessibilitySystemSettingLoader.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include "FUi_AccessibilitySystemSettingLoader.h" #include "FUi_AccessibilityManager.h" @@ -24,6 +25,7 @@ #include "FUi_EcoreEvas.h" using namespace Tizen::Base; +using namespace Tizen::Locales; using namespace Tizen::System; namespace Tizen { namespace Ui { @@ -49,6 +51,10 @@ _AccessibilitySystemSettingLoader::OnSettingChanged(String& key) { __pManager->OnChangedLocale(); } + else if (key == L"http://tizen.org/setting/speech.tts.screen") + { + _AccessibilityManager::GetInstance()->OnAccessibilityScreenReaderIsActivated(IsScreenReaderActivated()); + } } bool @@ -69,13 +75,14 @@ _AccessibilitySystemSettingLoader::GetLargeFontSize(void) return -1; } -String -_AccessibilitySystemSettingLoader::GetLocaleString(void) +Locale +_AccessibilitySystemSettingLoader::GetLocale(void) { - String countryCode = L""; - result r = _SettingInfoImpl::GetValue(L"http://tizen.org/setting/locale.country", countryCode); - SysTryReturn(NID_UI, r == E_SUCCESS,L"", E_SYSTEM,"System error was occured."); - return countryCode; + Locale locale(LANGUAGE_INVALID, COUNTRY_INVALID); + LocaleManager localeMgr; + localeMgr.Construct(); + locale = localeMgr.GetSystemLocale(); + return locale; } void diff --git a/src/ui/FUi_AccessibilityTtsPlayer.cpp b/src/ui/FUi_AccessibilityTtsPlayer.cpp index 1167e3b..154b0be 100644 --- a/src/ui/FUi_AccessibilityTtsPlayer.cpp +++ b/src/ui/FUi_AccessibilityTtsPlayer.cpp @@ -15,223 +15,535 @@ // limitations under the License. // -#include -#include +#include +#include #include -#include -#include +#include +#include +#include #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(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 (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(pLocaleList)->Add(*pLocale); + if (IsFailed(r)) + { + static_cast(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(__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(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; } - }} diff --git a/src/ui/controls/FUiCtrl_Toolbar.cpp b/src/ui/controls/FUiCtrl_Toolbar.cpp index 12b6ba0..7c72b42 100644 --- a/src/ui/controls/FUiCtrl_Toolbar.cpp +++ b/src/ui/controls/FUiCtrl_Toolbar.cpp @@ -2758,8 +2758,8 @@ _Toolbar::AddAccessibilityElement(ToolbarButton position, _Button* pButton) { pButtonElement->SetTrait(L"Button"); } - - pButtonElement->SetBounds(GetButtonBoundsF(position)); + FloatRectangle floatRect = GetButtonBoundsF(position); + pButtonElement->SetBounds(FloatRectangle(0,floatRect.y, pButton->GetBoundsF().width, floatRect.height)); } } diff --git a/src/ui/inc/FUi_AccessibilitySystemSettingLoader.h b/src/ui/inc/FUi_AccessibilitySystemSettingLoader.h index 4a7fae4..86c4b4e 100644 --- a/src/ui/inc/FUi_AccessibilitySystemSettingLoader.h +++ b/src/ui/inc/FUi_AccessibilitySystemSettingLoader.h @@ -31,6 +31,11 @@ namespace Tizen { namespace Base class String; }} //Tizen::Base +namespace Tizen { namespace Locales +{ +class Locale; +}} //Tizen::Locales + namespace Tizen { namespace Ui { class _AccessibilityManager; @@ -45,7 +50,7 @@ public: bool IsAccessibilityActivated(void); bool IsScreenReaderActivated(void); float GetLargeFontSize(void); - Tizen::Base::String GetLocaleString(void); + Tizen::Locales::Locale GetLocale(void); static void SetSystemSetting(const Tizen::Base::String key, bool value); diff --git a/src/ui/inc/FUi_AccessibilityTtsPlayer.h b/src/ui/inc/FUi_AccessibilityTtsPlayer.h index 3b93185..3ee3f20 100644 --- a/src/ui/inc/FUi_AccessibilityTtsPlayer.h +++ b/src/ui/inc/FUi_AccessibilityTtsPlayer.h @@ -25,71 +25,75 @@ #ifndef _FUI_INTERNAL_ACCESSIBILITY_TTS_PLAYER_H_ #define _FUI_INTERNAL_ACCESSIBILITY_TTS_PLAYER_H_ +#include #include -#include -#include #include -#include namespace Tizen { namespace Base { class String; -}} //namespace Tizen::Base - +}} namespace Tizen { namespace Locales { class Locale; -}} //namespace Tizen::Locales - -namespace Tizen { namespace Uix { namespace Speech -{ -class TextToSpeech; -}}} //Tizen::Uix::Speech - +}} namespace Tizen { namespace Ui { class _AccessibilityManager; class _AccessibilityTtsPlayer - :public Tizen::Uix::Speech::ITextToSpeechEventListener { public: + _AccessibilityTtsPlayer(_AccessibilityManager& manager); virtual ~_AccessibilityTtsPlayer(void); - result ReadGrammar(const Tizen::Base::String& grammar, bool bInit = true); + result Construct(void); + result ReadGrammar(const Tizen::Base::String& grammar, bool init = true); result StopReading(void); AccessibilityScreenReaderStatus GetStatus(void); Tizen::Base::String GetCurrentGrammar(void); - void SetMode(_AccessibilityTtsMode mode); - void ApplyLocale(void); - void SetLocale(const Tizen::Base::String& localeString); -private: - _AccessibilityTtsPlayer(_AccessibilityManager& manager); + + void OnStatusChanged(AccessibilityScreenReaderStatus status); + void OnErrorOccurred(Tizen::Base::String& errorString); result Activate(void); result Deactivate(void); - - virtual void OnTextToSpeechInitialized(void); - virtual void OnTextToSpeechErrorOccurred (Tizen::Uix::Speech::TextToSpeechError error); - virtual void OnTextToSpeechStatusChanged (Tizen::Uix::Speech::TextToSpeechStatus status); - virtual void OnTextToSpeechCompleted(void); + result SetLocale(const Tizen::Locales::Locale& locale); +private: void SetStatus(AccessibilityScreenReaderStatus status); - Tizen::Locales::Locale GetCurrentLocale(void); + + static const char* GetEngineStateMessage(const tts_state_e state); + static const char* GetEngineErrorMessage(const int errorType); + static void TtsStateChangedReceiver(tts_h ttsHandle, tts_state_e previousState, tts_state_e currentState, void* pTtsInstance); + static void TtsStartedReceiver(tts_h ttsHandle, int utteranceId, void* pListener); + static void TtsCompletedReceiver(tts_h ttsHandle, int utteranceId, void* pTtsInstance); + static void TtsErrorReceiver(tts_h ttsHandle, int ttsUtteranceId, tts_error_e error, void* pTtsInstance); + static bool TtsSupportedLocaleListGetter(tts_h ttsHandle, const char* pLanguage, tts_voice_type_e voiceType, void* pLocaleList); + static const char* ConvertTizenLocaleToEngineN(const Tizen::Locales::Locale& locale); + static const Tizen::Locales::Locale* ConvertEngineLocaleToNativeN(const Tizen::Base::String& strSource); + result Speak(const Tizen::Base::String& text); + result Stop(void); + result Pause(void); + result Resume(void); + Tizen::Locales::Locale GetLocale(void) const; + const Tizen::Base::Collection::IList* GetSupportedLocales(void) const; + bool IsLocaleSupported(const Tizen::Locales::Locale& locale) const; + result SetSpeechRate(tts_speed_e speechRate); private: _AccessibilityTtsPlayer(const _AccessibilityTtsPlayer& rhs); _AccessibilityTtsPlayer& operator =(const _AccessibilityTtsPlayer& rhs); - + private: - void* __handle; - Tizen::Uix::Speech::TextToSpeech* __pTts; - Tizen::Base::String __grammar; - Tizen::Base::String __localeString; + bool __initialized; + tts_h __ttsHandle; + int __localeIdx; + tts_speed_e __speed; AccessibilityScreenReaderStatus __status; - Tizen::Uix::Speech::TextToSpeechRequestMode __ttsRequestMode; + Tizen::Base::String __grammar; + Tizen::Locales::Locale* __pCurrentLocale; + Tizen::Base::Collection::IList* __pSupportedLocaleList; _AccessibilityManager* __pManager; - friend class _AccessibilityManager; }; //class _AccessibilityTtsPlayer }} //Tizen::Ui #endif //_FUI_INTERNAL_ACCESSIBILITY_TTS_PLAYER_H_ - diff --git a/src/uifw/CMakeLists.txt b/src/uifw/CMakeLists.txt index 0c8a0da..02865d6 100644 --- a/src/uifw/CMakeLists.txt +++ b/src/uifw/CMakeLists.txt @@ -54,7 +54,6 @@ SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined - TARGET_LINK_LIBRARIES( ${this_target} ${STATIC_LIBS}) TARGET_LINK_LIBRARIES(${this_target} "-L/usr/lib/osp -losp-appfw" ) TARGET_LINK_LIBRARIES(${this_target} "-losp-image-core" ) -TARGET_LINK_LIBRARIES(${this_target} "-losp-speech-tts" ) TARGET_LINK_LIBRARIES(${this_target} "-lcapi-appfw-application" ) TARGET_LINK_LIBRARIES(${this_target} "-lappcore-common" ) TARGET_LINK_LIBRARIES(${this_target} "-lappcore-efl" ) -- 2.7.4