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 static bool g_err_callback_status = false;
36 /* Function definition */
37 static Eina_Bool __tts_notify_state_changed(void *data);
38 static Eina_Bool __tts_notify_error(void *data);
45 static int __tts_get_feature_enabled()
47 if (0 == g_feature_enabled) {
48 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
49 return TTS_ERROR_NOT_SUPPORTED;
50 } else if (-1 == g_feature_enabled) {
51 bool tts_supported = false;
52 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
53 if (false == tts_supported) {
54 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
55 g_feature_enabled = 0;
56 return TTS_ERROR_NOT_SUPPORTED;
59 g_feature_enabled = 1;
61 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
62 return TTS_ERROR_NOT_SUPPORTED;
69 static const char* __tts_get_error_code(tts_error_e err)
72 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
73 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
74 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
75 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
76 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
77 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
78 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
79 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
80 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
81 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
82 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
83 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
84 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
86 return "Invalid error code";
91 static int __tts_convert_config_error_code(tts_config_error_e code)
93 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
94 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
95 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
96 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
97 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
98 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
99 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
100 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
101 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_OPERATION_FAILED;
106 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)
108 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
109 before_lang, before_voice_type, language, voice_type);
111 GList* client_list = NULL;
112 client_list = tts_client_get_client_list();
115 tts_client_s *data = NULL;
117 if (g_list_length(client_list) > 0) {
118 /* Get a first item */
119 iter = g_list_first(client_list);
121 while (NULL != iter) {
123 if (NULL != data->default_voice_changed_cb) {
124 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
125 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
126 language, voice_type, data->default_voice_changed_user_data);
130 iter = g_list_next(iter);
137 int tts_create(tts_h* tts)
139 if (0 != __tts_get_feature_enabled()) {
140 return TTS_ERROR_NOT_SUPPORTED;
143 SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
147 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
148 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
149 SLOG(LOG_DEBUG, TAG_TTSC, " ");
150 return TTS_ERROR_INVALID_PARAMETER;
153 if (0 == tts_client_get_size()) {
154 if (0 != tts_dbus_open_connection()) {
155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
156 return TTS_ERROR_OPERATION_FAILED;
160 if (0 != tts_client_new(tts)) {
161 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
162 return TTS_ERROR_OUT_OF_MEMORY;
165 tts_client_s* client = tts_client_get(*tts);
166 if (NULL == client) {
167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
168 return TTS_ERROR_OPERATION_FAILED;
171 int ret = tts_config_mgr_initialize(client->uid);
173 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
174 tts_client_destroy(*tts);
175 return __tts_convert_config_error_code(ret);
178 ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
181 tts_client_destroy(*tts);
182 return __tts_convert_config_error_code(ret);
185 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
186 SLOG(LOG_DEBUG, TAG_TTSC, " ");
188 return TTS_ERROR_NONE;
191 int tts_destroy(tts_h tts)
193 if (0 != __tts_get_feature_enabled()) {
194 return TTS_ERROR_NOT_SUPPORTED;
197 SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
200 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
201 return TTS_ERROR_INVALID_PARAMETER;
204 tts_client_s* client = tts_client_get(tts);
207 if (NULL == client) {
208 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
209 return TTS_ERROR_INVALID_PARAMETER;
212 /* check used callback */
213 if (0 != tts_client_get_use_callback(client)) {
214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
215 return TTS_ERROR_OPERATION_FAILED;
218 tts_config_mgr_finalize(client->uid);
224 switch (client->current_state) {
225 case TTS_STATE_PAUSED:
226 case TTS_STATE_PLAYING:
227 case TTS_STATE_READY:
228 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
230 ret = tts_dbus_request_finalize(client->uid);
232 if (TTS_ERROR_TIMED_OUT != ret) {
233 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
236 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
239 if (TTS_RETRY_COUNT == count) {
240 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
247 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
250 client->before_state = client->current_state;
251 client->current_state = TTS_STATE_CREATED;
253 case TTS_STATE_CREATED:
254 if (NULL != client->conn_timer) {
255 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
256 ecore_timer_del(client->conn_timer);
257 client->conn_timer = NULL;
260 tts_client_destroy(tts);
267 if (0 == tts_client_get_size()) {
268 if (0 != tts_dbus_close_connection()) {
269 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
275 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
276 SLOG(LOG_DEBUG, TAG_TTSC, " ");
278 return TTS_ERROR_NONE;
281 void __tts_screen_reader_changed_cb(bool value)
283 g_screen_reader = value;
286 int tts_set_mode(tts_h tts, tts_mode_e mode)
288 if (0 != __tts_get_feature_enabled()) {
289 return TTS_ERROR_NOT_SUPPORTED;
292 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
294 tts_client_s* client = tts_client_get(tts);
297 if (NULL == client) {
298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
299 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
300 SLOG(LOG_DEBUG, TAG_TTSC, " ");
301 return TTS_ERROR_INVALID_PARAMETER;
305 if (client->current_state != TTS_STATE_CREATED) {
306 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
307 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
308 SLOG(LOG_DEBUG, TAG_TTSC, " ");
309 return TTS_ERROR_INVALID_STATE;
312 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
315 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
316 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
317 SLOG(LOG_DEBUG, TAG_TTSC, " ");
318 return TTS_ERROR_INVALID_PARAMETER;
321 if (TTS_MODE_SCREEN_READER == mode) {
324 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
326 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
327 return TTS_ERROR_OPERATION_FAILED;
329 g_screen_reader = (bool)screen_reader;
330 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
332 tts_config_unset_screen_reader_callback(client->uid);
335 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
336 SLOG(LOG_DEBUG, TAG_TTSC, " ");
338 return TTS_ERROR_NONE;
341 int tts_get_mode(tts_h tts, tts_mode_e* mode)
343 if (0 != __tts_get_feature_enabled()) {
344 return TTS_ERROR_NOT_SUPPORTED;
347 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
349 tts_client_s* client = tts_client_get(tts);
352 if (NULL == client) {
353 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
354 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
355 SLOG(LOG_DEBUG, TAG_TTSC, " ");
356 return TTS_ERROR_INVALID_PARAMETER;
360 if (client->current_state != TTS_STATE_CREATED) {
361 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
364 return TTS_ERROR_INVALID_STATE;
368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
369 return TTS_ERROR_INVALID_PARAMETER;
372 *mode = client->mode;
374 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
375 SLOG(LOG_DEBUG, TAG_TTSC, " ");
377 return TTS_ERROR_NONE;
380 static Eina_Bool __tts_connect_daemon(void *data)
382 tts_h tts = (tts_h)data;
383 tts_client_s* client = tts_client_get(tts);
386 if (NULL == client) {
387 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
392 if (0 != tts_dbus_request_hello(client->uid)) {
396 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
398 /* do request initialize */
400 ret = tts_dbus_request_initialize(client->uid);
402 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
405 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
408 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
409 client->conn_timer = NULL;
412 } else if (TTS_ERROR_NONE != ret) {
413 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
417 /* success to connect tts-daemon */
420 client->conn_timer = NULL;
422 client = tts_client_get(tts);
424 if (NULL == client) {
425 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
429 client->before_state = client->current_state;
430 client->current_state = TTS_STATE_READY;
432 if (NULL != client->state_changed_cb) {
433 tts_client_use_callback(client);
434 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
435 tts_client_not_use_callback(client);
437 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
440 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
441 SLOG(LOG_DEBUG, TAG_TTSC, " ");
446 int tts_prepare(tts_h tts)
448 if (0 != __tts_get_feature_enabled()) {
449 return TTS_ERROR_NOT_SUPPORTED;
452 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
454 tts_client_s* client = tts_client_get(tts);
457 if (NULL == client) {
458 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
459 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
460 SLOG(LOG_DEBUG, TAG_TTSC, " ");
461 return TTS_ERROR_INVALID_PARAMETER;
465 if (client->current_state != TTS_STATE_CREATED) {
466 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
467 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
468 SLOG(LOG_DEBUG, TAG_TTSC, " ");
469 return TTS_ERROR_INVALID_STATE;
472 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
474 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
475 SLOG(LOG_DEBUG, TAG_TTSC, " ");
477 return TTS_ERROR_NONE;
480 int tts_unprepare(tts_h tts)
482 if (0 != __tts_get_feature_enabled()) {
483 return TTS_ERROR_NOT_SUPPORTED;
486 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
488 tts_client_s* client = tts_client_get(tts);
491 if (NULL == client) {
492 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
493 return TTS_ERROR_INVALID_PARAMETER;
497 if (client->current_state != TTS_STATE_READY) {
498 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
499 return TTS_ERROR_INVALID_STATE;
504 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
506 ret = tts_dbus_request_finalize(client->uid);
508 if (TTS_ERROR_TIMED_OUT != ret) {
509 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
512 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
515 if (TTS_RETRY_COUNT == count) {
516 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
523 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
526 client->before_state = client->current_state;
527 client->current_state = TTS_STATE_CREATED;
529 if (NULL != client->state_changed_cb) {
530 tts_client_use_callback(client);
531 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
532 tts_client_not_use_callback(client);
533 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
536 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
537 SLOG(LOG_DEBUG, TAG_TTSC, " ");
539 return TTS_ERROR_NONE;
542 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
544 tts_h tts = (tts_h)user_data;
546 tts_client_s* client = tts_client_get(tts);
547 if (NULL == client) {
548 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
552 /* call callback function */
553 if (NULL != client->supported_voice_cb) {
554 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
556 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
562 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
564 if (0 != __tts_get_feature_enabled()) {
565 return TTS_ERROR_NOT_SUPPORTED;
568 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
570 if (NULL == tts || NULL == callback) {
571 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
572 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
573 SLOG(LOG_DEBUG, TAG_TTSC, " ");
574 return TTS_ERROR_INVALID_PARAMETER;
577 tts_client_s* client = tts_client_get(tts);
580 if (NULL == client) {
581 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
582 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
583 SLOG(LOG_DEBUG, TAG_TTSC, " ");
584 return TTS_ERROR_INVALID_PARAMETER;
588 char* current_engine = NULL;
589 ret = tts_config_mgr_get_engine(¤t_engine);
591 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
592 return __tts_convert_config_error_code(ret);
595 client->supported_voice_cb = callback;
596 client->supported_voice_user_data = user_data;
598 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
600 if (NULL != current_engine)
601 free(current_engine);
603 client->supported_voice_cb = NULL;
604 client->supported_voice_user_data = NULL;
607 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
608 ret = TTS_ERROR_OPERATION_FAILED;
611 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
612 SLOG(LOG_DEBUG, TAG_TTSC, " ");
617 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
619 if (0 != __tts_get_feature_enabled()) {
620 return TTS_ERROR_NOT_SUPPORTED;
623 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
627 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
628 SLOG(LOG_DEBUG, TAG_TTSC, " ");
629 return TTS_ERROR_INVALID_PARAMETER;
632 tts_client_s* client = tts_client_get(tts);
634 if (NULL == client) {
635 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
636 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
637 SLOG(LOG_DEBUG, TAG_TTSC, " ");
638 return TTS_ERROR_INVALID_PARAMETER;
641 /* Request call remote method */
643 ret = tts_config_mgr_get_voice(lang, vctype);
645 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
646 return __tts_convert_config_error_code(ret);
648 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
651 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
652 SLOG(LOG_DEBUG, TAG_TTSC, " ");
657 int tts_get_max_text_size(tts_h tts, unsigned int* size)
659 if (0 != __tts_get_feature_enabled()) {
660 return TTS_ERROR_NOT_SUPPORTED;
663 if (NULL == tts || NULL == size) {
664 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
665 return TTS_ERROR_INVALID_PARAMETER;
668 tts_client_s* client = tts_client_get(tts);
670 if (NULL == client) {
671 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
672 return TTS_ERROR_INVALID_PARAMETER;
675 if (TTS_STATE_READY != client->current_state) {
676 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
677 return TTS_ERROR_INVALID_STATE;
680 *size = TTS_MAX_TEXT_SIZE;
682 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
683 return TTS_ERROR_NONE;
686 int tts_get_state(tts_h tts, tts_state_e* state)
688 if (0 != __tts_get_feature_enabled()) {
689 return TTS_ERROR_NOT_SUPPORTED;
692 if (NULL == tts || NULL == state) {
693 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
694 return TTS_ERROR_INVALID_PARAMETER;
697 tts_client_s* client = tts_client_get(tts);
699 if (NULL == client) {
700 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
701 return TTS_ERROR_INVALID_PARAMETER;
704 *state = client->current_state;
707 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
708 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
709 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
710 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
711 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
714 return TTS_ERROR_NONE;
717 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
719 if (0 != __tts_get_feature_enabled()) {
720 return TTS_ERROR_NOT_SUPPORTED;
723 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
724 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
725 return TTS_ERROR_INVALID_PARAMETER;
728 tts_client_s* client = tts_client_get(tts);
730 if (NULL == client) {
731 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
732 return TTS_ERROR_INVALID_PARAMETER;
735 *min = TTS_SPEED_MIN;
736 *normal = TTS_SPEED_NORMAL;
737 *max = TTS_SPEED_MAX;
739 return TTS_ERROR_NONE;
742 int tts_get_error_message(tts_h tts, char** err_msg)
744 if(0 != __tts_get_feature_enabled()) {
745 return TTS_ERROR_NOT_SUPPORTED;
748 if (NULL == tts || NULL == err_msg) {
749 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
750 return TTS_ERROR_INVALID_PARAMETER;
753 tts_client_s* client = tts_client_get(tts);
755 if (NULL == client) {
756 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
757 return TTS_ERROR_INVALID_PARAMETER;
760 if (NULL != client->err_msg) {
761 *err_msg = strdup(client->err_msg);
762 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
764 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
767 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
768 SLOG(LOG_DEBUG, TAG_TTSC, " ");
770 return TTS_ERROR_NONE;
773 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
775 if (0 != __tts_get_feature_enabled()) {
776 return TTS_ERROR_NOT_SUPPORTED;
780 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
781 return TTS_ERROR_INVALID_PARAMETER;
784 if (voice_type < 0) {
785 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
786 return TTS_ERROR_INVALID_PARAMETER;
789 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
791 if (NULL == tts || NULL == utt_id) {
792 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
793 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
794 SLOG(LOG_DEBUG, TAG_TTSC, " ");
795 return TTS_ERROR_INVALID_PARAMETER;
798 tts_client_s* client = tts_client_get(tts);
800 if (NULL == client) {
801 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
802 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
803 SLOG(LOG_DEBUG, TAG_TTSC, " ");
804 return TTS_ERROR_INVALID_PARAMETER;
807 if (TTS_STATE_CREATED == client->current_state) {
808 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
809 return TTS_ERROR_INVALID_STATE;
812 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
813 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
814 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
815 SLOG(LOG_DEBUG, TAG_TTSC, " ");
816 return TTS_ERROR_INVALID_PARAMETER;
819 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
820 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
821 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
822 SLOG(LOG_DEBUG, TAG_TTSC, " ");
823 return TTS_ERROR_INVALID_PARAMETER;
826 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
827 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
828 return TTS_ERROR_INVALID_STATE;
831 /* check valid utf8 */
833 ict = iconv_open("utf-8", "");
834 if ((iconv_t)-1 == ict) {
835 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
836 return TTS_ERROR_OPERATION_FAILED;
839 size_t len = strlen(text);
841 char in_buf[TTS_MAX_TEXT_SIZE];
842 char *out_tmp = NULL;
843 char out_buf[TTS_MAX_TEXT_SIZE];
844 size_t len_tmp = sizeof(out_buf);
846 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
847 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
850 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
854 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
855 if ((size_t)-1 == st) {
856 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
858 return TTS_ERROR_INVALID_PARAMETER;
861 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
863 /* change default language value */
866 if (NULL == language)
867 temp = strdup("default");
869 temp = strdup(language);
871 client->current_utt_id++;
872 if (client->current_utt_id == 10000) {
873 client->current_utt_id = 1;
880 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id);
882 if (TTS_ERROR_TIMED_OUT != ret) {
883 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
886 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
889 if (TTS_RETRY_COUNT == count) {
890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
895 *utt_id = client->current_utt_id;
899 if (NULL != temp) free(temp);
901 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
902 SLOG(LOG_DEBUG, TAG_TTSC, " ");
907 static void __tts_play_async(void *data)
909 tts_h tts = (tts_h)data;
910 tts_client_s* client = tts_client_get(tts);
913 if (NULL == client) {
914 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
921 ret = tts_dbus_request_play(client->uid);
923 if (TTS_ERROR_TIMED_OUT != ret) {
924 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
927 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
930 if (TTS_RETRY_COUNT == count) {
931 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
939 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
941 client->reason = ret;
944 ecore_timer_add(0, __tts_notify_error, client->tts);
948 client->before_state = client->current_state;
949 client->current_state = TTS_STATE_PLAYING;
951 if (NULL != client->state_changed_cb) {
952 tts_client_use_callback(client);
953 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
954 tts_client_not_use_callback(client);
955 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
958 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
959 SLOG(LOG_DEBUG, TAG_TTSC, " ");
964 int tts_play_async(tts_h tts)
966 if (0 != __tts_get_feature_enabled()) {
967 return TTS_ERROR_NOT_SUPPORTED;
970 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
973 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
974 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
975 SLOG(LOG_DEBUG, TAG_TTSC, " ");
976 return TTS_ERROR_INVALID_PARAMETER;
979 tts_client_s* client = tts_client_get(tts);
981 if (NULL == client) {
982 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
983 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
984 SLOG(LOG_DEBUG, TAG_TTSC, " ");
985 return TTS_ERROR_INVALID_PARAMETER;
988 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
989 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
990 return TTS_ERROR_INVALID_STATE;
993 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
994 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
995 return TTS_ERROR_INVALID_STATE;
998 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1000 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1001 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1003 return TTS_ERROR_NONE;
1006 int tts_play(tts_h tts)
1008 if (0 != __tts_get_feature_enabled()) {
1009 return TTS_ERROR_NOT_SUPPORTED;
1012 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1015 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1016 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1017 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1018 return TTS_ERROR_INVALID_PARAMETER;
1021 tts_client_s* client = tts_client_get(tts);
1023 if (NULL == client) {
1024 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1025 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1026 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1027 return TTS_ERROR_INVALID_PARAMETER;
1030 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1031 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1032 return TTS_ERROR_INVALID_STATE;
1035 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1036 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1037 return TTS_ERROR_INVALID_STATE;
1043 ret = tts_dbus_request_play(client->uid);
1045 if (TTS_ERROR_TIMED_OUT != ret) {
1046 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1049 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1052 if (TTS_RETRY_COUNT == count) {
1053 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1060 client->before_state = client->current_state;
1061 client->current_state = TTS_STATE_PLAYING;
1063 if (NULL != client->state_changed_cb) {
1064 tts_client_use_callback(client);
1065 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1066 tts_client_not_use_callback(client);
1067 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1070 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1071 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1073 return TTS_ERROR_NONE;
1076 static void __tts_stop_async(void *data)
1078 tts_h tts = (tts_h)data;
1079 tts_client_s* client = tts_client_get(tts);
1082 if (NULL == client) {
1083 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1090 ret = tts_dbus_request_stop(client->uid);
1092 if (TTS_ERROR_TIMED_OUT != ret) {
1093 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1096 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1099 if (TTS_RETRY_COUNT == count) {
1100 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1108 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1110 client->reason = ret;
1111 client->utt_id = -1;
1113 ecore_timer_add(0, __tts_notify_error, client->tts);
1117 client->before_state = client->current_state;
1118 client->current_state = TTS_STATE_READY;
1120 if (NULL != client->state_changed_cb) {
1121 tts_client_use_callback(client);
1122 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1123 tts_client_not_use_callback(client);
1124 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1127 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1128 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1133 int tts_stop_aync(tts_h tts)
1135 if (0 != __tts_get_feature_enabled()) {
1136 return TTS_ERROR_NOT_SUPPORTED;
1139 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1142 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1143 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1144 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1145 return TTS_ERROR_INVALID_PARAMETER;
1148 tts_client_s* client = tts_client_get(tts);
1150 if (NULL == client) {
1151 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1152 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1153 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1154 return TTS_ERROR_INVALID_PARAMETER;
1157 if (TTS_STATE_CREATED == client->current_state) {
1158 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1159 return TTS_ERROR_INVALID_STATE;
1162 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1163 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1164 return TTS_ERROR_INVALID_STATE;
1167 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1169 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1170 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1172 return TTS_ERROR_NONE;
1175 int tts_stop(tts_h tts)
1177 if (0 != __tts_get_feature_enabled()) {
1178 return TTS_ERROR_NOT_SUPPORTED;
1181 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1184 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1185 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1186 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1187 return TTS_ERROR_INVALID_PARAMETER;
1190 tts_client_s* client = tts_client_get(tts);
1192 if (NULL == client) {
1193 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1194 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1195 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1196 return TTS_ERROR_INVALID_PARAMETER;
1199 if (TTS_STATE_CREATED == client->current_state) {
1200 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1201 return TTS_ERROR_INVALID_STATE;
1204 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1205 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1206 return TTS_ERROR_INVALID_STATE;
1212 ret = tts_dbus_request_stop(client->uid);
1214 if (TTS_ERROR_TIMED_OUT != ret) {
1215 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1218 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1221 if (TTS_RETRY_COUNT == count) {
1222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1229 client->before_state = client->current_state;
1230 client->current_state = TTS_STATE_READY;
1232 if (NULL != client->state_changed_cb) {
1233 tts_client_use_callback(client);
1234 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1235 tts_client_not_use_callback(client);
1236 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1239 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1240 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1242 return TTS_ERROR_NONE;
1245 static void __tts_pause_async(void *data)
1247 tts_h tts = (tts_h)data;
1248 tts_client_s* client = tts_client_get(tts);
1251 if (NULL == client) {
1252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1259 ret = tts_dbus_request_pause(client->uid);
1261 if (TTS_ERROR_TIMED_OUT != ret) {
1262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1265 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1268 if (TTS_RETRY_COUNT == count) {
1269 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1277 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1279 client->reason = ret;
1280 client->utt_id = -1;
1282 ecore_timer_add(0, __tts_notify_error, client->tts);
1286 client->before_state = client->current_state;
1287 client->current_state = TTS_STATE_PAUSED;
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, "=====");
1297 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1302 int tts_pause_async(tts_h tts)
1304 if (0 != __tts_get_feature_enabled()) {
1305 return TTS_ERROR_NOT_SUPPORTED;
1308 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1311 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1312 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1313 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1314 return TTS_ERROR_INVALID_PARAMETER;
1317 tts_client_s* client = tts_client_get(tts);
1319 if (NULL == client) {
1320 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1321 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1322 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1323 return TTS_ERROR_INVALID_PARAMETER;
1326 if (TTS_STATE_PLAYING != client->current_state) {
1327 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1328 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1329 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1330 return TTS_ERROR_INVALID_STATE;
1333 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1334 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1335 return TTS_ERROR_INVALID_STATE;
1338 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1340 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1341 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1343 return TTS_ERROR_NONE;
1346 int tts_pause(tts_h tts)
1348 if (0 != __tts_get_feature_enabled()) {
1349 return TTS_ERROR_NOT_SUPPORTED;
1352 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1355 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1356 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1357 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1358 return TTS_ERROR_INVALID_PARAMETER;
1361 tts_client_s* client = tts_client_get(tts);
1363 if (NULL == client) {
1364 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1365 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1366 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1367 return TTS_ERROR_INVALID_PARAMETER;
1370 if (TTS_STATE_PLAYING != client->current_state) {
1371 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1372 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1373 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1374 return TTS_ERROR_INVALID_STATE;
1377 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1378 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1379 return TTS_ERROR_INVALID_STATE;
1385 ret = tts_dbus_request_pause(client->uid);
1387 if (TTS_ERROR_TIMED_OUT != ret) {
1388 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1391 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1394 if (TTS_RETRY_COUNT == count) {
1395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1402 client->before_state = client->current_state;
1403 client->current_state = TTS_STATE_PAUSED;
1405 if (NULL != client->state_changed_cb) {
1406 tts_client_use_callback(client);
1407 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1408 tts_client_not_use_callback(client);
1409 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1412 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1413 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1415 return TTS_ERROR_NONE;
1418 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1420 if (0 != __tts_get_feature_enabled()) {
1421 return TTS_ERROR_NOT_SUPPORTED;
1424 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1427 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1428 return TTS_ERROR_INVALID_PARAMETER;
1431 if (NULL == key || NULL == data) {
1432 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1433 return TTS_ERROR_INVALID_PARAMETER;
1436 tts_client_s* client = tts_client_get(tts);
1438 if (NULL == client) {
1439 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1440 return TTS_ERROR_INVALID_PARAMETER;
1443 if (TTS_STATE_READY != client->current_state) {
1444 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1445 return TTS_ERROR_INVALID_STATE;
1448 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1449 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1450 return TTS_ERROR_INVALID_STATE;
1456 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1458 if (TTS_ERROR_TIMED_OUT != ret) {
1459 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1462 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1465 if (TTS_RETRY_COUNT == count) {
1466 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1473 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1474 SLOG(LOG_DEBUG, TAG_TTSC, "");
1479 int tts_get_private_data(tts_h tts, const char* key, char** data)
1481 if (0 != __tts_get_feature_enabled()) {
1482 return TTS_ERROR_NOT_SUPPORTED;
1485 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1488 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1489 return TTS_ERROR_INVALID_PARAMETER;
1492 if (NULL == key || NULL == data) {
1493 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1494 return TTS_ERROR_INVALID_PARAMETER;
1497 tts_client_s* client = tts_client_get(tts);
1499 if (NULL == client) {
1500 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1501 return TTS_ERROR_INVALID_PARAMETER;
1504 if (TTS_STATE_READY != client->current_state) {
1505 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1506 return TTS_ERROR_INVALID_STATE;
1509 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1510 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1511 return TTS_ERROR_INVALID_STATE;
1517 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1519 if (TTS_ERROR_TIMED_OUT != ret) {
1520 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1523 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1526 if (TTS_RETRY_COUNT == count) {
1527 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1534 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1535 SLOG(LOG_DEBUG, TAG_TTSC, "");
1540 static Eina_Bool __tts_notify_error(void *data)
1542 tts_h tts = (tts_h)data;
1544 tts_client_s* client = tts_client_get(tts);
1547 if (NULL == client) {
1548 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1552 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1554 if (NULL != client->error_cb) {
1555 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1556 tts_client_use_callback(client);
1557 g_err_callback_status = true;
1558 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1559 g_err_callback_status = false;
1560 tts_client_not_use_callback(client);
1562 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1568 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1570 tts_client_s* client = tts_client_get_by_uid(uid);
1572 if (NULL == client) {
1573 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1574 return TTS_ERROR_INVALID_PARAMETER;
1577 client->utt_id = utt_id;
1578 client->reason = reason;
1579 if (NULL != client->err_msg) {
1580 free(client->err_msg);
1581 client->err_msg = NULL;
1583 client->err_msg = strdup(err_msg);
1585 /* call callback function */
1586 if (NULL != client->error_cb) {
1587 ecore_timer_add(0, __tts_notify_error, client->tts);
1589 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1595 static Eina_Bool __tts_notify_state_changed(void *data)
1597 tts_h tts = (tts_h)data;
1599 tts_client_s* client = tts_client_get(tts);
1602 if (NULL == client) {
1603 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1607 if (NULL != client->state_changed_cb) {
1608 tts_client_use_callback(client);
1609 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1610 tts_client_not_use_callback(client);
1611 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1613 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1619 int __tts_cb_set_state(int uid, int state)
1621 tts_client_s* client = tts_client_get_by_uid(uid);
1622 if (NULL == client) {
1623 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1627 tts_state_e state_from_daemon = (tts_state_e)state;
1629 if (client->current_state == state_from_daemon) {
1630 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1634 if (NULL != client->state_changed_cb) {
1635 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1637 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1640 client->before_state = client->current_state;
1641 client->current_state = state_from_daemon;
1646 int __tts_cb_utt_started(int uid, int utt_id)
1648 tts_client_s* client = tts_client_get_by_uid(uid);
1650 if (NULL == client) {
1651 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1652 return TTS_ERROR_INVALID_PARAMETER;
1655 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1657 client->utt_id = utt_id;
1659 /* call callback function */
1660 if (NULL != client->utt_started_cb) {
1661 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1662 tts_client_use_callback(client);
1663 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1664 tts_client_not_use_callback(client);
1666 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1672 int __tts_cb_utt_completed(int uid, int utt_id)
1674 tts_client_s* client = tts_client_get_by_uid(uid);
1676 if (NULL == client) {
1677 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1678 return TTS_ERROR_INVALID_PARAMETER;
1681 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1683 client->utt_id = utt_id;
1685 /* call callback function */
1686 if (NULL != client->utt_completeted_cb) {
1687 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1688 tts_client_use_callback(client);
1689 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1690 tts_client_not_use_callback(client);
1692 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1698 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1700 if (0 != __tts_get_feature_enabled()) {
1701 return TTS_ERROR_NOT_SUPPORTED;
1704 if (NULL == tts || NULL == callback) {
1705 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1706 return TTS_ERROR_INVALID_PARAMETER;
1709 tts_client_s* client = tts_client_get(tts);
1711 if (NULL == client) {
1712 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1713 return TTS_ERROR_INVALID_PARAMETER;
1716 if (TTS_STATE_CREATED != client->current_state) {
1717 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1718 return TTS_ERROR_INVALID_STATE;
1721 client->state_changed_cb = callback;
1722 client->state_changed_user_data = user_data;
1724 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1729 int tts_unset_state_changed_cb(tts_h tts)
1731 if (0 != __tts_get_feature_enabled()) {
1732 return TTS_ERROR_NOT_SUPPORTED;
1736 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1737 return TTS_ERROR_INVALID_PARAMETER;
1740 tts_client_s* client = tts_client_get(tts);
1742 if (NULL == client) {
1743 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1744 return TTS_ERROR_INVALID_PARAMETER;
1747 if (TTS_STATE_CREATED != client->current_state) {
1748 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1749 return TTS_ERROR_INVALID_STATE;
1752 client->state_changed_cb = NULL;
1753 client->state_changed_user_data = NULL;
1755 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1760 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1762 if (0 != __tts_get_feature_enabled()) {
1763 return TTS_ERROR_NOT_SUPPORTED;
1766 if (NULL == tts || NULL == callback) {
1767 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1768 return TTS_ERROR_INVALID_PARAMETER;
1771 tts_client_s* client = tts_client_get(tts);
1773 if (NULL == client) {
1774 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1775 return TTS_ERROR_INVALID_PARAMETER;
1778 if (TTS_STATE_CREATED != client->current_state) {
1779 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1780 return TTS_ERROR_INVALID_STATE;
1783 client->utt_started_cb = callback;
1784 client->utt_started_user_data = user_data;
1786 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1791 int tts_unset_utterance_started_cb(tts_h tts)
1793 if (0 != __tts_get_feature_enabled()) {
1794 return TTS_ERROR_NOT_SUPPORTED;
1798 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1799 return TTS_ERROR_INVALID_PARAMETER;
1802 tts_client_s* client = tts_client_get(tts);
1804 if (NULL == client) {
1805 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1806 return TTS_ERROR_INVALID_PARAMETER;
1809 if (TTS_STATE_CREATED != client->current_state) {
1810 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1811 return TTS_ERROR_INVALID_STATE;
1814 client->utt_started_cb = NULL;
1815 client->utt_started_user_data = NULL;
1817 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1822 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1824 if (0 != __tts_get_feature_enabled()) {
1825 return TTS_ERROR_NOT_SUPPORTED;
1828 if (NULL == tts || NULL == callback) {
1829 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1830 return TTS_ERROR_INVALID_PARAMETER;
1833 tts_client_s* client = tts_client_get(tts);
1835 if (NULL == client) {
1836 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1837 return TTS_ERROR_INVALID_PARAMETER;
1840 if (TTS_STATE_CREATED != client->current_state) {
1841 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1842 return TTS_ERROR_INVALID_STATE;
1845 client->utt_completeted_cb = callback;
1846 client->utt_completed_user_data = user_data;
1848 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1853 int tts_unset_utterance_completed_cb(tts_h tts)
1855 if (0 != __tts_get_feature_enabled()) {
1856 return TTS_ERROR_NOT_SUPPORTED;
1860 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1861 return TTS_ERROR_INVALID_PARAMETER;
1864 tts_client_s* client = tts_client_get(tts);
1866 if (NULL == client) {
1867 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1868 return TTS_ERROR_INVALID_PARAMETER;
1871 if (TTS_STATE_CREATED != client->current_state) {
1872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1873 return TTS_ERROR_INVALID_STATE;
1876 client->utt_completeted_cb = NULL;
1877 client->utt_completed_user_data = NULL;
1879 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1883 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1885 if (0 != __tts_get_feature_enabled()) {
1886 return TTS_ERROR_NOT_SUPPORTED;
1889 if (NULL == tts || NULL == callback) {
1890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1891 return TTS_ERROR_INVALID_PARAMETER;
1894 tts_client_s* client = tts_client_get(tts);
1896 if (NULL == client) {
1897 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1898 return TTS_ERROR_INVALID_PARAMETER;
1901 if (TTS_STATE_CREATED != client->current_state) {
1902 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1903 return TTS_ERROR_INVALID_STATE;
1906 client->error_cb = callback;
1907 client->error_user_data = user_data;
1909 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1914 int tts_unset_error_cb(tts_h tts)
1916 if (0 != __tts_get_feature_enabled()) {
1917 return TTS_ERROR_NOT_SUPPORTED;
1921 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1922 return TTS_ERROR_INVALID_PARAMETER;
1925 tts_client_s* client = tts_client_get(tts);
1927 if (NULL == client) {
1928 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1929 return TTS_ERROR_INVALID_PARAMETER;
1932 if (TTS_STATE_CREATED != client->current_state) {
1933 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1934 return TTS_ERROR_INVALID_STATE;
1937 client->error_cb = NULL;
1938 client->error_user_data = NULL;
1940 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1945 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1947 if (0 != __tts_get_feature_enabled()) {
1948 return TTS_ERROR_NOT_SUPPORTED;
1951 if (NULL == tts || NULL == callback) {
1952 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
1953 return TTS_ERROR_INVALID_PARAMETER;
1956 tts_client_s* client = tts_client_get(tts);
1958 if (NULL == client) {
1959 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
1960 return TTS_ERROR_INVALID_PARAMETER;
1963 if (TTS_STATE_CREATED != client->current_state) {
1964 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
1965 return TTS_ERROR_INVALID_STATE;
1968 client->default_voice_changed_cb = callback;
1969 client->default_voice_changed_user_data = user_data;
1971 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
1976 int tts_unset_default_voice_changed_cb(tts_h tts)
1978 if (0 != __tts_get_feature_enabled()) {
1979 return TTS_ERROR_NOT_SUPPORTED;
1983 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
1984 return TTS_ERROR_INVALID_PARAMETER;
1987 tts_client_s* client = tts_client_get(tts);
1989 if (NULL == client) {
1990 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
1991 return TTS_ERROR_INVALID_PARAMETER;
1994 if (TTS_STATE_CREATED != client->current_state) {
1995 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
1996 return TTS_ERROR_INVALID_STATE;
1999 client->default_voice_changed_cb = NULL;
2000 client->default_voice_changed_user_data = NULL;
2002 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");