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;
45 static char* g_language = NULL;
47 static int g_voice_type = -1;
49 static int g_speed = -1;
50 static int g_retry_cnt = 0;
52 /* for checking engine update */
53 static pkgmgr_client* g_pkgmgr = NULL;
54 static char* g_engine_name = NULL;
55 static int g_engine_update_status = 0;
56 static pthread_mutex_t g_pkgmgr_mutex = PTHREAD_MUTEX_INITIALIZER;
59 /* Function definition */
60 static Eina_Bool __tts_notify_state_changed(void *data);
61 static Eina_Bool __tts_notify_error(void *data);
62 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg);
70 static int __tts_get_feature_enabled()
72 if (0 == g_feature_enabled) {
73 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
74 return TTS_ERROR_NOT_SUPPORTED;
75 } else if (-1 == g_feature_enabled) {
76 bool tts_supported = false;
77 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
78 if (false == tts_supported) {
79 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
80 g_feature_enabled = 0;
81 return TTS_ERROR_NOT_SUPPORTED;
84 g_feature_enabled = 1;
86 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
87 return TTS_ERROR_NOT_SUPPORTED;
94 static const char* __tts_get_error_code(tts_error_e err)
97 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
98 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
99 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
100 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
101 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
102 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
103 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
104 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
105 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
106 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
107 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
108 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
109 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
110 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
111 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
113 return "Invalid error code";
118 static int __tts_convert_config_error_code(tts_config_error_e code)
120 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
121 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
122 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
123 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
124 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
125 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
126 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
127 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
128 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
134 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)
136 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
137 before_lang, before_voice_type, language, voice_type);
139 GList* client_list = NULL;
140 client_list = tts_client_get_client_list();
143 tts_client_s *data = NULL;
145 if (g_list_length(client_list) > 0) {
146 /* Get a first item */
147 iter = g_list_first(client_list);
149 while (NULL != iter) {
151 if (NULL != data->default_voice_changed_cb) {
152 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
153 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
154 language, voice_type, data->default_voice_changed_user_data);
157 /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
158 if (0 != strncmp(before_lang, language, strlen(before_lang))) {
159 if (NULL != data->text_repeat) {
160 free(data->text_repeat);
161 data->text_repeat = NULL;
166 iter = g_list_next(iter);
173 static Eina_Bool __reconnect_by_engine_changed(void* data)
175 tts_h tts = (tts_h)data;
177 tts_client_s* client = tts_client_get(tts);
178 if (NULL == client) {
179 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
183 if (TTS_STATE_READY != client->current_state) {
188 int ret = tts_unprepare(tts);
190 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
192 ret = tts_prepare(tts);
194 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
200 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)
202 tts_h tts = (tts_h)user_data;
204 tts_client_s* client = tts_client_get(tts);
205 if (NULL == client) {
206 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
210 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
211 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
212 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
213 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
215 /* When the default engine is changed, please unload the old engine and load the new one. */
218 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
221 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
224 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
225 } else if (TTS_STATE_READY == client->current_state) {
226 ret = tts_unprepare(tts);
228 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
230 ret = tts_prepare(tts);
232 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
236 /* call callback function */
237 if (NULL != client->engine_changed_cb) {
238 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
240 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
246 void __tts_unset_all_callbacks(tts_h tts)
248 SLOG(LOG_INFO, TAG_TTSC, "@@@ unset all callbacks");
250 tts_unset_state_changed_cb(tts);
251 tts_unset_utterance_started_cb(tts);
252 tts_unset_utterance_completed_cb(tts);
253 tts_unset_error_cb(tts);
254 tts_unset_default_voice_changed_cb(tts);
255 tts_unset_engine_changed_cb(tts);
257 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
260 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)
262 SLOG(LOG_INFO, TAG_TTSC, "[INFO] pkgmgr status cb is invoked. pkgname(%s), type(%s), key(%s), val(%s)", pkgname, type, key, val);
264 if (0 != strncmp(g_engine_name, pkgname, strlen(g_engine_name))) {
265 SLOG(LOG_DEBUG, TAG_TTSC, "[WARN] this is not tts engine");
268 if (key && 0 == strncmp(key, "start", strlen(key))) {
269 if (val && (0 == strncmp(val, "update", strlen(val) || 0 == strncmp(val, "uninstall", strlen(val))))) {
270 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] start to install.");
271 g_engine_update_status = 1;
273 } else if (key && 0 == strncmp(key, "end", strlen(key))) {
274 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] finish to install");
275 g_engine_update_status = 0;
282 static void __create_pkgmgr_thread(void* data, Ecore_Thread* thread)
284 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] create pkgmgr thread");
286 pthread_mutex_lock(&g_pkgmgr_mutex);
289 g_pkgmgr = pkgmgr_client_new(PC_LISTENING);
290 if (NULL == g_pkgmgr) {
291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create pkgmgr handle");
293 int ret = pkgmgr_client_set_status_type(g_pkgmgr, PKGMGR_CLIENT_STATUS_UNINSTALL | PKGMGR_CLIENT_STATUS_UPGRADE);
295 if (pkgmgr_client_listen_status(g_pkgmgr, __pkgmgr_status_cb, NULL) < 0) {
296 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to listen pkgmgr status. remove and recreate client");
297 pkgmgr_client_free(g_pkgmgr);
302 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Succeed to register pkgmgr cb");
305 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set status type on pkgmgr, ret(%d)", ret);
306 pkgmgr_client_free(g_pkgmgr);
315 pthread_mutex_unlock(&g_pkgmgr_mutex);
320 static void __finish_pkgmgr_thread(void* data, Ecore_Thread* thread)
322 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] Finish pkgmgr thread");
325 static void __pkgmgr_thread(void* data)
327 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] call pkgmgr_thread");
329 ecore_thread_run(__create_pkgmgr_thread, __finish_pkgmgr_thread, NULL, NULL);
334 int tts_create(tts_h* tts)
336 if (0 != __tts_get_feature_enabled()) {
337 return TTS_ERROR_NOT_SUPPORTED;
340 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
344 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
345 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
346 return TTS_ERROR_INVALID_PARAMETER;
349 if (0 == tts_client_get_size()) {
350 if (0 != tts_dbus_open_connection()) {
351 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
352 return TTS_ERROR_OPERATION_FAILED;
356 if (0 != tts_client_new(tts)) {
357 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
358 return TTS_ERROR_OUT_OF_MEMORY;
361 tts_client_s* client = tts_client_get(*tts);
362 if (NULL == client) {
363 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
364 return TTS_ERROR_OPERATION_FAILED;
367 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, client->uid);
369 int ret = tts_config_mgr_initialize(client->uid);
371 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
372 tts_client_destroy(*tts);
373 return __tts_convert_config_error_code(ret);
376 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL, client->tts);
378 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
379 tts_client_destroy(*tts);
380 return __tts_convert_config_error_code(ret);
383 ecore_main_loop_thread_safe_call_async(__pkgmgr_thread, NULL);
385 SLOG(LOG_INFO, TAG_TTSC, "[INFO] call ecore thread for creating pkgmgr thread");
387 g_engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
388 if (NULL == g_engine_name) {
389 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine name");
391 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Engine name(%s)", g_engine_name);
394 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
395 SLOG(LOG_DEBUG, TAG_TTSC, " ");
397 return TTS_ERROR_NONE;
400 int tts_destroy(tts_h tts)
402 if (0 != __tts_get_feature_enabled()) {
403 return TTS_ERROR_NOT_SUPPORTED;
406 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
409 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
410 return TTS_ERROR_INVALID_PARAMETER;
413 tts_client_s* client = tts_client_get(tts);
416 if (NULL == client) {
417 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
418 return TTS_ERROR_INVALID_PARAMETER;
421 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, client->uid);
423 /* check used callback */
424 if (0 != tts_client_get_use_callback(client)) {
425 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
426 return TTS_ERROR_OPERATION_FAILED;
429 tts_config_mgr_finalize(client->uid);
431 if (client->hello_timer) {
432 ecore_timer_del(client->hello_timer);
433 client->hello_timer = NULL;
438 int screen_reader = -1;
441 switch (client->current_state) {
442 case TTS_STATE_PAUSED:
443 case TTS_STATE_PLAYING:
444 case TTS_STATE_READY:
445 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
447 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
449 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);
450 g_screen_reader = (bool)screen_reader;
452 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
454 ret = tts_dbus_request_finalize(client->uid);
457 if (TTS_ERROR_TIMED_OUT != ret) {
458 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
461 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
464 if (TTS_RETRY_COUNT == count) {
465 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
473 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
476 client->before_state = client->current_state;
477 client->current_state = TTS_STATE_CREATED;
479 case TTS_STATE_CREATED:
480 if (NULL != client->conn_timer) {
481 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
482 ecore_timer_del(client->conn_timer);
483 client->conn_timer = NULL;
485 /* Unset registered callbacks */
486 __tts_unset_all_callbacks(tts);
489 tts_client_destroy(tts);
496 int num_of_client = tts_client_get_size();
497 if (0 == num_of_client) {
498 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] all clients are destroied");
499 if (0 != tts_dbus_close_connection()) {
500 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
502 pthread_mutex_lock(&g_pkgmgr_mutex);
504 pkgmgr_client_remove_listen_status(g_pkgmgr);
505 pkgmgr_client_free(g_pkgmgr);
508 pthread_mutex_unlock(&g_pkgmgr_mutex);
510 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] num_of_client(%d)", num_of_client);
513 if (NULL != g_language) {
518 /* Delete state timer before destroying handle */
519 if (NULL != g_check_state_timer) {
520 ecore_timer_del(g_check_state_timer);
521 g_check_state_timer = NULL;
526 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
528 return TTS_ERROR_NONE;
532 void __tts_screen_reader_changed_cb(bool value)
534 g_screen_reader = value;
538 int tts_set_mode(tts_h tts, tts_mode_e mode)
540 if (0 != __tts_get_feature_enabled()) {
541 return TTS_ERROR_NOT_SUPPORTED;
544 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
546 tts_client_s* client = tts_client_get(tts);
549 if (NULL == client) {
550 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
551 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
552 return TTS_ERROR_INVALID_PARAMETER;
556 if (client->current_state != TTS_STATE_CREATED) {
557 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
558 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
559 SLOG(LOG_DEBUG, TAG_TTSC, " ");
560 return TTS_ERROR_INVALID_STATE;
563 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
566 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
567 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
568 SLOG(LOG_DEBUG, TAG_TTSC, " ");
569 return TTS_ERROR_INVALID_PARAMETER;
572 if (TTS_MODE_SCREEN_READER == mode) {
575 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
577 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
578 return TTS_ERROR_OPERATION_FAILED;
580 g_screen_reader = (bool)screen_reader;
581 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
583 tts_config_unset_screen_reader_callback(client->uid);
586 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
588 return TTS_ERROR_NONE;
591 int tts_get_mode(tts_h tts, tts_mode_e* mode)
593 if (0 != __tts_get_feature_enabled()) {
594 return TTS_ERROR_NOT_SUPPORTED;
597 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
599 tts_client_s* client = tts_client_get(tts);
602 if (NULL == client) {
603 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
604 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
605 SLOG(LOG_DEBUG, TAG_TTSC, " ");
606 return TTS_ERROR_INVALID_PARAMETER;
610 if (client->current_state != TTS_STATE_CREATED) {
611 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
612 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
613 SLOG(LOG_DEBUG, TAG_TTSC, " ");
614 return TTS_ERROR_INVALID_STATE;
618 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
619 return TTS_ERROR_INVALID_PARAMETER;
622 *mode = client->mode;
624 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
625 SLOG(LOG_DEBUG, TAG_TTSC, " ");
627 return TTS_ERROR_NONE;
630 int tts_set_credential(tts_h tts, const char* credential)
632 if (0 != __tts_get_feature_enabled()) {
633 return TTS_ERROR_NOT_SUPPORTED;
636 if (NULL == tts || NULL == credential) {
637 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
638 return TTS_ERROR_INVALID_PARAMETER;
641 tts_client_s* client = tts_client_get(tts);
643 if (NULL == client) {
644 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
645 return TTS_ERROR_INVALID_PARAMETER;
648 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
649 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
650 return TTS_ERROR_INVALID_STATE;
653 if (NULL != client->credential) {
654 free(client->credential);
655 client->credential = NULL;
657 client->credential = strdup(credential);
659 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
661 return TTS_ERROR_NONE;
665 int tts_set_server_tts(tts_h tts, const char* credential)
667 if (0 != __tts_get_feature_enabled()) {
668 return TTS_ERROR_NOT_SUPPORTED;
672 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
673 return TTS_ERROR_INVALID_PARAMETER;
676 tts_client_s* client = tts_client_get(tts);
678 if (NULL == client) {
679 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
680 return TTS_ERROR_INVALID_PARAMETER;
683 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
685 return TTS_ERROR_INVALID_STATE;
688 if (NULL != client->credential) {
689 free(client->credential);
690 client->credential = NULL;
693 client->internal = true;
696 if (NULL != credential) {
697 key = strdup("EnableServerTTS");
698 client->credential = strdup(credential);
699 if (NULL == client->credential) {
700 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
705 return TTS_ERROR_OUT_OF_MEMORY;
708 key = strdup("DisableServerTTS");
712 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
713 return TTS_ERROR_OUT_OF_MEMORY;
718 int ret = app_manager_get_app_id(pid, &appid);
719 if (0 != ret || NULL == appid) {
720 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
727 return TTS_ERROR_OPERATION_FAILED;
730 ret = tts_set_private_data(tts, key, appid);
732 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
745 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
747 return TTS_ERROR_NONE;
751 static Eina_Bool __tts_connect_daemon(void *data)
753 tts_h tts = (tts_h)data;
754 tts_client_s* client = tts_client_get(tts);
757 if (NULL == client) {
758 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
762 /* check whether engine is updating or not */
763 if (g_engine_update_status) {
764 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] cannot prepare due to engine update");
765 __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
771 if (0 != tts_dbus_request_hello_sync(client->uid)) {
775 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
777 /* do request initialize */
779 bool credential_needed = false;
781 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
783 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
784 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
786 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
789 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
790 if (client->conn_timer) {
791 ecore_timer_del(client->conn_timer);
792 client->conn_timer = NULL;
796 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
797 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
799 client->reason = TTS_ERROR_PERMISSION_DENIED;
802 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
803 if (client->conn_timer) {
804 ecore_timer_del(client->conn_timer);
805 client->conn_timer = NULL;
809 } else if (TTS_ERROR_NONE != ret) {
810 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
814 /* success to connect tts-daemon */
815 client->credential_needed = credential_needed;
816 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
819 if (client->conn_timer) {
820 ecore_timer_del(client->conn_timer);
821 client->conn_timer = NULL;
824 client = tts_client_get(tts);
826 if (NULL == client) {
827 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
831 client->before_state = client->current_state;
832 client->current_state = TTS_STATE_READY;
834 if (NULL != client->state_changed_cb) {
835 tts_client_use_callback(client);
836 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
837 tts_client_not_use_callback(client);
839 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
842 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
847 int __tts_cb_hello(int uid, int ret, int credential_needed)
849 tts_client_s* client = tts_client_get_by_uid(uid);
850 if (NULL == client) {
851 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client or ignore this uid(%d)", uid);
852 return TTS_ERROR_OPERATION_FAILED;
855 if (client->hello_timer) {
856 ecore_timer_del(client->hello_timer);
857 client->hello_timer = NULL;
860 if (TTS_STATE_READY == client->current_state) {
861 SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts client is already READY");
862 return TTS_ERROR_NONE;
865 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
866 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
868 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
871 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
872 return TTS_ERROR_OPERATION_FAILED;
874 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
875 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
877 client->reason = TTS_ERROR_PERMISSION_DENIED;
880 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
881 return TTS_ERROR_PERMISSION_DENIED;
883 } else if (TTS_ERROR_NONE != ret) {
884 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
885 return TTS_ERROR_OPERATION_FAILED;
888 /* success to connect tts-daemon */
889 client->credential_needed = credential_needed;
890 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
893 client->before_state = client->current_state;
894 client->current_state = TTS_STATE_READY;
896 ecore_timer_add(0.0, __tts_notify_state_changed, client->tts);
898 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
899 return TTS_ERROR_NONE;
902 static Eina_Bool __send_hello(void *data)
904 tts_h tts = (tts_h)data;
905 tts_client_s* client = tts_client_get(tts);
908 if (NULL == client) {
909 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
914 if (client->current_state == TTS_STATE_READY) {
915 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] TTS client has been already connected to tts service"); //LCOV_EXCL_LINE
916 SLOG(LOG_ERROR, TAG_TTSC, "@@@");
917 client->hello_timer = NULL;
921 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, client->uid);
923 /* check whether engine is updating or not */
924 if (g_engine_update_status) {
925 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] cannot prepare due to engine update");
926 __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
927 client->hello_timer = NULL;
932 int ret = tts_dbus_request_hello(client->uid);
934 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
936 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Send Hello");
940 if (TTS_HELLO_RETRY_COUNT == g_retry_cnt) {
941 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Stop to send hello, retry count reaches the limit");
943 client->hello_timer = NULL;
947 if (!client->hello_timer) {
948 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Call checking Hello timer callback");
949 client->hello_timer = ecore_timer_add(0.5, __send_hello, tts);
955 int tts_prepare(tts_h tts)
957 if (0 != __tts_get_feature_enabled()) {
958 return TTS_ERROR_NOT_SUPPORTED;
961 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
963 tts_client_s* client = tts_client_get(tts);
966 if (NULL == client) {
967 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
968 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
969 return TTS_ERROR_INVALID_PARAMETER;
973 if (client->current_state != TTS_STATE_CREATED) {
974 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
975 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
976 return TTS_ERROR_INVALID_STATE;
979 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, client->uid);
981 if (NULL == client->hello_timer) {
982 SLOG(LOG_ERROR, TAG_TTSC, "@@@ Call checking Hello timer callback");
984 ecore_thread_main_loop_begin();
985 ecore_timer_add(0.0, __send_hello, (void*)tts);
986 ecore_thread_main_loop_end();
989 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
991 return TTS_ERROR_NONE;
995 int tts_prepare_sync(tts_h tts)
997 if (0 != __tts_get_feature_enabled()) {
998 return TTS_ERROR_NOT_SUPPORTED;
1001 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
1003 tts_client_s* client = tts_client_get(tts);
1006 if (NULL == client) {
1007 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
1008 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1009 return TTS_ERROR_INVALID_PARAMETER;
1013 if (client->current_state != TTS_STATE_CREATED) {
1014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
1015 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1016 return TTS_ERROR_INVALID_STATE;
1020 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
1024 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1026 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
1027 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
1028 return TTS_ERROR_OPERATION_FAILED;
1031 return TTS_ERROR_NONE;
1035 int tts_unprepare(tts_h tts)
1037 if (0 != __tts_get_feature_enabled()) {
1038 return TTS_ERROR_NOT_SUPPORTED;
1041 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
1043 tts_client_s* client = tts_client_get(tts);
1046 if (NULL == client) {
1047 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
1048 return TTS_ERROR_INVALID_PARAMETER;
1052 if (client->current_state != TTS_STATE_READY) {
1053 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
1054 return TTS_ERROR_INVALID_STATE;
1057 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, client->uid);
1059 if (client->hello_timer) {
1060 ecore_timer_del(client->hello_timer);
1061 client->hello_timer = NULL;
1066 int screen_reader = -1;
1068 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
1070 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
1072 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);
1073 g_screen_reader = (bool)screen_reader;
1076 bool is_prepared = false;
1077 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
1079 ret = tts_dbus_request_finalize(client->uid);
1082 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1083 client->current_state = TTS_STATE_CREATED;
1084 if (0 == tts_prepare_sync(tts)) {
1086 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1088 } else if (TTS_ERROR_TIMED_OUT != ret) {
1089 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1092 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
1095 if (TTS_RETRY_COUNT == count) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1104 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
1107 client->before_state = client->current_state;
1108 client->current_state = TTS_STATE_CREATED;
1110 if (NULL != client->state_changed_cb) {
1111 tts_client_use_callback(client);
1112 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1113 tts_client_not_use_callback(client);
1114 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1117 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1119 return TTS_ERROR_NONE;
1122 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
1124 tts_h tts = (tts_h)user_data;
1126 tts_client_s* client = tts_client_get(tts);
1127 if (NULL == client) {
1128 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
1132 /* call callback function */
1133 if (NULL != client->supported_voice_cb) {
1134 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
1136 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
1142 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
1144 if (0 != __tts_get_feature_enabled()) {
1145 return TTS_ERROR_NOT_SUPPORTED;
1148 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
1150 if (NULL == tts || NULL == callback) {
1151 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1152 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1153 return TTS_ERROR_INVALID_PARAMETER;
1156 tts_client_s* client = tts_client_get(tts);
1159 if (NULL == client) {
1160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1161 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1162 return TTS_ERROR_INVALID_PARAMETER;
1166 char* current_engine = NULL;
1167 ret = tts_config_mgr_get_engine(¤t_engine);
1169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
1170 return __tts_convert_config_error_code(ret);
1173 client->supported_voice_cb = callback;
1174 client->supported_voice_user_data = user_data;
1176 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
1178 if (NULL != current_engine) {
1179 free(current_engine);
1180 current_engine = NULL;
1183 client->supported_voice_cb = NULL;
1184 client->supported_voice_user_data = NULL;
1187 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
1188 ret = TTS_ERROR_OPERATION_FAILED;
1191 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1196 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
1198 if (0 != __tts_get_feature_enabled()) {
1199 return TTS_ERROR_NOT_SUPPORTED;
1202 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
1205 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1206 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1207 return TTS_ERROR_INVALID_PARAMETER;
1210 tts_client_s* client = tts_client_get(tts);
1212 if (NULL == client) {
1213 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1214 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1215 return TTS_ERROR_INVALID_PARAMETER;
1218 /* Request call remote method */
1220 ret = tts_config_mgr_get_voice(lang, vctype);
1222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
1223 return __tts_convert_config_error_code(ret);
1225 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
1228 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1233 int tts_get_max_text_size(tts_h tts, unsigned int* size)
1235 if (0 != __tts_get_feature_enabled()) {
1236 return TTS_ERROR_NOT_SUPPORTED;
1239 if (NULL == tts || NULL == size) {
1240 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
1241 return TTS_ERROR_INVALID_PARAMETER;
1244 tts_client_s* client = tts_client_get(tts);
1246 if (NULL == client) {
1247 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
1248 return TTS_ERROR_INVALID_PARAMETER;
1251 if (TTS_STATE_READY != client->current_state) {
1252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
1253 return TTS_ERROR_INVALID_STATE;
1256 if (0 != tts_config_mgr_get_max_text_size(size)) {
1257 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1258 return TTS_ERROR_INVALID_PARAMETER;
1261 g_max_text_size = (int)*size;
1263 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
1264 return TTS_ERROR_NONE;
1267 int tts_get_state(tts_h tts, tts_state_e* state)
1269 if (0 != __tts_get_feature_enabled()) {
1270 return TTS_ERROR_NOT_SUPPORTED;
1273 if (NULL == tts || NULL == state) {
1274 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
1275 return TTS_ERROR_INVALID_PARAMETER;
1278 tts_client_s* client = tts_client_get(tts);
1280 if (NULL == client) {
1281 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1282 return TTS_ERROR_INVALID_PARAMETER;
1285 *state = client->current_state;
1288 case TTS_STATE_CREATED: SLOG(LOG_INFO, TAG_TTSC, "Current state is 'Created'"); break;
1289 case TTS_STATE_READY: SLOG(LOG_INFO, TAG_TTSC, "Current state is 'Ready'"); break;
1290 case TTS_STATE_PLAYING: SLOG(LOG_INFO, TAG_TTSC, "Current state is 'Playing'"); break;
1291 case TTS_STATE_PAUSED: SLOG(LOG_INFO, TAG_TTSC, "Current state is 'Paused'"); break;
1292 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
1295 return TTS_ERROR_NONE;
1298 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1300 if (0 != __tts_get_feature_enabled()) {
1301 return TTS_ERROR_NOT_SUPPORTED;
1304 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1305 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1306 return TTS_ERROR_INVALID_PARAMETER;
1309 tts_client_s* client = tts_client_get(tts);
1311 if (NULL == client) {
1312 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1313 return TTS_ERROR_INVALID_PARAMETER;
1316 *min = TTS_SPEED_MIN;
1317 *normal = TTS_SPEED_NORMAL;
1318 *max = TTS_SPEED_MAX;
1320 return TTS_ERROR_NONE;
1323 int tts_get_error_message(tts_h tts, char** err_msg)
1325 if (0 != __tts_get_feature_enabled()) {
1326 return TTS_ERROR_NOT_SUPPORTED;
1329 if (NULL == tts || NULL == err_msg) {
1330 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1331 return TTS_ERROR_INVALID_PARAMETER;
1334 tts_client_s* client = tts_client_get(tts);
1336 if (NULL == client) {
1337 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1338 return TTS_ERROR_INVALID_PARAMETER;
1341 if (NULL != client->err_msg) {
1342 *err_msg = strdup(client->err_msg);
1343 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1346 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1349 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1351 return TTS_ERROR_NONE;
1354 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1356 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1358 if (0 != __tts_get_feature_enabled()) {
1359 return TTS_ERROR_NOT_SUPPORTED;
1363 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1364 return TTS_ERROR_INVALID_PARAMETER;
1367 if (voice_type < 0) {
1368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1369 return TTS_ERROR_INVALID_PARAMETER;
1372 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1374 if (NULL == tts || NULL == utt_id) {
1375 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1376 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1377 return TTS_ERROR_INVALID_PARAMETER;
1380 tts_client_s* client = tts_client_get(tts);
1382 if (NULL == client) {
1383 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1384 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1385 return TTS_ERROR_INVALID_PARAMETER;
1388 if (TTS_STATE_CREATED == client->current_state) {
1389 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1390 return TTS_ERROR_INVALID_STATE;
1393 if (-1 == g_max_text_size) {
1394 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1395 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1396 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1397 return TTS_ERROR_INVALID_PARAMETER;
1401 if (0 == g_max_text_size) {
1402 if (strlen(text) <= 0) {
1403 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1404 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1405 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1406 return TTS_ERROR_INVALID_PARAMETER;
1409 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1410 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1411 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1412 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1413 return TTS_ERROR_INVALID_PARAMETER;
1417 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1418 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1419 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1420 return TTS_ERROR_INVALID_PARAMETER;
1423 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1424 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1425 return TTS_ERROR_INVALID_STATE;
1428 if (true == client->credential_needed && NULL == client->credential) {
1429 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1430 return TTS_ERROR_PERMISSION_DENIED;
1433 /* check valid utf8 */
1437 dbus_error_init(&err);
1439 valid = dbus_validate_utf8(text, &err);
1440 if (dbus_error_is_set(&err)) {
1441 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1442 dbus_error_free(&err);
1443 return TTS_ERROR_INVALID_PARAMETER;
1446 if (valid != true) {
1447 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1448 return TTS_ERROR_INVALID_PARAMETER;
1450 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1452 /* save texts for repetition */
1453 if (NULL != client->text_repeat) {
1454 free(client->text_repeat);
1455 client->text_repeat = NULL;
1458 client->text_repeat = strdup(text);
1460 if (NULL != g_language) {
1464 if (NULL == language)
1467 g_language = strdup(language);
1469 g_voice_type = voice_type;
1472 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);
1474 /* change default language value */
1477 if (NULL == language)
1478 temp = strdup("default");
1480 temp = strdup(language);
1482 client->current_utt_id++;
1483 if (client->current_utt_id == 10000) {
1484 client->current_utt_id = 1;
1490 bool is_prepared = false;
1492 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1495 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1496 client->current_state = TTS_STATE_CREATED;
1497 if (0 == tts_prepare_sync(tts)) {
1499 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1501 } else if (TTS_ERROR_TIMED_OUT != ret) {
1502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1505 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1508 if (TTS_RETRY_MIN_COUNT == count) {
1509 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1515 *utt_id = client->current_utt_id;
1524 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1530 static void __tts_play_async(void *data)
1532 tts_h tts = (tts_h)data;
1533 tts_client_s* client = tts_client_get(tts);
1536 if (NULL == client) {
1537 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1543 bool is_prepared = false;
1545 ret = tts_dbus_request_play(client->uid, client->credential);
1547 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1548 client->current_state = TTS_STATE_CREATED;
1549 if (0 == tts_prepare_sync(tts)) {
1551 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1553 } else if (TTS_ERROR_TIMED_OUT != ret) {
1554 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1557 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1560 if (TTS_RETRY_COUNT == count) {
1561 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1569 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1571 client->reason = ret;
1572 client->utt_id = -1;
1574 ecore_timer_add(0, __tts_notify_error, client->tts);
1578 client->before_state = client->current_state;
1579 client->current_state = TTS_STATE_PLAYING;
1581 if (NULL != client->state_changed_cb) {
1582 tts_client_use_callback(client);
1583 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1584 tts_client_not_use_callback(client);
1585 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1588 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1593 int tts_play_async(tts_h tts)
1595 if (0 != __tts_get_feature_enabled()) {
1596 return TTS_ERROR_NOT_SUPPORTED;
1599 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1602 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1603 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1604 return TTS_ERROR_INVALID_PARAMETER;
1607 tts_client_s* client = tts_client_get(tts);
1609 if (NULL == client) {
1610 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1611 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1612 return TTS_ERROR_INVALID_PARAMETER;
1615 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1616 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1617 return TTS_ERROR_INVALID_STATE;
1620 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1621 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1622 return TTS_ERROR_INVALID_STATE;
1625 if (true == client->credential_needed && NULL == client->credential) {
1626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1627 return TTS_ERROR_PERMISSION_DENIED;
1630 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1632 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1634 return TTS_ERROR_NONE;
1637 int tts_play(tts_h tts)
1639 if (0 != __tts_get_feature_enabled()) {
1640 return TTS_ERROR_NOT_SUPPORTED;
1643 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1646 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1647 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1648 return TTS_ERROR_INVALID_PARAMETER;
1651 tts_client_s* client = tts_client_get(tts);
1653 if (NULL == client) {
1654 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1655 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1656 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1657 return TTS_ERROR_INVALID_PARAMETER;
1660 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1661 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1662 return TTS_ERROR_INVALID_STATE;
1665 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1666 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1667 return TTS_ERROR_INVALID_STATE;
1670 if (true == client->credential_needed && NULL == client->credential) {
1671 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1672 return TTS_ERROR_PERMISSION_DENIED;
1677 bool is_prepared = false;
1679 ret = tts_dbus_request_play(client->uid, client->credential);
1682 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1683 client->current_state = TTS_STATE_CREATED;
1684 if (0 == tts_prepare_sync(tts)) {
1686 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1688 } else if (TTS_ERROR_TIMED_OUT != ret) {
1689 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1692 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1695 if (TTS_RETRY_COUNT == count) {
1696 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1704 client->before_state = client->current_state;
1705 client->current_state = TTS_STATE_PLAYING;
1707 if (NULL != client->state_changed_cb) {
1708 tts_client_use_callback(client);
1709 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1710 tts_client_not_use_callback(client);
1711 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1714 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1716 return TTS_ERROR_NONE;
1719 static void __tts_stop_async(void *data)
1721 tts_h tts = (tts_h)data;
1722 tts_client_s* client = tts_client_get(tts);
1725 if (NULL == client) {
1726 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1732 bool is_prepared = false;
1734 ret = tts_dbus_request_stop(client->uid);
1736 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1737 client->current_state = TTS_STATE_CREATED;
1738 if (0 == tts_prepare_sync(tts)) {
1740 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1742 } else if (TTS_ERROR_TIMED_OUT != ret) {
1743 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1746 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1749 if (TTS_RETRY_COUNT == count) {
1750 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1758 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1760 client->reason = ret;
1761 client->utt_id = -1;
1763 ecore_timer_add(0, __tts_notify_error, client->tts);
1767 client->before_state = client->current_state;
1768 client->current_state = TTS_STATE_READY;
1770 if (NULL != client->state_changed_cb) {
1771 tts_client_use_callback(client);
1772 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1773 tts_client_not_use_callback(client);
1774 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1777 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1782 int tts_stop_aync(tts_h tts)
1784 if (0 != __tts_get_feature_enabled()) {
1785 return TTS_ERROR_NOT_SUPPORTED;
1788 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1792 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1793 return TTS_ERROR_INVALID_PARAMETER;
1796 tts_client_s* client = tts_client_get(tts);
1798 if (NULL == client) {
1799 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1800 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1801 return TTS_ERROR_INVALID_PARAMETER;
1804 if (TTS_STATE_CREATED == client->current_state) {
1805 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1806 return TTS_ERROR_INVALID_STATE;
1809 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1810 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1811 return TTS_ERROR_INVALID_STATE;
1814 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1816 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1818 return TTS_ERROR_NONE;
1821 int tts_stop(tts_h tts)
1823 if (0 != __tts_get_feature_enabled()) {
1824 return TTS_ERROR_NOT_SUPPORTED;
1827 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1830 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1831 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1832 return TTS_ERROR_INVALID_PARAMETER;
1835 tts_client_s* client = tts_client_get(tts);
1837 if (NULL == client) {
1838 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1839 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1840 return TTS_ERROR_INVALID_PARAMETER;
1843 if (TTS_STATE_CREATED == client->current_state) {
1844 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1845 return TTS_ERROR_INVALID_STATE;
1848 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1849 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1850 return TTS_ERROR_INVALID_STATE;
1855 bool is_prepared = false;
1857 ret = tts_dbus_request_stop(client->uid);
1860 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1861 client->current_state = TTS_STATE_CREATED;
1862 if (0 == tts_prepare_sync(tts)) {
1864 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1866 } else if (TTS_ERROR_TIMED_OUT != ret) {
1867 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1870 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1873 if (TTS_RETRY_COUNT == count) {
1874 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1882 client->before_state = client->current_state;
1883 client->current_state = TTS_STATE_READY;
1885 if (NULL != client->state_changed_cb) {
1886 tts_client_use_callback(client);
1887 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1888 tts_client_not_use_callback(client);
1889 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1892 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1894 return TTS_ERROR_NONE;
1897 static void __tts_pause_async(void *data)
1899 tts_h tts = (tts_h)data;
1900 tts_client_s* client = tts_client_get(tts);
1903 if (NULL == client) {
1904 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1910 bool is_prepared = false;
1912 ret = tts_dbus_request_pause(client->uid);
1914 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1915 client->current_state = TTS_STATE_CREATED;
1916 if (0 == tts_prepare_sync(tts)) {
1918 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1920 } else if (TTS_ERROR_TIMED_OUT != ret) {
1921 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1924 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1927 if (TTS_RETRY_COUNT == count) {
1928 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1936 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1938 client->reason = ret;
1939 client->utt_id = -1;
1941 ecore_timer_add(0, __tts_notify_error, client->tts);
1945 client->before_state = client->current_state;
1946 client->current_state = TTS_STATE_PAUSED;
1948 if (NULL != client->state_changed_cb) {
1949 tts_client_use_callback(client);
1950 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1951 tts_client_not_use_callback(client);
1952 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1955 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1960 int tts_pause_async(tts_h tts)
1962 if (0 != __tts_get_feature_enabled()) {
1963 return TTS_ERROR_NOT_SUPPORTED;
1966 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1969 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1970 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1971 return TTS_ERROR_INVALID_PARAMETER;
1974 tts_client_s* client = tts_client_get(tts);
1976 if (NULL == client) {
1977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1978 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1979 return TTS_ERROR_INVALID_PARAMETER;
1982 if (TTS_STATE_PLAYING != client->current_state) {
1983 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1984 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1985 return TTS_ERROR_INVALID_STATE;
1988 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1989 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1990 return TTS_ERROR_INVALID_STATE;
1993 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1995 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1997 return TTS_ERROR_NONE;
2000 int tts_pause(tts_h tts)
2002 if (0 != __tts_get_feature_enabled()) {
2003 return TTS_ERROR_NOT_SUPPORTED;
2006 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
2009 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
2010 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2011 return TTS_ERROR_INVALID_PARAMETER;
2014 tts_client_s* client = tts_client_get(tts);
2016 if (NULL == client) {
2017 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
2018 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2019 return TTS_ERROR_INVALID_PARAMETER;
2022 if (TTS_STATE_PLAYING != client->current_state) {
2023 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
2024 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2025 return TTS_ERROR_INVALID_STATE;
2028 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2029 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2030 return TTS_ERROR_INVALID_STATE;
2035 bool is_prepared = false;
2037 ret = tts_dbus_request_pause(client->uid);
2040 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2041 client->current_state = TTS_STATE_CREATED;
2042 if (0 == tts_prepare_sync(tts)) {
2044 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2046 } else if (TTS_ERROR_TIMED_OUT != ret) {
2047 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2050 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
2053 if (TTS_RETRY_COUNT == count) {
2054 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2062 client->before_state = client->current_state;
2063 client->current_state = TTS_STATE_PAUSED;
2065 if (NULL != client->state_changed_cb) {
2066 tts_client_use_callback(client);
2067 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2068 tts_client_not_use_callback(client);
2069 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2072 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2074 return TTS_ERROR_NONE;
2077 int tts_set_private_data(tts_h tts, const char* key, const char* data)
2079 if (0 != __tts_get_feature_enabled()) {
2080 return TTS_ERROR_NOT_SUPPORTED;
2083 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
2086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
2087 return TTS_ERROR_INVALID_PARAMETER;
2090 if (NULL == key || NULL == data) {
2091 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
2092 return TTS_ERROR_INVALID_PARAMETER;
2095 tts_client_s* client = tts_client_get(tts);
2097 if (NULL == client) {
2098 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
2099 return TTS_ERROR_INVALID_PARAMETER;
2102 if (TTS_STATE_READY != client->current_state) {
2103 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
2104 return TTS_ERROR_INVALID_STATE;
2107 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
2108 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
2109 return TTS_ERROR_INVALID_PARAMETER;
2114 bool is_prepared = false;
2116 ret = tts_dbus_request_set_private_data(client->uid, key, data);
2119 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2120 client->current_state = TTS_STATE_CREATED;
2121 if (0 == tts_prepare_sync(tts)) {
2123 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2125 } else if (TTS_ERROR_TIMED_OUT != ret) {
2126 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2129 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
2132 if (TTS_RETRY_COUNT == count) {
2133 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2141 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2146 int tts_get_private_data(tts_h tts, const char* key, char** data)
2148 if (0 != __tts_get_feature_enabled()) {
2149 return TTS_ERROR_NOT_SUPPORTED;
2152 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
2155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
2156 return TTS_ERROR_INVALID_PARAMETER;
2159 if (NULL == key || NULL == data) {
2160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
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] A handle is not valid");
2168 return TTS_ERROR_INVALID_PARAMETER;
2171 if (TTS_STATE_READY != client->current_state) {
2172 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
2173 return TTS_ERROR_INVALID_STATE;
2178 bool is_prepared = false;
2180 ret = tts_dbus_request_get_private_data(client->uid, key, data);
2183 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2184 client->current_state = TTS_STATE_CREATED;
2185 if (0 == tts_prepare_sync(tts)) {
2187 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2189 } else if (TTS_ERROR_TIMED_OUT != ret) {
2190 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2193 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
2196 if (TTS_RETRY_COUNT == count) {
2197 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2205 if (0 == strncmp(*data, "NULL", strlen(*data))) {
2210 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2216 static Eina_Bool __tts_notify_error(void *data)
2218 tts_h tts = (tts_h)data;
2220 tts_client_s* client = tts_client_get(tts);
2223 if (NULL == client) {
2224 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
2228 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
2230 if (NULL != client->error_cb) {
2231 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
2232 tts_client_use_callback(client);
2233 g_err_callback_status = true;
2234 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
2235 g_err_callback_status = false;
2236 tts_client_not_use_callback(client);
2238 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2244 static void __start_reprepare_thread(void* data, Ecore_Thread* thread)
2246 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] start reprepare thread. engine update status(%d)", g_engine_update_status);
2248 tts_client_s* temp = (tts_client_s*)data;
2250 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] data is null");
2255 while (!g_engine_update_status && (cnt < 10)) {
2256 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] wait for starting update");
2261 SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] update status(%d)", g_engine_update_status);
2263 while (g_engine_update_status && (NULL != g_pkgmgr)) {
2264 // SLOG(LOG_WARN, TAG_TTSC, "[WARNING] wait for finishing update");
2268 SLOG(LOG_INFO, TAG_TTSC, "[INFO] finish updating. request to prepare");
2270 if (0 != tts_prepare(temp->tts)) {
2271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2277 static void __end_reprepare_thread(void* data, Ecore_Thread* thread)
2279 SLOG(LOG_INFO, TAG_TTSC, "[INFO] end reprepare thread");
2282 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
2285 GList* client_list = NULL;
2286 client_list = tts_client_get_client_list();
2289 tts_client_s *data = NULL;
2291 if (g_list_length(client_list) > 0) {
2292 /* Get a first item */
2293 iter = g_list_first(client_list);
2295 while (NULL != iter) {
2298 data->utt_id = utt_id;
2299 data->reason = reason;
2300 if (NULL != data->err_msg) {
2301 free(data->err_msg);
2302 data->err_msg = NULL;
2304 if (NULL != err_msg)
2305 data->err_msg = strdup(err_msg);
2307 /* call callback function */
2308 if (NULL != data->error_cb) {
2309 ecore_timer_add(0, __tts_notify_error, data->tts);
2311 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2314 if (TTS_ERROR_SERVICE_RESET == reason) {
2315 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2317 data->current_state = TTS_STATE_CREATED;
2319 ecore_thread_run(__start_reprepare_thread, __end_reprepare_thread, NULL, data);
2323 iter = g_list_next(iter);
2327 tts_client_s* client = tts_client_get_by_uid(uid);
2329 if (NULL == client) {
2330 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2331 return TTS_ERROR_INVALID_PARAMETER;
2334 client->utt_id = utt_id;
2335 client->reason = reason;
2336 if (NULL != client->err_msg) {
2337 free(client->err_msg);
2338 client->err_msg = NULL;
2340 if (NULL != err_msg)
2341 client->err_msg = strdup(err_msg);
2343 /* call callback function */
2344 if (NULL != client->error_cb) {
2345 ecore_timer_add(0, __tts_notify_error, client->tts);
2347 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2350 if (TTS_ERROR_SERVICE_RESET == reason) {
2351 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2353 client->current_state = TTS_STATE_CREATED;
2355 ecore_thread_run(__start_reprepare_thread, __end_reprepare_thread, NULL, client);
2362 static Eina_Bool __tts_notify_state_changed(void *data)
2364 tts_h tts = (tts_h)data;
2366 tts_client_s* client = tts_client_get(tts);
2369 if (NULL == client) {
2370 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2374 if (NULL != client->state_changed_cb) {
2375 tts_client_use_callback(client);
2376 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2377 tts_client_not_use_callback(client);
2378 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2380 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2386 int __tts_cb_set_state(int uid, int state)
2388 tts_client_s* client = tts_client_get_by_uid(uid);
2389 if (NULL == client) {
2390 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2394 tts_state_e state_from_daemon = (tts_state_e)state;
2396 if (client->current_state == state_from_daemon) {
2397 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2401 if (NULL != client->state_changed_cb) {
2402 if (NULL != g_check_state_timer) {
2403 ecore_timer_del(g_check_state_timer);
2404 g_check_state_timer = NULL;
2406 g_check_state_timer = ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2408 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2411 client->before_state = client->current_state;
2412 client->current_state = state_from_daemon;
2418 int __tts_cb_utt_started(int uid, int utt_id)
2420 tts_client_s* client = tts_client_get_by_uid(uid);
2422 if (NULL == client) {
2423 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2424 return TTS_ERROR_INVALID_PARAMETER;
2427 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2429 client->utt_id = utt_id;
2431 /* call callback function */
2432 if (NULL != client->utt_started_cb) {
2433 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2434 tts_client_use_callback(client);
2435 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2436 tts_client_not_use_callback(client);
2438 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2444 int __tts_cb_utt_completed(int uid, int utt_id)
2446 tts_client_s* client = tts_client_get_by_uid(uid);
2448 if (NULL == client) {
2449 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2450 return TTS_ERROR_INVALID_PARAMETER;
2453 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2455 client->utt_id = utt_id;
2457 /* call callback function */
2458 if (NULL != client->utt_completeted_cb) {
2459 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2460 tts_client_use_callback(client);
2461 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2462 tts_client_not_use_callback(client);
2464 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2470 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2472 if (0 != __tts_get_feature_enabled()) {
2473 return TTS_ERROR_NOT_SUPPORTED;
2476 if (NULL == tts || NULL == callback) {
2477 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2478 return TTS_ERROR_INVALID_PARAMETER;
2481 tts_client_s* client = tts_client_get(tts);
2483 if (NULL == client) {
2484 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2485 return TTS_ERROR_INVALID_PARAMETER;
2488 if (TTS_STATE_CREATED != client->current_state) {
2489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2490 return TTS_ERROR_INVALID_STATE;
2493 client->state_changed_cb = callback;
2494 client->state_changed_user_data = user_data;
2496 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2501 int tts_unset_state_changed_cb(tts_h tts)
2503 if (0 != __tts_get_feature_enabled()) {
2504 return TTS_ERROR_NOT_SUPPORTED;
2508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2509 return TTS_ERROR_INVALID_PARAMETER;
2512 tts_client_s* client = tts_client_get(tts);
2514 if (NULL == client) {
2515 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2516 return TTS_ERROR_INVALID_PARAMETER;
2519 if (TTS_STATE_CREATED != client->current_state) {
2520 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2521 return TTS_ERROR_INVALID_STATE;
2524 client->state_changed_cb = NULL;
2525 client->state_changed_user_data = NULL;
2527 if (NULL != g_check_state_timer) {
2528 ecore_timer_del(g_check_state_timer);
2529 g_check_state_timer = NULL;
2532 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2537 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2539 if (0 != __tts_get_feature_enabled()) {
2540 return TTS_ERROR_NOT_SUPPORTED;
2543 if (NULL == tts || NULL == callback) {
2544 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2545 return TTS_ERROR_INVALID_PARAMETER;
2548 tts_client_s* client = tts_client_get(tts);
2550 if (NULL == client) {
2551 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2552 return TTS_ERROR_INVALID_PARAMETER;
2555 if (TTS_STATE_CREATED != client->current_state) {
2556 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2557 return TTS_ERROR_INVALID_STATE;
2560 client->utt_started_cb = callback;
2561 client->utt_started_user_data = user_data;
2563 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2568 int tts_unset_utterance_started_cb(tts_h tts)
2570 if (0 != __tts_get_feature_enabled()) {
2571 return TTS_ERROR_NOT_SUPPORTED;
2575 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2576 return TTS_ERROR_INVALID_PARAMETER;
2579 tts_client_s* client = tts_client_get(tts);
2581 if (NULL == client) {
2582 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2583 return TTS_ERROR_INVALID_PARAMETER;
2586 if (TTS_STATE_CREATED != client->current_state) {
2587 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2588 return TTS_ERROR_INVALID_STATE;
2591 client->utt_started_cb = NULL;
2592 client->utt_started_user_data = NULL;
2594 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2599 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2601 if (0 != __tts_get_feature_enabled()) {
2602 return TTS_ERROR_NOT_SUPPORTED;
2605 if (NULL == tts || NULL == callback) {
2606 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2607 return TTS_ERROR_INVALID_PARAMETER;
2610 tts_client_s* client = tts_client_get(tts);
2612 if (NULL == client) {
2613 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2614 return TTS_ERROR_INVALID_PARAMETER;
2617 if (TTS_STATE_CREATED != client->current_state) {
2618 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2619 return TTS_ERROR_INVALID_STATE;
2622 client->utt_completeted_cb = callback;
2623 client->utt_completed_user_data = user_data;
2625 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2630 int tts_unset_utterance_completed_cb(tts_h tts)
2632 if (0 != __tts_get_feature_enabled()) {
2633 return TTS_ERROR_NOT_SUPPORTED;
2637 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2638 return TTS_ERROR_INVALID_PARAMETER;
2641 tts_client_s* client = tts_client_get(tts);
2643 if (NULL == client) {
2644 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2645 return TTS_ERROR_INVALID_PARAMETER;
2648 if (TTS_STATE_CREATED != client->current_state) {
2649 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2650 return TTS_ERROR_INVALID_STATE;
2653 client->utt_completeted_cb = NULL;
2654 client->utt_completed_user_data = NULL;
2656 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2660 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2662 if (0 != __tts_get_feature_enabled()) {
2663 return TTS_ERROR_NOT_SUPPORTED;
2666 if (NULL == tts || NULL == callback) {
2667 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2668 return TTS_ERROR_INVALID_PARAMETER;
2671 tts_client_s* client = tts_client_get(tts);
2673 if (NULL == client) {
2674 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2675 return TTS_ERROR_INVALID_PARAMETER;
2678 if (TTS_STATE_CREATED != client->current_state) {
2679 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2680 return TTS_ERROR_INVALID_STATE;
2683 client->error_cb = callback;
2684 client->error_user_data = user_data;
2686 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2691 int tts_unset_error_cb(tts_h tts)
2693 if (0 != __tts_get_feature_enabled()) {
2694 return TTS_ERROR_NOT_SUPPORTED;
2698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2699 return TTS_ERROR_INVALID_PARAMETER;
2702 tts_client_s* client = tts_client_get(tts);
2704 if (NULL == client) {
2705 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2706 return TTS_ERROR_INVALID_PARAMETER;
2709 if (TTS_STATE_CREATED != client->current_state) {
2710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2711 return TTS_ERROR_INVALID_STATE;
2714 client->error_cb = NULL;
2715 client->error_user_data = NULL;
2717 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2722 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2724 if (0 != __tts_get_feature_enabled()) {
2725 return TTS_ERROR_NOT_SUPPORTED;
2728 if (NULL == tts || NULL == callback) {
2729 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2730 return TTS_ERROR_INVALID_PARAMETER;
2733 tts_client_s* client = tts_client_get(tts);
2735 if (NULL == client) {
2736 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2737 return TTS_ERROR_INVALID_PARAMETER;
2740 if (TTS_STATE_CREATED != client->current_state) {
2741 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2742 return TTS_ERROR_INVALID_STATE;
2745 client->default_voice_changed_cb = callback;
2746 client->default_voice_changed_user_data = user_data;
2748 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2753 int tts_unset_default_voice_changed_cb(tts_h tts)
2755 if (0 != __tts_get_feature_enabled()) {
2756 return TTS_ERROR_NOT_SUPPORTED;
2760 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2761 return TTS_ERROR_INVALID_PARAMETER;
2764 tts_client_s* client = tts_client_get(tts);
2766 if (NULL == client) {
2767 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2768 return TTS_ERROR_INVALID_PARAMETER;
2771 if (TTS_STATE_CREATED != client->current_state) {
2772 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2773 return TTS_ERROR_INVALID_STATE;
2776 client->default_voice_changed_cb = NULL;
2777 client->default_voice_changed_user_data = NULL;
2779 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2784 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2786 if (0 != __tts_get_feature_enabled()) {
2787 return TTS_ERROR_NOT_SUPPORTED;
2790 if (NULL == tts || NULL == callback) {
2791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2792 return TTS_ERROR_INVALID_PARAMETER;
2795 tts_client_s* client = tts_client_get(tts);
2797 if (NULL == client) {
2798 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2799 return TTS_ERROR_INVALID_PARAMETER;
2802 if (TTS_STATE_CREATED != client->current_state) {
2803 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2804 return TTS_ERROR_INVALID_STATE;
2807 client->engine_changed_cb = callback;
2808 client->engine_changed_user_data = user_data;
2810 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2815 int tts_unset_engine_changed_cb(tts_h tts)
2817 if (0 != __tts_get_feature_enabled()) {
2818 return TTS_ERROR_NOT_SUPPORTED;
2822 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2823 return TTS_ERROR_INVALID_PARAMETER;
2826 tts_client_s* client = tts_client_get(tts);
2828 if (NULL == client) {
2829 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2830 return TTS_ERROR_INVALID_PARAMETER;
2833 if (TTS_STATE_CREATED != client->current_state) {
2834 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2835 return TTS_ERROR_INVALID_STATE;
2838 client->engine_changed_cb = NULL;
2839 client->engine_changed_user_data = NULL;
2841 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2847 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2849 if (0 != __tts_get_feature_enabled()) {
2850 return TTS_ERROR_NOT_SUPPORTED;
2853 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2856 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2857 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2858 return TTS_ERROR_INVALID_PARAMETER;
2861 tts_client_s* client = tts_client_get(tts);
2863 if (NULL == client) {
2864 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2865 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2866 return TTS_ERROR_INVALID_PARAMETER;
2869 if (TTS_STATE_CREATED == client->current_state) {
2870 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2871 return TTS_ERROR_INVALID_STATE;
2874 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2875 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2876 return TTS_ERROR_INVALID_STATE;
2881 bool is_prepared = false;
2883 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2885 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2886 client->current_state = TTS_STATE_CREATED;
2887 if (0 == tts_prepare_sync(tts)) {
2889 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2891 } else if (TTS_ERROR_TIMED_OUT != ret) {
2892 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2895 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2898 if (TTS_RETRY_COUNT == count) {
2899 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2906 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2908 return TTS_ERROR_NONE;
2911 int tts_play_pcm(tts_h tts)
2913 if (0 != __tts_get_feature_enabled()) {
2914 return TTS_ERROR_NOT_SUPPORTED;
2917 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2921 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2922 return TTS_ERROR_INVALID_PARAMETER;
2925 tts_client_s* client = tts_client_get(tts);
2927 if (NULL == client) {
2928 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2929 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2930 return TTS_ERROR_INVALID_PARAMETER;
2933 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2934 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2935 return TTS_ERROR_INVALID_STATE;
2938 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2939 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2940 return TTS_ERROR_INVALID_STATE;
2945 bool is_prepared = false;
2947 ret = tts_dbus_request_play_pcm(client->uid);
2949 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2950 client->current_state = TTS_STATE_CREATED;
2951 if (0 == tts_prepare_sync(tts)) {
2953 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2955 } else if (TTS_ERROR_TIMED_OUT != ret) {
2956 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2959 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2962 if (TTS_RETRY_COUNT == count) {
2963 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2970 client->before_state = client->current_state;
2971 client->current_state = TTS_STATE_PLAYING;
2973 if (NULL != client->state_changed_cb) {
2974 tts_client_use_callback(client);
2975 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2976 tts_client_not_use_callback(client);
2977 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2980 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2982 return TTS_ERROR_NONE;
2985 int tts_stop_pcm(tts_h tts)
2987 if (0 != __tts_get_feature_enabled()) {
2988 return TTS_ERROR_NOT_SUPPORTED;
2991 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2994 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2995 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2996 return TTS_ERROR_INVALID_PARAMETER;
2999 tts_client_s* client = tts_client_get(tts);
3001 if (NULL == client) {
3002 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
3003 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3004 return TTS_ERROR_INVALID_PARAMETER;
3007 if (TTS_STATE_CREATED == client->current_state) {
3008 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
3009 return TTS_ERROR_INVALID_STATE;
3012 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
3013 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
3014 return TTS_ERROR_INVALID_STATE;
3019 bool is_prepared = false;
3021 ret = tts_dbus_request_stop_pcm(client->uid);
3023 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3024 client->current_state = TTS_STATE_CREATED;
3025 if (0 == tts_prepare_sync(tts)) {
3027 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
3029 } else if (TTS_ERROR_TIMED_OUT != ret) {
3030 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
3033 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
3036 if (TTS_RETRY_COUNT == count) {
3037 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
3044 client->before_state = client->current_state;
3045 client->current_state = TTS_STATE_READY;
3047 if (NULL != client->state_changed_cb) {
3048 tts_client_use_callback(client);
3049 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
3050 tts_client_not_use_callback(client);
3051 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
3054 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3056 return TTS_ERROR_NONE;
3060 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
3062 if (0 != __tts_get_feature_enabled()) {
3063 return TTS_ERROR_NOT_SUPPORTED;
3066 SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
3069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
3070 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3071 return TTS_ERROR_INVALID_PARAMETER;
3074 if (NULL == text_repeat || NULL == utt_id) {
3075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
3076 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3077 return TTS_ERROR_INVALID_PARAMETER;
3080 *text_repeat = NULL;
3083 tts_client_s* client = tts_client_get(tts);
3085 if (NULL == client) {
3086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
3087 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
3088 return TTS_ERROR_INVALID_PARAMETER;
3091 if (TTS_STATE_READY != client->current_state) {
3092 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
3093 return TTS_ERROR_INVALID_STATE;
3096 /* Clear the legacy and Add texts to be played repeatedly */
3098 ret = tts_stop(tts);
3099 if (TTS_ERROR_NONE != ret) {
3100 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
3104 if (NULL != client->text_repeat) {
3105 char* tmp_text = strdup(client->text_repeat);
3106 char* tmp_lang = NULL;
3107 if (NULL != g_language) {
3108 tmp_lang = strdup(g_language);
3110 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
3111 if (TTS_ERROR_NONE != ret) {
3112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
3113 if (NULL != tmp_text) {
3117 if (NULL != tmp_lang) {
3123 *text_repeat = strdup(client->text_repeat);
3124 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", (*text_repeat) ? *text_repeat : "NULL", *utt_id);
3125 if (NULL != tmp_text) {
3129 if (NULL != tmp_lang) {
3134 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
3135 return TTS_ERROR_OPERATION_FAILED;
3138 /* Play added texts */
3139 ret = tts_play(tts);
3140 if (TTS_ERROR_NONE != ret) {
3141 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
3142 if (NULL != *text_repeat) {
3144 *text_repeat = NULL;
3150 return TTS_ERROR_NONE;