2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
14 #include <app_manager.h>
19 #include <sys/types.h>
21 #include <system_info.h>
25 #include "tts_client.h"
26 #include "tts_config_mgr.h"
31 static bool g_screen_reader;
33 static int g_feature_enabled = -1;
35 static bool g_err_callback_status = false;
37 static int g_max_text_size = -1;
39 /* Function definition */
40 static Eina_Bool __tts_notify_state_changed(void *data);
41 static Eina_Bool __tts_notify_error(void *data);
48 static int __tts_get_feature_enabled()
50 if (0 == g_feature_enabled) {
51 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
52 return TTS_ERROR_NOT_SUPPORTED;
53 } else if (-1 == g_feature_enabled) {
54 bool tts_supported = false;
55 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
56 if (false == tts_supported) {
57 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
58 g_feature_enabled = 0;
59 return TTS_ERROR_NOT_SUPPORTED;
62 g_feature_enabled = 1;
64 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
65 return TTS_ERROR_NOT_SUPPORTED;
72 static const char* __tts_get_error_code(tts_error_e err)
75 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
76 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
77 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
78 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
79 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
80 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
81 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
82 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
83 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
84 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
85 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
86 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
87 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
88 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
89 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
91 return "Invalid error code";
96 static int __tts_convert_config_error_code(tts_config_error_e code)
98 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
99 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
100 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
101 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
102 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
103 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
104 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
105 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
106 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
111 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)
113 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
114 before_lang, before_voice_type, language, voice_type);
116 GList* client_list = NULL;
117 client_list = tts_client_get_client_list();
120 tts_client_s *data = NULL;
122 if (g_list_length(client_list) > 0) {
123 /* Get a first item */
124 iter = g_list_first(client_list);
126 while (NULL != iter) {
128 if (NULL != data->default_voice_changed_cb) {
129 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
130 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
131 language, voice_type, data->default_voice_changed_user_data);
135 iter = g_list_next(iter);
142 static Eina_Bool __reconnect_by_engine_changed(void* data)
144 tts_h tts = (tts_h)data;
146 tts_client_s* client = tts_client_get(tts);
147 if (NULL == client) {
148 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
152 if (TTS_STATE_READY != client->current_state) {
157 int ret = tts_unprepare(tts);
159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
161 ret = tts_prepare(tts);
163 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
169 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)
171 tts_h tts = (tts_h)user_data;
173 tts_client_s* client = tts_client_get(tts);
174 if (NULL == client) {
175 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
179 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
180 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
181 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
182 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
184 /* When the default engine is changed, please unload the old engine and load the new one. */
187 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
190 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
193 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
194 } else if (TTS_STATE_READY == client->current_state) {
195 ret = tts_unprepare(tts);
197 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
199 ret = tts_prepare(tts);
201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
205 /* call callback function */
206 if (NULL != client->engine_changed_cb) {
207 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
209 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
214 int tts_create(tts_h* tts)
216 if (0 != __tts_get_feature_enabled()) {
217 return TTS_ERROR_NOT_SUPPORTED;
220 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
225 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
226 return TTS_ERROR_INVALID_PARAMETER;
229 if (0 == tts_client_get_size()) {
230 if (0 != tts_dbus_open_connection()) {
231 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
232 return TTS_ERROR_OPERATION_FAILED;
236 if (0 != tts_client_new(tts)) {
237 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
238 return TTS_ERROR_OUT_OF_MEMORY;
241 tts_client_s* client = tts_client_get(*tts);
242 if (NULL == client) {
243 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
244 return TTS_ERROR_OPERATION_FAILED;
247 int ret = tts_config_mgr_initialize(client->uid);
249 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
250 tts_client_destroy(*tts);
251 return __tts_convert_config_error_code(ret);
254 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
256 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
257 tts_client_destroy(*tts);
258 return __tts_convert_config_error_code(ret);
261 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
262 SLOG(LOG_DEBUG, TAG_TTSC, " ");
264 return TTS_ERROR_NONE;
267 int tts_destroy(tts_h tts)
269 if (0 != __tts_get_feature_enabled()) {
270 return TTS_ERROR_NOT_SUPPORTED;
273 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
276 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
277 return TTS_ERROR_INVALID_PARAMETER;
280 tts_client_s* client = tts_client_get(tts);
283 if (NULL == client) {
284 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
285 return TTS_ERROR_INVALID_PARAMETER;
288 /* check used callback */
289 if (0 != tts_client_get_use_callback(client)) {
290 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
291 return TTS_ERROR_OPERATION_FAILED;
294 tts_config_mgr_finalize(client->uid);
298 int screen_reader = -1;
301 switch (client->current_state) {
302 case TTS_STATE_PAUSED:
303 case TTS_STATE_PLAYING:
304 case TTS_STATE_READY:
305 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
307 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
309 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);
310 g_screen_reader = (bool)screen_reader;
312 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
314 ret = tts_dbus_request_finalize(client->uid);
316 if (TTS_ERROR_TIMED_OUT != ret) {
317 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
320 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
323 if (TTS_RETRY_COUNT == count) {
324 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
331 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
334 client->before_state = client->current_state;
335 client->current_state = TTS_STATE_CREATED;
337 case TTS_STATE_CREATED:
338 if (NULL != client->conn_timer) {
339 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
340 ecore_timer_del(client->conn_timer);
341 client->conn_timer = NULL;
344 tts_client_destroy(tts);
351 if (0 == tts_client_get_size()) {
352 if (0 != tts_dbus_close_connection()) {
353 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
359 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
361 return TTS_ERROR_NONE;
364 void __tts_screen_reader_changed_cb(bool value)
366 g_screen_reader = value;
369 int tts_set_mode(tts_h tts, tts_mode_e mode)
371 if (0 != __tts_get_feature_enabled()) {
372 return TTS_ERROR_NOT_SUPPORTED;
375 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
377 tts_client_s* client = tts_client_get(tts);
380 if (NULL == client) {
381 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
382 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
383 return TTS_ERROR_INVALID_PARAMETER;
387 if (client->current_state != TTS_STATE_CREATED) {
388 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
389 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
390 SLOG(LOG_DEBUG, TAG_TTSC, " ");
391 return TTS_ERROR_INVALID_STATE;
394 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
397 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
398 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
399 SLOG(LOG_DEBUG, TAG_TTSC, " ");
400 return TTS_ERROR_INVALID_PARAMETER;
403 if (TTS_MODE_SCREEN_READER == mode) {
406 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
408 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
409 return TTS_ERROR_OPERATION_FAILED;
411 g_screen_reader = (bool)screen_reader;
412 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
414 tts_config_unset_screen_reader_callback(client->uid);
417 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
419 return TTS_ERROR_NONE;
422 int tts_get_mode(tts_h tts, tts_mode_e* mode)
424 if (0 != __tts_get_feature_enabled()) {
425 return TTS_ERROR_NOT_SUPPORTED;
428 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
430 tts_client_s* client = tts_client_get(tts);
433 if (NULL == client) {
434 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
435 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
436 SLOG(LOG_DEBUG, TAG_TTSC, " ");
437 return TTS_ERROR_INVALID_PARAMETER;
441 if (client->current_state != TTS_STATE_CREATED) {
442 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
443 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
444 SLOG(LOG_DEBUG, TAG_TTSC, " ");
445 return TTS_ERROR_INVALID_STATE;
449 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
450 return TTS_ERROR_INVALID_PARAMETER;
453 *mode = client->mode;
455 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
456 SLOG(LOG_DEBUG, TAG_TTSC, " ");
458 return TTS_ERROR_NONE;
461 int tts_set_credential(tts_h tts, const char* credential)
463 if (0 != __tts_get_feature_enabled()) {
464 return TTS_ERROR_NOT_SUPPORTED;
467 if (NULL == tts || NULL == credential) {
468 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
469 return TTS_ERROR_INVALID_PARAMETER;
472 tts_client_s* client = tts_client_get(tts);
474 if (NULL == client) {
475 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
476 return TTS_ERROR_INVALID_PARAMETER;
479 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
480 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
481 return TTS_ERROR_INVALID_STATE;
484 if (NULL != client->credential) {
485 free(client->credential);
486 client->credential = NULL;
488 client->credential = strdup(credential);
490 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
492 return TTS_ERROR_NONE;
495 int tts_set_server_tts(tts_h tts, const char* credential)
497 if (0 != __tts_get_feature_enabled()) {
498 return TTS_ERROR_NOT_SUPPORTED;
502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
503 return TTS_ERROR_INVALID_PARAMETER;
506 tts_client_s* client = tts_client_get(tts);
508 if (NULL == client) {
509 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
510 return TTS_ERROR_INVALID_PARAMETER;
513 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
515 return TTS_ERROR_INVALID_STATE;
518 if (NULL != client->credential) {
519 free(client->credential);
520 client->credential = NULL;
523 client->internal = true;
526 if (NULL != credential) {
527 key = strdup("EnableServerTTS");
528 client->credential = strdup(credential);
529 if (NULL == client->credential) {
530 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
535 return TTS_ERROR_OUT_OF_MEMORY;
538 key = strdup("DisableServerTTS");
542 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
543 return TTS_ERROR_OUT_OF_MEMORY;
548 int ret = app_manager_get_app_id(pid, &appid);
549 if (0 != ret || NULL == appid) {
550 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
557 return TTS_ERROR_OPERATION_FAILED;
560 ret = tts_set_private_data(tts, key, appid);
562 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
575 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
577 return TTS_ERROR_NONE;
580 static Eina_Bool __tts_connect_daemon(void *data)
582 tts_h tts = (tts_h)data;
583 tts_client_s* client = tts_client_get(tts);
586 if (NULL == client) {
587 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
592 if (0 != tts_dbus_request_hello(client->uid)) {
596 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
598 /* do request initialize */
600 bool credential_needed = false;
602 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
604 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
607 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
610 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
611 client->conn_timer = NULL;
614 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
615 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
617 client->reason = TTS_ERROR_PERMISSION_DENIED;
620 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
621 client->conn_timer = NULL;
624 } else if (TTS_ERROR_NONE != ret) {
625 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
629 /* success to connect tts-daemon */
630 client->credential_needed = credential_needed;
631 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
634 client->conn_timer = NULL;
636 client = tts_client_get(tts);
638 if (NULL == client) {
639 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
643 client->before_state = client->current_state;
644 client->current_state = TTS_STATE_READY;
646 if (NULL != client->state_changed_cb) {
647 tts_client_use_callback(client);
648 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
649 tts_client_not_use_callback(client);
651 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
654 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
659 int tts_prepare(tts_h tts)
661 if (0 != __tts_get_feature_enabled()) {
662 return TTS_ERROR_NOT_SUPPORTED;
665 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
667 tts_client_s* client = tts_client_get(tts);
670 if (NULL == client) {
671 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
672 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
673 return TTS_ERROR_INVALID_PARAMETER;
677 if (client->current_state != TTS_STATE_CREATED) {
678 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
679 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
680 return TTS_ERROR_INVALID_STATE;
683 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
685 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
687 return TTS_ERROR_NONE;
690 int tts_prepare_sync(tts_h tts)
692 if (0 != __tts_get_feature_enabled()) {
693 return TTS_ERROR_NOT_SUPPORTED;
696 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
698 tts_client_s* client = tts_client_get(tts);
701 if (NULL == client) {
702 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
703 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
704 return TTS_ERROR_INVALID_PARAMETER;
708 if (client->current_state != TTS_STATE_CREATED) {
709 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
710 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
711 return TTS_ERROR_INVALID_STATE;
715 while (EINA_TRUE == __tts_connect_daemon(NULL) && TTS_CONNECTION_RETRY_COUNT > cnt) {
719 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
721 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
722 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
723 return TTS_ERROR_OPERATION_FAILED;
726 return TTS_ERROR_NONE;
729 int tts_unprepare(tts_h tts)
731 if (0 != __tts_get_feature_enabled()) {
732 return TTS_ERROR_NOT_SUPPORTED;
735 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
737 tts_client_s* client = tts_client_get(tts);
740 if (NULL == client) {
741 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
742 return TTS_ERROR_INVALID_PARAMETER;
746 if (client->current_state != TTS_STATE_READY) {
747 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
748 return TTS_ERROR_INVALID_STATE;
753 int screen_reader = -1;
755 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
757 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
759 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);
760 g_screen_reader = (bool)screen_reader;
763 bool is_prepared = false;
764 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
766 ret = tts_dbus_request_finalize(client->uid);
768 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
769 if (0 == tts_prepare_sync(tts)) {
771 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
773 } else if (TTS_ERROR_TIMED_OUT != ret) {
774 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
777 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
780 if (TTS_RETRY_COUNT == count) {
781 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
788 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
791 client->before_state = client->current_state;
792 client->current_state = TTS_STATE_CREATED;
794 if (NULL != client->state_changed_cb) {
795 tts_client_use_callback(client);
796 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
797 tts_client_not_use_callback(client);
798 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
801 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
803 return TTS_ERROR_NONE;
806 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
808 tts_h tts = (tts_h)user_data;
810 tts_client_s* client = tts_client_get(tts);
811 if (NULL == client) {
812 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
816 /* call callback function */
817 if (NULL != client->supported_voice_cb) {
818 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
820 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
826 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
828 if (0 != __tts_get_feature_enabled()) {
829 return TTS_ERROR_NOT_SUPPORTED;
832 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
834 if (NULL == tts || NULL == callback) {
835 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
836 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
837 return TTS_ERROR_INVALID_PARAMETER;
840 tts_client_s* client = tts_client_get(tts);
843 if (NULL == client) {
844 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
845 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
846 return TTS_ERROR_INVALID_PARAMETER;
850 char* current_engine = NULL;
851 ret = tts_config_mgr_get_engine(¤t_engine);
853 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
854 return __tts_convert_config_error_code(ret);
857 client->supported_voice_cb = callback;
858 client->supported_voice_user_data = user_data;
860 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
862 if (NULL != current_engine) {
863 free(current_engine);
864 current_engine = NULL;
867 client->supported_voice_cb = NULL;
868 client->supported_voice_user_data = NULL;
871 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
872 ret = TTS_ERROR_OPERATION_FAILED;
875 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
880 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
882 if (0 != __tts_get_feature_enabled()) {
883 return TTS_ERROR_NOT_SUPPORTED;
886 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
889 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
890 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
891 return TTS_ERROR_INVALID_PARAMETER;
894 tts_client_s* client = tts_client_get(tts);
896 if (NULL == client) {
897 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
898 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
899 return TTS_ERROR_INVALID_PARAMETER;
902 /* Request call remote method */
904 ret = tts_config_mgr_get_voice(lang, vctype);
906 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
907 return __tts_convert_config_error_code(ret);
909 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
912 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
917 int tts_get_max_text_size(tts_h tts, unsigned int* size)
919 if (0 != __tts_get_feature_enabled()) {
920 return TTS_ERROR_NOT_SUPPORTED;
923 if (NULL == tts || NULL == size) {
924 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
925 return TTS_ERROR_INVALID_PARAMETER;
928 tts_client_s* client = tts_client_get(tts);
930 if (NULL == client) {
931 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
932 return TTS_ERROR_INVALID_PARAMETER;
935 if (TTS_STATE_READY != client->current_state) {
936 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
937 return TTS_ERROR_INVALID_STATE;
940 if (0 != tts_config_mgr_get_max_text_size(size)) {
941 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
942 return TTS_ERROR_INVALID_PARAMETER;
945 g_max_text_size = (int)*size;
947 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
948 return TTS_ERROR_NONE;
951 int tts_get_state(tts_h tts, tts_state_e* state)
953 if (0 != __tts_get_feature_enabled()) {
954 return TTS_ERROR_NOT_SUPPORTED;
957 if (NULL == tts || NULL == state) {
958 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
959 return TTS_ERROR_INVALID_PARAMETER;
962 tts_client_s* client = tts_client_get(tts);
964 if (NULL == client) {
965 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
966 return TTS_ERROR_INVALID_PARAMETER;
969 *state = client->current_state;
972 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
973 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
974 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
975 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
976 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
979 return TTS_ERROR_NONE;
982 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
984 if (0 != __tts_get_feature_enabled()) {
985 return TTS_ERROR_NOT_SUPPORTED;
988 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
989 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
990 return TTS_ERROR_INVALID_PARAMETER;
993 tts_client_s* client = tts_client_get(tts);
995 if (NULL == client) {
996 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
997 return TTS_ERROR_INVALID_PARAMETER;
1000 *min = TTS_SPEED_MIN;
1001 *normal = TTS_SPEED_NORMAL;
1002 *max = TTS_SPEED_MAX;
1004 return TTS_ERROR_NONE;
1007 int tts_get_error_message(tts_h tts, char** err_msg)
1009 if (0 != __tts_get_feature_enabled()) {
1010 return TTS_ERROR_NOT_SUPPORTED;
1013 if (NULL == tts || NULL == err_msg) {
1014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1015 return TTS_ERROR_INVALID_PARAMETER;
1018 tts_client_s* client = tts_client_get(tts);
1020 if (NULL == client) {
1021 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1022 return TTS_ERROR_INVALID_PARAMETER;
1025 if (NULL != client->err_msg) {
1026 *err_msg = strdup(client->err_msg);
1027 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1030 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1033 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1035 return TTS_ERROR_NONE;
1038 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1040 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1042 if (0 != __tts_get_feature_enabled()) {
1043 return TTS_ERROR_NOT_SUPPORTED;
1047 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1048 return TTS_ERROR_INVALID_PARAMETER;
1051 if (voice_type < 0) {
1052 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1053 return TTS_ERROR_INVALID_PARAMETER;
1056 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1058 if (NULL == tts || NULL == utt_id) {
1059 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1060 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1061 return TTS_ERROR_INVALID_PARAMETER;
1064 tts_client_s* client = tts_client_get(tts);
1066 if (NULL == client) {
1067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1068 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1069 return TTS_ERROR_INVALID_PARAMETER;
1072 if (TTS_STATE_CREATED == client->current_state) {
1073 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1074 return TTS_ERROR_INVALID_STATE;
1077 if (-1 == g_max_text_size) {
1078 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1079 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1080 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1081 return TTS_ERROR_INVALID_PARAMETER;
1085 if (0 == g_max_text_size) {
1086 if (strlen(text) <= 0) {
1087 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1088 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1089 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1090 return TTS_ERROR_INVALID_PARAMETER;
1093 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1094 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1095 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1096 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1097 return TTS_ERROR_INVALID_PARAMETER;
1101 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1102 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1103 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1104 return TTS_ERROR_INVALID_PARAMETER;
1107 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1108 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1109 return TTS_ERROR_INVALID_STATE;
1112 if (true == client->credential_needed && NULL == client->credential) {
1113 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1114 return TTS_ERROR_PERMISSION_DENIED;
1117 /* check valid utf8 */
1121 dbus_error_init(&err);
1123 valid = dbus_validate_utf8(text, &err);
1124 if (dbus_error_is_set(&err)) {
1125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1126 dbus_error_free(&err);
1127 return TTS_ERROR_INVALID_PARAMETER;
1130 if (valid != true) {
1131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1132 return TTS_ERROR_INVALID_PARAMETER;
1134 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1136 /* change default language value */
1139 if (NULL == language)
1140 temp = strdup("default");
1142 temp = strdup(language);
1144 client->current_utt_id++;
1145 if (client->current_utt_id == 10000) {
1146 client->current_utt_id = 1;
1152 bool is_prepared = false;
1154 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1156 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1157 if (0 == tts_prepare_sync(tts)) {
1159 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1161 } else if (TTS_ERROR_TIMED_OUT != ret) {
1162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1165 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1168 if (TTS_RETRY_MIN_COUNT == count) {
1169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1174 *utt_id = client->current_utt_id;
1183 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1188 static void __tts_play_async(void *data)
1190 tts_h tts = (tts_h)data;
1191 tts_client_s* client = tts_client_get(tts);
1194 if (NULL == client) {
1195 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1201 bool is_prepared = false;
1203 ret = tts_dbus_request_play(client->uid, client->credential);
1205 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1206 if (0 == tts_prepare_sync(tts)) {
1208 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1210 } else if (TTS_ERROR_TIMED_OUT != ret) {
1211 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1214 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1217 if (TTS_RETRY_COUNT == count) {
1218 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1226 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1228 client->reason = ret;
1229 client->utt_id = -1;
1231 ecore_timer_add(0, __tts_notify_error, client->tts);
1235 client->before_state = client->current_state;
1236 client->current_state = TTS_STATE_PLAYING;
1238 if (NULL != client->state_changed_cb) {
1239 tts_client_use_callback(client);
1240 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1241 tts_client_not_use_callback(client);
1242 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1245 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1250 int tts_play_async(tts_h tts)
1252 if (0 != __tts_get_feature_enabled()) {
1253 return TTS_ERROR_NOT_SUPPORTED;
1256 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1259 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1260 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1261 return TTS_ERROR_INVALID_PARAMETER;
1264 tts_client_s* client = tts_client_get(tts);
1266 if (NULL == client) {
1267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1268 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1269 return TTS_ERROR_INVALID_PARAMETER;
1272 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1273 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1274 return TTS_ERROR_INVALID_STATE;
1277 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1278 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1279 return TTS_ERROR_INVALID_STATE;
1282 if (true == client->credential_needed && NULL == client->credential) {
1283 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1284 return TTS_ERROR_PERMISSION_DENIED;
1287 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1289 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1291 return TTS_ERROR_NONE;
1294 int tts_play(tts_h tts)
1296 if (0 != __tts_get_feature_enabled()) {
1297 return TTS_ERROR_NOT_SUPPORTED;
1300 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1303 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1304 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1305 return TTS_ERROR_INVALID_PARAMETER;
1308 tts_client_s* client = tts_client_get(tts);
1310 if (NULL == client) {
1311 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1312 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1313 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1314 return TTS_ERROR_INVALID_PARAMETER;
1317 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1318 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1319 return TTS_ERROR_INVALID_STATE;
1322 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1323 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1324 return TTS_ERROR_INVALID_STATE;
1327 if (true == client->credential_needed && NULL == client->credential) {
1328 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1329 return TTS_ERROR_PERMISSION_DENIED;
1334 bool is_prepared = false;
1336 ret = tts_dbus_request_play(client->uid, client->credential);
1338 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1339 if (0 == tts_prepare_sync(tts)) {
1341 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1343 } else if (TTS_ERROR_TIMED_OUT != ret) {
1344 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1347 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1350 if (TTS_RETRY_COUNT == count) {
1351 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1358 client->before_state = client->current_state;
1359 client->current_state = TTS_STATE_PLAYING;
1361 if (NULL != client->state_changed_cb) {
1362 tts_client_use_callback(client);
1363 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1364 tts_client_not_use_callback(client);
1365 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1368 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1370 return TTS_ERROR_NONE;
1373 static void __tts_stop_async(void *data)
1375 tts_h tts = (tts_h)data;
1376 tts_client_s* client = tts_client_get(tts);
1379 if (NULL == client) {
1380 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1386 bool is_prepared = false;
1388 ret = tts_dbus_request_stop(client->uid);
1390 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1391 if (0 == tts_prepare_sync(tts)) {
1393 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1395 } else if (TTS_ERROR_TIMED_OUT != ret) {
1396 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1399 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1402 if (TTS_RETRY_COUNT == count) {
1403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1411 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1413 client->reason = ret;
1414 client->utt_id = -1;
1416 ecore_timer_add(0, __tts_notify_error, client->tts);
1420 client->before_state = client->current_state;
1421 client->current_state = TTS_STATE_READY;
1423 if (NULL != client->state_changed_cb) {
1424 tts_client_use_callback(client);
1425 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1426 tts_client_not_use_callback(client);
1427 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1430 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1435 int tts_stop_aync(tts_h tts)
1437 if (0 != __tts_get_feature_enabled()) {
1438 return TTS_ERROR_NOT_SUPPORTED;
1441 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1444 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1445 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1446 return TTS_ERROR_INVALID_PARAMETER;
1449 tts_client_s* client = tts_client_get(tts);
1451 if (NULL == client) {
1452 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1453 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1454 return TTS_ERROR_INVALID_PARAMETER;
1457 if (TTS_STATE_CREATED == client->current_state) {
1458 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1459 return TTS_ERROR_INVALID_STATE;
1462 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1463 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1464 return TTS_ERROR_INVALID_STATE;
1467 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1469 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1471 return TTS_ERROR_NONE;
1474 int tts_stop(tts_h tts)
1476 if (0 != __tts_get_feature_enabled()) {
1477 return TTS_ERROR_NOT_SUPPORTED;
1480 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1483 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1484 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1485 return TTS_ERROR_INVALID_PARAMETER;
1488 tts_client_s* client = tts_client_get(tts);
1490 if (NULL == client) {
1491 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1492 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1493 return TTS_ERROR_INVALID_PARAMETER;
1496 if (TTS_STATE_CREATED == client->current_state) {
1497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1498 return TTS_ERROR_INVALID_STATE;
1501 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1502 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1503 return TTS_ERROR_INVALID_STATE;
1508 bool is_prepared = false;
1510 ret = tts_dbus_request_stop(client->uid);
1512 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1513 if (0 == tts_prepare_sync(tts)) {
1515 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1517 } else if (TTS_ERROR_TIMED_OUT != ret) {
1518 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1521 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1524 if (TTS_RETRY_COUNT == count) {
1525 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1532 client->before_state = client->current_state;
1533 client->current_state = TTS_STATE_READY;
1535 if (NULL != client->state_changed_cb) {
1536 tts_client_use_callback(client);
1537 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1538 tts_client_not_use_callback(client);
1539 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1542 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1544 return TTS_ERROR_NONE;
1547 static void __tts_pause_async(void *data)
1549 tts_h tts = (tts_h)data;
1550 tts_client_s* client = tts_client_get(tts);
1553 if (NULL == client) {
1554 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1560 bool is_prepared = false;
1562 ret = tts_dbus_request_pause(client->uid);
1564 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1565 if (0 == tts_prepare_sync(tts)) {
1567 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1569 } else if (TTS_ERROR_TIMED_OUT != ret) {
1570 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1573 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1576 if (TTS_RETRY_COUNT == count) {
1577 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1585 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1587 client->reason = ret;
1588 client->utt_id = -1;
1590 ecore_timer_add(0, __tts_notify_error, client->tts);
1594 client->before_state = client->current_state;
1595 client->current_state = TTS_STATE_PAUSED;
1597 if (NULL != client->state_changed_cb) {
1598 tts_client_use_callback(client);
1599 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1600 tts_client_not_use_callback(client);
1601 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1604 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1609 int tts_pause_async(tts_h tts)
1611 if (0 != __tts_get_feature_enabled()) {
1612 return TTS_ERROR_NOT_SUPPORTED;
1615 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1618 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1619 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1620 return TTS_ERROR_INVALID_PARAMETER;
1623 tts_client_s* client = tts_client_get(tts);
1625 if (NULL == client) {
1626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1627 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1628 return TTS_ERROR_INVALID_PARAMETER;
1631 if (TTS_STATE_PLAYING != client->current_state) {
1632 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1633 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1634 return TTS_ERROR_INVALID_STATE;
1637 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1638 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1639 return TTS_ERROR_INVALID_STATE;
1642 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1644 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1646 return TTS_ERROR_NONE;
1649 int tts_pause(tts_h tts)
1651 if (0 != __tts_get_feature_enabled()) {
1652 return TTS_ERROR_NOT_SUPPORTED;
1655 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1659 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1660 return TTS_ERROR_INVALID_PARAMETER;
1663 tts_client_s* client = tts_client_get(tts);
1665 if (NULL == client) {
1666 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1667 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1668 return TTS_ERROR_INVALID_PARAMETER;
1671 if (TTS_STATE_PLAYING != client->current_state) {
1672 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1673 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1674 return TTS_ERROR_INVALID_STATE;
1677 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1678 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1679 return TTS_ERROR_INVALID_STATE;
1684 bool is_prepared = false;
1686 ret = tts_dbus_request_pause(client->uid);
1688 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1689 if (0 == tts_prepare_sync(tts)) {
1691 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1693 } else if (TTS_ERROR_TIMED_OUT != ret) {
1694 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1697 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1700 if (TTS_RETRY_COUNT == count) {
1701 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1708 client->before_state = client->current_state;
1709 client->current_state = TTS_STATE_PAUSED;
1711 if (NULL != client->state_changed_cb) {
1712 tts_client_use_callback(client);
1713 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1714 tts_client_not_use_callback(client);
1715 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1718 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1720 return TTS_ERROR_NONE;
1723 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1725 if (0 != __tts_get_feature_enabled()) {
1726 return TTS_ERROR_NOT_SUPPORTED;
1729 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1732 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1733 return TTS_ERROR_INVALID_PARAMETER;
1736 if (NULL == key || NULL == data) {
1737 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1738 return TTS_ERROR_INVALID_PARAMETER;
1741 tts_client_s* client = tts_client_get(tts);
1743 if (NULL == client) {
1744 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1745 return TTS_ERROR_INVALID_PARAMETER;
1748 if (TTS_STATE_READY != client->current_state) {
1749 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1750 return TTS_ERROR_INVALID_STATE;
1753 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1754 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1755 return TTS_ERROR_INVALID_PARAMETER;
1760 bool is_prepared = false;
1762 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1764 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1765 if (0 == tts_prepare_sync(tts)) {
1767 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1769 } else if (TTS_ERROR_TIMED_OUT != ret) {
1770 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1773 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1776 if (TTS_RETRY_COUNT == count) {
1777 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1784 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1789 int tts_get_private_data(tts_h tts, const char* key, char** data)
1791 if (0 != __tts_get_feature_enabled()) {
1792 return TTS_ERROR_NOT_SUPPORTED;
1795 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1798 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1799 return TTS_ERROR_INVALID_PARAMETER;
1802 if (NULL == key || NULL == data) {
1803 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1804 return TTS_ERROR_INVALID_PARAMETER;
1807 tts_client_s* client = tts_client_get(tts);
1809 if (NULL == client) {
1810 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1811 return TTS_ERROR_INVALID_PARAMETER;
1814 if (TTS_STATE_READY != client->current_state) {
1815 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1816 return TTS_ERROR_INVALID_STATE;
1821 bool is_prepared = false;
1823 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1825 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1826 if (0 == tts_prepare_sync(tts)) {
1828 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1830 } else if (TTS_ERROR_TIMED_OUT != ret) {
1831 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1834 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1837 if (TTS_RETRY_COUNT == count) {
1838 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1845 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1850 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1855 static Eina_Bool __tts_notify_error(void *data)
1857 tts_h tts = (tts_h)data;
1859 tts_client_s* client = tts_client_get(tts);
1862 if (NULL == client) {
1863 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1867 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1869 if (NULL != client->error_cb) {
1870 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1871 tts_client_use_callback(client);
1872 g_err_callback_status = true;
1873 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1874 g_err_callback_status = false;
1875 tts_client_not_use_callback(client);
1877 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1883 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1886 GList* client_list = NULL;
1887 client_list = tts_client_get_client_list();
1890 tts_client_s *data = NULL;
1892 if (g_list_length(client_list) > 0) {
1893 /* Get a first item */
1894 iter = g_list_first(client_list);
1896 while (NULL != iter) {
1899 data->utt_id = utt_id;
1900 data->reason = reason;
1901 if (NULL != data->err_msg) {
1902 free(data->err_msg);
1903 data->err_msg = NULL;
1905 if (NULL != err_msg)
1906 data->err_msg = strdup(err_msg);
1908 /* call callback function */
1909 if (NULL != data->error_cb) {
1910 ecore_timer_add(0, __tts_notify_error, data->tts);
1912 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1915 if (TTS_ERROR_SERVICE_RESET == reason) {
1916 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1918 data->current_state = TTS_STATE_CREATED;
1919 if (0 != tts_prepare(data->tts)) {
1920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1925 iter = g_list_next(iter);
1929 tts_client_s* client = tts_client_get_by_uid(uid);
1931 if (NULL == client) {
1932 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1933 return TTS_ERROR_INVALID_PARAMETER;
1936 client->utt_id = utt_id;
1937 client->reason = reason;
1938 if (NULL != client->err_msg) {
1939 free(client->err_msg);
1940 client->err_msg = NULL;
1942 if (NULL != err_msg)
1943 client->err_msg = strdup(err_msg);
1945 /* call callback function */
1946 if (NULL != client->error_cb) {
1947 ecore_timer_add(0, __tts_notify_error, client->tts);
1949 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1952 if (TTS_ERROR_SERVICE_RESET == reason) {
1953 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1955 client->current_state = TTS_STATE_CREATED;
1956 if (0 != tts_prepare(client->tts)) {
1957 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1965 static Eina_Bool __tts_notify_state_changed(void *data)
1967 tts_h tts = (tts_h)data;
1969 tts_client_s* client = tts_client_get(tts);
1972 if (NULL == client) {
1973 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1977 if (NULL != client->state_changed_cb) {
1978 tts_client_use_callback(client);
1979 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1980 tts_client_not_use_callback(client);
1981 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1983 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1989 int __tts_cb_set_state(int uid, int state)
1991 tts_client_s* client = tts_client_get_by_uid(uid);
1992 if (NULL == client) {
1993 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1997 tts_state_e state_from_daemon = (tts_state_e)state;
1999 if (client->current_state == state_from_daemon) {
2000 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2004 if (NULL != client->state_changed_cb) {
2005 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2007 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2010 client->before_state = client->current_state;
2011 client->current_state = state_from_daemon;
2016 int __tts_cb_utt_started(int uid, int utt_id)
2018 tts_client_s* client = tts_client_get_by_uid(uid);
2020 if (NULL == client) {
2021 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2022 return TTS_ERROR_INVALID_PARAMETER;
2025 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2027 client->utt_id = utt_id;
2029 /* call callback function */
2030 if (NULL != client->utt_started_cb) {
2031 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2032 tts_client_use_callback(client);
2033 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2034 tts_client_not_use_callback(client);
2036 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2042 int __tts_cb_utt_completed(int uid, int utt_id)
2044 tts_client_s* client = tts_client_get_by_uid(uid);
2046 if (NULL == client) {
2047 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2048 return TTS_ERROR_INVALID_PARAMETER;
2051 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2053 client->utt_id = utt_id;
2055 /* call callback function */
2056 if (NULL != client->utt_completeted_cb) {
2057 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2058 tts_client_use_callback(client);
2059 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2060 tts_client_not_use_callback(client);
2062 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2068 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2070 if (0 != __tts_get_feature_enabled()) {
2071 return TTS_ERROR_NOT_SUPPORTED;
2074 if (NULL == tts || NULL == callback) {
2075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2076 return TTS_ERROR_INVALID_PARAMETER;
2079 tts_client_s* client = tts_client_get(tts);
2081 if (NULL == client) {
2082 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2083 return TTS_ERROR_INVALID_PARAMETER;
2086 if (TTS_STATE_CREATED != client->current_state) {
2087 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2088 return TTS_ERROR_INVALID_STATE;
2091 client->state_changed_cb = callback;
2092 client->state_changed_user_data = user_data;
2094 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2099 int tts_unset_state_changed_cb(tts_h tts)
2101 if (0 != __tts_get_feature_enabled()) {
2102 return TTS_ERROR_NOT_SUPPORTED;
2106 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2107 return TTS_ERROR_INVALID_PARAMETER;
2110 tts_client_s* client = tts_client_get(tts);
2112 if (NULL == client) {
2113 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2114 return TTS_ERROR_INVALID_PARAMETER;
2117 if (TTS_STATE_CREATED != client->current_state) {
2118 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2119 return TTS_ERROR_INVALID_STATE;
2122 client->state_changed_cb = NULL;
2123 client->state_changed_user_data = NULL;
2125 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2130 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2132 if (0 != __tts_get_feature_enabled()) {
2133 return TTS_ERROR_NOT_SUPPORTED;
2136 if (NULL == tts || NULL == callback) {
2137 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2138 return TTS_ERROR_INVALID_PARAMETER;
2141 tts_client_s* client = tts_client_get(tts);
2143 if (NULL == client) {
2144 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2145 return TTS_ERROR_INVALID_PARAMETER;
2148 if (TTS_STATE_CREATED != client->current_state) {
2149 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2150 return TTS_ERROR_INVALID_STATE;
2153 client->utt_started_cb = callback;
2154 client->utt_started_user_data = user_data;
2156 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2161 int tts_unset_utterance_started_cb(tts_h tts)
2163 if (0 != __tts_get_feature_enabled()) {
2164 return TTS_ERROR_NOT_SUPPORTED;
2168 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2169 return TTS_ERROR_INVALID_PARAMETER;
2172 tts_client_s* client = tts_client_get(tts);
2174 if (NULL == client) {
2175 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2176 return TTS_ERROR_INVALID_PARAMETER;
2179 if (TTS_STATE_CREATED != client->current_state) {
2180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2181 return TTS_ERROR_INVALID_STATE;
2184 client->utt_started_cb = NULL;
2185 client->utt_started_user_data = NULL;
2187 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2192 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2194 if (0 != __tts_get_feature_enabled()) {
2195 return TTS_ERROR_NOT_SUPPORTED;
2198 if (NULL == tts || NULL == callback) {
2199 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2200 return TTS_ERROR_INVALID_PARAMETER;
2203 tts_client_s* client = tts_client_get(tts);
2205 if (NULL == client) {
2206 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2207 return TTS_ERROR_INVALID_PARAMETER;
2210 if (TTS_STATE_CREATED != client->current_state) {
2211 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2212 return TTS_ERROR_INVALID_STATE;
2215 client->utt_completeted_cb = callback;
2216 client->utt_completed_user_data = user_data;
2218 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2223 int tts_unset_utterance_completed_cb(tts_h tts)
2225 if (0 != __tts_get_feature_enabled()) {
2226 return TTS_ERROR_NOT_SUPPORTED;
2230 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2231 return TTS_ERROR_INVALID_PARAMETER;
2234 tts_client_s* client = tts_client_get(tts);
2236 if (NULL == client) {
2237 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2238 return TTS_ERROR_INVALID_PARAMETER;
2241 if (TTS_STATE_CREATED != client->current_state) {
2242 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2243 return TTS_ERROR_INVALID_STATE;
2246 client->utt_completeted_cb = NULL;
2247 client->utt_completed_user_data = NULL;
2249 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2253 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2255 if (0 != __tts_get_feature_enabled()) {
2256 return TTS_ERROR_NOT_SUPPORTED;
2259 if (NULL == tts || NULL == callback) {
2260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2261 return TTS_ERROR_INVALID_PARAMETER;
2264 tts_client_s* client = tts_client_get(tts);
2266 if (NULL == client) {
2267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2268 return TTS_ERROR_INVALID_PARAMETER;
2271 if (TTS_STATE_CREATED != client->current_state) {
2272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2273 return TTS_ERROR_INVALID_STATE;
2276 client->error_cb = callback;
2277 client->error_user_data = user_data;
2279 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2284 int tts_unset_error_cb(tts_h tts)
2286 if (0 != __tts_get_feature_enabled()) {
2287 return TTS_ERROR_NOT_SUPPORTED;
2291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2292 return TTS_ERROR_INVALID_PARAMETER;
2295 tts_client_s* client = tts_client_get(tts);
2297 if (NULL == client) {
2298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2299 return TTS_ERROR_INVALID_PARAMETER;
2302 if (TTS_STATE_CREATED != client->current_state) {
2303 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2304 return TTS_ERROR_INVALID_STATE;
2307 client->error_cb = NULL;
2308 client->error_user_data = NULL;
2310 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2315 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2317 if (0 != __tts_get_feature_enabled()) {
2318 return TTS_ERROR_NOT_SUPPORTED;
2321 if (NULL == tts || NULL == callback) {
2322 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2323 return TTS_ERROR_INVALID_PARAMETER;
2326 tts_client_s* client = tts_client_get(tts);
2328 if (NULL == client) {
2329 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2330 return TTS_ERROR_INVALID_PARAMETER;
2333 if (TTS_STATE_CREATED != client->current_state) {
2334 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2335 return TTS_ERROR_INVALID_STATE;
2338 client->default_voice_changed_cb = callback;
2339 client->default_voice_changed_user_data = user_data;
2341 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2346 int tts_unset_default_voice_changed_cb(tts_h tts)
2348 if (0 != __tts_get_feature_enabled()) {
2349 return TTS_ERROR_NOT_SUPPORTED;
2353 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2354 return TTS_ERROR_INVALID_PARAMETER;
2357 tts_client_s* client = tts_client_get(tts);
2359 if (NULL == client) {
2360 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2361 return TTS_ERROR_INVALID_PARAMETER;
2364 if (TTS_STATE_CREATED != client->current_state) {
2365 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2366 return TTS_ERROR_INVALID_STATE;
2369 client->default_voice_changed_cb = NULL;
2370 client->default_voice_changed_user_data = NULL;
2372 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2377 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2379 if (0 != __tts_get_feature_enabled()) {
2380 return TTS_ERROR_NOT_SUPPORTED;
2383 if (NULL == tts || NULL == callback) {
2384 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2385 return TTS_ERROR_INVALID_PARAMETER;
2388 tts_client_s* client = tts_client_get(tts);
2390 if (NULL == client) {
2391 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2392 return TTS_ERROR_INVALID_PARAMETER;
2395 if (TTS_STATE_CREATED != client->current_state) {
2396 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2397 return TTS_ERROR_INVALID_STATE;
2400 client->engine_changed_cb = callback;
2401 client->engine_changed_user_data = user_data;
2403 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2408 int tts_unset_engine_changed_cb(tts_h tts)
2410 if (0 != __tts_get_feature_enabled()) {
2411 return TTS_ERROR_NOT_SUPPORTED;
2415 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2416 return TTS_ERROR_INVALID_PARAMETER;
2419 tts_client_s* client = tts_client_get(tts);
2421 if (NULL == client) {
2422 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2423 return TTS_ERROR_INVALID_PARAMETER;
2426 if (TTS_STATE_CREATED != client->current_state) {
2427 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2428 return TTS_ERROR_INVALID_STATE;
2431 client->engine_changed_cb = NULL;
2432 client->engine_changed_user_data = NULL;
2434 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2439 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2441 if (0 != __tts_get_feature_enabled()) {
2442 return TTS_ERROR_NOT_SUPPORTED;
2445 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2448 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2449 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2450 return TTS_ERROR_INVALID_PARAMETER;
2453 tts_client_s* client = tts_client_get(tts);
2455 if (NULL == client) {
2456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2457 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2458 return TTS_ERROR_INVALID_PARAMETER;
2461 if (TTS_STATE_CREATED == client->current_state) {
2462 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2463 return TTS_ERROR_INVALID_STATE;
2466 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2467 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2468 return TTS_ERROR_INVALID_STATE;
2473 bool is_prepared = false;
2475 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2477 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2478 if (0 == tts_prepare_sync(tts)) {
2480 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2482 } else if (TTS_ERROR_TIMED_OUT != ret) {
2483 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2486 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2489 if (TTS_RETRY_COUNT == count) {
2490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2497 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2499 return TTS_ERROR_NONE;
2502 int tts_play_pcm(tts_h tts)
2504 if (0 != __tts_get_feature_enabled()) {
2505 return TTS_ERROR_NOT_SUPPORTED;
2508 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2511 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2512 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2513 return TTS_ERROR_INVALID_PARAMETER;
2516 tts_client_s* client = tts_client_get(tts);
2518 if (NULL == client) {
2519 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2520 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2521 return TTS_ERROR_INVALID_PARAMETER;
2524 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2525 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2526 return TTS_ERROR_INVALID_STATE;
2529 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2530 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2531 return TTS_ERROR_INVALID_STATE;
2536 bool is_prepared = false;
2538 ret = tts_dbus_request_play_pcm(client->uid);
2540 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2541 if (0 == tts_prepare_sync(tts)) {
2543 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2545 } else if (TTS_ERROR_TIMED_OUT != ret) {
2546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2549 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2552 if (TTS_RETRY_COUNT == count) {
2553 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2560 client->before_state = client->current_state;
2561 client->current_state = TTS_STATE_PLAYING;
2563 if (NULL != client->state_changed_cb) {
2564 tts_client_use_callback(client);
2565 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2566 tts_client_not_use_callback(client);
2567 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2570 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2572 return TTS_ERROR_NONE;
2575 int tts_stop_pcm(tts_h tts)
2577 if (0 != __tts_get_feature_enabled()) {
2578 return TTS_ERROR_NOT_SUPPORTED;
2581 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2584 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2585 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2586 return TTS_ERROR_INVALID_PARAMETER;
2589 tts_client_s* client = tts_client_get(tts);
2591 if (NULL == client) {
2592 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2593 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2594 return TTS_ERROR_INVALID_PARAMETER;
2597 if (TTS_STATE_CREATED == client->current_state) {
2598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2599 return TTS_ERROR_INVALID_STATE;
2602 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2603 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2604 return TTS_ERROR_INVALID_STATE;
2609 bool is_prepared = false;
2611 ret = tts_dbus_request_stop_pcm(client->uid);
2613 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2614 if (0 == tts_prepare_sync(tts)) {
2616 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2618 } else if (TTS_ERROR_TIMED_OUT != ret) {
2619 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2622 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2625 if (TTS_RETRY_COUNT == count) {
2626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2633 client->before_state = client->current_state;
2634 client->current_state = TTS_STATE_READY;
2636 if (NULL != client->state_changed_cb) {
2637 tts_client_use_callback(client);
2638 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2639 tts_client_not_use_callback(client);
2640 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2643 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2645 return TTS_ERROR_NONE;