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");
531 return TTS_ERROR_OUT_OF_MEMORY;
534 key = strdup("DisableServerTTS");
538 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
539 return TTS_ERROR_OUT_OF_MEMORY;
544 int ret = app_manager_get_app_id(pid, &appid);
546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
549 return TTS_ERROR_OPERATION_FAILED;
552 ret = tts_set_private_data(tts, key, appid);
554 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
565 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
567 return TTS_ERROR_NONE;
570 static Eina_Bool __tts_connect_daemon(void *data)
572 tts_h tts = (tts_h)data;
573 tts_client_s* client = tts_client_get(tts);
576 if (NULL == client) {
577 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
582 if (0 != tts_dbus_request_hello(client->uid)) {
586 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
588 /* do request initialize */
590 bool credential_needed = false;
592 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
594 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
595 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
597 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
600 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
601 client->conn_timer = NULL;
604 } else if (TTS_ERROR_NONE != ret) {
605 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
609 /* success to connect tts-daemon */
610 client->credential_needed = credential_needed;
611 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
614 client->conn_timer = NULL;
616 client = tts_client_get(tts);
618 if (NULL == client) {
619 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
623 client->before_state = client->current_state;
624 client->current_state = TTS_STATE_READY;
626 if (NULL != client->state_changed_cb) {
627 tts_client_use_callback(client);
628 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
629 tts_client_not_use_callback(client);
631 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
634 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
639 int tts_prepare(tts_h tts)
641 if (0 != __tts_get_feature_enabled()) {
642 return TTS_ERROR_NOT_SUPPORTED;
645 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
647 tts_client_s* client = tts_client_get(tts);
650 if (NULL == client) {
651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
652 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
653 return TTS_ERROR_INVALID_PARAMETER;
657 if (client->current_state != TTS_STATE_CREATED) {
658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
659 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
660 return TTS_ERROR_INVALID_STATE;
663 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
665 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
667 return TTS_ERROR_NONE;
670 int tts_unprepare(tts_h tts)
672 if (0 != __tts_get_feature_enabled()) {
673 return TTS_ERROR_NOT_SUPPORTED;
676 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
678 tts_client_s* client = tts_client_get(tts);
681 if (NULL == client) {
682 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
683 return TTS_ERROR_INVALID_PARAMETER;
687 if (client->current_state != TTS_STATE_READY) {
688 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
689 return TTS_ERROR_INVALID_STATE;
694 int screen_reader = -1;
696 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
698 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
700 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);
701 g_screen_reader = (bool)screen_reader;
704 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
706 ret = tts_dbus_request_finalize(client->uid);
708 if (TTS_ERROR_TIMED_OUT != ret) {
709 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
712 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
715 if (TTS_RETRY_COUNT == count) {
716 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
723 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
726 client->before_state = client->current_state;
727 client->current_state = TTS_STATE_CREATED;
729 if (NULL != client->state_changed_cb) {
730 tts_client_use_callback(client);
731 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
732 tts_client_not_use_callback(client);
733 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
736 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
738 return TTS_ERROR_NONE;
741 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
743 tts_h tts = (tts_h)user_data;
745 tts_client_s* client = tts_client_get(tts);
746 if (NULL == client) {
747 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
751 /* call callback function */
752 if (NULL != client->supported_voice_cb) {
753 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
755 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
761 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
763 if (0 != __tts_get_feature_enabled()) {
764 return TTS_ERROR_NOT_SUPPORTED;
767 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
769 if (NULL == tts || NULL == callback) {
770 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
771 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
772 return TTS_ERROR_INVALID_PARAMETER;
775 tts_client_s* client = tts_client_get(tts);
778 if (NULL == client) {
779 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
780 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
781 return TTS_ERROR_INVALID_PARAMETER;
785 char* current_engine = NULL;
786 ret = tts_config_mgr_get_engine(¤t_engine);
788 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
789 return __tts_convert_config_error_code(ret);
792 client->supported_voice_cb = callback;
793 client->supported_voice_user_data = user_data;
795 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
797 if (NULL != current_engine) {
798 free(current_engine);
799 current_engine = NULL;
802 client->supported_voice_cb = NULL;
803 client->supported_voice_user_data = NULL;
806 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
807 ret = TTS_ERROR_OPERATION_FAILED;
810 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
815 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
817 if (0 != __tts_get_feature_enabled()) {
818 return TTS_ERROR_NOT_SUPPORTED;
821 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
824 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
825 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
826 return TTS_ERROR_INVALID_PARAMETER;
829 tts_client_s* client = tts_client_get(tts);
831 if (NULL == client) {
832 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
833 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
834 return TTS_ERROR_INVALID_PARAMETER;
837 /* Request call remote method */
839 ret = tts_config_mgr_get_voice(lang, vctype);
841 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
842 return __tts_convert_config_error_code(ret);
844 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
847 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
852 int tts_get_max_text_size(tts_h tts, unsigned int* size)
854 if (0 != __tts_get_feature_enabled()) {
855 return TTS_ERROR_NOT_SUPPORTED;
858 if (NULL == tts || NULL == size) {
859 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
860 return TTS_ERROR_INVALID_PARAMETER;
863 tts_client_s* client = tts_client_get(tts);
865 if (NULL == client) {
866 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
867 return TTS_ERROR_INVALID_PARAMETER;
870 if (TTS_STATE_READY != client->current_state) {
871 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
872 return TTS_ERROR_INVALID_STATE;
875 // *size = TTS_MAX_TEXT_SIZE;
876 if (0 != tts_config_mgr_get_max_text_size(size)) {
877 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
878 return TTS_ERROR_INVALID_PARAMETER;
881 g_max_text_size = (int)*size;
883 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
884 return TTS_ERROR_NONE;
887 int tts_get_state(tts_h tts, tts_state_e* state)
889 if (0 != __tts_get_feature_enabled()) {
890 return TTS_ERROR_NOT_SUPPORTED;
893 if (NULL == tts || NULL == state) {
894 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
895 return TTS_ERROR_INVALID_PARAMETER;
898 tts_client_s* client = tts_client_get(tts);
900 if (NULL == client) {
901 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
902 return TTS_ERROR_INVALID_PARAMETER;
905 *state = client->current_state;
908 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
909 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
910 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
911 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
912 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
915 return TTS_ERROR_NONE;
918 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
920 if (0 != __tts_get_feature_enabled()) {
921 return TTS_ERROR_NOT_SUPPORTED;
924 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
925 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
926 return TTS_ERROR_INVALID_PARAMETER;
929 tts_client_s* client = tts_client_get(tts);
931 if (NULL == client) {
932 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
933 return TTS_ERROR_INVALID_PARAMETER;
936 *min = TTS_SPEED_MIN;
937 *normal = TTS_SPEED_NORMAL;
938 *max = TTS_SPEED_MAX;
940 return TTS_ERROR_NONE;
943 int tts_get_error_message(tts_h tts, char** err_msg)
945 if (0 != __tts_get_feature_enabled()) {
946 return TTS_ERROR_NOT_SUPPORTED;
949 if (NULL == tts || NULL == err_msg) {
950 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
951 return TTS_ERROR_INVALID_PARAMETER;
954 tts_client_s* client = tts_client_get(tts);
956 if (NULL == client) {
957 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
958 return TTS_ERROR_INVALID_PARAMETER;
961 if (NULL != client->err_msg) {
962 *err_msg = strdup(client->err_msg);
963 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
966 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
969 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
971 return TTS_ERROR_NONE;
974 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
976 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
978 if (0 != __tts_get_feature_enabled()) {
979 return TTS_ERROR_NOT_SUPPORTED;
983 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
984 return TTS_ERROR_INVALID_PARAMETER;
987 if (voice_type < 0) {
988 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
989 return TTS_ERROR_INVALID_PARAMETER;
992 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
994 if (NULL == tts || NULL == utt_id) {
995 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
996 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
997 return TTS_ERROR_INVALID_PARAMETER;
1000 tts_client_s* client = tts_client_get(tts);
1002 if (NULL == client) {
1003 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1004 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1005 return TTS_ERROR_INVALID_PARAMETER;
1008 if (TTS_STATE_CREATED == client->current_state) {
1009 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1010 return TTS_ERROR_INVALID_STATE;
1013 if (-1 == g_max_text_size) {
1014 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1015 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1016 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1017 return TTS_ERROR_INVALID_PARAMETER;
1021 if (0 == g_max_text_size) {
1022 if (strlen(text) <= 0) {
1023 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1024 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1025 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1026 return TTS_ERROR_INVALID_PARAMETER;
1029 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1030 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1031 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1032 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1033 return TTS_ERROR_INVALID_PARAMETER;
1037 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1038 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1039 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1040 return TTS_ERROR_INVALID_PARAMETER;
1043 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1044 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1045 return TTS_ERROR_INVALID_STATE;
1048 if (true == client->credential_needed && NULL == client->credential) {
1049 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1050 return TTS_ERROR_PERMISSION_DENIED;
1053 /* check valid utf8 */
1057 dbus_error_init(&err);
1059 valid = dbus_validate_utf8(text, &err);
1060 if (dbus_error_is_set(&err)) {
1061 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1062 dbus_error_free(&err);
1063 return TTS_ERROR_INVALID_PARAMETER;
1066 if (valid != true) {
1067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1068 return TTS_ERROR_INVALID_PARAMETER;
1070 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1072 /* change default language value */
1075 if (NULL == language)
1076 temp = strdup("default");
1078 temp = strdup(language);
1080 client->current_utt_id++;
1081 if (client->current_utt_id == 10000) {
1082 client->current_utt_id = 1;
1089 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1091 if (TTS_ERROR_TIMED_OUT != ret) {
1092 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1095 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1098 if (TTS_RETRY_MIN_COUNT == count) {
1099 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1104 *utt_id = client->current_utt_id;
1113 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1118 static void __tts_play_async(void *data)
1120 tts_h tts = (tts_h)data;
1121 tts_client_s* client = tts_client_get(tts);
1124 if (NULL == client) {
1125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1132 ret = tts_dbus_request_play(client->uid, client->credential);
1134 if (TTS_ERROR_TIMED_OUT != ret) {
1135 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1138 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1141 if (TTS_RETRY_COUNT == count) {
1142 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1150 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1152 client->reason = ret;
1153 client->utt_id = -1;
1155 ecore_timer_add(0, __tts_notify_error, client->tts);
1159 client->before_state = client->current_state;
1160 client->current_state = TTS_STATE_PLAYING;
1162 if (NULL != client->state_changed_cb) {
1163 tts_client_use_callback(client);
1164 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1165 tts_client_not_use_callback(client);
1166 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1169 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1174 int tts_play_async(tts_h tts)
1176 if (0 != __tts_get_feature_enabled()) {
1177 return TTS_ERROR_NOT_SUPPORTED;
1180 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1183 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1184 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1185 return TTS_ERROR_INVALID_PARAMETER;
1188 tts_client_s* client = tts_client_get(tts);
1190 if (NULL == client) {
1191 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1192 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1193 return TTS_ERROR_INVALID_PARAMETER;
1196 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1197 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1198 return TTS_ERROR_INVALID_STATE;
1201 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1202 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1203 return TTS_ERROR_INVALID_STATE;
1206 if (true == client->credential_needed && NULL == client->credential) {
1207 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1208 return TTS_ERROR_PERMISSION_DENIED;
1211 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1213 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1215 return TTS_ERROR_NONE;
1218 int tts_play(tts_h tts)
1220 if (0 != __tts_get_feature_enabled()) {
1221 return TTS_ERROR_NOT_SUPPORTED;
1224 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1227 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1228 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1229 return TTS_ERROR_INVALID_PARAMETER;
1232 tts_client_s* client = tts_client_get(tts);
1234 if (NULL == client) {
1235 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1236 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1237 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1238 return TTS_ERROR_INVALID_PARAMETER;
1241 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1242 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1243 return TTS_ERROR_INVALID_STATE;
1246 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1247 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1248 return TTS_ERROR_INVALID_STATE;
1251 if (true == client->credential_needed && NULL == client->credential) {
1252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1253 return TTS_ERROR_PERMISSION_DENIED;
1259 ret = tts_dbus_request_play(client->uid, client->credential);
1261 if (TTS_ERROR_TIMED_OUT != ret) {
1262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1265 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1268 if (TTS_RETRY_COUNT == count) {
1269 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1276 client->before_state = client->current_state;
1277 client->current_state = TTS_STATE_PLAYING;
1279 if (NULL != client->state_changed_cb) {
1280 tts_client_use_callback(client);
1281 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1282 tts_client_not_use_callback(client);
1283 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1286 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1288 return TTS_ERROR_NONE;
1291 static void __tts_stop_async(void *data)
1293 tts_h tts = (tts_h)data;
1294 tts_client_s* client = tts_client_get(tts);
1297 if (NULL == client) {
1298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1305 ret = tts_dbus_request_stop(client->uid);
1307 if (TTS_ERROR_TIMED_OUT != ret) {
1308 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1311 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1314 if (TTS_RETRY_COUNT == count) {
1315 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1323 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1325 client->reason = ret;
1326 client->utt_id = -1;
1328 ecore_timer_add(0, __tts_notify_error, client->tts);
1332 client->before_state = client->current_state;
1333 client->current_state = TTS_STATE_READY;
1335 if (NULL != client->state_changed_cb) {
1336 tts_client_use_callback(client);
1337 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1338 tts_client_not_use_callback(client);
1339 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1342 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1347 int tts_stop_aync(tts_h tts)
1349 if (0 != __tts_get_feature_enabled()) {
1350 return TTS_ERROR_NOT_SUPPORTED;
1353 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1356 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1357 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1358 return TTS_ERROR_INVALID_PARAMETER;
1361 tts_client_s* client = tts_client_get(tts);
1363 if (NULL == client) {
1364 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1365 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1366 return TTS_ERROR_INVALID_PARAMETER;
1369 if (TTS_STATE_CREATED == client->current_state) {
1370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1371 return TTS_ERROR_INVALID_STATE;
1374 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1375 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1376 return TTS_ERROR_INVALID_STATE;
1379 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1381 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1383 return TTS_ERROR_NONE;
1386 int tts_stop(tts_h tts)
1388 if (0 != __tts_get_feature_enabled()) {
1389 return TTS_ERROR_NOT_SUPPORTED;
1392 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1396 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1397 return TTS_ERROR_INVALID_PARAMETER;
1400 tts_client_s* client = tts_client_get(tts);
1402 if (NULL == client) {
1403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1404 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1405 return TTS_ERROR_INVALID_PARAMETER;
1408 if (TTS_STATE_CREATED == client->current_state) {
1409 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1410 return TTS_ERROR_INVALID_STATE;
1413 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1414 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1415 return TTS_ERROR_INVALID_STATE;
1421 ret = tts_dbus_request_stop(client->uid);
1423 if (TTS_ERROR_TIMED_OUT != ret) {
1424 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1427 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1430 if (TTS_RETRY_COUNT == count) {
1431 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1438 client->before_state = client->current_state;
1439 client->current_state = TTS_STATE_READY;
1441 if (NULL != client->state_changed_cb) {
1442 tts_client_use_callback(client);
1443 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1444 tts_client_not_use_callback(client);
1445 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1448 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1450 return TTS_ERROR_NONE;
1453 static void __tts_pause_async(void *data)
1455 tts_h tts = (tts_h)data;
1456 tts_client_s* client = tts_client_get(tts);
1459 if (NULL == client) {
1460 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1467 ret = tts_dbus_request_pause(client->uid);
1469 if (TTS_ERROR_TIMED_OUT != ret) {
1470 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1473 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1476 if (TTS_RETRY_COUNT == count) {
1477 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1485 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1487 client->reason = ret;
1488 client->utt_id = -1;
1490 ecore_timer_add(0, __tts_notify_error, client->tts);
1494 client->before_state = client->current_state;
1495 client->current_state = TTS_STATE_PAUSED;
1497 if (NULL != client->state_changed_cb) {
1498 tts_client_use_callback(client);
1499 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1500 tts_client_not_use_callback(client);
1501 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1504 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1509 int tts_pause_async(tts_h tts)
1511 if (0 != __tts_get_feature_enabled()) {
1512 return TTS_ERROR_NOT_SUPPORTED;
1515 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1518 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1519 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1520 return TTS_ERROR_INVALID_PARAMETER;
1523 tts_client_s* client = tts_client_get(tts);
1525 if (NULL == client) {
1526 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1527 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1528 return TTS_ERROR_INVALID_PARAMETER;
1531 if (TTS_STATE_PLAYING != client->current_state) {
1532 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1533 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1534 return TTS_ERROR_INVALID_STATE;
1537 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1538 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1539 return TTS_ERROR_INVALID_STATE;
1542 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1544 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1546 return TTS_ERROR_NONE;
1549 int tts_pause(tts_h tts)
1551 if (0 != __tts_get_feature_enabled()) {
1552 return TTS_ERROR_NOT_SUPPORTED;
1555 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1558 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1559 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1560 return TTS_ERROR_INVALID_PARAMETER;
1563 tts_client_s* client = tts_client_get(tts);
1565 if (NULL == client) {
1566 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1567 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1568 return TTS_ERROR_INVALID_PARAMETER;
1571 if (TTS_STATE_PLAYING != client->current_state) {
1572 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1573 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1574 return TTS_ERROR_INVALID_STATE;
1577 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1578 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1579 return TTS_ERROR_INVALID_STATE;
1585 ret = tts_dbus_request_pause(client->uid);
1587 if (TTS_ERROR_TIMED_OUT != ret) {
1588 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1591 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1594 if (TTS_RETRY_COUNT == count) {
1595 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1602 client->before_state = client->current_state;
1603 client->current_state = TTS_STATE_PAUSED;
1605 if (NULL != client->state_changed_cb) {
1606 tts_client_use_callback(client);
1607 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1608 tts_client_not_use_callback(client);
1609 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1612 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1614 return TTS_ERROR_NONE;
1617 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1619 if (0 != __tts_get_feature_enabled()) {
1620 return TTS_ERROR_NOT_SUPPORTED;
1623 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1627 return TTS_ERROR_INVALID_PARAMETER;
1630 if (NULL == key || NULL == data) {
1631 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1632 return TTS_ERROR_INVALID_PARAMETER;
1635 tts_client_s* client = tts_client_get(tts);
1637 if (NULL == client) {
1638 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1639 return TTS_ERROR_INVALID_PARAMETER;
1642 if (TTS_STATE_READY != client->current_state) {
1643 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1644 return TTS_ERROR_INVALID_STATE;
1647 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1649 return TTS_ERROR_INVALID_PARAMETER;
1655 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1657 if (TTS_ERROR_TIMED_OUT != ret) {
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1661 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1664 if (TTS_RETRY_COUNT == count) {
1665 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1672 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1677 int tts_get_private_data(tts_h tts, const char* key, char** data)
1679 if (0 != __tts_get_feature_enabled()) {
1680 return TTS_ERROR_NOT_SUPPORTED;
1683 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1686 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1687 return TTS_ERROR_INVALID_PARAMETER;
1690 if (NULL == key || NULL == data) {
1691 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1692 return TTS_ERROR_INVALID_PARAMETER;
1695 tts_client_s* client = tts_client_get(tts);
1697 if (NULL == client) {
1698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1699 return TTS_ERROR_INVALID_PARAMETER;
1702 if (TTS_STATE_READY != client->current_state) {
1703 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1704 return TTS_ERROR_INVALID_STATE;
1710 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1712 if (TTS_ERROR_TIMED_OUT != ret) {
1713 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1716 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1719 if (TTS_RETRY_COUNT == count) {
1720 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1727 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1732 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1737 static Eina_Bool __tts_notify_error(void *data)
1739 tts_h tts = (tts_h)data;
1741 tts_client_s* client = tts_client_get(tts);
1744 if (NULL == client) {
1745 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1749 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1751 if (NULL != client->error_cb) {
1752 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1753 tts_client_use_callback(client);
1754 g_err_callback_status = true;
1755 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1756 g_err_callback_status = false;
1757 tts_client_not_use_callback(client);
1759 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1765 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1768 GList* client_list = NULL;
1769 client_list = tts_client_get_client_list();
1772 tts_client_s *data = NULL;
1774 if (g_list_length(client_list) > 0) {
1775 /* Get a first item */
1776 iter = g_list_first(client_list);
1778 while (NULL != iter) {
1781 data->utt_id = utt_id;
1782 data->reason = reason;
1783 if (NULL != data->err_msg) {
1784 free(data->err_msg);
1785 data->err_msg = NULL;
1787 if (NULL != err_msg)
1788 data->err_msg = strdup(err_msg);
1790 /* call callback function */
1791 if (NULL != data->error_cb) {
1792 ecore_timer_add(0, __tts_notify_error, data->tts);
1794 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1797 if (TTS_ERROR_SERVICE_RESET == reason) {
1798 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1800 data->current_state = TTS_STATE_CREATED;
1801 if (0 != tts_prepare(data->tts)) {
1802 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1807 iter = g_list_next(iter);
1811 tts_client_s* client = tts_client_get_by_uid(uid);
1813 if (NULL == client) {
1814 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1815 return TTS_ERROR_INVALID_PARAMETER;
1818 client->utt_id = utt_id;
1819 client->reason = reason;
1820 if (NULL != client->err_msg) {
1821 free(client->err_msg);
1822 client->err_msg = NULL;
1824 if (NULL != err_msg)
1825 client->err_msg = strdup(err_msg);
1827 /* call callback function */
1828 if (NULL != client->error_cb) {
1829 ecore_timer_add(0, __tts_notify_error, client->tts);
1831 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1834 if (TTS_ERROR_SERVICE_RESET == reason) {
1835 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1837 client->current_state = TTS_STATE_CREATED;
1838 if (0 != tts_prepare(client->tts)) {
1839 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1847 static Eina_Bool __tts_notify_state_changed(void *data)
1849 tts_h tts = (tts_h)data;
1851 tts_client_s* client = tts_client_get(tts);
1854 if (NULL == client) {
1855 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1859 if (NULL != client->state_changed_cb) {
1860 tts_client_use_callback(client);
1861 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1862 tts_client_not_use_callback(client);
1863 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1865 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1871 int __tts_cb_set_state(int uid, int state)
1873 tts_client_s* client = tts_client_get_by_uid(uid);
1874 if (NULL == client) {
1875 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1879 tts_state_e state_from_daemon = (tts_state_e)state;
1881 if (client->current_state == state_from_daemon) {
1882 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1886 if (NULL != client->state_changed_cb) {
1887 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1889 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1892 client->before_state = client->current_state;
1893 client->current_state = state_from_daemon;
1898 int __tts_cb_utt_started(int uid, int utt_id)
1900 tts_client_s* client = tts_client_get_by_uid(uid);
1902 if (NULL == client) {
1903 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1904 return TTS_ERROR_INVALID_PARAMETER;
1907 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1909 client->utt_id = utt_id;
1911 /* call callback function */
1912 if (NULL != client->utt_started_cb) {
1913 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1914 tts_client_use_callback(client);
1915 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1916 tts_client_not_use_callback(client);
1918 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1924 int __tts_cb_utt_completed(int uid, int utt_id)
1926 tts_client_s* client = tts_client_get_by_uid(uid);
1928 if (NULL == client) {
1929 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1930 return TTS_ERROR_INVALID_PARAMETER;
1933 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1935 client->utt_id = utt_id;
1937 /* call callback function */
1938 if (NULL != client->utt_completeted_cb) {
1939 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1940 tts_client_use_callback(client);
1941 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1942 tts_client_not_use_callback(client);
1944 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1950 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1952 if (0 != __tts_get_feature_enabled()) {
1953 return TTS_ERROR_NOT_SUPPORTED;
1956 if (NULL == tts || NULL == callback) {
1957 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1958 return TTS_ERROR_INVALID_PARAMETER;
1961 tts_client_s* client = tts_client_get(tts);
1963 if (NULL == client) {
1964 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1965 return TTS_ERROR_INVALID_PARAMETER;
1968 if (TTS_STATE_CREATED != client->current_state) {
1969 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1970 return TTS_ERROR_INVALID_STATE;
1973 client->state_changed_cb = callback;
1974 client->state_changed_user_data = user_data;
1976 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
1981 int tts_unset_state_changed_cb(tts_h tts)
1983 if (0 != __tts_get_feature_enabled()) {
1984 return TTS_ERROR_NOT_SUPPORTED;
1988 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1989 return TTS_ERROR_INVALID_PARAMETER;
1992 tts_client_s* client = tts_client_get(tts);
1994 if (NULL == client) {
1995 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1996 return TTS_ERROR_INVALID_PARAMETER;
1999 if (TTS_STATE_CREATED != client->current_state) {
2000 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2001 return TTS_ERROR_INVALID_STATE;
2004 client->state_changed_cb = NULL;
2005 client->state_changed_user_data = NULL;
2007 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2012 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2014 if (0 != __tts_get_feature_enabled()) {
2015 return TTS_ERROR_NOT_SUPPORTED;
2018 if (NULL == tts || NULL == callback) {
2019 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2020 return TTS_ERROR_INVALID_PARAMETER;
2023 tts_client_s* client = tts_client_get(tts);
2025 if (NULL == client) {
2026 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2027 return TTS_ERROR_INVALID_PARAMETER;
2030 if (TTS_STATE_CREATED != client->current_state) {
2031 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2032 return TTS_ERROR_INVALID_STATE;
2035 client->utt_started_cb = callback;
2036 client->utt_started_user_data = user_data;
2038 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2043 int tts_unset_utterance_started_cb(tts_h tts)
2045 if (0 != __tts_get_feature_enabled()) {
2046 return TTS_ERROR_NOT_SUPPORTED;
2050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2051 return TTS_ERROR_INVALID_PARAMETER;
2054 tts_client_s* client = tts_client_get(tts);
2056 if (NULL == client) {
2057 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2058 return TTS_ERROR_INVALID_PARAMETER;
2061 if (TTS_STATE_CREATED != client->current_state) {
2062 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2063 return TTS_ERROR_INVALID_STATE;
2066 client->utt_started_cb = NULL;
2067 client->utt_started_user_data = NULL;
2069 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2074 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2076 if (0 != __tts_get_feature_enabled()) {
2077 return TTS_ERROR_NOT_SUPPORTED;
2080 if (NULL == tts || NULL == callback) {
2081 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2082 return TTS_ERROR_INVALID_PARAMETER;
2085 tts_client_s* client = tts_client_get(tts);
2087 if (NULL == client) {
2088 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2089 return TTS_ERROR_INVALID_PARAMETER;
2092 if (TTS_STATE_CREATED != client->current_state) {
2093 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2094 return TTS_ERROR_INVALID_STATE;
2097 client->utt_completeted_cb = callback;
2098 client->utt_completed_user_data = user_data;
2100 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2105 int tts_unset_utterance_completed_cb(tts_h tts)
2107 if (0 != __tts_get_feature_enabled()) {
2108 return TTS_ERROR_NOT_SUPPORTED;
2112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2113 return TTS_ERROR_INVALID_PARAMETER;
2116 tts_client_s* client = tts_client_get(tts);
2118 if (NULL == client) {
2119 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2120 return TTS_ERROR_INVALID_PARAMETER;
2123 if (TTS_STATE_CREATED != client->current_state) {
2124 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2125 return TTS_ERROR_INVALID_STATE;
2128 client->utt_completeted_cb = NULL;
2129 client->utt_completed_user_data = NULL;
2131 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2135 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2137 if (0 != __tts_get_feature_enabled()) {
2138 return TTS_ERROR_NOT_SUPPORTED;
2141 if (NULL == tts || NULL == callback) {
2142 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2143 return TTS_ERROR_INVALID_PARAMETER;
2146 tts_client_s* client = tts_client_get(tts);
2148 if (NULL == client) {
2149 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2150 return TTS_ERROR_INVALID_PARAMETER;
2153 if (TTS_STATE_CREATED != client->current_state) {
2154 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2155 return TTS_ERROR_INVALID_STATE;
2158 client->error_cb = callback;
2159 client->error_user_data = user_data;
2161 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2166 int tts_unset_error_cb(tts_h tts)
2168 if (0 != __tts_get_feature_enabled()) {
2169 return TTS_ERROR_NOT_SUPPORTED;
2173 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2174 return TTS_ERROR_INVALID_PARAMETER;
2177 tts_client_s* client = tts_client_get(tts);
2179 if (NULL == client) {
2180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2181 return TTS_ERROR_INVALID_PARAMETER;
2184 if (TTS_STATE_CREATED != client->current_state) {
2185 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2186 return TTS_ERROR_INVALID_STATE;
2189 client->error_cb = NULL;
2190 client->error_user_data = NULL;
2192 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2197 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2199 if (0 != __tts_get_feature_enabled()) {
2200 return TTS_ERROR_NOT_SUPPORTED;
2203 if (NULL == tts || NULL == callback) {
2204 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2205 return TTS_ERROR_INVALID_PARAMETER;
2208 tts_client_s* client = tts_client_get(tts);
2210 if (NULL == client) {
2211 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2212 return TTS_ERROR_INVALID_PARAMETER;
2215 if (TTS_STATE_CREATED != client->current_state) {
2216 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2217 return TTS_ERROR_INVALID_STATE;
2220 client->default_voice_changed_cb = callback;
2221 client->default_voice_changed_user_data = user_data;
2223 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2228 int tts_unset_default_voice_changed_cb(tts_h tts)
2230 if (0 != __tts_get_feature_enabled()) {
2231 return TTS_ERROR_NOT_SUPPORTED;
2235 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2236 return TTS_ERROR_INVALID_PARAMETER;
2239 tts_client_s* client = tts_client_get(tts);
2241 if (NULL == client) {
2242 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2243 return TTS_ERROR_INVALID_PARAMETER;
2246 if (TTS_STATE_CREATED != client->current_state) {
2247 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2248 return TTS_ERROR_INVALID_STATE;
2251 client->default_voice_changed_cb = NULL;
2252 client->default_voice_changed_user_data = NULL;
2254 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2259 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2261 if (0 != __tts_get_feature_enabled()) {
2262 return TTS_ERROR_NOT_SUPPORTED;
2265 if (NULL == tts || NULL == callback) {
2266 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2267 return TTS_ERROR_INVALID_PARAMETER;
2270 tts_client_s* client = tts_client_get(tts);
2272 if (NULL == client) {
2273 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2274 return TTS_ERROR_INVALID_PARAMETER;
2277 if (TTS_STATE_CREATED != client->current_state) {
2278 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2279 return TTS_ERROR_INVALID_STATE;
2282 client->engine_changed_cb = callback;
2283 client->engine_changed_user_data = user_data;
2285 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2290 int tts_unset_engine_changed_cb(tts_h tts)
2292 if (0 != __tts_get_feature_enabled()) {
2293 return TTS_ERROR_NOT_SUPPORTED;
2297 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2298 return TTS_ERROR_INVALID_PARAMETER;
2301 tts_client_s* client = tts_client_get(tts);
2303 if (NULL == client) {
2304 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2305 return TTS_ERROR_INVALID_PARAMETER;
2308 if (TTS_STATE_CREATED != client->current_state) {
2309 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2310 return TTS_ERROR_INVALID_STATE;
2313 client->engine_changed_cb = NULL;
2314 client->engine_changed_user_data = NULL;
2316 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2321 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2323 if (0 != __tts_get_feature_enabled()) {
2324 return TTS_ERROR_NOT_SUPPORTED;
2327 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2330 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2331 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2332 return TTS_ERROR_INVALID_PARAMETER;
2335 tts_client_s* client = tts_client_get(tts);
2337 if (NULL == client) {
2338 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2339 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2340 return TTS_ERROR_INVALID_PARAMETER;
2343 if (TTS_STATE_PLAYING != client->current_state) {
2344 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2345 return TTS_ERROR_INVALID_STATE;
2348 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2349 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2350 return TTS_ERROR_INVALID_STATE;
2356 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2358 if (TTS_ERROR_TIMED_OUT != ret) {
2359 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2362 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2365 if (TTS_RETRY_COUNT == count) {
2366 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2373 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2375 return TTS_ERROR_NONE;
2378 int tts_play_pcm(tts_h tts)
2380 if (0 != __tts_get_feature_enabled()) {
2381 return TTS_ERROR_NOT_SUPPORTED;
2384 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2387 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2388 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2389 return TTS_ERROR_INVALID_PARAMETER;
2392 tts_client_s* client = tts_client_get(tts);
2394 if (NULL == client) {
2395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2396 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2397 return TTS_ERROR_INVALID_PARAMETER;
2400 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2401 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2402 return TTS_ERROR_INVALID_STATE;
2405 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2406 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2407 return TTS_ERROR_INVALID_STATE;
2413 ret = tts_dbus_request_play_pcm(client->uid);
2415 if (TTS_ERROR_TIMED_OUT != ret) {
2416 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2419 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2422 if (TTS_RETRY_COUNT == count) {
2423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2430 client->before_state = client->current_state;
2431 client->current_state = TTS_STATE_PLAYING;
2433 if (NULL != client->state_changed_cb) {
2434 tts_client_use_callback(client);
2435 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2436 tts_client_not_use_callback(client);
2437 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2440 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2442 return TTS_ERROR_NONE;
2445 int tts_stop_pcm(tts_h tts)
2447 if (0 != __tts_get_feature_enabled()) {
2448 return TTS_ERROR_NOT_SUPPORTED;
2451 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2454 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2455 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2456 return TTS_ERROR_INVALID_PARAMETER;
2459 tts_client_s* client = tts_client_get(tts);
2461 if (NULL == client) {
2462 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2463 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2464 return TTS_ERROR_INVALID_PARAMETER;
2467 if (TTS_STATE_PLAYING != client->current_state) {
2468 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2469 return TTS_ERROR_INVALID_STATE;
2472 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2473 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2474 return TTS_ERROR_INVALID_STATE;
2480 ret = tts_dbus_request_stop_pcm(client->uid);
2482 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 stop pcm : %s", __tts_get_error_code(ret));
2489 if (TTS_RETRY_COUNT == count) {
2490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2497 client->before_state = client->current_state;
2498 client->current_state = TTS_STATE_READY;
2500 if (NULL != client->state_changed_cb) {
2501 tts_client_use_callback(client);
2502 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2503 tts_client_not_use_callback(client);
2504 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2507 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2509 return TTS_ERROR_NONE;