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;
40 static Ecore_Timer* g_check_state_timer = NULL;
44 static char* g_language = NULL;
46 static int g_voice_type = -1;
48 static int g_speed = -1;
51 /* Function definition */
52 static Eina_Bool __tts_notify_state_changed(void *data);
53 static Eina_Bool __tts_notify_error(void *data);
60 static int __tts_get_feature_enabled()
62 if (0 == g_feature_enabled) {
63 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
64 return TTS_ERROR_NOT_SUPPORTED;
65 } else if (-1 == g_feature_enabled) {
66 bool tts_supported = false;
67 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
68 if (false == tts_supported) {
69 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
70 g_feature_enabled = 0;
71 return TTS_ERROR_NOT_SUPPORTED;
74 g_feature_enabled = 1;
76 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
77 return TTS_ERROR_NOT_SUPPORTED;
84 static const char* __tts_get_error_code(tts_error_e err)
87 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
88 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
89 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
90 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
91 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
92 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
93 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
94 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
95 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
96 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
97 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
98 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
99 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
100 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
101 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
103 return "Invalid error code";
108 static int __tts_convert_config_error_code(tts_config_error_e code)
110 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
111 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
112 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
113 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
114 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
115 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
116 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
117 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
118 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
124 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)
126 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
127 before_lang, before_voice_type, language, voice_type);
129 GList* client_list = NULL;
130 client_list = tts_client_get_client_list();
133 tts_client_s *data = NULL;
135 if (g_list_length(client_list) > 0) {
136 /* Get a first item */
137 iter = g_list_first(client_list);
139 while (NULL != iter) {
141 if (NULL != data->default_voice_changed_cb) {
142 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
143 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
144 language, voice_type, data->default_voice_changed_user_data);
147 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
148 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
149 if (NULL != data->text_repeat) {
150 free(data->text_repeat);
151 data->text_repeat = NULL;
156 iter = g_list_next(iter);
163 static Eina_Bool __reconnect_by_engine_changed(void* data)
165 tts_h tts = (tts_h)data;
167 tts_client_s* client = tts_client_get(tts);
168 if (NULL == client) {
169 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
173 if (TTS_STATE_READY != client->current_state) {
178 int ret = tts_unprepare(tts);
180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
182 ret = tts_prepare(tts);
184 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
190 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)
192 tts_h tts = (tts_h)user_data;
194 tts_client_s* client = tts_client_get(tts);
195 if (NULL == client) {
196 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
200 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
201 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
202 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
203 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
205 /* When the default engine is changed, please unload the old engine and load the new one. */
208 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
211 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
214 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
215 } else if (TTS_STATE_READY == client->current_state) {
216 ret = tts_unprepare(tts);
218 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
220 ret = tts_prepare(tts);
222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
226 /* call callback function */
227 if (NULL != client->engine_changed_cb) {
228 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
230 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
236 int tts_create(tts_h* tts)
238 if (0 != __tts_get_feature_enabled()) {
239 return TTS_ERROR_NOT_SUPPORTED;
242 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
246 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
247 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
248 return TTS_ERROR_INVALID_PARAMETER;
251 if (0 == tts_client_get_size()) {
252 if (0 != tts_dbus_open_connection()) {
253 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
254 return TTS_ERROR_OPERATION_FAILED;
258 if (0 != tts_client_new(tts)) {
259 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
260 return TTS_ERROR_OUT_OF_MEMORY;
263 tts_client_s* client = tts_client_get(*tts);
264 if (NULL == client) {
265 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
266 return TTS_ERROR_OPERATION_FAILED;
269 int ret = tts_config_mgr_initialize(client->uid);
271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
272 tts_client_destroy(*tts);
273 return __tts_convert_config_error_code(ret);
276 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
278 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
279 tts_client_destroy(*tts);
280 return __tts_convert_config_error_code(ret);
283 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
284 SLOG(LOG_DEBUG, TAG_TTSC, " ");
286 return TTS_ERROR_NONE;
289 int tts_destroy(tts_h tts)
291 if (0 != __tts_get_feature_enabled()) {
292 return TTS_ERROR_NOT_SUPPORTED;
295 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
299 return TTS_ERROR_INVALID_PARAMETER;
302 tts_client_s* client = tts_client_get(tts);
305 if (NULL == client) {
306 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
307 return TTS_ERROR_INVALID_PARAMETER;
310 /* check used callback */
311 if (0 != tts_client_get_use_callback(client)) {
312 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
313 return TTS_ERROR_OPERATION_FAILED;
316 tts_config_mgr_finalize(client->uid);
320 int screen_reader = -1;
323 switch (client->current_state) {
324 case TTS_STATE_PAUSED:
325 case TTS_STATE_PLAYING:
326 case TTS_STATE_READY:
327 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
329 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
331 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);
332 g_screen_reader = (bool)screen_reader;
334 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
336 ret = tts_dbus_request_finalize(client->uid);
339 if (TTS_ERROR_TIMED_OUT != ret) {
340 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
343 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
346 if (TTS_RETRY_COUNT == count) {
347 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
355 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
358 client->before_state = client->current_state;
359 client->current_state = TTS_STATE_CREATED;
361 case TTS_STATE_CREATED:
362 if (NULL != client->conn_timer) {
363 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
364 ecore_timer_del(client->conn_timer);
365 client->conn_timer = NULL;
368 tts_client_destroy(tts);
375 if (0 == tts_client_get_size()) {
376 if (0 != tts_dbus_close_connection()) {
377 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
381 if (NULL != g_language) {
386 /* Delete state timer before destroying handle */
387 if (NULL != g_check_state_timer) {
388 ecore_timer_del(g_check_state_timer);
389 g_check_state_timer = NULL;
394 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
396 return TTS_ERROR_NONE;
400 void __tts_screen_reader_changed_cb(bool value)
402 g_screen_reader = value;
406 int tts_set_mode(tts_h tts, tts_mode_e mode)
408 if (0 != __tts_get_feature_enabled()) {
409 return TTS_ERROR_NOT_SUPPORTED;
412 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
414 tts_client_s* client = tts_client_get(tts);
417 if (NULL == client) {
418 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
419 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
420 return TTS_ERROR_INVALID_PARAMETER;
424 if (client->current_state != TTS_STATE_CREATED) {
425 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
426 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
427 SLOG(LOG_DEBUG, TAG_TTSC, " ");
428 return TTS_ERROR_INVALID_STATE;
431 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
434 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
435 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
436 SLOG(LOG_DEBUG, TAG_TTSC, " ");
437 return TTS_ERROR_INVALID_PARAMETER;
440 if (TTS_MODE_SCREEN_READER == mode) {
443 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
445 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
446 return TTS_ERROR_OPERATION_FAILED;
448 g_screen_reader = (bool)screen_reader;
449 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
451 tts_config_unset_screen_reader_callback(client->uid);
454 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
456 return TTS_ERROR_NONE;
459 int tts_get_mode(tts_h tts, tts_mode_e* mode)
461 if (0 != __tts_get_feature_enabled()) {
462 return TTS_ERROR_NOT_SUPPORTED;
465 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
467 tts_client_s* client = tts_client_get(tts);
470 if (NULL == client) {
471 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
472 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
473 SLOG(LOG_DEBUG, TAG_TTSC, " ");
474 return TTS_ERROR_INVALID_PARAMETER;
478 if (client->current_state != TTS_STATE_CREATED) {
479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
480 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
481 SLOG(LOG_DEBUG, TAG_TTSC, " ");
482 return TTS_ERROR_INVALID_STATE;
486 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
487 return TTS_ERROR_INVALID_PARAMETER;
490 *mode = client->mode;
492 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
493 SLOG(LOG_DEBUG, TAG_TTSC, " ");
495 return TTS_ERROR_NONE;
498 int tts_set_credential(tts_h tts, const char* credential)
500 if (0 != __tts_get_feature_enabled()) {
501 return TTS_ERROR_NOT_SUPPORTED;
504 if (NULL == tts || NULL == credential) {
505 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
506 return TTS_ERROR_INVALID_PARAMETER;
509 tts_client_s* client = tts_client_get(tts);
511 if (NULL == client) {
512 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
513 return TTS_ERROR_INVALID_PARAMETER;
516 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
517 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
518 return TTS_ERROR_INVALID_STATE;
521 if (NULL != client->credential) {
522 free(client->credential);
523 client->credential = NULL;
525 client->credential = strdup(credential);
527 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
529 return TTS_ERROR_NONE;
533 int tts_set_server_tts(tts_h tts, const char* credential)
535 if (0 != __tts_get_feature_enabled()) {
536 return TTS_ERROR_NOT_SUPPORTED;
540 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
541 return TTS_ERROR_INVALID_PARAMETER;
544 tts_client_s* client = tts_client_get(tts);
546 if (NULL == client) {
547 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
548 return TTS_ERROR_INVALID_PARAMETER;
551 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
552 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
553 return TTS_ERROR_INVALID_STATE;
556 if (NULL != client->credential) {
557 free(client->credential);
558 client->credential = NULL;
561 client->internal = true;
564 if (NULL != credential) {
565 key = strdup("EnableServerTTS");
566 client->credential = strdup(credential);
567 if (NULL == client->credential) {
568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
573 return TTS_ERROR_OUT_OF_MEMORY;
576 key = strdup("DisableServerTTS");
580 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
581 return TTS_ERROR_OUT_OF_MEMORY;
586 int ret = app_manager_get_app_id(pid, &appid);
587 if (0 != ret || NULL == appid) {
588 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
595 return TTS_ERROR_OPERATION_FAILED;
598 ret = tts_set_private_data(tts, key, appid);
600 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
613 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
615 return TTS_ERROR_NONE;
619 static Eina_Bool __tts_connect_daemon(void *data)
621 tts_h tts = (tts_h)data;
622 tts_client_s* client = tts_client_get(tts);
625 if (NULL == client) {
626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
631 if (0 != tts_dbus_request_hello(client->uid)) {
635 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
637 /* do request initialize */
639 bool credential_needed = false;
641 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
643 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
644 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
646 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
649 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
650 client->conn_timer = NULL;
653 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
654 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
656 client->reason = TTS_ERROR_PERMISSION_DENIED;
659 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
660 client->conn_timer = NULL;
663 } else if (TTS_ERROR_NONE != ret) {
664 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
668 /* success to connect tts-daemon */
669 client->credential_needed = credential_needed;
670 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
673 client->conn_timer = NULL;
675 client = tts_client_get(tts);
677 if (NULL == client) {
678 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
682 client->before_state = client->current_state;
683 client->current_state = TTS_STATE_READY;
685 if (NULL != client->state_changed_cb) {
686 tts_client_use_callback(client);
687 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
688 tts_client_not_use_callback(client);
690 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
693 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
698 int tts_prepare(tts_h tts)
700 if (0 != __tts_get_feature_enabled()) {
701 return TTS_ERROR_NOT_SUPPORTED;
704 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
706 tts_client_s* client = tts_client_get(tts);
709 if (NULL == client) {
710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
711 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
712 return TTS_ERROR_INVALID_PARAMETER;
716 if (client->current_state != TTS_STATE_CREATED) {
717 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
718 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
719 return TTS_ERROR_INVALID_STATE;
722 ecore_thread_main_loop_begin();
723 client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
724 ecore_thread_main_loop_end();
726 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
728 return TTS_ERROR_NONE;
732 int tts_prepare_sync(tts_h tts)
734 if (0 != __tts_get_feature_enabled()) {
735 return TTS_ERROR_NOT_SUPPORTED;
738 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
740 tts_client_s* client = tts_client_get(tts);
743 if (NULL == client) {
744 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
745 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
746 return TTS_ERROR_INVALID_PARAMETER;
750 if (client->current_state != TTS_STATE_CREATED) {
751 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
752 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
753 return TTS_ERROR_INVALID_STATE;
757 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
761 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
763 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
764 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
765 return TTS_ERROR_OPERATION_FAILED;
768 return TTS_ERROR_NONE;
772 int tts_unprepare(tts_h tts)
774 if (0 != __tts_get_feature_enabled()) {
775 return TTS_ERROR_NOT_SUPPORTED;
778 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
780 tts_client_s* client = tts_client_get(tts);
783 if (NULL == client) {
784 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
785 return TTS_ERROR_INVALID_PARAMETER;
789 if (client->current_state != TTS_STATE_READY) {
790 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
791 return TTS_ERROR_INVALID_STATE;
796 int screen_reader = -1;
798 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
800 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
802 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);
803 g_screen_reader = (bool)screen_reader;
806 bool is_prepared = false;
807 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
809 ret = tts_dbus_request_finalize(client->uid);
812 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
813 client->current_state = TTS_STATE_CREATED;
814 if (0 == tts_prepare_sync(tts)) {
816 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
818 } else if (TTS_ERROR_TIMED_OUT != ret) {
819 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
822 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
825 if (TTS_RETRY_COUNT == count) {
826 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
834 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
837 client->before_state = client->current_state;
838 client->current_state = TTS_STATE_CREATED;
840 if (NULL != client->state_changed_cb) {
841 tts_client_use_callback(client);
842 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
843 tts_client_not_use_callback(client);
844 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
847 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
849 return TTS_ERROR_NONE;
852 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
854 tts_h tts = (tts_h)user_data;
856 tts_client_s* client = tts_client_get(tts);
857 if (NULL == client) {
858 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
862 /* call callback function */
863 if (NULL != client->supported_voice_cb) {
864 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
866 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
872 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
874 if (0 != __tts_get_feature_enabled()) {
875 return TTS_ERROR_NOT_SUPPORTED;
878 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
880 if (NULL == tts || NULL == callback) {
881 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
882 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
883 return TTS_ERROR_INVALID_PARAMETER;
886 tts_client_s* client = tts_client_get(tts);
889 if (NULL == client) {
890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
891 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
892 return TTS_ERROR_INVALID_PARAMETER;
896 char* current_engine = NULL;
897 ret = tts_config_mgr_get_engine(¤t_engine);
899 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
900 return __tts_convert_config_error_code(ret);
903 client->supported_voice_cb = callback;
904 client->supported_voice_user_data = user_data;
906 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
908 if (NULL != current_engine) {
909 free(current_engine);
910 current_engine = NULL;
913 client->supported_voice_cb = NULL;
914 client->supported_voice_user_data = NULL;
917 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
918 ret = TTS_ERROR_OPERATION_FAILED;
921 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
926 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
928 if (0 != __tts_get_feature_enabled()) {
929 return TTS_ERROR_NOT_SUPPORTED;
932 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
936 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
937 return TTS_ERROR_INVALID_PARAMETER;
940 tts_client_s* client = tts_client_get(tts);
942 if (NULL == client) {
943 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
944 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
945 return TTS_ERROR_INVALID_PARAMETER;
948 /* Request call remote method */
950 ret = tts_config_mgr_get_voice(lang, vctype);
952 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
953 return __tts_convert_config_error_code(ret);
955 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
958 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
963 int tts_get_max_text_size(tts_h tts, unsigned int* size)
965 if (0 != __tts_get_feature_enabled()) {
966 return TTS_ERROR_NOT_SUPPORTED;
969 if (NULL == tts || NULL == size) {
970 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
971 return TTS_ERROR_INVALID_PARAMETER;
974 tts_client_s* client = tts_client_get(tts);
976 if (NULL == client) {
977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
978 return TTS_ERROR_INVALID_PARAMETER;
981 if (TTS_STATE_READY != client->current_state) {
982 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
983 return TTS_ERROR_INVALID_STATE;
986 if (0 != tts_config_mgr_get_max_text_size(size)) {
987 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
988 return TTS_ERROR_INVALID_PARAMETER;
991 g_max_text_size = (int)*size;
993 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
994 return TTS_ERROR_NONE;
997 int tts_get_state(tts_h tts, tts_state_e* state)
999 if (0 != __tts_get_feature_enabled()) {
1000 return TTS_ERROR_NOT_SUPPORTED;
1003 if (NULL == tts || NULL == state) {
1004 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
1005 return TTS_ERROR_INVALID_PARAMETER;
1008 tts_client_s* client = tts_client_get(tts);
1010 if (NULL == client) {
1011 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1012 return TTS_ERROR_INVALID_PARAMETER;
1015 *state = client->current_state;
1018 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
1019 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
1020 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
1021 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
1022 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1025 return TTS_ERROR_NONE;
1028 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1030 if (0 != __tts_get_feature_enabled()) {
1031 return TTS_ERROR_NOT_SUPPORTED;
1034 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1035 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1036 return TTS_ERROR_INVALID_PARAMETER;
1039 tts_client_s* client = tts_client_get(tts);
1041 if (NULL == client) {
1042 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1043 return TTS_ERROR_INVALID_PARAMETER;
1046 *min = TTS_SPEED_MIN;
1047 *normal = TTS_SPEED_NORMAL;
1048 *max = TTS_SPEED_MAX;
1050 return TTS_ERROR_NONE;
1053 int tts_get_error_message(tts_h tts, char** err_msg)
1055 if (0 != __tts_get_feature_enabled()) {
1056 return TTS_ERROR_NOT_SUPPORTED;
1059 if (NULL == tts || NULL == err_msg) {
1060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1061 return TTS_ERROR_INVALID_PARAMETER;
1064 tts_client_s* client = tts_client_get(tts);
1066 if (NULL == client) {
1067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1068 return TTS_ERROR_INVALID_PARAMETER;
1071 if (NULL != client->err_msg) {
1072 *err_msg = strdup(client->err_msg);
1073 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1076 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1079 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1081 return TTS_ERROR_NONE;
1084 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1086 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1088 if (0 != __tts_get_feature_enabled()) {
1089 return TTS_ERROR_NOT_SUPPORTED;
1093 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1094 return TTS_ERROR_INVALID_PARAMETER;
1097 if (voice_type < 0) {
1098 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1099 return TTS_ERROR_INVALID_PARAMETER;
1102 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1104 if (NULL == tts || NULL == utt_id) {
1105 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1106 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1107 return TTS_ERROR_INVALID_PARAMETER;
1110 tts_client_s* client = tts_client_get(tts);
1112 if (NULL == client) {
1113 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1114 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1115 return TTS_ERROR_INVALID_PARAMETER;
1118 if (TTS_STATE_CREATED == client->current_state) {
1119 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1120 return TTS_ERROR_INVALID_STATE;
1123 if (-1 == g_max_text_size) {
1124 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1125 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1126 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1127 return TTS_ERROR_INVALID_PARAMETER;
1131 if (0 == g_max_text_size) {
1132 if (strlen(text) <= 0) {
1133 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1134 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1135 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1136 return TTS_ERROR_INVALID_PARAMETER;
1139 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1140 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1141 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1142 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1143 return TTS_ERROR_INVALID_PARAMETER;
1147 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1149 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1150 return TTS_ERROR_INVALID_PARAMETER;
1153 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1154 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1155 return TTS_ERROR_INVALID_STATE;
1158 if (true == client->credential_needed && NULL == client->credential) {
1159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1160 return TTS_ERROR_PERMISSION_DENIED;
1163 /* check valid utf8 */
1167 dbus_error_init(&err);
1169 valid = dbus_validate_utf8(text, &err);
1170 if (dbus_error_is_set(&err)) {
1171 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1172 dbus_error_free(&err);
1173 return TTS_ERROR_INVALID_PARAMETER;
1176 if (valid != true) {
1177 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1178 return TTS_ERROR_INVALID_PARAMETER;
1180 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1182 /* save texts for repetition */
1183 if (NULL != client->text_repeat) {
1184 free(client->text_repeat);
1185 client->text_repeat = NULL;
1188 client->text_repeat = strdup(text);
1190 if (NULL != g_language) {
1194 if (NULL == language)
1197 g_language = strdup(language);
1199 g_voice_type = voice_type;
1202 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);
1204 /* change default language value */
1207 if (NULL == language)
1208 temp = strdup("default");
1210 temp = strdup(language);
1212 client->current_utt_id++;
1213 if (client->current_utt_id == 10000) {
1214 client->current_utt_id = 1;
1220 bool is_prepared = false;
1222 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1225 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1226 client->current_state = TTS_STATE_CREATED;
1227 if (0 == tts_prepare_sync(tts)) {
1229 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1231 } else if (TTS_ERROR_TIMED_OUT != ret) {
1232 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1235 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1238 if (TTS_RETRY_MIN_COUNT == count) {
1239 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1245 *utt_id = client->current_utt_id;
1254 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1260 static void __tts_play_async(void *data)
1262 tts_h tts = (tts_h)data;
1263 tts_client_s* client = tts_client_get(tts);
1266 if (NULL == client) {
1267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1273 bool is_prepared = false;
1275 ret = tts_dbus_request_play(client->uid, client->credential);
1277 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1278 client->current_state = TTS_STATE_CREATED;
1279 if (0 == tts_prepare_sync(tts)) {
1281 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1283 } else if (TTS_ERROR_TIMED_OUT != ret) {
1284 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1287 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1290 if (TTS_RETRY_COUNT == count) {
1291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1299 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1301 client->reason = ret;
1302 client->utt_id = -1;
1304 ecore_timer_add(0, __tts_notify_error, client->tts);
1308 client->before_state = client->current_state;
1309 client->current_state = TTS_STATE_PLAYING;
1311 if (NULL != client->state_changed_cb) {
1312 tts_client_use_callback(client);
1313 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1314 tts_client_not_use_callback(client);
1315 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1318 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1323 int tts_play_async(tts_h tts)
1325 if (0 != __tts_get_feature_enabled()) {
1326 return TTS_ERROR_NOT_SUPPORTED;
1329 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1332 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1333 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1334 return TTS_ERROR_INVALID_PARAMETER;
1337 tts_client_s* client = tts_client_get(tts);
1339 if (NULL == client) {
1340 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1341 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1342 return TTS_ERROR_INVALID_PARAMETER;
1345 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1346 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1347 return TTS_ERROR_INVALID_STATE;
1350 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1351 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1352 return TTS_ERROR_INVALID_STATE;
1355 if (true == client->credential_needed && NULL == client->credential) {
1356 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1357 return TTS_ERROR_PERMISSION_DENIED;
1360 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1362 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1364 return TTS_ERROR_NONE;
1367 int tts_play(tts_h tts)
1369 if (0 != __tts_get_feature_enabled()) {
1370 return TTS_ERROR_NOT_SUPPORTED;
1373 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1376 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1377 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1378 return TTS_ERROR_INVALID_PARAMETER;
1381 tts_client_s* client = tts_client_get(tts);
1383 if (NULL == client) {
1384 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1385 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1386 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1387 return TTS_ERROR_INVALID_PARAMETER;
1390 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1391 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1392 return TTS_ERROR_INVALID_STATE;
1395 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1396 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1397 return TTS_ERROR_INVALID_STATE;
1400 if (true == client->credential_needed && NULL == client->credential) {
1401 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1402 return TTS_ERROR_PERMISSION_DENIED;
1407 bool is_prepared = false;
1409 ret = tts_dbus_request_play(client->uid, client->credential);
1412 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1413 client->current_state = TTS_STATE_CREATED;
1414 if (0 == tts_prepare_sync(tts)) {
1416 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1418 } else if (TTS_ERROR_TIMED_OUT != ret) {
1419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1422 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1425 if (TTS_RETRY_COUNT == count) {
1426 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1434 client->before_state = client->current_state;
1435 client->current_state = TTS_STATE_PLAYING;
1437 if (NULL != client->state_changed_cb) {
1438 tts_client_use_callback(client);
1439 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1440 tts_client_not_use_callback(client);
1441 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1444 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1446 return TTS_ERROR_NONE;
1449 static void __tts_stop_async(void *data)
1451 tts_h tts = (tts_h)data;
1452 tts_client_s* client = tts_client_get(tts);
1455 if (NULL == client) {
1456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1462 bool is_prepared = false;
1464 ret = tts_dbus_request_stop(client->uid);
1466 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1467 client->current_state = TTS_STATE_CREATED;
1468 if (0 == tts_prepare_sync(tts)) {
1470 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1472 } else if (TTS_ERROR_TIMED_OUT != ret) {
1473 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1476 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1479 if (TTS_RETRY_COUNT == count) {
1480 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1488 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1490 client->reason = ret;
1491 client->utt_id = -1;
1493 ecore_timer_add(0, __tts_notify_error, client->tts);
1497 client->before_state = client->current_state;
1498 client->current_state = TTS_STATE_READY;
1500 if (NULL != client->state_changed_cb) {
1501 tts_client_use_callback(client);
1502 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1503 tts_client_not_use_callback(client);
1504 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1507 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1512 int tts_stop_aync(tts_h tts)
1514 if (0 != __tts_get_feature_enabled()) {
1515 return TTS_ERROR_NOT_SUPPORTED;
1518 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1521 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1522 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1523 return TTS_ERROR_INVALID_PARAMETER;
1526 tts_client_s* client = tts_client_get(tts);
1528 if (NULL == client) {
1529 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1530 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1531 return TTS_ERROR_INVALID_PARAMETER;
1534 if (TTS_STATE_CREATED == client->current_state) {
1535 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1536 return TTS_ERROR_INVALID_STATE;
1539 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1540 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1541 return TTS_ERROR_INVALID_STATE;
1544 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1546 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1548 return TTS_ERROR_NONE;
1551 int tts_stop(tts_h tts)
1553 if (0 != __tts_get_feature_enabled()) {
1554 return TTS_ERROR_NOT_SUPPORTED;
1557 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1560 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1561 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1562 return TTS_ERROR_INVALID_PARAMETER;
1565 tts_client_s* client = tts_client_get(tts);
1567 if (NULL == client) {
1568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1569 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1570 return TTS_ERROR_INVALID_PARAMETER;
1573 if (TTS_STATE_CREATED == client->current_state) {
1574 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1575 return TTS_ERROR_INVALID_STATE;
1578 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1579 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1580 return TTS_ERROR_INVALID_STATE;
1585 bool is_prepared = false;
1587 ret = tts_dbus_request_stop(client->uid);
1590 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1591 client->current_state = TTS_STATE_CREATED;
1592 if (0 == tts_prepare_sync(tts)) {
1594 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1596 } else if (TTS_ERROR_TIMED_OUT != ret) {
1597 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1600 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1603 if (TTS_RETRY_COUNT == count) {
1604 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1612 client->before_state = client->current_state;
1613 client->current_state = TTS_STATE_READY;
1615 if (NULL != client->state_changed_cb) {
1616 tts_client_use_callback(client);
1617 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1618 tts_client_not_use_callback(client);
1619 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1622 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1624 return TTS_ERROR_NONE;
1627 static void __tts_pause_async(void *data)
1629 tts_h tts = (tts_h)data;
1630 tts_client_s* client = tts_client_get(tts);
1633 if (NULL == client) {
1634 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1640 bool is_prepared = false;
1642 ret = tts_dbus_request_pause(client->uid);
1644 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1645 client->current_state = TTS_STATE_CREATED;
1646 if (0 == tts_prepare_sync(tts)) {
1648 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1650 } else if (TTS_ERROR_TIMED_OUT != ret) {
1651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1654 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1657 if (TTS_RETRY_COUNT == count) {
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1666 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1668 client->reason = ret;
1669 client->utt_id = -1;
1671 ecore_timer_add(0, __tts_notify_error, client->tts);
1675 client->before_state = client->current_state;
1676 client->current_state = TTS_STATE_PAUSED;
1678 if (NULL != client->state_changed_cb) {
1679 tts_client_use_callback(client);
1680 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1681 tts_client_not_use_callback(client);
1682 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1685 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1690 int tts_pause_async(tts_h tts)
1692 if (0 != __tts_get_feature_enabled()) {
1693 return TTS_ERROR_NOT_SUPPORTED;
1696 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1699 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1700 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1701 return TTS_ERROR_INVALID_PARAMETER;
1704 tts_client_s* client = tts_client_get(tts);
1706 if (NULL == client) {
1707 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1708 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1709 return TTS_ERROR_INVALID_PARAMETER;
1712 if (TTS_STATE_PLAYING != client->current_state) {
1713 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1714 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1715 return TTS_ERROR_INVALID_STATE;
1718 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1719 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1720 return TTS_ERROR_INVALID_STATE;
1723 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1725 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1727 return TTS_ERROR_NONE;
1730 int tts_pause(tts_h tts)
1732 if (0 != __tts_get_feature_enabled()) {
1733 return TTS_ERROR_NOT_SUPPORTED;
1736 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1739 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1740 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1741 return TTS_ERROR_INVALID_PARAMETER;
1744 tts_client_s* client = tts_client_get(tts);
1746 if (NULL == client) {
1747 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1748 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1749 return TTS_ERROR_INVALID_PARAMETER;
1752 if (TTS_STATE_PLAYING != client->current_state) {
1753 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1754 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1755 return TTS_ERROR_INVALID_STATE;
1758 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1759 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1760 return TTS_ERROR_INVALID_STATE;
1765 bool is_prepared = false;
1767 ret = tts_dbus_request_pause(client->uid);
1770 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1771 client->current_state = TTS_STATE_CREATED;
1772 if (0 == tts_prepare_sync(tts)) {
1774 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1776 } else if (TTS_ERROR_TIMED_OUT != ret) {
1777 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1780 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1783 if (TTS_RETRY_COUNT == count) {
1784 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1792 client->before_state = client->current_state;
1793 client->current_state = TTS_STATE_PAUSED;
1795 if (NULL != client->state_changed_cb) {
1796 tts_client_use_callback(client);
1797 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1798 tts_client_not_use_callback(client);
1799 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1802 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1804 return TTS_ERROR_NONE;
1807 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1809 if (0 != __tts_get_feature_enabled()) {
1810 return TTS_ERROR_NOT_SUPPORTED;
1813 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1816 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1817 return TTS_ERROR_INVALID_PARAMETER;
1820 if (NULL == key || NULL == data) {
1821 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1822 return TTS_ERROR_INVALID_PARAMETER;
1825 tts_client_s* client = tts_client_get(tts);
1827 if (NULL == client) {
1828 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1829 return TTS_ERROR_INVALID_PARAMETER;
1832 if (TTS_STATE_READY != client->current_state) {
1833 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1834 return TTS_ERROR_INVALID_STATE;
1837 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1838 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1839 return TTS_ERROR_INVALID_PARAMETER;
1844 bool is_prepared = false;
1846 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1849 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1850 client->current_state = TTS_STATE_CREATED;
1851 if (0 == tts_prepare_sync(tts)) {
1853 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1855 } else if (TTS_ERROR_TIMED_OUT != ret) {
1856 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1859 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1862 if (TTS_RETRY_COUNT == count) {
1863 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1871 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1876 int tts_get_private_data(tts_h tts, const char* key, char** data)
1878 if (0 != __tts_get_feature_enabled()) {
1879 return TTS_ERROR_NOT_SUPPORTED;
1882 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1885 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1886 return TTS_ERROR_INVALID_PARAMETER;
1889 if (NULL == key || NULL == data) {
1890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1891 return TTS_ERROR_INVALID_PARAMETER;
1894 tts_client_s* client = tts_client_get(tts);
1896 if (NULL == client) {
1897 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1898 return TTS_ERROR_INVALID_PARAMETER;
1901 if (TTS_STATE_READY != client->current_state) {
1902 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1903 return TTS_ERROR_INVALID_STATE;
1908 bool is_prepared = false;
1910 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1913 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1914 client->current_state = TTS_STATE_CREATED;
1915 if (0 == tts_prepare_sync(tts)) {
1917 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1919 } else if (TTS_ERROR_TIMED_OUT != ret) {
1920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1923 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1926 if (TTS_RETRY_COUNT == count) {
1927 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1935 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1940 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1946 static Eina_Bool __tts_notify_error(void *data)
1948 tts_h tts = (tts_h)data;
1950 tts_client_s* client = tts_client_get(tts);
1953 if (NULL == client) {
1954 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1958 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1960 if (NULL != client->error_cb) {
1961 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1962 tts_client_use_callback(client);
1963 g_err_callback_status = true;
1964 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1965 g_err_callback_status = false;
1966 tts_client_not_use_callback(client);
1968 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1974 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1977 GList* client_list = NULL;
1978 client_list = tts_client_get_client_list();
1981 tts_client_s *data = NULL;
1983 if (g_list_length(client_list) > 0) {
1984 /* Get a first item */
1985 iter = g_list_first(client_list);
1987 while (NULL != iter) {
1990 data->utt_id = utt_id;
1991 data->reason = reason;
1992 if (NULL != data->err_msg) {
1993 free(data->err_msg);
1994 data->err_msg = NULL;
1996 if (NULL != err_msg)
1997 data->err_msg = strdup(err_msg);
1999 /* call callback function */
2000 if (NULL != data->error_cb) {
2001 ecore_timer_add(0, __tts_notify_error, data->tts);
2003 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2006 if (TTS_ERROR_SERVICE_RESET == reason) {
2007 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2009 data->current_state = TTS_STATE_CREATED;
2010 if (0 != tts_prepare(data->tts)) {
2011 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2016 iter = g_list_next(iter);
2020 tts_client_s* client = tts_client_get_by_uid(uid);
2022 if (NULL == client) {
2023 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2024 return TTS_ERROR_INVALID_PARAMETER;
2027 client->utt_id = utt_id;
2028 client->reason = reason;
2029 if (NULL != client->err_msg) {
2030 free(client->err_msg);
2031 client->err_msg = NULL;
2033 if (NULL != err_msg)
2034 client->err_msg = strdup(err_msg);
2036 /* call callback function */
2037 if (NULL != client->error_cb) {
2038 ecore_timer_add(0, __tts_notify_error, client->tts);
2040 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2043 if (TTS_ERROR_SERVICE_RESET == reason) {
2044 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2046 client->current_state = TTS_STATE_CREATED;
2047 if (0 != tts_prepare(client->tts)) {
2048 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2056 static Eina_Bool __tts_notify_state_changed(void *data)
2058 tts_h tts = (tts_h)data;
2060 tts_client_s* client = tts_client_get(tts);
2063 if (NULL == client) {
2064 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2068 if (NULL != client->state_changed_cb) {
2069 tts_client_use_callback(client);
2070 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2071 tts_client_not_use_callback(client);
2072 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2074 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2080 int __tts_cb_set_state(int uid, int state)
2082 tts_client_s* client = tts_client_get_by_uid(uid);
2083 if (NULL == client) {
2084 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2088 tts_state_e state_from_daemon = (tts_state_e)state;
2090 if (client->current_state == state_from_daemon) {
2091 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2095 if (NULL != client->state_changed_cb) {
2096 if (NULL != g_check_state_timer) {
2097 ecore_timer_del(g_check_state_timer);
2098 g_check_state_timer = NULL;
2100 g_check_state_timer = ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2102 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2105 client->before_state = client->current_state;
2106 client->current_state = state_from_daemon;
2112 int __tts_cb_utt_started(int uid, int utt_id)
2114 tts_client_s* client = tts_client_get_by_uid(uid);
2116 if (NULL == client) {
2117 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2118 return TTS_ERROR_INVALID_PARAMETER;
2121 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2123 client->utt_id = utt_id;
2125 /* call callback function */
2126 if (NULL != client->utt_started_cb) {
2127 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2128 tts_client_use_callback(client);
2129 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2130 tts_client_not_use_callback(client);
2132 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2138 int __tts_cb_utt_completed(int uid, int utt_id)
2140 tts_client_s* client = tts_client_get_by_uid(uid);
2142 if (NULL == client) {
2143 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2144 return TTS_ERROR_INVALID_PARAMETER;
2147 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2149 client->utt_id = utt_id;
2151 /* call callback function */
2152 if (NULL != client->utt_completeted_cb) {
2153 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2154 tts_client_use_callback(client);
2155 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2156 tts_client_not_use_callback(client);
2158 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2164 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2166 if (0 != __tts_get_feature_enabled()) {
2167 return TTS_ERROR_NOT_SUPPORTED;
2170 if (NULL == tts || NULL == callback) {
2171 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2172 return TTS_ERROR_INVALID_PARAMETER;
2175 tts_client_s* client = tts_client_get(tts);
2177 if (NULL == client) {
2178 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2179 return TTS_ERROR_INVALID_PARAMETER;
2182 if (TTS_STATE_CREATED != client->current_state) {
2183 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2184 return TTS_ERROR_INVALID_STATE;
2187 client->state_changed_cb = callback;
2188 client->state_changed_user_data = user_data;
2190 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2195 int tts_unset_state_changed_cb(tts_h tts)
2197 if (0 != __tts_get_feature_enabled()) {
2198 return TTS_ERROR_NOT_SUPPORTED;
2202 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2203 return TTS_ERROR_INVALID_PARAMETER;
2206 tts_client_s* client = tts_client_get(tts);
2208 if (NULL == client) {
2209 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2210 return TTS_ERROR_INVALID_PARAMETER;
2213 if (TTS_STATE_CREATED != client->current_state) {
2214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2215 return TTS_ERROR_INVALID_STATE;
2218 client->state_changed_cb = NULL;
2219 client->state_changed_user_data = NULL;
2221 if (NULL != g_check_state_timer) {
2222 ecore_timer_del(g_check_state_timer);
2223 g_check_state_timer = NULL;
2226 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2231 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2233 if (0 != __tts_get_feature_enabled()) {
2234 return TTS_ERROR_NOT_SUPPORTED;
2237 if (NULL == tts || NULL == callback) {
2238 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2239 return TTS_ERROR_INVALID_PARAMETER;
2242 tts_client_s* client = tts_client_get(tts);
2244 if (NULL == client) {
2245 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2246 return TTS_ERROR_INVALID_PARAMETER;
2249 if (TTS_STATE_CREATED != client->current_state) {
2250 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2251 return TTS_ERROR_INVALID_STATE;
2254 client->utt_started_cb = callback;
2255 client->utt_started_user_data = user_data;
2257 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2262 int tts_unset_utterance_started_cb(tts_h tts)
2264 if (0 != __tts_get_feature_enabled()) {
2265 return TTS_ERROR_NOT_SUPPORTED;
2269 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2270 return TTS_ERROR_INVALID_PARAMETER;
2273 tts_client_s* client = tts_client_get(tts);
2275 if (NULL == client) {
2276 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2277 return TTS_ERROR_INVALID_PARAMETER;
2280 if (TTS_STATE_CREATED != client->current_state) {
2281 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2282 return TTS_ERROR_INVALID_STATE;
2285 client->utt_started_cb = NULL;
2286 client->utt_started_user_data = NULL;
2288 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2293 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2295 if (0 != __tts_get_feature_enabled()) {
2296 return TTS_ERROR_NOT_SUPPORTED;
2299 if (NULL == tts || NULL == callback) {
2300 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2301 return TTS_ERROR_INVALID_PARAMETER;
2304 tts_client_s* client = tts_client_get(tts);
2306 if (NULL == client) {
2307 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2308 return TTS_ERROR_INVALID_PARAMETER;
2311 if (TTS_STATE_CREATED != client->current_state) {
2312 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2313 return TTS_ERROR_INVALID_STATE;
2316 client->utt_completeted_cb = callback;
2317 client->utt_completed_user_data = user_data;
2319 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2324 int tts_unset_utterance_completed_cb(tts_h tts)
2326 if (0 != __tts_get_feature_enabled()) {
2327 return TTS_ERROR_NOT_SUPPORTED;
2331 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2332 return TTS_ERROR_INVALID_PARAMETER;
2335 tts_client_s* client = tts_client_get(tts);
2337 if (NULL == client) {
2338 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2339 return TTS_ERROR_INVALID_PARAMETER;
2342 if (TTS_STATE_CREATED != client->current_state) {
2343 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2344 return TTS_ERROR_INVALID_STATE;
2347 client->utt_completeted_cb = NULL;
2348 client->utt_completed_user_data = NULL;
2350 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2354 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2356 if (0 != __tts_get_feature_enabled()) {
2357 return TTS_ERROR_NOT_SUPPORTED;
2360 if (NULL == tts || NULL == callback) {
2361 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2362 return TTS_ERROR_INVALID_PARAMETER;
2365 tts_client_s* client = tts_client_get(tts);
2367 if (NULL == client) {
2368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2369 return TTS_ERROR_INVALID_PARAMETER;
2372 if (TTS_STATE_CREATED != client->current_state) {
2373 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2374 return TTS_ERROR_INVALID_STATE;
2377 client->error_cb = callback;
2378 client->error_user_data = user_data;
2380 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2385 int tts_unset_error_cb(tts_h tts)
2387 if (0 != __tts_get_feature_enabled()) {
2388 return TTS_ERROR_NOT_SUPPORTED;
2392 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2393 return TTS_ERROR_INVALID_PARAMETER;
2396 tts_client_s* client = tts_client_get(tts);
2398 if (NULL == client) {
2399 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2400 return TTS_ERROR_INVALID_PARAMETER;
2403 if (TTS_STATE_CREATED != client->current_state) {
2404 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2405 return TTS_ERROR_INVALID_STATE;
2408 client->error_cb = NULL;
2409 client->error_user_data = NULL;
2411 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2416 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2418 if (0 != __tts_get_feature_enabled()) {
2419 return TTS_ERROR_NOT_SUPPORTED;
2422 if (NULL == tts || NULL == callback) {
2423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2424 return TTS_ERROR_INVALID_PARAMETER;
2427 tts_client_s* client = tts_client_get(tts);
2429 if (NULL == client) {
2430 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2431 return TTS_ERROR_INVALID_PARAMETER;
2434 if (TTS_STATE_CREATED != client->current_state) {
2435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2436 return TTS_ERROR_INVALID_STATE;
2439 client->default_voice_changed_cb = callback;
2440 client->default_voice_changed_user_data = user_data;
2442 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2447 int tts_unset_default_voice_changed_cb(tts_h tts)
2449 if (0 != __tts_get_feature_enabled()) {
2450 return TTS_ERROR_NOT_SUPPORTED;
2454 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2455 return TTS_ERROR_INVALID_PARAMETER;
2458 tts_client_s* client = tts_client_get(tts);
2460 if (NULL == client) {
2461 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2462 return TTS_ERROR_INVALID_PARAMETER;
2465 if (TTS_STATE_CREATED != client->current_state) {
2466 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2467 return TTS_ERROR_INVALID_STATE;
2470 client->default_voice_changed_cb = NULL;
2471 client->default_voice_changed_user_data = NULL;
2473 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2478 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2480 if (0 != __tts_get_feature_enabled()) {
2481 return TTS_ERROR_NOT_SUPPORTED;
2484 if (NULL == tts || NULL == callback) {
2485 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2486 return TTS_ERROR_INVALID_PARAMETER;
2489 tts_client_s* client = tts_client_get(tts);
2491 if (NULL == client) {
2492 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2493 return TTS_ERROR_INVALID_PARAMETER;
2496 if (TTS_STATE_CREATED != client->current_state) {
2497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2498 return TTS_ERROR_INVALID_STATE;
2501 client->engine_changed_cb = callback;
2502 client->engine_changed_user_data = user_data;
2504 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2509 int tts_unset_engine_changed_cb(tts_h tts)
2511 if (0 != __tts_get_feature_enabled()) {
2512 return TTS_ERROR_NOT_SUPPORTED;
2516 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2517 return TTS_ERROR_INVALID_PARAMETER;
2520 tts_client_s* client = tts_client_get(tts);
2522 if (NULL == client) {
2523 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2524 return TTS_ERROR_INVALID_PARAMETER;
2527 if (TTS_STATE_CREATED != client->current_state) {
2528 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2529 return TTS_ERROR_INVALID_STATE;
2532 client->engine_changed_cb = NULL;
2533 client->engine_changed_user_data = NULL;
2535 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2541 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2543 if (0 != __tts_get_feature_enabled()) {
2544 return TTS_ERROR_NOT_SUPPORTED;
2547 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2550 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2551 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2552 return TTS_ERROR_INVALID_PARAMETER;
2555 tts_client_s* client = tts_client_get(tts);
2557 if (NULL == client) {
2558 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2559 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2560 return TTS_ERROR_INVALID_PARAMETER;
2563 if (TTS_STATE_CREATED == client->current_state) {
2564 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2565 return TTS_ERROR_INVALID_STATE;
2568 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2569 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2570 return TTS_ERROR_INVALID_STATE;
2575 bool is_prepared = false;
2577 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2579 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2580 client->current_state = TTS_STATE_CREATED;
2581 if (0 == tts_prepare_sync(tts)) {
2583 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2585 } else if (TTS_ERROR_TIMED_OUT != ret) {
2586 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2589 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2592 if (TTS_RETRY_COUNT == count) {
2593 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2600 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2602 return TTS_ERROR_NONE;
2605 int tts_play_pcm(tts_h tts)
2607 if (0 != __tts_get_feature_enabled()) {
2608 return TTS_ERROR_NOT_SUPPORTED;
2611 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2614 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2615 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2616 return TTS_ERROR_INVALID_PARAMETER;
2619 tts_client_s* client = tts_client_get(tts);
2621 if (NULL == client) {
2622 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2623 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2624 return TTS_ERROR_INVALID_PARAMETER;
2627 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2628 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2629 return TTS_ERROR_INVALID_STATE;
2632 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2633 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2634 return TTS_ERROR_INVALID_STATE;
2639 bool is_prepared = false;
2641 ret = tts_dbus_request_play_pcm(client->uid);
2643 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2644 client->current_state = TTS_STATE_CREATED;
2645 if (0 == tts_prepare_sync(tts)) {
2647 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2649 } else if (TTS_ERROR_TIMED_OUT != ret) {
2650 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2653 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2656 if (TTS_RETRY_COUNT == count) {
2657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2664 client->before_state = client->current_state;
2665 client->current_state = TTS_STATE_PLAYING;
2667 if (NULL != client->state_changed_cb) {
2668 tts_client_use_callback(client);
2669 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2670 tts_client_not_use_callback(client);
2671 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2674 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2676 return TTS_ERROR_NONE;
2679 int tts_stop_pcm(tts_h tts)
2681 if (0 != __tts_get_feature_enabled()) {
2682 return TTS_ERROR_NOT_SUPPORTED;
2685 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2688 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2689 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2690 return TTS_ERROR_INVALID_PARAMETER;
2693 tts_client_s* client = tts_client_get(tts);
2695 if (NULL == client) {
2696 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2697 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2698 return TTS_ERROR_INVALID_PARAMETER;
2701 if (TTS_STATE_CREATED == client->current_state) {
2702 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2703 return TTS_ERROR_INVALID_STATE;
2706 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2707 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2708 return TTS_ERROR_INVALID_STATE;
2713 bool is_prepared = false;
2715 ret = tts_dbus_request_stop_pcm(client->uid);
2717 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2718 client->current_state = TTS_STATE_CREATED;
2719 if (0 == tts_prepare_sync(tts)) {
2721 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2723 } else if (TTS_ERROR_TIMED_OUT != ret) {
2724 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2727 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2730 if (TTS_RETRY_COUNT == count) {
2731 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2738 client->before_state = client->current_state;
2739 client->current_state = TTS_STATE_READY;
2741 if (NULL != client->state_changed_cb) {
2742 tts_client_use_callback(client);
2743 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2744 tts_client_not_use_callback(client);
2745 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2748 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2750 return TTS_ERROR_NONE;
2754 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
2756 if (0 != __tts_get_feature_enabled()) {
2757 return TTS_ERROR_NOT_SUPPORTED;
2760 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
2763 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2764 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2765 return TTS_ERROR_INVALID_PARAMETER;
2768 if (NULL == text_repeat || NULL == utt_id) {
2769 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
2770 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2771 return TTS_ERROR_INVALID_PARAMETER;
2774 *text_repeat = NULL;
2777 tts_client_s* client = tts_client_get(tts);
2779 if (NULL == client) {
2780 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2781 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2782 return TTS_ERROR_INVALID_PARAMETER;
2785 if (TTS_STATE_READY != client->current_state) {
2786 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
2787 return TTS_ERROR_INVALID_STATE;
2790 /* Clear the legacy and Add texts to be played repeatedly */
2792 ret = tts_stop(tts);
2793 if (TTS_ERROR_NONE != ret) {
2794 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
2798 if (NULL != client->text_repeat) {
2799 char* tmp_text = strdup(client->text_repeat);
2800 char* tmp_lang = NULL;
2801 if (NULL != g_language) {
2802 tmp_lang = strdup(g_language);
2804 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
2805 if (TTS_ERROR_NONE != ret) {
2806 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
2807 if (NULL != tmp_text) {
2811 if (NULL != tmp_lang) {
2817 *text_repeat = strdup(client->text_repeat);
2818 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
2819 if (NULL != tmp_text) {
2823 if (NULL != tmp_lang) {
2828 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
2829 return TTS_ERROR_OPERATION_FAILED;
2832 /* Play added texts */
2833 ret = tts_play(tts);
2834 if (TTS_ERROR_NONE != ret) {
2835 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
2836 if (NULL != *text_repeat) {
2838 *text_repeat = NULL;
2844 return TTS_ERROR_NONE;