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>
23 #include <package-manager.h>
27 #include "tts_client.h"
28 #include "tts_config_mgr.h"
32 #include "tts_internal.h"
34 static bool g_screen_reader;
36 static int g_feature_enabled = -1;
38 static bool g_err_callback_status = false;
40 static int g_max_text_size = -1;
42 static Ecore_Timer* g_check_state_timer = NULL;
44 static Ecore_Timer* g_hello_timer;
47 static char* g_language = NULL;
49 static int g_voice_type = -1;
51 static int g_speed = -1;
53 /* for checking engine update */
54 static pkgmgr_client* g_pkgmgr = NULL;
55 static char* g_engine_name = NULL;
56 static int g_engine_update_status = 0;
57 static pthread_mutex_t g_pkgmgr_mutex = PTHREAD_MUTEX_INITIALIZER;
60 /* Function definition */
61 static Eina_Bool __tts_notify_state_changed(void *data);
62 static Eina_Bool __tts_notify_error(void *data);
63 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg);
71 static int __tts_get_feature_enabled()
73 if (0 == g_feature_enabled) {
74 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
75 return TTS_ERROR_NOT_SUPPORTED;
76 } else if (-1 == g_feature_enabled) {
77 bool tts_supported = false;
78 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
79 if (false == tts_supported) {
80 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
81 g_feature_enabled = 0;
82 return TTS_ERROR_NOT_SUPPORTED;
85 g_feature_enabled = 1;
87 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
88 return TTS_ERROR_NOT_SUPPORTED;
95 static const char* __tts_get_error_code(tts_error_e err)
98 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
99 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
100 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
101 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
102 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
103 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
104 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
105 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
106 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
107 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
108 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
109 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
110 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
111 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
112 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
114 return "Invalid error code";
119 static int __tts_convert_config_error_code(tts_config_error_e code)
121 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
122 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
123 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
124 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
125 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
126 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
127 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
128 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
129 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
135 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)
137 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
138 before_lang, before_voice_type, language, voice_type);
140 GList* client_list = NULL;
141 client_list = tts_client_get_client_list();
144 tts_client_s *data = NULL;
146 if (g_list_length(client_list) > 0) {
147 /* Get a first item */
148 iter = g_list_first(client_list);
150 while (NULL != iter) {
152 if (NULL != data->default_voice_changed_cb) {
153 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
154 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
155 language, voice_type, data->default_voice_changed_user_data);
158 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
159 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
160 if (NULL != data->text_repeat) {
161 free(data->text_repeat);
162 data->text_repeat = NULL;
167 iter = g_list_next(iter);
174 static Eina_Bool __reconnect_by_engine_changed(void* data)
176 tts_h tts = (tts_h)data;
178 tts_client_s* client = tts_client_get(tts);
179 if (NULL == client) {
180 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
184 if (TTS_STATE_READY != client->current_state) {
189 int ret = tts_unprepare(tts);
191 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
193 ret = tts_prepare(tts);
195 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
201 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)
203 tts_h tts = (tts_h)user_data;
205 tts_client_s* client = tts_client_get(tts);
206 if (NULL == client) {
207 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
211 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
212 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
213 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
214 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
216 /* When the default engine is changed, please unload the old engine and load the new one. */
219 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
222 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
225 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
226 } else if (TTS_STATE_READY == client->current_state) {
227 ret = tts_unprepare(tts);
229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
231 ret = tts_prepare(tts);
233 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
237 /* call callback function */
238 if (NULL != client->engine_changed_cb) {
239 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
241 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
247 void __tts_unset_all_callbacks(tts_h tts)
249 SLOG(LOG_INFO, TAG_TTSC, "@@@ unset all callbacks");
251 tts_unset_state_changed_cb(tts);
252 tts_unset_utterance_started_cb(tts);
253 tts_unset_utterance_completed_cb(tts);
254 tts_unset_error_cb(tts);
255 tts_unset_default_voice_changed_cb(tts);
256 tts_unset_engine_changed_cb(tts);
258 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
261 static int __pkgmgr_status_cb(uid_t target_uid, int req_id, const char *type, const char *pkgname, const char *key, const char *val, const void *pmsg, void *data)
263 SLOG(LOG_INFO, TAG_TTSC, "[INFO] pkgmgr status cb is invoked. pkgname(%s), type(%s), key(%s), val(%s)", pkgname, type, key, val);
265 if (0 != strncmp(g_engine_name, pkgname, strlen(g_engine_name))) {
266 SLOG(LOG_DEBUG, TAG_TTSC, "[WARN] this is not tts engine");
269 if (key && 0 == strncmp(key, "start", strlen(key))) {
270 if (val && (0 == strncmp(val, "update", strlen(val) || 0 == strncmp(val, "uninstall", strlen(val))))) {
271 SLOG(LOG_INFO, TAG_TTSC, "[INFO] start to install.");
272 g_engine_update_status = 1;
274 } else if (key && 0 == strncmp(key, "end", strlen(key))) {
275 SLOG(LOG_INFO, TAG_TTSC, "[INFO] finish to install");
276 g_engine_update_status = 0;
283 static void __create_pkgmgr_thread(void* data, Ecore_Thread* thread)
285 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] create pkgmgr thread");
287 pthread_mutex_lock(&g_pkgmgr_mutex);
290 g_pkgmgr = pkgmgr_client_new(PC_LISTENING);
291 if (NULL == g_pkgmgr) {
292 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create pkgmgr handle");
294 if (pkgmgr_client_listen_status(g_pkgmgr, __pkgmgr_status_cb, NULL) < 0) {
295 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to listen pkgmgr status. remove and recreate client");
296 pkgmgr_client_free(g_pkgmgr);
300 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] Succeed to register pkgmgr cb");
306 pthread_mutex_unlock(&g_pkgmgr_mutex);
311 static void __finish_pkgmgr_thread(void* data, Ecore_Thread* thread)
313 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] Finish pkgmgr thread");
316 static void __pkgmgr_thread(void* data)
318 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] call pkgmgr_thread");
320 ecore_thread_run(__create_pkgmgr_thread, __finish_pkgmgr_thread, NULL, NULL);
325 int tts_create(tts_h* tts)
327 if (0 != __tts_get_feature_enabled()) {
328 return TTS_ERROR_NOT_SUPPORTED;
331 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
335 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
336 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
337 return TTS_ERROR_INVALID_PARAMETER;
340 if (0 == tts_client_get_size()) {
341 if (0 != tts_dbus_open_connection()) {
342 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
343 return TTS_ERROR_OPERATION_FAILED;
347 if (0 != tts_client_new(tts)) {
348 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
349 return TTS_ERROR_OUT_OF_MEMORY;
352 tts_client_s* client = tts_client_get(*tts);
353 if (NULL == client) {
354 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
355 return TTS_ERROR_OPERATION_FAILED;
358 int ret = tts_config_mgr_initialize(client->uid);
360 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
361 tts_client_destroy(*tts);
362 return __tts_convert_config_error_code(ret);
365 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL, client->tts);
367 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
368 tts_client_destroy(*tts);
369 return __tts_convert_config_error_code(ret);
372 ecore_main_loop_thread_safe_call_async(__pkgmgr_thread, NULL);
374 SLOG(LOG_INFO, TAG_TTSC, "[INFO] call ecore thread for creating pkgmgr thread");
376 g_engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
377 if (NULL == g_engine_name) {
378 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine name");
380 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Engine name(%s)", g_engine_name);
383 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
384 SLOG(LOG_DEBUG, TAG_TTSC, " ");
386 return TTS_ERROR_NONE;
389 int tts_destroy(tts_h tts)
391 if (0 != __tts_get_feature_enabled()) {
392 return TTS_ERROR_NOT_SUPPORTED;
395 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
398 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
399 return TTS_ERROR_INVALID_PARAMETER;
402 tts_client_s* client = tts_client_get(tts);
405 if (NULL == client) {
406 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
407 return TTS_ERROR_INVALID_PARAMETER;
410 /* check used callback */
411 if (0 != tts_client_get_use_callback(client)) {
412 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
413 return TTS_ERROR_OPERATION_FAILED;
416 pthread_mutex_lock(&g_pkgmgr_mutex);
418 pkgmgr_client_remove_listen_status(g_pkgmgr);
419 pkgmgr_client_free(g_pkgmgr);
422 pthread_mutex_unlock(&g_pkgmgr_mutex);
424 tts_config_mgr_finalize(client->uid);
428 int screen_reader = -1;
431 switch (client->current_state) {
432 case TTS_STATE_PAUSED:
433 case TTS_STATE_PLAYING:
434 case TTS_STATE_READY:
435 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
437 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
439 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);
440 g_screen_reader = (bool)screen_reader;
442 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
444 ret = tts_dbus_request_finalize(client->uid);
447 if (TTS_ERROR_TIMED_OUT != ret) {
448 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
451 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
454 if (TTS_RETRY_COUNT == count) {
455 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
463 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
466 client->before_state = client->current_state;
467 client->current_state = TTS_STATE_CREATED;
469 case TTS_STATE_CREATED:
470 if (NULL != client->conn_timer) {
471 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
472 ecore_timer_del(client->conn_timer);
473 client->conn_timer = NULL;
475 /* Unset registered callbacks */
476 __tts_unset_all_callbacks(tts);
479 tts_client_destroy(tts);
486 if (0 == tts_client_get_size()) {
487 if (0 != tts_dbus_close_connection()) {
488 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
492 if (NULL != g_language) {
497 /* Delete state timer before destroying handle */
498 if (NULL != g_check_state_timer) {
499 ecore_timer_del(g_check_state_timer);
500 g_check_state_timer = NULL;
505 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
507 return TTS_ERROR_NONE;
511 void __tts_screen_reader_changed_cb(bool value)
513 g_screen_reader = value;
517 int tts_set_mode(tts_h tts, tts_mode_e mode)
519 if (0 != __tts_get_feature_enabled()) {
520 return TTS_ERROR_NOT_SUPPORTED;
523 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
525 tts_client_s* client = tts_client_get(tts);
528 if (NULL == client) {
529 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
530 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
531 return TTS_ERROR_INVALID_PARAMETER;
535 if (client->current_state != TTS_STATE_CREATED) {
536 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
537 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
538 SLOG(LOG_DEBUG, TAG_TTSC, " ");
539 return TTS_ERROR_INVALID_STATE;
542 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
545 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
546 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
547 SLOG(LOG_DEBUG, TAG_TTSC, " ");
548 return TTS_ERROR_INVALID_PARAMETER;
551 if (TTS_MODE_SCREEN_READER == mode) {
554 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
556 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
557 return TTS_ERROR_OPERATION_FAILED;
559 g_screen_reader = (bool)screen_reader;
560 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
562 tts_config_unset_screen_reader_callback(client->uid);
565 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
567 return TTS_ERROR_NONE;
570 int tts_get_mode(tts_h tts, tts_mode_e* mode)
572 if (0 != __tts_get_feature_enabled()) {
573 return TTS_ERROR_NOT_SUPPORTED;
576 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
578 tts_client_s* client = tts_client_get(tts);
581 if (NULL == client) {
582 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
583 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
584 SLOG(LOG_DEBUG, TAG_TTSC, " ");
585 return TTS_ERROR_INVALID_PARAMETER;
589 if (client->current_state != TTS_STATE_CREATED) {
590 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
591 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
592 SLOG(LOG_DEBUG, TAG_TTSC, " ");
593 return TTS_ERROR_INVALID_STATE;
597 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
598 return TTS_ERROR_INVALID_PARAMETER;
601 *mode = client->mode;
603 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
604 SLOG(LOG_DEBUG, TAG_TTSC, " ");
606 return TTS_ERROR_NONE;
609 int tts_set_credential(tts_h tts, const char* credential)
611 if (0 != __tts_get_feature_enabled()) {
612 return TTS_ERROR_NOT_SUPPORTED;
615 if (NULL == tts || NULL == credential) {
616 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
617 return TTS_ERROR_INVALID_PARAMETER;
620 tts_client_s* client = tts_client_get(tts);
622 if (NULL == client) {
623 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
624 return TTS_ERROR_INVALID_PARAMETER;
627 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
628 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
629 return TTS_ERROR_INVALID_STATE;
632 if (NULL != client->credential) {
633 free(client->credential);
634 client->credential = NULL;
636 client->credential = strdup(credential);
638 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
640 return TTS_ERROR_NONE;
644 int tts_set_server_tts(tts_h tts, const char* credential)
646 if (0 != __tts_get_feature_enabled()) {
647 return TTS_ERROR_NOT_SUPPORTED;
651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
652 return TTS_ERROR_INVALID_PARAMETER;
655 tts_client_s* client = tts_client_get(tts);
657 if (NULL == client) {
658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
659 return TTS_ERROR_INVALID_PARAMETER;
662 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
663 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
664 return TTS_ERROR_INVALID_STATE;
667 if (NULL != client->credential) {
668 free(client->credential);
669 client->credential = NULL;
672 client->internal = true;
675 if (NULL != credential) {
676 key = strdup("EnableServerTTS");
677 client->credential = strdup(credential);
678 if (NULL == client->credential) {
679 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
684 return TTS_ERROR_OUT_OF_MEMORY;
687 key = strdup("DisableServerTTS");
691 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
692 return TTS_ERROR_OUT_OF_MEMORY;
697 int ret = app_manager_get_app_id(pid, &appid);
698 if (0 != ret || NULL == appid) {
699 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
706 return TTS_ERROR_OPERATION_FAILED;
709 ret = tts_set_private_data(tts, key, appid);
711 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
724 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
726 return TTS_ERROR_NONE;
730 static Eina_Bool __tts_connect_daemon(void *data)
732 tts_h tts = (tts_h)data;
733 tts_client_s* client = tts_client_get(tts);
736 if (NULL == client) {
737 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
741 /* check whether engine is updating or not */
742 if (g_engine_update_status) {
743 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] cannot prepare due to engine update");
744 __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
750 if (0 != tts_dbus_request_hello_sync(client->uid)) {
754 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
756 /* do request initialize */
758 bool credential_needed = false;
760 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
762 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
763 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
765 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
768 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
769 if (client->conn_timer) {
770 ecore_timer_del(client->conn_timer);
771 client->conn_timer = NULL;
775 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
776 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
778 client->reason = TTS_ERROR_PERMISSION_DENIED;
781 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
782 if (client->conn_timer) {
783 ecore_timer_del(client->conn_timer);
784 client->conn_timer = NULL;
788 } else if (TTS_ERROR_NONE != ret) {
789 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
793 /* success to connect tts-daemon */
794 client->credential_needed = credential_needed;
795 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
798 if (client->conn_timer) {
799 ecore_timer_del(client->conn_timer);
800 client->conn_timer = NULL;
803 client = tts_client_get(tts);
805 if (NULL == client) {
806 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
810 client->before_state = client->current_state;
811 client->current_state = TTS_STATE_READY;
813 if (NULL != client->state_changed_cb) {
814 tts_client_use_callback(client);
815 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
816 tts_client_not_use_callback(client);
818 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
821 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
826 int __tts_cb_hello(int uid, int ret, int credential_needed)
828 tts_client_s* client = tts_client_get_by_uid(uid);
829 if (NULL == client) {
830 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client or ignore this uid(%d)", uid);
831 return TTS_ERROR_OPERATION_FAILED;
835 ecore_timer_del(g_hello_timer);
836 g_hello_timer = NULL;
839 if (TTS_STATE_READY == client->current_state) {
840 SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts client is already READY");
841 return TTS_ERROR_NONE;
844 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
845 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
847 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
850 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
851 return TTS_ERROR_OPERATION_FAILED;
853 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
854 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
856 client->reason = TTS_ERROR_PERMISSION_DENIED;
859 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
860 return TTS_ERROR_PERMISSION_DENIED;
862 } else if (TTS_ERROR_NONE != ret) {
863 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
864 return TTS_ERROR_OPERATION_FAILED;
867 /* success to connect tts-daemon */
868 client->credential_needed = credential_needed;
869 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
872 client->before_state = client->current_state;
873 client->current_state = TTS_STATE_READY;
875 ecore_timer_add(0.0, __tts_notify_state_changed, client->tts);
877 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
878 return TTS_ERROR_NONE;
881 static Eina_Bool __send_hello(void *data)
883 tts_h tts = (tts_h)data;
884 tts_client_s* client = tts_client_get(tts);
887 if (NULL == client) {
888 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
889 g_hello_timer = NULL;
894 if (client->current_state == TTS_STATE_READY) {
895 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] TTS client has been already connected to tts service"); //LCOV_EXCL_LINE
896 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
897 g_hello_timer = NULL;
902 int ret = tts_dbus_request_hello(client->uid);
904 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
906 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Send Hello");
909 if (!g_hello_timer) {
910 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Call checking Hello timer callback");
911 g_hello_timer = ecore_timer_add(0.5, __send_hello, tts);
917 int tts_prepare(tts_h tts)
919 if (0 != __tts_get_feature_enabled()) {
920 return TTS_ERROR_NOT_SUPPORTED;
923 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
925 tts_client_s* client = tts_client_get(tts);
928 if (NULL == client) {
929 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
930 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
931 return TTS_ERROR_INVALID_PARAMETER;
935 if (client->current_state != TTS_STATE_CREATED) {
936 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
937 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
938 return TTS_ERROR_INVALID_STATE;
941 if (NULL == g_hello_timer) {
942 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Call checking Hello timer callback");
943 ecore_thread_main_loop_begin();
944 ecore_timer_add(0.0, __send_hello, (void*)tts);
945 ecore_thread_main_loop_end();
948 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
950 return TTS_ERROR_NONE;
954 int tts_prepare_sync(tts_h tts)
956 if (0 != __tts_get_feature_enabled()) {
957 return TTS_ERROR_NOT_SUPPORTED;
960 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
962 tts_client_s* client = tts_client_get(tts);
965 if (NULL == client) {
966 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
967 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
968 return TTS_ERROR_INVALID_PARAMETER;
972 if (client->current_state != TTS_STATE_CREATED) {
973 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
974 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
975 return TTS_ERROR_INVALID_STATE;
979 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
983 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
985 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
986 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
987 return TTS_ERROR_OPERATION_FAILED;
990 return TTS_ERROR_NONE;
994 int tts_unprepare(tts_h tts)
996 if (0 != __tts_get_feature_enabled()) {
997 return TTS_ERROR_NOT_SUPPORTED;
1000 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
1002 tts_client_s* client = tts_client_get(tts);
1005 if (NULL == client) {
1006 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
1007 return TTS_ERROR_INVALID_PARAMETER;
1011 if (client->current_state != TTS_STATE_READY) {
1012 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
1013 return TTS_ERROR_INVALID_STATE;
1018 int screen_reader = -1;
1020 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
1022 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
1024 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);
1025 g_screen_reader = (bool)screen_reader;
1028 bool is_prepared = false;
1029 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
1031 ret = tts_dbus_request_finalize(client->uid);
1034 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1035 client->current_state = TTS_STATE_CREATED;
1036 if (0 == tts_prepare_sync(tts)) {
1038 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1040 } else if (TTS_ERROR_TIMED_OUT != ret) {
1041 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1044 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
1047 if (TTS_RETRY_COUNT == count) {
1048 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1056 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
1059 client->before_state = client->current_state;
1060 client->current_state = TTS_STATE_CREATED;
1062 if (NULL != client->state_changed_cb) {
1063 tts_client_use_callback(client);
1064 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1065 tts_client_not_use_callback(client);
1066 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1069 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1071 return TTS_ERROR_NONE;
1074 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
1076 tts_h tts = (tts_h)user_data;
1078 tts_client_s* client = tts_client_get(tts);
1079 if (NULL == client) {
1080 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
1084 /* call callback function */
1085 if (NULL != client->supported_voice_cb) {
1086 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
1088 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
1094 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
1096 if (0 != __tts_get_feature_enabled()) {
1097 return TTS_ERROR_NOT_SUPPORTED;
1100 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
1102 if (NULL == tts || NULL == callback) {
1103 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1104 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1105 return TTS_ERROR_INVALID_PARAMETER;
1108 tts_client_s* client = tts_client_get(tts);
1111 if (NULL == client) {
1112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1113 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1114 return TTS_ERROR_INVALID_PARAMETER;
1118 char* current_engine = NULL;
1119 ret = tts_config_mgr_get_engine(¤t_engine);
1121 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
1122 return __tts_convert_config_error_code(ret);
1125 client->supported_voice_cb = callback;
1126 client->supported_voice_user_data = user_data;
1128 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
1130 if (NULL != current_engine) {
1131 free(current_engine);
1132 current_engine = NULL;
1135 client->supported_voice_cb = NULL;
1136 client->supported_voice_user_data = NULL;
1139 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
1140 ret = TTS_ERROR_OPERATION_FAILED;
1143 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1148 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
1150 if (0 != __tts_get_feature_enabled()) {
1151 return TTS_ERROR_NOT_SUPPORTED;
1154 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
1157 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1158 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1159 return TTS_ERROR_INVALID_PARAMETER;
1162 tts_client_s* client = tts_client_get(tts);
1164 if (NULL == client) {
1165 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1166 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1167 return TTS_ERROR_INVALID_PARAMETER;
1170 /* Request call remote method */
1172 ret = tts_config_mgr_get_voice(lang, vctype);
1174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
1175 return __tts_convert_config_error_code(ret);
1177 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
1180 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1185 int tts_get_max_text_size(tts_h tts, unsigned int* size)
1187 if (0 != __tts_get_feature_enabled()) {
1188 return TTS_ERROR_NOT_SUPPORTED;
1191 if (NULL == tts || NULL == size) {
1192 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
1193 return TTS_ERROR_INVALID_PARAMETER;
1196 tts_client_s* client = tts_client_get(tts);
1198 if (NULL == client) {
1199 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
1200 return TTS_ERROR_INVALID_PARAMETER;
1203 if (TTS_STATE_READY != client->current_state) {
1204 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
1205 return TTS_ERROR_INVALID_STATE;
1208 if (0 != tts_config_mgr_get_max_text_size(size)) {
1209 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1210 return TTS_ERROR_INVALID_PARAMETER;
1213 g_max_text_size = (int)*size;
1215 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
1216 return TTS_ERROR_NONE;
1219 int tts_get_state(tts_h tts, tts_state_e* state)
1221 if (0 != __tts_get_feature_enabled()) {
1222 return TTS_ERROR_NOT_SUPPORTED;
1225 if (NULL == tts || NULL == state) {
1226 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
1227 return TTS_ERROR_INVALID_PARAMETER;
1230 tts_client_s* client = tts_client_get(tts);
1232 if (NULL == client) {
1233 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1234 return TTS_ERROR_INVALID_PARAMETER;
1237 *state = client->current_state;
1240 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
1241 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
1242 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
1243 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
1244 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1247 return TTS_ERROR_NONE;
1250 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1252 if (0 != __tts_get_feature_enabled()) {
1253 return TTS_ERROR_NOT_SUPPORTED;
1256 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1257 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1258 return TTS_ERROR_INVALID_PARAMETER;
1261 tts_client_s* client = tts_client_get(tts);
1263 if (NULL == client) {
1264 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1265 return TTS_ERROR_INVALID_PARAMETER;
1268 *min = TTS_SPEED_MIN;
1269 *normal = TTS_SPEED_NORMAL;
1270 *max = TTS_SPEED_MAX;
1272 return TTS_ERROR_NONE;
1275 int tts_get_error_message(tts_h tts, char** err_msg)
1277 if (0 != __tts_get_feature_enabled()) {
1278 return TTS_ERROR_NOT_SUPPORTED;
1281 if (NULL == tts || NULL == err_msg) {
1282 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1283 return TTS_ERROR_INVALID_PARAMETER;
1286 tts_client_s* client = tts_client_get(tts);
1288 if (NULL == client) {
1289 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1290 return TTS_ERROR_INVALID_PARAMETER;
1293 if (NULL != client->err_msg) {
1294 *err_msg = strdup(client->err_msg);
1295 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1298 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1301 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1303 return TTS_ERROR_NONE;
1306 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1308 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1310 if (0 != __tts_get_feature_enabled()) {
1311 return TTS_ERROR_NOT_SUPPORTED;
1315 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1316 return TTS_ERROR_INVALID_PARAMETER;
1319 if (voice_type < 0) {
1320 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1321 return TTS_ERROR_INVALID_PARAMETER;
1324 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1326 if (NULL == tts || NULL == utt_id) {
1327 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1328 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1329 return TTS_ERROR_INVALID_PARAMETER;
1332 tts_client_s* client = tts_client_get(tts);
1334 if (NULL == client) {
1335 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1336 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1337 return TTS_ERROR_INVALID_PARAMETER;
1340 if (TTS_STATE_CREATED == client->current_state) {
1341 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1342 return TTS_ERROR_INVALID_STATE;
1345 if (-1 == g_max_text_size) {
1346 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1347 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1348 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1349 return TTS_ERROR_INVALID_PARAMETER;
1353 if (0 == g_max_text_size) {
1354 if (strlen(text) <= 0) {
1355 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1356 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1357 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1358 return TTS_ERROR_INVALID_PARAMETER;
1361 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1362 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1363 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1364 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1365 return TTS_ERROR_INVALID_PARAMETER;
1369 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1371 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1372 return TTS_ERROR_INVALID_PARAMETER;
1375 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1376 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1377 return TTS_ERROR_INVALID_STATE;
1380 if (true == client->credential_needed && NULL == client->credential) {
1381 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1382 return TTS_ERROR_PERMISSION_DENIED;
1385 /* check valid utf8 */
1389 dbus_error_init(&err);
1391 valid = dbus_validate_utf8(text, &err);
1392 if (dbus_error_is_set(&err)) {
1393 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1394 dbus_error_free(&err);
1395 return TTS_ERROR_INVALID_PARAMETER;
1398 if (valid != true) {
1399 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1400 return TTS_ERROR_INVALID_PARAMETER;
1402 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1404 /* save texts for repetition */
1405 if (NULL != client->text_repeat) {
1406 free(client->text_repeat);
1407 client->text_repeat = NULL;
1410 client->text_repeat = strdup(text);
1412 if (NULL != g_language) {
1416 if (NULL == language)
1419 g_language = strdup(language);
1421 g_voice_type = voice_type;
1424 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] repeat: text(%s), language(%s), voice type(%d), speed(%d)", client->text_repeat, (g_language) ? g_language : "NULL", g_voice_type, g_speed);
1426 /* change default language value */
1429 if (NULL == language)
1430 temp = strdup("default");
1432 temp = strdup(language);
1434 client->current_utt_id++;
1435 if (client->current_utt_id == 10000) {
1436 client->current_utt_id = 1;
1442 bool is_prepared = false;
1444 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1447 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1448 client->current_state = TTS_STATE_CREATED;
1449 if (0 == tts_prepare_sync(tts)) {
1451 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1453 } else if (TTS_ERROR_TIMED_OUT != ret) {
1454 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1457 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1460 if (TTS_RETRY_MIN_COUNT == count) {
1461 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1467 *utt_id = client->current_utt_id;
1476 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1482 static void __tts_play_async(void *data)
1484 tts_h tts = (tts_h)data;
1485 tts_client_s* client = tts_client_get(tts);
1488 if (NULL == client) {
1489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1495 bool is_prepared = false;
1497 ret = tts_dbus_request_play(client->uid, client->credential);
1499 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1500 client->current_state = TTS_STATE_CREATED;
1501 if (0 == tts_prepare_sync(tts)) {
1503 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1505 } else if (TTS_ERROR_TIMED_OUT != ret) {
1506 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1509 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1512 if (TTS_RETRY_COUNT == count) {
1513 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1521 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1523 client->reason = ret;
1524 client->utt_id = -1;
1526 ecore_timer_add(0, __tts_notify_error, client->tts);
1530 client->before_state = client->current_state;
1531 client->current_state = TTS_STATE_PLAYING;
1533 if (NULL != client->state_changed_cb) {
1534 tts_client_use_callback(client);
1535 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1536 tts_client_not_use_callback(client);
1537 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1540 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1545 int tts_play_async(tts_h tts)
1547 if (0 != __tts_get_feature_enabled()) {
1548 return TTS_ERROR_NOT_SUPPORTED;
1551 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1554 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1555 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1556 return TTS_ERROR_INVALID_PARAMETER;
1559 tts_client_s* client = tts_client_get(tts);
1561 if (NULL == client) {
1562 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1563 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1564 return TTS_ERROR_INVALID_PARAMETER;
1567 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1569 return TTS_ERROR_INVALID_STATE;
1572 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1573 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1574 return TTS_ERROR_INVALID_STATE;
1577 if (true == client->credential_needed && NULL == client->credential) {
1578 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1579 return TTS_ERROR_PERMISSION_DENIED;
1582 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1584 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1586 return TTS_ERROR_NONE;
1589 int tts_play(tts_h tts)
1591 if (0 != __tts_get_feature_enabled()) {
1592 return TTS_ERROR_NOT_SUPPORTED;
1595 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1599 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1600 return TTS_ERROR_INVALID_PARAMETER;
1603 tts_client_s* client = tts_client_get(tts);
1605 if (NULL == client) {
1606 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1607 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1608 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1609 return TTS_ERROR_INVALID_PARAMETER;
1612 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1613 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1614 return TTS_ERROR_INVALID_STATE;
1617 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1618 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1619 return TTS_ERROR_INVALID_STATE;
1622 if (true == client->credential_needed && NULL == client->credential) {
1623 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1624 return TTS_ERROR_PERMISSION_DENIED;
1629 bool is_prepared = false;
1631 ret = tts_dbus_request_play(client->uid, client->credential);
1634 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1635 client->current_state = TTS_STATE_CREATED;
1636 if (0 == tts_prepare_sync(tts)) {
1638 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1640 } else if (TTS_ERROR_TIMED_OUT != ret) {
1641 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1644 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1647 if (TTS_RETRY_COUNT == count) {
1648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1656 client->before_state = client->current_state;
1657 client->current_state = TTS_STATE_PLAYING;
1659 if (NULL != client->state_changed_cb) {
1660 tts_client_use_callback(client);
1661 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1662 tts_client_not_use_callback(client);
1663 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1666 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1668 return TTS_ERROR_NONE;
1671 static void __tts_stop_async(void *data)
1673 tts_h tts = (tts_h)data;
1674 tts_client_s* client = tts_client_get(tts);
1677 if (NULL == client) {
1678 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1684 bool is_prepared = false;
1686 ret = tts_dbus_request_stop(client->uid);
1688 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1689 client->current_state = TTS_STATE_CREATED;
1690 if (0 == tts_prepare_sync(tts)) {
1692 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1694 } else if (TTS_ERROR_TIMED_OUT != ret) {
1695 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1698 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1701 if (TTS_RETRY_COUNT == count) {
1702 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1712 client->reason = ret;
1713 client->utt_id = -1;
1715 ecore_timer_add(0, __tts_notify_error, client->tts);
1719 client->before_state = client->current_state;
1720 client->current_state = TTS_STATE_READY;
1722 if (NULL != client->state_changed_cb) {
1723 tts_client_use_callback(client);
1724 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1725 tts_client_not_use_callback(client);
1726 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1729 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1734 int tts_stop_aync(tts_h tts)
1736 if (0 != __tts_get_feature_enabled()) {
1737 return TTS_ERROR_NOT_SUPPORTED;
1740 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1743 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1744 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1745 return TTS_ERROR_INVALID_PARAMETER;
1748 tts_client_s* client = tts_client_get(tts);
1750 if (NULL == client) {
1751 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1752 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1753 return TTS_ERROR_INVALID_PARAMETER;
1756 if (TTS_STATE_CREATED == client->current_state) {
1757 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1758 return TTS_ERROR_INVALID_STATE;
1761 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1762 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1763 return TTS_ERROR_INVALID_STATE;
1766 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1768 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1770 return TTS_ERROR_NONE;
1773 int tts_stop(tts_h tts)
1775 if (0 != __tts_get_feature_enabled()) {
1776 return TTS_ERROR_NOT_SUPPORTED;
1779 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1782 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1783 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1784 return TTS_ERROR_INVALID_PARAMETER;
1787 tts_client_s* client = tts_client_get(tts);
1789 if (NULL == client) {
1790 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1791 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1792 return TTS_ERROR_INVALID_PARAMETER;
1795 if (TTS_STATE_CREATED == client->current_state) {
1796 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1797 return TTS_ERROR_INVALID_STATE;
1800 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1801 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1802 return TTS_ERROR_INVALID_STATE;
1807 bool is_prepared = false;
1809 ret = tts_dbus_request_stop(client->uid);
1812 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1813 client->current_state = TTS_STATE_CREATED;
1814 if (0 == tts_prepare_sync(tts)) {
1816 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1818 } else if (TTS_ERROR_TIMED_OUT != ret) {
1819 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1822 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1825 if (TTS_RETRY_COUNT == count) {
1826 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1834 client->before_state = client->current_state;
1835 client->current_state = TTS_STATE_READY;
1837 if (NULL != client->state_changed_cb) {
1838 tts_client_use_callback(client);
1839 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1840 tts_client_not_use_callback(client);
1841 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1844 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1846 return TTS_ERROR_NONE;
1849 static void __tts_pause_async(void *data)
1851 tts_h tts = (tts_h)data;
1852 tts_client_s* client = tts_client_get(tts);
1855 if (NULL == client) {
1856 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1862 bool is_prepared = false;
1864 ret = tts_dbus_request_pause(client->uid);
1866 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1867 client->current_state = TTS_STATE_CREATED;
1868 if (0 == tts_prepare_sync(tts)) {
1870 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1872 } else if (TTS_ERROR_TIMED_OUT != ret) {
1873 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1876 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1879 if (TTS_RETRY_COUNT == count) {
1880 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1888 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1890 client->reason = ret;
1891 client->utt_id = -1;
1893 ecore_timer_add(0, __tts_notify_error, client->tts);
1897 client->before_state = client->current_state;
1898 client->current_state = TTS_STATE_PAUSED;
1900 if (NULL != client->state_changed_cb) {
1901 tts_client_use_callback(client);
1902 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1903 tts_client_not_use_callback(client);
1904 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1907 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1912 int tts_pause_async(tts_h tts)
1914 if (0 != __tts_get_feature_enabled()) {
1915 return TTS_ERROR_NOT_SUPPORTED;
1918 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1921 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1922 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1923 return TTS_ERROR_INVALID_PARAMETER;
1926 tts_client_s* client = tts_client_get(tts);
1928 if (NULL == client) {
1929 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1930 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1931 return TTS_ERROR_INVALID_PARAMETER;
1934 if (TTS_STATE_PLAYING != client->current_state) {
1935 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1936 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1937 return TTS_ERROR_INVALID_STATE;
1940 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1941 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1942 return TTS_ERROR_INVALID_STATE;
1945 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1947 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1949 return TTS_ERROR_NONE;
1952 int tts_pause(tts_h tts)
1954 if (0 != __tts_get_feature_enabled()) {
1955 return TTS_ERROR_NOT_SUPPORTED;
1958 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1961 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1962 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1963 return TTS_ERROR_INVALID_PARAMETER;
1966 tts_client_s* client = tts_client_get(tts);
1968 if (NULL == client) {
1969 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1970 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1971 return TTS_ERROR_INVALID_PARAMETER;
1974 if (TTS_STATE_PLAYING != client->current_state) {
1975 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1976 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1977 return TTS_ERROR_INVALID_STATE;
1980 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1981 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1982 return TTS_ERROR_INVALID_STATE;
1987 bool is_prepared = false;
1989 ret = tts_dbus_request_pause(client->uid);
1992 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1993 client->current_state = TTS_STATE_CREATED;
1994 if (0 == tts_prepare_sync(tts)) {
1996 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1998 } else if (TTS_ERROR_TIMED_OUT != ret) {
1999 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2002 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
2005 if (TTS_RETRY_COUNT == count) {
2006 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2014 client->before_state = client->current_state;
2015 client->current_state = TTS_STATE_PAUSED;
2017 if (NULL != client->state_changed_cb) {
2018 tts_client_use_callback(client);
2019 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2020 tts_client_not_use_callback(client);
2021 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2024 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2026 return TTS_ERROR_NONE;
2029 int tts_set_private_data(tts_h tts, const char* key, const char* data)
2031 if (0 != __tts_get_feature_enabled()) {
2032 return TTS_ERROR_NOT_SUPPORTED;
2035 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
2038 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
2039 return TTS_ERROR_INVALID_PARAMETER;
2042 if (NULL == key || NULL == data) {
2043 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
2044 return TTS_ERROR_INVALID_PARAMETER;
2047 tts_client_s* client = tts_client_get(tts);
2049 if (NULL == client) {
2050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
2051 return TTS_ERROR_INVALID_PARAMETER;
2054 if (TTS_STATE_READY != client->current_state) {
2055 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
2056 return TTS_ERROR_INVALID_STATE;
2059 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
2060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
2061 return TTS_ERROR_INVALID_PARAMETER;
2066 bool is_prepared = false;
2068 ret = tts_dbus_request_set_private_data(client->uid, key, data);
2071 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2072 client->current_state = TTS_STATE_CREATED;
2073 if (0 == tts_prepare_sync(tts)) {
2075 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2077 } else if (TTS_ERROR_TIMED_OUT != ret) {
2078 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2081 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
2084 if (TTS_RETRY_COUNT == count) {
2085 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2093 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2098 int tts_get_private_data(tts_h tts, const char* key, char** data)
2100 if (0 != __tts_get_feature_enabled()) {
2101 return TTS_ERROR_NOT_SUPPORTED;
2104 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
2107 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
2108 return TTS_ERROR_INVALID_PARAMETER;
2111 if (NULL == key || NULL == data) {
2112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
2113 return TTS_ERROR_INVALID_PARAMETER;
2116 tts_client_s* client = tts_client_get(tts);
2118 if (NULL == client) {
2119 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
2120 return TTS_ERROR_INVALID_PARAMETER;
2123 if (TTS_STATE_READY != client->current_state) {
2124 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
2125 return TTS_ERROR_INVALID_STATE;
2130 bool is_prepared = false;
2132 ret = tts_dbus_request_get_private_data(client->uid, key, data);
2135 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2136 client->current_state = TTS_STATE_CREATED;
2137 if (0 == tts_prepare_sync(tts)) {
2139 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2141 } else if (TTS_ERROR_TIMED_OUT != ret) {
2142 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2145 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
2148 if (TTS_RETRY_COUNT == count) {
2149 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2157 if (0 == strncmp(*data, "NULL", strlen(*data))) {
2162 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2168 static Eina_Bool __tts_notify_error(void *data)
2170 tts_h tts = (tts_h)data;
2172 tts_client_s* client = tts_client_get(tts);
2175 if (NULL == client) {
2176 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
2180 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
2182 if (NULL != client->error_cb) {
2183 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
2184 tts_client_use_callback(client);
2185 g_err_callback_status = true;
2186 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
2187 g_err_callback_status = false;
2188 tts_client_not_use_callback(client);
2190 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2196 static void __start_reprepare_thread(void* data, Ecore_Thread* thread)
2198 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] start reprepare thread. engine update status(%d)", g_engine_update_status);
2200 tts_client_s* temp = (tts_client_s*)data;
2202 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] data is null");
2207 while (!g_engine_update_status && (cnt < 10)) {
2208 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] wait for starting update");
2213 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] update status(%d)", g_engine_update_status);
2215 while (g_engine_update_status && (NULL != g_pkgmgr)) {
2216 // SLOG(LOG_WARN, TAG_TTSC, "[WARNING] wait for finishing update");
2220 SLOG(LOG_INFO, TAG_TTSC, "[INFO] finish updating. request to prepare");
2222 if (0 != tts_prepare(temp->tts)) {
2223 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2229 static void __end_reprepare_thread(void* data, Ecore_Thread* thread)
2231 SLOG(LOG_INFO, TAG_TTSC, "[INFO] end reprepare thread");
2234 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
2237 GList* client_list = NULL;
2238 client_list = tts_client_get_client_list();
2241 tts_client_s *data = NULL;
2243 if (g_list_length(client_list) > 0) {
2244 /* Get a first item */
2245 iter = g_list_first(client_list);
2247 while (NULL != iter) {
2250 data->utt_id = utt_id;
2251 data->reason = reason;
2252 if (NULL != data->err_msg) {
2253 free(data->err_msg);
2254 data->err_msg = NULL;
2256 if (NULL != err_msg)
2257 data->err_msg = strdup(err_msg);
2259 /* call callback function */
2260 if (NULL != data->error_cb) {
2261 ecore_timer_add(0, __tts_notify_error, data->tts);
2263 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2266 if (TTS_ERROR_SERVICE_RESET == reason) {
2267 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2269 data->current_state = TTS_STATE_CREATED;
2271 ecore_thread_run(__start_reprepare_thread, __end_reprepare_thread, NULL, data);
2275 iter = g_list_next(iter);
2279 tts_client_s* client = tts_client_get_by_uid(uid);
2281 if (NULL == client) {
2282 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2283 return TTS_ERROR_INVALID_PARAMETER;
2286 client->utt_id = utt_id;
2287 client->reason = reason;
2288 if (NULL != client->err_msg) {
2289 free(client->err_msg);
2290 client->err_msg = NULL;
2292 if (NULL != err_msg)
2293 client->err_msg = strdup(err_msg);
2295 /* call callback function */
2296 if (NULL != client->error_cb) {
2297 ecore_timer_add(0, __tts_notify_error, client->tts);
2299 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2302 if (TTS_ERROR_SERVICE_RESET == reason) {
2303 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2305 client->current_state = TTS_STATE_CREATED;
2307 ecore_thread_run(__start_reprepare_thread, __end_reprepare_thread, NULL, client);
2314 static Eina_Bool __tts_notify_state_changed(void *data)
2316 tts_h tts = (tts_h)data;
2318 tts_client_s* client = tts_client_get(tts);
2321 if (NULL == client) {
2322 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2326 if (NULL != client->state_changed_cb) {
2327 tts_client_use_callback(client);
2328 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2329 tts_client_not_use_callback(client);
2330 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2332 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2338 int __tts_cb_set_state(int uid, int state)
2340 tts_client_s* client = tts_client_get_by_uid(uid);
2341 if (NULL == client) {
2342 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2346 tts_state_e state_from_daemon = (tts_state_e)state;
2348 if (client->current_state == state_from_daemon) {
2349 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2353 if (NULL != client->state_changed_cb) {
2354 if (NULL != g_check_state_timer) {
2355 ecore_timer_del(g_check_state_timer);
2356 g_check_state_timer = NULL;
2358 g_check_state_timer = ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2360 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2363 client->before_state = client->current_state;
2364 client->current_state = state_from_daemon;
2370 int __tts_cb_utt_started(int uid, int utt_id)
2372 tts_client_s* client = tts_client_get_by_uid(uid);
2374 if (NULL == client) {
2375 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2376 return TTS_ERROR_INVALID_PARAMETER;
2379 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2381 client->utt_id = utt_id;
2383 /* call callback function */
2384 if (NULL != client->utt_started_cb) {
2385 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2386 tts_client_use_callback(client);
2387 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2388 tts_client_not_use_callback(client);
2390 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2396 int __tts_cb_utt_completed(int uid, int utt_id)
2398 tts_client_s* client = tts_client_get_by_uid(uid);
2400 if (NULL == client) {
2401 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2402 return TTS_ERROR_INVALID_PARAMETER;
2405 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2407 client->utt_id = utt_id;
2409 /* call callback function */
2410 if (NULL != client->utt_completeted_cb) {
2411 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2412 tts_client_use_callback(client);
2413 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2414 tts_client_not_use_callback(client);
2416 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2422 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2424 if (0 != __tts_get_feature_enabled()) {
2425 return TTS_ERROR_NOT_SUPPORTED;
2428 if (NULL == tts || NULL == callback) {
2429 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2430 return TTS_ERROR_INVALID_PARAMETER;
2433 tts_client_s* client = tts_client_get(tts);
2435 if (NULL == client) {
2436 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2437 return TTS_ERROR_INVALID_PARAMETER;
2440 if (TTS_STATE_CREATED != client->current_state) {
2441 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2442 return TTS_ERROR_INVALID_STATE;
2445 client->state_changed_cb = callback;
2446 client->state_changed_user_data = user_data;
2448 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2453 int tts_unset_state_changed_cb(tts_h tts)
2455 if (0 != __tts_get_feature_enabled()) {
2456 return TTS_ERROR_NOT_SUPPORTED;
2460 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2461 return TTS_ERROR_INVALID_PARAMETER;
2464 tts_client_s* client = tts_client_get(tts);
2466 if (NULL == client) {
2467 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2468 return TTS_ERROR_INVALID_PARAMETER;
2471 if (TTS_STATE_CREATED != client->current_state) {
2472 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2473 return TTS_ERROR_INVALID_STATE;
2476 client->state_changed_cb = NULL;
2477 client->state_changed_user_data = NULL;
2479 if (NULL != g_check_state_timer) {
2480 ecore_timer_del(g_check_state_timer);
2481 g_check_state_timer = NULL;
2484 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2489 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2491 if (0 != __tts_get_feature_enabled()) {
2492 return TTS_ERROR_NOT_SUPPORTED;
2495 if (NULL == tts || NULL == callback) {
2496 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2497 return TTS_ERROR_INVALID_PARAMETER;
2500 tts_client_s* client = tts_client_get(tts);
2502 if (NULL == client) {
2503 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2504 return TTS_ERROR_INVALID_PARAMETER;
2507 if (TTS_STATE_CREATED != client->current_state) {
2508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2509 return TTS_ERROR_INVALID_STATE;
2512 client->utt_started_cb = callback;
2513 client->utt_started_user_data = user_data;
2515 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2520 int tts_unset_utterance_started_cb(tts_h tts)
2522 if (0 != __tts_get_feature_enabled()) {
2523 return TTS_ERROR_NOT_SUPPORTED;
2527 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2528 return TTS_ERROR_INVALID_PARAMETER;
2531 tts_client_s* client = tts_client_get(tts);
2533 if (NULL == client) {
2534 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2535 return TTS_ERROR_INVALID_PARAMETER;
2538 if (TTS_STATE_CREATED != client->current_state) {
2539 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2540 return TTS_ERROR_INVALID_STATE;
2543 client->utt_started_cb = NULL;
2544 client->utt_started_user_data = NULL;
2546 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2551 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2553 if (0 != __tts_get_feature_enabled()) {
2554 return TTS_ERROR_NOT_SUPPORTED;
2557 if (NULL == tts || NULL == callback) {
2558 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2559 return TTS_ERROR_INVALID_PARAMETER;
2562 tts_client_s* client = tts_client_get(tts);
2564 if (NULL == client) {
2565 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2566 return TTS_ERROR_INVALID_PARAMETER;
2569 if (TTS_STATE_CREATED != client->current_state) {
2570 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2571 return TTS_ERROR_INVALID_STATE;
2574 client->utt_completeted_cb = callback;
2575 client->utt_completed_user_data = user_data;
2577 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2582 int tts_unset_utterance_completed_cb(tts_h tts)
2584 if (0 != __tts_get_feature_enabled()) {
2585 return TTS_ERROR_NOT_SUPPORTED;
2589 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2590 return TTS_ERROR_INVALID_PARAMETER;
2593 tts_client_s* client = tts_client_get(tts);
2595 if (NULL == client) {
2596 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2597 return TTS_ERROR_INVALID_PARAMETER;
2600 if (TTS_STATE_CREATED != client->current_state) {
2601 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2602 return TTS_ERROR_INVALID_STATE;
2605 client->utt_completeted_cb = NULL;
2606 client->utt_completed_user_data = NULL;
2608 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2612 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2614 if (0 != __tts_get_feature_enabled()) {
2615 return TTS_ERROR_NOT_SUPPORTED;
2618 if (NULL == tts || NULL == callback) {
2619 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2620 return TTS_ERROR_INVALID_PARAMETER;
2623 tts_client_s* client = tts_client_get(tts);
2625 if (NULL == client) {
2626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2627 return TTS_ERROR_INVALID_PARAMETER;
2630 if (TTS_STATE_CREATED != client->current_state) {
2631 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2632 return TTS_ERROR_INVALID_STATE;
2635 client->error_cb = callback;
2636 client->error_user_data = user_data;
2638 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2643 int tts_unset_error_cb(tts_h tts)
2645 if (0 != __tts_get_feature_enabled()) {
2646 return TTS_ERROR_NOT_SUPPORTED;
2650 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2651 return TTS_ERROR_INVALID_PARAMETER;
2654 tts_client_s* client = tts_client_get(tts);
2656 if (NULL == client) {
2657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2658 return TTS_ERROR_INVALID_PARAMETER;
2661 if (TTS_STATE_CREATED != client->current_state) {
2662 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2663 return TTS_ERROR_INVALID_STATE;
2666 client->error_cb = NULL;
2667 client->error_user_data = NULL;
2669 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2674 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2676 if (0 != __tts_get_feature_enabled()) {
2677 return TTS_ERROR_NOT_SUPPORTED;
2680 if (NULL == tts || NULL == callback) {
2681 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2682 return TTS_ERROR_INVALID_PARAMETER;
2685 tts_client_s* client = tts_client_get(tts);
2687 if (NULL == client) {
2688 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2689 return TTS_ERROR_INVALID_PARAMETER;
2692 if (TTS_STATE_CREATED != client->current_state) {
2693 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2694 return TTS_ERROR_INVALID_STATE;
2697 client->default_voice_changed_cb = callback;
2698 client->default_voice_changed_user_data = user_data;
2700 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2705 int tts_unset_default_voice_changed_cb(tts_h tts)
2707 if (0 != __tts_get_feature_enabled()) {
2708 return TTS_ERROR_NOT_SUPPORTED;
2712 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2713 return TTS_ERROR_INVALID_PARAMETER;
2716 tts_client_s* client = tts_client_get(tts);
2718 if (NULL == client) {
2719 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2720 return TTS_ERROR_INVALID_PARAMETER;
2723 if (TTS_STATE_CREATED != client->current_state) {
2724 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2725 return TTS_ERROR_INVALID_STATE;
2728 client->default_voice_changed_cb = NULL;
2729 client->default_voice_changed_user_data = NULL;
2731 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2736 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2738 if (0 != __tts_get_feature_enabled()) {
2739 return TTS_ERROR_NOT_SUPPORTED;
2742 if (NULL == tts || NULL == callback) {
2743 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2744 return TTS_ERROR_INVALID_PARAMETER;
2747 tts_client_s* client = tts_client_get(tts);
2749 if (NULL == client) {
2750 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2751 return TTS_ERROR_INVALID_PARAMETER;
2754 if (TTS_STATE_CREATED != client->current_state) {
2755 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2756 return TTS_ERROR_INVALID_STATE;
2759 client->engine_changed_cb = callback;
2760 client->engine_changed_user_data = user_data;
2762 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2767 int tts_unset_engine_changed_cb(tts_h tts)
2769 if (0 != __tts_get_feature_enabled()) {
2770 return TTS_ERROR_NOT_SUPPORTED;
2774 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2775 return TTS_ERROR_INVALID_PARAMETER;
2778 tts_client_s* client = tts_client_get(tts);
2780 if (NULL == client) {
2781 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2782 return TTS_ERROR_INVALID_PARAMETER;
2785 if (TTS_STATE_CREATED != client->current_state) {
2786 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2787 return TTS_ERROR_INVALID_STATE;
2790 client->engine_changed_cb = NULL;
2791 client->engine_changed_user_data = NULL;
2793 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2799 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2801 if (0 != __tts_get_feature_enabled()) {
2802 return TTS_ERROR_NOT_SUPPORTED;
2805 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2808 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2809 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2810 return TTS_ERROR_INVALID_PARAMETER;
2813 tts_client_s* client = tts_client_get(tts);
2815 if (NULL == client) {
2816 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2817 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2818 return TTS_ERROR_INVALID_PARAMETER;
2821 if (TTS_STATE_CREATED == client->current_state) {
2822 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2823 return TTS_ERROR_INVALID_STATE;
2826 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2827 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2828 return TTS_ERROR_INVALID_STATE;
2833 bool is_prepared = false;
2835 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2837 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2838 client->current_state = TTS_STATE_CREATED;
2839 if (0 == tts_prepare_sync(tts)) {
2841 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2843 } else if (TTS_ERROR_TIMED_OUT != ret) {
2844 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2847 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2850 if (TTS_RETRY_COUNT == count) {
2851 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2858 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2860 return TTS_ERROR_NONE;
2863 int tts_play_pcm(tts_h tts)
2865 if (0 != __tts_get_feature_enabled()) {
2866 return TTS_ERROR_NOT_SUPPORTED;
2869 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2873 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2874 return TTS_ERROR_INVALID_PARAMETER;
2877 tts_client_s* client = tts_client_get(tts);
2879 if (NULL == client) {
2880 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2881 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2882 return TTS_ERROR_INVALID_PARAMETER;
2885 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2886 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2887 return TTS_ERROR_INVALID_STATE;
2890 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2891 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2892 return TTS_ERROR_INVALID_STATE;
2897 bool is_prepared = false;
2899 ret = tts_dbus_request_play_pcm(client->uid);
2901 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2902 client->current_state = TTS_STATE_CREATED;
2903 if (0 == tts_prepare_sync(tts)) {
2905 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2907 } else if (TTS_ERROR_TIMED_OUT != ret) {
2908 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2911 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2914 if (TTS_RETRY_COUNT == count) {
2915 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2922 client->before_state = client->current_state;
2923 client->current_state = TTS_STATE_PLAYING;
2925 if (NULL != client->state_changed_cb) {
2926 tts_client_use_callback(client);
2927 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2928 tts_client_not_use_callback(client);
2929 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2932 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2934 return TTS_ERROR_NONE;
2937 int tts_stop_pcm(tts_h tts)
2939 if (0 != __tts_get_feature_enabled()) {
2940 return TTS_ERROR_NOT_SUPPORTED;
2943 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2946 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2947 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2948 return TTS_ERROR_INVALID_PARAMETER;
2951 tts_client_s* client = tts_client_get(tts);
2953 if (NULL == client) {
2954 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2955 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2956 return TTS_ERROR_INVALID_PARAMETER;
2959 if (TTS_STATE_CREATED == client->current_state) {
2960 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2961 return TTS_ERROR_INVALID_STATE;
2964 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2965 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2966 return TTS_ERROR_INVALID_STATE;
2971 bool is_prepared = false;
2973 ret = tts_dbus_request_stop_pcm(client->uid);
2975 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2976 client->current_state = TTS_STATE_CREATED;
2977 if (0 == tts_prepare_sync(tts)) {
2979 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2981 } else if (TTS_ERROR_TIMED_OUT != ret) {
2982 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2985 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2988 if (TTS_RETRY_COUNT == count) {
2989 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2996 client->before_state = client->current_state;
2997 client->current_state = TTS_STATE_READY;
2999 if (NULL != client->state_changed_cb) {
3000 tts_client_use_callback(client);
3001 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
3002 tts_client_not_use_callback(client);
3003 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
3006 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3008 return TTS_ERROR_NONE;
3012 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
3014 if (0 != __tts_get_feature_enabled()) {
3015 return TTS_ERROR_NOT_SUPPORTED;
3018 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
3021 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
3022 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3023 return TTS_ERROR_INVALID_PARAMETER;
3026 if (NULL == text_repeat || NULL == utt_id) {
3027 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
3028 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3029 return TTS_ERROR_INVALID_PARAMETER;
3032 *text_repeat = NULL;
3035 tts_client_s* client = tts_client_get(tts);
3037 if (NULL == client) {
3038 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
3039 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3040 return TTS_ERROR_INVALID_PARAMETER;
3043 if (TTS_STATE_READY != client->current_state) {
3044 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
3045 return TTS_ERROR_INVALID_STATE;
3048 /* Clear the legacy and Add texts to be played repeatedly */
3050 ret = tts_stop(tts);
3051 if (TTS_ERROR_NONE != ret) {
3052 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
3056 if (NULL != client->text_repeat) {
3057 char* tmp_text = strdup(client->text_repeat);
3058 char* tmp_lang = NULL;
3059 if (NULL != g_language) {
3060 tmp_lang = strdup(g_language);
3062 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
3063 if (TTS_ERROR_NONE != ret) {
3064 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
3065 if (NULL != tmp_text) {
3069 if (NULL != tmp_lang) {
3075 *text_repeat = strdup(client->text_repeat);
3076 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", (*text_repeat) ? *text_repeat : "NULL", *utt_id);
3077 if (NULL != tmp_text) {
3081 if (NULL != tmp_lang) {
3086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
3087 return TTS_ERROR_OPERATION_FAILED;
3090 /* Play added texts */
3091 ret = tts_play(tts);
3092 if (TTS_ERROR_NONE != ret) {
3093 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
3094 if (NULL != *text_repeat) {
3096 *text_repeat = NULL;
3102 return TTS_ERROR_NONE;