2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
14 #include <app_manager.h>
19 #include <sys/types.h>
21 #include <system_info.h>
25 #include "tts_client.h"
26 #include "tts_config_mgr.h"
30 #include "tts_internal.h"
32 static bool g_screen_reader;
34 static int g_feature_enabled = -1;
36 static bool g_err_callback_status = false;
38 static int g_max_text_size = -1;
41 static char* g_language = NULL;
43 static int g_voice_type = -1;
45 static int g_speed = -1;
48 /* Function definition */
49 static Eina_Bool __tts_notify_state_changed(void *data);
50 static Eina_Bool __tts_notify_error(void *data);
57 static int __tts_get_feature_enabled()
59 if (0 == g_feature_enabled) {
60 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
61 return TTS_ERROR_NOT_SUPPORTED;
62 } else if (-1 == g_feature_enabled) {
63 bool tts_supported = false;
64 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
65 if (false == tts_supported) {
66 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
67 g_feature_enabled = 0;
68 return TTS_ERROR_NOT_SUPPORTED;
71 g_feature_enabled = 1;
73 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
74 return TTS_ERROR_NOT_SUPPORTED;
81 static const char* __tts_get_error_code(tts_error_e err)
84 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
85 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
86 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
87 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
88 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
89 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
90 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
91 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
92 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
93 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
94 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
95 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
96 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
97 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
98 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
100 return "Invalid error code";
105 static int __tts_convert_config_error_code(tts_config_error_e code)
107 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
108 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
109 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
110 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
111 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
112 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
113 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
114 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
115 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
120 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
122 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
123 before_lang, before_voice_type, language, voice_type);
125 GList* client_list = NULL;
126 client_list = tts_client_get_client_list();
129 tts_client_s *data = NULL;
131 if (g_list_length(client_list) > 0) {
132 /* Get a first item */
133 iter = g_list_first(client_list);
135 while (NULL != iter) {
137 if (NULL != data->default_voice_changed_cb) {
138 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
139 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
140 language, voice_type, data->default_voice_changed_user_data);
143 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
144 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
145 if (NULL != data->text_repeat) {
146 free(data->text_repeat);
147 data->text_repeat = NULL;
152 iter = g_list_next(iter);
159 static Eina_Bool __reconnect_by_engine_changed(void* data)
161 tts_h tts = (tts_h)data;
163 tts_client_s* client = tts_client_get(tts);
164 if (NULL == client) {
165 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
169 if (TTS_STATE_READY != client->current_state) {
174 int ret = tts_unprepare(tts);
176 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
178 ret = tts_prepare(tts);
180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
186 void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
188 tts_h tts = (tts_h)user_data;
190 tts_client_s* client = tts_client_get(tts);
191 if (NULL == client) {
192 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
196 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
197 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
198 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
199 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
201 /* When the default engine is changed, please unload the old engine and load the new one. */
204 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
207 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
210 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
211 } else if (TTS_STATE_READY == client->current_state) {
212 ret = tts_unprepare(tts);
214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
216 ret = tts_prepare(tts);
218 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
222 /* call callback function */
223 if (NULL != client->engine_changed_cb) {
224 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
226 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
231 int tts_create(tts_h* tts)
233 if (0 != __tts_get_feature_enabled()) {
234 return TTS_ERROR_NOT_SUPPORTED;
237 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
242 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
243 return TTS_ERROR_INVALID_PARAMETER;
246 if (0 == tts_client_get_size()) {
247 if (0 != tts_dbus_open_connection()) {
248 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
249 return TTS_ERROR_OPERATION_FAILED;
253 if (0 != tts_client_new(tts)) {
254 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
255 return TTS_ERROR_OUT_OF_MEMORY;
258 tts_client_s* client = tts_client_get(*tts);
259 if (NULL == client) {
260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
261 return TTS_ERROR_OPERATION_FAILED;
264 int ret = tts_config_mgr_initialize(client->uid);
266 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
267 tts_client_destroy(*tts);
268 return __tts_convert_config_error_code(ret);
271 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
273 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
274 tts_client_destroy(*tts);
275 return __tts_convert_config_error_code(ret);
278 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
279 SLOG(LOG_DEBUG, TAG_TTSC, " ");
281 return TTS_ERROR_NONE;
284 int tts_destroy(tts_h tts)
286 if (0 != __tts_get_feature_enabled()) {
287 return TTS_ERROR_NOT_SUPPORTED;
290 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
293 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
294 return TTS_ERROR_INVALID_PARAMETER;
297 tts_client_s* client = tts_client_get(tts);
300 if (NULL == client) {
301 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
302 return TTS_ERROR_INVALID_PARAMETER;
305 /* check used callback */
306 if (0 != tts_client_get_use_callback(client)) {
307 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
308 return TTS_ERROR_OPERATION_FAILED;
311 tts_config_mgr_finalize(client->uid);
315 int screen_reader = -1;
318 switch (client->current_state) {
319 case TTS_STATE_PAUSED:
320 case TTS_STATE_PLAYING:
321 case TTS_STATE_READY:
322 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
324 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
326 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
327 g_screen_reader = (bool)screen_reader;
329 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
331 ret = tts_dbus_request_finalize(client->uid);
333 if (TTS_ERROR_TIMED_OUT != ret) {
334 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
337 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
340 if (TTS_RETRY_COUNT == count) {
341 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
348 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
351 client->before_state = client->current_state;
352 client->current_state = TTS_STATE_CREATED;
354 case TTS_STATE_CREATED:
355 if (NULL != client->conn_timer) {
356 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
357 ecore_timer_del(client->conn_timer);
358 client->conn_timer = NULL;
361 tts_client_destroy(tts);
368 if (0 == tts_client_get_size()) {
369 if (0 != tts_dbus_close_connection()) {
370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
374 if (NULL != g_language) {
381 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
383 return TTS_ERROR_NONE;
386 void __tts_screen_reader_changed_cb(bool value)
388 g_screen_reader = value;
391 int tts_set_mode(tts_h tts, tts_mode_e mode)
393 if (0 != __tts_get_feature_enabled()) {
394 return TTS_ERROR_NOT_SUPPORTED;
397 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
399 tts_client_s* client = tts_client_get(tts);
402 if (NULL == client) {
403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
404 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
405 return TTS_ERROR_INVALID_PARAMETER;
409 if (client->current_state != TTS_STATE_CREATED) {
410 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
411 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
412 SLOG(LOG_DEBUG, TAG_TTSC, " ");
413 return TTS_ERROR_INVALID_STATE;
416 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
420 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
421 SLOG(LOG_DEBUG, TAG_TTSC, " ");
422 return TTS_ERROR_INVALID_PARAMETER;
425 if (TTS_MODE_SCREEN_READER == mode) {
428 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
430 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
431 return TTS_ERROR_OPERATION_FAILED;
433 g_screen_reader = (bool)screen_reader;
434 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
436 tts_config_unset_screen_reader_callback(client->uid);
439 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
441 return TTS_ERROR_NONE;
444 int tts_get_mode(tts_h tts, tts_mode_e* mode)
446 if (0 != __tts_get_feature_enabled()) {
447 return TTS_ERROR_NOT_SUPPORTED;
450 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
452 tts_client_s* client = tts_client_get(tts);
455 if (NULL == client) {
456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
457 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
458 SLOG(LOG_DEBUG, TAG_TTSC, " ");
459 return TTS_ERROR_INVALID_PARAMETER;
463 if (client->current_state != TTS_STATE_CREATED) {
464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
465 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
466 SLOG(LOG_DEBUG, TAG_TTSC, " ");
467 return TTS_ERROR_INVALID_STATE;
471 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
472 return TTS_ERROR_INVALID_PARAMETER;
475 *mode = client->mode;
477 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
478 SLOG(LOG_DEBUG, TAG_TTSC, " ");
480 return TTS_ERROR_NONE;
483 int tts_set_credential(tts_h tts, const char* credential)
485 if (0 != __tts_get_feature_enabled()) {
486 return TTS_ERROR_NOT_SUPPORTED;
489 if (NULL == tts || NULL == credential) {
490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
491 return TTS_ERROR_INVALID_PARAMETER;
494 tts_client_s* client = tts_client_get(tts);
496 if (NULL == client) {
497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
498 return TTS_ERROR_INVALID_PARAMETER;
501 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
503 return TTS_ERROR_INVALID_STATE;
506 if (NULL != client->credential) {
507 free(client->credential);
508 client->credential = NULL;
510 client->credential = strdup(credential);
512 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
514 return TTS_ERROR_NONE;
517 int tts_set_server_tts(tts_h tts, const char* credential)
519 if (0 != __tts_get_feature_enabled()) {
520 return TTS_ERROR_NOT_SUPPORTED;
524 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
525 return TTS_ERROR_INVALID_PARAMETER;
528 tts_client_s* client = tts_client_get(tts);
530 if (NULL == client) {
531 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
532 return TTS_ERROR_INVALID_PARAMETER;
535 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
536 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
537 return TTS_ERROR_INVALID_STATE;
540 if (NULL != client->credential) {
541 free(client->credential);
542 client->credential = NULL;
545 client->internal = true;
548 if (NULL != credential) {
549 key = strdup("EnableServerTTS");
550 client->credential = strdup(credential);
551 if (NULL == client->credential) {
552 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
557 return TTS_ERROR_OUT_OF_MEMORY;
560 key = strdup("DisableServerTTS");
564 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
565 return TTS_ERROR_OUT_OF_MEMORY;
570 int ret = app_manager_get_app_id(pid, &appid);
571 if (0 != ret || NULL == appid) {
572 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
579 return TTS_ERROR_OPERATION_FAILED;
582 ret = tts_set_private_data(tts, key, appid);
584 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
597 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
599 return TTS_ERROR_NONE;
602 static Eina_Bool __tts_connect_daemon(void *data)
604 tts_h tts = (tts_h)data;
605 tts_client_s* client = tts_client_get(tts);
608 if (NULL == client) {
609 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
614 if (0 != tts_dbus_request_hello(client->uid)) {
618 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
620 /* do request initialize */
622 bool credential_needed = false;
624 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
626 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
627 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
629 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
632 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
633 client->conn_timer = NULL;
636 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
637 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
639 client->reason = TTS_ERROR_PERMISSION_DENIED;
642 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
643 client->conn_timer = NULL;
646 } else if (TTS_ERROR_NONE != ret) {
647 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
651 /* success to connect tts-daemon */
652 client->credential_needed = credential_needed;
653 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
656 client->conn_timer = NULL;
658 client = tts_client_get(tts);
660 if (NULL == client) {
661 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
665 client->before_state = client->current_state;
666 client->current_state = TTS_STATE_READY;
668 if (NULL != client->state_changed_cb) {
669 tts_client_use_callback(client);
670 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
671 tts_client_not_use_callback(client);
673 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
676 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
681 int tts_prepare(tts_h tts)
683 if (0 != __tts_get_feature_enabled()) {
684 return TTS_ERROR_NOT_SUPPORTED;
687 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
689 tts_client_s* client = tts_client_get(tts);
692 if (NULL == client) {
693 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
694 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
695 return TTS_ERROR_INVALID_PARAMETER;
699 if (client->current_state != TTS_STATE_CREATED) {
700 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
701 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
702 return TTS_ERROR_INVALID_STATE;
705 client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
707 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
709 return TTS_ERROR_NONE;
712 int tts_prepare_sync(tts_h tts)
714 if (0 != __tts_get_feature_enabled()) {
715 return TTS_ERROR_NOT_SUPPORTED;
718 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
720 tts_client_s* client = tts_client_get(tts);
723 if (NULL == client) {
724 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
725 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
726 return TTS_ERROR_INVALID_PARAMETER;
730 if (client->current_state != TTS_STATE_CREATED) {
731 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
732 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
733 return TTS_ERROR_INVALID_STATE;
737 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
741 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
743 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
744 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
745 return TTS_ERROR_OPERATION_FAILED;
748 return TTS_ERROR_NONE;
751 int tts_unprepare(tts_h tts)
753 if (0 != __tts_get_feature_enabled()) {
754 return TTS_ERROR_NOT_SUPPORTED;
757 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
759 tts_client_s* client = tts_client_get(tts);
762 if (NULL == client) {
763 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
764 return TTS_ERROR_INVALID_PARAMETER;
768 if (client->current_state != TTS_STATE_READY) {
769 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
770 return TTS_ERROR_INVALID_STATE;
775 int screen_reader = -1;
777 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
779 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
781 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);
782 g_screen_reader = (bool)screen_reader;
785 bool is_prepared = false;
786 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
788 ret = tts_dbus_request_finalize(client->uid);
790 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
791 client->current_state = TTS_STATE_CREATED;
792 if (0 == tts_prepare_sync(tts)) {
794 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
796 } else if (TTS_ERROR_TIMED_OUT != ret) {
797 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
800 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
803 if (TTS_RETRY_COUNT == count) {
804 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
811 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
814 client->before_state = client->current_state;
815 client->current_state = TTS_STATE_CREATED;
817 if (NULL != client->state_changed_cb) {
818 tts_client_use_callback(client);
819 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
820 tts_client_not_use_callback(client);
821 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
824 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
826 return TTS_ERROR_NONE;
829 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
831 tts_h tts = (tts_h)user_data;
833 tts_client_s* client = tts_client_get(tts);
834 if (NULL == client) {
835 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
839 /* call callback function */
840 if (NULL != client->supported_voice_cb) {
841 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
843 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
849 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
851 if (0 != __tts_get_feature_enabled()) {
852 return TTS_ERROR_NOT_SUPPORTED;
855 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
857 if (NULL == tts || NULL == callback) {
858 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
859 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
860 return TTS_ERROR_INVALID_PARAMETER;
863 tts_client_s* client = tts_client_get(tts);
866 if (NULL == client) {
867 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
868 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
869 return TTS_ERROR_INVALID_PARAMETER;
873 char* current_engine = NULL;
874 ret = tts_config_mgr_get_engine(¤t_engine);
876 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
877 return __tts_convert_config_error_code(ret);
880 client->supported_voice_cb = callback;
881 client->supported_voice_user_data = user_data;
883 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
885 if (NULL != current_engine) {
886 free(current_engine);
887 current_engine = NULL;
890 client->supported_voice_cb = NULL;
891 client->supported_voice_user_data = NULL;
894 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
895 ret = TTS_ERROR_OPERATION_FAILED;
898 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
903 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
905 if (0 != __tts_get_feature_enabled()) {
906 return TTS_ERROR_NOT_SUPPORTED;
909 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
912 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
913 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
914 return TTS_ERROR_INVALID_PARAMETER;
917 tts_client_s* client = tts_client_get(tts);
919 if (NULL == client) {
920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
921 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
922 return TTS_ERROR_INVALID_PARAMETER;
925 /* Request call remote method */
927 ret = tts_config_mgr_get_voice(lang, vctype);
929 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
930 return __tts_convert_config_error_code(ret);
932 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
935 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
940 int tts_get_max_text_size(tts_h tts, unsigned int* size)
942 if (0 != __tts_get_feature_enabled()) {
943 return TTS_ERROR_NOT_SUPPORTED;
946 if (NULL == tts || NULL == size) {
947 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
948 return TTS_ERROR_INVALID_PARAMETER;
951 tts_client_s* client = tts_client_get(tts);
953 if (NULL == client) {
954 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
955 return TTS_ERROR_INVALID_PARAMETER;
958 if (TTS_STATE_READY != client->current_state) {
959 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
960 return TTS_ERROR_INVALID_STATE;
963 if (0 != tts_config_mgr_get_max_text_size(size)) {
964 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
965 return TTS_ERROR_INVALID_PARAMETER;
968 g_max_text_size = (int)*size;
970 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
971 return TTS_ERROR_NONE;
974 int tts_get_state(tts_h tts, tts_state_e* state)
976 if (0 != __tts_get_feature_enabled()) {
977 return TTS_ERROR_NOT_SUPPORTED;
980 if (NULL == tts || NULL == state) {
981 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
982 return TTS_ERROR_INVALID_PARAMETER;
985 tts_client_s* client = tts_client_get(tts);
987 if (NULL == client) {
988 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
989 return TTS_ERROR_INVALID_PARAMETER;
992 *state = client->current_state;
995 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
996 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
997 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
998 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
999 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1002 return TTS_ERROR_NONE;
1005 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1007 if (0 != __tts_get_feature_enabled()) {
1008 return TTS_ERROR_NOT_SUPPORTED;
1011 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1012 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1013 return TTS_ERROR_INVALID_PARAMETER;
1016 tts_client_s* client = tts_client_get(tts);
1018 if (NULL == client) {
1019 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1020 return TTS_ERROR_INVALID_PARAMETER;
1023 *min = TTS_SPEED_MIN;
1024 *normal = TTS_SPEED_NORMAL;
1025 *max = TTS_SPEED_MAX;
1027 return TTS_ERROR_NONE;
1030 int tts_get_error_message(tts_h tts, char** err_msg)
1032 if (0 != __tts_get_feature_enabled()) {
1033 return TTS_ERROR_NOT_SUPPORTED;
1036 if (NULL == tts || NULL == err_msg) {
1037 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1038 return TTS_ERROR_INVALID_PARAMETER;
1041 tts_client_s* client = tts_client_get(tts);
1043 if (NULL == client) {
1044 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1045 return TTS_ERROR_INVALID_PARAMETER;
1048 if (NULL != client->err_msg) {
1049 *err_msg = strdup(client->err_msg);
1050 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1053 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1056 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1058 return TTS_ERROR_NONE;
1061 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1063 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1065 if (0 != __tts_get_feature_enabled()) {
1066 return TTS_ERROR_NOT_SUPPORTED;
1070 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1071 return TTS_ERROR_INVALID_PARAMETER;
1074 if (voice_type < 0) {
1075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1076 return TTS_ERROR_INVALID_PARAMETER;
1079 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1081 if (NULL == tts || NULL == utt_id) {
1082 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1083 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1084 return TTS_ERROR_INVALID_PARAMETER;
1087 tts_client_s* client = tts_client_get(tts);
1089 if (NULL == client) {
1090 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1091 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1092 return TTS_ERROR_INVALID_PARAMETER;
1095 if (TTS_STATE_CREATED == client->current_state) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1097 return TTS_ERROR_INVALID_STATE;
1100 if (-1 == g_max_text_size) {
1101 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1102 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1103 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1104 return TTS_ERROR_INVALID_PARAMETER;
1108 if (0 == g_max_text_size) {
1109 if (strlen(text) <= 0) {
1110 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1111 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1112 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1113 return TTS_ERROR_INVALID_PARAMETER;
1116 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1117 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1118 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1119 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1120 return TTS_ERROR_INVALID_PARAMETER;
1124 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1126 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1127 return TTS_ERROR_INVALID_PARAMETER;
1130 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1131 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1132 return TTS_ERROR_INVALID_STATE;
1135 if (true == client->credential_needed && NULL == client->credential) {
1136 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1137 return TTS_ERROR_PERMISSION_DENIED;
1140 /* check valid utf8 */
1144 dbus_error_init(&err);
1146 valid = dbus_validate_utf8(text, &err);
1147 if (dbus_error_is_set(&err)) {
1148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1149 dbus_error_free(&err);
1150 return TTS_ERROR_INVALID_PARAMETER;
1153 if (valid != true) {
1154 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1155 return TTS_ERROR_INVALID_PARAMETER;
1157 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1159 /* save texts for repetition */
1160 if (NULL != client->text_repeat) {
1161 free(client->text_repeat);
1162 client->text_repeat = NULL;
1165 client->text_repeat = strdup(text);
1167 if (NULL != g_language) {
1171 if (NULL == language)
1174 g_language = strdup(language);
1176 g_voice_type = voice_type;
1179 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);
1181 /* change default language value */
1184 if (NULL == language)
1185 temp = strdup("default");
1187 temp = strdup(language);
1189 client->current_utt_id++;
1190 if (client->current_utt_id == 10000) {
1191 client->current_utt_id = 1;
1197 bool is_prepared = false;
1199 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1201 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1202 client->current_state = TTS_STATE_CREATED;
1203 if (0 == tts_prepare_sync(tts)) {
1205 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1207 } else if (TTS_ERROR_TIMED_OUT != ret) {
1208 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1211 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1214 if (TTS_RETRY_MIN_COUNT == count) {
1215 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1220 *utt_id = client->current_utt_id;
1229 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1234 static void __tts_play_async(void *data)
1236 tts_h tts = (tts_h)data;
1237 tts_client_s* client = tts_client_get(tts);
1240 if (NULL == client) {
1241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1247 bool is_prepared = false;
1249 ret = tts_dbus_request_play(client->uid, client->credential);
1251 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1252 client->current_state = TTS_STATE_CREATED;
1253 if (0 == tts_prepare_sync(tts)) {
1255 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1257 } else if (TTS_ERROR_TIMED_OUT != ret) {
1258 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1261 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1264 if (TTS_RETRY_COUNT == count) {
1265 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1273 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1275 client->reason = ret;
1276 client->utt_id = -1;
1278 ecore_timer_add(0, __tts_notify_error, client->tts);
1282 client->before_state = client->current_state;
1283 client->current_state = TTS_STATE_PLAYING;
1285 if (NULL != client->state_changed_cb) {
1286 tts_client_use_callback(client);
1287 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1288 tts_client_not_use_callback(client);
1289 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1292 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1297 int tts_play_async(tts_h tts)
1299 if (0 != __tts_get_feature_enabled()) {
1300 return TTS_ERROR_NOT_SUPPORTED;
1303 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1306 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1307 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1308 return TTS_ERROR_INVALID_PARAMETER;
1311 tts_client_s* client = tts_client_get(tts);
1313 if (NULL == client) {
1314 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1315 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1316 return TTS_ERROR_INVALID_PARAMETER;
1319 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1320 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1321 return TTS_ERROR_INVALID_STATE;
1324 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1325 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1326 return TTS_ERROR_INVALID_STATE;
1329 if (true == client->credential_needed && NULL == client->credential) {
1330 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1331 return TTS_ERROR_PERMISSION_DENIED;
1334 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1336 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1338 return TTS_ERROR_NONE;
1341 int tts_play(tts_h tts)
1343 if (0 != __tts_get_feature_enabled()) {
1344 return TTS_ERROR_NOT_SUPPORTED;
1347 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1350 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1351 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1352 return TTS_ERROR_INVALID_PARAMETER;
1355 tts_client_s* client = tts_client_get(tts);
1357 if (NULL == client) {
1358 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1359 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1360 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1361 return TTS_ERROR_INVALID_PARAMETER;
1364 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1365 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1366 return TTS_ERROR_INVALID_STATE;
1369 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1370 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1371 return TTS_ERROR_INVALID_STATE;
1374 if (true == client->credential_needed && NULL == client->credential) {
1375 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1376 return TTS_ERROR_PERMISSION_DENIED;
1381 bool is_prepared = false;
1383 ret = tts_dbus_request_play(client->uid, client->credential);
1385 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1386 client->current_state = TTS_STATE_CREATED;
1387 if (0 == tts_prepare_sync(tts)) {
1389 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1391 } else if (TTS_ERROR_TIMED_OUT != ret) {
1392 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1395 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1398 if (TTS_RETRY_COUNT == count) {
1399 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1406 client->before_state = client->current_state;
1407 client->current_state = TTS_STATE_PLAYING;
1409 if (NULL != client->state_changed_cb) {
1410 tts_client_use_callback(client);
1411 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1412 tts_client_not_use_callback(client);
1413 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1416 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1418 return TTS_ERROR_NONE;
1421 static void __tts_stop_async(void *data)
1423 tts_h tts = (tts_h)data;
1424 tts_client_s* client = tts_client_get(tts);
1427 if (NULL == client) {
1428 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1434 bool is_prepared = false;
1436 ret = tts_dbus_request_stop(client->uid);
1438 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1439 client->current_state = TTS_STATE_CREATED;
1440 if (0 == tts_prepare_sync(tts)) {
1442 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1444 } else if (TTS_ERROR_TIMED_OUT != ret) {
1445 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1448 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1451 if (TTS_RETRY_COUNT == count) {
1452 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1460 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1462 client->reason = ret;
1463 client->utt_id = -1;
1465 ecore_timer_add(0, __tts_notify_error, client->tts);
1469 client->before_state = client->current_state;
1470 client->current_state = TTS_STATE_READY;
1472 if (NULL != client->state_changed_cb) {
1473 tts_client_use_callback(client);
1474 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1475 tts_client_not_use_callback(client);
1476 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1479 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1484 int tts_stop_aync(tts_h tts)
1486 if (0 != __tts_get_feature_enabled()) {
1487 return TTS_ERROR_NOT_SUPPORTED;
1490 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1493 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1494 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1495 return TTS_ERROR_INVALID_PARAMETER;
1498 tts_client_s* client = tts_client_get(tts);
1500 if (NULL == client) {
1501 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1502 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1503 return TTS_ERROR_INVALID_PARAMETER;
1506 if (TTS_STATE_CREATED == client->current_state) {
1507 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1508 return TTS_ERROR_INVALID_STATE;
1511 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1512 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1513 return TTS_ERROR_INVALID_STATE;
1516 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1518 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1520 return TTS_ERROR_NONE;
1523 int tts_stop(tts_h tts)
1525 if (0 != __tts_get_feature_enabled()) {
1526 return TTS_ERROR_NOT_SUPPORTED;
1529 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1532 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1533 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1534 return TTS_ERROR_INVALID_PARAMETER;
1537 tts_client_s* client = tts_client_get(tts);
1539 if (NULL == client) {
1540 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1541 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1542 return TTS_ERROR_INVALID_PARAMETER;
1545 if (TTS_STATE_CREATED == client->current_state) {
1546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1547 return TTS_ERROR_INVALID_STATE;
1550 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1551 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1552 return TTS_ERROR_INVALID_STATE;
1557 bool is_prepared = false;
1559 ret = tts_dbus_request_stop(client->uid);
1561 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1562 client->current_state = TTS_STATE_CREATED;
1563 if (0 == tts_prepare_sync(tts)) {
1565 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1567 } else if (TTS_ERROR_TIMED_OUT != ret) {
1568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1571 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1574 if (TTS_RETRY_COUNT == count) {
1575 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1582 client->before_state = client->current_state;
1583 client->current_state = TTS_STATE_READY;
1585 if (NULL != client->state_changed_cb) {
1586 tts_client_use_callback(client);
1587 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1588 tts_client_not_use_callback(client);
1589 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1592 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1594 return TTS_ERROR_NONE;
1597 static void __tts_pause_async(void *data)
1599 tts_h tts = (tts_h)data;
1600 tts_client_s* client = tts_client_get(tts);
1603 if (NULL == client) {
1604 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1610 bool is_prepared = false;
1612 ret = tts_dbus_request_pause(client->uid);
1614 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1615 client->current_state = TTS_STATE_CREATED;
1616 if (0 == tts_prepare_sync(tts)) {
1618 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1620 } else if (TTS_ERROR_TIMED_OUT != ret) {
1621 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1624 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1627 if (TTS_RETRY_COUNT == count) {
1628 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1636 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1638 client->reason = ret;
1639 client->utt_id = -1;
1641 ecore_timer_add(0, __tts_notify_error, client->tts);
1645 client->before_state = client->current_state;
1646 client->current_state = TTS_STATE_PAUSED;
1648 if (NULL != client->state_changed_cb) {
1649 tts_client_use_callback(client);
1650 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1651 tts_client_not_use_callback(client);
1652 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1655 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1660 int tts_pause_async(tts_h tts)
1662 if (0 != __tts_get_feature_enabled()) {
1663 return TTS_ERROR_NOT_SUPPORTED;
1666 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1669 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1670 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1671 return TTS_ERROR_INVALID_PARAMETER;
1674 tts_client_s* client = tts_client_get(tts);
1676 if (NULL == client) {
1677 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1678 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1679 return TTS_ERROR_INVALID_PARAMETER;
1682 if (TTS_STATE_PLAYING != client->current_state) {
1683 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1684 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1685 return TTS_ERROR_INVALID_STATE;
1688 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1689 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1690 return TTS_ERROR_INVALID_STATE;
1693 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1695 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1697 return TTS_ERROR_NONE;
1700 int tts_pause(tts_h tts)
1702 if (0 != __tts_get_feature_enabled()) {
1703 return TTS_ERROR_NOT_SUPPORTED;
1706 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1709 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1710 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1711 return TTS_ERROR_INVALID_PARAMETER;
1714 tts_client_s* client = tts_client_get(tts);
1716 if (NULL == client) {
1717 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1718 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1719 return TTS_ERROR_INVALID_PARAMETER;
1722 if (TTS_STATE_PLAYING != client->current_state) {
1723 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1724 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1725 return TTS_ERROR_INVALID_STATE;
1728 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1729 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1730 return TTS_ERROR_INVALID_STATE;
1735 bool is_prepared = false;
1737 ret = tts_dbus_request_pause(client->uid);
1739 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1740 client->current_state = TTS_STATE_CREATED;
1741 if (0 == tts_prepare_sync(tts)) {
1743 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1745 } else if (TTS_ERROR_TIMED_OUT != ret) {
1746 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1749 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1752 if (TTS_RETRY_COUNT == count) {
1753 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1760 client->before_state = client->current_state;
1761 client->current_state = TTS_STATE_PAUSED;
1763 if (NULL != client->state_changed_cb) {
1764 tts_client_use_callback(client);
1765 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1766 tts_client_not_use_callback(client);
1767 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1770 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1772 return TTS_ERROR_NONE;
1775 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1777 if (0 != __tts_get_feature_enabled()) {
1778 return TTS_ERROR_NOT_SUPPORTED;
1781 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1784 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1785 return TTS_ERROR_INVALID_PARAMETER;
1788 if (NULL == key || NULL == data) {
1789 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1790 return TTS_ERROR_INVALID_PARAMETER;
1793 tts_client_s* client = tts_client_get(tts);
1795 if (NULL == client) {
1796 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1797 return TTS_ERROR_INVALID_PARAMETER;
1800 if (TTS_STATE_READY != client->current_state) {
1801 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1802 return TTS_ERROR_INVALID_STATE;
1805 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1806 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1807 return TTS_ERROR_INVALID_PARAMETER;
1812 bool is_prepared = false;
1814 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1816 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1817 client->current_state = TTS_STATE_CREATED;
1818 if (0 == tts_prepare_sync(tts)) {
1820 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1822 } else if (TTS_ERROR_TIMED_OUT != ret) {
1823 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1826 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1829 if (TTS_RETRY_COUNT == count) {
1830 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1837 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1842 int tts_get_private_data(tts_h tts, const char* key, char** data)
1844 if (0 != __tts_get_feature_enabled()) {
1845 return TTS_ERROR_NOT_SUPPORTED;
1848 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1851 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1852 return TTS_ERROR_INVALID_PARAMETER;
1855 if (NULL == key || NULL == data) {
1856 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1857 return TTS_ERROR_INVALID_PARAMETER;
1860 tts_client_s* client = tts_client_get(tts);
1862 if (NULL == client) {
1863 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1864 return TTS_ERROR_INVALID_PARAMETER;
1867 if (TTS_STATE_READY != client->current_state) {
1868 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1869 return TTS_ERROR_INVALID_STATE;
1874 bool is_prepared = false;
1876 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1878 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1879 client->current_state = TTS_STATE_CREATED;
1880 if (0 == tts_prepare_sync(tts)) {
1882 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1884 } else if (TTS_ERROR_TIMED_OUT != ret) {
1885 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1888 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1891 if (TTS_RETRY_COUNT == count) {
1892 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1899 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1904 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1909 static Eina_Bool __tts_notify_error(void *data)
1911 tts_h tts = (tts_h)data;
1913 tts_client_s* client = tts_client_get(tts);
1916 if (NULL == client) {
1917 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1921 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1923 if (NULL != client->error_cb) {
1924 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1925 tts_client_use_callback(client);
1926 g_err_callback_status = true;
1927 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1928 g_err_callback_status = false;
1929 tts_client_not_use_callback(client);
1931 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1937 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1940 GList* client_list = NULL;
1941 client_list = tts_client_get_client_list();
1944 tts_client_s *data = NULL;
1946 if (g_list_length(client_list) > 0) {
1947 /* Get a first item */
1948 iter = g_list_first(client_list);
1950 while (NULL != iter) {
1953 data->utt_id = utt_id;
1954 data->reason = reason;
1955 if (NULL != data->err_msg) {
1956 free(data->err_msg);
1957 data->err_msg = NULL;
1959 if (NULL != err_msg)
1960 data->err_msg = strdup(err_msg);
1962 /* call callback function */
1963 if (NULL != data->error_cb) {
1964 ecore_timer_add(0, __tts_notify_error, data->tts);
1966 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1969 if (TTS_ERROR_SERVICE_RESET == reason) {
1970 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1972 data->current_state = TTS_STATE_CREATED;
1973 if (0 != tts_prepare(data->tts)) {
1974 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1979 iter = g_list_next(iter);
1983 tts_client_s* client = tts_client_get_by_uid(uid);
1985 if (NULL == client) {
1986 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1987 return TTS_ERROR_INVALID_PARAMETER;
1990 client->utt_id = utt_id;
1991 client->reason = reason;
1992 if (NULL != client->err_msg) {
1993 free(client->err_msg);
1994 client->err_msg = NULL;
1996 if (NULL != err_msg)
1997 client->err_msg = strdup(err_msg);
1999 /* call callback function */
2000 if (NULL != client->error_cb) {
2001 ecore_timer_add(0, __tts_notify_error, client->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 client->current_state = TTS_STATE_CREATED;
2010 if (0 != tts_prepare(client->tts)) {
2011 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2019 static Eina_Bool __tts_notify_state_changed(void *data)
2021 tts_h tts = (tts_h)data;
2023 tts_client_s* client = tts_client_get(tts);
2026 if (NULL == client) {
2027 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2031 if (NULL != client->state_changed_cb) {
2032 tts_client_use_callback(client);
2033 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2034 tts_client_not_use_callback(client);
2035 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2037 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2043 int __tts_cb_set_state(int uid, int state)
2045 tts_client_s* client = tts_client_get_by_uid(uid);
2046 if (NULL == client) {
2047 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2051 tts_state_e state_from_daemon = (tts_state_e)state;
2053 if (client->current_state == state_from_daemon) {
2054 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2058 if (NULL != client->state_changed_cb) {
2059 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2061 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2064 client->before_state = client->current_state;
2065 client->current_state = state_from_daemon;
2070 int __tts_cb_utt_started(int uid, int utt_id)
2072 tts_client_s* client = tts_client_get_by_uid(uid);
2074 if (NULL == client) {
2075 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2076 return TTS_ERROR_INVALID_PARAMETER;
2079 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2081 client->utt_id = utt_id;
2083 /* call callback function */
2084 if (NULL != client->utt_started_cb) {
2085 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2086 tts_client_use_callback(client);
2087 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2088 tts_client_not_use_callback(client);
2090 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2096 int __tts_cb_utt_completed(int uid, int utt_id)
2098 tts_client_s* client = tts_client_get_by_uid(uid);
2100 if (NULL == client) {
2101 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2102 return TTS_ERROR_INVALID_PARAMETER;
2105 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2107 client->utt_id = utt_id;
2109 /* call callback function */
2110 if (NULL != client->utt_completeted_cb) {
2111 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2112 tts_client_use_callback(client);
2113 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2114 tts_client_not_use_callback(client);
2116 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2122 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2124 if (0 != __tts_get_feature_enabled()) {
2125 return TTS_ERROR_NOT_SUPPORTED;
2128 if (NULL == tts || NULL == callback) {
2129 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2130 return TTS_ERROR_INVALID_PARAMETER;
2133 tts_client_s* client = tts_client_get(tts);
2135 if (NULL == client) {
2136 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2137 return TTS_ERROR_INVALID_PARAMETER;
2140 if (TTS_STATE_CREATED != client->current_state) {
2141 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2142 return TTS_ERROR_INVALID_STATE;
2145 client->state_changed_cb = callback;
2146 client->state_changed_user_data = user_data;
2148 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2153 int tts_unset_state_changed_cb(tts_h tts)
2155 if (0 != __tts_get_feature_enabled()) {
2156 return TTS_ERROR_NOT_SUPPORTED;
2160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2161 return TTS_ERROR_INVALID_PARAMETER;
2164 tts_client_s* client = tts_client_get(tts);
2166 if (NULL == client) {
2167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2168 return TTS_ERROR_INVALID_PARAMETER;
2171 if (TTS_STATE_CREATED != client->current_state) {
2172 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2173 return TTS_ERROR_INVALID_STATE;
2176 client->state_changed_cb = NULL;
2177 client->state_changed_user_data = NULL;
2179 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2184 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2186 if (0 != __tts_get_feature_enabled()) {
2187 return TTS_ERROR_NOT_SUPPORTED;
2190 if (NULL == tts || NULL == callback) {
2191 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2192 return TTS_ERROR_INVALID_PARAMETER;
2195 tts_client_s* client = tts_client_get(tts);
2197 if (NULL == client) {
2198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2199 return TTS_ERROR_INVALID_PARAMETER;
2202 if (TTS_STATE_CREATED != client->current_state) {
2203 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2204 return TTS_ERROR_INVALID_STATE;
2207 client->utt_started_cb = callback;
2208 client->utt_started_user_data = user_data;
2210 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2215 int tts_unset_utterance_started_cb(tts_h tts)
2217 if (0 != __tts_get_feature_enabled()) {
2218 return TTS_ERROR_NOT_SUPPORTED;
2222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2223 return TTS_ERROR_INVALID_PARAMETER;
2226 tts_client_s* client = tts_client_get(tts);
2228 if (NULL == client) {
2229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2230 return TTS_ERROR_INVALID_PARAMETER;
2233 if (TTS_STATE_CREATED != client->current_state) {
2234 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2235 return TTS_ERROR_INVALID_STATE;
2238 client->utt_started_cb = NULL;
2239 client->utt_started_user_data = NULL;
2241 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2246 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2248 if (0 != __tts_get_feature_enabled()) {
2249 return TTS_ERROR_NOT_SUPPORTED;
2252 if (NULL == tts || NULL == callback) {
2253 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2254 return TTS_ERROR_INVALID_PARAMETER;
2257 tts_client_s* client = tts_client_get(tts);
2259 if (NULL == client) {
2260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2261 return TTS_ERROR_INVALID_PARAMETER;
2264 if (TTS_STATE_CREATED != client->current_state) {
2265 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2266 return TTS_ERROR_INVALID_STATE;
2269 client->utt_completeted_cb = callback;
2270 client->utt_completed_user_data = user_data;
2272 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2277 int tts_unset_utterance_completed_cb(tts_h tts)
2279 if (0 != __tts_get_feature_enabled()) {
2280 return TTS_ERROR_NOT_SUPPORTED;
2284 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2285 return TTS_ERROR_INVALID_PARAMETER;
2288 tts_client_s* client = tts_client_get(tts);
2290 if (NULL == client) {
2291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2292 return TTS_ERROR_INVALID_PARAMETER;
2295 if (TTS_STATE_CREATED != client->current_state) {
2296 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2297 return TTS_ERROR_INVALID_STATE;
2300 client->utt_completeted_cb = NULL;
2301 client->utt_completed_user_data = NULL;
2303 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2307 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2309 if (0 != __tts_get_feature_enabled()) {
2310 return TTS_ERROR_NOT_SUPPORTED;
2313 if (NULL == tts || NULL == callback) {
2314 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2315 return TTS_ERROR_INVALID_PARAMETER;
2318 tts_client_s* client = tts_client_get(tts);
2320 if (NULL == client) {
2321 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2322 return TTS_ERROR_INVALID_PARAMETER;
2325 if (TTS_STATE_CREATED != client->current_state) {
2326 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2327 return TTS_ERROR_INVALID_STATE;
2330 client->error_cb = callback;
2331 client->error_user_data = user_data;
2333 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2338 int tts_unset_error_cb(tts_h tts)
2340 if (0 != __tts_get_feature_enabled()) {
2341 return TTS_ERROR_NOT_SUPPORTED;
2345 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2346 return TTS_ERROR_INVALID_PARAMETER;
2349 tts_client_s* client = tts_client_get(tts);
2351 if (NULL == client) {
2352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2353 return TTS_ERROR_INVALID_PARAMETER;
2356 if (TTS_STATE_CREATED != client->current_state) {
2357 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2358 return TTS_ERROR_INVALID_STATE;
2361 client->error_cb = NULL;
2362 client->error_user_data = NULL;
2364 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2369 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2371 if (0 != __tts_get_feature_enabled()) {
2372 return TTS_ERROR_NOT_SUPPORTED;
2375 if (NULL == tts || NULL == callback) {
2376 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2377 return TTS_ERROR_INVALID_PARAMETER;
2380 tts_client_s* client = tts_client_get(tts);
2382 if (NULL == client) {
2383 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2384 return TTS_ERROR_INVALID_PARAMETER;
2387 if (TTS_STATE_CREATED != client->current_state) {
2388 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2389 return TTS_ERROR_INVALID_STATE;
2392 client->default_voice_changed_cb = callback;
2393 client->default_voice_changed_user_data = user_data;
2395 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2400 int tts_unset_default_voice_changed_cb(tts_h tts)
2402 if (0 != __tts_get_feature_enabled()) {
2403 return TTS_ERROR_NOT_SUPPORTED;
2407 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2408 return TTS_ERROR_INVALID_PARAMETER;
2411 tts_client_s* client = tts_client_get(tts);
2413 if (NULL == client) {
2414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2415 return TTS_ERROR_INVALID_PARAMETER;
2418 if (TTS_STATE_CREATED != client->current_state) {
2419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2420 return TTS_ERROR_INVALID_STATE;
2423 client->default_voice_changed_cb = NULL;
2424 client->default_voice_changed_user_data = NULL;
2426 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2431 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2433 if (0 != __tts_get_feature_enabled()) {
2434 return TTS_ERROR_NOT_SUPPORTED;
2437 if (NULL == tts || NULL == callback) {
2438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2439 return TTS_ERROR_INVALID_PARAMETER;
2442 tts_client_s* client = tts_client_get(tts);
2444 if (NULL == client) {
2445 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2446 return TTS_ERROR_INVALID_PARAMETER;
2449 if (TTS_STATE_CREATED != client->current_state) {
2450 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2451 return TTS_ERROR_INVALID_STATE;
2454 client->engine_changed_cb = callback;
2455 client->engine_changed_user_data = user_data;
2457 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2462 int tts_unset_engine_changed_cb(tts_h tts)
2464 if (0 != __tts_get_feature_enabled()) {
2465 return TTS_ERROR_NOT_SUPPORTED;
2469 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2470 return TTS_ERROR_INVALID_PARAMETER;
2473 tts_client_s* client = tts_client_get(tts);
2475 if (NULL == client) {
2476 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2477 return TTS_ERROR_INVALID_PARAMETER;
2480 if (TTS_STATE_CREATED != client->current_state) {
2481 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2482 return TTS_ERROR_INVALID_STATE;
2485 client->engine_changed_cb = NULL;
2486 client->engine_changed_user_data = NULL;
2488 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2493 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2495 if (0 != __tts_get_feature_enabled()) {
2496 return TTS_ERROR_NOT_SUPPORTED;
2499 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2503 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2504 return TTS_ERROR_INVALID_PARAMETER;
2507 tts_client_s* client = tts_client_get(tts);
2509 if (NULL == client) {
2510 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2511 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2512 return TTS_ERROR_INVALID_PARAMETER;
2515 if (TTS_STATE_CREATED == client->current_state) {
2516 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2517 return TTS_ERROR_INVALID_STATE;
2520 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2521 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2522 return TTS_ERROR_INVALID_STATE;
2527 bool is_prepared = false;
2529 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2531 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2532 client->current_state = TTS_STATE_CREATED;
2533 if (0 == tts_prepare_sync(tts)) {
2535 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2537 } else if (TTS_ERROR_TIMED_OUT != ret) {
2538 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2541 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2544 if (TTS_RETRY_COUNT == count) {
2545 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2552 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2554 return TTS_ERROR_NONE;
2557 int tts_play_pcm(tts_h tts)
2559 if (0 != __tts_get_feature_enabled()) {
2560 return TTS_ERROR_NOT_SUPPORTED;
2563 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2566 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2567 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2568 return TTS_ERROR_INVALID_PARAMETER;
2571 tts_client_s* client = tts_client_get(tts);
2573 if (NULL == client) {
2574 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2575 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2576 return TTS_ERROR_INVALID_PARAMETER;
2579 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2580 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2581 return TTS_ERROR_INVALID_STATE;
2584 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2585 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2586 return TTS_ERROR_INVALID_STATE;
2591 bool is_prepared = false;
2593 ret = tts_dbus_request_play_pcm(client->uid);
2595 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2596 client->current_state = TTS_STATE_CREATED;
2597 if (0 == tts_prepare_sync(tts)) {
2599 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2601 } else if (TTS_ERROR_TIMED_OUT != ret) {
2602 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2605 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2608 if (TTS_RETRY_COUNT == count) {
2609 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2616 client->before_state = client->current_state;
2617 client->current_state = TTS_STATE_PLAYING;
2619 if (NULL != client->state_changed_cb) {
2620 tts_client_use_callback(client);
2621 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2622 tts_client_not_use_callback(client);
2623 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2626 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2628 return TTS_ERROR_NONE;
2631 int tts_stop_pcm(tts_h tts)
2633 if (0 != __tts_get_feature_enabled()) {
2634 return TTS_ERROR_NOT_SUPPORTED;
2637 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2640 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2641 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2642 return TTS_ERROR_INVALID_PARAMETER;
2645 tts_client_s* client = tts_client_get(tts);
2647 if (NULL == client) {
2648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2649 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2650 return TTS_ERROR_INVALID_PARAMETER;
2653 if (TTS_STATE_CREATED == client->current_state) {
2654 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2655 return TTS_ERROR_INVALID_STATE;
2658 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2659 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2660 return TTS_ERROR_INVALID_STATE;
2665 bool is_prepared = false;
2667 ret = tts_dbus_request_stop_pcm(client->uid);
2669 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2670 client->current_state = TTS_STATE_CREATED;
2671 if (0 == tts_prepare_sync(tts)) {
2673 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2675 } else if (TTS_ERROR_TIMED_OUT != ret) {
2676 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2679 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2682 if (TTS_RETRY_COUNT == count) {
2683 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2690 client->before_state = client->current_state;
2691 client->current_state = TTS_STATE_READY;
2693 if (NULL != client->state_changed_cb) {
2694 tts_client_use_callback(client);
2695 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2696 tts_client_not_use_callback(client);
2697 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2700 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2702 return TTS_ERROR_NONE;
2705 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
2707 if (0 != __tts_get_feature_enabled()) {
2708 return TTS_ERROR_NOT_SUPPORTED;
2711 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
2714 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2715 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2716 return TTS_ERROR_INVALID_PARAMETER;
2719 if (NULL == text_repeat || NULL == utt_id) {
2720 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
2721 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2722 return TTS_ERROR_INVALID_PARAMETER;
2725 *text_repeat = NULL;
2728 tts_client_s* client = tts_client_get(tts);
2730 if (NULL == client) {
2731 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2732 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2733 return TTS_ERROR_INVALID_PARAMETER;
2736 if (TTS_STATE_READY != client->current_state) {
2737 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
2738 return TTS_ERROR_INVALID_STATE;
2741 /* Clear the legacy and Add texts to be played repeatedly */
2743 ret = tts_stop(tts);
2744 if (TTS_ERROR_NONE != ret) {
2745 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
2749 if (NULL != client->text_repeat) {
2750 char* tmp_text = strdup(client->text_repeat);
2751 char* tmp_lang = NULL;
2752 if (NULL != g_language) {
2753 tmp_lang = strdup(g_language);
2755 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
2756 if (TTS_ERROR_NONE != ret) {
2757 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
2758 if (NULL != tmp_text) {
2762 if (NULL != tmp_lang) {
2768 *text_repeat = strdup(client->text_repeat);
2769 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
2770 if (NULL != tmp_text) {
2774 if (NULL != tmp_lang) {
2779 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
2780 return TTS_ERROR_OPERATION_FAILED;
2783 /* Play added texts */
2784 ret = tts_play(tts);
2785 if (TTS_ERROR_NONE != ret) {
2786 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
2787 if (NULL != *text_repeat) {
2789 *text_repeat = NULL;
2795 return TTS_ERROR_NONE;