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_PERMISSION_DENIED == ret) {
605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
607 client->reason = TTS_ERROR_PERMISSION_DENIED;
610 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
611 client->conn_timer = NULL;
614 } else if (TTS_ERROR_NONE != ret) {
615 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
619 /* success to connect tts-daemon */
620 client->credential_needed = credential_needed;
621 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
624 client->conn_timer = NULL;
626 client = tts_client_get(tts);
628 if (NULL == client) {
629 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
633 client->before_state = client->current_state;
634 client->current_state = TTS_STATE_READY;
636 if (NULL != client->state_changed_cb) {
637 tts_client_use_callback(client);
638 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
639 tts_client_not_use_callback(client);
641 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
644 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
649 int tts_prepare(tts_h tts)
651 if (0 != __tts_get_feature_enabled()) {
652 return TTS_ERROR_NOT_SUPPORTED;
655 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
657 tts_client_s* client = tts_client_get(tts);
660 if (NULL == client) {
661 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
662 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
663 return TTS_ERROR_INVALID_PARAMETER;
667 if (client->current_state != TTS_STATE_CREATED) {
668 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
669 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
670 return TTS_ERROR_INVALID_STATE;
673 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
675 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
677 return TTS_ERROR_NONE;
680 int tts_unprepare(tts_h tts)
682 if (0 != __tts_get_feature_enabled()) {
683 return TTS_ERROR_NOT_SUPPORTED;
686 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
688 tts_client_s* client = tts_client_get(tts);
691 if (NULL == client) {
692 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
693 return TTS_ERROR_INVALID_PARAMETER;
697 if (client->current_state != TTS_STATE_READY) {
698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
699 return TTS_ERROR_INVALID_STATE;
704 int screen_reader = -1;
706 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
708 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
710 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);
711 g_screen_reader = (bool)screen_reader;
714 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
716 ret = tts_dbus_request_finalize(client->uid);
718 if (TTS_ERROR_TIMED_OUT != ret) {
719 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
722 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
725 if (TTS_RETRY_COUNT == count) {
726 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
733 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
736 client->before_state = client->current_state;
737 client->current_state = TTS_STATE_CREATED;
739 if (NULL != client->state_changed_cb) {
740 tts_client_use_callback(client);
741 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
742 tts_client_not_use_callback(client);
743 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
746 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
748 return TTS_ERROR_NONE;
751 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
753 tts_h tts = (tts_h)user_data;
755 tts_client_s* client = tts_client_get(tts);
756 if (NULL == client) {
757 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
761 /* call callback function */
762 if (NULL != client->supported_voice_cb) {
763 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
765 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
771 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
773 if (0 != __tts_get_feature_enabled()) {
774 return TTS_ERROR_NOT_SUPPORTED;
777 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
779 if (NULL == tts || NULL == callback) {
780 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
781 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
782 return TTS_ERROR_INVALID_PARAMETER;
785 tts_client_s* client = tts_client_get(tts);
788 if (NULL == client) {
789 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
790 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
791 return TTS_ERROR_INVALID_PARAMETER;
795 char* current_engine = NULL;
796 ret = tts_config_mgr_get_engine(¤t_engine);
798 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
799 return __tts_convert_config_error_code(ret);
802 client->supported_voice_cb = callback;
803 client->supported_voice_user_data = user_data;
805 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
807 if (NULL != current_engine) {
808 free(current_engine);
809 current_engine = NULL;
812 client->supported_voice_cb = NULL;
813 client->supported_voice_user_data = NULL;
816 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
817 ret = TTS_ERROR_OPERATION_FAILED;
820 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
825 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
827 if (0 != __tts_get_feature_enabled()) {
828 return TTS_ERROR_NOT_SUPPORTED;
831 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
834 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
835 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
836 return TTS_ERROR_INVALID_PARAMETER;
839 tts_client_s* client = tts_client_get(tts);
841 if (NULL == client) {
842 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
843 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
844 return TTS_ERROR_INVALID_PARAMETER;
847 /* Request call remote method */
849 ret = tts_config_mgr_get_voice(lang, vctype);
851 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
852 return __tts_convert_config_error_code(ret);
854 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
857 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
862 int tts_get_max_text_size(tts_h tts, unsigned int* size)
864 if (0 != __tts_get_feature_enabled()) {
865 return TTS_ERROR_NOT_SUPPORTED;
868 if (NULL == tts || NULL == size) {
869 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
870 return TTS_ERROR_INVALID_PARAMETER;
873 tts_client_s* client = tts_client_get(tts);
875 if (NULL == client) {
876 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
877 return TTS_ERROR_INVALID_PARAMETER;
880 if (TTS_STATE_READY != client->current_state) {
881 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
882 return TTS_ERROR_INVALID_STATE;
885 // *size = TTS_MAX_TEXT_SIZE;
886 if (0 != tts_config_mgr_get_max_text_size(size)) {
887 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
888 return TTS_ERROR_INVALID_PARAMETER;
891 g_max_text_size = (int)*size;
893 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
894 return TTS_ERROR_NONE;
897 int tts_get_state(tts_h tts, tts_state_e* state)
899 if (0 != __tts_get_feature_enabled()) {
900 return TTS_ERROR_NOT_SUPPORTED;
903 if (NULL == tts || NULL == state) {
904 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
905 return TTS_ERROR_INVALID_PARAMETER;
908 tts_client_s* client = tts_client_get(tts);
910 if (NULL == client) {
911 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
912 return TTS_ERROR_INVALID_PARAMETER;
915 *state = client->current_state;
918 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
919 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
920 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
921 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
922 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
925 return TTS_ERROR_NONE;
928 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
930 if (0 != __tts_get_feature_enabled()) {
931 return TTS_ERROR_NOT_SUPPORTED;
934 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
936 return TTS_ERROR_INVALID_PARAMETER;
939 tts_client_s* client = tts_client_get(tts);
941 if (NULL == client) {
942 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
943 return TTS_ERROR_INVALID_PARAMETER;
946 *min = TTS_SPEED_MIN;
947 *normal = TTS_SPEED_NORMAL;
948 *max = TTS_SPEED_MAX;
950 return TTS_ERROR_NONE;
953 int tts_get_error_message(tts_h tts, char** err_msg)
955 if (0 != __tts_get_feature_enabled()) {
956 return TTS_ERROR_NOT_SUPPORTED;
959 if (NULL == tts || NULL == err_msg) {
960 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
961 return TTS_ERROR_INVALID_PARAMETER;
964 tts_client_s* client = tts_client_get(tts);
966 if (NULL == client) {
967 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
968 return TTS_ERROR_INVALID_PARAMETER;
971 if (NULL != client->err_msg) {
972 *err_msg = strdup(client->err_msg);
973 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
976 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
979 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
981 return TTS_ERROR_NONE;
984 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
986 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
988 if (0 != __tts_get_feature_enabled()) {
989 return TTS_ERROR_NOT_SUPPORTED;
993 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
994 return TTS_ERROR_INVALID_PARAMETER;
997 if (voice_type < 0) {
998 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
999 return TTS_ERROR_INVALID_PARAMETER;
1002 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1004 if (NULL == tts || NULL == utt_id) {
1005 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1006 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1007 return TTS_ERROR_INVALID_PARAMETER;
1010 tts_client_s* client = tts_client_get(tts);
1012 if (NULL == client) {
1013 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1014 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1015 return TTS_ERROR_INVALID_PARAMETER;
1018 if (TTS_STATE_CREATED == client->current_state) {
1019 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1020 return TTS_ERROR_INVALID_STATE;
1023 if (-1 == g_max_text_size) {
1024 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1025 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1026 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1027 return TTS_ERROR_INVALID_PARAMETER;
1031 if (0 == g_max_text_size) {
1032 if (strlen(text) <= 0) {
1033 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1034 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1035 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1036 return TTS_ERROR_INVALID_PARAMETER;
1039 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1040 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1041 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1042 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1043 return TTS_ERROR_INVALID_PARAMETER;
1047 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1048 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1049 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1050 return TTS_ERROR_INVALID_PARAMETER;
1053 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1054 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1055 return TTS_ERROR_INVALID_STATE;
1058 if (true == client->credential_needed && NULL == client->credential) {
1059 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1060 return TTS_ERROR_PERMISSION_DENIED;
1063 /* check valid utf8 */
1067 dbus_error_init(&err);
1069 valid = dbus_validate_utf8(text, &err);
1070 if (dbus_error_is_set(&err)) {
1071 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1072 dbus_error_free(&err);
1073 return TTS_ERROR_INVALID_PARAMETER;
1076 if (valid != true) {
1077 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1078 return TTS_ERROR_INVALID_PARAMETER;
1080 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1082 /* change default language value */
1085 if (NULL == language)
1086 temp = strdup("default");
1088 temp = strdup(language);
1090 client->current_utt_id++;
1091 if (client->current_utt_id == 10000) {
1092 client->current_utt_id = 1;
1099 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1101 if (TTS_ERROR_TIMED_OUT != ret) {
1102 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1105 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1108 if (TTS_RETRY_MIN_COUNT == count) {
1109 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1114 *utt_id = client->current_utt_id;
1123 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1128 static void __tts_play_async(void *data)
1130 tts_h tts = (tts_h)data;
1131 tts_client_s* client = tts_client_get(tts);
1134 if (NULL == client) {
1135 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1142 ret = tts_dbus_request_play(client->uid, client->credential);
1144 if (TTS_ERROR_TIMED_OUT != ret) {
1145 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1148 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1151 if (TTS_RETRY_COUNT == count) {
1152 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1162 client->reason = ret;
1163 client->utt_id = -1;
1165 ecore_timer_add(0, __tts_notify_error, client->tts);
1169 client->before_state = client->current_state;
1170 client->current_state = TTS_STATE_PLAYING;
1172 if (NULL != client->state_changed_cb) {
1173 tts_client_use_callback(client);
1174 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1175 tts_client_not_use_callback(client);
1176 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1179 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1184 int tts_play_async(tts_h tts)
1186 if (0 != __tts_get_feature_enabled()) {
1187 return TTS_ERROR_NOT_SUPPORTED;
1190 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1193 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1194 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1195 return TTS_ERROR_INVALID_PARAMETER;
1198 tts_client_s* client = tts_client_get(tts);
1200 if (NULL == client) {
1201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1202 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1203 return TTS_ERROR_INVALID_PARAMETER;
1206 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1207 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1208 return TTS_ERROR_INVALID_STATE;
1211 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1212 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1213 return TTS_ERROR_INVALID_STATE;
1216 if (true == client->credential_needed && NULL == client->credential) {
1217 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1218 return TTS_ERROR_PERMISSION_DENIED;
1221 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1223 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1225 return TTS_ERROR_NONE;
1228 int tts_play(tts_h tts)
1230 if (0 != __tts_get_feature_enabled()) {
1231 return TTS_ERROR_NOT_SUPPORTED;
1234 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1237 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1238 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1239 return TTS_ERROR_INVALID_PARAMETER;
1242 tts_client_s* client = tts_client_get(tts);
1244 if (NULL == client) {
1245 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1246 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1247 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1248 return TTS_ERROR_INVALID_PARAMETER;
1251 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1253 return TTS_ERROR_INVALID_STATE;
1256 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1257 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1258 return TTS_ERROR_INVALID_STATE;
1261 if (true == client->credential_needed && NULL == client->credential) {
1262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1263 return TTS_ERROR_PERMISSION_DENIED;
1269 ret = tts_dbus_request_play(client->uid, client->credential);
1271 if (TTS_ERROR_TIMED_OUT != ret) {
1272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1275 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1278 if (TTS_RETRY_COUNT == count) {
1279 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1286 client->before_state = client->current_state;
1287 client->current_state = TTS_STATE_PLAYING;
1289 if (NULL != client->state_changed_cb) {
1290 tts_client_use_callback(client);
1291 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1292 tts_client_not_use_callback(client);
1293 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1296 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1298 return TTS_ERROR_NONE;
1301 static void __tts_stop_async(void *data)
1303 tts_h tts = (tts_h)data;
1304 tts_client_s* client = tts_client_get(tts);
1307 if (NULL == client) {
1308 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1315 ret = tts_dbus_request_stop(client->uid);
1317 if (TTS_ERROR_TIMED_OUT != ret) {
1318 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1321 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1324 if (TTS_RETRY_COUNT == count) {
1325 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1333 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1335 client->reason = ret;
1336 client->utt_id = -1;
1338 ecore_timer_add(0, __tts_notify_error, client->tts);
1342 client->before_state = client->current_state;
1343 client->current_state = TTS_STATE_READY;
1345 if (NULL != client->state_changed_cb) {
1346 tts_client_use_callback(client);
1347 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1348 tts_client_not_use_callback(client);
1349 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1352 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1357 int tts_stop_aync(tts_h tts)
1359 if (0 != __tts_get_feature_enabled()) {
1360 return TTS_ERROR_NOT_SUPPORTED;
1363 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1366 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1367 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1368 return TTS_ERROR_INVALID_PARAMETER;
1371 tts_client_s* client = tts_client_get(tts);
1373 if (NULL == client) {
1374 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1375 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1376 return TTS_ERROR_INVALID_PARAMETER;
1379 if (TTS_STATE_CREATED == client->current_state) {
1380 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1381 return TTS_ERROR_INVALID_STATE;
1384 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1385 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1386 return TTS_ERROR_INVALID_STATE;
1389 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1391 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1393 return TTS_ERROR_NONE;
1396 int tts_stop(tts_h tts)
1398 if (0 != __tts_get_feature_enabled()) {
1399 return TTS_ERROR_NOT_SUPPORTED;
1402 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1405 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1406 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1407 return TTS_ERROR_INVALID_PARAMETER;
1410 tts_client_s* client = tts_client_get(tts);
1412 if (NULL == client) {
1413 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1414 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1415 return TTS_ERROR_INVALID_PARAMETER;
1418 if (TTS_STATE_CREATED == client->current_state) {
1419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1420 return TTS_ERROR_INVALID_STATE;
1423 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1424 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1425 return TTS_ERROR_INVALID_STATE;
1431 ret = tts_dbus_request_stop(client->uid);
1433 if (TTS_ERROR_TIMED_OUT != ret) {
1434 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1437 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1440 if (TTS_RETRY_COUNT == count) {
1441 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1448 client->before_state = client->current_state;
1449 client->current_state = TTS_STATE_READY;
1451 if (NULL != client->state_changed_cb) {
1452 tts_client_use_callback(client);
1453 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1454 tts_client_not_use_callback(client);
1455 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1458 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1460 return TTS_ERROR_NONE;
1463 static void __tts_pause_async(void *data)
1465 tts_h tts = (tts_h)data;
1466 tts_client_s* client = tts_client_get(tts);
1469 if (NULL == client) {
1470 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1477 ret = tts_dbus_request_pause(client->uid);
1479 if (TTS_ERROR_TIMED_OUT != ret) {
1480 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1483 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1486 if (TTS_RETRY_COUNT == count) {
1487 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1495 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1497 client->reason = ret;
1498 client->utt_id = -1;
1500 ecore_timer_add(0, __tts_notify_error, client->tts);
1504 client->before_state = client->current_state;
1505 client->current_state = TTS_STATE_PAUSED;
1507 if (NULL != client->state_changed_cb) {
1508 tts_client_use_callback(client);
1509 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1510 tts_client_not_use_callback(client);
1511 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1514 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1519 int tts_pause_async(tts_h tts)
1521 if (0 != __tts_get_feature_enabled()) {
1522 return TTS_ERROR_NOT_SUPPORTED;
1525 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1528 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1529 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1530 return TTS_ERROR_INVALID_PARAMETER;
1533 tts_client_s* client = tts_client_get(tts);
1535 if (NULL == client) {
1536 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1537 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1538 return TTS_ERROR_INVALID_PARAMETER;
1541 if (TTS_STATE_PLAYING != client->current_state) {
1542 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1543 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1544 return TTS_ERROR_INVALID_STATE;
1547 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1548 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1549 return TTS_ERROR_INVALID_STATE;
1552 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1554 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1556 return TTS_ERROR_NONE;
1559 int tts_pause(tts_h tts)
1561 if (0 != __tts_get_feature_enabled()) {
1562 return TTS_ERROR_NOT_SUPPORTED;
1565 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1568 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1569 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1570 return TTS_ERROR_INVALID_PARAMETER;
1573 tts_client_s* client = tts_client_get(tts);
1575 if (NULL == client) {
1576 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1577 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1578 return TTS_ERROR_INVALID_PARAMETER;
1581 if (TTS_STATE_PLAYING != client->current_state) {
1582 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1583 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1584 return TTS_ERROR_INVALID_STATE;
1587 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1588 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1589 return TTS_ERROR_INVALID_STATE;
1595 ret = tts_dbus_request_pause(client->uid);
1597 if (TTS_ERROR_TIMED_OUT != ret) {
1598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1601 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1604 if (TTS_RETRY_COUNT == count) {
1605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1612 client->before_state = client->current_state;
1613 client->current_state = TTS_STATE_PAUSED;
1615 if (NULL != client->state_changed_cb) {
1616 tts_client_use_callback(client);
1617 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1618 tts_client_not_use_callback(client);
1619 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1622 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1624 return TTS_ERROR_NONE;
1627 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1629 if (0 != __tts_get_feature_enabled()) {
1630 return TTS_ERROR_NOT_SUPPORTED;
1633 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1636 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1637 return TTS_ERROR_INVALID_PARAMETER;
1640 if (NULL == key || NULL == data) {
1641 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1642 return TTS_ERROR_INVALID_PARAMETER;
1645 tts_client_s* client = tts_client_get(tts);
1647 if (NULL == client) {
1648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1649 return TTS_ERROR_INVALID_PARAMETER;
1652 if (TTS_STATE_READY != client->current_state) {
1653 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1654 return TTS_ERROR_INVALID_STATE;
1657 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1659 return TTS_ERROR_INVALID_PARAMETER;
1665 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1667 if (TTS_ERROR_TIMED_OUT != ret) {
1668 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1671 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1674 if (TTS_RETRY_COUNT == count) {
1675 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1682 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1687 int tts_get_private_data(tts_h tts, const char* key, char** data)
1689 if (0 != __tts_get_feature_enabled()) {
1690 return TTS_ERROR_NOT_SUPPORTED;
1693 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1696 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1697 return TTS_ERROR_INVALID_PARAMETER;
1700 if (NULL == key || NULL == data) {
1701 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1702 return TTS_ERROR_INVALID_PARAMETER;
1705 tts_client_s* client = tts_client_get(tts);
1707 if (NULL == client) {
1708 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1709 return TTS_ERROR_INVALID_PARAMETER;
1712 if (TTS_STATE_READY != client->current_state) {
1713 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1714 return TTS_ERROR_INVALID_STATE;
1720 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1722 if (TTS_ERROR_TIMED_OUT != ret) {
1723 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1726 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1729 if (TTS_RETRY_COUNT == count) {
1730 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1737 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1742 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1747 static Eina_Bool __tts_notify_error(void *data)
1749 tts_h tts = (tts_h)data;
1751 tts_client_s* client = tts_client_get(tts);
1754 if (NULL == client) {
1755 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1759 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1761 if (NULL != client->error_cb) {
1762 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1763 tts_client_use_callback(client);
1764 g_err_callback_status = true;
1765 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1766 g_err_callback_status = false;
1767 tts_client_not_use_callback(client);
1769 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1775 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1778 GList* client_list = NULL;
1779 client_list = tts_client_get_client_list();
1782 tts_client_s *data = NULL;
1784 if (g_list_length(client_list) > 0) {
1785 /* Get a first item */
1786 iter = g_list_first(client_list);
1788 while (NULL != iter) {
1791 data->utt_id = utt_id;
1792 data->reason = reason;
1793 if (NULL != data->err_msg) {
1794 free(data->err_msg);
1795 data->err_msg = NULL;
1797 if (NULL != err_msg)
1798 data->err_msg = strdup(err_msg);
1800 /* call callback function */
1801 if (NULL != data->error_cb) {
1802 ecore_timer_add(0, __tts_notify_error, data->tts);
1804 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1807 if (TTS_ERROR_SERVICE_RESET == reason) {
1808 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1810 data->current_state = TTS_STATE_CREATED;
1811 if (0 != tts_prepare(data->tts)) {
1812 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1817 iter = g_list_next(iter);
1821 tts_client_s* client = tts_client_get_by_uid(uid);
1823 if (NULL == client) {
1824 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1825 return TTS_ERROR_INVALID_PARAMETER;
1828 client->utt_id = utt_id;
1829 client->reason = reason;
1830 if (NULL != client->err_msg) {
1831 free(client->err_msg);
1832 client->err_msg = NULL;
1834 if (NULL != err_msg)
1835 client->err_msg = strdup(err_msg);
1837 /* call callback function */
1838 if (NULL != client->error_cb) {
1839 ecore_timer_add(0, __tts_notify_error, client->tts);
1841 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1844 if (TTS_ERROR_SERVICE_RESET == reason) {
1845 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1847 client->current_state = TTS_STATE_CREATED;
1848 if (0 != tts_prepare(client->tts)) {
1849 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1857 static Eina_Bool __tts_notify_state_changed(void *data)
1859 tts_h tts = (tts_h)data;
1861 tts_client_s* client = tts_client_get(tts);
1864 if (NULL == client) {
1865 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1869 if (NULL != client->state_changed_cb) {
1870 tts_client_use_callback(client);
1871 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1872 tts_client_not_use_callback(client);
1873 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1875 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1881 int __tts_cb_set_state(int uid, int state)
1883 tts_client_s* client = tts_client_get_by_uid(uid);
1884 if (NULL == client) {
1885 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1889 tts_state_e state_from_daemon = (tts_state_e)state;
1891 if (client->current_state == state_from_daemon) {
1892 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1896 if (NULL != client->state_changed_cb) {
1897 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1899 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1902 client->before_state = client->current_state;
1903 client->current_state = state_from_daemon;
1908 int __tts_cb_utt_started(int uid, int utt_id)
1910 tts_client_s* client = tts_client_get_by_uid(uid);
1912 if (NULL == client) {
1913 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1914 return TTS_ERROR_INVALID_PARAMETER;
1917 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1919 client->utt_id = utt_id;
1921 /* call callback function */
1922 if (NULL != client->utt_started_cb) {
1923 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1924 tts_client_use_callback(client);
1925 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1926 tts_client_not_use_callback(client);
1928 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1934 int __tts_cb_utt_completed(int uid, int utt_id)
1936 tts_client_s* client = tts_client_get_by_uid(uid);
1938 if (NULL == client) {
1939 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1940 return TTS_ERROR_INVALID_PARAMETER;
1943 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1945 client->utt_id = utt_id;
1947 /* call callback function */
1948 if (NULL != client->utt_completeted_cb) {
1949 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1950 tts_client_use_callback(client);
1951 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1952 tts_client_not_use_callback(client);
1954 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1960 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1962 if (0 != __tts_get_feature_enabled()) {
1963 return TTS_ERROR_NOT_SUPPORTED;
1966 if (NULL == tts || NULL == callback) {
1967 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1968 return TTS_ERROR_INVALID_PARAMETER;
1971 tts_client_s* client = tts_client_get(tts);
1973 if (NULL == client) {
1974 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1975 return TTS_ERROR_INVALID_PARAMETER;
1978 if (TTS_STATE_CREATED != client->current_state) {
1979 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1980 return TTS_ERROR_INVALID_STATE;
1983 client->state_changed_cb = callback;
1984 client->state_changed_user_data = user_data;
1986 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
1991 int tts_unset_state_changed_cb(tts_h tts)
1993 if (0 != __tts_get_feature_enabled()) {
1994 return TTS_ERROR_NOT_SUPPORTED;
1998 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1999 return TTS_ERROR_INVALID_PARAMETER;
2002 tts_client_s* client = tts_client_get(tts);
2004 if (NULL == client) {
2005 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2006 return TTS_ERROR_INVALID_PARAMETER;
2009 if (TTS_STATE_CREATED != client->current_state) {
2010 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2011 return TTS_ERROR_INVALID_STATE;
2014 client->state_changed_cb = NULL;
2015 client->state_changed_user_data = NULL;
2017 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2022 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2024 if (0 != __tts_get_feature_enabled()) {
2025 return TTS_ERROR_NOT_SUPPORTED;
2028 if (NULL == tts || NULL == callback) {
2029 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2030 return TTS_ERROR_INVALID_PARAMETER;
2033 tts_client_s* client = tts_client_get(tts);
2035 if (NULL == client) {
2036 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2037 return TTS_ERROR_INVALID_PARAMETER;
2040 if (TTS_STATE_CREATED != client->current_state) {
2041 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2042 return TTS_ERROR_INVALID_STATE;
2045 client->utt_started_cb = callback;
2046 client->utt_started_user_data = user_data;
2048 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2053 int tts_unset_utterance_started_cb(tts_h tts)
2055 if (0 != __tts_get_feature_enabled()) {
2056 return TTS_ERROR_NOT_SUPPORTED;
2060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2061 return TTS_ERROR_INVALID_PARAMETER;
2064 tts_client_s* client = tts_client_get(tts);
2066 if (NULL == client) {
2067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2068 return TTS_ERROR_INVALID_PARAMETER;
2071 if (TTS_STATE_CREATED != client->current_state) {
2072 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2073 return TTS_ERROR_INVALID_STATE;
2076 client->utt_started_cb = NULL;
2077 client->utt_started_user_data = NULL;
2079 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2084 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2086 if (0 != __tts_get_feature_enabled()) {
2087 return TTS_ERROR_NOT_SUPPORTED;
2090 if (NULL == tts || NULL == callback) {
2091 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2092 return TTS_ERROR_INVALID_PARAMETER;
2095 tts_client_s* client = tts_client_get(tts);
2097 if (NULL == client) {
2098 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2099 return TTS_ERROR_INVALID_PARAMETER;
2102 if (TTS_STATE_CREATED != client->current_state) {
2103 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2104 return TTS_ERROR_INVALID_STATE;
2107 client->utt_completeted_cb = callback;
2108 client->utt_completed_user_data = user_data;
2110 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2115 int tts_unset_utterance_completed_cb(tts_h tts)
2117 if (0 != __tts_get_feature_enabled()) {
2118 return TTS_ERROR_NOT_SUPPORTED;
2122 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2123 return TTS_ERROR_INVALID_PARAMETER;
2126 tts_client_s* client = tts_client_get(tts);
2128 if (NULL == client) {
2129 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2130 return TTS_ERROR_INVALID_PARAMETER;
2133 if (TTS_STATE_CREATED != client->current_state) {
2134 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2135 return TTS_ERROR_INVALID_STATE;
2138 client->utt_completeted_cb = NULL;
2139 client->utt_completed_user_data = NULL;
2141 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2145 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2147 if (0 != __tts_get_feature_enabled()) {
2148 return TTS_ERROR_NOT_SUPPORTED;
2151 if (NULL == tts || NULL == callback) {
2152 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2153 return TTS_ERROR_INVALID_PARAMETER;
2156 tts_client_s* client = tts_client_get(tts);
2158 if (NULL == client) {
2159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2160 return TTS_ERROR_INVALID_PARAMETER;
2163 if (TTS_STATE_CREATED != client->current_state) {
2164 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2165 return TTS_ERROR_INVALID_STATE;
2168 client->error_cb = callback;
2169 client->error_user_data = user_data;
2171 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2176 int tts_unset_error_cb(tts_h tts)
2178 if (0 != __tts_get_feature_enabled()) {
2179 return TTS_ERROR_NOT_SUPPORTED;
2183 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2184 return TTS_ERROR_INVALID_PARAMETER;
2187 tts_client_s* client = tts_client_get(tts);
2189 if (NULL == client) {
2190 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2191 return TTS_ERROR_INVALID_PARAMETER;
2194 if (TTS_STATE_CREATED != client->current_state) {
2195 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2196 return TTS_ERROR_INVALID_STATE;
2199 client->error_cb = NULL;
2200 client->error_user_data = NULL;
2202 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2207 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2209 if (0 != __tts_get_feature_enabled()) {
2210 return TTS_ERROR_NOT_SUPPORTED;
2213 if (NULL == tts || NULL == callback) {
2214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2215 return TTS_ERROR_INVALID_PARAMETER;
2218 tts_client_s* client = tts_client_get(tts);
2220 if (NULL == client) {
2221 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2222 return TTS_ERROR_INVALID_PARAMETER;
2225 if (TTS_STATE_CREATED != client->current_state) {
2226 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2227 return TTS_ERROR_INVALID_STATE;
2230 client->default_voice_changed_cb = callback;
2231 client->default_voice_changed_user_data = user_data;
2233 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2238 int tts_unset_default_voice_changed_cb(tts_h tts)
2240 if (0 != __tts_get_feature_enabled()) {
2241 return TTS_ERROR_NOT_SUPPORTED;
2245 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2246 return TTS_ERROR_INVALID_PARAMETER;
2249 tts_client_s* client = tts_client_get(tts);
2251 if (NULL == client) {
2252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2253 return TTS_ERROR_INVALID_PARAMETER;
2256 if (TTS_STATE_CREATED != client->current_state) {
2257 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2258 return TTS_ERROR_INVALID_STATE;
2261 client->default_voice_changed_cb = NULL;
2262 client->default_voice_changed_user_data = NULL;
2264 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2269 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2271 if (0 != __tts_get_feature_enabled()) {
2272 return TTS_ERROR_NOT_SUPPORTED;
2275 if (NULL == tts || NULL == callback) {
2276 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2277 return TTS_ERROR_INVALID_PARAMETER;
2280 tts_client_s* client = tts_client_get(tts);
2282 if (NULL == client) {
2283 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2284 return TTS_ERROR_INVALID_PARAMETER;
2287 if (TTS_STATE_CREATED != client->current_state) {
2288 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2289 return TTS_ERROR_INVALID_STATE;
2292 client->engine_changed_cb = callback;
2293 client->engine_changed_user_data = user_data;
2295 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2300 int tts_unset_engine_changed_cb(tts_h tts)
2302 if (0 != __tts_get_feature_enabled()) {
2303 return TTS_ERROR_NOT_SUPPORTED;
2307 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2308 return TTS_ERROR_INVALID_PARAMETER;
2311 tts_client_s* client = tts_client_get(tts);
2313 if (NULL == client) {
2314 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2315 return TTS_ERROR_INVALID_PARAMETER;
2318 if (TTS_STATE_CREATED != client->current_state) {
2319 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2320 return TTS_ERROR_INVALID_STATE;
2323 client->engine_changed_cb = NULL;
2324 client->engine_changed_user_data = NULL;
2326 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2331 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2333 if (0 != __tts_get_feature_enabled()) {
2334 return TTS_ERROR_NOT_SUPPORTED;
2337 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2340 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2341 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2342 return TTS_ERROR_INVALID_PARAMETER;
2345 tts_client_s* client = tts_client_get(tts);
2347 if (NULL == client) {
2348 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2349 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2350 return TTS_ERROR_INVALID_PARAMETER;
2353 if (TTS_STATE_PLAYING != client->current_state) {
2354 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2355 return TTS_ERROR_INVALID_STATE;
2358 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2359 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2360 return TTS_ERROR_INVALID_STATE;
2366 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2368 if (TTS_ERROR_TIMED_OUT != ret) {
2369 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2372 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2375 if (TTS_RETRY_COUNT == count) {
2376 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2383 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2385 return TTS_ERROR_NONE;
2388 int tts_play_pcm(tts_h tts)
2390 if (0 != __tts_get_feature_enabled()) {
2391 return TTS_ERROR_NOT_SUPPORTED;
2394 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2397 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2398 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2399 return TTS_ERROR_INVALID_PARAMETER;
2402 tts_client_s* client = tts_client_get(tts);
2404 if (NULL == client) {
2405 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2406 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2407 return TTS_ERROR_INVALID_PARAMETER;
2410 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2411 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2412 return TTS_ERROR_INVALID_STATE;
2415 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2416 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2417 return TTS_ERROR_INVALID_STATE;
2423 ret = tts_dbus_request_play_pcm(client->uid);
2425 if (TTS_ERROR_TIMED_OUT != ret) {
2426 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2429 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2432 if (TTS_RETRY_COUNT == count) {
2433 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2440 client->before_state = client->current_state;
2441 client->current_state = TTS_STATE_PLAYING;
2443 if (NULL != client->state_changed_cb) {
2444 tts_client_use_callback(client);
2445 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2446 tts_client_not_use_callback(client);
2447 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2450 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2452 return TTS_ERROR_NONE;
2455 int tts_stop_pcm(tts_h tts)
2457 if (0 != __tts_get_feature_enabled()) {
2458 return TTS_ERROR_NOT_SUPPORTED;
2461 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2465 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2466 return TTS_ERROR_INVALID_PARAMETER;
2469 tts_client_s* client = tts_client_get(tts);
2471 if (NULL == client) {
2472 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2473 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2474 return TTS_ERROR_INVALID_PARAMETER;
2477 if (TTS_STATE_PLAYING != client->current_state) {
2478 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2479 return TTS_ERROR_INVALID_STATE;
2482 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2483 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2484 return TTS_ERROR_INVALID_STATE;
2490 ret = tts_dbus_request_stop_pcm(client->uid);
2492 if (TTS_ERROR_TIMED_OUT != ret) {
2493 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2496 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2499 if (TTS_RETRY_COUNT == count) {
2500 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2507 client->before_state = client->current_state;
2508 client->current_state = TTS_STATE_READY;
2510 if (NULL != client->state_changed_cb) {
2511 tts_client_use_callback(client);
2512 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2513 tts_client_not_use_callback(client);
2514 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2517 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2519 return TTS_ERROR_NONE;