2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
14 #include <app_manager.h>
19 #include <sys/types.h>
21 #include <system_info.h>
25 #include "tts_client.h"
26 #include "tts_config_mgr.h"
30 #include "tts_internal.h"
32 static bool g_screen_reader;
34 static int g_feature_enabled = -1;
36 static bool g_err_callback_status = false;
38 static int g_max_text_size = -1;
40 /* Function definition */
41 static Eina_Bool __tts_notify_state_changed(void *data);
42 static Eina_Bool __tts_notify_error(void *data);
49 static int __tts_get_feature_enabled()
51 if (0 == g_feature_enabled) {
52 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
53 return TTS_ERROR_NOT_SUPPORTED;
54 } else if (-1 == g_feature_enabled) {
55 bool tts_supported = false;
56 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
57 if (false == tts_supported) {
58 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
59 g_feature_enabled = 0;
60 return TTS_ERROR_NOT_SUPPORTED;
63 g_feature_enabled = 1;
65 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
66 return TTS_ERROR_NOT_SUPPORTED;
73 static const char* __tts_get_error_code(tts_error_e err)
76 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
77 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
78 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
79 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
80 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
81 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
82 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
83 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
84 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
85 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
86 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
87 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
88 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
89 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
90 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
92 return "Invalid error code";
97 static int __tts_convert_config_error_code(tts_config_error_e code)
99 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
100 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
101 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
102 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
103 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
104 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
105 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
106 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
107 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
112 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)
114 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
115 before_lang, before_voice_type, language, voice_type);
117 GList* client_list = NULL;
118 client_list = tts_client_get_client_list();
121 tts_client_s *data = NULL;
123 if (g_list_length(client_list) > 0) {
124 /* Get a first item */
125 iter = g_list_first(client_list);
127 while (NULL != iter) {
129 if (NULL != data->default_voice_changed_cb) {
130 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
131 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
132 language, voice_type, data->default_voice_changed_user_data);
136 iter = g_list_next(iter);
143 static Eina_Bool __reconnect_by_engine_changed(void* data)
145 tts_h tts = (tts_h)data;
147 tts_client_s* client = tts_client_get(tts);
148 if (NULL == client) {
149 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
153 if (TTS_STATE_READY != client->current_state) {
158 int ret = tts_unprepare(tts);
160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
162 ret = tts_prepare(tts);
164 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
170 void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
172 tts_h tts = (tts_h)user_data;
174 tts_client_s* client = tts_client_get(tts);
175 if (NULL == client) {
176 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
180 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
181 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
182 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
183 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
185 /* When the default engine is changed, please unload the old engine and load the new one. */
188 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
191 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
194 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
195 } else if (TTS_STATE_READY == client->current_state) {
196 ret = tts_unprepare(tts);
198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
200 ret = tts_prepare(tts);
202 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
206 /* call callback function */
207 if (NULL != client->engine_changed_cb) {
208 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
210 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
215 int tts_create(tts_h* tts)
217 if (0 != __tts_get_feature_enabled()) {
218 return TTS_ERROR_NOT_SUPPORTED;
221 SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
225 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
226 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
227 return TTS_ERROR_INVALID_PARAMETER;
230 if (0 == tts_client_get_size()) {
231 if (0 != tts_dbus_open_connection()) {
232 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
233 return TTS_ERROR_OPERATION_FAILED;
237 if (0 != tts_client_new(tts)) {
238 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
239 return TTS_ERROR_OUT_OF_MEMORY;
242 tts_client_s* client = tts_client_get(*tts);
243 if (NULL == client) {
244 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
245 return TTS_ERROR_OPERATION_FAILED;
248 int ret = tts_config_mgr_initialize(client->uid);
250 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
251 tts_client_destroy(*tts);
252 return __tts_convert_config_error_code(ret);
255 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
257 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
258 tts_client_destroy(*tts);
259 return __tts_convert_config_error_code(ret);
262 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
263 SLOG(LOG_DEBUG, TAG_TTSC, " ");
265 return TTS_ERROR_NONE;
268 int tts_destroy(tts_h tts)
270 if (0 != __tts_get_feature_enabled()) {
271 return TTS_ERROR_NOT_SUPPORTED;
274 SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
277 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
278 return TTS_ERROR_INVALID_PARAMETER;
281 tts_client_s* client = tts_client_get(tts);
284 if (NULL == client) {
285 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
286 return TTS_ERROR_INVALID_PARAMETER;
289 /* check used callback */
290 if (0 != tts_client_get_use_callback(client)) {
291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
292 return TTS_ERROR_OPERATION_FAILED;
295 tts_config_mgr_finalize(client->uid);
299 int screen_reader = -1;
302 switch (client->current_state) {
303 case TTS_STATE_PAUSED:
304 case TTS_STATE_PLAYING:
305 case TTS_STATE_READY:
306 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
308 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
310 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
311 g_screen_reader = (bool)screen_reader;
313 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
315 ret = tts_dbus_request_finalize(client->uid);
317 if (TTS_ERROR_TIMED_OUT != ret) {
318 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
321 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
324 if (TTS_RETRY_COUNT == count) {
325 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
332 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
335 client->before_state = client->current_state;
336 client->current_state = TTS_STATE_CREATED;
338 case TTS_STATE_CREATED:
339 if (NULL != client->conn_timer) {
340 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
341 ecore_timer_del(client->conn_timer);
342 client->conn_timer = NULL;
345 tts_client_destroy(tts);
352 if (0 == tts_client_get_size()) {
353 if (0 != tts_dbus_close_connection()) {
354 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
360 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
362 return TTS_ERROR_NONE;
365 void __tts_screen_reader_changed_cb(bool value)
367 g_screen_reader = value;
370 int tts_set_mode(tts_h tts, tts_mode_e mode)
372 if (0 != __tts_get_feature_enabled()) {
373 return TTS_ERROR_NOT_SUPPORTED;
376 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
378 tts_client_s* client = tts_client_get(tts);
381 if (NULL == client) {
382 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
383 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
384 return TTS_ERROR_INVALID_PARAMETER;
388 if (client->current_state != TTS_STATE_CREATED) {
389 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
390 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
391 SLOG(LOG_DEBUG, TAG_TTSC, " ");
392 return TTS_ERROR_INVALID_STATE;
395 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
398 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
399 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
400 SLOG(LOG_DEBUG, TAG_TTSC, " ");
401 return TTS_ERROR_INVALID_PARAMETER;
404 if (TTS_MODE_SCREEN_READER == mode) {
407 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
409 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
410 return TTS_ERROR_OPERATION_FAILED;
412 g_screen_reader = (bool)screen_reader;
413 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
415 tts_config_unset_screen_reader_callback(client->uid);
418 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
420 return TTS_ERROR_NONE;
423 int tts_get_mode(tts_h tts, tts_mode_e* mode)
425 if (0 != __tts_get_feature_enabled()) {
426 return TTS_ERROR_NOT_SUPPORTED;
429 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
431 tts_client_s* client = tts_client_get(tts);
434 if (NULL == client) {
435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
436 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
437 SLOG(LOG_DEBUG, TAG_TTSC, " ");
438 return TTS_ERROR_INVALID_PARAMETER;
442 if (client->current_state != TTS_STATE_CREATED) {
443 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
444 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
445 SLOG(LOG_DEBUG, TAG_TTSC, " ");
446 return TTS_ERROR_INVALID_STATE;
450 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
451 return TTS_ERROR_INVALID_PARAMETER;
454 *mode = client->mode;
456 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
457 SLOG(LOG_DEBUG, TAG_TTSC, " ");
459 return TTS_ERROR_NONE;
462 int tts_set_credential(tts_h tts, const char* credential)
464 if (0 != __tts_get_feature_enabled()) {
465 return TTS_ERROR_NOT_SUPPORTED;
468 if (NULL == tts || NULL == credential) {
469 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
470 return TTS_ERROR_INVALID_PARAMETER;
473 tts_client_s* client = tts_client_get(tts);
475 if (NULL == client) {
476 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
477 return TTS_ERROR_INVALID_PARAMETER;
480 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
481 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
482 return TTS_ERROR_INVALID_STATE;
485 if (NULL != client->credential) {
486 free(client->credential);
487 client->credential = NULL;
489 client->credential = strdup(credential);
491 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
493 return TTS_ERROR_NONE;
496 int tts_set_server_tts(tts_h tts, const char* credential)
498 if (0 != __tts_get_feature_enabled()) {
499 return TTS_ERROR_NOT_SUPPORTED;
503 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
504 return TTS_ERROR_INVALID_PARAMETER;
507 tts_client_s* client = tts_client_get(tts);
509 if (NULL == client) {
510 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
511 return TTS_ERROR_INVALID_PARAMETER;
514 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
515 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
516 return TTS_ERROR_INVALID_STATE;
519 if (NULL != client->credential) {
520 free(client->credential);
521 client->credential = NULL;
524 client->internal = true;
527 if (NULL != credential) {
528 key = strdup("EnableServerTTS");
529 client->credential = strdup(credential);
530 if (NULL == client->credential) {
531 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
536 return TTS_ERROR_OUT_OF_MEMORY;
539 key = strdup("DisableServerTTS");
543 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
544 return TTS_ERROR_OUT_OF_MEMORY;
549 int ret = app_manager_get_app_id(pid, &appid);
550 if (0 != ret || NULL == appid) {
551 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
558 return TTS_ERROR_OPERATION_FAILED;
561 ret = tts_set_private_data(tts, key, appid);
563 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
576 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
578 return TTS_ERROR_NONE;
581 static Eina_Bool __tts_connect_daemon(void *data)
583 tts_h tts = (tts_h)data;
584 tts_client_s* client = tts_client_get(tts);
587 if (NULL == client) {
588 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
593 if (0 != tts_dbus_request_hello(client->uid)) {
597 SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
599 /* do request initialize */
601 bool credential_needed = false;
603 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
605 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
606 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
608 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
611 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
612 client->conn_timer = NULL;
615 } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
616 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
618 client->reason = TTS_ERROR_PERMISSION_DENIED;
621 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
622 client->conn_timer = NULL;
625 } else if (TTS_ERROR_NONE != ret) {
626 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
630 /* success to connect tts-daemon */
631 client->credential_needed = credential_needed;
632 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
635 client->conn_timer = NULL;
637 client = tts_client_get(tts);
639 if (NULL == client) {
640 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
644 client->before_state = client->current_state;
645 client->current_state = TTS_STATE_READY;
647 if (NULL != client->state_changed_cb) {
648 tts_client_use_callback(client);
649 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
650 tts_client_not_use_callback(client);
652 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
655 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
660 int tts_prepare(tts_h tts)
662 if (0 != __tts_get_feature_enabled()) {
663 return TTS_ERROR_NOT_SUPPORTED;
666 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
668 tts_client_s* client = tts_client_get(tts);
671 if (NULL == client) {
672 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
673 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
674 return TTS_ERROR_INVALID_PARAMETER;
678 if (client->current_state != TTS_STATE_CREATED) {
679 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
680 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
681 return TTS_ERROR_INVALID_STATE;
684 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
686 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
688 return TTS_ERROR_NONE;
691 int tts_unprepare(tts_h tts)
693 if (0 != __tts_get_feature_enabled()) {
694 return TTS_ERROR_NOT_SUPPORTED;
697 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
699 tts_client_s* client = tts_client_get(tts);
702 if (NULL == client) {
703 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
704 return TTS_ERROR_INVALID_PARAMETER;
708 if (client->current_state != TTS_STATE_READY) {
709 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
710 return TTS_ERROR_INVALID_STATE;
715 int screen_reader = -1;
717 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
719 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
721 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
722 g_screen_reader = (bool)screen_reader;
725 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
727 ret = tts_dbus_request_finalize(client->uid);
729 if (TTS_ERROR_TIMED_OUT != ret) {
730 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
733 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
736 if (TTS_RETRY_COUNT == count) {
737 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
744 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
747 client->before_state = client->current_state;
748 client->current_state = TTS_STATE_CREATED;
750 if (NULL != client->state_changed_cb) {
751 tts_client_use_callback(client);
752 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
753 tts_client_not_use_callback(client);
754 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
757 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
759 return TTS_ERROR_NONE;
762 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
764 tts_h tts = (tts_h)user_data;
766 tts_client_s* client = tts_client_get(tts);
767 if (NULL == client) {
768 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
772 /* call callback function */
773 if (NULL != client->supported_voice_cb) {
774 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
776 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
782 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
784 if (0 != __tts_get_feature_enabled()) {
785 return TTS_ERROR_NOT_SUPPORTED;
788 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
790 if (NULL == tts || NULL == callback) {
791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
792 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
793 return TTS_ERROR_INVALID_PARAMETER;
796 tts_client_s* client = tts_client_get(tts);
799 if (NULL == client) {
800 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
801 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
802 return TTS_ERROR_INVALID_PARAMETER;
806 char* current_engine = NULL;
807 ret = tts_config_mgr_get_engine(¤t_engine);
809 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
810 return __tts_convert_config_error_code(ret);
813 client->supported_voice_cb = callback;
814 client->supported_voice_user_data = user_data;
816 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
818 if (NULL != current_engine) {
819 free(current_engine);
820 current_engine = NULL;
823 client->supported_voice_cb = NULL;
824 client->supported_voice_user_data = NULL;
827 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
828 ret = TTS_ERROR_OPERATION_FAILED;
831 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
836 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
838 if (0 != __tts_get_feature_enabled()) {
839 return TTS_ERROR_NOT_SUPPORTED;
842 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
845 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
846 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
847 return TTS_ERROR_INVALID_PARAMETER;
850 tts_client_s* client = tts_client_get(tts);
852 if (NULL == client) {
853 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
854 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
855 return TTS_ERROR_INVALID_PARAMETER;
858 /* Request call remote method */
860 ret = tts_config_mgr_get_voice(lang, vctype);
862 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
863 return __tts_convert_config_error_code(ret);
865 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
868 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
873 int tts_get_max_text_size(tts_h tts, unsigned int* size)
875 if (0 != __tts_get_feature_enabled()) {
876 return TTS_ERROR_NOT_SUPPORTED;
879 if (NULL == tts || NULL == size) {
880 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
881 return TTS_ERROR_INVALID_PARAMETER;
884 tts_client_s* client = tts_client_get(tts);
886 if (NULL == client) {
887 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
888 return TTS_ERROR_INVALID_PARAMETER;
891 if (TTS_STATE_READY != client->current_state) {
892 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
893 return TTS_ERROR_INVALID_STATE;
896 if (0 != tts_config_mgr_get_max_text_size(size)) {
897 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
898 return TTS_ERROR_INVALID_PARAMETER;
901 g_max_text_size = (int)*size;
903 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
904 return TTS_ERROR_NONE;
907 int tts_get_state(tts_h tts, tts_state_e* state)
909 if (0 != __tts_get_feature_enabled()) {
910 return TTS_ERROR_NOT_SUPPORTED;
913 if (NULL == tts || NULL == state) {
914 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
915 return TTS_ERROR_INVALID_PARAMETER;
918 tts_client_s* client = tts_client_get(tts);
920 if (NULL == client) {
921 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
922 return TTS_ERROR_INVALID_PARAMETER;
925 *state = client->current_state;
928 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
929 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
930 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
931 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
932 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
935 return TTS_ERROR_NONE;
938 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
940 if (0 != __tts_get_feature_enabled()) {
941 return TTS_ERROR_NOT_SUPPORTED;
944 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
945 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
946 return TTS_ERROR_INVALID_PARAMETER;
949 tts_client_s* client = tts_client_get(tts);
951 if (NULL == client) {
952 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
953 return TTS_ERROR_INVALID_PARAMETER;
956 *min = TTS_SPEED_MIN;
957 *normal = TTS_SPEED_NORMAL;
958 *max = TTS_SPEED_MAX;
960 return TTS_ERROR_NONE;
963 int tts_get_error_message(tts_h tts, char** err_msg)
965 if (0 != __tts_get_feature_enabled()) {
966 return TTS_ERROR_NOT_SUPPORTED;
969 if (NULL == tts || NULL == err_msg) {
970 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
971 return TTS_ERROR_INVALID_PARAMETER;
974 tts_client_s* client = tts_client_get(tts);
976 if (NULL == client) {
977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
978 return TTS_ERROR_INVALID_PARAMETER;
981 if (NULL != client->err_msg) {
982 *err_msg = strdup(client->err_msg);
983 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
986 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
989 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
991 return TTS_ERROR_NONE;
994 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
996 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
998 if (0 != __tts_get_feature_enabled()) {
999 return TTS_ERROR_NOT_SUPPORTED;
1003 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1004 return TTS_ERROR_INVALID_PARAMETER;
1007 if (voice_type < 0) {
1008 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1009 return TTS_ERROR_INVALID_PARAMETER;
1012 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1014 if (NULL == tts || NULL == utt_id) {
1015 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1016 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1017 return TTS_ERROR_INVALID_PARAMETER;
1020 tts_client_s* client = tts_client_get(tts);
1022 if (NULL == client) {
1023 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1024 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1025 return TTS_ERROR_INVALID_PARAMETER;
1028 if (TTS_STATE_CREATED == client->current_state) {
1029 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1030 return TTS_ERROR_INVALID_STATE;
1033 if (-1 == g_max_text_size) {
1034 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1035 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1036 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1037 return TTS_ERROR_INVALID_PARAMETER;
1041 if (0 == g_max_text_size) {
1042 if (strlen(text) <= 0) {
1043 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1044 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1045 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1046 return TTS_ERROR_INVALID_PARAMETER;
1049 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1050 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1051 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1052 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1053 return TTS_ERROR_INVALID_PARAMETER;
1057 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1058 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1059 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1060 return TTS_ERROR_INVALID_PARAMETER;
1063 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1064 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1065 return TTS_ERROR_INVALID_STATE;
1068 if (true == client->credential_needed && NULL == client->credential) {
1069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1070 return TTS_ERROR_PERMISSION_DENIED;
1073 /* check valid utf8 */
1077 dbus_error_init(&err);
1079 valid = dbus_validate_utf8(text, &err);
1080 if (dbus_error_is_set(&err)) {
1081 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1082 dbus_error_free(&err);
1083 return TTS_ERROR_INVALID_PARAMETER;
1086 if (valid != true) {
1087 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1088 return TTS_ERROR_INVALID_PARAMETER;
1090 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1092 /* change default language value */
1095 if (NULL == language)
1096 temp = strdup("default");
1098 temp = strdup(language);
1100 client->current_utt_id++;
1101 if (client->current_utt_id == 10000) {
1102 client->current_utt_id = 1;
1109 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1111 if (TTS_ERROR_TIMED_OUT != ret) {
1112 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1115 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1118 if (TTS_RETRY_MIN_COUNT == count) {
1119 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1124 *utt_id = client->current_utt_id;
1133 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1138 static void __tts_play_async(void *data)
1140 tts_h tts = (tts_h)data;
1141 tts_client_s* client = tts_client_get(tts);
1144 if (NULL == client) {
1145 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1152 ret = tts_dbus_request_play(client->uid, client->credential);
1154 if (TTS_ERROR_TIMED_OUT != ret) {
1155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1158 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1161 if (TTS_RETRY_COUNT == count) {
1162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1170 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1172 client->reason = ret;
1173 client->utt_id = -1;
1175 ecore_timer_add(0, __tts_notify_error, client->tts);
1179 client->before_state = client->current_state;
1180 client->current_state = TTS_STATE_PLAYING;
1182 if (NULL != client->state_changed_cb) {
1183 tts_client_use_callback(client);
1184 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1185 tts_client_not_use_callback(client);
1186 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1189 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1194 int tts_play_async(tts_h tts)
1196 if (0 != __tts_get_feature_enabled()) {
1197 return TTS_ERROR_NOT_SUPPORTED;
1200 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1203 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1204 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1205 return TTS_ERROR_INVALID_PARAMETER;
1208 tts_client_s* client = tts_client_get(tts);
1210 if (NULL == client) {
1211 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1212 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1213 return TTS_ERROR_INVALID_PARAMETER;
1216 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1217 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1218 return TTS_ERROR_INVALID_STATE;
1221 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1222 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1223 return TTS_ERROR_INVALID_STATE;
1226 if (true == client->credential_needed && NULL == client->credential) {
1227 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1228 return TTS_ERROR_PERMISSION_DENIED;
1231 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1233 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1235 return TTS_ERROR_NONE;
1238 int tts_play(tts_h tts)
1240 if (0 != __tts_get_feature_enabled()) {
1241 return TTS_ERROR_NOT_SUPPORTED;
1244 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1247 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1248 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1249 return TTS_ERROR_INVALID_PARAMETER;
1252 tts_client_s* client = tts_client_get(tts);
1254 if (NULL == client) {
1255 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1256 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1257 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1258 return TTS_ERROR_INVALID_PARAMETER;
1261 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1263 return TTS_ERROR_INVALID_STATE;
1266 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1267 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1268 return TTS_ERROR_INVALID_STATE;
1271 if (true == client->credential_needed && NULL == client->credential) {
1272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1273 return TTS_ERROR_PERMISSION_DENIED;
1279 ret = tts_dbus_request_play(client->uid, client->credential);
1281 if (TTS_ERROR_TIMED_OUT != ret) {
1282 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1285 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1288 if (TTS_RETRY_COUNT == count) {
1289 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1296 client->before_state = client->current_state;
1297 client->current_state = TTS_STATE_PLAYING;
1299 if (NULL != client->state_changed_cb) {
1300 tts_client_use_callback(client);
1301 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1302 tts_client_not_use_callback(client);
1303 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1306 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1308 return TTS_ERROR_NONE;
1311 static void __tts_stop_async(void *data)
1313 tts_h tts = (tts_h)data;
1314 tts_client_s* client = tts_client_get(tts);
1317 if (NULL == client) {
1318 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1325 ret = tts_dbus_request_stop(client->uid);
1327 if (TTS_ERROR_TIMED_OUT != ret) {
1328 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1331 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1334 if (TTS_RETRY_COUNT == count) {
1335 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1343 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1345 client->reason = ret;
1346 client->utt_id = -1;
1348 ecore_timer_add(0, __tts_notify_error, client->tts);
1352 client->before_state = client->current_state;
1353 client->current_state = TTS_STATE_READY;
1355 if (NULL != client->state_changed_cb) {
1356 tts_client_use_callback(client);
1357 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1358 tts_client_not_use_callback(client);
1359 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1362 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1367 int tts_stop_aync(tts_h tts)
1369 if (0 != __tts_get_feature_enabled()) {
1370 return TTS_ERROR_NOT_SUPPORTED;
1373 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1376 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1377 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1378 return TTS_ERROR_INVALID_PARAMETER;
1381 tts_client_s* client = tts_client_get(tts);
1383 if (NULL == client) {
1384 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1385 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1386 return TTS_ERROR_INVALID_PARAMETER;
1389 if (TTS_STATE_CREATED == client->current_state) {
1390 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1391 return TTS_ERROR_INVALID_STATE;
1394 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1395 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1396 return TTS_ERROR_INVALID_STATE;
1399 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1401 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1403 return TTS_ERROR_NONE;
1406 int tts_stop(tts_h tts)
1408 if (0 != __tts_get_feature_enabled()) {
1409 return TTS_ERROR_NOT_SUPPORTED;
1412 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1415 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1416 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1417 return TTS_ERROR_INVALID_PARAMETER;
1420 tts_client_s* client = tts_client_get(tts);
1422 if (NULL == client) {
1423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1424 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1425 return TTS_ERROR_INVALID_PARAMETER;
1428 if (TTS_STATE_CREATED == client->current_state) {
1429 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1430 return TTS_ERROR_INVALID_STATE;
1433 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1434 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1435 return TTS_ERROR_INVALID_STATE;
1441 ret = tts_dbus_request_stop(client->uid);
1443 if (TTS_ERROR_TIMED_OUT != ret) {
1444 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1447 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1450 if (TTS_RETRY_COUNT == count) {
1451 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1458 client->before_state = client->current_state;
1459 client->current_state = TTS_STATE_READY;
1461 if (NULL != client->state_changed_cb) {
1462 tts_client_use_callback(client);
1463 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1464 tts_client_not_use_callback(client);
1465 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1468 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1470 return TTS_ERROR_NONE;
1473 static void __tts_pause_async(void *data)
1475 tts_h tts = (tts_h)data;
1476 tts_client_s* client = tts_client_get(tts);
1479 if (NULL == client) {
1480 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1487 ret = tts_dbus_request_pause(client->uid);
1489 if (TTS_ERROR_TIMED_OUT != ret) {
1490 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1493 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1496 if (TTS_RETRY_COUNT == count) {
1497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1505 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1507 client->reason = ret;
1508 client->utt_id = -1;
1510 ecore_timer_add(0, __tts_notify_error, client->tts);
1514 client->before_state = client->current_state;
1515 client->current_state = TTS_STATE_PAUSED;
1517 if (NULL != client->state_changed_cb) {
1518 tts_client_use_callback(client);
1519 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1520 tts_client_not_use_callback(client);
1521 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1524 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1529 int tts_pause_async(tts_h tts)
1531 if (0 != __tts_get_feature_enabled()) {
1532 return TTS_ERROR_NOT_SUPPORTED;
1535 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1538 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1539 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1540 return TTS_ERROR_INVALID_PARAMETER;
1543 tts_client_s* client = tts_client_get(tts);
1545 if (NULL == client) {
1546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1547 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1548 return TTS_ERROR_INVALID_PARAMETER;
1551 if (TTS_STATE_PLAYING != client->current_state) {
1552 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1553 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1554 return TTS_ERROR_INVALID_STATE;
1557 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1558 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1559 return TTS_ERROR_INVALID_STATE;
1562 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1564 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1566 return TTS_ERROR_NONE;
1569 int tts_pause(tts_h tts)
1571 if (0 != __tts_get_feature_enabled()) {
1572 return TTS_ERROR_NOT_SUPPORTED;
1575 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1578 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1579 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1580 return TTS_ERROR_INVALID_PARAMETER;
1583 tts_client_s* client = tts_client_get(tts);
1585 if (NULL == client) {
1586 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1587 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1588 return TTS_ERROR_INVALID_PARAMETER;
1591 if (TTS_STATE_PLAYING != client->current_state) {
1592 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1593 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1594 return TTS_ERROR_INVALID_STATE;
1597 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1598 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1599 return TTS_ERROR_INVALID_STATE;
1605 ret = tts_dbus_request_pause(client->uid);
1607 if (TTS_ERROR_TIMED_OUT != ret) {
1608 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1611 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1614 if (TTS_RETRY_COUNT == count) {
1615 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1622 client->before_state = client->current_state;
1623 client->current_state = TTS_STATE_PAUSED;
1625 if (NULL != client->state_changed_cb) {
1626 tts_client_use_callback(client);
1627 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1628 tts_client_not_use_callback(client);
1629 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1632 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1634 return TTS_ERROR_NONE;
1637 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1639 if (0 != __tts_get_feature_enabled()) {
1640 return TTS_ERROR_NOT_SUPPORTED;
1643 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1646 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1647 return TTS_ERROR_INVALID_PARAMETER;
1650 if (NULL == key || NULL == data) {
1651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1652 return TTS_ERROR_INVALID_PARAMETER;
1655 tts_client_s* client = tts_client_get(tts);
1657 if (NULL == client) {
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1659 return TTS_ERROR_INVALID_PARAMETER;
1662 if (TTS_STATE_READY != client->current_state) {
1663 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1664 return TTS_ERROR_INVALID_STATE;
1667 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1668 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1669 return TTS_ERROR_INVALID_PARAMETER;
1675 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1677 if (TTS_ERROR_TIMED_OUT != ret) {
1678 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1681 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1684 if (TTS_RETRY_COUNT == count) {
1685 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1692 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1697 int tts_get_private_data(tts_h tts, const char* key, char** data)
1699 if (0 != __tts_get_feature_enabled()) {
1700 return TTS_ERROR_NOT_SUPPORTED;
1703 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1706 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1707 return TTS_ERROR_INVALID_PARAMETER;
1710 if (NULL == key || NULL == data) {
1711 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1712 return TTS_ERROR_INVALID_PARAMETER;
1715 tts_client_s* client = tts_client_get(tts);
1717 if (NULL == client) {
1718 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1719 return TTS_ERROR_INVALID_PARAMETER;
1722 if (TTS_STATE_READY != client->current_state) {
1723 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1724 return TTS_ERROR_INVALID_STATE;
1730 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1732 if (TTS_ERROR_TIMED_OUT != ret) {
1733 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1736 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1739 if (TTS_RETRY_COUNT == count) {
1740 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1747 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1752 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1757 static Eina_Bool __tts_notify_error(void *data)
1759 tts_h tts = (tts_h)data;
1761 tts_client_s* client = tts_client_get(tts);
1764 if (NULL == client) {
1765 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1769 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1771 if (NULL != client->error_cb) {
1772 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1773 tts_client_use_callback(client);
1774 g_err_callback_status = true;
1775 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1776 g_err_callback_status = false;
1777 tts_client_not_use_callback(client);
1779 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1785 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1788 GList* client_list = NULL;
1789 client_list = tts_client_get_client_list();
1792 tts_client_s *data = NULL;
1794 if (g_list_length(client_list) > 0) {
1795 /* Get a first item */
1796 iter = g_list_first(client_list);
1798 while (NULL != iter) {
1801 data->utt_id = utt_id;
1802 data->reason = reason;
1803 if (NULL != data->err_msg) {
1804 free(data->err_msg);
1805 data->err_msg = NULL;
1807 if (NULL != err_msg)
1808 data->err_msg = strdup(err_msg);
1810 /* call callback function */
1811 if (NULL != data->error_cb) {
1812 ecore_timer_add(0, __tts_notify_error, data->tts);
1814 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1817 if (TTS_ERROR_SERVICE_RESET == reason) {
1818 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1820 data->current_state = TTS_STATE_CREATED;
1821 if (0 != tts_prepare(data->tts)) {
1822 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1827 iter = g_list_next(iter);
1831 tts_client_s* client = tts_client_get_by_uid(uid);
1833 if (NULL == client) {
1834 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1835 return TTS_ERROR_INVALID_PARAMETER;
1838 client->utt_id = utt_id;
1839 client->reason = reason;
1840 if (NULL != client->err_msg) {
1841 free(client->err_msg);
1842 client->err_msg = NULL;
1844 if (NULL != err_msg)
1845 client->err_msg = strdup(err_msg);
1847 /* call callback function */
1848 if (NULL != client->error_cb) {
1849 ecore_timer_add(0, __tts_notify_error, client->tts);
1851 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1854 if (TTS_ERROR_SERVICE_RESET == reason) {
1855 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1857 client->current_state = TTS_STATE_CREATED;
1858 if (0 != tts_prepare(client->tts)) {
1859 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1867 static Eina_Bool __tts_notify_state_changed(void *data)
1869 tts_h tts = (tts_h)data;
1871 tts_client_s* client = tts_client_get(tts);
1874 if (NULL == client) {
1875 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1879 if (NULL != client->state_changed_cb) {
1880 tts_client_use_callback(client);
1881 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1882 tts_client_not_use_callback(client);
1883 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1885 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1891 int __tts_cb_set_state(int uid, int state)
1893 tts_client_s* client = tts_client_get_by_uid(uid);
1894 if (NULL == client) {
1895 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1899 tts_state_e state_from_daemon = (tts_state_e)state;
1901 if (client->current_state == state_from_daemon) {
1902 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1906 if (NULL != client->state_changed_cb) {
1907 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1909 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1912 client->before_state = client->current_state;
1913 client->current_state = state_from_daemon;
1918 int __tts_cb_utt_started(int uid, int utt_id)
1920 tts_client_s* client = tts_client_get_by_uid(uid);
1922 if (NULL == client) {
1923 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1924 return TTS_ERROR_INVALID_PARAMETER;
1927 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1929 client->utt_id = utt_id;
1931 /* call callback function */
1932 if (NULL != client->utt_started_cb) {
1933 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1934 tts_client_use_callback(client);
1935 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1936 tts_client_not_use_callback(client);
1938 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1944 int __tts_cb_utt_completed(int uid, int utt_id)
1946 tts_client_s* client = tts_client_get_by_uid(uid);
1948 if (NULL == client) {
1949 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1950 return TTS_ERROR_INVALID_PARAMETER;
1953 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1955 client->utt_id = utt_id;
1957 /* call callback function */
1958 if (NULL != client->utt_completeted_cb) {
1959 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1960 tts_client_use_callback(client);
1961 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1962 tts_client_not_use_callback(client);
1964 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1970 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1972 if (0 != __tts_get_feature_enabled()) {
1973 return TTS_ERROR_NOT_SUPPORTED;
1976 if (NULL == tts || NULL == callback) {
1977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1978 return TTS_ERROR_INVALID_PARAMETER;
1981 tts_client_s* client = tts_client_get(tts);
1983 if (NULL == client) {
1984 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1985 return TTS_ERROR_INVALID_PARAMETER;
1988 if (TTS_STATE_CREATED != client->current_state) {
1989 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1990 return TTS_ERROR_INVALID_STATE;
1993 client->state_changed_cb = callback;
1994 client->state_changed_user_data = user_data;
1996 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2001 int tts_unset_state_changed_cb(tts_h tts)
2003 if (0 != __tts_get_feature_enabled()) {
2004 return TTS_ERROR_NOT_SUPPORTED;
2008 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2009 return TTS_ERROR_INVALID_PARAMETER;
2012 tts_client_s* client = tts_client_get(tts);
2014 if (NULL == client) {
2015 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2016 return TTS_ERROR_INVALID_PARAMETER;
2019 if (TTS_STATE_CREATED != client->current_state) {
2020 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2021 return TTS_ERROR_INVALID_STATE;
2024 client->state_changed_cb = NULL;
2025 client->state_changed_user_data = NULL;
2027 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2032 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2034 if (0 != __tts_get_feature_enabled()) {
2035 return TTS_ERROR_NOT_SUPPORTED;
2038 if (NULL == tts || NULL == callback) {
2039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2040 return TTS_ERROR_INVALID_PARAMETER;
2043 tts_client_s* client = tts_client_get(tts);
2045 if (NULL == client) {
2046 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2047 return TTS_ERROR_INVALID_PARAMETER;
2050 if (TTS_STATE_CREATED != client->current_state) {
2051 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2052 return TTS_ERROR_INVALID_STATE;
2055 client->utt_started_cb = callback;
2056 client->utt_started_user_data = user_data;
2058 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2063 int tts_unset_utterance_started_cb(tts_h tts)
2065 if (0 != __tts_get_feature_enabled()) {
2066 return TTS_ERROR_NOT_SUPPORTED;
2070 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2071 return TTS_ERROR_INVALID_PARAMETER;
2074 tts_client_s* client = tts_client_get(tts);
2076 if (NULL == client) {
2077 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2078 return TTS_ERROR_INVALID_PARAMETER;
2081 if (TTS_STATE_CREATED != client->current_state) {
2082 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2083 return TTS_ERROR_INVALID_STATE;
2086 client->utt_started_cb = NULL;
2087 client->utt_started_user_data = NULL;
2089 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2094 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2096 if (0 != __tts_get_feature_enabled()) {
2097 return TTS_ERROR_NOT_SUPPORTED;
2100 if (NULL == tts || NULL == callback) {
2101 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2102 return TTS_ERROR_INVALID_PARAMETER;
2105 tts_client_s* client = tts_client_get(tts);
2107 if (NULL == client) {
2108 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2109 return TTS_ERROR_INVALID_PARAMETER;
2112 if (TTS_STATE_CREATED != client->current_state) {
2113 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2114 return TTS_ERROR_INVALID_STATE;
2117 client->utt_completeted_cb = callback;
2118 client->utt_completed_user_data = user_data;
2120 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2125 int tts_unset_utterance_completed_cb(tts_h tts)
2127 if (0 != __tts_get_feature_enabled()) {
2128 return TTS_ERROR_NOT_SUPPORTED;
2132 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2133 return TTS_ERROR_INVALID_PARAMETER;
2136 tts_client_s* client = tts_client_get(tts);
2138 if (NULL == client) {
2139 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2140 return TTS_ERROR_INVALID_PARAMETER;
2143 if (TTS_STATE_CREATED != client->current_state) {
2144 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2145 return TTS_ERROR_INVALID_STATE;
2148 client->utt_completeted_cb = NULL;
2149 client->utt_completed_user_data = NULL;
2151 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2155 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2157 if (0 != __tts_get_feature_enabled()) {
2158 return TTS_ERROR_NOT_SUPPORTED;
2161 if (NULL == tts || NULL == callback) {
2162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2163 return TTS_ERROR_INVALID_PARAMETER;
2166 tts_client_s* client = tts_client_get(tts);
2168 if (NULL == client) {
2169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2170 return TTS_ERROR_INVALID_PARAMETER;
2173 if (TTS_STATE_CREATED != client->current_state) {
2174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2175 return TTS_ERROR_INVALID_STATE;
2178 client->error_cb = callback;
2179 client->error_user_data = user_data;
2181 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2186 int tts_unset_error_cb(tts_h tts)
2188 if (0 != __tts_get_feature_enabled()) {
2189 return TTS_ERROR_NOT_SUPPORTED;
2193 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2194 return TTS_ERROR_INVALID_PARAMETER;
2197 tts_client_s* client = tts_client_get(tts);
2199 if (NULL == client) {
2200 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2201 return TTS_ERROR_INVALID_PARAMETER;
2204 if (TTS_STATE_CREATED != client->current_state) {
2205 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2206 return TTS_ERROR_INVALID_STATE;
2209 client->error_cb = NULL;
2210 client->error_user_data = NULL;
2212 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2217 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2219 if (0 != __tts_get_feature_enabled()) {
2220 return TTS_ERROR_NOT_SUPPORTED;
2223 if (NULL == tts || NULL == callback) {
2224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2225 return TTS_ERROR_INVALID_PARAMETER;
2228 tts_client_s* client = tts_client_get(tts);
2230 if (NULL == client) {
2231 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2232 return TTS_ERROR_INVALID_PARAMETER;
2235 if (TTS_STATE_CREATED != client->current_state) {
2236 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2237 return TTS_ERROR_INVALID_STATE;
2240 client->default_voice_changed_cb = callback;
2241 client->default_voice_changed_user_data = user_data;
2243 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2248 int tts_unset_default_voice_changed_cb(tts_h tts)
2250 if (0 != __tts_get_feature_enabled()) {
2251 return TTS_ERROR_NOT_SUPPORTED;
2255 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2256 return TTS_ERROR_INVALID_PARAMETER;
2259 tts_client_s* client = tts_client_get(tts);
2261 if (NULL == client) {
2262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2263 return TTS_ERROR_INVALID_PARAMETER;
2266 if (TTS_STATE_CREATED != client->current_state) {
2267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2268 return TTS_ERROR_INVALID_STATE;
2271 client->default_voice_changed_cb = NULL;
2272 client->default_voice_changed_user_data = NULL;
2274 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2279 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2281 if (0 != __tts_get_feature_enabled()) {
2282 return TTS_ERROR_NOT_SUPPORTED;
2285 if (NULL == tts || NULL == callback) {
2286 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2287 return TTS_ERROR_INVALID_PARAMETER;
2290 tts_client_s* client = tts_client_get(tts);
2292 if (NULL == client) {
2293 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2294 return TTS_ERROR_INVALID_PARAMETER;
2297 if (TTS_STATE_CREATED != client->current_state) {
2298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2299 return TTS_ERROR_INVALID_STATE;
2302 client->engine_changed_cb = callback;
2303 client->engine_changed_user_data = user_data;
2305 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2310 int tts_unset_engine_changed_cb(tts_h tts)
2312 if (0 != __tts_get_feature_enabled()) {
2313 return TTS_ERROR_NOT_SUPPORTED;
2317 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2318 return TTS_ERROR_INVALID_PARAMETER;
2321 tts_client_s* client = tts_client_get(tts);
2323 if (NULL == client) {
2324 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2325 return TTS_ERROR_INVALID_PARAMETER;
2328 if (TTS_STATE_CREATED != client->current_state) {
2329 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2330 return TTS_ERROR_INVALID_STATE;
2333 client->engine_changed_cb = NULL;
2334 client->engine_changed_user_data = NULL;
2336 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2341 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2343 if (0 != __tts_get_feature_enabled()) {
2344 return TTS_ERROR_NOT_SUPPORTED;
2347 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2350 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2351 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2352 return TTS_ERROR_INVALID_PARAMETER;
2355 tts_client_s* client = tts_client_get(tts);
2357 if (NULL == client) {
2358 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2359 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2360 return TTS_ERROR_INVALID_PARAMETER;
2363 if (TTS_STATE_CREATED == client->current_state) {
2364 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2365 return TTS_ERROR_INVALID_STATE;
2368 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2369 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2370 return TTS_ERROR_INVALID_STATE;
2376 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2378 if (TTS_ERROR_TIMED_OUT != ret) {
2379 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2382 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2385 if (TTS_RETRY_COUNT == count) {
2386 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2393 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2395 return TTS_ERROR_NONE;
2398 int tts_play_pcm(tts_h tts)
2400 if (0 != __tts_get_feature_enabled()) {
2401 return TTS_ERROR_NOT_SUPPORTED;
2404 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2407 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2408 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2409 return TTS_ERROR_INVALID_PARAMETER;
2412 tts_client_s* client = tts_client_get(tts);
2414 if (NULL == client) {
2415 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2416 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2417 return TTS_ERROR_INVALID_PARAMETER;
2420 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2421 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2422 return TTS_ERROR_INVALID_STATE;
2425 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2426 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2427 return TTS_ERROR_INVALID_STATE;
2433 ret = tts_dbus_request_play_pcm(client->uid);
2435 if (TTS_ERROR_TIMED_OUT != ret) {
2436 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2439 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2442 if (TTS_RETRY_COUNT == count) {
2443 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2450 client->before_state = client->current_state;
2451 client->current_state = TTS_STATE_PLAYING;
2453 if (NULL != client->state_changed_cb) {
2454 tts_client_use_callback(client);
2455 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2456 tts_client_not_use_callback(client);
2457 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2460 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2462 return TTS_ERROR_NONE;
2465 int tts_stop_pcm(tts_h tts)
2467 if (0 != __tts_get_feature_enabled()) {
2468 return TTS_ERROR_NOT_SUPPORTED;
2471 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2474 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2475 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2476 return TTS_ERROR_INVALID_PARAMETER;
2479 tts_client_s* client = tts_client_get(tts);
2481 if (NULL == client) {
2482 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2483 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2484 return TTS_ERROR_INVALID_PARAMETER;
2487 if (TTS_STATE_CREATED == client->current_state) {
2488 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2489 return TTS_ERROR_INVALID_STATE;
2492 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2493 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2494 return TTS_ERROR_INVALID_STATE;
2500 ret = tts_dbus_request_stop_pcm(client->uid);
2502 if (TTS_ERROR_TIMED_OUT != ret) {
2503 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2506 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2509 if (TTS_RETRY_COUNT == count) {
2510 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2517 client->before_state = client->current_state;
2518 client->current_state = TTS_STATE_READY;
2520 if (NULL != client->state_changed_cb) {
2521 tts_client_use_callback(client);
2522 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2523 tts_client_not_use_callback(client);
2524 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2527 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2529 return TTS_ERROR_NONE;