2 * Copyright (c) 2011-2014 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.
18 #include <sys/types.h>
20 #include <system_info.h>
24 #include "tts_client.h"
25 #include "tts_config_mgr.h"
30 static bool g_screen_reader;
32 static int g_feature_enabled = -1;
34 /* Function definition */
35 static Eina_Bool __tts_notify_state_changed(void *data);
36 static Eina_Bool __tts_notify_error(void *data);
43 static int __tts_get_feature_enabled()
45 if (0 == g_feature_enabled) {
46 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
47 return TTS_ERROR_NOT_SUPPORTED;
48 } else if (-1 == g_feature_enabled) {
49 bool tts_supported = false;
50 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
51 if (false == tts_supported) {
52 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
53 g_feature_enabled = 0;
54 return TTS_ERROR_NOT_SUPPORTED;
57 g_feature_enabled = 1;
59 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
60 return TTS_ERROR_NOT_SUPPORTED;
67 static const char* __tts_get_error_code(tts_error_e err)
70 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
71 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
72 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
73 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
74 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
75 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
76 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
77 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
78 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
79 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
80 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
81 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
82 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
84 return "Invalid error code";
89 static int __tts_convert_config_error_code(tts_config_error_e code)
91 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
92 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
93 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
94 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
95 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
96 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
97 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
98 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
99 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_OPERATION_FAILED;
104 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)
106 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
107 before_lang, before_voice_type, language, voice_type);
109 GList* client_list = NULL;
110 client_list = tts_client_get_client_list();
113 tts_client_s *data = NULL;
115 if (g_list_length(client_list) > 0) {
116 /* Get a first item */
117 iter = g_list_first(client_list);
119 while (NULL != iter) {
121 if (NULL != data->default_voice_changed_cb) {
122 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
123 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
124 language, voice_type, data->default_voice_changed_user_data);
128 iter = g_list_next(iter);
135 int tts_create(tts_h* tts)
137 if (0 != __tts_get_feature_enabled()) {
138 return TTS_ERROR_NOT_SUPPORTED;
141 SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
145 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
146 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
147 SLOG(LOG_DEBUG, TAG_TTSC, " ");
148 return TTS_ERROR_INVALID_PARAMETER;
151 if (0 == tts_client_get_size()) {
152 if (0 != tts_dbus_open_connection()) {
153 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
154 return TTS_ERROR_OPERATION_FAILED;
158 if (0 != tts_client_new(tts)) {
159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
160 return TTS_ERROR_OUT_OF_MEMORY;
163 tts_client_s* client = tts_client_get(*tts);
164 if (NULL == client) {
165 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
166 return TTS_ERROR_OPERATION_FAILED;
169 int ret = tts_config_mgr_initialize(client->uid);
171 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
172 tts_client_destroy(*tts);
173 return __tts_convert_config_error_code(ret);
176 ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
178 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
179 tts_client_destroy(*tts);
180 return __tts_convert_config_error_code(ret);
183 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
184 SLOG(LOG_DEBUG, TAG_TTSC, " ");
186 return TTS_ERROR_NONE;
189 int tts_destroy(tts_h tts)
191 if (0 != __tts_get_feature_enabled()) {
192 return TTS_ERROR_NOT_SUPPORTED;
195 SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
199 return TTS_ERROR_INVALID_PARAMETER;
202 tts_client_s* client = tts_client_get(tts);
205 if (NULL == client) {
206 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
207 return TTS_ERROR_INVALID_PARAMETER;
210 /* check used callback */
211 if (0 != tts_client_get_use_callback(client)) {
212 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
213 return TTS_ERROR_OPERATION_FAILED;
216 tts_config_mgr_finalize(client->uid);
222 switch (client->current_state) {
223 case TTS_STATE_PAUSED:
224 case TTS_STATE_PLAYING:
225 case TTS_STATE_READY:
226 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
228 ret = tts_dbus_request_finalize(client->uid);
230 if (TTS_ERROR_TIMED_OUT != ret) {
231 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
234 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
237 if (TTS_RETRY_COUNT == count) {
238 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
245 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
248 client->before_state = client->current_state;
249 client->current_state = TTS_STATE_CREATED;
251 case TTS_STATE_CREATED:
252 if (NULL != client->conn_timer) {
253 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
254 ecore_timer_del(client->conn_timer);
255 client->conn_timer = NULL;
258 tts_client_destroy(tts);
265 if (0 == tts_client_get_size()) {
266 if (0 != tts_dbus_close_connection()) {
267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
273 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
274 SLOG(LOG_DEBUG, TAG_TTSC, " ");
276 return TTS_ERROR_NONE;
279 void __tts_screen_reader_changed_cb(bool value)
281 g_screen_reader = value;
284 int tts_set_mode(tts_h tts, tts_mode_e mode)
286 if (0 != __tts_get_feature_enabled()) {
287 return TTS_ERROR_NOT_SUPPORTED;
290 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
292 tts_client_s* client = tts_client_get(tts);
295 if (NULL == client) {
296 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
297 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
298 SLOG(LOG_DEBUG, TAG_TTSC, " ");
299 return TTS_ERROR_INVALID_PARAMETER;
303 if (client->current_state != TTS_STATE_CREATED) {
304 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
305 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
306 SLOG(LOG_DEBUG, TAG_TTSC, " ");
307 return TTS_ERROR_INVALID_STATE;
310 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
313 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
314 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
315 SLOG(LOG_DEBUG, TAG_TTSC, " ");
316 return TTS_ERROR_INVALID_PARAMETER;
319 if (TTS_MODE_SCREEN_READER == mode) {
322 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
324 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
325 return TTS_ERROR_OPERATION_FAILED;
327 g_screen_reader = (bool)screen_reader;
328 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
330 tts_config_unset_screen_reader_callback(client->uid);
333 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
334 SLOG(LOG_DEBUG, TAG_TTSC, " ");
336 return TTS_ERROR_NONE;
339 int tts_get_mode(tts_h tts, tts_mode_e* mode)
341 if (0 != __tts_get_feature_enabled()) {
342 return TTS_ERROR_NOT_SUPPORTED;
345 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
347 tts_client_s* client = tts_client_get(tts);
350 if (NULL == client) {
351 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
352 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
353 SLOG(LOG_DEBUG, TAG_TTSC, " ");
354 return TTS_ERROR_INVALID_PARAMETER;
358 if (client->current_state != TTS_STATE_CREATED) {
359 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
360 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
361 SLOG(LOG_DEBUG, TAG_TTSC, " ");
362 return TTS_ERROR_INVALID_STATE;
366 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
367 return TTS_ERROR_INVALID_PARAMETER;
370 *mode = client->mode;
372 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
373 SLOG(LOG_DEBUG, TAG_TTSC, " ");
375 return TTS_ERROR_NONE;
378 static Eina_Bool __tts_connect_daemon(void *data)
380 tts_h tts = (tts_h)data;
381 tts_client_s* client = tts_client_get(tts);
384 if (NULL == client) {
385 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
390 if (0 != tts_dbus_request_hello(client->uid)) {
394 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
396 /* do request initialize */
398 ret = tts_dbus_request_initialize(client->uid);
400 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
401 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
403 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
406 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
407 client->conn_timer = NULL;
410 } else if (TTS_ERROR_NONE != ret) {
411 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
415 /* success to connect tts-daemon */
418 client->conn_timer = NULL;
420 client = tts_client_get(tts);
422 if (NULL == client) {
423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
427 client->before_state = client->current_state;
428 client->current_state = TTS_STATE_READY;
430 if (NULL != client->state_changed_cb) {
431 tts_client_use_callback(client);
432 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
433 tts_client_not_use_callback(client);
435 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
438 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
439 SLOG(LOG_DEBUG, TAG_TTSC, " ");
444 int tts_prepare(tts_h tts)
446 if (0 != __tts_get_feature_enabled()) {
447 return TTS_ERROR_NOT_SUPPORTED;
450 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
452 tts_client_s* client = tts_client_get(tts);
455 if (NULL == client) {
456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
457 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
458 SLOG(LOG_DEBUG, TAG_TTSC, " ");
459 return TTS_ERROR_INVALID_PARAMETER;
463 if (client->current_state != TTS_STATE_CREATED) {
464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
465 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
466 SLOG(LOG_DEBUG, TAG_TTSC, " ");
467 return TTS_ERROR_INVALID_STATE;
470 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
472 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
473 SLOG(LOG_DEBUG, TAG_TTSC, " ");
475 return TTS_ERROR_NONE;
478 int tts_unprepare(tts_h tts)
480 if (0 != __tts_get_feature_enabled()) {
481 return TTS_ERROR_NOT_SUPPORTED;
484 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
486 tts_client_s* client = tts_client_get(tts);
489 if (NULL == client) {
490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
491 return TTS_ERROR_INVALID_PARAMETER;
495 if (client->current_state != TTS_STATE_READY) {
496 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
497 return TTS_ERROR_INVALID_STATE;
502 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
504 ret = tts_dbus_request_finalize(client->uid);
506 if (TTS_ERROR_TIMED_OUT != ret) {
507 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
510 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
513 if (TTS_RETRY_COUNT == count) {
514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
521 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
524 client->before_state = client->current_state;
525 client->current_state = TTS_STATE_CREATED;
527 if (NULL != client->state_changed_cb) {
528 tts_client_use_callback(client);
529 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
530 tts_client_not_use_callback(client);
531 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
534 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
535 SLOG(LOG_DEBUG, TAG_TTSC, " ");
537 return TTS_ERROR_NONE;
540 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
542 tts_h tts = (tts_h)user_data;
544 tts_client_s* client = tts_client_get(tts);
545 if (NULL == client) {
546 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
550 /* call callback function */
551 if (NULL != client->supported_voice_cb) {
552 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
554 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
560 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
562 if (0 != __tts_get_feature_enabled()) {
563 return TTS_ERROR_NOT_SUPPORTED;
566 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
568 if (NULL == tts || NULL == callback) {
569 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
570 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
571 SLOG(LOG_DEBUG, TAG_TTSC, " ");
572 return TTS_ERROR_INVALID_PARAMETER;
575 tts_client_s* client = tts_client_get(tts);
578 if (NULL == client) {
579 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
580 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
581 SLOG(LOG_DEBUG, TAG_TTSC, " ");
582 return TTS_ERROR_INVALID_PARAMETER;
586 char* current_engine = NULL;
587 ret = tts_config_mgr_get_engine(¤t_engine);
589 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
590 return __tts_convert_config_error_code(ret);
593 client->supported_voice_cb = callback;
594 client->supported_voice_user_data = user_data;
596 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
598 if (NULL != current_engine)
599 free(current_engine);
601 client->supported_voice_cb = NULL;
602 client->supported_voice_user_data = NULL;
605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
606 ret = TTS_ERROR_OPERATION_FAILED;
609 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
610 SLOG(LOG_DEBUG, TAG_TTSC, " ");
615 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
617 if (0 != __tts_get_feature_enabled()) {
618 return TTS_ERROR_NOT_SUPPORTED;
621 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
624 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
625 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
626 SLOG(LOG_DEBUG, TAG_TTSC, " ");
627 return TTS_ERROR_INVALID_PARAMETER;
630 tts_client_s* client = tts_client_get(tts);
632 if (NULL == client) {
633 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
634 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
635 SLOG(LOG_DEBUG, TAG_TTSC, " ");
636 return TTS_ERROR_INVALID_PARAMETER;
639 /* Request call remote method */
641 ret = tts_config_mgr_get_voice(lang, vctype);
643 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
644 return __tts_convert_config_error_code(ret);
646 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
649 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
650 SLOG(LOG_DEBUG, TAG_TTSC, " ");
655 int tts_get_max_text_size(tts_h tts, unsigned int* size)
657 if (0 != __tts_get_feature_enabled()) {
658 return TTS_ERROR_NOT_SUPPORTED;
661 if (NULL == tts || NULL == size) {
662 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
663 return TTS_ERROR_INVALID_PARAMETER;
666 tts_client_s* client = tts_client_get(tts);
668 if (NULL == client) {
669 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
670 return TTS_ERROR_INVALID_PARAMETER;
673 if (TTS_STATE_READY != client->current_state) {
674 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
675 return TTS_ERROR_INVALID_STATE;
678 *size = TTS_MAX_TEXT_SIZE;
680 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
681 return TTS_ERROR_NONE;
684 int tts_get_state(tts_h tts, tts_state_e* state)
686 if (0 != __tts_get_feature_enabled()) {
687 return TTS_ERROR_NOT_SUPPORTED;
690 if (NULL == tts || NULL == state) {
691 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
692 return TTS_ERROR_INVALID_PARAMETER;
695 tts_client_s* client = tts_client_get(tts);
697 if (NULL == client) {
698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
699 return TTS_ERROR_INVALID_PARAMETER;
702 *state = client->current_state;
705 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
706 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
707 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
708 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
709 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
712 return TTS_ERROR_NONE;
715 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
717 if (0 != __tts_get_feature_enabled()) {
718 return TTS_ERROR_NOT_SUPPORTED;
721 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
722 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
723 return TTS_ERROR_INVALID_PARAMETER;
726 tts_client_s* client = tts_client_get(tts);
728 if (NULL == client) {
729 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
730 return TTS_ERROR_INVALID_PARAMETER;
733 *min = TTS_SPEED_MIN;
734 *normal = TTS_SPEED_NORMAL;
735 *max = TTS_SPEED_MAX;
737 return TTS_ERROR_NONE;
740 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
742 if (0 != __tts_get_feature_enabled()) {
743 return TTS_ERROR_NOT_SUPPORTED;
747 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
748 return TTS_ERROR_INVALID_PARAMETER;
751 if (voice_type < 0) {
752 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
753 return TTS_ERROR_INVALID_PARAMETER;
756 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
758 if (NULL == tts || NULL == utt_id) {
759 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
760 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
761 SLOG(LOG_DEBUG, TAG_TTSC, " ");
762 return TTS_ERROR_INVALID_PARAMETER;
765 tts_client_s* client = tts_client_get(tts);
767 if (NULL == client) {
768 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
769 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
770 SLOG(LOG_DEBUG, TAG_TTSC, " ");
771 return TTS_ERROR_INVALID_PARAMETER;
774 if (TTS_STATE_CREATED == client->current_state) {
775 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
776 return TTS_ERROR_INVALID_STATE;
779 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
780 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
781 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
782 SLOG(LOG_DEBUG, TAG_TTSC, " ");
783 return TTS_ERROR_INVALID_PARAMETER;
786 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
787 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
788 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
789 SLOG(LOG_DEBUG, TAG_TTSC, " ");
790 return TTS_ERROR_INVALID_PARAMETER;
793 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
794 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
795 return TTS_ERROR_INVALID_STATE;
798 /* check valid utf8 */
800 ict = iconv_open("utf-8", "");
801 if ((iconv_t)-1 == ict) {
802 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
803 return TTS_ERROR_OPERATION_FAILED;
806 size_t len = strlen(text);
808 char in_buf[TTS_MAX_TEXT_SIZE];
809 char *out_tmp = NULL;
810 char out_buf[TTS_MAX_TEXT_SIZE];
811 size_t len_tmp = sizeof(out_buf);
813 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
814 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
817 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
821 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
822 if ((size_t)-1 == st) {
823 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
825 return TTS_ERROR_INVALID_PARAMETER;
828 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
830 /* change default language value */
833 if (NULL == language)
834 temp = strdup("default");
836 temp = strdup(language);
838 client->current_utt_id++;
839 if (client->current_utt_id == 10000) {
840 client->current_utt_id = 1;
847 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id);
849 if (TTS_ERROR_TIMED_OUT != ret) {
850 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
853 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
856 if (TTS_RETRY_COUNT == count) {
857 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
862 *utt_id = client->current_utt_id;
866 if (NULL != temp) free(temp);
868 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
869 SLOG(LOG_DEBUG, TAG_TTSC, " ");
874 static void __tts_play_async(void *data)
876 tts_h tts = (tts_h)data;
877 tts_client_s* client = tts_client_get(tts);
880 if (NULL == client) {
881 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
888 ret = tts_dbus_request_play(client->uid);
890 if (TTS_ERROR_TIMED_OUT != ret) {
891 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
894 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
897 if (TTS_RETRY_COUNT == count) {
898 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
906 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
908 client->reason = ret;
911 ecore_timer_add(0, __tts_notify_error, client->tts);
915 client->before_state = client->current_state;
916 client->current_state = TTS_STATE_PLAYING;
918 if (NULL != client->state_changed_cb) {
919 tts_client_use_callback(client);
920 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
921 tts_client_not_use_callback(client);
922 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
925 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
926 SLOG(LOG_DEBUG, TAG_TTSC, " ");
931 int tts_play_async(tts_h tts)
933 if (0 != __tts_get_feature_enabled()) {
934 return TTS_ERROR_NOT_SUPPORTED;
937 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
940 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
941 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
942 SLOG(LOG_DEBUG, TAG_TTSC, " ");
943 return TTS_ERROR_INVALID_PARAMETER;
946 tts_client_s* client = tts_client_get(tts);
948 if (NULL == client) {
949 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
950 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
951 SLOG(LOG_DEBUG, TAG_TTSC, " ");
952 return TTS_ERROR_INVALID_PARAMETER;
955 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
956 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
957 return TTS_ERROR_INVALID_STATE;
960 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
961 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
962 return TTS_ERROR_INVALID_STATE;
965 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
967 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
968 SLOG(LOG_DEBUG, TAG_TTSC, " ");
970 return TTS_ERROR_NONE;
973 int tts_play(tts_h tts)
975 if (0 != __tts_get_feature_enabled()) {
976 return TTS_ERROR_NOT_SUPPORTED;
979 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
982 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
983 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
984 SLOG(LOG_DEBUG, TAG_TTSC, " ");
985 return TTS_ERROR_INVALID_PARAMETER;
988 tts_client_s* client = tts_client_get(tts);
990 if (NULL == client) {
991 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
992 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
993 SLOG(LOG_DEBUG, TAG_TTSC, " ");
994 return TTS_ERROR_INVALID_PARAMETER;
997 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
998 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
999 return TTS_ERROR_INVALID_STATE;
1002 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1003 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1004 return TTS_ERROR_INVALID_STATE;
1010 ret = tts_dbus_request_play(client->uid);
1012 if (TTS_ERROR_TIMED_OUT != ret) {
1013 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1016 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1019 if (TTS_RETRY_COUNT == count) {
1020 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1027 client->before_state = client->current_state;
1028 client->current_state = TTS_STATE_PLAYING;
1030 if (NULL != client->state_changed_cb) {
1031 tts_client_use_callback(client);
1032 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1033 tts_client_not_use_callback(client);
1034 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1037 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1038 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1040 return TTS_ERROR_NONE;
1043 static void __tts_stop_async(void *data)
1045 tts_h tts = (tts_h)data;
1046 tts_client_s* client = tts_client_get(tts);
1049 if (NULL == client) {
1050 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1057 ret = tts_dbus_request_stop(client->uid);
1059 if (TTS_ERROR_TIMED_OUT != ret) {
1060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1063 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1066 if (TTS_RETRY_COUNT == count) {
1067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1077 client->reason = ret;
1078 client->utt_id = -1;
1080 ecore_timer_add(0, __tts_notify_error, client->tts);
1084 client->before_state = client->current_state;
1085 client->current_state = TTS_STATE_READY;
1087 if (NULL != client->state_changed_cb) {
1088 tts_client_use_callback(client);
1089 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1090 tts_client_not_use_callback(client);
1091 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1094 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1095 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1100 int tts_stop_aync(tts_h tts)
1102 if (0 != __tts_get_feature_enabled()) {
1103 return TTS_ERROR_NOT_SUPPORTED;
1106 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1109 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1110 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1111 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1112 return TTS_ERROR_INVALID_PARAMETER;
1115 tts_client_s* client = tts_client_get(tts);
1117 if (NULL == client) {
1118 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1119 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1120 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1121 return TTS_ERROR_INVALID_PARAMETER;
1124 if (TTS_STATE_CREATED == client->current_state) {
1125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1126 return TTS_ERROR_INVALID_STATE;
1129 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1130 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1131 return TTS_ERROR_INVALID_STATE;
1134 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1136 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1137 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1139 return TTS_ERROR_NONE;
1142 int tts_stop(tts_h tts)
1144 if (0 != __tts_get_feature_enabled()) {
1145 return TTS_ERROR_NOT_SUPPORTED;
1148 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1151 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1152 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1153 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1154 return TTS_ERROR_INVALID_PARAMETER;
1157 tts_client_s* client = tts_client_get(tts);
1159 if (NULL == client) {
1160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1161 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1162 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1163 return TTS_ERROR_INVALID_PARAMETER;
1166 if (TTS_STATE_CREATED == client->current_state) {
1167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1168 return TTS_ERROR_INVALID_STATE;
1171 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1172 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1173 return TTS_ERROR_INVALID_STATE;
1179 ret = tts_dbus_request_stop(client->uid);
1181 if (TTS_ERROR_TIMED_OUT != ret) {
1182 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1185 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1188 if (TTS_RETRY_COUNT == count) {
1189 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1196 client->before_state = client->current_state;
1197 client->current_state = TTS_STATE_READY;
1199 if (NULL != client->state_changed_cb) {
1200 tts_client_use_callback(client);
1201 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1202 tts_client_not_use_callback(client);
1203 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1206 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1207 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1209 return TTS_ERROR_NONE;
1212 static void __tts_pause_async(void *data)
1214 tts_h tts = (tts_h)data;
1215 tts_client_s* client = tts_client_get(tts);
1218 if (NULL == client) {
1219 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1226 ret = tts_dbus_request_pause(client->uid);
1228 if (TTS_ERROR_TIMED_OUT != ret) {
1229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1232 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1235 if (TTS_RETRY_COUNT == count) {
1236 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1244 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1246 client->reason = ret;
1247 client->utt_id = -1;
1249 ecore_timer_add(0, __tts_notify_error, client->tts);
1253 client->before_state = client->current_state;
1254 client->current_state = TTS_STATE_PAUSED;
1256 if (NULL != client->state_changed_cb) {
1257 tts_client_use_callback(client);
1258 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1259 tts_client_not_use_callback(client);
1260 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1263 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1264 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1269 int tts_pause_async(tts_h tts)
1271 if (0 != __tts_get_feature_enabled()) {
1272 return TTS_ERROR_NOT_SUPPORTED;
1275 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1278 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1279 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1280 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1281 return TTS_ERROR_INVALID_PARAMETER;
1284 tts_client_s* client = tts_client_get(tts);
1286 if (NULL == client) {
1287 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1288 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1289 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1290 return TTS_ERROR_INVALID_PARAMETER;
1293 if (TTS_STATE_PLAYING != client->current_state) {
1294 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1295 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1296 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1297 return TTS_ERROR_INVALID_STATE;
1300 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1301 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1302 return TTS_ERROR_INVALID_STATE;
1305 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1307 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1308 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1310 return TTS_ERROR_NONE;
1313 int tts_pause(tts_h tts)
1315 if (0 != __tts_get_feature_enabled()) {
1316 return TTS_ERROR_NOT_SUPPORTED;
1319 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1322 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1323 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1324 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1325 return TTS_ERROR_INVALID_PARAMETER;
1328 tts_client_s* client = tts_client_get(tts);
1330 if (NULL == client) {
1331 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1332 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1333 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1334 return TTS_ERROR_INVALID_PARAMETER;
1337 if (TTS_STATE_PLAYING != client->current_state) {
1338 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1339 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1340 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1341 return TTS_ERROR_INVALID_STATE;
1344 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1345 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1346 return TTS_ERROR_INVALID_STATE;
1352 ret = tts_dbus_request_pause(client->uid);
1354 if (TTS_ERROR_TIMED_OUT != ret) {
1355 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1358 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1361 if (TTS_RETRY_COUNT == count) {
1362 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1369 client->before_state = client->current_state;
1370 client->current_state = TTS_STATE_PAUSED;
1372 if (NULL != client->state_changed_cb) {
1373 tts_client_use_callback(client);
1374 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1375 tts_client_not_use_callback(client);
1376 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1379 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1380 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1382 return TTS_ERROR_NONE;
1385 static Eina_Bool __tts_notify_error(void *data)
1387 tts_h tts = (tts_h)data;
1389 tts_client_s* client = tts_client_get(tts);
1392 if (NULL == client) {
1393 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1397 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1399 if (NULL != client->error_cb) {
1400 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1401 tts_client_use_callback(client);
1402 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1403 tts_client_not_use_callback(client);
1405 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1411 int __tts_cb_error(int uid, tts_error_e reason, int utt_id)
1413 tts_client_s* client = tts_client_get_by_uid(uid);
1415 if (NULL == client) {
1416 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1417 return TTS_ERROR_INVALID_PARAMETER;
1420 client->utt_id = utt_id;
1421 client->reason = reason;
1423 /* call callback function */
1424 if (NULL != client->error_cb) {
1425 ecore_timer_add(0, __tts_notify_error, client->tts);
1427 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1433 static Eina_Bool __tts_notify_state_changed(void *data)
1435 tts_h tts = (tts_h)data;
1437 tts_client_s* client = tts_client_get(tts);
1440 if (NULL == client) {
1441 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1445 if (NULL != client->state_changed_cb) {
1446 tts_client_use_callback(client);
1447 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1448 tts_client_not_use_callback(client);
1449 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1451 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1457 int __tts_cb_set_state(int uid, int state)
1459 tts_client_s* client = tts_client_get_by_uid(uid);
1460 if (NULL == client) {
1461 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1465 tts_state_e state_from_daemon = (tts_state_e)state;
1467 if (client->current_state == state_from_daemon) {
1468 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1472 if (NULL != client->state_changed_cb) {
1473 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1475 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1478 client->before_state = client->current_state;
1479 client->current_state = state_from_daemon;
1484 int __tts_cb_utt_started(int uid, int utt_id)
1486 tts_client_s* client = tts_client_get_by_uid(uid);
1488 if (NULL == client) {
1489 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1490 return TTS_ERROR_INVALID_PARAMETER;
1493 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1495 client->utt_id = utt_id;
1497 /* call callback function */
1498 if (NULL != client->utt_started_cb) {
1499 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1500 tts_client_use_callback(client);
1501 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1502 tts_client_not_use_callback(client);
1504 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1510 int __tts_cb_utt_completed(int uid, int utt_id)
1512 tts_client_s* client = tts_client_get_by_uid(uid);
1514 if (NULL == client) {
1515 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1516 return TTS_ERROR_INVALID_PARAMETER;
1519 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1521 client->utt_id = utt_id;
1523 /* call callback function */
1524 if (NULL != client->utt_completeted_cb) {
1525 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1526 tts_client_use_callback(client);
1527 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1528 tts_client_not_use_callback(client);
1530 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1536 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1538 if (0 != __tts_get_feature_enabled()) {
1539 return TTS_ERROR_NOT_SUPPORTED;
1542 if (NULL == tts || NULL == callback) {
1543 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1544 return TTS_ERROR_INVALID_PARAMETER;
1547 tts_client_s* client = tts_client_get(tts);
1549 if (NULL == client) {
1550 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1551 return TTS_ERROR_INVALID_PARAMETER;
1554 if (TTS_STATE_CREATED != client->current_state) {
1555 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1556 return TTS_ERROR_INVALID_STATE;
1559 client->state_changed_cb = callback;
1560 client->state_changed_user_data = user_data;
1562 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1567 int tts_unset_state_changed_cb(tts_h tts)
1569 if (0 != __tts_get_feature_enabled()) {
1570 return TTS_ERROR_NOT_SUPPORTED;
1574 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1575 return TTS_ERROR_INVALID_PARAMETER;
1578 tts_client_s* client = tts_client_get(tts);
1580 if (NULL == client) {
1581 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1582 return TTS_ERROR_INVALID_PARAMETER;
1585 if (TTS_STATE_CREATED != client->current_state) {
1586 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1587 return TTS_ERROR_INVALID_STATE;
1590 client->state_changed_cb = NULL;
1591 client->state_changed_user_data = NULL;
1593 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1598 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1600 if (0 != __tts_get_feature_enabled()) {
1601 return TTS_ERROR_NOT_SUPPORTED;
1604 if (NULL == tts || NULL == callback) {
1605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1606 return TTS_ERROR_INVALID_PARAMETER;
1609 tts_client_s* client = tts_client_get(tts);
1611 if (NULL == client) {
1612 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1613 return TTS_ERROR_INVALID_PARAMETER;
1616 if (TTS_STATE_CREATED != client->current_state) {
1617 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1618 return TTS_ERROR_INVALID_STATE;
1621 client->utt_started_cb = callback;
1622 client->utt_started_user_data = user_data;
1624 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1629 int tts_unset_utterance_started_cb(tts_h tts)
1631 if (0 != __tts_get_feature_enabled()) {
1632 return TTS_ERROR_NOT_SUPPORTED;
1636 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1637 return TTS_ERROR_INVALID_PARAMETER;
1640 tts_client_s* client = tts_client_get(tts);
1642 if (NULL == client) {
1643 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1644 return TTS_ERROR_INVALID_PARAMETER;
1647 if (TTS_STATE_CREATED != client->current_state) {
1648 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1649 return TTS_ERROR_INVALID_STATE;
1652 client->utt_started_cb = NULL;
1653 client->utt_started_user_data = NULL;
1655 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1660 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1662 if (0 != __tts_get_feature_enabled()) {
1663 return TTS_ERROR_NOT_SUPPORTED;
1666 if (NULL == tts || NULL == callback) {
1667 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1668 return TTS_ERROR_INVALID_PARAMETER;
1671 tts_client_s* client = tts_client_get(tts);
1673 if (NULL == client) {
1674 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1675 return TTS_ERROR_INVALID_PARAMETER;
1678 if (TTS_STATE_CREATED != client->current_state) {
1679 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1680 return TTS_ERROR_INVALID_STATE;
1683 client->utt_completeted_cb = callback;
1684 client->utt_completed_user_data = user_data;
1686 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1691 int tts_unset_utterance_completed_cb(tts_h tts)
1693 if (0 != __tts_get_feature_enabled()) {
1694 return TTS_ERROR_NOT_SUPPORTED;
1698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1699 return TTS_ERROR_INVALID_PARAMETER;
1702 tts_client_s* client = tts_client_get(tts);
1704 if (NULL == client) {
1705 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1706 return TTS_ERROR_INVALID_PARAMETER;
1709 if (TTS_STATE_CREATED != client->current_state) {
1710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1711 return TTS_ERROR_INVALID_STATE;
1714 client->utt_completeted_cb = NULL;
1715 client->utt_completed_user_data = NULL;
1717 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1721 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1723 if (0 != __tts_get_feature_enabled()) {
1724 return TTS_ERROR_NOT_SUPPORTED;
1727 if (NULL == tts || NULL == callback) {
1728 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1729 return TTS_ERROR_INVALID_PARAMETER;
1732 tts_client_s* client = tts_client_get(tts);
1734 if (NULL == client) {
1735 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1736 return TTS_ERROR_INVALID_PARAMETER;
1739 if (TTS_STATE_CREATED != client->current_state) {
1740 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1741 return TTS_ERROR_INVALID_STATE;
1744 client->error_cb = callback;
1745 client->error_user_data = user_data;
1747 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1752 int tts_unset_error_cb(tts_h tts)
1754 if (0 != __tts_get_feature_enabled()) {
1755 return TTS_ERROR_NOT_SUPPORTED;
1759 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1760 return TTS_ERROR_INVALID_PARAMETER;
1763 tts_client_s* client = tts_client_get(tts);
1765 if (NULL == client) {
1766 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1767 return TTS_ERROR_INVALID_PARAMETER;
1770 if (TTS_STATE_CREATED != client->current_state) {
1771 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1772 return TTS_ERROR_INVALID_STATE;
1775 client->error_cb = NULL;
1776 client->error_user_data = NULL;
1778 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1783 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1785 if (0 != __tts_get_feature_enabled()) {
1786 return TTS_ERROR_NOT_SUPPORTED;
1789 if (NULL == tts || NULL == callback) {
1790 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
1791 return TTS_ERROR_INVALID_PARAMETER;
1794 tts_client_s* client = tts_client_get(tts);
1796 if (NULL == client) {
1797 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
1798 return TTS_ERROR_INVALID_PARAMETER;
1801 if (TTS_STATE_CREATED != client->current_state) {
1802 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
1803 return TTS_ERROR_INVALID_STATE;
1806 client->default_voice_changed_cb = callback;
1807 client->default_voice_changed_user_data = user_data;
1809 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
1814 int tts_unset_default_voice_changed_cb(tts_h tts)
1816 if (0 != __tts_get_feature_enabled()) {
1817 return TTS_ERROR_NOT_SUPPORTED;
1821 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
1822 return TTS_ERROR_INVALID_PARAMETER;
1825 tts_client_s* client = tts_client_get(tts);
1827 if (NULL == client) {
1828 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
1829 return TTS_ERROR_INVALID_PARAMETER;
1832 if (TTS_STATE_CREATED != client->current_state) {
1833 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
1834 return TTS_ERROR_INVALID_STATE;
1837 client->default_voice_changed_cb = NULL;
1838 client->default_voice_changed_user_data = NULL;
1840 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");