2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
14 #include <app_manager.h>
19 #include <sys/types.h>
21 #include <system_info.h>
25 #include "tts_client.h"
26 #include "tts_config_mgr.h"
30 #include "tts_internal.h"
32 static bool g_screen_reader;
34 static int g_feature_enabled = -1;
36 static bool g_err_callback_status = false;
38 static int g_max_text_size = -1;
41 static char* g_language = NULL;
43 static int g_voice_type = -1;
45 static int g_speed = -1;
48 /* Function definition */
49 static Eina_Bool __tts_notify_state_changed(void *data);
50 static Eina_Bool __tts_notify_error(void *data);
57 static int __tts_get_feature_enabled()
59 if (0 == g_feature_enabled) {
60 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
61 return TTS_ERROR_NOT_SUPPORTED;
62 } else if (-1 == g_feature_enabled) {
63 bool tts_supported = false;
64 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
65 if (false == tts_supported) {
66 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
67 g_feature_enabled = 0;
68 return TTS_ERROR_NOT_SUPPORTED;
71 g_feature_enabled = 1;
73 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
74 return TTS_ERROR_NOT_SUPPORTED;
81 static const char* __tts_get_error_code(tts_error_e err)
84 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
85 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
86 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
87 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
88 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
89 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
90 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
91 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
92 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
93 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
94 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
95 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
96 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
97 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
98 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
100 return "Invalid error code";
105 static int __tts_convert_config_error_code(tts_config_error_e code)
107 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
108 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
109 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
110 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
111 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
112 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
113 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
114 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
115 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
120 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
122 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
123 before_lang, before_voice_type, language, voice_type);
125 GList* client_list = NULL;
126 client_list = tts_client_get_client_list();
129 tts_client_s *data = NULL;
131 if (g_list_length(client_list) > 0) {
132 /* Get a first item */
133 iter = g_list_first(client_list);
135 while (NULL != iter) {
137 if (NULL != data->default_voice_changed_cb) {
138 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
139 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
140 language, voice_type, data->default_voice_changed_user_data);
143 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
144 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
145 if (NULL != data->text_repeat) {
146 free(data->text_repeat);
147 data->text_repeat = NULL;
152 iter = g_list_next(iter);
159 static Eina_Bool __reconnect_by_engine_changed(void* data)
161 tts_h tts = (tts_h)data;
163 tts_client_s* client = tts_client_get(tts);
164 if (NULL == client) {
165 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
169 if (TTS_STATE_READY != client->current_state) {
174 int ret = tts_unprepare(tts);
176 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
178 ret = tts_prepare(tts);
180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
186 void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
188 tts_h tts = (tts_h)user_data;
190 tts_client_s* client = tts_client_get(tts);
191 if (NULL == client) {
192 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
196 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
197 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
198 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
199 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
201 /* When the default engine is changed, please unload the old engine and load the new one. */
204 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
207 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
210 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
211 } else if (TTS_STATE_READY == client->current_state) {
212 ret = tts_unprepare(tts);
214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
216 ret = tts_prepare(tts);
218 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
222 /* call callback function */
223 if (NULL != client->engine_changed_cb) {
224 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
226 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
231 int tts_create(tts_h* tts)
233 if (0 != __tts_get_feature_enabled()) {
234 return TTS_ERROR_NOT_SUPPORTED;
237 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
242 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
243 return TTS_ERROR_INVALID_PARAMETER;
246 if (0 == tts_client_get_size()) {
247 if (0 != tts_dbus_open_connection()) {
248 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
249 return TTS_ERROR_OPERATION_FAILED;
253 if (0 != tts_client_new(tts)) {
254 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
255 return TTS_ERROR_OUT_OF_MEMORY;
258 tts_client_s* client = tts_client_get(*tts);
259 if (NULL == client) {
260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
261 return TTS_ERROR_OPERATION_FAILED;
264 int ret = tts_config_mgr_initialize(client->uid);
266 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
267 tts_client_destroy(*tts);
268 return __tts_convert_config_error_code(ret);
271 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
273 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
274 tts_client_destroy(*tts);
275 return __tts_convert_config_error_code(ret);
278 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
279 SLOG(LOG_DEBUG, TAG_TTSC, " ");
281 return TTS_ERROR_NONE;
284 int tts_destroy(tts_h tts)
286 if (0 != __tts_get_feature_enabled()) {
287 return TTS_ERROR_NOT_SUPPORTED;
290 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
293 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
294 return TTS_ERROR_INVALID_PARAMETER;
297 tts_client_s* client = tts_client_get(tts);
300 if (NULL == client) {
301 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
302 return TTS_ERROR_INVALID_PARAMETER;
305 /* check used callback */
306 if (0 != tts_client_get_use_callback(client)) {
307 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
308 return TTS_ERROR_OPERATION_FAILED;
311 tts_config_mgr_finalize(client->uid);
315 int screen_reader = -1;
318 switch (client->current_state) {
319 case TTS_STATE_PAUSED:
320 case TTS_STATE_PLAYING:
321 case TTS_STATE_READY:
322 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
324 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
326 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
327 g_screen_reader = (bool)screen_reader;
329 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
331 ret = tts_dbus_request_finalize(client->uid);
333 if (TTS_ERROR_TIMED_OUT != ret) {
334 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
337 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
340 if (TTS_RETRY_COUNT == count) {
341 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
348 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
351 client->before_state = client->current_state;
352 client->current_state = TTS_STATE_CREATED;
354 case TTS_STATE_CREATED:
355 if (NULL != client->conn_timer) {
356 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
357 ecore_timer_del(client->conn_timer);
358 client->conn_timer = NULL;
361 tts_client_destroy(tts);
368 if (0 == tts_client_get_size()) {
369 if (0 != tts_dbus_close_connection()) {
370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
374 if (NULL != g_language) {
381 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
383 return TTS_ERROR_NONE;
386 void __tts_screen_reader_changed_cb(bool value)
388 g_screen_reader = value;
391 int tts_set_mode(tts_h tts, tts_mode_e mode)
393 if (0 != __tts_get_feature_enabled()) {
394 return TTS_ERROR_NOT_SUPPORTED;
397 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
399 tts_client_s* client = tts_client_get(tts);
402 if (NULL == client) {
403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
404 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
405 return TTS_ERROR_INVALID_PARAMETER;
409 if (client->current_state != TTS_STATE_CREATED) {
410 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
411 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
412 SLOG(LOG_DEBUG, TAG_TTSC, " ");
413 return TTS_ERROR_INVALID_STATE;
416 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
420 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
421 SLOG(LOG_DEBUG, TAG_TTSC, " ");
422 return TTS_ERROR_INVALID_PARAMETER;
425 if (TTS_MODE_SCREEN_READER == mode) {
428 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
430 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
431 return TTS_ERROR_OPERATION_FAILED;
433 g_screen_reader = (bool)screen_reader;
434 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
436 tts_config_unset_screen_reader_callback(client->uid);
439 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
441 return TTS_ERROR_NONE;
444 int tts_get_mode(tts_h tts, tts_mode_e* mode)
446 if (0 != __tts_get_feature_enabled()) {
447 return TTS_ERROR_NOT_SUPPORTED;
450 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
452 tts_client_s* client = tts_client_get(tts);
455 if (NULL == client) {
456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
457 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
458 SLOG(LOG_DEBUG, TAG_TTSC, " ");
459 return TTS_ERROR_INVALID_PARAMETER;
463 if (client->current_state != TTS_STATE_CREATED) {
464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
465 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
466 SLOG(LOG_DEBUG, TAG_TTSC, " ");
467 return TTS_ERROR_INVALID_STATE;
471 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
472 return TTS_ERROR_INVALID_PARAMETER;
475 *mode = client->mode;
477 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
478 SLOG(LOG_DEBUG, TAG_TTSC, " ");
480 return TTS_ERROR_NONE;
483 int tts_set_credential(tts_h tts, const char* credential)
485 if (0 != __tts_get_feature_enabled()) {
486 return TTS_ERROR_NOT_SUPPORTED;
489 if (NULL == tts || NULL == credential) {
490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
491 return TTS_ERROR_INVALID_PARAMETER;
494 tts_client_s* client = tts_client_get(tts);
496 if (NULL == client) {
497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
498 return TTS_ERROR_INVALID_PARAMETER;
501 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
503 return TTS_ERROR_INVALID_STATE;
506 if (NULL != client->credential) {
507 free(client->credential);
508 client->credential = NULL;
510 client->credential = strdup(credential);
512 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
514 return TTS_ERROR_NONE;
518 int tts_set_server_tts(tts_h tts, const char* credential)
520 if (0 != __tts_get_feature_enabled()) {
521 return TTS_ERROR_NOT_SUPPORTED;
525 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
526 return TTS_ERROR_INVALID_PARAMETER;
529 tts_client_s* client = tts_client_get(tts);
531 if (NULL == client) {
532 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
533 return TTS_ERROR_INVALID_PARAMETER;
536 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
537 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
538 return TTS_ERROR_INVALID_STATE;
541 if (NULL != client->credential) {
542 free(client->credential);
543 client->credential = NULL;
546 client->internal = true;
549 if (NULL != credential) {
550 key = strdup("EnableServerTTS");
551 client->credential = strdup(credential);
552 if (NULL == client->credential) {
553 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
558 return TTS_ERROR_OUT_OF_MEMORY;
561 key = strdup("DisableServerTTS");
565 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
566 return TTS_ERROR_OUT_OF_MEMORY;
571 int ret = app_manager_get_app_id(pid, &appid);
572 if (0 != ret || NULL == appid) {
573 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
580 return TTS_ERROR_OPERATION_FAILED;
583 ret = tts_set_private_data(tts, key, appid);
585 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
598 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
600 return TTS_ERROR_NONE;
604 static Eina_Bool __tts_connect_daemon(void *data)
606 tts_h tts = (tts_h)data;
607 tts_client_s* client = tts_client_get(tts);
610 if (NULL == client) {
611 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
616 if (0 != tts_dbus_request_hello(client->uid)) {
620 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
622 /* do request initialize */
624 bool credential_needed = false;
626 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
628 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
629 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
631 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
634 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
635 client->conn_timer = NULL;
638 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
639 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
641 client->reason = TTS_ERROR_PERMISSION_DENIED;
644 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
645 client->conn_timer = NULL;
648 } else if (TTS_ERROR_NONE != ret) {
649 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
653 /* success to connect tts-daemon */
654 client->credential_needed = credential_needed;
655 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
658 client->conn_timer = NULL;
660 client = tts_client_get(tts);
662 if (NULL == client) {
663 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
667 client->before_state = client->current_state;
668 client->current_state = TTS_STATE_READY;
670 if (NULL != client->state_changed_cb) {
671 tts_client_use_callback(client);
672 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
673 tts_client_not_use_callback(client);
675 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
678 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
683 int tts_prepare(tts_h tts)
685 if (0 != __tts_get_feature_enabled()) {
686 return TTS_ERROR_NOT_SUPPORTED;
689 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
691 tts_client_s* client = tts_client_get(tts);
694 if (NULL == client) {
695 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
696 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
697 return TTS_ERROR_INVALID_PARAMETER;
701 if (client->current_state != TTS_STATE_CREATED) {
702 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
703 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
704 return TTS_ERROR_INVALID_STATE;
707 ecore_thread_main_loop_begin();
708 client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
709 ecore_thread_main_loop_end();
711 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
713 return TTS_ERROR_NONE;
717 int tts_prepare_sync(tts_h tts)
719 if (0 != __tts_get_feature_enabled()) {
720 return TTS_ERROR_NOT_SUPPORTED;
723 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
725 tts_client_s* client = tts_client_get(tts);
728 if (NULL == client) {
729 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
730 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
731 return TTS_ERROR_INVALID_PARAMETER;
735 if (client->current_state != TTS_STATE_CREATED) {
736 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
737 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
738 return TTS_ERROR_INVALID_STATE;
742 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
746 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
748 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
749 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
750 return TTS_ERROR_OPERATION_FAILED;
753 return TTS_ERROR_NONE;
757 int tts_unprepare(tts_h tts)
759 if (0 != __tts_get_feature_enabled()) {
760 return TTS_ERROR_NOT_SUPPORTED;
763 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
765 tts_client_s* client = tts_client_get(tts);
768 if (NULL == client) {
769 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
770 return TTS_ERROR_INVALID_PARAMETER;
774 if (client->current_state != TTS_STATE_READY) {
775 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
776 return TTS_ERROR_INVALID_STATE;
781 int screen_reader = -1;
783 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
785 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
787 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
788 g_screen_reader = (bool)screen_reader;
791 bool is_prepared = false;
792 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
794 ret = tts_dbus_request_finalize(client->uid);
796 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
797 client->current_state = TTS_STATE_CREATED;
798 if (0 == tts_prepare_sync(tts)) {
800 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
802 } else if (TTS_ERROR_TIMED_OUT != ret) {
803 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
806 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
809 if (TTS_RETRY_COUNT == count) {
810 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
817 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
820 client->before_state = client->current_state;
821 client->current_state = TTS_STATE_CREATED;
823 if (NULL != client->state_changed_cb) {
824 tts_client_use_callback(client);
825 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
826 tts_client_not_use_callback(client);
827 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
830 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
832 return TTS_ERROR_NONE;
835 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
837 tts_h tts = (tts_h)user_data;
839 tts_client_s* client = tts_client_get(tts);
840 if (NULL == client) {
841 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
845 /* call callback function */
846 if (NULL != client->supported_voice_cb) {
847 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
849 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
855 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
857 if (0 != __tts_get_feature_enabled()) {
858 return TTS_ERROR_NOT_SUPPORTED;
861 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
863 if (NULL == tts || NULL == callback) {
864 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
865 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
866 return TTS_ERROR_INVALID_PARAMETER;
869 tts_client_s* client = tts_client_get(tts);
872 if (NULL == client) {
873 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
874 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
875 return TTS_ERROR_INVALID_PARAMETER;
879 char* current_engine = NULL;
880 ret = tts_config_mgr_get_engine(¤t_engine);
882 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
883 return __tts_convert_config_error_code(ret);
886 client->supported_voice_cb = callback;
887 client->supported_voice_user_data = user_data;
889 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
891 if (NULL != current_engine) {
892 free(current_engine);
893 current_engine = NULL;
896 client->supported_voice_cb = NULL;
897 client->supported_voice_user_data = NULL;
900 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
901 ret = TTS_ERROR_OPERATION_FAILED;
904 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
909 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
911 if (0 != __tts_get_feature_enabled()) {
912 return TTS_ERROR_NOT_SUPPORTED;
915 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
918 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
919 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
920 return TTS_ERROR_INVALID_PARAMETER;
923 tts_client_s* client = tts_client_get(tts);
925 if (NULL == client) {
926 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
927 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
928 return TTS_ERROR_INVALID_PARAMETER;
931 /* Request call remote method */
933 ret = tts_config_mgr_get_voice(lang, vctype);
935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
936 return __tts_convert_config_error_code(ret);
938 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
941 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
946 int tts_get_max_text_size(tts_h tts, unsigned int* size)
948 if (0 != __tts_get_feature_enabled()) {
949 return TTS_ERROR_NOT_SUPPORTED;
952 if (NULL == tts || NULL == size) {
953 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
954 return TTS_ERROR_INVALID_PARAMETER;
957 tts_client_s* client = tts_client_get(tts);
959 if (NULL == client) {
960 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
961 return TTS_ERROR_INVALID_PARAMETER;
964 if (TTS_STATE_READY != client->current_state) {
965 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
966 return TTS_ERROR_INVALID_STATE;
969 if (0 != tts_config_mgr_get_max_text_size(size)) {
970 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
971 return TTS_ERROR_INVALID_PARAMETER;
974 g_max_text_size = (int)*size;
976 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
977 return TTS_ERROR_NONE;
980 int tts_get_state(tts_h tts, tts_state_e* state)
982 if (0 != __tts_get_feature_enabled()) {
983 return TTS_ERROR_NOT_SUPPORTED;
986 if (NULL == tts || NULL == state) {
987 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
988 return TTS_ERROR_INVALID_PARAMETER;
991 tts_client_s* client = tts_client_get(tts);
993 if (NULL == client) {
994 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
995 return TTS_ERROR_INVALID_PARAMETER;
998 *state = client->current_state;
1001 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
1002 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
1003 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
1004 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
1005 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1008 return TTS_ERROR_NONE;
1011 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1013 if (0 != __tts_get_feature_enabled()) {
1014 return TTS_ERROR_NOT_SUPPORTED;
1017 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1018 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1019 return TTS_ERROR_INVALID_PARAMETER;
1022 tts_client_s* client = tts_client_get(tts);
1024 if (NULL == client) {
1025 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1026 return TTS_ERROR_INVALID_PARAMETER;
1029 *min = TTS_SPEED_MIN;
1030 *normal = TTS_SPEED_NORMAL;
1031 *max = TTS_SPEED_MAX;
1033 return TTS_ERROR_NONE;
1036 int tts_get_error_message(tts_h tts, char** err_msg)
1038 if (0 != __tts_get_feature_enabled()) {
1039 return TTS_ERROR_NOT_SUPPORTED;
1042 if (NULL == tts || NULL == err_msg) {
1043 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1044 return TTS_ERROR_INVALID_PARAMETER;
1047 tts_client_s* client = tts_client_get(tts);
1049 if (NULL == client) {
1050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1051 return TTS_ERROR_INVALID_PARAMETER;
1054 if (NULL != client->err_msg) {
1055 *err_msg = strdup(client->err_msg);
1056 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1059 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1062 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1064 return TTS_ERROR_NONE;
1067 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1069 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1071 if (0 != __tts_get_feature_enabled()) {
1072 return TTS_ERROR_NOT_SUPPORTED;
1076 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1077 return TTS_ERROR_INVALID_PARAMETER;
1080 if (voice_type < 0) {
1081 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1082 return TTS_ERROR_INVALID_PARAMETER;
1085 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1087 if (NULL == tts || NULL == utt_id) {
1088 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1089 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1090 return TTS_ERROR_INVALID_PARAMETER;
1093 tts_client_s* client = tts_client_get(tts);
1095 if (NULL == client) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1097 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1098 return TTS_ERROR_INVALID_PARAMETER;
1101 if (TTS_STATE_CREATED == client->current_state) {
1102 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1103 return TTS_ERROR_INVALID_STATE;
1106 if (-1 == g_max_text_size) {
1107 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1108 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1109 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1110 return TTS_ERROR_INVALID_PARAMETER;
1114 if (0 == g_max_text_size) {
1115 if (strlen(text) <= 0) {
1116 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1117 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1118 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1119 return TTS_ERROR_INVALID_PARAMETER;
1122 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1123 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1124 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1125 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1126 return TTS_ERROR_INVALID_PARAMETER;
1130 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1132 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1133 return TTS_ERROR_INVALID_PARAMETER;
1136 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1137 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1138 return TTS_ERROR_INVALID_STATE;
1141 if (true == client->credential_needed && NULL == client->credential) {
1142 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1143 return TTS_ERROR_PERMISSION_DENIED;
1146 /* check valid utf8 */
1150 dbus_error_init(&err);
1152 valid = dbus_validate_utf8(text, &err);
1153 if (dbus_error_is_set(&err)) {
1154 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1155 dbus_error_free(&err);
1156 return TTS_ERROR_INVALID_PARAMETER;
1159 if (valid != true) {
1160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1161 return TTS_ERROR_INVALID_PARAMETER;
1163 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1165 /* save texts for repetition */
1166 if (NULL != client->text_repeat) {
1167 free(client->text_repeat);
1168 client->text_repeat = NULL;
1171 client->text_repeat = strdup(text);
1173 if (NULL != g_language) {
1177 if (NULL == language)
1180 g_language = strdup(language);
1182 g_voice_type = voice_type;
1185 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] repeat: text(%s), language(%s), voice type(%d), speed(%d)", client->text_repeat, g_language, g_voice_type, g_speed);
1187 /* change default language value */
1190 if (NULL == language)
1191 temp = strdup("default");
1193 temp = strdup(language);
1195 client->current_utt_id++;
1196 if (client->current_utt_id == 10000) {
1197 client->current_utt_id = 1;
1203 bool is_prepared = false;
1205 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1207 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1208 client->current_state = TTS_STATE_CREATED;
1209 if (0 == tts_prepare_sync(tts)) {
1211 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1213 } else if (TTS_ERROR_TIMED_OUT != ret) {
1214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1217 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1220 if (TTS_RETRY_MIN_COUNT == count) {
1221 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1226 *utt_id = client->current_utt_id;
1235 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1241 static void __tts_play_async(void *data)
1243 tts_h tts = (tts_h)data;
1244 tts_client_s* client = tts_client_get(tts);
1247 if (NULL == client) {
1248 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1254 bool is_prepared = false;
1256 ret = tts_dbus_request_play(client->uid, client->credential);
1258 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1259 client->current_state = TTS_STATE_CREATED;
1260 if (0 == tts_prepare_sync(tts)) {
1262 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1264 } else if (TTS_ERROR_TIMED_OUT != ret) {
1265 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1268 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1271 if (TTS_RETRY_COUNT == count) {
1272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1280 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1282 client->reason = ret;
1283 client->utt_id = -1;
1285 ecore_timer_add(0, __tts_notify_error, client->tts);
1289 client->before_state = client->current_state;
1290 client->current_state = TTS_STATE_PLAYING;
1292 if (NULL != client->state_changed_cb) {
1293 tts_client_use_callback(client);
1294 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1295 tts_client_not_use_callback(client);
1296 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1299 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1304 int tts_play_async(tts_h tts)
1306 if (0 != __tts_get_feature_enabled()) {
1307 return TTS_ERROR_NOT_SUPPORTED;
1310 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1313 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1314 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1315 return TTS_ERROR_INVALID_PARAMETER;
1318 tts_client_s* client = tts_client_get(tts);
1320 if (NULL == client) {
1321 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1322 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1323 return TTS_ERROR_INVALID_PARAMETER;
1326 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1327 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1328 return TTS_ERROR_INVALID_STATE;
1331 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1332 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1333 return TTS_ERROR_INVALID_STATE;
1336 if (true == client->credential_needed && NULL == client->credential) {
1337 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1338 return TTS_ERROR_PERMISSION_DENIED;
1341 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1343 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1345 return TTS_ERROR_NONE;
1348 int tts_play(tts_h tts)
1350 if (0 != __tts_get_feature_enabled()) {
1351 return TTS_ERROR_NOT_SUPPORTED;
1354 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1357 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1358 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1359 return TTS_ERROR_INVALID_PARAMETER;
1362 tts_client_s* client = tts_client_get(tts);
1364 if (NULL == client) {
1365 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1366 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1367 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1368 return TTS_ERROR_INVALID_PARAMETER;
1371 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1372 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1373 return TTS_ERROR_INVALID_STATE;
1376 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1377 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1378 return TTS_ERROR_INVALID_STATE;
1381 if (true == client->credential_needed && NULL == client->credential) {
1382 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1383 return TTS_ERROR_PERMISSION_DENIED;
1388 bool is_prepared = false;
1390 ret = tts_dbus_request_play(client->uid, client->credential);
1392 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1393 client->current_state = TTS_STATE_CREATED;
1394 if (0 == tts_prepare_sync(tts)) {
1396 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1398 } else if (TTS_ERROR_TIMED_OUT != ret) {
1399 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1402 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1405 if (TTS_RETRY_COUNT == count) {
1406 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1413 client->before_state = client->current_state;
1414 client->current_state = TTS_STATE_PLAYING;
1416 if (NULL != client->state_changed_cb) {
1417 tts_client_use_callback(client);
1418 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1419 tts_client_not_use_callback(client);
1420 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1423 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1425 return TTS_ERROR_NONE;
1428 static void __tts_stop_async(void *data)
1430 tts_h tts = (tts_h)data;
1431 tts_client_s* client = tts_client_get(tts);
1434 if (NULL == client) {
1435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1441 bool is_prepared = false;
1443 ret = tts_dbus_request_stop(client->uid);
1445 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1446 client->current_state = TTS_STATE_CREATED;
1447 if (0 == tts_prepare_sync(tts)) {
1449 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1451 } else if (TTS_ERROR_TIMED_OUT != ret) {
1452 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1455 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1458 if (TTS_RETRY_COUNT == count) {
1459 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1467 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1469 client->reason = ret;
1470 client->utt_id = -1;
1472 ecore_timer_add(0, __tts_notify_error, client->tts);
1476 client->before_state = client->current_state;
1477 client->current_state = TTS_STATE_READY;
1479 if (NULL != client->state_changed_cb) {
1480 tts_client_use_callback(client);
1481 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1482 tts_client_not_use_callback(client);
1483 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1486 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1491 int tts_stop_aync(tts_h tts)
1493 if (0 != __tts_get_feature_enabled()) {
1494 return TTS_ERROR_NOT_SUPPORTED;
1497 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1500 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1501 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1502 return TTS_ERROR_INVALID_PARAMETER;
1505 tts_client_s* client = tts_client_get(tts);
1507 if (NULL == client) {
1508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1509 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1510 return TTS_ERROR_INVALID_PARAMETER;
1513 if (TTS_STATE_CREATED == client->current_state) {
1514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1515 return TTS_ERROR_INVALID_STATE;
1518 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1519 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1520 return TTS_ERROR_INVALID_STATE;
1523 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1525 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1527 return TTS_ERROR_NONE;
1530 int tts_stop(tts_h tts)
1532 if (0 != __tts_get_feature_enabled()) {
1533 return TTS_ERROR_NOT_SUPPORTED;
1536 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1539 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1540 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1541 return TTS_ERROR_INVALID_PARAMETER;
1544 tts_client_s* client = tts_client_get(tts);
1546 if (NULL == client) {
1547 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1548 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1549 return TTS_ERROR_INVALID_PARAMETER;
1552 if (TTS_STATE_CREATED == client->current_state) {
1553 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1554 return TTS_ERROR_INVALID_STATE;
1557 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1558 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1559 return TTS_ERROR_INVALID_STATE;
1564 bool is_prepared = false;
1566 ret = tts_dbus_request_stop(client->uid);
1568 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1569 client->current_state = TTS_STATE_CREATED;
1570 if (0 == tts_prepare_sync(tts)) {
1572 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1574 } else if (TTS_ERROR_TIMED_OUT != ret) {
1575 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1578 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1581 if (TTS_RETRY_COUNT == count) {
1582 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1589 client->before_state = client->current_state;
1590 client->current_state = TTS_STATE_READY;
1592 if (NULL != client->state_changed_cb) {
1593 tts_client_use_callback(client);
1594 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1595 tts_client_not_use_callback(client);
1596 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1599 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1601 return TTS_ERROR_NONE;
1604 static void __tts_pause_async(void *data)
1606 tts_h tts = (tts_h)data;
1607 tts_client_s* client = tts_client_get(tts);
1610 if (NULL == client) {
1611 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1617 bool is_prepared = false;
1619 ret = tts_dbus_request_pause(client->uid);
1621 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1622 client->current_state = TTS_STATE_CREATED;
1623 if (0 == tts_prepare_sync(tts)) {
1625 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1627 } else if (TTS_ERROR_TIMED_OUT != ret) {
1628 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1631 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1634 if (TTS_RETRY_COUNT == count) {
1635 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1643 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1645 client->reason = ret;
1646 client->utt_id = -1;
1648 ecore_timer_add(0, __tts_notify_error, client->tts);
1652 client->before_state = client->current_state;
1653 client->current_state = TTS_STATE_PAUSED;
1655 if (NULL != client->state_changed_cb) {
1656 tts_client_use_callback(client);
1657 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1658 tts_client_not_use_callback(client);
1659 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1662 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1667 int tts_pause_async(tts_h tts)
1669 if (0 != __tts_get_feature_enabled()) {
1670 return TTS_ERROR_NOT_SUPPORTED;
1673 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1676 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1677 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1678 return TTS_ERROR_INVALID_PARAMETER;
1681 tts_client_s* client = tts_client_get(tts);
1683 if (NULL == client) {
1684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1685 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1686 return TTS_ERROR_INVALID_PARAMETER;
1689 if (TTS_STATE_PLAYING != client->current_state) {
1690 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1691 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1692 return TTS_ERROR_INVALID_STATE;
1695 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1696 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1697 return TTS_ERROR_INVALID_STATE;
1700 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1702 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1704 return TTS_ERROR_NONE;
1707 int tts_pause(tts_h tts)
1709 if (0 != __tts_get_feature_enabled()) {
1710 return TTS_ERROR_NOT_SUPPORTED;
1713 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1716 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1717 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1718 return TTS_ERROR_INVALID_PARAMETER;
1721 tts_client_s* client = tts_client_get(tts);
1723 if (NULL == client) {
1724 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1725 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1726 return TTS_ERROR_INVALID_PARAMETER;
1729 if (TTS_STATE_PLAYING != client->current_state) {
1730 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1731 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1732 return TTS_ERROR_INVALID_STATE;
1735 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1736 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1737 return TTS_ERROR_INVALID_STATE;
1742 bool is_prepared = false;
1744 ret = tts_dbus_request_pause(client->uid);
1746 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1747 client->current_state = TTS_STATE_CREATED;
1748 if (0 == tts_prepare_sync(tts)) {
1750 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1752 } else if (TTS_ERROR_TIMED_OUT != ret) {
1753 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1756 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1759 if (TTS_RETRY_COUNT == count) {
1760 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1767 client->before_state = client->current_state;
1768 client->current_state = TTS_STATE_PAUSED;
1770 if (NULL != client->state_changed_cb) {
1771 tts_client_use_callback(client);
1772 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1773 tts_client_not_use_callback(client);
1774 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1777 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1779 return TTS_ERROR_NONE;
1782 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1784 if (0 != __tts_get_feature_enabled()) {
1785 return TTS_ERROR_NOT_SUPPORTED;
1788 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1792 return TTS_ERROR_INVALID_PARAMETER;
1795 if (NULL == key || NULL == data) {
1796 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1797 return TTS_ERROR_INVALID_PARAMETER;
1800 tts_client_s* client = tts_client_get(tts);
1802 if (NULL == client) {
1803 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1804 return TTS_ERROR_INVALID_PARAMETER;
1807 if (TTS_STATE_READY != client->current_state) {
1808 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1809 return TTS_ERROR_INVALID_STATE;
1812 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1813 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1814 return TTS_ERROR_INVALID_PARAMETER;
1819 bool is_prepared = false;
1821 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1823 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1824 client->current_state = TTS_STATE_CREATED;
1825 if (0 == tts_prepare_sync(tts)) {
1827 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1829 } else if (TTS_ERROR_TIMED_OUT != ret) {
1830 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1833 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1836 if (TTS_RETRY_COUNT == count) {
1837 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1844 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1849 int tts_get_private_data(tts_h tts, const char* key, char** data)
1851 if (0 != __tts_get_feature_enabled()) {
1852 return TTS_ERROR_NOT_SUPPORTED;
1855 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1858 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1859 return TTS_ERROR_INVALID_PARAMETER;
1862 if (NULL == key || NULL == data) {
1863 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1864 return TTS_ERROR_INVALID_PARAMETER;
1867 tts_client_s* client = tts_client_get(tts);
1869 if (NULL == client) {
1870 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1871 return TTS_ERROR_INVALID_PARAMETER;
1874 if (TTS_STATE_READY != client->current_state) {
1875 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1876 return TTS_ERROR_INVALID_STATE;
1881 bool is_prepared = false;
1883 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1885 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1886 client->current_state = TTS_STATE_CREATED;
1887 if (0 == tts_prepare_sync(tts)) {
1889 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1891 } else if (TTS_ERROR_TIMED_OUT != ret) {
1892 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1895 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1898 if (TTS_RETRY_COUNT == count) {
1899 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1906 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1911 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1916 static Eina_Bool __tts_notify_error(void *data)
1918 tts_h tts = (tts_h)data;
1920 tts_client_s* client = tts_client_get(tts);
1923 if (NULL == client) {
1924 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1928 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1930 if (NULL != client->error_cb) {
1931 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1932 tts_client_use_callback(client);
1933 g_err_callback_status = true;
1934 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1935 g_err_callback_status = false;
1936 tts_client_not_use_callback(client);
1938 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1944 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1947 GList* client_list = NULL;
1948 client_list = tts_client_get_client_list();
1951 tts_client_s *data = NULL;
1953 if (g_list_length(client_list) > 0) {
1954 /* Get a first item */
1955 iter = g_list_first(client_list);
1957 while (NULL != iter) {
1960 data->utt_id = utt_id;
1961 data->reason = reason;
1962 if (NULL != data->err_msg) {
1963 free(data->err_msg);
1964 data->err_msg = NULL;
1966 if (NULL != err_msg)
1967 data->err_msg = strdup(err_msg);
1969 /* call callback function */
1970 if (NULL != data->error_cb) {
1971 ecore_timer_add(0, __tts_notify_error, data->tts);
1973 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1976 if (TTS_ERROR_SERVICE_RESET == reason) {
1977 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1979 data->current_state = TTS_STATE_CREATED;
1980 if (0 != tts_prepare(data->tts)) {
1981 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1986 iter = g_list_next(iter);
1990 tts_client_s* client = tts_client_get_by_uid(uid);
1992 if (NULL == client) {
1993 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1994 return TTS_ERROR_INVALID_PARAMETER;
1997 client->utt_id = utt_id;
1998 client->reason = reason;
1999 if (NULL != client->err_msg) {
2000 free(client->err_msg);
2001 client->err_msg = NULL;
2003 if (NULL != err_msg)
2004 client->err_msg = strdup(err_msg);
2006 /* call callback function */
2007 if (NULL != client->error_cb) {
2008 ecore_timer_add(0, __tts_notify_error, client->tts);
2010 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2013 if (TTS_ERROR_SERVICE_RESET == reason) {
2014 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2016 client->current_state = TTS_STATE_CREATED;
2017 if (0 != tts_prepare(client->tts)) {
2018 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2026 static Eina_Bool __tts_notify_state_changed(void *data)
2028 tts_h tts = (tts_h)data;
2030 tts_client_s* client = tts_client_get(tts);
2033 if (NULL == client) {
2034 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2038 if (NULL != client->state_changed_cb) {
2039 tts_client_use_callback(client);
2040 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2041 tts_client_not_use_callback(client);
2042 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2044 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2050 int __tts_cb_set_state(int uid, int state)
2052 tts_client_s* client = tts_client_get_by_uid(uid);
2053 if (NULL == client) {
2054 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2058 tts_state_e state_from_daemon = (tts_state_e)state;
2060 if (client->current_state == state_from_daemon) {
2061 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2065 if (NULL != client->state_changed_cb) {
2066 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2068 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2071 client->before_state = client->current_state;
2072 client->current_state = state_from_daemon;
2077 int __tts_cb_utt_started(int uid, int utt_id)
2079 tts_client_s* client = tts_client_get_by_uid(uid);
2081 if (NULL == client) {
2082 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2083 return TTS_ERROR_INVALID_PARAMETER;
2086 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2088 client->utt_id = utt_id;
2090 /* call callback function */
2091 if (NULL != client->utt_started_cb) {
2092 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2093 tts_client_use_callback(client);
2094 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2095 tts_client_not_use_callback(client);
2097 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2103 int __tts_cb_utt_completed(int uid, int utt_id)
2105 tts_client_s* client = tts_client_get_by_uid(uid);
2107 if (NULL == client) {
2108 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2109 return TTS_ERROR_INVALID_PARAMETER;
2112 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2114 client->utt_id = utt_id;
2116 /* call callback function */
2117 if (NULL != client->utt_completeted_cb) {
2118 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2119 tts_client_use_callback(client);
2120 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2121 tts_client_not_use_callback(client);
2123 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2129 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2131 if (0 != __tts_get_feature_enabled()) {
2132 return TTS_ERROR_NOT_SUPPORTED;
2135 if (NULL == tts || NULL == callback) {
2136 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2137 return TTS_ERROR_INVALID_PARAMETER;
2140 tts_client_s* client = tts_client_get(tts);
2142 if (NULL == client) {
2143 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2144 return TTS_ERROR_INVALID_PARAMETER;
2147 if (TTS_STATE_CREATED != client->current_state) {
2148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2149 return TTS_ERROR_INVALID_STATE;
2152 client->state_changed_cb = callback;
2153 client->state_changed_user_data = user_data;
2155 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2160 int tts_unset_state_changed_cb(tts_h tts)
2162 if (0 != __tts_get_feature_enabled()) {
2163 return TTS_ERROR_NOT_SUPPORTED;
2167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2168 return TTS_ERROR_INVALID_PARAMETER;
2171 tts_client_s* client = tts_client_get(tts);
2173 if (NULL == client) {
2174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2175 return TTS_ERROR_INVALID_PARAMETER;
2178 if (TTS_STATE_CREATED != client->current_state) {
2179 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2180 return TTS_ERROR_INVALID_STATE;
2183 client->state_changed_cb = NULL;
2184 client->state_changed_user_data = NULL;
2186 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2191 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2193 if (0 != __tts_get_feature_enabled()) {
2194 return TTS_ERROR_NOT_SUPPORTED;
2197 if (NULL == tts || NULL == callback) {
2198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2199 return TTS_ERROR_INVALID_PARAMETER;
2202 tts_client_s* client = tts_client_get(tts);
2204 if (NULL == client) {
2205 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2206 return TTS_ERROR_INVALID_PARAMETER;
2209 if (TTS_STATE_CREATED != client->current_state) {
2210 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2211 return TTS_ERROR_INVALID_STATE;
2214 client->utt_started_cb = callback;
2215 client->utt_started_user_data = user_data;
2217 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2222 int tts_unset_utterance_started_cb(tts_h tts)
2224 if (0 != __tts_get_feature_enabled()) {
2225 return TTS_ERROR_NOT_SUPPORTED;
2229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2230 return TTS_ERROR_INVALID_PARAMETER;
2233 tts_client_s* client = tts_client_get(tts);
2235 if (NULL == client) {
2236 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2237 return TTS_ERROR_INVALID_PARAMETER;
2240 if (TTS_STATE_CREATED != client->current_state) {
2241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2242 return TTS_ERROR_INVALID_STATE;
2245 client->utt_started_cb = NULL;
2246 client->utt_started_user_data = NULL;
2248 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2253 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2255 if (0 != __tts_get_feature_enabled()) {
2256 return TTS_ERROR_NOT_SUPPORTED;
2259 if (NULL == tts || NULL == callback) {
2260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2261 return TTS_ERROR_INVALID_PARAMETER;
2264 tts_client_s* client = tts_client_get(tts);
2266 if (NULL == client) {
2267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2268 return TTS_ERROR_INVALID_PARAMETER;
2271 if (TTS_STATE_CREATED != client->current_state) {
2272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2273 return TTS_ERROR_INVALID_STATE;
2276 client->utt_completeted_cb = callback;
2277 client->utt_completed_user_data = user_data;
2279 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2284 int tts_unset_utterance_completed_cb(tts_h tts)
2286 if (0 != __tts_get_feature_enabled()) {
2287 return TTS_ERROR_NOT_SUPPORTED;
2291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2292 return TTS_ERROR_INVALID_PARAMETER;
2295 tts_client_s* client = tts_client_get(tts);
2297 if (NULL == client) {
2298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2299 return TTS_ERROR_INVALID_PARAMETER;
2302 if (TTS_STATE_CREATED != client->current_state) {
2303 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2304 return TTS_ERROR_INVALID_STATE;
2307 client->utt_completeted_cb = NULL;
2308 client->utt_completed_user_data = NULL;
2310 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2314 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2316 if (0 != __tts_get_feature_enabled()) {
2317 return TTS_ERROR_NOT_SUPPORTED;
2320 if (NULL == tts || NULL == callback) {
2321 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2322 return TTS_ERROR_INVALID_PARAMETER;
2325 tts_client_s* client = tts_client_get(tts);
2327 if (NULL == client) {
2328 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2329 return TTS_ERROR_INVALID_PARAMETER;
2332 if (TTS_STATE_CREATED != client->current_state) {
2333 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2334 return TTS_ERROR_INVALID_STATE;
2337 client->error_cb = callback;
2338 client->error_user_data = user_data;
2340 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2345 int tts_unset_error_cb(tts_h tts)
2347 if (0 != __tts_get_feature_enabled()) {
2348 return TTS_ERROR_NOT_SUPPORTED;
2352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2353 return TTS_ERROR_INVALID_PARAMETER;
2356 tts_client_s* client = tts_client_get(tts);
2358 if (NULL == client) {
2359 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2360 return TTS_ERROR_INVALID_PARAMETER;
2363 if (TTS_STATE_CREATED != client->current_state) {
2364 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2365 return TTS_ERROR_INVALID_STATE;
2368 client->error_cb = NULL;
2369 client->error_user_data = NULL;
2371 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2376 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2378 if (0 != __tts_get_feature_enabled()) {
2379 return TTS_ERROR_NOT_SUPPORTED;
2382 if (NULL == tts || NULL == callback) {
2383 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2384 return TTS_ERROR_INVALID_PARAMETER;
2387 tts_client_s* client = tts_client_get(tts);
2389 if (NULL == client) {
2390 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2391 return TTS_ERROR_INVALID_PARAMETER;
2394 if (TTS_STATE_CREATED != client->current_state) {
2395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2396 return TTS_ERROR_INVALID_STATE;
2399 client->default_voice_changed_cb = callback;
2400 client->default_voice_changed_user_data = user_data;
2402 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2407 int tts_unset_default_voice_changed_cb(tts_h tts)
2409 if (0 != __tts_get_feature_enabled()) {
2410 return TTS_ERROR_NOT_SUPPORTED;
2414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2415 return TTS_ERROR_INVALID_PARAMETER;
2418 tts_client_s* client = tts_client_get(tts);
2420 if (NULL == client) {
2421 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2422 return TTS_ERROR_INVALID_PARAMETER;
2425 if (TTS_STATE_CREATED != client->current_state) {
2426 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2427 return TTS_ERROR_INVALID_STATE;
2430 client->default_voice_changed_cb = NULL;
2431 client->default_voice_changed_user_data = NULL;
2433 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2438 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2440 if (0 != __tts_get_feature_enabled()) {
2441 return TTS_ERROR_NOT_SUPPORTED;
2444 if (NULL == tts || NULL == callback) {
2445 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2446 return TTS_ERROR_INVALID_PARAMETER;
2449 tts_client_s* client = tts_client_get(tts);
2451 if (NULL == client) {
2452 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2453 return TTS_ERROR_INVALID_PARAMETER;
2456 if (TTS_STATE_CREATED != client->current_state) {
2457 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2458 return TTS_ERROR_INVALID_STATE;
2461 client->engine_changed_cb = callback;
2462 client->engine_changed_user_data = user_data;
2464 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2469 int tts_unset_engine_changed_cb(tts_h tts)
2471 if (0 != __tts_get_feature_enabled()) {
2472 return TTS_ERROR_NOT_SUPPORTED;
2476 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2477 return TTS_ERROR_INVALID_PARAMETER;
2480 tts_client_s* client = tts_client_get(tts);
2482 if (NULL == client) {
2483 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2484 return TTS_ERROR_INVALID_PARAMETER;
2487 if (TTS_STATE_CREATED != client->current_state) {
2488 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2489 return TTS_ERROR_INVALID_STATE;
2492 client->engine_changed_cb = NULL;
2493 client->engine_changed_user_data = NULL;
2495 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2501 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2503 if (0 != __tts_get_feature_enabled()) {
2504 return TTS_ERROR_NOT_SUPPORTED;
2507 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2510 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2511 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2512 return TTS_ERROR_INVALID_PARAMETER;
2515 tts_client_s* client = tts_client_get(tts);
2517 if (NULL == client) {
2518 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2519 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2520 return TTS_ERROR_INVALID_PARAMETER;
2523 if (TTS_STATE_CREATED == client->current_state) {
2524 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2525 return TTS_ERROR_INVALID_STATE;
2528 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2529 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2530 return TTS_ERROR_INVALID_STATE;
2535 bool is_prepared = false;
2537 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2539 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2540 client->current_state = TTS_STATE_CREATED;
2541 if (0 == tts_prepare_sync(tts)) {
2543 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2545 } else if (TTS_ERROR_TIMED_OUT != ret) {
2546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2549 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2552 if (TTS_RETRY_COUNT == count) {
2553 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2560 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2562 return TTS_ERROR_NONE;
2565 int tts_play_pcm(tts_h tts)
2567 if (0 != __tts_get_feature_enabled()) {
2568 return TTS_ERROR_NOT_SUPPORTED;
2571 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2574 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2575 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2576 return TTS_ERROR_INVALID_PARAMETER;
2579 tts_client_s* client = tts_client_get(tts);
2581 if (NULL == client) {
2582 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2583 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2584 return TTS_ERROR_INVALID_PARAMETER;
2587 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2588 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2589 return TTS_ERROR_INVALID_STATE;
2592 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2593 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2594 return TTS_ERROR_INVALID_STATE;
2599 bool is_prepared = false;
2601 ret = tts_dbus_request_play_pcm(client->uid);
2603 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2604 client->current_state = TTS_STATE_CREATED;
2605 if (0 == tts_prepare_sync(tts)) {
2607 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2609 } else if (TTS_ERROR_TIMED_OUT != ret) {
2610 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2613 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2616 if (TTS_RETRY_COUNT == count) {
2617 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2624 client->before_state = client->current_state;
2625 client->current_state = TTS_STATE_PLAYING;
2627 if (NULL != client->state_changed_cb) {
2628 tts_client_use_callback(client);
2629 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2630 tts_client_not_use_callback(client);
2631 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2634 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2636 return TTS_ERROR_NONE;
2639 int tts_stop_pcm(tts_h tts)
2641 if (0 != __tts_get_feature_enabled()) {
2642 return TTS_ERROR_NOT_SUPPORTED;
2645 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2649 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2650 return TTS_ERROR_INVALID_PARAMETER;
2653 tts_client_s* client = tts_client_get(tts);
2655 if (NULL == client) {
2656 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2657 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2658 return TTS_ERROR_INVALID_PARAMETER;
2661 if (TTS_STATE_CREATED == client->current_state) {
2662 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2663 return TTS_ERROR_INVALID_STATE;
2666 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2667 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2668 return TTS_ERROR_INVALID_STATE;
2673 bool is_prepared = false;
2675 ret = tts_dbus_request_stop_pcm(client->uid);
2677 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2678 client->current_state = TTS_STATE_CREATED;
2679 if (0 == tts_prepare_sync(tts)) {
2681 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2683 } else if (TTS_ERROR_TIMED_OUT != ret) {
2684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2687 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2690 if (TTS_RETRY_COUNT == count) {
2691 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2698 client->before_state = client->current_state;
2699 client->current_state = TTS_STATE_READY;
2701 if (NULL != client->state_changed_cb) {
2702 tts_client_use_callback(client);
2703 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2704 tts_client_not_use_callback(client);
2705 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2708 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2710 return TTS_ERROR_NONE;
2713 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
2715 if (0 != __tts_get_feature_enabled()) {
2716 return TTS_ERROR_NOT_SUPPORTED;
2719 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
2722 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2723 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2724 return TTS_ERROR_INVALID_PARAMETER;
2727 if (NULL == text_repeat || NULL == utt_id) {
2728 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
2729 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2730 return TTS_ERROR_INVALID_PARAMETER;
2733 *text_repeat = NULL;
2736 tts_client_s* client = tts_client_get(tts);
2738 if (NULL == client) {
2739 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2740 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2741 return TTS_ERROR_INVALID_PARAMETER;
2744 if (TTS_STATE_READY != client->current_state) {
2745 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
2746 return TTS_ERROR_INVALID_STATE;
2749 /* Clear the legacy and Add texts to be played repeatedly */
2751 ret = tts_stop(tts);
2752 if (TTS_ERROR_NONE != ret) {
2753 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
2757 if (NULL != client->text_repeat) {
2758 char* tmp_text = strdup(client->text_repeat);
2759 char* tmp_lang = NULL;
2760 if (NULL != g_language) {
2761 tmp_lang = strdup(g_language);
2763 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
2764 if (TTS_ERROR_NONE != ret) {
2765 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
2766 if (NULL != tmp_text) {
2770 if (NULL != tmp_lang) {
2776 *text_repeat = strdup(client->text_repeat);
2777 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
2778 if (NULL != tmp_text) {
2782 if (NULL != tmp_lang) {
2787 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
2788 return TTS_ERROR_OPERATION_FAILED;
2791 /* Play added texts */
2792 ret = tts_play(tts);
2793 if (TTS_ERROR_NONE != ret) {
2794 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
2795 if (NULL != *text_repeat) {
2797 *text_repeat = NULL;
2803 return TTS_ERROR_NONE;