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;
121 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)
123 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
124 before_lang, before_voice_type, language, voice_type);
126 GList* client_list = NULL;
127 client_list = tts_client_get_client_list();
130 tts_client_s *data = NULL;
132 if (g_list_length(client_list) > 0) {
133 /* Get a first item */
134 iter = g_list_first(client_list);
136 while (NULL != iter) {
138 if (NULL != data->default_voice_changed_cb) {
139 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
140 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
141 language, voice_type, data->default_voice_changed_user_data);
144 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
145 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
146 if (NULL != data->text_repeat) {
147 free(data->text_repeat);
148 data->text_repeat = NULL;
153 iter = g_list_next(iter);
160 static Eina_Bool __reconnect_by_engine_changed(void* data)
162 tts_h tts = (tts_h)data;
164 tts_client_s* client = tts_client_get(tts);
165 if (NULL == client) {
166 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
170 if (TTS_STATE_READY != client->current_state) {
175 int ret = tts_unprepare(tts);
177 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
179 ret = tts_prepare(tts);
181 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
187 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)
189 tts_h tts = (tts_h)user_data;
191 tts_client_s* client = tts_client_get(tts);
192 if (NULL == client) {
193 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
197 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
198 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
199 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
200 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
202 /* When the default engine is changed, please unload the old engine and load the new one. */
205 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
208 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
211 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
212 } else if (TTS_STATE_READY == client->current_state) {
213 ret = tts_unprepare(tts);
215 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
217 ret = tts_prepare(tts);
219 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
223 /* call callback function */
224 if (NULL != client->engine_changed_cb) {
225 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
227 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
233 int tts_create(tts_h* tts)
235 if (0 != __tts_get_feature_enabled()) {
236 return TTS_ERROR_NOT_SUPPORTED;
239 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
243 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
244 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
245 return TTS_ERROR_INVALID_PARAMETER;
248 if (0 == tts_client_get_size()) {
249 if (0 != tts_dbus_open_connection()) {
250 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
251 return TTS_ERROR_OPERATION_FAILED;
255 if (0 != tts_client_new(tts)) {
256 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
257 return TTS_ERROR_OUT_OF_MEMORY;
260 tts_client_s* client = tts_client_get(*tts);
261 if (NULL == client) {
262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
263 return TTS_ERROR_OPERATION_FAILED;
266 int ret = tts_config_mgr_initialize(client->uid);
268 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
269 tts_client_destroy(*tts);
270 return __tts_convert_config_error_code(ret);
273 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
275 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
276 tts_client_destroy(*tts);
277 return __tts_convert_config_error_code(ret);
280 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
281 SLOG(LOG_DEBUG, TAG_TTSC, " ");
283 return TTS_ERROR_NONE;
286 int tts_destroy(tts_h tts)
288 if (0 != __tts_get_feature_enabled()) {
289 return TTS_ERROR_NOT_SUPPORTED;
292 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
295 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
296 return TTS_ERROR_INVALID_PARAMETER;
299 tts_client_s* client = tts_client_get(tts);
302 if (NULL == client) {
303 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
304 return TTS_ERROR_INVALID_PARAMETER;
307 /* check used callback */
308 if (0 != tts_client_get_use_callback(client)) {
309 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
310 return TTS_ERROR_OPERATION_FAILED;
313 tts_config_mgr_finalize(client->uid);
317 int screen_reader = -1;
320 switch (client->current_state) {
321 case TTS_STATE_PAUSED:
322 case TTS_STATE_PLAYING:
323 case TTS_STATE_READY:
324 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
326 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
328 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);
329 g_screen_reader = (bool)screen_reader;
331 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
333 ret = tts_dbus_request_finalize(client->uid);
336 if (TTS_ERROR_TIMED_OUT != ret) {
337 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
340 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
343 if (TTS_RETRY_COUNT == count) {
344 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
352 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
355 client->before_state = client->current_state;
356 client->current_state = TTS_STATE_CREATED;
358 case TTS_STATE_CREATED:
359 if (NULL != client->conn_timer) {
360 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
361 ecore_timer_del(client->conn_timer);
362 client->conn_timer = NULL;
365 tts_client_destroy(tts);
372 if (0 == tts_client_get_size()) {
373 if (0 != tts_dbus_close_connection()) {
374 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
378 if (NULL != g_language) {
385 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
387 return TTS_ERROR_NONE;
391 void __tts_screen_reader_changed_cb(bool value)
393 g_screen_reader = value;
397 int tts_set_mode(tts_h tts, tts_mode_e mode)
399 if (0 != __tts_get_feature_enabled()) {
400 return TTS_ERROR_NOT_SUPPORTED;
403 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
405 tts_client_s* client = tts_client_get(tts);
408 if (NULL == client) {
409 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
410 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
411 return TTS_ERROR_INVALID_PARAMETER;
415 if (client->current_state != TTS_STATE_CREATED) {
416 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
417 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
418 SLOG(LOG_DEBUG, TAG_TTSC, " ");
419 return TTS_ERROR_INVALID_STATE;
422 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
425 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
426 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
427 SLOG(LOG_DEBUG, TAG_TTSC, " ");
428 return TTS_ERROR_INVALID_PARAMETER;
431 if (TTS_MODE_SCREEN_READER == mode) {
434 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
436 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
437 return TTS_ERROR_OPERATION_FAILED;
439 g_screen_reader = (bool)screen_reader;
440 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
442 tts_config_unset_screen_reader_callback(client->uid);
445 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
447 return TTS_ERROR_NONE;
450 int tts_get_mode(tts_h tts, tts_mode_e* mode)
452 if (0 != __tts_get_feature_enabled()) {
453 return TTS_ERROR_NOT_SUPPORTED;
456 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
458 tts_client_s* client = tts_client_get(tts);
461 if (NULL == client) {
462 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
463 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
464 SLOG(LOG_DEBUG, TAG_TTSC, " ");
465 return TTS_ERROR_INVALID_PARAMETER;
469 if (client->current_state != TTS_STATE_CREATED) {
470 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
471 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
472 SLOG(LOG_DEBUG, TAG_TTSC, " ");
473 return TTS_ERROR_INVALID_STATE;
477 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
478 return TTS_ERROR_INVALID_PARAMETER;
481 *mode = client->mode;
483 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
484 SLOG(LOG_DEBUG, TAG_TTSC, " ");
486 return TTS_ERROR_NONE;
489 int tts_set_credential(tts_h tts, const char* credential)
491 if (0 != __tts_get_feature_enabled()) {
492 return TTS_ERROR_NOT_SUPPORTED;
495 if (NULL == tts || NULL == credential) {
496 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
497 return TTS_ERROR_INVALID_PARAMETER;
500 tts_client_s* client = tts_client_get(tts);
502 if (NULL == client) {
503 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
504 return TTS_ERROR_INVALID_PARAMETER;
507 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
509 return TTS_ERROR_INVALID_STATE;
512 if (NULL != client->credential) {
513 free(client->credential);
514 client->credential = NULL;
516 client->credential = strdup(credential);
518 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
520 return TTS_ERROR_NONE;
524 int tts_set_server_tts(tts_h tts, const char* credential)
526 if (0 != __tts_get_feature_enabled()) {
527 return TTS_ERROR_NOT_SUPPORTED;
531 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
532 return TTS_ERROR_INVALID_PARAMETER;
535 tts_client_s* client = tts_client_get(tts);
537 if (NULL == client) {
538 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
539 return TTS_ERROR_INVALID_PARAMETER;
542 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
543 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
544 return TTS_ERROR_INVALID_STATE;
547 if (NULL != client->credential) {
548 free(client->credential);
549 client->credential = NULL;
552 client->internal = true;
555 if (NULL != credential) {
556 key = strdup("EnableServerTTS");
557 client->credential = strdup(credential);
558 if (NULL == client->credential) {
559 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
564 return TTS_ERROR_OUT_OF_MEMORY;
567 key = strdup("DisableServerTTS");
571 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
572 return TTS_ERROR_OUT_OF_MEMORY;
577 int ret = app_manager_get_app_id(pid, &appid);
578 if (0 != ret || NULL == appid) {
579 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
586 return TTS_ERROR_OPERATION_FAILED;
589 ret = tts_set_private_data(tts, key, appid);
591 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
604 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
606 return TTS_ERROR_NONE;
610 static Eina_Bool __tts_connect_daemon(void *data)
612 tts_h tts = (tts_h)data;
613 tts_client_s* client = tts_client_get(tts);
616 if (NULL == client) {
617 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
622 if (0 != tts_dbus_request_hello(client->uid)) {
626 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
628 /* do request initialize */
630 bool credential_needed = false;
632 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
634 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
635 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
637 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
640 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
641 client->conn_timer = NULL;
644 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
645 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
647 client->reason = TTS_ERROR_PERMISSION_DENIED;
650 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
651 client->conn_timer = NULL;
654 } else if (TTS_ERROR_NONE != ret) {
655 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
659 /* success to connect tts-daemon */
660 client->credential_needed = credential_needed;
661 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
664 client->conn_timer = NULL;
666 client = tts_client_get(tts);
668 if (NULL == client) {
669 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
673 client->before_state = client->current_state;
674 client->current_state = TTS_STATE_READY;
676 if (NULL != client->state_changed_cb) {
677 tts_client_use_callback(client);
678 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
679 tts_client_not_use_callback(client);
681 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
684 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
689 int tts_prepare(tts_h tts)
691 if (0 != __tts_get_feature_enabled()) {
692 return TTS_ERROR_NOT_SUPPORTED;
695 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
697 tts_client_s* client = tts_client_get(tts);
700 if (NULL == client) {
701 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
702 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
703 return TTS_ERROR_INVALID_PARAMETER;
707 if (client->current_state != TTS_STATE_CREATED) {
708 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
709 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
710 return TTS_ERROR_INVALID_STATE;
713 ecore_thread_main_loop_begin();
714 client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
715 ecore_thread_main_loop_end();
717 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
719 return TTS_ERROR_NONE;
723 int tts_prepare_sync(tts_h tts)
725 if (0 != __tts_get_feature_enabled()) {
726 return TTS_ERROR_NOT_SUPPORTED;
729 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
731 tts_client_s* client = tts_client_get(tts);
734 if (NULL == client) {
735 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
736 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
737 return TTS_ERROR_INVALID_PARAMETER;
741 if (client->current_state != TTS_STATE_CREATED) {
742 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
743 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
744 return TTS_ERROR_INVALID_STATE;
748 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
752 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
754 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
755 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
756 return TTS_ERROR_OPERATION_FAILED;
759 return TTS_ERROR_NONE;
763 int tts_unprepare(tts_h tts)
765 if (0 != __tts_get_feature_enabled()) {
766 return TTS_ERROR_NOT_SUPPORTED;
769 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
771 tts_client_s* client = tts_client_get(tts);
774 if (NULL == client) {
775 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
776 return TTS_ERROR_INVALID_PARAMETER;
780 if (client->current_state != TTS_STATE_READY) {
781 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
782 return TTS_ERROR_INVALID_STATE;
787 int screen_reader = -1;
789 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
791 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
793 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);
794 g_screen_reader = (bool)screen_reader;
797 bool is_prepared = false;
798 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
800 ret = tts_dbus_request_finalize(client->uid);
803 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
804 client->current_state = TTS_STATE_CREATED;
805 if (0 == tts_prepare_sync(tts)) {
807 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
809 } else if (TTS_ERROR_TIMED_OUT != ret) {
810 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
813 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
816 if (TTS_RETRY_COUNT == count) {
817 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
825 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
828 client->before_state = client->current_state;
829 client->current_state = TTS_STATE_CREATED;
831 if (NULL != client->state_changed_cb) {
832 tts_client_use_callback(client);
833 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
834 tts_client_not_use_callback(client);
835 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
838 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
840 return TTS_ERROR_NONE;
843 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
845 tts_h tts = (tts_h)user_data;
847 tts_client_s* client = tts_client_get(tts);
848 if (NULL == client) {
849 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
853 /* call callback function */
854 if (NULL != client->supported_voice_cb) {
855 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
857 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
863 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
865 if (0 != __tts_get_feature_enabled()) {
866 return TTS_ERROR_NOT_SUPPORTED;
869 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
871 if (NULL == tts || NULL == callback) {
872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
873 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
874 return TTS_ERROR_INVALID_PARAMETER;
877 tts_client_s* client = tts_client_get(tts);
880 if (NULL == client) {
881 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
882 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
883 return TTS_ERROR_INVALID_PARAMETER;
887 char* current_engine = NULL;
888 ret = tts_config_mgr_get_engine(¤t_engine);
890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
891 return __tts_convert_config_error_code(ret);
894 client->supported_voice_cb = callback;
895 client->supported_voice_user_data = user_data;
897 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
899 if (NULL != current_engine) {
900 free(current_engine);
901 current_engine = NULL;
904 client->supported_voice_cb = NULL;
905 client->supported_voice_user_data = NULL;
908 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
909 ret = TTS_ERROR_OPERATION_FAILED;
912 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
917 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
919 if (0 != __tts_get_feature_enabled()) {
920 return TTS_ERROR_NOT_SUPPORTED;
923 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
926 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
927 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
928 return TTS_ERROR_INVALID_PARAMETER;
931 tts_client_s* client = tts_client_get(tts);
933 if (NULL == client) {
934 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
935 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
936 return TTS_ERROR_INVALID_PARAMETER;
939 /* Request call remote method */
941 ret = tts_config_mgr_get_voice(lang, vctype);
943 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
944 return __tts_convert_config_error_code(ret);
946 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
949 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
954 int tts_get_max_text_size(tts_h tts, unsigned int* size)
956 if (0 != __tts_get_feature_enabled()) {
957 return TTS_ERROR_NOT_SUPPORTED;
960 if (NULL == tts || NULL == size) {
961 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
962 return TTS_ERROR_INVALID_PARAMETER;
965 tts_client_s* client = tts_client_get(tts);
967 if (NULL == client) {
968 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
969 return TTS_ERROR_INVALID_PARAMETER;
972 if (TTS_STATE_READY != client->current_state) {
973 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
974 return TTS_ERROR_INVALID_STATE;
977 if (0 != tts_config_mgr_get_max_text_size(size)) {
978 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
979 return TTS_ERROR_INVALID_PARAMETER;
982 g_max_text_size = (int)*size;
984 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
985 return TTS_ERROR_NONE;
988 int tts_get_state(tts_h tts, tts_state_e* state)
990 if (0 != __tts_get_feature_enabled()) {
991 return TTS_ERROR_NOT_SUPPORTED;
994 if (NULL == tts || NULL == state) {
995 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
996 return TTS_ERROR_INVALID_PARAMETER;
999 tts_client_s* client = tts_client_get(tts);
1001 if (NULL == client) {
1002 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1003 return TTS_ERROR_INVALID_PARAMETER;
1006 *state = client->current_state;
1009 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
1010 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
1011 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
1012 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
1013 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1016 return TTS_ERROR_NONE;
1019 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1021 if (0 != __tts_get_feature_enabled()) {
1022 return TTS_ERROR_NOT_SUPPORTED;
1025 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1026 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1027 return TTS_ERROR_INVALID_PARAMETER;
1030 tts_client_s* client = tts_client_get(tts);
1032 if (NULL == client) {
1033 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1034 return TTS_ERROR_INVALID_PARAMETER;
1037 *min = TTS_SPEED_MIN;
1038 *normal = TTS_SPEED_NORMAL;
1039 *max = TTS_SPEED_MAX;
1041 return TTS_ERROR_NONE;
1044 int tts_get_error_message(tts_h tts, char** err_msg)
1046 if (0 != __tts_get_feature_enabled()) {
1047 return TTS_ERROR_NOT_SUPPORTED;
1050 if (NULL == tts || NULL == err_msg) {
1051 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1052 return TTS_ERROR_INVALID_PARAMETER;
1055 tts_client_s* client = tts_client_get(tts);
1057 if (NULL == client) {
1058 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1059 return TTS_ERROR_INVALID_PARAMETER;
1062 if (NULL != client->err_msg) {
1063 *err_msg = strdup(client->err_msg);
1064 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1067 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1070 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1072 return TTS_ERROR_NONE;
1075 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1077 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1079 if (0 != __tts_get_feature_enabled()) {
1080 return TTS_ERROR_NOT_SUPPORTED;
1084 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1085 return TTS_ERROR_INVALID_PARAMETER;
1088 if (voice_type < 0) {
1089 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1090 return TTS_ERROR_INVALID_PARAMETER;
1093 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1095 if (NULL == tts || NULL == utt_id) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1097 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1098 return TTS_ERROR_INVALID_PARAMETER;
1101 tts_client_s* client = tts_client_get(tts);
1103 if (NULL == client) {
1104 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1105 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1106 return TTS_ERROR_INVALID_PARAMETER;
1109 if (TTS_STATE_CREATED == client->current_state) {
1110 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1111 return TTS_ERROR_INVALID_STATE;
1114 if (-1 == g_max_text_size) {
1115 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1116 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1117 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1118 return TTS_ERROR_INVALID_PARAMETER;
1122 if (0 == g_max_text_size) {
1123 if (strlen(text) <= 0) {
1124 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1126 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1127 return TTS_ERROR_INVALID_PARAMETER;
1130 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1131 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1132 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1133 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1134 return TTS_ERROR_INVALID_PARAMETER;
1138 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1139 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1140 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1141 return TTS_ERROR_INVALID_PARAMETER;
1144 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1145 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1146 return TTS_ERROR_INVALID_STATE;
1149 if (true == client->credential_needed && NULL == client->credential) {
1150 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1151 return TTS_ERROR_PERMISSION_DENIED;
1154 /* check valid utf8 */
1158 dbus_error_init(&err);
1160 valid = dbus_validate_utf8(text, &err);
1161 if (dbus_error_is_set(&err)) {
1162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1163 dbus_error_free(&err);
1164 return TTS_ERROR_INVALID_PARAMETER;
1167 if (valid != true) {
1168 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1169 return TTS_ERROR_INVALID_PARAMETER;
1171 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1173 /* save texts for repetition */
1174 if (NULL != client->text_repeat) {
1175 free(client->text_repeat);
1176 client->text_repeat = NULL;
1179 client->text_repeat = strdup(text);
1181 if (NULL != g_language) {
1185 if (NULL == language)
1188 g_language = strdup(language);
1190 g_voice_type = voice_type;
1193 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);
1195 /* change default language value */
1198 if (NULL == language)
1199 temp = strdup("default");
1201 temp = strdup(language);
1203 client->current_utt_id++;
1204 if (client->current_utt_id == 10000) {
1205 client->current_utt_id = 1;
1211 bool is_prepared = false;
1213 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1216 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1217 client->current_state = TTS_STATE_CREATED;
1218 if (0 == tts_prepare_sync(tts)) {
1220 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1222 } else if (TTS_ERROR_TIMED_OUT != ret) {
1223 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1226 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1229 if (TTS_RETRY_MIN_COUNT == count) {
1230 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1236 *utt_id = client->current_utt_id;
1245 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1251 static void __tts_play_async(void *data)
1253 tts_h tts = (tts_h)data;
1254 tts_client_s* client = tts_client_get(tts);
1257 if (NULL == client) {
1258 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1264 bool is_prepared = false;
1266 ret = tts_dbus_request_play(client->uid, client->credential);
1268 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1269 client->current_state = TTS_STATE_CREATED;
1270 if (0 == tts_prepare_sync(tts)) {
1272 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1274 } else if (TTS_ERROR_TIMED_OUT != ret) {
1275 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1278 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1281 if (TTS_RETRY_COUNT == count) {
1282 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1290 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1292 client->reason = ret;
1293 client->utt_id = -1;
1295 ecore_timer_add(0, __tts_notify_error, client->tts);
1299 client->before_state = client->current_state;
1300 client->current_state = TTS_STATE_PLAYING;
1302 if (NULL != client->state_changed_cb) {
1303 tts_client_use_callback(client);
1304 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1305 tts_client_not_use_callback(client);
1306 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1309 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1314 int tts_play_async(tts_h tts)
1316 if (0 != __tts_get_feature_enabled()) {
1317 return TTS_ERROR_NOT_SUPPORTED;
1320 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1323 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1324 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1325 return TTS_ERROR_INVALID_PARAMETER;
1328 tts_client_s* client = tts_client_get(tts);
1330 if (NULL == client) {
1331 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1332 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1333 return TTS_ERROR_INVALID_PARAMETER;
1336 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1337 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1338 return TTS_ERROR_INVALID_STATE;
1341 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1342 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1343 return TTS_ERROR_INVALID_STATE;
1346 if (true == client->credential_needed && NULL == client->credential) {
1347 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1348 return TTS_ERROR_PERMISSION_DENIED;
1351 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1353 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1355 return TTS_ERROR_NONE;
1358 int tts_play(tts_h tts)
1360 if (0 != __tts_get_feature_enabled()) {
1361 return TTS_ERROR_NOT_SUPPORTED;
1364 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1367 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1368 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1369 return TTS_ERROR_INVALID_PARAMETER;
1372 tts_client_s* client = tts_client_get(tts);
1374 if (NULL == client) {
1375 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1376 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1377 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1378 return TTS_ERROR_INVALID_PARAMETER;
1381 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1382 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1383 return TTS_ERROR_INVALID_STATE;
1386 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1387 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1388 return TTS_ERROR_INVALID_STATE;
1391 if (true == client->credential_needed && NULL == client->credential) {
1392 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1393 return TTS_ERROR_PERMISSION_DENIED;
1398 bool is_prepared = false;
1400 ret = tts_dbus_request_play(client->uid, client->credential);
1403 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1404 client->current_state = TTS_STATE_CREATED;
1405 if (0 == tts_prepare_sync(tts)) {
1407 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1409 } else if (TTS_ERROR_TIMED_OUT != ret) {
1410 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1413 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1416 if (TTS_RETRY_COUNT == count) {
1417 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1425 client->before_state = client->current_state;
1426 client->current_state = TTS_STATE_PLAYING;
1428 if (NULL != client->state_changed_cb) {
1429 tts_client_use_callback(client);
1430 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1431 tts_client_not_use_callback(client);
1432 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1435 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1437 return TTS_ERROR_NONE;
1440 static void __tts_stop_async(void *data)
1442 tts_h tts = (tts_h)data;
1443 tts_client_s* client = tts_client_get(tts);
1446 if (NULL == client) {
1447 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1453 bool is_prepared = false;
1455 ret = tts_dbus_request_stop(client->uid);
1457 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1458 client->current_state = TTS_STATE_CREATED;
1459 if (0 == tts_prepare_sync(tts)) {
1461 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1463 } else if (TTS_ERROR_TIMED_OUT != ret) {
1464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1467 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1470 if (TTS_RETRY_COUNT == count) {
1471 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1481 client->reason = ret;
1482 client->utt_id = -1;
1484 ecore_timer_add(0, __tts_notify_error, client->tts);
1488 client->before_state = client->current_state;
1489 client->current_state = TTS_STATE_READY;
1491 if (NULL != client->state_changed_cb) {
1492 tts_client_use_callback(client);
1493 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1494 tts_client_not_use_callback(client);
1495 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1498 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1503 int tts_stop_aync(tts_h tts)
1505 if (0 != __tts_get_feature_enabled()) {
1506 return TTS_ERROR_NOT_SUPPORTED;
1509 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1512 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1513 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1514 return TTS_ERROR_INVALID_PARAMETER;
1517 tts_client_s* client = tts_client_get(tts);
1519 if (NULL == client) {
1520 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1521 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1522 return TTS_ERROR_INVALID_PARAMETER;
1525 if (TTS_STATE_CREATED == client->current_state) {
1526 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1527 return TTS_ERROR_INVALID_STATE;
1530 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1531 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1532 return TTS_ERROR_INVALID_STATE;
1535 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1537 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1539 return TTS_ERROR_NONE;
1542 int tts_stop(tts_h tts)
1544 if (0 != __tts_get_feature_enabled()) {
1545 return TTS_ERROR_NOT_SUPPORTED;
1548 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1551 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1552 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1553 return TTS_ERROR_INVALID_PARAMETER;
1556 tts_client_s* client = tts_client_get(tts);
1558 if (NULL == client) {
1559 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1560 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1561 return TTS_ERROR_INVALID_PARAMETER;
1564 if (TTS_STATE_CREATED == client->current_state) {
1565 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1566 return TTS_ERROR_INVALID_STATE;
1569 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1570 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1571 return TTS_ERROR_INVALID_STATE;
1576 bool is_prepared = false;
1578 ret = tts_dbus_request_stop(client->uid);
1581 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1582 client->current_state = TTS_STATE_CREATED;
1583 if (0 == tts_prepare_sync(tts)) {
1585 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1587 } else if (TTS_ERROR_TIMED_OUT != ret) {
1588 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1591 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1594 if (TTS_RETRY_COUNT == count) {
1595 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1603 client->before_state = client->current_state;
1604 client->current_state = TTS_STATE_READY;
1606 if (NULL != client->state_changed_cb) {
1607 tts_client_use_callback(client);
1608 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1609 tts_client_not_use_callback(client);
1610 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1613 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1615 return TTS_ERROR_NONE;
1618 static void __tts_pause_async(void *data)
1620 tts_h tts = (tts_h)data;
1621 tts_client_s* client = tts_client_get(tts);
1624 if (NULL == client) {
1625 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1631 bool is_prepared = false;
1633 ret = tts_dbus_request_pause(client->uid);
1635 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1636 client->current_state = TTS_STATE_CREATED;
1637 if (0 == tts_prepare_sync(tts)) {
1639 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1641 } else if (TTS_ERROR_TIMED_OUT != ret) {
1642 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1645 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1648 if (TTS_RETRY_COUNT == count) {
1649 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1659 client->reason = ret;
1660 client->utt_id = -1;
1662 ecore_timer_add(0, __tts_notify_error, client->tts);
1666 client->before_state = client->current_state;
1667 client->current_state = TTS_STATE_PAUSED;
1669 if (NULL != client->state_changed_cb) {
1670 tts_client_use_callback(client);
1671 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1672 tts_client_not_use_callback(client);
1673 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1676 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1681 int tts_pause_async(tts_h tts)
1683 if (0 != __tts_get_feature_enabled()) {
1684 return TTS_ERROR_NOT_SUPPORTED;
1687 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1690 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1691 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1692 return TTS_ERROR_INVALID_PARAMETER;
1695 tts_client_s* client = tts_client_get(tts);
1697 if (NULL == client) {
1698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1699 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1700 return TTS_ERROR_INVALID_PARAMETER;
1703 if (TTS_STATE_PLAYING != client->current_state) {
1704 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1705 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1706 return TTS_ERROR_INVALID_STATE;
1709 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1710 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1711 return TTS_ERROR_INVALID_STATE;
1714 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1716 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1718 return TTS_ERROR_NONE;
1721 int tts_pause(tts_h tts)
1723 if (0 != __tts_get_feature_enabled()) {
1724 return TTS_ERROR_NOT_SUPPORTED;
1727 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1730 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1731 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1732 return TTS_ERROR_INVALID_PARAMETER;
1735 tts_client_s* client = tts_client_get(tts);
1737 if (NULL == client) {
1738 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1739 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1740 return TTS_ERROR_INVALID_PARAMETER;
1743 if (TTS_STATE_PLAYING != client->current_state) {
1744 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1745 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1746 return TTS_ERROR_INVALID_STATE;
1749 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1750 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1751 return TTS_ERROR_INVALID_STATE;
1756 bool is_prepared = false;
1758 ret = tts_dbus_request_pause(client->uid);
1761 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1762 client->current_state = TTS_STATE_CREATED;
1763 if (0 == tts_prepare_sync(tts)) {
1765 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1767 } else if (TTS_ERROR_TIMED_OUT != ret) {
1768 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1771 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1774 if (TTS_RETRY_COUNT == count) {
1775 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1783 client->before_state = client->current_state;
1784 client->current_state = TTS_STATE_PAUSED;
1786 if (NULL != client->state_changed_cb) {
1787 tts_client_use_callback(client);
1788 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1789 tts_client_not_use_callback(client);
1790 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1793 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1795 return TTS_ERROR_NONE;
1798 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1800 if (0 != __tts_get_feature_enabled()) {
1801 return TTS_ERROR_NOT_SUPPORTED;
1804 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1807 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1808 return TTS_ERROR_INVALID_PARAMETER;
1811 if (NULL == key || NULL == data) {
1812 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1813 return TTS_ERROR_INVALID_PARAMETER;
1816 tts_client_s* client = tts_client_get(tts);
1818 if (NULL == client) {
1819 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1820 return TTS_ERROR_INVALID_PARAMETER;
1823 if (TTS_STATE_READY != client->current_state) {
1824 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1825 return TTS_ERROR_INVALID_STATE;
1828 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1829 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1830 return TTS_ERROR_INVALID_PARAMETER;
1835 bool is_prepared = false;
1837 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1840 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1841 client->current_state = TTS_STATE_CREATED;
1842 if (0 == tts_prepare_sync(tts)) {
1844 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1846 } else if (TTS_ERROR_TIMED_OUT != ret) {
1847 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1850 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1853 if (TTS_RETRY_COUNT == count) {
1854 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1862 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1867 int tts_get_private_data(tts_h tts, const char* key, char** data)
1869 if (0 != __tts_get_feature_enabled()) {
1870 return TTS_ERROR_NOT_SUPPORTED;
1873 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1876 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1877 return TTS_ERROR_INVALID_PARAMETER;
1880 if (NULL == key || NULL == data) {
1881 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1882 return TTS_ERROR_INVALID_PARAMETER;
1885 tts_client_s* client = tts_client_get(tts);
1887 if (NULL == client) {
1888 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1889 return TTS_ERROR_INVALID_PARAMETER;
1892 if (TTS_STATE_READY != client->current_state) {
1893 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1894 return TTS_ERROR_INVALID_STATE;
1899 bool is_prepared = false;
1901 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1904 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1905 client->current_state = TTS_STATE_CREATED;
1906 if (0 == tts_prepare_sync(tts)) {
1908 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1910 } else if (TTS_ERROR_TIMED_OUT != ret) {
1911 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1914 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1917 if (TTS_RETRY_COUNT == count) {
1918 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1926 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1931 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1937 static Eina_Bool __tts_notify_error(void *data)
1939 tts_h tts = (tts_h)data;
1941 tts_client_s* client = tts_client_get(tts);
1944 if (NULL == client) {
1945 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1949 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1951 if (NULL != client->error_cb) {
1952 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1953 tts_client_use_callback(client);
1954 g_err_callback_status = true;
1955 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1956 g_err_callback_status = false;
1957 tts_client_not_use_callback(client);
1959 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1965 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1968 GList* client_list = NULL;
1969 client_list = tts_client_get_client_list();
1972 tts_client_s *data = NULL;
1974 if (g_list_length(client_list) > 0) {
1975 /* Get a first item */
1976 iter = g_list_first(client_list);
1978 while (NULL != iter) {
1981 data->utt_id = utt_id;
1982 data->reason = reason;
1983 if (NULL != data->err_msg) {
1984 free(data->err_msg);
1985 data->err_msg = NULL;
1987 if (NULL != err_msg)
1988 data->err_msg = strdup(err_msg);
1990 /* call callback function */
1991 if (NULL != data->error_cb) {
1992 ecore_timer_add(0, __tts_notify_error, data->tts);
1994 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1997 if (TTS_ERROR_SERVICE_RESET == reason) {
1998 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2000 data->current_state = TTS_STATE_CREATED;
2001 if (0 != tts_prepare(data->tts)) {
2002 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2007 iter = g_list_next(iter);
2011 tts_client_s* client = tts_client_get_by_uid(uid);
2013 if (NULL == client) {
2014 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2015 return TTS_ERROR_INVALID_PARAMETER;
2018 client->utt_id = utt_id;
2019 client->reason = reason;
2020 if (NULL != client->err_msg) {
2021 free(client->err_msg);
2022 client->err_msg = NULL;
2024 if (NULL != err_msg)
2025 client->err_msg = strdup(err_msg);
2027 /* call callback function */
2028 if (NULL != client->error_cb) {
2029 ecore_timer_add(0, __tts_notify_error, client->tts);
2031 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2034 if (TTS_ERROR_SERVICE_RESET == reason) {
2035 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2037 client->current_state = TTS_STATE_CREATED;
2038 if (0 != tts_prepare(client->tts)) {
2039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2047 static Eina_Bool __tts_notify_state_changed(void *data)
2049 tts_h tts = (tts_h)data;
2051 tts_client_s* client = tts_client_get(tts);
2054 if (NULL == client) {
2055 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2059 if (NULL != client->state_changed_cb) {
2060 tts_client_use_callback(client);
2061 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2062 tts_client_not_use_callback(client);
2063 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2065 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2071 int __tts_cb_set_state(int uid, int state)
2073 tts_client_s* client = tts_client_get_by_uid(uid);
2074 if (NULL == client) {
2075 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2079 tts_state_e state_from_daemon = (tts_state_e)state;
2081 if (client->current_state == state_from_daemon) {
2082 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2086 if (NULL != client->state_changed_cb) {
2087 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2089 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2092 client->before_state = client->current_state;
2093 client->current_state = state_from_daemon;
2099 int __tts_cb_utt_started(int uid, int utt_id)
2101 tts_client_s* client = tts_client_get_by_uid(uid);
2103 if (NULL == client) {
2104 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2105 return TTS_ERROR_INVALID_PARAMETER;
2108 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2110 client->utt_id = utt_id;
2112 /* call callback function */
2113 if (NULL != client->utt_started_cb) {
2114 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2115 tts_client_use_callback(client);
2116 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2117 tts_client_not_use_callback(client);
2119 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2125 int __tts_cb_utt_completed(int uid, int utt_id)
2127 tts_client_s* client = tts_client_get_by_uid(uid);
2129 if (NULL == client) {
2130 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2131 return TTS_ERROR_INVALID_PARAMETER;
2134 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2136 client->utt_id = utt_id;
2138 /* call callback function */
2139 if (NULL != client->utt_completeted_cb) {
2140 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2141 tts_client_use_callback(client);
2142 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2143 tts_client_not_use_callback(client);
2145 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2151 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2153 if (0 != __tts_get_feature_enabled()) {
2154 return TTS_ERROR_NOT_SUPPORTED;
2157 if (NULL == tts || NULL == callback) {
2158 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2159 return TTS_ERROR_INVALID_PARAMETER;
2162 tts_client_s* client = tts_client_get(tts);
2164 if (NULL == client) {
2165 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2166 return TTS_ERROR_INVALID_PARAMETER;
2169 if (TTS_STATE_CREATED != client->current_state) {
2170 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2171 return TTS_ERROR_INVALID_STATE;
2174 client->state_changed_cb = callback;
2175 client->state_changed_user_data = user_data;
2177 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2182 int tts_unset_state_changed_cb(tts_h tts)
2184 if (0 != __tts_get_feature_enabled()) {
2185 return TTS_ERROR_NOT_SUPPORTED;
2189 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2190 return TTS_ERROR_INVALID_PARAMETER;
2193 tts_client_s* client = tts_client_get(tts);
2195 if (NULL == client) {
2196 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2197 return TTS_ERROR_INVALID_PARAMETER;
2200 if (TTS_STATE_CREATED != client->current_state) {
2201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2202 return TTS_ERROR_INVALID_STATE;
2205 client->state_changed_cb = NULL;
2206 client->state_changed_user_data = NULL;
2208 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2213 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2215 if (0 != __tts_get_feature_enabled()) {
2216 return TTS_ERROR_NOT_SUPPORTED;
2219 if (NULL == tts || NULL == callback) {
2220 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2221 return TTS_ERROR_INVALID_PARAMETER;
2224 tts_client_s* client = tts_client_get(tts);
2226 if (NULL == client) {
2227 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2228 return TTS_ERROR_INVALID_PARAMETER;
2231 if (TTS_STATE_CREATED != client->current_state) {
2232 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2233 return TTS_ERROR_INVALID_STATE;
2236 client->utt_started_cb = callback;
2237 client->utt_started_user_data = user_data;
2239 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2244 int tts_unset_utterance_started_cb(tts_h tts)
2246 if (0 != __tts_get_feature_enabled()) {
2247 return TTS_ERROR_NOT_SUPPORTED;
2251 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2252 return TTS_ERROR_INVALID_PARAMETER;
2255 tts_client_s* client = tts_client_get(tts);
2257 if (NULL == client) {
2258 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2259 return TTS_ERROR_INVALID_PARAMETER;
2262 if (TTS_STATE_CREATED != client->current_state) {
2263 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2264 return TTS_ERROR_INVALID_STATE;
2267 client->utt_started_cb = NULL;
2268 client->utt_started_user_data = NULL;
2270 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2275 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2277 if (0 != __tts_get_feature_enabled()) {
2278 return TTS_ERROR_NOT_SUPPORTED;
2281 if (NULL == tts || NULL == callback) {
2282 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2283 return TTS_ERROR_INVALID_PARAMETER;
2286 tts_client_s* client = tts_client_get(tts);
2288 if (NULL == client) {
2289 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2290 return TTS_ERROR_INVALID_PARAMETER;
2293 if (TTS_STATE_CREATED != client->current_state) {
2294 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2295 return TTS_ERROR_INVALID_STATE;
2298 client->utt_completeted_cb = callback;
2299 client->utt_completed_user_data = user_data;
2301 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2306 int tts_unset_utterance_completed_cb(tts_h tts)
2308 if (0 != __tts_get_feature_enabled()) {
2309 return TTS_ERROR_NOT_SUPPORTED;
2313 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2314 return TTS_ERROR_INVALID_PARAMETER;
2317 tts_client_s* client = tts_client_get(tts);
2319 if (NULL == client) {
2320 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2321 return TTS_ERROR_INVALID_PARAMETER;
2324 if (TTS_STATE_CREATED != client->current_state) {
2325 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2326 return TTS_ERROR_INVALID_STATE;
2329 client->utt_completeted_cb = NULL;
2330 client->utt_completed_user_data = NULL;
2332 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2336 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2338 if (0 != __tts_get_feature_enabled()) {
2339 return TTS_ERROR_NOT_SUPPORTED;
2342 if (NULL == tts || NULL == callback) {
2343 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2344 return TTS_ERROR_INVALID_PARAMETER;
2347 tts_client_s* client = tts_client_get(tts);
2349 if (NULL == client) {
2350 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2351 return TTS_ERROR_INVALID_PARAMETER;
2354 if (TTS_STATE_CREATED != client->current_state) {
2355 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2356 return TTS_ERROR_INVALID_STATE;
2359 client->error_cb = callback;
2360 client->error_user_data = user_data;
2362 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2367 int tts_unset_error_cb(tts_h tts)
2369 if (0 != __tts_get_feature_enabled()) {
2370 return TTS_ERROR_NOT_SUPPORTED;
2374 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2375 return TTS_ERROR_INVALID_PARAMETER;
2378 tts_client_s* client = tts_client_get(tts);
2380 if (NULL == client) {
2381 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2382 return TTS_ERROR_INVALID_PARAMETER;
2385 if (TTS_STATE_CREATED != client->current_state) {
2386 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2387 return TTS_ERROR_INVALID_STATE;
2390 client->error_cb = NULL;
2391 client->error_user_data = NULL;
2393 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2398 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2400 if (0 != __tts_get_feature_enabled()) {
2401 return TTS_ERROR_NOT_SUPPORTED;
2404 if (NULL == tts || NULL == callback) {
2405 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2406 return TTS_ERROR_INVALID_PARAMETER;
2409 tts_client_s* client = tts_client_get(tts);
2411 if (NULL == client) {
2412 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2413 return TTS_ERROR_INVALID_PARAMETER;
2416 if (TTS_STATE_CREATED != client->current_state) {
2417 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2418 return TTS_ERROR_INVALID_STATE;
2421 client->default_voice_changed_cb = callback;
2422 client->default_voice_changed_user_data = user_data;
2424 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2429 int tts_unset_default_voice_changed_cb(tts_h tts)
2431 if (0 != __tts_get_feature_enabled()) {
2432 return TTS_ERROR_NOT_SUPPORTED;
2436 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2437 return TTS_ERROR_INVALID_PARAMETER;
2440 tts_client_s* client = tts_client_get(tts);
2442 if (NULL == client) {
2443 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2444 return TTS_ERROR_INVALID_PARAMETER;
2447 if (TTS_STATE_CREATED != client->current_state) {
2448 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2449 return TTS_ERROR_INVALID_STATE;
2452 client->default_voice_changed_cb = NULL;
2453 client->default_voice_changed_user_data = NULL;
2455 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2460 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2462 if (0 != __tts_get_feature_enabled()) {
2463 return TTS_ERROR_NOT_SUPPORTED;
2466 if (NULL == tts || NULL == callback) {
2467 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2468 return TTS_ERROR_INVALID_PARAMETER;
2471 tts_client_s* client = tts_client_get(tts);
2473 if (NULL == client) {
2474 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2475 return TTS_ERROR_INVALID_PARAMETER;
2478 if (TTS_STATE_CREATED != client->current_state) {
2479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2480 return TTS_ERROR_INVALID_STATE;
2483 client->engine_changed_cb = callback;
2484 client->engine_changed_user_data = user_data;
2486 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2491 int tts_unset_engine_changed_cb(tts_h tts)
2493 if (0 != __tts_get_feature_enabled()) {
2494 return TTS_ERROR_NOT_SUPPORTED;
2498 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2499 return TTS_ERROR_INVALID_PARAMETER;
2502 tts_client_s* client = tts_client_get(tts);
2504 if (NULL == client) {
2505 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2506 return TTS_ERROR_INVALID_PARAMETER;
2509 if (TTS_STATE_CREATED != client->current_state) {
2510 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2511 return TTS_ERROR_INVALID_STATE;
2514 client->engine_changed_cb = NULL;
2515 client->engine_changed_user_data = NULL;
2517 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2523 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2525 if (0 != __tts_get_feature_enabled()) {
2526 return TTS_ERROR_NOT_SUPPORTED;
2529 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2532 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2533 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2534 return TTS_ERROR_INVALID_PARAMETER;
2537 tts_client_s* client = tts_client_get(tts);
2539 if (NULL == client) {
2540 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2541 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2542 return TTS_ERROR_INVALID_PARAMETER;
2545 if (TTS_STATE_CREATED == client->current_state) {
2546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2547 return TTS_ERROR_INVALID_STATE;
2550 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2551 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2552 return TTS_ERROR_INVALID_STATE;
2557 bool is_prepared = false;
2559 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2561 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2562 client->current_state = TTS_STATE_CREATED;
2563 if (0 == tts_prepare_sync(tts)) {
2565 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2567 } else if (TTS_ERROR_TIMED_OUT != ret) {
2568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2571 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2574 if (TTS_RETRY_COUNT == count) {
2575 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2582 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2584 return TTS_ERROR_NONE;
2587 int tts_play_pcm(tts_h tts)
2589 if (0 != __tts_get_feature_enabled()) {
2590 return TTS_ERROR_NOT_SUPPORTED;
2593 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2596 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2597 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2598 return TTS_ERROR_INVALID_PARAMETER;
2601 tts_client_s* client = tts_client_get(tts);
2603 if (NULL == client) {
2604 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2605 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2606 return TTS_ERROR_INVALID_PARAMETER;
2609 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2610 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2611 return TTS_ERROR_INVALID_STATE;
2614 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2615 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2616 return TTS_ERROR_INVALID_STATE;
2621 bool is_prepared = false;
2623 ret = tts_dbus_request_play_pcm(client->uid);
2625 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2626 client->current_state = TTS_STATE_CREATED;
2627 if (0 == tts_prepare_sync(tts)) {
2629 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2631 } else if (TTS_ERROR_TIMED_OUT != ret) {
2632 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2635 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2638 if (TTS_RETRY_COUNT == count) {
2639 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2646 client->before_state = client->current_state;
2647 client->current_state = TTS_STATE_PLAYING;
2649 if (NULL != client->state_changed_cb) {
2650 tts_client_use_callback(client);
2651 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2652 tts_client_not_use_callback(client);
2653 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2656 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2658 return TTS_ERROR_NONE;
2661 int tts_stop_pcm(tts_h tts)
2663 if (0 != __tts_get_feature_enabled()) {
2664 return TTS_ERROR_NOT_SUPPORTED;
2667 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2670 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2671 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2672 return TTS_ERROR_INVALID_PARAMETER;
2675 tts_client_s* client = tts_client_get(tts);
2677 if (NULL == client) {
2678 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2679 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2680 return TTS_ERROR_INVALID_PARAMETER;
2683 if (TTS_STATE_CREATED == client->current_state) {
2684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2685 return TTS_ERROR_INVALID_STATE;
2688 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2689 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2690 return TTS_ERROR_INVALID_STATE;
2695 bool is_prepared = false;
2697 ret = tts_dbus_request_stop_pcm(client->uid);
2699 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2700 client->current_state = TTS_STATE_CREATED;
2701 if (0 == tts_prepare_sync(tts)) {
2703 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2705 } else if (TTS_ERROR_TIMED_OUT != ret) {
2706 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2709 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2712 if (TTS_RETRY_COUNT == count) {
2713 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2720 client->before_state = client->current_state;
2721 client->current_state = TTS_STATE_READY;
2723 if (NULL != client->state_changed_cb) {
2724 tts_client_use_callback(client);
2725 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2726 tts_client_not_use_callback(client);
2727 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2730 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2732 return TTS_ERROR_NONE;
2736 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
2738 if (0 != __tts_get_feature_enabled()) {
2739 return TTS_ERROR_NOT_SUPPORTED;
2742 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
2745 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2746 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2747 return TTS_ERROR_INVALID_PARAMETER;
2750 if (NULL == text_repeat || NULL == utt_id) {
2751 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
2752 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2753 return TTS_ERROR_INVALID_PARAMETER;
2756 *text_repeat = NULL;
2759 tts_client_s* client = tts_client_get(tts);
2761 if (NULL == client) {
2762 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2763 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2764 return TTS_ERROR_INVALID_PARAMETER;
2767 if (TTS_STATE_READY != client->current_state) {
2768 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
2769 return TTS_ERROR_INVALID_STATE;
2772 /* Clear the legacy and Add texts to be played repeatedly */
2774 ret = tts_stop(tts);
2775 if (TTS_ERROR_NONE != ret) {
2776 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
2780 if (NULL != client->text_repeat) {
2781 char* tmp_text = strdup(client->text_repeat);
2782 char* tmp_lang = NULL;
2783 if (NULL != g_language) {
2784 tmp_lang = strdup(g_language);
2786 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
2787 if (TTS_ERROR_NONE != ret) {
2788 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
2789 if (NULL != tmp_text) {
2793 if (NULL != tmp_lang) {
2799 *text_repeat = strdup(client->text_repeat);
2800 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
2801 if (NULL != tmp_text) {
2805 if (NULL != tmp_lang) {
2810 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
2811 return TTS_ERROR_OPERATION_FAILED;
2814 /* Play added texts */
2815 ret = tts_play(tts);
2816 if (TTS_ERROR_NONE != ret) {
2817 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
2818 if (NULL != *text_repeat) {
2820 *text_repeat = NULL;
2826 return TTS_ERROR_NONE;