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_unprepare(tts_h tts)
692 if (0 != __tts_get_feature_enabled()) {
693 return TTS_ERROR_NOT_SUPPORTED;
696 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare 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 return TTS_ERROR_INVALID_PARAMETER;
707 if (client->current_state != TTS_STATE_READY) {
708 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
709 return TTS_ERROR_INVALID_STATE;
714 int screen_reader = -1;
716 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
718 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
720 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);
721 g_screen_reader = (bool)screen_reader;
724 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
726 ret = tts_dbus_request_finalize(client->uid);
728 if (TTS_ERROR_TIMED_OUT != ret) {
729 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
732 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
735 if (TTS_RETRY_COUNT == count) {
736 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
743 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
746 client->before_state = client->current_state;
747 client->current_state = TTS_STATE_CREATED;
749 if (NULL != client->state_changed_cb) {
750 tts_client_use_callback(client);
751 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
752 tts_client_not_use_callback(client);
753 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
756 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
758 return TTS_ERROR_NONE;
761 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
763 tts_h tts = (tts_h)user_data;
765 tts_client_s* client = tts_client_get(tts);
766 if (NULL == client) {
767 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
771 /* call callback function */
772 if (NULL != client->supported_voice_cb) {
773 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
775 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
781 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
783 if (0 != __tts_get_feature_enabled()) {
784 return TTS_ERROR_NOT_SUPPORTED;
787 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
789 if (NULL == tts || NULL == callback) {
790 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
791 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
792 return TTS_ERROR_INVALID_PARAMETER;
795 tts_client_s* client = tts_client_get(tts);
798 if (NULL == client) {
799 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
800 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
801 return TTS_ERROR_INVALID_PARAMETER;
805 char* current_engine = NULL;
806 ret = tts_config_mgr_get_engine(¤t_engine);
808 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
809 return __tts_convert_config_error_code(ret);
812 client->supported_voice_cb = callback;
813 client->supported_voice_user_data = user_data;
815 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
817 if (NULL != current_engine) {
818 free(current_engine);
819 current_engine = NULL;
822 client->supported_voice_cb = NULL;
823 client->supported_voice_user_data = NULL;
826 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
827 ret = TTS_ERROR_OPERATION_FAILED;
830 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
835 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
837 if (0 != __tts_get_feature_enabled()) {
838 return TTS_ERROR_NOT_SUPPORTED;
841 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
844 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
845 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
846 return TTS_ERROR_INVALID_PARAMETER;
849 tts_client_s* client = tts_client_get(tts);
851 if (NULL == client) {
852 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
853 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
854 return TTS_ERROR_INVALID_PARAMETER;
857 /* Request call remote method */
859 ret = tts_config_mgr_get_voice(lang, vctype);
861 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
862 return __tts_convert_config_error_code(ret);
864 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
867 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
872 int tts_get_max_text_size(tts_h tts, unsigned int* size)
874 if (0 != __tts_get_feature_enabled()) {
875 return TTS_ERROR_NOT_SUPPORTED;
878 if (NULL == tts || NULL == size) {
879 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
880 return TTS_ERROR_INVALID_PARAMETER;
883 tts_client_s* client = tts_client_get(tts);
885 if (NULL == client) {
886 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
887 return TTS_ERROR_INVALID_PARAMETER;
890 if (TTS_STATE_READY != client->current_state) {
891 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
892 return TTS_ERROR_INVALID_STATE;
895 if (0 != tts_config_mgr_get_max_text_size(size)) {
896 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
897 return TTS_ERROR_INVALID_PARAMETER;
900 g_max_text_size = (int)*size;
902 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
903 return TTS_ERROR_NONE;
906 int tts_get_state(tts_h tts, tts_state_e* state)
908 if (0 != __tts_get_feature_enabled()) {
909 return TTS_ERROR_NOT_SUPPORTED;
912 if (NULL == tts || NULL == state) {
913 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
914 return TTS_ERROR_INVALID_PARAMETER;
917 tts_client_s* client = tts_client_get(tts);
919 if (NULL == client) {
920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
921 return TTS_ERROR_INVALID_PARAMETER;
924 *state = client->current_state;
927 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
928 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
929 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
930 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
931 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
934 return TTS_ERROR_NONE;
937 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
939 if (0 != __tts_get_feature_enabled()) {
940 return TTS_ERROR_NOT_SUPPORTED;
943 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
944 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
945 return TTS_ERROR_INVALID_PARAMETER;
948 tts_client_s* client = tts_client_get(tts);
950 if (NULL == client) {
951 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
952 return TTS_ERROR_INVALID_PARAMETER;
955 *min = TTS_SPEED_MIN;
956 *normal = TTS_SPEED_NORMAL;
957 *max = TTS_SPEED_MAX;
959 return TTS_ERROR_NONE;
962 int tts_get_error_message(tts_h tts, char** err_msg)
964 if (0 != __tts_get_feature_enabled()) {
965 return TTS_ERROR_NOT_SUPPORTED;
968 if (NULL == tts || NULL == err_msg) {
969 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
970 return TTS_ERROR_INVALID_PARAMETER;
973 tts_client_s* client = tts_client_get(tts);
975 if (NULL == client) {
976 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
977 return TTS_ERROR_INVALID_PARAMETER;
980 if (NULL != client->err_msg) {
981 *err_msg = strdup(client->err_msg);
982 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
985 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
988 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
990 return TTS_ERROR_NONE;
993 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
995 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
997 if (0 != __tts_get_feature_enabled()) {
998 return TTS_ERROR_NOT_SUPPORTED;
1002 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1003 return TTS_ERROR_INVALID_PARAMETER;
1006 if (voice_type < 0) {
1007 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1008 return TTS_ERROR_INVALID_PARAMETER;
1011 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1013 if (NULL == tts || NULL == utt_id) {
1014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1015 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1016 return TTS_ERROR_INVALID_PARAMETER;
1019 tts_client_s* client = tts_client_get(tts);
1021 if (NULL == client) {
1022 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1023 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1024 return TTS_ERROR_INVALID_PARAMETER;
1027 if (TTS_STATE_CREATED == client->current_state) {
1028 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1029 return TTS_ERROR_INVALID_STATE;
1032 if (-1 == g_max_text_size) {
1033 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1034 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1035 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1036 return TTS_ERROR_INVALID_PARAMETER;
1040 if (0 == g_max_text_size) {
1041 if (strlen(text) <= 0) {
1042 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1043 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1044 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1045 return TTS_ERROR_INVALID_PARAMETER;
1048 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1049 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1051 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1052 return TTS_ERROR_INVALID_PARAMETER;
1056 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1057 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1058 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1059 return TTS_ERROR_INVALID_PARAMETER;
1062 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1063 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1064 return TTS_ERROR_INVALID_STATE;
1067 if (true == client->credential_needed && NULL == client->credential) {
1068 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1069 return TTS_ERROR_PERMISSION_DENIED;
1072 /* check valid utf8 */
1076 dbus_error_init(&err);
1078 valid = dbus_validate_utf8(text, &err);
1079 if (dbus_error_is_set(&err)) {
1080 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1081 dbus_error_free(&err);
1082 return TTS_ERROR_INVALID_PARAMETER;
1085 if (valid != true) {
1086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1087 return TTS_ERROR_INVALID_PARAMETER;
1089 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1091 /* change default language value */
1094 if (NULL == language)
1095 temp = strdup("default");
1097 temp = strdup(language);
1099 client->current_utt_id++;
1100 if (client->current_utt_id == 10000) {
1101 client->current_utt_id = 1;
1108 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1110 if (TTS_ERROR_TIMED_OUT != ret) {
1111 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1114 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1117 if (TTS_RETRY_MIN_COUNT == count) {
1118 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1123 *utt_id = client->current_utt_id;
1132 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1137 static void __tts_play_async(void *data)
1139 tts_h tts = (tts_h)data;
1140 tts_client_s* client = tts_client_get(tts);
1143 if (NULL == client) {
1144 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1151 ret = tts_dbus_request_play(client->uid, client->credential);
1153 if (TTS_ERROR_TIMED_OUT != ret) {
1154 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1157 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1160 if (TTS_RETRY_COUNT == count) {
1161 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1171 client->reason = ret;
1172 client->utt_id = -1;
1174 ecore_timer_add(0, __tts_notify_error, client->tts);
1178 client->before_state = client->current_state;
1179 client->current_state = TTS_STATE_PLAYING;
1181 if (NULL != client->state_changed_cb) {
1182 tts_client_use_callback(client);
1183 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1184 tts_client_not_use_callback(client);
1185 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1188 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1193 int tts_play_async(tts_h tts)
1195 if (0 != __tts_get_feature_enabled()) {
1196 return TTS_ERROR_NOT_SUPPORTED;
1199 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1202 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1203 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1204 return TTS_ERROR_INVALID_PARAMETER;
1207 tts_client_s* client = tts_client_get(tts);
1209 if (NULL == client) {
1210 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1211 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1212 return TTS_ERROR_INVALID_PARAMETER;
1215 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1216 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1217 return TTS_ERROR_INVALID_STATE;
1220 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1221 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1222 return TTS_ERROR_INVALID_STATE;
1225 if (true == client->credential_needed && NULL == client->credential) {
1226 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1227 return TTS_ERROR_PERMISSION_DENIED;
1230 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1232 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1234 return TTS_ERROR_NONE;
1237 int tts_play(tts_h tts)
1239 if (0 != __tts_get_feature_enabled()) {
1240 return TTS_ERROR_NOT_SUPPORTED;
1243 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1246 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1247 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1248 return TTS_ERROR_INVALID_PARAMETER;
1251 tts_client_s* client = tts_client_get(tts);
1253 if (NULL == client) {
1254 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1255 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1256 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1257 return TTS_ERROR_INVALID_PARAMETER;
1260 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1261 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1262 return TTS_ERROR_INVALID_STATE;
1265 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1266 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1267 return TTS_ERROR_INVALID_STATE;
1270 if (true == client->credential_needed && NULL == client->credential) {
1271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1272 return TTS_ERROR_PERMISSION_DENIED;
1278 ret = tts_dbus_request_play(client->uid, client->credential);
1280 if (TTS_ERROR_TIMED_OUT != ret) {
1281 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1284 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1287 if (TTS_RETRY_COUNT == count) {
1288 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1295 client->before_state = client->current_state;
1296 client->current_state = TTS_STATE_PLAYING;
1298 if (NULL != client->state_changed_cb) {
1299 tts_client_use_callback(client);
1300 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1301 tts_client_not_use_callback(client);
1302 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1305 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1307 return TTS_ERROR_NONE;
1310 static void __tts_stop_async(void *data)
1312 tts_h tts = (tts_h)data;
1313 tts_client_s* client = tts_client_get(tts);
1316 if (NULL == client) {
1317 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1324 ret = tts_dbus_request_stop(client->uid);
1326 if (TTS_ERROR_TIMED_OUT != ret) {
1327 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1330 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1333 if (TTS_RETRY_COUNT == count) {
1334 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1342 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1344 client->reason = ret;
1345 client->utt_id = -1;
1347 ecore_timer_add(0, __tts_notify_error, client->tts);
1351 client->before_state = client->current_state;
1352 client->current_state = TTS_STATE_READY;
1354 if (NULL != client->state_changed_cb) {
1355 tts_client_use_callback(client);
1356 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1357 tts_client_not_use_callback(client);
1358 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1361 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1366 int tts_stop_aync(tts_h tts)
1368 if (0 != __tts_get_feature_enabled()) {
1369 return TTS_ERROR_NOT_SUPPORTED;
1372 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1375 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle 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 (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1394 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1395 return TTS_ERROR_INVALID_STATE;
1398 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1400 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1402 return TTS_ERROR_NONE;
1405 int tts_stop(tts_h tts)
1407 if (0 != __tts_get_feature_enabled()) {
1408 return TTS_ERROR_NOT_SUPPORTED;
1411 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1415 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1416 return TTS_ERROR_INVALID_PARAMETER;
1419 tts_client_s* client = tts_client_get(tts);
1421 if (NULL == client) {
1422 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1423 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1424 return TTS_ERROR_INVALID_PARAMETER;
1427 if (TTS_STATE_CREATED == client->current_state) {
1428 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1429 return TTS_ERROR_INVALID_STATE;
1432 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1433 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1434 return TTS_ERROR_INVALID_STATE;
1440 ret = tts_dbus_request_stop(client->uid);
1442 if (TTS_ERROR_TIMED_OUT != ret) {
1443 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1446 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1449 if (TTS_RETRY_COUNT == count) {
1450 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1457 client->before_state = client->current_state;
1458 client->current_state = TTS_STATE_READY;
1460 if (NULL != client->state_changed_cb) {
1461 tts_client_use_callback(client);
1462 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1463 tts_client_not_use_callback(client);
1464 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1467 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1469 return TTS_ERROR_NONE;
1472 static void __tts_pause_async(void *data)
1474 tts_h tts = (tts_h)data;
1475 tts_client_s* client = tts_client_get(tts);
1478 if (NULL == client) {
1479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1486 ret = tts_dbus_request_pause(client->uid);
1488 if (TTS_ERROR_TIMED_OUT != ret) {
1489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1492 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1495 if (TTS_RETRY_COUNT == count) {
1496 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1504 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1506 client->reason = ret;
1507 client->utt_id = -1;
1509 ecore_timer_add(0, __tts_notify_error, client->tts);
1513 client->before_state = client->current_state;
1514 client->current_state = TTS_STATE_PAUSED;
1516 if (NULL != client->state_changed_cb) {
1517 tts_client_use_callback(client);
1518 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1519 tts_client_not_use_callback(client);
1520 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1523 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1528 int tts_pause_async(tts_h tts)
1530 if (0 != __tts_get_feature_enabled()) {
1531 return TTS_ERROR_NOT_SUPPORTED;
1534 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1537 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1538 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1539 return TTS_ERROR_INVALID_PARAMETER;
1542 tts_client_s* client = tts_client_get(tts);
1544 if (NULL == client) {
1545 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1546 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1547 return TTS_ERROR_INVALID_PARAMETER;
1550 if (TTS_STATE_PLAYING != client->current_state) {
1551 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1552 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1553 return TTS_ERROR_INVALID_STATE;
1556 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1557 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1558 return TTS_ERROR_INVALID_STATE;
1561 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1563 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1565 return TTS_ERROR_NONE;
1568 int tts_pause(tts_h tts)
1570 if (0 != __tts_get_feature_enabled()) {
1571 return TTS_ERROR_NOT_SUPPORTED;
1574 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1577 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1578 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1579 return TTS_ERROR_INVALID_PARAMETER;
1582 tts_client_s* client = tts_client_get(tts);
1584 if (NULL == client) {
1585 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1586 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1587 return TTS_ERROR_INVALID_PARAMETER;
1590 if (TTS_STATE_PLAYING != client->current_state) {
1591 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1592 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1593 return TTS_ERROR_INVALID_STATE;
1596 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1597 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1598 return TTS_ERROR_INVALID_STATE;
1604 ret = tts_dbus_request_pause(client->uid);
1606 if (TTS_ERROR_TIMED_OUT != ret) {
1607 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1610 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1613 if (TTS_RETRY_COUNT == count) {
1614 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1621 client->before_state = client->current_state;
1622 client->current_state = TTS_STATE_PAUSED;
1624 if (NULL != client->state_changed_cb) {
1625 tts_client_use_callback(client);
1626 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1627 tts_client_not_use_callback(client);
1628 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1631 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1633 return TTS_ERROR_NONE;
1636 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1638 if (0 != __tts_get_feature_enabled()) {
1639 return TTS_ERROR_NOT_SUPPORTED;
1642 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1645 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1646 return TTS_ERROR_INVALID_PARAMETER;
1649 if (NULL == key || NULL == data) {
1650 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1651 return TTS_ERROR_INVALID_PARAMETER;
1654 tts_client_s* client = tts_client_get(tts);
1656 if (NULL == client) {
1657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1658 return TTS_ERROR_INVALID_PARAMETER;
1661 if (TTS_STATE_READY != client->current_state) {
1662 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1663 return TTS_ERROR_INVALID_STATE;
1666 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1667 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1668 return TTS_ERROR_INVALID_PARAMETER;
1674 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1676 if (TTS_ERROR_TIMED_OUT != ret) {
1677 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1680 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1683 if (TTS_RETRY_COUNT == count) {
1684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1691 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1696 int tts_get_private_data(tts_h tts, const char* key, char** data)
1698 if (0 != __tts_get_feature_enabled()) {
1699 return TTS_ERROR_NOT_SUPPORTED;
1702 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1705 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1706 return TTS_ERROR_INVALID_PARAMETER;
1709 if (NULL == key || NULL == data) {
1710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1711 return TTS_ERROR_INVALID_PARAMETER;
1714 tts_client_s* client = tts_client_get(tts);
1716 if (NULL == client) {
1717 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1718 return TTS_ERROR_INVALID_PARAMETER;
1721 if (TTS_STATE_READY != client->current_state) {
1722 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1723 return TTS_ERROR_INVALID_STATE;
1729 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1731 if (TTS_ERROR_TIMED_OUT != ret) {
1732 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1735 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1738 if (TTS_RETRY_COUNT == count) {
1739 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1746 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1751 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1756 static Eina_Bool __tts_notify_error(void *data)
1758 tts_h tts = (tts_h)data;
1760 tts_client_s* client = tts_client_get(tts);
1763 if (NULL == client) {
1764 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1768 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1770 if (NULL != client->error_cb) {
1771 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1772 tts_client_use_callback(client);
1773 g_err_callback_status = true;
1774 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1775 g_err_callback_status = false;
1776 tts_client_not_use_callback(client);
1778 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1784 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1787 GList* client_list = NULL;
1788 client_list = tts_client_get_client_list();
1791 tts_client_s *data = NULL;
1793 if (g_list_length(client_list) > 0) {
1794 /* Get a first item */
1795 iter = g_list_first(client_list);
1797 while (NULL != iter) {
1800 data->utt_id = utt_id;
1801 data->reason = reason;
1802 if (NULL != data->err_msg) {
1803 free(data->err_msg);
1804 data->err_msg = NULL;
1806 if (NULL != err_msg)
1807 data->err_msg = strdup(err_msg);
1809 /* call callback function */
1810 if (NULL != data->error_cb) {
1811 ecore_timer_add(0, __tts_notify_error, data->tts);
1813 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1816 if (TTS_ERROR_SERVICE_RESET == reason) {
1817 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1819 data->current_state = TTS_STATE_CREATED;
1820 if (0 != tts_prepare(data->tts)) {
1821 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1826 iter = g_list_next(iter);
1830 tts_client_s* client = tts_client_get_by_uid(uid);
1832 if (NULL == client) {
1833 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1834 return TTS_ERROR_INVALID_PARAMETER;
1837 client->utt_id = utt_id;
1838 client->reason = reason;
1839 if (NULL != client->err_msg) {
1840 free(client->err_msg);
1841 client->err_msg = NULL;
1843 if (NULL != err_msg)
1844 client->err_msg = strdup(err_msg);
1846 /* call callback function */
1847 if (NULL != client->error_cb) {
1848 ecore_timer_add(0, __tts_notify_error, client->tts);
1850 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1853 if (TTS_ERROR_SERVICE_RESET == reason) {
1854 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1856 client->current_state = TTS_STATE_CREATED;
1857 if (0 != tts_prepare(client->tts)) {
1858 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1866 static Eina_Bool __tts_notify_state_changed(void *data)
1868 tts_h tts = (tts_h)data;
1870 tts_client_s* client = tts_client_get(tts);
1873 if (NULL == client) {
1874 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1878 if (NULL != client->state_changed_cb) {
1879 tts_client_use_callback(client);
1880 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1881 tts_client_not_use_callback(client);
1882 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1884 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1890 int __tts_cb_set_state(int uid, int state)
1892 tts_client_s* client = tts_client_get_by_uid(uid);
1893 if (NULL == client) {
1894 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1898 tts_state_e state_from_daemon = (tts_state_e)state;
1900 if (client->current_state == state_from_daemon) {
1901 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1905 if (NULL != client->state_changed_cb) {
1906 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1908 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1911 client->before_state = client->current_state;
1912 client->current_state = state_from_daemon;
1917 int __tts_cb_utt_started(int uid, int utt_id)
1919 tts_client_s* client = tts_client_get_by_uid(uid);
1921 if (NULL == client) {
1922 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1923 return TTS_ERROR_INVALID_PARAMETER;
1926 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1928 client->utt_id = utt_id;
1930 /* call callback function */
1931 if (NULL != client->utt_started_cb) {
1932 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1933 tts_client_use_callback(client);
1934 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1935 tts_client_not_use_callback(client);
1937 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1943 int __tts_cb_utt_completed(int uid, int utt_id)
1945 tts_client_s* client = tts_client_get_by_uid(uid);
1947 if (NULL == client) {
1948 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1949 return TTS_ERROR_INVALID_PARAMETER;
1952 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1954 client->utt_id = utt_id;
1956 /* call callback function */
1957 if (NULL != client->utt_completeted_cb) {
1958 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1959 tts_client_use_callback(client);
1960 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1961 tts_client_not_use_callback(client);
1963 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1969 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1971 if (0 != __tts_get_feature_enabled()) {
1972 return TTS_ERROR_NOT_SUPPORTED;
1975 if (NULL == tts || NULL == callback) {
1976 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1977 return TTS_ERROR_INVALID_PARAMETER;
1980 tts_client_s* client = tts_client_get(tts);
1982 if (NULL == client) {
1983 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1984 return TTS_ERROR_INVALID_PARAMETER;
1987 if (TTS_STATE_CREATED != client->current_state) {
1988 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1989 return TTS_ERROR_INVALID_STATE;
1992 client->state_changed_cb = callback;
1993 client->state_changed_user_data = user_data;
1995 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2000 int tts_unset_state_changed_cb(tts_h tts)
2002 if (0 != __tts_get_feature_enabled()) {
2003 return TTS_ERROR_NOT_SUPPORTED;
2007 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2008 return TTS_ERROR_INVALID_PARAMETER;
2011 tts_client_s* client = tts_client_get(tts);
2013 if (NULL == client) {
2014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2015 return TTS_ERROR_INVALID_PARAMETER;
2018 if (TTS_STATE_CREATED != client->current_state) {
2019 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2020 return TTS_ERROR_INVALID_STATE;
2023 client->state_changed_cb = NULL;
2024 client->state_changed_user_data = NULL;
2026 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2031 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2033 if (0 != __tts_get_feature_enabled()) {
2034 return TTS_ERROR_NOT_SUPPORTED;
2037 if (NULL == tts || NULL == callback) {
2038 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2039 return TTS_ERROR_INVALID_PARAMETER;
2042 tts_client_s* client = tts_client_get(tts);
2044 if (NULL == client) {
2045 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2046 return TTS_ERROR_INVALID_PARAMETER;
2049 if (TTS_STATE_CREATED != client->current_state) {
2050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2051 return TTS_ERROR_INVALID_STATE;
2054 client->utt_started_cb = callback;
2055 client->utt_started_user_data = user_data;
2057 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2062 int tts_unset_utterance_started_cb(tts_h tts)
2064 if (0 != __tts_get_feature_enabled()) {
2065 return TTS_ERROR_NOT_SUPPORTED;
2069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2070 return TTS_ERROR_INVALID_PARAMETER;
2073 tts_client_s* client = tts_client_get(tts);
2075 if (NULL == client) {
2076 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2077 return TTS_ERROR_INVALID_PARAMETER;
2080 if (TTS_STATE_CREATED != client->current_state) {
2081 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2082 return TTS_ERROR_INVALID_STATE;
2085 client->utt_started_cb = NULL;
2086 client->utt_started_user_data = NULL;
2088 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2093 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2095 if (0 != __tts_get_feature_enabled()) {
2096 return TTS_ERROR_NOT_SUPPORTED;
2099 if (NULL == tts || NULL == callback) {
2100 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2101 return TTS_ERROR_INVALID_PARAMETER;
2104 tts_client_s* client = tts_client_get(tts);
2106 if (NULL == client) {
2107 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2108 return TTS_ERROR_INVALID_PARAMETER;
2111 if (TTS_STATE_CREATED != client->current_state) {
2112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2113 return TTS_ERROR_INVALID_STATE;
2116 client->utt_completeted_cb = callback;
2117 client->utt_completed_user_data = user_data;
2119 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2124 int tts_unset_utterance_completed_cb(tts_h tts)
2126 if (0 != __tts_get_feature_enabled()) {
2127 return TTS_ERROR_NOT_SUPPORTED;
2131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2132 return TTS_ERROR_INVALID_PARAMETER;
2135 tts_client_s* client = tts_client_get(tts);
2137 if (NULL == client) {
2138 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2139 return TTS_ERROR_INVALID_PARAMETER;
2142 if (TTS_STATE_CREATED != client->current_state) {
2143 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2144 return TTS_ERROR_INVALID_STATE;
2147 client->utt_completeted_cb = NULL;
2148 client->utt_completed_user_data = NULL;
2150 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2154 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2156 if (0 != __tts_get_feature_enabled()) {
2157 return TTS_ERROR_NOT_SUPPORTED;
2160 if (NULL == tts || NULL == callback) {
2161 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2162 return TTS_ERROR_INVALID_PARAMETER;
2165 tts_client_s* client = tts_client_get(tts);
2167 if (NULL == client) {
2168 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2169 return TTS_ERROR_INVALID_PARAMETER;
2172 if (TTS_STATE_CREATED != client->current_state) {
2173 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2174 return TTS_ERROR_INVALID_STATE;
2177 client->error_cb = callback;
2178 client->error_user_data = user_data;
2180 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2185 int tts_unset_error_cb(tts_h tts)
2187 if (0 != __tts_get_feature_enabled()) {
2188 return TTS_ERROR_NOT_SUPPORTED;
2192 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2193 return TTS_ERROR_INVALID_PARAMETER;
2196 tts_client_s* client = tts_client_get(tts);
2198 if (NULL == client) {
2199 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2200 return TTS_ERROR_INVALID_PARAMETER;
2203 if (TTS_STATE_CREATED != client->current_state) {
2204 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2205 return TTS_ERROR_INVALID_STATE;
2208 client->error_cb = NULL;
2209 client->error_user_data = NULL;
2211 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2216 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2218 if (0 != __tts_get_feature_enabled()) {
2219 return TTS_ERROR_NOT_SUPPORTED;
2222 if (NULL == tts || NULL == callback) {
2223 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2224 return TTS_ERROR_INVALID_PARAMETER;
2227 tts_client_s* client = tts_client_get(tts);
2229 if (NULL == client) {
2230 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2231 return TTS_ERROR_INVALID_PARAMETER;
2234 if (TTS_STATE_CREATED != client->current_state) {
2235 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2236 return TTS_ERROR_INVALID_STATE;
2239 client->default_voice_changed_cb = callback;
2240 client->default_voice_changed_user_data = user_data;
2242 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2247 int tts_unset_default_voice_changed_cb(tts_h tts)
2249 if (0 != __tts_get_feature_enabled()) {
2250 return TTS_ERROR_NOT_SUPPORTED;
2254 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2255 return TTS_ERROR_INVALID_PARAMETER;
2258 tts_client_s* client = tts_client_get(tts);
2260 if (NULL == client) {
2261 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2262 return TTS_ERROR_INVALID_PARAMETER;
2265 if (TTS_STATE_CREATED != client->current_state) {
2266 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2267 return TTS_ERROR_INVALID_STATE;
2270 client->default_voice_changed_cb = NULL;
2271 client->default_voice_changed_user_data = NULL;
2273 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2278 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2280 if (0 != __tts_get_feature_enabled()) {
2281 return TTS_ERROR_NOT_SUPPORTED;
2284 if (NULL == tts || NULL == callback) {
2285 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2286 return TTS_ERROR_INVALID_PARAMETER;
2289 tts_client_s* client = tts_client_get(tts);
2291 if (NULL == client) {
2292 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2293 return TTS_ERROR_INVALID_PARAMETER;
2296 if (TTS_STATE_CREATED != client->current_state) {
2297 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2298 return TTS_ERROR_INVALID_STATE;
2301 client->engine_changed_cb = callback;
2302 client->engine_changed_user_data = user_data;
2304 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2309 int tts_unset_engine_changed_cb(tts_h tts)
2311 if (0 != __tts_get_feature_enabled()) {
2312 return TTS_ERROR_NOT_SUPPORTED;
2316 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2317 return TTS_ERROR_INVALID_PARAMETER;
2320 tts_client_s* client = tts_client_get(tts);
2322 if (NULL == client) {
2323 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2324 return TTS_ERROR_INVALID_PARAMETER;
2327 if (TTS_STATE_CREATED != client->current_state) {
2328 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2329 return TTS_ERROR_INVALID_STATE;
2332 client->engine_changed_cb = NULL;
2333 client->engine_changed_user_data = NULL;
2335 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2340 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2342 if (0 != __tts_get_feature_enabled()) {
2343 return TTS_ERROR_NOT_SUPPORTED;
2346 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2349 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2350 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2351 return TTS_ERROR_INVALID_PARAMETER;
2354 tts_client_s* client = tts_client_get(tts);
2356 if (NULL == client) {
2357 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2358 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2359 return TTS_ERROR_INVALID_PARAMETER;
2362 if (TTS_STATE_CREATED == client->current_state) {
2363 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2364 return TTS_ERROR_INVALID_STATE;
2367 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2368 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2369 return TTS_ERROR_INVALID_STATE;
2375 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2377 if (TTS_ERROR_TIMED_OUT != ret) {
2378 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2381 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2384 if (TTS_RETRY_COUNT == count) {
2385 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2392 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2394 return TTS_ERROR_NONE;
2397 int tts_play_pcm(tts_h tts)
2399 if (0 != __tts_get_feature_enabled()) {
2400 return TTS_ERROR_NOT_SUPPORTED;
2403 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2406 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2407 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2408 return TTS_ERROR_INVALID_PARAMETER;
2411 tts_client_s* client = tts_client_get(tts);
2413 if (NULL == client) {
2414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2415 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2416 return TTS_ERROR_INVALID_PARAMETER;
2419 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2420 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2421 return TTS_ERROR_INVALID_STATE;
2424 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2425 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2426 return TTS_ERROR_INVALID_STATE;
2432 ret = tts_dbus_request_play_pcm(client->uid);
2434 if (TTS_ERROR_TIMED_OUT != ret) {
2435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2438 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2441 if (TTS_RETRY_COUNT == count) {
2442 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2449 client->before_state = client->current_state;
2450 client->current_state = TTS_STATE_PLAYING;
2452 if (NULL != client->state_changed_cb) {
2453 tts_client_use_callback(client);
2454 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2455 tts_client_not_use_callback(client);
2456 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2459 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2461 return TTS_ERROR_NONE;
2464 int tts_stop_pcm(tts_h tts)
2466 if (0 != __tts_get_feature_enabled()) {
2467 return TTS_ERROR_NOT_SUPPORTED;
2470 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2473 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2474 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2475 return TTS_ERROR_INVALID_PARAMETER;
2478 tts_client_s* client = tts_client_get(tts);
2480 if (NULL == client) {
2481 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2482 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2483 return TTS_ERROR_INVALID_PARAMETER;
2486 if (TTS_STATE_CREATED == client->current_state) {
2487 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2488 return TTS_ERROR_INVALID_STATE;
2491 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2492 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2493 return TTS_ERROR_INVALID_STATE;
2499 ret = tts_dbus_request_stop_pcm(client->uid);
2501 if (TTS_ERROR_TIMED_OUT != ret) {
2502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2505 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2508 if (TTS_RETRY_COUNT == count) {
2509 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2516 client->before_state = client->current_state;
2517 client->current_state = TTS_STATE_READY;
2519 if (NULL != client->state_changed_cb) {
2520 tts_client_use_callback(client);
2521 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2522 tts_client_not_use_callback(client);
2523 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2526 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2528 return TTS_ERROR_NONE;