2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
14 #include <app_manager.h>
19 #include <sys/types.h>
21 #include <system_info.h>
25 #include "tts_client.h"
26 #include "tts_config_mgr.h"
31 static bool g_screen_reader;
33 static int g_feature_enabled = -1;
35 static bool g_err_callback_status = false;
37 static int g_max_text_size = -1;
39 /* Function definition */
40 static Eina_Bool __tts_notify_state_changed(void *data);
41 static Eina_Bool __tts_notify_error(void *data);
48 static int __tts_get_feature_enabled()
50 if (0 == g_feature_enabled) {
51 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
52 return TTS_ERROR_NOT_SUPPORTED;
53 } else if (-1 == g_feature_enabled) {
54 bool tts_supported = false;
55 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
56 if (false == tts_supported) {
57 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
58 g_feature_enabled = 0;
59 return TTS_ERROR_NOT_SUPPORTED;
62 g_feature_enabled = 1;
64 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
65 return TTS_ERROR_NOT_SUPPORTED;
72 static const char* __tts_get_error_code(tts_error_e err)
75 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
76 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
77 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
78 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
79 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
80 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
81 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
82 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
83 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
84 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
85 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
86 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
87 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
88 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
89 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
91 return "Invalid error code";
96 static int __tts_convert_config_error_code(tts_config_error_e code)
98 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
99 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
100 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
101 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
102 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
103 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
104 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
105 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
106 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
111 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
113 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
114 before_lang, before_voice_type, language, voice_type);
116 GList* client_list = NULL;
117 client_list = tts_client_get_client_list();
120 tts_client_s *data = NULL;
122 if (g_list_length(client_list) > 0) {
123 /* Get a first item */
124 iter = g_list_first(client_list);
126 while (NULL != iter) {
128 if (NULL != data->default_voice_changed_cb) {
129 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
130 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
131 language, voice_type, data->default_voice_changed_user_data);
135 iter = g_list_next(iter);
142 static Eina_Bool __reconnect_by_engine_changed(void* data)
144 tts_h tts = (tts_h)data;
146 tts_client_s* client = tts_client_get(tts);
147 if (NULL == client) {
148 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
152 if (TTS_STATE_READY != client->current_state) {
157 int ret = tts_unprepare(tts);
159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
161 ret = tts_prepare(tts);
163 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
169 void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
171 tts_h tts = (tts_h)user_data;
173 tts_client_s* client = tts_client_get(tts);
174 if (NULL == client) {
175 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
179 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
180 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
181 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
182 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
184 /* When the default engine is changed, please unload the old engine and load the new one. */
187 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
190 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
193 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
194 } else if (TTS_STATE_READY == client->current_state) {
195 ret = tts_unprepare(tts);
197 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
199 ret = tts_prepare(tts);
201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
205 /* call callback function */
206 if (NULL != client->engine_changed_cb) {
207 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
209 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
214 int tts_create(tts_h* tts)
216 if (0 != __tts_get_feature_enabled()) {
217 return TTS_ERROR_NOT_SUPPORTED;
220 SLOG(LOG_INFO, TAG_TTSC, "===== Create TTS");
224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
225 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
226 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, "=====");
361 SLOG(LOG_DEBUG, TAG_TTSC, " ");
363 return TTS_ERROR_NONE;
366 void __tts_screen_reader_changed_cb(bool value)
368 g_screen_reader = value;
371 int tts_set_mode(tts_h tts, tts_mode_e mode)
373 if (0 != __tts_get_feature_enabled()) {
374 return TTS_ERROR_NOT_SUPPORTED;
377 SLOG(LOG_INFO, TAG_TTSC, "===== Set TTS mode(%d)", mode);
379 tts_client_s* client = tts_client_get(tts);
382 if (NULL == client) {
383 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
384 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
385 SLOG(LOG_DEBUG, TAG_TTSC, " ");
386 return TTS_ERROR_INVALID_PARAMETER;
390 if (client->current_state != TTS_STATE_CREATED) {
391 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
392 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
393 SLOG(LOG_DEBUG, TAG_TTSC, " ");
394 return TTS_ERROR_INVALID_STATE;
397 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
400 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
401 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
402 SLOG(LOG_DEBUG, TAG_TTSC, " ");
403 return TTS_ERROR_INVALID_PARAMETER;
406 if (TTS_MODE_SCREEN_READER == mode) {
409 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
411 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
412 return TTS_ERROR_OPERATION_FAILED;
414 g_screen_reader = (bool)screen_reader;
415 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
417 tts_config_unset_screen_reader_callback(client->uid);
420 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
421 SLOG(LOG_DEBUG, TAG_TTSC, " ");
423 return TTS_ERROR_NONE;
426 int tts_get_mode(tts_h tts, tts_mode_e* mode)
428 if (0 != __tts_get_feature_enabled()) {
429 return TTS_ERROR_NOT_SUPPORTED;
432 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
434 tts_client_s* client = tts_client_get(tts);
437 if (NULL == client) {
438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
439 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
440 SLOG(LOG_DEBUG, TAG_TTSC, " ");
441 return TTS_ERROR_INVALID_PARAMETER;
445 if (client->current_state != TTS_STATE_CREATED) {
446 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
447 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
448 SLOG(LOG_DEBUG, TAG_TTSC, " ");
449 return TTS_ERROR_INVALID_STATE;
453 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
454 return TTS_ERROR_INVALID_PARAMETER;
457 *mode = client->mode;
459 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
460 SLOG(LOG_DEBUG, TAG_TTSC, " ");
462 return TTS_ERROR_NONE;
465 int tts_set_credential(tts_h tts, const char* credential)
467 if (0 != __tts_get_feature_enabled()) {
468 return TTS_ERROR_NOT_SUPPORTED;
471 if (NULL == tts || NULL == credential) {
472 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
473 return TTS_ERROR_INVALID_PARAMETER;
476 tts_client_s* client = tts_client_get(tts);
478 if (NULL == client) {
479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
480 return TTS_ERROR_INVALID_PARAMETER;
483 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
484 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
485 return TTS_ERROR_INVALID_STATE;
488 if (NULL != client->credential) {
489 free(client->credential);
490 client->credential = NULL;
492 client->credential = strdup(credential);
494 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
495 SLOG(LOG_DEBUG, TAG_TTSC, " ");
497 return TTS_ERROR_NONE;
500 int tts_set_server_tts(tts_h tts, const char* credential)
502 if (0 != __tts_get_feature_enabled()) {
503 return TTS_ERROR_NOT_SUPPORTED;
507 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
508 return TTS_ERROR_INVALID_PARAMETER;
511 tts_client_s* client = tts_client_get(tts);
513 if (NULL == client) {
514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
515 return TTS_ERROR_INVALID_PARAMETER;
518 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
519 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
520 return TTS_ERROR_INVALID_STATE;
523 if (NULL != client->credential) {
524 free(client->credential);
525 client->credential = NULL;
528 client->internal = true;
531 if (NULL != credential) {
532 key = strdup("EnableServerTTS");
533 client->credential = strdup(credential);
534 if (NULL == client->credential) {
535 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);
551 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
554 return TTS_ERROR_OPERATION_FAILED;
557 ret = tts_set_private_data(tts, key, appid);
559 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
570 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
571 SLOG(LOG_DEBUG, TAG_TTSC, " ");
573 return TTS_ERROR_NONE;
576 static Eina_Bool __tts_connect_daemon(void *data)
578 tts_h tts = (tts_h)data;
579 tts_client_s* client = tts_client_get(tts);
582 if (NULL == client) {
583 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
588 if (0 != tts_dbus_request_hello(client->uid)) {
592 SLOG(LOG_INFO, TAG_TTSC, "===== Connect daemon");
594 /* do request initialize */
596 bool credential_needed = false;
598 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
600 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
601 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
603 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
606 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
607 client->conn_timer = NULL;
610 } else if (TTS_ERROR_NONE != ret) {
611 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
615 /* success to connect tts-daemon */
616 client->credential_needed = credential_needed;
617 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
620 client->conn_timer = NULL;
622 client = tts_client_get(tts);
624 if (NULL == client) {
625 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
629 client->before_state = client->current_state;
630 client->current_state = TTS_STATE_READY;
632 if (NULL != client->state_changed_cb) {
633 tts_client_use_callback(client);
634 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
635 tts_client_not_use_callback(client);
637 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
640 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
641 SLOG(LOG_DEBUG, TAG_TTSC, " ");
646 int tts_prepare(tts_h tts)
648 if (0 != __tts_get_feature_enabled()) {
649 return TTS_ERROR_NOT_SUPPORTED;
652 SLOG(LOG_INFO, TAG_TTSC, "===== Prepare TTS");
654 tts_client_s* client = tts_client_get(tts);
657 if (NULL == client) {
658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
659 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
660 SLOG(LOG_DEBUG, TAG_TTSC, " ");
661 return TTS_ERROR_INVALID_PARAMETER;
665 if (client->current_state != TTS_STATE_CREATED) {
666 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
667 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
668 SLOG(LOG_DEBUG, TAG_TTSC, " ");
669 return TTS_ERROR_INVALID_STATE;
672 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
674 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
675 SLOG(LOG_DEBUG, TAG_TTSC, " ");
677 return TTS_ERROR_NONE;
680 int tts_unprepare(tts_h tts)
682 if (0 != __tts_get_feature_enabled()) {
683 return TTS_ERROR_NOT_SUPPORTED;
686 SLOG(LOG_INFO, TAG_TTSC, "===== Unprepare TTS");
688 tts_client_s* client = tts_client_get(tts);
691 if (NULL == client) {
692 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
693 return TTS_ERROR_INVALID_PARAMETER;
697 if (client->current_state != TTS_STATE_READY) {
698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
699 return TTS_ERROR_INVALID_STATE;
704 int screen_reader = -1;
706 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
708 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
710 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
711 g_screen_reader = (bool)screen_reader;
714 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
716 ret = tts_dbus_request_finalize(client->uid);
718 if (TTS_ERROR_TIMED_OUT != ret) {
719 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
722 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
725 if (TTS_RETRY_COUNT == count) {
726 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
733 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
736 client->before_state = client->current_state;
737 client->current_state = TTS_STATE_CREATED;
739 if (NULL != client->state_changed_cb) {
740 tts_client_use_callback(client);
741 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
742 tts_client_not_use_callback(client);
743 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
746 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
747 SLOG(LOG_DEBUG, TAG_TTSC, " ");
749 return TTS_ERROR_NONE;
752 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
754 tts_h tts = (tts_h)user_data;
756 tts_client_s* client = tts_client_get(tts);
757 if (NULL == client) {
758 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
762 /* call callback function */
763 if (NULL != client->supported_voice_cb) {
764 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
766 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
772 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
774 if (0 != __tts_get_feature_enabled()) {
775 return TTS_ERROR_NOT_SUPPORTED;
778 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
780 if (NULL == tts || NULL == callback) {
781 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
782 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
783 SLOG(LOG_DEBUG, TAG_TTSC, " ");
784 return TTS_ERROR_INVALID_PARAMETER;
787 tts_client_s* client = tts_client_get(tts);
790 if (NULL == client) {
791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
792 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
793 SLOG(LOG_DEBUG, TAG_TTSC, " ");
794 return TTS_ERROR_INVALID_PARAMETER;
798 char* current_engine = NULL;
799 ret = tts_config_mgr_get_engine(¤t_engine);
801 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
802 return __tts_convert_config_error_code(ret);
805 client->supported_voice_cb = callback;
806 client->supported_voice_user_data = user_data;
808 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
810 if (NULL != current_engine) {
811 free(current_engine);
812 current_engine = NULL;
815 client->supported_voice_cb = NULL;
816 client->supported_voice_user_data = NULL;
819 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
820 ret = TTS_ERROR_OPERATION_FAILED;
823 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
824 SLOG(LOG_DEBUG, TAG_TTSC, " ");
829 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
831 if (0 != __tts_get_feature_enabled()) {
832 return TTS_ERROR_NOT_SUPPORTED;
835 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
838 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
839 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
840 SLOG(LOG_DEBUG, TAG_TTSC, " ");
841 return TTS_ERROR_INVALID_PARAMETER;
844 tts_client_s* client = tts_client_get(tts);
846 if (NULL == client) {
847 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
848 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
849 SLOG(LOG_DEBUG, TAG_TTSC, " ");
850 return TTS_ERROR_INVALID_PARAMETER;
853 /* Request call remote method */
855 ret = tts_config_mgr_get_voice(lang, vctype);
857 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
858 return __tts_convert_config_error_code(ret);
860 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
863 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
864 SLOG(LOG_DEBUG, TAG_TTSC, " ");
869 int tts_get_max_text_size(tts_h tts, unsigned int* size)
871 if (0 != __tts_get_feature_enabled()) {
872 return TTS_ERROR_NOT_SUPPORTED;
875 if (NULL == tts || NULL == size) {
876 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
877 return TTS_ERROR_INVALID_PARAMETER;
880 tts_client_s* client = tts_client_get(tts);
882 if (NULL == client) {
883 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
884 return TTS_ERROR_INVALID_PARAMETER;
887 if (TTS_STATE_READY != client->current_state) {
888 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
889 return TTS_ERROR_INVALID_STATE;
892 // *size = TTS_MAX_TEXT_SIZE;
893 if (0 != tts_config_mgr_get_max_text_size(size)) {
894 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
895 return TTS_ERROR_INVALID_PARAMETER;
898 g_max_text_size = (int)*size;
900 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
901 return TTS_ERROR_NONE;
904 int tts_get_state(tts_h tts, tts_state_e* state)
906 if (0 != __tts_get_feature_enabled()) {
907 return TTS_ERROR_NOT_SUPPORTED;
910 if (NULL == tts || NULL == state) {
911 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
912 return TTS_ERROR_INVALID_PARAMETER;
915 tts_client_s* client = tts_client_get(tts);
917 if (NULL == client) {
918 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
919 return TTS_ERROR_INVALID_PARAMETER;
922 *state = client->current_state;
925 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
926 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
927 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
928 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
929 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
932 return TTS_ERROR_NONE;
935 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
937 if (0 != __tts_get_feature_enabled()) {
938 return TTS_ERROR_NOT_SUPPORTED;
941 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
942 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
943 return TTS_ERROR_INVALID_PARAMETER;
946 tts_client_s* client = tts_client_get(tts);
948 if (NULL == client) {
949 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
950 return TTS_ERROR_INVALID_PARAMETER;
953 *min = TTS_SPEED_MIN;
954 *normal = TTS_SPEED_NORMAL;
955 *max = TTS_SPEED_MAX;
957 return TTS_ERROR_NONE;
960 int tts_get_error_message(tts_h tts, char** err_msg)
962 if (0 != __tts_get_feature_enabled()) {
963 return TTS_ERROR_NOT_SUPPORTED;
966 if (NULL == tts || NULL == err_msg) {
967 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
968 return TTS_ERROR_INVALID_PARAMETER;
971 tts_client_s* client = tts_client_get(tts);
973 if (NULL == client) {
974 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
975 return TTS_ERROR_INVALID_PARAMETER;
978 if (NULL != client->err_msg) {
979 *err_msg = strdup(client->err_msg);
980 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
983 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
986 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
987 SLOG(LOG_DEBUG, TAG_TTSC, " ");
989 return TTS_ERROR_NONE;
992 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
994 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
996 if (0 != __tts_get_feature_enabled()) {
997 return TTS_ERROR_NOT_SUPPORTED;
1001 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1002 return TTS_ERROR_INVALID_PARAMETER;
1005 if (voice_type < 0) {
1006 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1007 return TTS_ERROR_INVALID_PARAMETER;
1010 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
1012 if (NULL == tts || NULL == utt_id) {
1013 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1014 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1015 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1016 return TTS_ERROR_INVALID_PARAMETER;
1019 tts_client_s* client = tts_client_get(tts);
1021 if (NULL == client) {
1022 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1023 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
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 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1047 return TTS_ERROR_INVALID_PARAMETER;
1050 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1051 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1052 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1053 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1054 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1055 return TTS_ERROR_INVALID_PARAMETER;
1059 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1061 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1062 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1063 return TTS_ERROR_INVALID_PARAMETER;
1066 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1067 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1068 return TTS_ERROR_INVALID_STATE;
1071 if (true == client->credential_needed && NULL == client->credential) {
1072 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1073 return TTS_ERROR_PERMISSION_DENIED;
1076 /* check valid utf8 */
1080 dbus_error_init(&err);
1082 valid = dbus_validate_utf8(text, &err);
1083 if (dbus_error_is_set(&err)) {
1084 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1085 dbus_error_free(&err);
1086 return TTS_ERROR_INVALID_PARAMETER;
1089 if (valid != true) {
1090 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1091 return TTS_ERROR_INVALID_PARAMETER;
1093 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1095 /* change default language value */
1098 if (NULL == language)
1099 temp = strdup("default");
1101 temp = strdup(language);
1103 client->current_utt_id++;
1104 if (client->current_utt_id == 10000) {
1105 client->current_utt_id = 1;
1112 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1114 if (TTS_ERROR_TIMED_OUT != ret) {
1115 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1118 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1121 if (TTS_RETRY_MIN_COUNT == count) {
1122 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1127 *utt_id = client->current_utt_id;
1136 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1137 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1142 static void __tts_play_async(void *data)
1144 tts_h tts = (tts_h)data;
1145 tts_client_s* client = tts_client_get(tts);
1148 if (NULL == client) {
1149 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1156 ret = tts_dbus_request_play(client->uid, client->credential);
1158 if (TTS_ERROR_TIMED_OUT != ret) {
1159 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1162 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1165 if (TTS_RETRY_COUNT == count) {
1166 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1176 client->reason = ret;
1177 client->utt_id = -1;
1179 ecore_timer_add(0, __tts_notify_error, client->tts);
1183 client->before_state = client->current_state;
1184 client->current_state = TTS_STATE_PLAYING;
1186 if (NULL != client->state_changed_cb) {
1187 tts_client_use_callback(client);
1188 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1189 tts_client_not_use_callback(client);
1190 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1193 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1194 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1199 int tts_play_async(tts_h tts)
1201 if (0 != __tts_get_feature_enabled()) {
1202 return TTS_ERROR_NOT_SUPPORTED;
1205 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1208 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1209 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1210 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1211 return TTS_ERROR_INVALID_PARAMETER;
1214 tts_client_s* client = tts_client_get(tts);
1216 if (NULL == client) {
1217 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1218 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1219 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1220 return TTS_ERROR_INVALID_PARAMETER;
1223 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1225 return TTS_ERROR_INVALID_STATE;
1228 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1229 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1230 return TTS_ERROR_INVALID_STATE;
1233 if (true == client->credential_needed && NULL == client->credential) {
1234 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1235 return TTS_ERROR_PERMISSION_DENIED;
1238 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1240 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1241 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1243 return TTS_ERROR_NONE;
1246 int tts_play(tts_h tts)
1248 if (0 != __tts_get_feature_enabled()) {
1249 return TTS_ERROR_NOT_SUPPORTED;
1252 SLOG(LOG_INFO, TAG_TTSC, "===== Play tts");
1255 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1256 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1257 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1258 return TTS_ERROR_INVALID_PARAMETER;
1261 tts_client_s* client = tts_client_get(tts);
1263 if (NULL == client) {
1264 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1265 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1266 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1267 return TTS_ERROR_INVALID_PARAMETER;
1270 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1271 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1272 return TTS_ERROR_INVALID_STATE;
1275 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1276 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1277 return TTS_ERROR_INVALID_STATE;
1280 if (true == client->credential_needed && NULL == client->credential) {
1281 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1282 return TTS_ERROR_PERMISSION_DENIED;
1288 ret = tts_dbus_request_play(client->uid, client->credential);
1290 if (TTS_ERROR_TIMED_OUT != ret) {
1291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1294 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1297 if (TTS_RETRY_COUNT == count) {
1298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1305 client->before_state = client->current_state;
1306 client->current_state = TTS_STATE_PLAYING;
1308 if (NULL != client->state_changed_cb) {
1309 tts_client_use_callback(client);
1310 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1311 tts_client_not_use_callback(client);
1312 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1315 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1316 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1318 return TTS_ERROR_NONE;
1321 static void __tts_stop_async(void *data)
1323 tts_h tts = (tts_h)data;
1324 tts_client_s* client = tts_client_get(tts);
1327 if (NULL == client) {
1328 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1335 ret = tts_dbus_request_stop(client->uid);
1337 if (TTS_ERROR_TIMED_OUT != ret) {
1338 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1341 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1344 if (TTS_RETRY_COUNT == count) {
1345 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1353 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1355 client->reason = ret;
1356 client->utt_id = -1;
1358 ecore_timer_add(0, __tts_notify_error, client->tts);
1362 client->before_state = client->current_state;
1363 client->current_state = TTS_STATE_READY;
1365 if (NULL != client->state_changed_cb) {
1366 tts_client_use_callback(client);
1367 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1368 tts_client_not_use_callback(client);
1369 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1372 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1373 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1378 int tts_stop_aync(tts_h tts)
1380 if (0 != __tts_get_feature_enabled()) {
1381 return TTS_ERROR_NOT_SUPPORTED;
1384 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1387 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1388 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1389 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1390 return TTS_ERROR_INVALID_PARAMETER;
1393 tts_client_s* client = tts_client_get(tts);
1395 if (NULL == client) {
1396 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1397 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1398 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1399 return TTS_ERROR_INVALID_PARAMETER;
1402 if (TTS_STATE_CREATED == client->current_state) {
1403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1404 return TTS_ERROR_INVALID_STATE;
1407 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1408 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1409 return TTS_ERROR_INVALID_STATE;
1412 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1414 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1415 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1417 return TTS_ERROR_NONE;
1420 int tts_stop(tts_h tts)
1422 if (0 != __tts_get_feature_enabled()) {
1423 return TTS_ERROR_NOT_SUPPORTED;
1426 SLOG(LOG_INFO, TAG_TTSC, "===== Stop tts");
1429 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1430 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1431 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1432 return TTS_ERROR_INVALID_PARAMETER;
1435 tts_client_s* client = tts_client_get(tts);
1437 if (NULL == client) {
1438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1439 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1440 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1441 return TTS_ERROR_INVALID_PARAMETER;
1444 if (TTS_STATE_CREATED == client->current_state) {
1445 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1446 return TTS_ERROR_INVALID_STATE;
1449 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1450 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1451 return TTS_ERROR_INVALID_STATE;
1457 ret = tts_dbus_request_stop(client->uid);
1459 if (TTS_ERROR_TIMED_OUT != ret) {
1460 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1463 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1466 if (TTS_RETRY_COUNT == count) {
1467 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1474 client->before_state = client->current_state;
1475 client->current_state = TTS_STATE_READY;
1477 if (NULL != client->state_changed_cb) {
1478 tts_client_use_callback(client);
1479 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1480 tts_client_not_use_callback(client);
1481 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1484 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1485 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1487 return TTS_ERROR_NONE;
1490 static void __tts_pause_async(void *data)
1492 tts_h tts = (tts_h)data;
1493 tts_client_s* client = tts_client_get(tts);
1496 if (NULL == client) {
1497 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1504 ret = tts_dbus_request_pause(client->uid);
1506 if (TTS_ERROR_TIMED_OUT != ret) {
1507 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1510 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1513 if (TTS_RETRY_COUNT == count) {
1514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1522 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1524 client->reason = ret;
1525 client->utt_id = -1;
1527 ecore_timer_add(0, __tts_notify_error, client->tts);
1531 client->before_state = client->current_state;
1532 client->current_state = TTS_STATE_PAUSED;
1534 if (NULL != client->state_changed_cb) {
1535 tts_client_use_callback(client);
1536 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1537 tts_client_not_use_callback(client);
1538 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1541 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1542 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1547 int tts_pause_async(tts_h tts)
1549 if (0 != __tts_get_feature_enabled()) {
1550 return TTS_ERROR_NOT_SUPPORTED;
1553 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1556 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1557 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1558 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1559 return TTS_ERROR_INVALID_PARAMETER;
1562 tts_client_s* client = tts_client_get(tts);
1564 if (NULL == client) {
1565 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1566 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1567 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1568 return TTS_ERROR_INVALID_PARAMETER;
1571 if (TTS_STATE_PLAYING != client->current_state) {
1572 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1573 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1574 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1575 return TTS_ERROR_INVALID_STATE;
1578 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1579 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1580 return TTS_ERROR_INVALID_STATE;
1583 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1585 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1586 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1588 return TTS_ERROR_NONE;
1591 int tts_pause(tts_h tts)
1593 if (0 != __tts_get_feature_enabled()) {
1594 return TTS_ERROR_NOT_SUPPORTED;
1597 SLOG(LOG_INFO, TAG_TTSC, "===== Pause tts");
1600 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1601 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1602 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1603 return TTS_ERROR_INVALID_PARAMETER;
1606 tts_client_s* client = tts_client_get(tts);
1608 if (NULL == client) {
1609 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1610 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1611 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1612 return TTS_ERROR_INVALID_PARAMETER;
1615 if (TTS_STATE_PLAYING != client->current_state) {
1616 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1617 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1618 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1619 return TTS_ERROR_INVALID_STATE;
1622 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1623 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1624 return TTS_ERROR_INVALID_STATE;
1630 ret = tts_dbus_request_pause(client->uid);
1632 if (TTS_ERROR_TIMED_OUT != ret) {
1633 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1636 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1639 if (TTS_RETRY_COUNT == count) {
1640 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1647 client->before_state = client->current_state;
1648 client->current_state = TTS_STATE_PAUSED;
1650 if (NULL != client->state_changed_cb) {
1651 tts_client_use_callback(client);
1652 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1653 tts_client_not_use_callback(client);
1654 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1657 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1658 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1660 return TTS_ERROR_NONE;
1663 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1665 if (0 != __tts_get_feature_enabled()) {
1666 return TTS_ERROR_NOT_SUPPORTED;
1669 SLOG(LOG_INFO, TAG_TTSC, "===== Set private data, key(%s), data(%s)", key, data);
1672 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1673 return TTS_ERROR_INVALID_PARAMETER;
1676 if (NULL == key || NULL == data) {
1677 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1678 return TTS_ERROR_INVALID_PARAMETER;
1681 tts_client_s* client = tts_client_get(tts);
1683 if (NULL == client) {
1684 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1685 return TTS_ERROR_INVALID_PARAMETER;
1688 if (TTS_STATE_READY != client->current_state) {
1689 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1690 return TTS_ERROR_INVALID_STATE;
1693 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1694 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1695 return TTS_ERROR_INVALID_PARAMETER;
1701 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1703 if (TTS_ERROR_TIMED_OUT != ret) {
1704 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1707 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1710 if (TTS_RETRY_COUNT == count) {
1711 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1718 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1719 SLOG(LOG_DEBUG, TAG_TTSC, "");
1724 int tts_get_private_data(tts_h tts, const char* key, char** data)
1726 if (0 != __tts_get_feature_enabled()) {
1727 return TTS_ERROR_NOT_SUPPORTED;
1730 SLOG(LOG_INFO, TAG_TTSC, "===== Get private data, key(%s)", key);
1733 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1734 return TTS_ERROR_INVALID_PARAMETER;
1737 if (NULL == key || NULL == data) {
1738 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1739 return TTS_ERROR_INVALID_PARAMETER;
1742 tts_client_s* client = tts_client_get(tts);
1744 if (NULL == client) {
1745 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1746 return TTS_ERROR_INVALID_PARAMETER;
1749 if (TTS_STATE_READY != client->current_state) {
1750 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1751 return TTS_ERROR_INVALID_STATE;
1757 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1759 if (TTS_ERROR_TIMED_OUT != ret) {
1760 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1763 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1766 if (TTS_RETRY_COUNT == count) {
1767 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1774 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1779 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1780 SLOG(LOG_DEBUG, TAG_TTSC, "");
1785 static Eina_Bool __tts_notify_error(void *data)
1787 tts_h tts = (tts_h)data;
1789 tts_client_s* client = tts_client_get(tts);
1792 if (NULL == client) {
1793 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1797 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1799 if (NULL != client->error_cb) {
1800 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1801 tts_client_use_callback(client);
1802 g_err_callback_status = true;
1803 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1804 g_err_callback_status = false;
1805 tts_client_not_use_callback(client);
1807 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1813 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1816 GList* client_list = NULL;
1817 client_list = tts_client_get_client_list();
1820 tts_client_s *data = NULL;
1822 if (g_list_length(client_list) > 0) {
1823 /* Get a first item */
1824 iter = g_list_first(client_list);
1826 while (NULL != iter) {
1829 data->utt_id = utt_id;
1830 data->reason = reason;
1831 if (NULL != data->err_msg) {
1832 free(data->err_msg);
1833 data->err_msg = NULL;
1835 if (NULL != err_msg)
1836 data->err_msg = strdup(err_msg);
1838 /* call callback function */
1839 if (NULL != data->error_cb) {
1840 ecore_timer_add(0, __tts_notify_error, data->tts);
1842 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1845 if (TTS_ERROR_SERVICE_RESET == reason) {
1846 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1848 data->current_state = TTS_STATE_CREATED;
1849 if (0 != tts_prepare(data->tts)) {
1850 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1855 iter = g_list_next(iter);
1859 tts_client_s* client = tts_client_get_by_uid(uid);
1861 if (NULL == client) {
1862 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1863 return TTS_ERROR_INVALID_PARAMETER;
1866 client->utt_id = utt_id;
1867 client->reason = reason;
1868 if (NULL != client->err_msg) {
1869 free(client->err_msg);
1870 client->err_msg = NULL;
1872 if (NULL != err_msg)
1873 client->err_msg = strdup(err_msg);
1875 /* call callback function */
1876 if (NULL != client->error_cb) {
1877 ecore_timer_add(0, __tts_notify_error, client->tts);
1879 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1882 if (TTS_ERROR_SERVICE_RESET == reason) {
1883 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1885 client->current_state = TTS_STATE_CREATED;
1886 if (0 != tts_prepare(client->tts)) {
1887 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1895 static Eina_Bool __tts_notify_state_changed(void *data)
1897 tts_h tts = (tts_h)data;
1899 tts_client_s* client = tts_client_get(tts);
1902 if (NULL == client) {
1903 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1907 if (NULL != client->state_changed_cb) {
1908 tts_client_use_callback(client);
1909 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1910 tts_client_not_use_callback(client);
1911 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1913 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1919 int __tts_cb_set_state(int uid, int state)
1921 tts_client_s* client = tts_client_get_by_uid(uid);
1922 if (NULL == client) {
1923 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1927 tts_state_e state_from_daemon = (tts_state_e)state;
1929 if (client->current_state == state_from_daemon) {
1930 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1934 if (NULL != client->state_changed_cb) {
1935 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1937 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1940 client->before_state = client->current_state;
1941 client->current_state = state_from_daemon;
1946 int __tts_cb_utt_started(int uid, int utt_id)
1948 tts_client_s* client = tts_client_get_by_uid(uid);
1950 if (NULL == client) {
1951 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1952 return TTS_ERROR_INVALID_PARAMETER;
1955 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1957 client->utt_id = utt_id;
1959 /* call callback function */
1960 if (NULL != client->utt_started_cb) {
1961 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1962 tts_client_use_callback(client);
1963 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1964 tts_client_not_use_callback(client);
1966 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1972 int __tts_cb_utt_completed(int uid, int utt_id)
1974 tts_client_s* client = tts_client_get_by_uid(uid);
1976 if (NULL == client) {
1977 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1978 return TTS_ERROR_INVALID_PARAMETER;
1981 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1983 client->utt_id = utt_id;
1985 /* call callback function */
1986 if (NULL != client->utt_completeted_cb) {
1987 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1988 tts_client_use_callback(client);
1989 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1990 tts_client_not_use_callback(client);
1992 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1998 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2000 if (0 != __tts_get_feature_enabled()) {
2001 return TTS_ERROR_NOT_SUPPORTED;
2004 if (NULL == tts || NULL == callback) {
2005 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2006 return TTS_ERROR_INVALID_PARAMETER;
2009 tts_client_s* client = tts_client_get(tts);
2011 if (NULL == client) {
2012 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2013 return TTS_ERROR_INVALID_PARAMETER;
2016 if (TTS_STATE_CREATED != client->current_state) {
2017 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2018 return TTS_ERROR_INVALID_STATE;
2021 client->state_changed_cb = callback;
2022 client->state_changed_user_data = user_data;
2024 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2029 int tts_unset_state_changed_cb(tts_h tts)
2031 if (0 != __tts_get_feature_enabled()) {
2032 return TTS_ERROR_NOT_SUPPORTED;
2036 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2037 return TTS_ERROR_INVALID_PARAMETER;
2040 tts_client_s* client = tts_client_get(tts);
2042 if (NULL == client) {
2043 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2044 return TTS_ERROR_INVALID_PARAMETER;
2047 if (TTS_STATE_CREATED != client->current_state) {
2048 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2049 return TTS_ERROR_INVALID_STATE;
2052 client->state_changed_cb = NULL;
2053 client->state_changed_user_data = NULL;
2055 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2060 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2062 if (0 != __tts_get_feature_enabled()) {
2063 return TTS_ERROR_NOT_SUPPORTED;
2066 if (NULL == tts || NULL == callback) {
2067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2068 return TTS_ERROR_INVALID_PARAMETER;
2071 tts_client_s* client = tts_client_get(tts);
2073 if (NULL == client) {
2074 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2075 return TTS_ERROR_INVALID_PARAMETER;
2078 if (TTS_STATE_CREATED != client->current_state) {
2079 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2080 return TTS_ERROR_INVALID_STATE;
2083 client->utt_started_cb = callback;
2084 client->utt_started_user_data = user_data;
2086 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2091 int tts_unset_utterance_started_cb(tts_h tts)
2093 if (0 != __tts_get_feature_enabled()) {
2094 return TTS_ERROR_NOT_SUPPORTED;
2098 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2099 return TTS_ERROR_INVALID_PARAMETER;
2102 tts_client_s* client = tts_client_get(tts);
2104 if (NULL == client) {
2105 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2106 return TTS_ERROR_INVALID_PARAMETER;
2109 if (TTS_STATE_CREATED != client->current_state) {
2110 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2111 return TTS_ERROR_INVALID_STATE;
2114 client->utt_started_cb = NULL;
2115 client->utt_started_user_data = NULL;
2117 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2122 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2124 if (0 != __tts_get_feature_enabled()) {
2125 return TTS_ERROR_NOT_SUPPORTED;
2128 if (NULL == tts || NULL == callback) {
2129 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2130 return TTS_ERROR_INVALID_PARAMETER;
2133 tts_client_s* client = tts_client_get(tts);
2135 if (NULL == client) {
2136 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2137 return TTS_ERROR_INVALID_PARAMETER;
2140 if (TTS_STATE_CREATED != client->current_state) {
2141 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2142 return TTS_ERROR_INVALID_STATE;
2145 client->utt_completeted_cb = callback;
2146 client->utt_completed_user_data = user_data;
2148 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2153 int tts_unset_utterance_completed_cb(tts_h tts)
2155 if (0 != __tts_get_feature_enabled()) {
2156 return TTS_ERROR_NOT_SUPPORTED;
2160 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2161 return TTS_ERROR_INVALID_PARAMETER;
2164 tts_client_s* client = tts_client_get(tts);
2166 if (NULL == client) {
2167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2168 return TTS_ERROR_INVALID_PARAMETER;
2171 if (TTS_STATE_CREATED != client->current_state) {
2172 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2173 return TTS_ERROR_INVALID_STATE;
2176 client->utt_completeted_cb = NULL;
2177 client->utt_completed_user_data = NULL;
2179 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2183 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2185 if (0 != __tts_get_feature_enabled()) {
2186 return TTS_ERROR_NOT_SUPPORTED;
2189 if (NULL == tts || NULL == callback) {
2190 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2191 return TTS_ERROR_INVALID_PARAMETER;
2194 tts_client_s* client = tts_client_get(tts);
2196 if (NULL == client) {
2197 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2198 return TTS_ERROR_INVALID_PARAMETER;
2201 if (TTS_STATE_CREATED != client->current_state) {
2202 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2203 return TTS_ERROR_INVALID_STATE;
2206 client->error_cb = callback;
2207 client->error_user_data = user_data;
2209 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2214 int tts_unset_error_cb(tts_h tts)
2216 if (0 != __tts_get_feature_enabled()) {
2217 return TTS_ERROR_NOT_SUPPORTED;
2221 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2222 return TTS_ERROR_INVALID_PARAMETER;
2225 tts_client_s* client = tts_client_get(tts);
2227 if (NULL == client) {
2228 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2229 return TTS_ERROR_INVALID_PARAMETER;
2232 if (TTS_STATE_CREATED != client->current_state) {
2233 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2234 return TTS_ERROR_INVALID_STATE;
2237 client->error_cb = NULL;
2238 client->error_user_data = NULL;
2240 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2245 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2247 if (0 != __tts_get_feature_enabled()) {
2248 return TTS_ERROR_NOT_SUPPORTED;
2251 if (NULL == tts || NULL == callback) {
2252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2253 return TTS_ERROR_INVALID_PARAMETER;
2256 tts_client_s* client = tts_client_get(tts);
2258 if (NULL == client) {
2259 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2260 return TTS_ERROR_INVALID_PARAMETER;
2263 if (TTS_STATE_CREATED != client->current_state) {
2264 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2265 return TTS_ERROR_INVALID_STATE;
2268 client->default_voice_changed_cb = callback;
2269 client->default_voice_changed_user_data = user_data;
2271 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2276 int tts_unset_default_voice_changed_cb(tts_h tts)
2278 if (0 != __tts_get_feature_enabled()) {
2279 return TTS_ERROR_NOT_SUPPORTED;
2283 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2284 return TTS_ERROR_INVALID_PARAMETER;
2287 tts_client_s* client = tts_client_get(tts);
2289 if (NULL == client) {
2290 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2291 return TTS_ERROR_INVALID_PARAMETER;
2294 if (TTS_STATE_CREATED != client->current_state) {
2295 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2296 return TTS_ERROR_INVALID_STATE;
2299 client->default_voice_changed_cb = NULL;
2300 client->default_voice_changed_user_data = NULL;
2302 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2307 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2309 if (0 != __tts_get_feature_enabled()) {
2310 return TTS_ERROR_NOT_SUPPORTED;
2313 if (NULL == tts || NULL == callback) {
2314 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2315 return TTS_ERROR_INVALID_PARAMETER;
2318 tts_client_s* client = tts_client_get(tts);
2320 if (NULL == client) {
2321 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2322 return TTS_ERROR_INVALID_PARAMETER;
2325 if (TTS_STATE_CREATED != client->current_state) {
2326 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2327 return TTS_ERROR_INVALID_STATE;
2330 client->engine_changed_cb = callback;
2331 client->engine_changed_user_data = user_data;
2333 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2338 int tts_unset_engine_changed_cb(tts_h tts)
2340 if (0 != __tts_get_feature_enabled()) {
2341 return TTS_ERROR_NOT_SUPPORTED;
2345 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2346 return TTS_ERROR_INVALID_PARAMETER;
2349 tts_client_s* client = tts_client_get(tts);
2351 if (NULL == client) {
2352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2353 return TTS_ERROR_INVALID_PARAMETER;
2356 if (TTS_STATE_CREATED != client->current_state) {
2357 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2358 return TTS_ERROR_INVALID_STATE;
2361 client->engine_changed_cb = NULL;
2362 client->engine_changed_user_data = NULL;
2364 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2369 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2371 if (0 != __tts_get_feature_enabled()) {
2372 return TTS_ERROR_NOT_SUPPORTED;
2375 SLOG(LOG_INFO, TAG_TTSC, "===== Add pcm tts");
2378 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2379 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2380 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2381 return TTS_ERROR_INVALID_PARAMETER;
2384 tts_client_s* client = tts_client_get(tts);
2386 if (NULL == client) {
2387 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2388 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2389 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2390 return TTS_ERROR_INVALID_PARAMETER;
2393 if (TTS_STATE_PLAYING != client->current_state) {
2394 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2395 return TTS_ERROR_INVALID_STATE;
2398 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2399 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2400 return TTS_ERROR_INVALID_STATE;
2406 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2408 if (TTS_ERROR_TIMED_OUT != ret) {
2409 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2412 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2415 if (TTS_RETRY_COUNT == count) {
2416 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2423 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2424 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2426 return TTS_ERROR_NONE;
2429 int tts_play_pcm(tts_h tts)
2431 if (0 != __tts_get_feature_enabled()) {
2432 return TTS_ERROR_NOT_SUPPORTED;
2435 SLOG(LOG_INFO, TAG_TTSC, "===== Play pcm tts");
2438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2439 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2440 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2441 return TTS_ERROR_INVALID_PARAMETER;
2444 tts_client_s* client = tts_client_get(tts);
2446 if (NULL == client) {
2447 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2448 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2449 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2450 return TTS_ERROR_INVALID_PARAMETER;
2453 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2454 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2455 return TTS_ERROR_INVALID_STATE;
2458 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2459 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2460 return TTS_ERROR_INVALID_STATE;
2466 ret = tts_dbus_request_play_pcm(client->uid);
2468 if (TTS_ERROR_TIMED_OUT != ret) {
2469 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2472 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2475 if (TTS_RETRY_COUNT == count) {
2476 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2483 client->before_state = client->current_state;
2484 client->current_state = TTS_STATE_PLAYING;
2486 if (NULL != client->state_changed_cb) {
2487 tts_client_use_callback(client);
2488 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2489 tts_client_not_use_callback(client);
2490 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2493 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2494 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2496 return TTS_ERROR_NONE;
2499 int tts_stop_pcm(tts_h tts)
2501 if (0 != __tts_get_feature_enabled()) {
2502 return TTS_ERROR_NOT_SUPPORTED;
2505 SLOG(LOG_INFO, TAG_TTSC, "===== Stop pcm tts");
2508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2509 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2510 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2511 return TTS_ERROR_INVALID_PARAMETER;
2514 tts_client_s* client = tts_client_get(tts);
2516 if (NULL == client) {
2517 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2518 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2519 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2520 return TTS_ERROR_INVALID_PARAMETER;
2523 if (TTS_STATE_PLAYING != client->current_state) {
2524 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2525 return TTS_ERROR_INVALID_STATE;
2528 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2529 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2530 return TTS_ERROR_INVALID_STATE;
2536 ret = tts_dbus_request_stop_pcm(client->uid);
2538 if (TTS_ERROR_TIMED_OUT != ret) {
2539 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2542 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2545 if (TTS_RETRY_COUNT == count) {
2546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2553 client->before_state = client->current_state;
2554 client->current_state = TTS_STATE_READY;
2556 if (NULL != client->state_changed_cb) {
2557 tts_client_use_callback(client);
2558 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2559 tts_client_not_use_callback(client);
2560 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2563 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2564 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2566 return TTS_ERROR_NONE;