src/stt/FUixSpeech_SpeechToTextImpl.cpp

   1 //\r
   2 // Open Service Platform\r
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.\r
   4 //\r
   5 // Licensed under the Apache License, Version 2.0 (the License);\r
   6 // you may not use this file except in compliance with the License.\r
   7 // You may obtain a copy of the License at\r
   8 //\r
   9 //     http://www.apache.org/licenses/LICENSE-2.0\r
  10 //\r
  11 // Unless required by applicable law or agreed to in writing, software\r
  12 // distributed under the License is distributed on an "AS IS" BASIS,\r
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14 // See the License for the specific language governing permissions and\r
  15 // limitations under the License.\r
  16 //\r
  17 \r
  18 /**\r
  19  * @file    FUixSpeech_SpeechToTextImpl.cpp\r
  20  * @brief   This is the implementation file for the _SpeechToTextImpl class.\r
  21  *\r
  22  * This files contains implementation of the _SpeechToTextImpl class.\r
  23  */\r
  24 \r
  25 #include <new>\r
  26 #include <FBaseColIList.h>\r
  27 #include <FBaseColArrayList.h>\r
  28 #include <FBaseString.h>\r
  29 #include <FBaseUtilStringTokenizer.h>\r
  30 #include <FLclLocale.h>\r
  31 #include <FUixSpeechSpeechToText.h>\r
  32 #include <FBaseSysLog.h>\r
  33 #include <FBase_StringConverter.h>\r
  34 #include <FUixSpeech_SpeechToTextImpl.h>\r
  35 \r
  36 using namespace Tizen::Base;\r
  37 using namespace Tizen::Base::Collection;\r
  38 using namespace Tizen::Locales;\r
  39 \r
  40 namespace Tizen { namespace Uix { namespace Speech\r
  41 {\r
  42 \r
  43 void\r
  44 _SpeechToTextImpl::SttResultReceiver(stt_h sttHandle, const char* type, const char* data[], int dataCount, const char* msg, void* pListener)\r
  45 {\r
  46     String userSpeech;\r
  47     userSpeech.Clear();\r
  48 \r
  49     if (dataCount == 0)\r
  50     {\r
  51         userSpeech.Append(msg);\r
  52     }\r
  53     else\r
  54     {\r
  55         for (int i = 0; i < dataCount; i++)\r
  56         {\r
  57             userSpeech.Append(data[i]);\r
  58         }\r
  59     }\r
  60     static_cast < ISpeechToTextEventListener* >(pListener)->OnSpeechToTextCompleted(userSpeech);\r
  61 }\r
  62 \r
  63 void\r
  64 _SpeechToTextImpl::SttPartialResultReceiver(stt_h sttHandle, const char* data, void* pListener)\r
  65 {\r
  66 }\r
  67 \r
  68 void\r
  69 _SpeechToTextImpl::SttStateChangedReceiver(stt_h sttHandle, stt_state_e previousState, stt_state_e currentState, void* pSttInstance)\r
  70 {\r
  71     SysLog(NID_UIX_SPEECH, "The current state is changed to '%s' from '%s'.",\r
  72             GetEngineStateMessage(currentState), GetEngineStateMessage(previousState));\r
  73 \r
  74     _SpeechToTextImpl* pInstance = static_cast<_SpeechToTextImpl*>(pSttInstance);\r
  75     ISpeechToTextEventListener* pListener = pInstance->__pSpeechToTextListener;\r
  76 \r
  77     // Start()\r
  78     if ((previousState == STT_STATE_READY) && (currentState == STT_STATE_RECORDING))\r
  79     {\r
  80         pInstance->__currentStatus = SPEECH_TO_TEXT_STATUS_RECORDING;\r
  81         pListener->OnSpeechToTextStatusChanged(SPEECH_TO_TEXT_STATUS_RECORDING);\r
  82     }\r
  83     // Cancel()\r
  84     else if ((previousState == STT_STATE_RECORDING || previousState == STT_STATE_PROCESSING)\r
  85             && (currentState == STT_STATE_READY))\r
  86     {\r
  87         pInstance->__currentStatus = SPEECH_TO_TEXT_STATUS_READY;\r
  88         pListener->OnSpeechToTextStatusChanged(SPEECH_TO_TEXT_STATUS_READY);\r
  89     }\r
  90     // Stop()\r
  91     else if ((previousState == STT_STATE_RECORDING) && (currentState == STT_STATE_PROCESSING))\r
  92     {\r
  93         pInstance->__currentStatus = SPEECH_TO_TEXT_STATUS_PROCESSING;\r
  94         pListener->OnSpeechToTextStatusChanged(SPEECH_TO_TEXT_STATUS_PROCESSING);\r
  95     }\r
  96     else if ((previousState == STT_STATE_CREATED) && (currentState == STT_STATE_READY))\r
  97     {\r
  98         char *pDefaultLang = null;\r
  99 \r
 100         int ttsError = stt_get_default_language(sttHandle, &pDefaultLang);\r
 101         if (ttsError == STT_ERROR_NONE)\r
 102         {\r
 103             SysLog(NID_UIX_SPEECH, "The default language is '%s'.", pDefaultLang);\r
 104             const Locale* pDefaultLocale = ConvertEngineLocaleToOspN(pDefaultLang);\r
 105             *pInstance->__pCurrentLocale = *pDefaultLocale;\r
 106 \r
 107             delete pDefaultLocale;\r
 108             free(pDefaultLang);\r
 109         }\r
 110 \r
 111         int sttError = stt_foreach_supported_languages(sttHandle, SttSupportedLocaleListGetter, (void *)pInstance->__pSupportedLocaleList);\r
 112         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to get supported voices", GetEngineErrorMessage(sttError));\r
 113 \r
 114         pInstance->__isInitialized = true;\r
 115         pInstance->__currentStatus = SPEECH_TO_TEXT_STATUS_READY;\r
 116 \r
 117         pListener->OnSpeechToTextInitialized();\r
 118         pListener->OnSpeechToTextStatusChanged(SPEECH_TO_TEXT_STATUS_READY);\r
 119     }\r
 120     else\r
 121     {\r
 122         SysLog(NID_UIX_SPEECH, "The unknown state is changed to '%s' from '%s'.",\r
 123                         GetEngineStateMessage(currentState), GetEngineStateMessage(previousState));\r
 124     }\r
 125 }\r
 126 \r
 127 void\r
 128 _SpeechToTextImpl::SttErrorReceiver(stt_h sttHandle, stt_error_e error, void* pListener)\r
 129 {\r
 130         SysLog(NID_UIX_SPEECH, "[%s] Error occurred.", GetEngineErrorMessage(error));\r
 131 \r
 132     SpeechToTextError sttError;\r
 133 \r
 134     switch (error)\r
 135     {\r
 136     case STT_ERROR_OUT_OF_NETWORK:\r
 137         sttError = SPEECH_TO_TEXT_ERROR_NETWORK_ERROR;\r
 138         break;\r
 139     case STT_ERROR_OUT_OF_MEMORY:\r
 140         sttError = SPEECH_TO_TEXT_ERROR_OUT_OF_MEMORY;\r
 141         break;\r
 142     case STT_ERROR_IO_ERROR:\r
 143         sttError = SPEECH_TO_TEXT_ERROR_IO_ERROR;\r
 144         break;\r
 145     case STT_ERROR_ENGINE_NOT_FOUND:\r
 146         sttError = SPEECH_TO_TEXT_ERROR_UNSUPPORTED_SERVICE;\r
 147         break;\r
 148     case STT_ERROR_TIMED_OUT:\r
 149         sttError = SPEECH_TO_TEXT_ERROR_TIME_OUT;\r
 150         break;\r
 151     default:\r
 152         sttError = SPEECH_TO_TEXT_ERROR_SYSTEM_ERROR;\r
 153         break;\r
 154     }\r
 155     static_cast <ISpeechToTextEventListener*>(pListener)->OnSpeechToTextErrorOccurred(sttError);\r
 156 }\r
 157 \r
 158 bool\r
 159 _SpeechToTextImpl::SttSupportedLocaleListGetter(stt_h sttHandle, const char* pLanguage, void* pLocaleList)\r
 160 {\r
 161     SysLog(NID_UIX_SPEECH, "The language is '%s'.", pLanguage);\r
 162 \r
 163     const Locale* pLocale = ConvertEngineLocaleToOspN(String(pLanguage));\r
 164     if (pLocale == null)\r
 165     {\r
 166         static_cast<ArrayList*>(pLocaleList)->RemoveAll(true);\r
 167         return false;   // escape call back loop\r
 168     }\r
 169 \r
 170     if (pLocale->GetLanguageCode() == LANGUAGE_INVALID)\r
 171     {\r
 172         SysLog(NID_UIX_SPEECH, "The '%s' language is not supported.", pLanguage);\r
 173         delete pLocale;\r
 174     }\r
 175     else\r
 176     {\r
 177         result r = static_cast<ArrayList*>(pLocaleList)->Add(*pLocale);\r
 178         if (IsFailed(r))\r
 179         {\r
 180             static_cast<ArrayList*>(pLocaleList)->RemoveAll(true);\r
 181             return false;   // escape call back loop\r
 182         }\r
 183     }\r
 184 \r
 185     return true;        // continue call back loop\r
 186 }\r
 187 \r
 188 _SpeechToTextImpl::_SpeechToTextImpl(void)\r
 189     : __sttHandle(null)\r
 190     , __pSpeechToTextListener(null)\r
 191     , __pCurrentLocale(null)\r
 192     , __grammar(SPEECH_TO_TEXT_GRAMMAR_FREE)\r
 193     , __pSupportedLocaleList(null)\r
 194     , __isInitialized(false)\r
 195     , __isSilenceDetection(true)\r
 196 {\r
 197 \r
 198 }\r
 199 \r
 200 _SpeechToTextImpl::~_SpeechToTextImpl(void)\r
 201 {\r
 202     stt_state_e sttState = STT_STATE_READY;\r
 203     int sttError = stt_get_state(__sttHandle, &sttState);\r
 204     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to get the current state.", GetEngineErrorMessage(sttError));\r
 205 \r
 206     if (sttState == STT_STATE_RECORDING || sttState == STT_STATE_PROCESSING)\r
 207     {\r
 208         sttError = stt_stop(__sttHandle);\r
 209         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to stop.", GetEngineErrorMessage(sttError));\r
 210     }\r
 211 \r
 212     if (__isInitialized)\r
 213     {\r
 214         sttError = stt_unprepare(__sttHandle);\r
 215         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to unprepare.", GetEngineErrorMessage(sttError));\r
 216 \r
 217         sttError = stt_unset_result_cb(__sttHandle);\r
 218         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to unset the result callback.", GetEngineErrorMessage(sttError));\r
 219 \r
 220         sttError = stt_unset_partial_result_cb(__sttHandle);\r
 221         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to unset the partial result callback.", GetEngineErrorMessage(sttError));\r
 222 \r
 223         sttError = stt_unset_state_changed_cb(__sttHandle);\r
 224         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to unset the state changed callback.", GetEngineErrorMessage(sttError));\r
 225 \r
 226         sttError = stt_unset_error_cb(__sttHandle);\r
 227         SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to unset the error callback.", GetEngineErrorMessage(sttError));\r
 228     }\r
 229 \r
 230     sttError = stt_destroy(__sttHandle);\r
 231     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to destroy.", GetEngineErrorMessage(sttError));\r
 232 \r
 233     delete __pCurrentLocale;\r
 234 \r
 235     if (__pSupportedLocaleList != null)\r
 236     {\r
 237         __pSupportedLocaleList->RemoveAll(true);\r
 238         delete __pSupportedLocaleList;\r
 239     }\r
 240 }\r
 241 \r
 242 result\r
 243 _SpeechToTextImpl::Construct(ISpeechToTextEventListener& listener)\r
 244 {\r
 245     int sttError = stt_create(&__sttHandle);\r
 246     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to create", GetEngineErrorMessage(sttError));\r
 247     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to create.");\r
 248 \r
 249     Locale *pLocale = new (std::nothrow) Locale(LANGUAGE_INVALID, COUNTRY_INVALID);\r
 250     SysTryReturnResult(NID_UIX_SPEECH, pLocale != null, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 251 \r
 252     ArrayList* pLocaleList = new (std::nothrow) ArrayList();\r
 253     SysTryReturnResult(NID_UIX_SPEECH, pLocaleList != null, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 254 \r
 255     result r = pLocaleList->Construct();\r
 256     SysTryReturnResult(NID_UIX_SPEECH, r == E_SUCCESS, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 257 \r
 258     __pCurrentLocale = pLocale;\r
 259     __pSupportedLocaleList = pLocaleList;\r
 260     __pSpeechToTextListener = &listener;\r
 261 \r
 262     return E_SUCCESS;\r
 263 }\r
 264 \r
 265 result\r
 266 _SpeechToTextImpl::Initialize(void)\r
 267 {\r
 268     SysAssertf(__isInitialized != true,\r
 269                 "Already calling Initialize() twice or more on a same instance is not allowed for this class.");\r
 270 \r
 271     int sttError = stt_set_error_cb(__sttHandle, SttErrorReceiver, __pSpeechToTextListener);\r
 272     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to set the error callback.", GetEngineErrorMessage(sttError));\r
 273     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 274 \r
 275     sttError = stt_set_state_changed_cb(__sttHandle, SttStateChangedReceiver, this);\r
 276     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE,  "[%s] Failed to set the state changed callback.", GetEngineErrorMessage(sttError));\r
 277     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 278 \r
 279     sttError = stt_set_partial_result_cb(__sttHandle, SttPartialResultReceiver, __pSpeechToTextListener);\r
 280     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to set the partial result callback.", GetEngineErrorMessage(sttError));\r
 281     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 282 \r
 283     sttError = stt_set_result_cb(__sttHandle, SttResultReceiver, __pSpeechToTextListener);\r
 284     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to set the result callback.", GetEngineErrorMessage(sttError));\r
 285     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 286 \r
 287     sttError = stt_prepare(__sttHandle);\r
 288     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to prepare.", GetEngineErrorMessage(sttError));\r
 289     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 290 \r
 291     return E_SUCCESS;\r
 292 }\r
 293 \r
 294 result\r
 295 _SpeechToTextImpl::Start(void)\r
 296 {\r
 297     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 298                 "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 299 \r
 300     stt_state_e sttState = STT_STATE_READY;\r
 301     const char* sttRecognitionType = null;\r
 302     const char* pSttRecognitionLanguageN = null;\r
 303 \r
 304     int sttError = stt_get_state(__sttHandle, &sttState);\r
 305     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] The current state is '%s'.",\r
 306                 GetEngineErrorMessage(sttError), GetEngineStateMessage(sttState));\r
 307 \r
 308     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");\r
 309     SysTryReturnResult(NID_UIX_SPEECH, sttState == STT_STATE_READY, E_INVALID_OPERATION, "The TTS state should be SPEECH_TO_TEXT_STATUS_READY.");\r
 310 \r
 311 \r
 312     sttRecognitionType = ConvertOspRecognitionTypeToEngine(__grammar);\r
 313     pSttRecognitionLanguageN = ConvertOspLocaleToEngineN(*__pCurrentLocale);\r
 314     SysTryReturnResult(NID_UIX_SPEECH, pSttRecognitionLanguageN != null, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 315 \r
 316     sttError = stt_start(__sttHandle, pSttRecognitionLanguageN, sttRecognitionType);\r
 317     SysTryReturnResult(NID_UIX_SPEECH, sttError != STT_ERROR_RECORDER_BUSY, E_SERVICE_BUSY, "The recorder is busy.");\r
 318     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to start.");\r
 319 \r
 320     delete[] pSttRecognitionLanguageN;\r
 321 \r
 322     return E_SUCCESS;\r
 323 }\r
 324 \r
 325 result\r
 326 _SpeechToTextImpl::Stop(void)\r
 327 {\r
 328     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 329                 "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 330 \r
 331     stt_state_e sttState = STT_STATE_READY;\r
 332 \r
 333     int sttError = stt_get_state(__sttHandle, &sttState);\r
 334     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");\r
 335 \r
 336     SysTryReturnResult(NID_UIX_SPEECH, sttState == STT_STATE_RECORDING, E_INVALID_OPERATION,\r
 337             "The STT state should be SPEECH_TO_TEXT_STATUS_RECORDING.");\r
 338 \r
 339     sttError = stt_stop(__sttHandle);\r
 340     SysTryReturnResult(NID_UIX_SPEECH, sttError != STT_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "The memory is insufficient.");\r
 341     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to stop.");\r
 342 \r
 343     return E_SUCCESS;\r
 344 }\r
 345 \r
 346 result\r
 347 _SpeechToTextImpl::Cancel(void)\r
 348 {\r
 349     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 350                 "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 351 \r
 352     stt_state_e sttState = STT_STATE_READY;\r
 353 \r
 354     int sttError = stt_get_state(__sttHandle, &sttState);\r
 355     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "Failed to get the current state.");\r
 356 \r
 357     SysTryReturnResult(NID_UIX_SPEECH, sttState != STT_STATE_READY, E_INVALID_OPERATION,\r
 358             "The STT state should be SPEECH_TO_TEXT_STATUS_RECORDING or SPEECH_TO_TEXT_STATUS_PROCESSING.");\r
 359 \r
 360     sttError = stt_cancel(__sttHandle);\r
 361     SysTryReturnResult(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, E_SYSTEM, "[E_SYSTEM] Failed to cancel.");\r
 362 \r
 363     return E_SUCCESS;\r
 364 }\r
 365 \r
 366 bool\r
 367 _SpeechToTextImpl::IsLocaleSupported(const Locale& locale) const\r
 368 {\r
 369         SysTryReturn(NID_UIX_SPEECH, __isInitialized, false, E_INVALID_STATE,\r
 370             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 371 \r
 372     SetLastResult(E_SUCCESS);\r
 373     return __pSupportedLocaleList->Contains(locale);\r
 374 }\r
 375 \r
 376 result\r
 377 _SpeechToTextImpl::SetLocale(const Locale& locale)\r
 378 {\r
 379     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 380             "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 381 \r
 382     SysTryReturnResult(NID_UIX_SPEECH, IsLocaleSupported(locale), E_UNSUPPORTED_LOCALE, "This locale is not supported.")\r
 383 \r
 384     *__pCurrentLocale = locale;\r
 385 \r
 386     return E_SUCCESS;\r
 387 }\r
 388 \r
 389 Tizen::Locales::Locale\r
 390 _SpeechToTextImpl::GetLocale(void) const\r
 391 {\r
 392         SysTryReturn(NID_UIX_SPEECH, __isInitialized, Locale(LANGUAGE_INVALID, COUNTRY_INVALID), E_INVALID_STATE,\r
 393             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 394 \r
 395     SetLastResult(E_SUCCESS);\r
 396     return *__pCurrentLocale;\r
 397 }\r
 398 \r
 399 const IList*\r
 400 _SpeechToTextImpl::GetSupportedLocales(void) const\r
 401 {\r
 402         SysTryReturn(NID_UIX_SPEECH, __isInitialized, null, E_INVALID_STATE,\r
 403             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 404 \r
 405     SetLastResult(E_SUCCESS);\r
 406     return __pSupportedLocaleList;\r
 407 }\r
 408 \r
 409 result\r
 410 _SpeechToTextImpl::SetGrammar(SpeechToTextGrammar grammar)\r
 411 {\r
 412     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 413             "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 414 \r
 415     __grammar = grammar;\r
 416 \r
 417     return E_SUCCESS;\r
 418 }\r
 419 \r
 420 SpeechToTextGrammar\r
 421 _SpeechToTextImpl::GetGrammar(void) const\r
 422 {\r
 423         SysTryReturn(NID_UIX_SPEECH, __isInitialized, SPEECH_TO_TEXT_GRAMMAR_FREE, E_INVALID_STATE,\r
 424             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 425 \r
 426     SetLastResult(E_SUCCESS);\r
 427 \r
 428     return __grammar;\r
 429 }\r
 430 \r
 431 result\r
 432 _SpeechToTextImpl::SetSilenceDetectionEnabled(bool enable)\r
 433 {\r
 434     SysTryReturnResult(NID_UIX_SPEECH, __isInitialized, E_INVALID_STATE,\r
 435             "Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 436 \r
 437     int sttError = stt_set_silence_detection(__sttHandle, ConvertOspSilenceDetectionTypeToEngine(enable));\r
 438     SysTryLog(NID_UIX_SPEECH, sttError == STT_ERROR_NONE, "[%s] Failed to set the silence detection.", GetEngineErrorMessage(sttError));\r
 439 \r
 440     __isSilenceDetection = enable;\r
 441 \r
 442     return E_SUCCESS;\r
 443 }\r
 444 \r
 445 bool\r
 446 _SpeechToTextImpl::IsSilenceDetectionEnabled(void) const\r
 447 {\r
 448         SysTryReturn(NID_UIX_SPEECH, __isInitialized, false, E_INVALID_STATE,\r
 449             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 450 \r
 451     SetLastResult(E_SUCCESS);\r
 452     return __isSilenceDetection;\r
 453 }\r
 454 \r
 455 SpeechToTextStatus\r
 456 _SpeechToTextImpl::GetCurrentStatus(void) const\r
 457 {\r
 458         SysTryReturn(NID_UIX_SPEECH, __isInitialized, SPEECH_TO_TEXT_STATUS_NONE, E_INVALID_STATE,\r
 459             "[E_INVALID_STATE] Not yet initialized! This method should be called after receiving OnSpeechToTextInitialized() event.");\r
 460 \r
 461     SetLastResult(E_SUCCESS);\r
 462     return __currentStatus;\r
 463 }\r
 464 \r
 465 _SpeechToTextImpl*\r
 466 _SpeechToTextImpl::GetInstance(SpeechToText& speechToText)\r
 467 {\r
 468     return speechToText.__pSpeechToTextImpl;\r
 469 }\r
 470 \r
 471 const _SpeechToTextImpl*\r
 472 _SpeechToTextImpl::GetInstance(const SpeechToText& speechToText)\r
 473 {\r
 474     return speechToText.__pSpeechToTextImpl;\r
 475 }\r
 476 \r
 477 const char*\r
 478 _SpeechToTextImpl::ConvertOspRecognitionTypeToEngine(SpeechToTextGrammar grammar)\r
 479 {\r
 480     switch (grammar)\r
 481     {\r
 482     case SPEECH_TO_TEXT_GRAMMAR_FREE:\r
 483         return STT_RECOGNITION_TYPE_FREE;\r
 484 \r
 485     case SPEECH_TO_TEXT_GRAMMAR_WEB_SEARCH:\r
 486         return STT_RECOGNITION_TYPE_WEB_SEARCH;\r
 487 \r
 488     default:\r
 489         return null;\r
 490     }\r
 491 }\r
 492 \r
 493 stt_option_silence_detection_e\r
 494 _SpeechToTextImpl::ConvertOspSilenceDetectionTypeToEngine(bool silenceDetectionType)\r
 495 {\r
 496     if (silenceDetectionType)\r
 497     {\r
 498         return STT_OPTION_SILENCE_DETECTION_TRUE;\r
 499     }\r
 500     else\r
 501     {\r
 502         return STT_OPTION_SILENCE_DETECTION_FALSE;\r
 503     }\r
 504 }\r
 505 \r
 506 const char*\r
 507 _SpeechToTextImpl::ConvertOspLocaleToEngineN(const Locale& locale)\r
 508 {\r
 509     String strLanguageCode = Locale::LanguageCodeToTwoLetterLanguageCodeString(locale.GetLanguageCode());\r
 510     String strCountryCode = Locale::CountryCodeToString(locale.GetCountryCode());\r
 511 \r
 512     String strLanguage = strLanguageCode + L"_" + strCountryCode;\r
 513 \r
 514     return _StringConverter::CopyToCharArrayN(strLanguage);\r
 515 }\r
 516 \r
 517 const Tizen::Locales::Locale*\r
 518 _SpeechToTextImpl::ConvertEngineLocaleToOspN(const String& strSource)\r
 519 {\r
 520     String strDelim(L"_");\r
 521     String strLanguageCode;\r
 522     String strCountryCode;\r
 523 \r
 524     LanguageCode languageCode = LANGUAGE_INVALID;\r
 525     CountryCode countryCode = COUNTRY_INVALID;\r
 526 \r
 527     Utility::StringTokenizer toknizer(strSource, strDelim);\r
 528     if (toknizer.GetTokenCount() == 2)\r
 529     {\r
 530         toknizer.GetNextToken(strLanguageCode);\r
 531         toknizer.GetNextToken(strCountryCode);\r
 532 \r
 533         languageCode = Locale::TwoLetterLanguageCodeStringToLanguageCode(strLanguageCode);\r
 534         countryCode = Locale::StringToCountryCode(strCountryCode);\r
 535     }\r
 536 \r
 537     return new (std::nothrow) Locale(languageCode, countryCode);\r
 538 }\r
 539 \r
 540 const char*\r
 541 _SpeechToTextImpl::GetEngineErrorMessage(int error)\r
 542 {\r
 543     switch (error)\r
 544     {\r
 545     case STT_ERROR_NONE:\r
 546         return "STT_ERROR_NONE";\r
 547 \r
 548     case STT_ERROR_OUT_OF_MEMORY:\r
 549         return "STT_ERROR_OUT_OF_MEMORY";\r
 550 \r
 551     case STT_ERROR_IO_ERROR:\r
 552         return "STT_ERROR_IO_ERROR";\r
 553 \r
 554     case STT_ERROR_INVALID_PARAMETER:\r
 555         return "STT_ERROR_INVALID_PARAMETER";\r
 556 \r
 557     case STT_ERROR_INVALID_STATE:\r
 558         return "STT_ERROR_INVALID_STATE";\r
 559 \r
 560     case STT_ERROR_INVALID_LANGUAGE:\r
 561         return "STT_ERROR_INVALID_LANGUAGE";\r
 562 \r
 563     case STT_ERROR_ENGINE_NOT_FOUND:\r
 564         return "STT_ERROR_ENGINE_NOT_FOUND";\r
 565 \r
 566     case STT_ERROR_TIMED_OUT:\r
 567         return "STT_ERROR_TIMED_OUT";\r
 568 \r
 569     case STT_ERROR_OPERATION_FAILED:\r
 570         return "STT_ERROR_OPERATION_FAILED";\r
 571 \r
 572     case STT_ERROR_RECORDER_BUSY:\r
 573         return "STT_ERROR_RECORDER_BUSY";\r
 574 \r
 575     case STT_ERROR_OUT_OF_NETWORK:\r
 576         return "STT_ERROR_OUT_OF_NETWORK";\r
 577 \r
 578     default:\r
 579         return "STT_ERROR_UNKNOWN";\r
 580     }\r
 581 }\r
 582 \r
 583 const char*\r
 584 _SpeechToTextImpl::GetEngineStateMessage(stt_state_e state)\r
 585 {\r
 586     switch (state)\r
 587     {\r
 588     case STT_STATE_CREATED:\r
 589         return "STT_STATE_CREATED";\r
 590 \r
 591     case STT_STATE_READY:\r
 592         return "STT_STATE_READY";\r
 593 \r
 594     case STT_STATE_RECORDING:\r
 595         return "STT_STATE_RECORDING";\r
 596 \r
 597     case STT_STATE_PROCESSING:\r
 598         return "STT_STATE_PROCESSING";\r
 599 \r
 600     default:\r
 601         return "STT_STATE_UNKNOWN";\r
 602     }\r
 603 }\r
 604 \r
 605 } } } // Tizen::Uix::Speech\r