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.02, __tts_connect_daemon, (void*)tts);
686 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
688 return TTS_ERROR_NONE;
691 int tts_prepare_sync(tts_h tts)
693 if (0 != __tts_get_feature_enabled()) {
694 return TTS_ERROR_NOT_SUPPORTED;
697 SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare 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 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
705 return TTS_ERROR_INVALID_PARAMETER;
709 if (client->current_state != TTS_STATE_CREATED) {
710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
711 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
712 return TTS_ERROR_INVALID_STATE;
716 while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
720 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
722 if (TTS_CONNECTION_RETRY_COUNT == cnt) {
723 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
724 return TTS_ERROR_OPERATION_FAILED;
727 return TTS_ERROR_NONE;
730 int tts_unprepare(tts_h tts)
732 if (0 != __tts_get_feature_enabled()) {
733 return TTS_ERROR_NOT_SUPPORTED;
736 SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
738 tts_client_s* client = tts_client_get(tts);
741 if (NULL == client) {
742 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
743 return TTS_ERROR_INVALID_PARAMETER;
747 if (client->current_state != TTS_STATE_READY) {
748 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
749 return TTS_ERROR_INVALID_STATE;
754 int screen_reader = -1;
756 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
758 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
760 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);
761 g_screen_reader = (bool)screen_reader;
764 bool is_prepared = false;
765 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
767 ret = tts_dbus_request_finalize(client->uid);
769 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
770 client->current_state = TTS_STATE_CREATED;
771 if (0 == tts_prepare_sync(tts)) {
773 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
775 } else if (TTS_ERROR_TIMED_OUT != ret) {
776 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
779 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
782 if (TTS_RETRY_COUNT == count) {
783 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
790 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
793 client->before_state = client->current_state;
794 client->current_state = TTS_STATE_CREATED;
796 if (NULL != client->state_changed_cb) {
797 tts_client_use_callback(client);
798 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
799 tts_client_not_use_callback(client);
800 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
803 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
805 return TTS_ERROR_NONE;
808 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
810 tts_h tts = (tts_h)user_data;
812 tts_client_s* client = tts_client_get(tts);
813 if (NULL == client) {
814 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
818 /* call callback function */
819 if (NULL != client->supported_voice_cb) {
820 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
822 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
828 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
830 if (0 != __tts_get_feature_enabled()) {
831 return TTS_ERROR_NOT_SUPPORTED;
834 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
836 if (NULL == tts || NULL == callback) {
837 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
838 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
839 return TTS_ERROR_INVALID_PARAMETER;
842 tts_client_s* client = tts_client_get(tts);
845 if (NULL == client) {
846 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
847 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
848 return TTS_ERROR_INVALID_PARAMETER;
852 char* current_engine = NULL;
853 ret = tts_config_mgr_get_engine(¤t_engine);
855 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
856 return __tts_convert_config_error_code(ret);
859 client->supported_voice_cb = callback;
860 client->supported_voice_user_data = user_data;
862 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
864 if (NULL != current_engine) {
865 free(current_engine);
866 current_engine = NULL;
869 client->supported_voice_cb = NULL;
870 client->supported_voice_user_data = NULL;
873 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
874 ret = TTS_ERROR_OPERATION_FAILED;
877 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
882 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
884 if (0 != __tts_get_feature_enabled()) {
885 return TTS_ERROR_NOT_SUPPORTED;
888 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
891 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
892 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
893 return TTS_ERROR_INVALID_PARAMETER;
896 tts_client_s* client = tts_client_get(tts);
898 if (NULL == client) {
899 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
900 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
901 return TTS_ERROR_INVALID_PARAMETER;
904 /* Request call remote method */
906 ret = tts_config_mgr_get_voice(lang, vctype);
908 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
909 return __tts_convert_config_error_code(ret);
911 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
914 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
919 int tts_get_max_text_size(tts_h tts, unsigned int* size)
921 if (0 != __tts_get_feature_enabled()) {
922 return TTS_ERROR_NOT_SUPPORTED;
925 if (NULL == tts || NULL == size) {
926 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
927 return TTS_ERROR_INVALID_PARAMETER;
930 tts_client_s* client = tts_client_get(tts);
932 if (NULL == client) {
933 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
934 return TTS_ERROR_INVALID_PARAMETER;
937 if (TTS_STATE_READY != client->current_state) {
938 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
939 return TTS_ERROR_INVALID_STATE;
942 if (0 != tts_config_mgr_get_max_text_size(size)) {
943 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
944 return TTS_ERROR_INVALID_PARAMETER;
947 g_max_text_size = (int)*size;
949 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
950 return TTS_ERROR_NONE;
953 int tts_get_state(tts_h tts, tts_state_e* state)
955 if (0 != __tts_get_feature_enabled()) {
956 return TTS_ERROR_NOT_SUPPORTED;
959 if (NULL == tts || NULL == state) {
960 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
961 return TTS_ERROR_INVALID_PARAMETER;
964 tts_client_s* client = tts_client_get(tts);
966 if (NULL == client) {
967 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
968 return TTS_ERROR_INVALID_PARAMETER;
971 *state = client->current_state;
974 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
975 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
976 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
977 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
978 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
981 return TTS_ERROR_NONE;
984 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
986 if (0 != __tts_get_feature_enabled()) {
987 return TTS_ERROR_NOT_SUPPORTED;
990 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
991 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
992 return TTS_ERROR_INVALID_PARAMETER;
995 tts_client_s* client = tts_client_get(tts);
997 if (NULL == client) {
998 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
999 return TTS_ERROR_INVALID_PARAMETER;
1002 *min = TTS_SPEED_MIN;
1003 *normal = TTS_SPEED_NORMAL;
1004 *max = TTS_SPEED_MAX;
1006 return TTS_ERROR_NONE;
1009 int tts_get_error_message(tts_h tts, char** err_msg)
1011 if (0 != __tts_get_feature_enabled()) {
1012 return TTS_ERROR_NOT_SUPPORTED;
1015 if (NULL == tts || NULL == err_msg) {
1016 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
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] Get state : A handle is not valid");
1024 return TTS_ERROR_INVALID_PARAMETER;
1027 if (NULL != client->err_msg) {
1028 *err_msg = strdup(client->err_msg);
1029 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1032 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1035 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1037 return TTS_ERROR_NONE;
1040 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1042 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1044 if (0 != __tts_get_feature_enabled()) {
1045 return TTS_ERROR_NOT_SUPPORTED;
1049 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1050 return TTS_ERROR_INVALID_PARAMETER;
1053 if (voice_type < 0) {
1054 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1055 return TTS_ERROR_INVALID_PARAMETER;
1058 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1060 if (NULL == tts || NULL == utt_id) {
1061 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1062 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1063 return TTS_ERROR_INVALID_PARAMETER;
1066 tts_client_s* client = tts_client_get(tts);
1068 if (NULL == client) {
1069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1070 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1071 return TTS_ERROR_INVALID_PARAMETER;
1074 if (TTS_STATE_CREATED == client->current_state) {
1075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1076 return TTS_ERROR_INVALID_STATE;
1079 if (-1 == g_max_text_size) {
1080 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1081 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1082 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1083 return TTS_ERROR_INVALID_PARAMETER;
1087 if (0 == g_max_text_size) {
1088 if (strlen(text) <= 0) {
1089 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1090 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1091 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1092 return TTS_ERROR_INVALID_PARAMETER;
1095 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1096 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1097 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1098 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1099 return TTS_ERROR_INVALID_PARAMETER;
1103 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1104 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1105 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1106 return TTS_ERROR_INVALID_PARAMETER;
1109 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1110 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1111 return TTS_ERROR_INVALID_STATE;
1114 if (true == client->credential_needed && NULL == client->credential) {
1115 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1116 return TTS_ERROR_PERMISSION_DENIED;
1119 /* check valid utf8 */
1123 dbus_error_init(&err);
1125 valid = dbus_validate_utf8(text, &err);
1126 if (dbus_error_is_set(&err)) {
1127 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1128 dbus_error_free(&err);
1129 return TTS_ERROR_INVALID_PARAMETER;
1132 if (valid != true) {
1133 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1134 return TTS_ERROR_INVALID_PARAMETER;
1136 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1138 /* change default language value */
1141 if (NULL == language)
1142 temp = strdup("default");
1144 temp = strdup(language);
1146 client->current_utt_id++;
1147 if (client->current_utt_id == 10000) {
1148 client->current_utt_id = 1;
1154 bool is_prepared = false;
1156 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1158 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1159 client->current_state = TTS_STATE_CREATED;
1160 if (0 == tts_prepare_sync(tts)) {
1162 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1164 } else if (TTS_ERROR_TIMED_OUT != ret) {
1165 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1168 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1171 if (TTS_RETRY_MIN_COUNT == count) {
1172 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1177 *utt_id = client->current_utt_id;
1186 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1191 static void __tts_play_async(void *data)
1193 tts_h tts = (tts_h)data;
1194 tts_client_s* client = tts_client_get(tts);
1197 if (NULL == client) {
1198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1204 bool is_prepared = false;
1206 ret = tts_dbus_request_play(client->uid, client->credential);
1208 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1209 client->current_state = TTS_STATE_CREATED;
1210 if (0 == tts_prepare_sync(tts)) {
1212 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1214 } else 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 play : %s", __tts_get_error_code(ret));
1221 if (TTS_RETRY_COUNT == count) {
1222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1230 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1232 client->reason = ret;
1233 client->utt_id = -1;
1235 ecore_timer_add(0, __tts_notify_error, client->tts);
1239 client->before_state = client->current_state;
1240 client->current_state = TTS_STATE_PLAYING;
1242 if (NULL != client->state_changed_cb) {
1243 tts_client_use_callback(client);
1244 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1245 tts_client_not_use_callback(client);
1246 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1249 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1254 int tts_play_async(tts_h tts)
1256 if (0 != __tts_get_feature_enabled()) {
1257 return TTS_ERROR_NOT_SUPPORTED;
1260 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1263 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1264 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1265 return TTS_ERROR_INVALID_PARAMETER;
1268 tts_client_s* client = tts_client_get(tts);
1270 if (NULL == client) {
1271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1272 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1273 return TTS_ERROR_INVALID_PARAMETER;
1276 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1277 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1278 return TTS_ERROR_INVALID_STATE;
1281 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1282 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1283 return TTS_ERROR_INVALID_STATE;
1286 if (true == client->credential_needed && NULL == client->credential) {
1287 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1288 return TTS_ERROR_PERMISSION_DENIED;
1291 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1293 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1295 return TTS_ERROR_NONE;
1298 int tts_play(tts_h tts)
1300 if (0 != __tts_get_feature_enabled()) {
1301 return TTS_ERROR_NOT_SUPPORTED;
1304 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1307 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1308 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1309 return TTS_ERROR_INVALID_PARAMETER;
1312 tts_client_s* client = tts_client_get(tts);
1314 if (NULL == client) {
1315 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1316 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1317 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1318 return TTS_ERROR_INVALID_PARAMETER;
1321 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1322 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1323 return TTS_ERROR_INVALID_STATE;
1326 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1327 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1328 return TTS_ERROR_INVALID_STATE;
1331 if (true == client->credential_needed && NULL == client->credential) {
1332 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1333 return TTS_ERROR_PERMISSION_DENIED;
1338 bool is_prepared = false;
1340 ret = tts_dbus_request_play(client->uid, client->credential);
1342 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1343 client->current_state = TTS_STATE_CREATED;
1344 if (0 == tts_prepare_sync(tts)) {
1346 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1348 } else if (TTS_ERROR_TIMED_OUT != ret) {
1349 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1352 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1355 if (TTS_RETRY_COUNT == count) {
1356 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1363 client->before_state = client->current_state;
1364 client->current_state = TTS_STATE_PLAYING;
1366 if (NULL != client->state_changed_cb) {
1367 tts_client_use_callback(client);
1368 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1369 tts_client_not_use_callback(client);
1370 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1373 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1375 return TTS_ERROR_NONE;
1378 static void __tts_stop_async(void *data)
1380 tts_h tts = (tts_h)data;
1381 tts_client_s* client = tts_client_get(tts);
1384 if (NULL == client) {
1385 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1391 bool is_prepared = false;
1393 ret = tts_dbus_request_stop(client->uid);
1395 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1396 client->current_state = TTS_STATE_CREATED;
1397 if (0 == tts_prepare_sync(tts)) {
1399 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1401 } else if (TTS_ERROR_TIMED_OUT != ret) {
1402 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1405 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1408 if (TTS_RETRY_COUNT == count) {
1409 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1417 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1419 client->reason = ret;
1420 client->utt_id = -1;
1422 ecore_timer_add(0, __tts_notify_error, client->tts);
1426 client->before_state = client->current_state;
1427 client->current_state = TTS_STATE_READY;
1429 if (NULL != client->state_changed_cb) {
1430 tts_client_use_callback(client);
1431 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1432 tts_client_not_use_callback(client);
1433 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1436 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1441 int tts_stop_aync(tts_h tts)
1443 if (0 != __tts_get_feature_enabled()) {
1444 return TTS_ERROR_NOT_SUPPORTED;
1447 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1450 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1451 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1452 return TTS_ERROR_INVALID_PARAMETER;
1455 tts_client_s* client = tts_client_get(tts);
1457 if (NULL == client) {
1458 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1459 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1460 return TTS_ERROR_INVALID_PARAMETER;
1463 if (TTS_STATE_CREATED == client->current_state) {
1464 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1465 return TTS_ERROR_INVALID_STATE;
1468 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1469 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1470 return TTS_ERROR_INVALID_STATE;
1473 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1475 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1477 return TTS_ERROR_NONE;
1480 int tts_stop(tts_h tts)
1482 if (0 != __tts_get_feature_enabled()) {
1483 return TTS_ERROR_NOT_SUPPORTED;
1486 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1490 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1491 return TTS_ERROR_INVALID_PARAMETER;
1494 tts_client_s* client = tts_client_get(tts);
1496 if (NULL == client) {
1497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1498 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1499 return TTS_ERROR_INVALID_PARAMETER;
1502 if (TTS_STATE_CREATED == client->current_state) {
1503 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1504 return TTS_ERROR_INVALID_STATE;
1507 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1508 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1509 return TTS_ERROR_INVALID_STATE;
1514 bool is_prepared = false;
1516 ret = tts_dbus_request_stop(client->uid);
1518 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1519 client->current_state = TTS_STATE_CREATED;
1520 if (0 == tts_prepare_sync(tts)) {
1522 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1524 } else if (TTS_ERROR_TIMED_OUT != ret) {
1525 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1528 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1531 if (TTS_RETRY_COUNT == count) {
1532 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1539 client->before_state = client->current_state;
1540 client->current_state = TTS_STATE_READY;
1542 if (NULL != client->state_changed_cb) {
1543 tts_client_use_callback(client);
1544 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1545 tts_client_not_use_callback(client);
1546 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1549 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1551 return TTS_ERROR_NONE;
1554 static void __tts_pause_async(void *data)
1556 tts_h tts = (tts_h)data;
1557 tts_client_s* client = tts_client_get(tts);
1560 if (NULL == client) {
1561 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1567 bool is_prepared = false;
1569 ret = tts_dbus_request_pause(client->uid);
1571 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1572 client->current_state = TTS_STATE_CREATED;
1573 if (0 == tts_prepare_sync(tts)) {
1575 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1577 } else if (TTS_ERROR_TIMED_OUT != ret) {
1578 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1581 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1584 if (TTS_RETRY_COUNT == count) {
1585 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1593 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1595 client->reason = ret;
1596 client->utt_id = -1;
1598 ecore_timer_add(0, __tts_notify_error, client->tts);
1602 client->before_state = client->current_state;
1603 client->current_state = TTS_STATE_PAUSED;
1605 if (NULL != client->state_changed_cb) {
1606 tts_client_use_callback(client);
1607 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1608 tts_client_not_use_callback(client);
1609 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1612 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1617 int tts_pause_async(tts_h tts)
1619 if (0 != __tts_get_feature_enabled()) {
1620 return TTS_ERROR_NOT_SUPPORTED;
1623 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1627 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1628 return TTS_ERROR_INVALID_PARAMETER;
1631 tts_client_s* client = tts_client_get(tts);
1633 if (NULL == client) {
1634 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1635 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1636 return TTS_ERROR_INVALID_PARAMETER;
1639 if (TTS_STATE_PLAYING != client->current_state) {
1640 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1641 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1642 return TTS_ERROR_INVALID_STATE;
1645 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1646 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1647 return TTS_ERROR_INVALID_STATE;
1650 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1652 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1654 return TTS_ERROR_NONE;
1657 int tts_pause(tts_h tts)
1659 if (0 != __tts_get_feature_enabled()) {
1660 return TTS_ERROR_NOT_SUPPORTED;
1663 SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1666 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1667 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1668 return TTS_ERROR_INVALID_PARAMETER;
1671 tts_client_s* client = tts_client_get(tts);
1673 if (NULL == client) {
1674 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1675 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1676 return TTS_ERROR_INVALID_PARAMETER;
1679 if (TTS_STATE_PLAYING != client->current_state) {
1680 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1681 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1682 return TTS_ERROR_INVALID_STATE;
1685 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1686 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1687 return TTS_ERROR_INVALID_STATE;
1692 bool is_prepared = false;
1694 ret = tts_dbus_request_pause(client->uid);
1696 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1697 client->current_state = TTS_STATE_CREATED;
1698 if (0 == tts_prepare_sync(tts)) {
1700 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1702 } else if (TTS_ERROR_TIMED_OUT != ret) {
1703 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1706 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1709 if (TTS_RETRY_COUNT == count) {
1710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1717 client->before_state = client->current_state;
1718 client->current_state = TTS_STATE_PAUSED;
1720 if (NULL != client->state_changed_cb) {
1721 tts_client_use_callback(client);
1722 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1723 tts_client_not_use_callback(client);
1724 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1727 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1729 return TTS_ERROR_NONE;
1732 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1734 if (0 != __tts_get_feature_enabled()) {
1735 return TTS_ERROR_NOT_SUPPORTED;
1738 SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1741 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1742 return TTS_ERROR_INVALID_PARAMETER;
1745 if (NULL == key || NULL == data) {
1746 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1747 return TTS_ERROR_INVALID_PARAMETER;
1750 tts_client_s* client = tts_client_get(tts);
1752 if (NULL == client) {
1753 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1754 return TTS_ERROR_INVALID_PARAMETER;
1757 if (TTS_STATE_READY != client->current_state) {
1758 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1759 return TTS_ERROR_INVALID_STATE;
1762 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1763 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1764 return TTS_ERROR_INVALID_PARAMETER;
1769 bool is_prepared = false;
1771 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1773 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1774 client->current_state = TTS_STATE_CREATED;
1775 if (0 == tts_prepare_sync(tts)) {
1777 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1779 } else if (TTS_ERROR_TIMED_OUT != ret) {
1780 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1783 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1786 if (TTS_RETRY_COUNT == count) {
1787 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1794 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1799 int tts_get_private_data(tts_h tts, const char* key, char** data)
1801 if (0 != __tts_get_feature_enabled()) {
1802 return TTS_ERROR_NOT_SUPPORTED;
1805 SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1808 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1809 return TTS_ERROR_INVALID_PARAMETER;
1812 if (NULL == key || NULL == data) {
1813 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1814 return TTS_ERROR_INVALID_PARAMETER;
1817 tts_client_s* client = tts_client_get(tts);
1819 if (NULL == client) {
1820 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1821 return TTS_ERROR_INVALID_PARAMETER;
1824 if (TTS_STATE_READY != client->current_state) {
1825 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1826 return TTS_ERROR_INVALID_STATE;
1831 bool is_prepared = false;
1833 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1835 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1836 client->current_state = TTS_STATE_CREATED;
1837 if (0 == tts_prepare_sync(tts)) {
1839 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1841 } else if (TTS_ERROR_TIMED_OUT != ret) {
1842 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1845 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1848 if (TTS_RETRY_COUNT == count) {
1849 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1856 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1861 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1866 static Eina_Bool __tts_notify_error(void *data)
1868 tts_h tts = (tts_h)data;
1870 tts_client_s* client = tts_client_get(tts);
1873 if (NULL == client) {
1874 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1878 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1880 if (NULL != client->error_cb) {
1881 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1882 tts_client_use_callback(client);
1883 g_err_callback_status = true;
1884 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1885 g_err_callback_status = false;
1886 tts_client_not_use_callback(client);
1888 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1894 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1897 GList* client_list = NULL;
1898 client_list = tts_client_get_client_list();
1901 tts_client_s *data = NULL;
1903 if (g_list_length(client_list) > 0) {
1904 /* Get a first item */
1905 iter = g_list_first(client_list);
1907 while (NULL != iter) {
1910 data->utt_id = utt_id;
1911 data->reason = reason;
1912 if (NULL != data->err_msg) {
1913 free(data->err_msg);
1914 data->err_msg = NULL;
1916 if (NULL != err_msg)
1917 data->err_msg = strdup(err_msg);
1919 /* call callback function */
1920 if (NULL != data->error_cb) {
1921 ecore_timer_add(0, __tts_notify_error, data->tts);
1923 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1926 if (TTS_ERROR_SERVICE_RESET == reason) {
1927 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1929 data->current_state = TTS_STATE_CREATED;
1930 if (0 != tts_prepare(data->tts)) {
1931 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1936 iter = g_list_next(iter);
1940 tts_client_s* client = tts_client_get_by_uid(uid);
1942 if (NULL == client) {
1943 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1944 return TTS_ERROR_INVALID_PARAMETER;
1947 client->utt_id = utt_id;
1948 client->reason = reason;
1949 if (NULL != client->err_msg) {
1950 free(client->err_msg);
1951 client->err_msg = NULL;
1953 if (NULL != err_msg)
1954 client->err_msg = strdup(err_msg);
1956 /* call callback function */
1957 if (NULL != client->error_cb) {
1958 ecore_timer_add(0, __tts_notify_error, client->tts);
1960 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1963 if (TTS_ERROR_SERVICE_RESET == reason) {
1964 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1966 client->current_state = TTS_STATE_CREATED;
1967 if (0 != tts_prepare(client->tts)) {
1968 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1976 static Eina_Bool __tts_notify_state_changed(void *data)
1978 tts_h tts = (tts_h)data;
1980 tts_client_s* client = tts_client_get(tts);
1983 if (NULL == client) {
1984 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1988 if (NULL != client->state_changed_cb) {
1989 tts_client_use_callback(client);
1990 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1991 tts_client_not_use_callback(client);
1992 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1994 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2000 int __tts_cb_set_state(int uid, int state)
2002 tts_client_s* client = tts_client_get_by_uid(uid);
2003 if (NULL == client) {
2004 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2008 tts_state_e state_from_daemon = (tts_state_e)state;
2010 if (client->current_state == state_from_daemon) {
2011 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2015 if (NULL != client->state_changed_cb) {
2016 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2018 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2021 client->before_state = client->current_state;
2022 client->current_state = state_from_daemon;
2027 int __tts_cb_utt_started(int uid, int utt_id)
2029 tts_client_s* client = tts_client_get_by_uid(uid);
2031 if (NULL == client) {
2032 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2033 return TTS_ERROR_INVALID_PARAMETER;
2036 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2038 client->utt_id = utt_id;
2040 /* call callback function */
2041 if (NULL != client->utt_started_cb) {
2042 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2043 tts_client_use_callback(client);
2044 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2045 tts_client_not_use_callback(client);
2047 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2053 int __tts_cb_utt_completed(int uid, int utt_id)
2055 tts_client_s* client = tts_client_get_by_uid(uid);
2057 if (NULL == client) {
2058 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2059 return TTS_ERROR_INVALID_PARAMETER;
2062 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2064 client->utt_id = utt_id;
2066 /* call callback function */
2067 if (NULL != client->utt_completeted_cb) {
2068 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2069 tts_client_use_callback(client);
2070 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2071 tts_client_not_use_callback(client);
2073 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2079 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2081 if (0 != __tts_get_feature_enabled()) {
2082 return TTS_ERROR_NOT_SUPPORTED;
2085 if (NULL == tts || NULL == callback) {
2086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2087 return TTS_ERROR_INVALID_PARAMETER;
2090 tts_client_s* client = tts_client_get(tts);
2092 if (NULL == client) {
2093 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2094 return TTS_ERROR_INVALID_PARAMETER;
2097 if (TTS_STATE_CREATED != client->current_state) {
2098 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2099 return TTS_ERROR_INVALID_STATE;
2102 client->state_changed_cb = callback;
2103 client->state_changed_user_data = user_data;
2105 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2110 int tts_unset_state_changed_cb(tts_h tts)
2112 if (0 != __tts_get_feature_enabled()) {
2113 return TTS_ERROR_NOT_SUPPORTED;
2117 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2118 return TTS_ERROR_INVALID_PARAMETER;
2121 tts_client_s* client = tts_client_get(tts);
2123 if (NULL == client) {
2124 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2125 return TTS_ERROR_INVALID_PARAMETER;
2128 if (TTS_STATE_CREATED != client->current_state) {
2129 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2130 return TTS_ERROR_INVALID_STATE;
2133 client->state_changed_cb = NULL;
2134 client->state_changed_user_data = NULL;
2136 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2141 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2143 if (0 != __tts_get_feature_enabled()) {
2144 return TTS_ERROR_NOT_SUPPORTED;
2147 if (NULL == tts || NULL == callback) {
2148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2149 return TTS_ERROR_INVALID_PARAMETER;
2152 tts_client_s* client = tts_client_get(tts);
2154 if (NULL == client) {
2155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2156 return TTS_ERROR_INVALID_PARAMETER;
2159 if (TTS_STATE_CREATED != client->current_state) {
2160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2161 return TTS_ERROR_INVALID_STATE;
2164 client->utt_started_cb = callback;
2165 client->utt_started_user_data = user_data;
2167 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2172 int tts_unset_utterance_started_cb(tts_h tts)
2174 if (0 != __tts_get_feature_enabled()) {
2175 return TTS_ERROR_NOT_SUPPORTED;
2179 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2180 return TTS_ERROR_INVALID_PARAMETER;
2183 tts_client_s* client = tts_client_get(tts);
2185 if (NULL == client) {
2186 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2187 return TTS_ERROR_INVALID_PARAMETER;
2190 if (TTS_STATE_CREATED != client->current_state) {
2191 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2192 return TTS_ERROR_INVALID_STATE;
2195 client->utt_started_cb = NULL;
2196 client->utt_started_user_data = NULL;
2198 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2203 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2205 if (0 != __tts_get_feature_enabled()) {
2206 return TTS_ERROR_NOT_SUPPORTED;
2209 if (NULL == tts || NULL == callback) {
2210 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2211 return TTS_ERROR_INVALID_PARAMETER;
2214 tts_client_s* client = tts_client_get(tts);
2216 if (NULL == client) {
2217 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2218 return TTS_ERROR_INVALID_PARAMETER;
2221 if (TTS_STATE_CREATED != client->current_state) {
2222 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2223 return TTS_ERROR_INVALID_STATE;
2226 client->utt_completeted_cb = callback;
2227 client->utt_completed_user_data = user_data;
2229 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2234 int tts_unset_utterance_completed_cb(tts_h tts)
2236 if (0 != __tts_get_feature_enabled()) {
2237 return TTS_ERROR_NOT_SUPPORTED;
2241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2242 return TTS_ERROR_INVALID_PARAMETER;
2245 tts_client_s* client = tts_client_get(tts);
2247 if (NULL == client) {
2248 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2249 return TTS_ERROR_INVALID_PARAMETER;
2252 if (TTS_STATE_CREATED != client->current_state) {
2253 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2254 return TTS_ERROR_INVALID_STATE;
2257 client->utt_completeted_cb = NULL;
2258 client->utt_completed_user_data = NULL;
2260 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2264 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2266 if (0 != __tts_get_feature_enabled()) {
2267 return TTS_ERROR_NOT_SUPPORTED;
2270 if (NULL == tts || NULL == callback) {
2271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2272 return TTS_ERROR_INVALID_PARAMETER;
2275 tts_client_s* client = tts_client_get(tts);
2277 if (NULL == client) {
2278 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2279 return TTS_ERROR_INVALID_PARAMETER;
2282 if (TTS_STATE_CREATED != client->current_state) {
2283 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2284 return TTS_ERROR_INVALID_STATE;
2287 client->error_cb = callback;
2288 client->error_user_data = user_data;
2290 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2295 int tts_unset_error_cb(tts_h tts)
2297 if (0 != __tts_get_feature_enabled()) {
2298 return TTS_ERROR_NOT_SUPPORTED;
2302 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2303 return TTS_ERROR_INVALID_PARAMETER;
2306 tts_client_s* client = tts_client_get(tts);
2308 if (NULL == client) {
2309 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2310 return TTS_ERROR_INVALID_PARAMETER;
2313 if (TTS_STATE_CREATED != client->current_state) {
2314 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2315 return TTS_ERROR_INVALID_STATE;
2318 client->error_cb = NULL;
2319 client->error_user_data = NULL;
2321 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2326 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2328 if (0 != __tts_get_feature_enabled()) {
2329 return TTS_ERROR_NOT_SUPPORTED;
2332 if (NULL == tts || NULL == callback) {
2333 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2334 return TTS_ERROR_INVALID_PARAMETER;
2337 tts_client_s* client = tts_client_get(tts);
2339 if (NULL == client) {
2340 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2341 return TTS_ERROR_INVALID_PARAMETER;
2344 if (TTS_STATE_CREATED != client->current_state) {
2345 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2346 return TTS_ERROR_INVALID_STATE;
2349 client->default_voice_changed_cb = callback;
2350 client->default_voice_changed_user_data = user_data;
2352 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2357 int tts_unset_default_voice_changed_cb(tts_h tts)
2359 if (0 != __tts_get_feature_enabled()) {
2360 return TTS_ERROR_NOT_SUPPORTED;
2364 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2365 return TTS_ERROR_INVALID_PARAMETER;
2368 tts_client_s* client = tts_client_get(tts);
2370 if (NULL == client) {
2371 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2372 return TTS_ERROR_INVALID_PARAMETER;
2375 if (TTS_STATE_CREATED != client->current_state) {
2376 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2377 return TTS_ERROR_INVALID_STATE;
2380 client->default_voice_changed_cb = NULL;
2381 client->default_voice_changed_user_data = NULL;
2383 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2388 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2390 if (0 != __tts_get_feature_enabled()) {
2391 return TTS_ERROR_NOT_SUPPORTED;
2394 if (NULL == tts || NULL == callback) {
2395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2396 return TTS_ERROR_INVALID_PARAMETER;
2399 tts_client_s* client = tts_client_get(tts);
2401 if (NULL == client) {
2402 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2403 return TTS_ERROR_INVALID_PARAMETER;
2406 if (TTS_STATE_CREATED != client->current_state) {
2407 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2408 return TTS_ERROR_INVALID_STATE;
2411 client->engine_changed_cb = callback;
2412 client->engine_changed_user_data = user_data;
2414 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2419 int tts_unset_engine_changed_cb(tts_h tts)
2421 if (0 != __tts_get_feature_enabled()) {
2422 return TTS_ERROR_NOT_SUPPORTED;
2426 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2427 return TTS_ERROR_INVALID_PARAMETER;
2430 tts_client_s* client = tts_client_get(tts);
2432 if (NULL == client) {
2433 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2434 return TTS_ERROR_INVALID_PARAMETER;
2437 if (TTS_STATE_CREATED != client->current_state) {
2438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2439 return TTS_ERROR_INVALID_STATE;
2442 client->engine_changed_cb = NULL;
2443 client->engine_changed_user_data = NULL;
2445 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2450 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2452 if (0 != __tts_get_feature_enabled()) {
2453 return TTS_ERROR_NOT_SUPPORTED;
2456 SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2459 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2460 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2461 return TTS_ERROR_INVALID_PARAMETER;
2464 tts_client_s* client = tts_client_get(tts);
2466 if (NULL == client) {
2467 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2468 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2469 return TTS_ERROR_INVALID_PARAMETER;
2472 if (TTS_STATE_CREATED == client->current_state) {
2473 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2474 return TTS_ERROR_INVALID_STATE;
2477 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2478 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2479 return TTS_ERROR_INVALID_STATE;
2484 bool is_prepared = false;
2486 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2488 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2489 client->current_state = TTS_STATE_CREATED;
2490 if (0 == tts_prepare_sync(tts)) {
2492 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2494 } else if (TTS_ERROR_TIMED_OUT != ret) {
2495 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2498 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2501 if (TTS_RETRY_COUNT == count) {
2502 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2509 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2511 return TTS_ERROR_NONE;
2514 int tts_play_pcm(tts_h tts)
2516 if (0 != __tts_get_feature_enabled()) {
2517 return TTS_ERROR_NOT_SUPPORTED;
2520 SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2523 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2524 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2525 return TTS_ERROR_INVALID_PARAMETER;
2528 tts_client_s* client = tts_client_get(tts);
2530 if (NULL == client) {
2531 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2532 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2533 return TTS_ERROR_INVALID_PARAMETER;
2536 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2537 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2538 return TTS_ERROR_INVALID_STATE;
2541 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2542 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2543 return TTS_ERROR_INVALID_STATE;
2548 bool is_prepared = false;
2550 ret = tts_dbus_request_play_pcm(client->uid);
2552 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2553 client->current_state = TTS_STATE_CREATED;
2554 if (0 == tts_prepare_sync(tts)) {
2556 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2558 } else if (TTS_ERROR_TIMED_OUT != ret) {
2559 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2562 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2565 if (TTS_RETRY_COUNT == count) {
2566 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2573 client->before_state = client->current_state;
2574 client->current_state = TTS_STATE_PLAYING;
2576 if (NULL != client->state_changed_cb) {
2577 tts_client_use_callback(client);
2578 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2579 tts_client_not_use_callback(client);
2580 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2583 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2585 return TTS_ERROR_NONE;
2588 int tts_stop_pcm(tts_h tts)
2590 if (0 != __tts_get_feature_enabled()) {
2591 return TTS_ERROR_NOT_SUPPORTED;
2594 SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2597 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2598 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2599 return TTS_ERROR_INVALID_PARAMETER;
2602 tts_client_s* client = tts_client_get(tts);
2604 if (NULL == client) {
2605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2606 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2607 return TTS_ERROR_INVALID_PARAMETER;
2610 if (TTS_STATE_CREATED == client->current_state) {
2611 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2612 return TTS_ERROR_INVALID_STATE;
2615 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2616 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2617 return TTS_ERROR_INVALID_STATE;
2622 bool is_prepared = false;
2624 ret = tts_dbus_request_stop_pcm(client->uid);
2626 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2627 client->current_state = TTS_STATE_CREATED;
2628 if (0 == tts_prepare_sync(tts)) {
2630 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2632 } else if (TTS_ERROR_TIMED_OUT != ret) {
2633 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2636 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2639 if (TTS_RETRY_COUNT == count) {
2640 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2647 client->before_state = client->current_state;
2648 client->current_state = TTS_STATE_READY;
2650 if (NULL != client->state_changed_cb) {
2651 tts_client_use_callback(client);
2652 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2653 tts_client_not_use_callback(client);
2654 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2657 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2659 return TTS_ERROR_NONE;