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 /* Function definition */
38 static Eina_Bool __tts_notify_state_changed(void *data);
39 static Eina_Bool __tts_notify_error(void *data);
46 static int __tts_get_feature_enabled()
48 if (0 == g_feature_enabled) {
49 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
50 return TTS_ERROR_NOT_SUPPORTED;
51 } else if (-1 == g_feature_enabled) {
52 bool tts_supported = false;
53 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
54 if (false == tts_supported) {
55 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
56 g_feature_enabled = 0;
57 return TTS_ERROR_NOT_SUPPORTED;
60 g_feature_enabled = 1;
62 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
63 return TTS_ERROR_NOT_SUPPORTED;
70 static const char* __tts_get_error_code(tts_error_e err)
73 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
74 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
75 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
76 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
77 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
78 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
79 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
80 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
81 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
82 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
83 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
84 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
85 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
86 case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
87 case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET";
89 return "Invalid error code";
94 static int __tts_convert_config_error_code(tts_config_error_e code)
96 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
97 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
98 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
99 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
100 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
101 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
102 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
103 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
104 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE;
109 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)
111 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
112 before_lang, before_voice_type, language, voice_type);
114 GList* client_list = NULL;
115 client_list = tts_client_get_client_list();
118 tts_client_s *data = NULL;
120 if (g_list_length(client_list) > 0) {
121 /* Get a first item */
122 iter = g_list_first(client_list);
124 while (NULL != iter) {
126 if (NULL != data->default_voice_changed_cb) {
127 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
128 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
129 language, voice_type, data->default_voice_changed_user_data);
133 iter = g_list_next(iter);
140 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)
142 tts_h tts = (tts_h)user_data;
144 tts_client_s* client = tts_client_get(tts);
145 if (NULL == client) {
146 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
150 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
151 if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
152 if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
153 SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
155 /* call callback function */
156 if (NULL != client->engine_changed_cb) {
157 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
159 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
164 int tts_create(tts_h* tts)
166 if (0 != __tts_get_feature_enabled()) {
167 return TTS_ERROR_NOT_SUPPORTED;
170 SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
175 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
176 SLOG(LOG_DEBUG, TAG_TTSC, " ");
177 return TTS_ERROR_INVALID_PARAMETER;
180 if (0 == tts_client_get_size()) {
181 if (0 != tts_dbus_open_connection()) {
182 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
183 return TTS_ERROR_OPERATION_FAILED;
187 if (0 != tts_client_new(tts)) {
188 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
189 return TTS_ERROR_OUT_OF_MEMORY;
192 tts_client_s* client = tts_client_get(*tts);
193 if (NULL == client) {
194 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
195 return TTS_ERROR_OPERATION_FAILED;
198 int ret = tts_config_mgr_initialize(client->uid);
200 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
201 tts_client_destroy(*tts);
202 return __tts_convert_config_error_code(ret);
205 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL);
207 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
208 tts_client_destroy(*tts);
209 return __tts_convert_config_error_code(ret);
212 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
213 SLOG(LOG_DEBUG, TAG_TTSC, " ");
215 return TTS_ERROR_NONE;
218 int tts_destroy(tts_h tts)
220 if (0 != __tts_get_feature_enabled()) {
221 return TTS_ERROR_NOT_SUPPORTED;
224 SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
227 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
228 return TTS_ERROR_INVALID_PARAMETER;
231 tts_client_s* client = tts_client_get(tts);
234 if (NULL == client) {
235 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
236 return TTS_ERROR_INVALID_PARAMETER;
239 /* check used callback */
240 if (0 != tts_client_get_use_callback(client)) {
241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
242 return TTS_ERROR_OPERATION_FAILED;
245 tts_config_mgr_finalize(client->uid);
251 switch (client->current_state) {
252 case TTS_STATE_PAUSED:
253 case TTS_STATE_PLAYING:
254 case TTS_STATE_READY:
255 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
257 ret = tts_dbus_request_finalize(client->uid);
259 if (TTS_ERROR_TIMED_OUT != ret) {
260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
263 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
266 if (TTS_RETRY_COUNT == count) {
267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
274 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
277 client->before_state = client->current_state;
278 client->current_state = TTS_STATE_CREATED;
280 case TTS_STATE_CREATED:
281 if (NULL != client->conn_timer) {
282 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
283 ecore_timer_del(client->conn_timer);
284 client->conn_timer = NULL;
287 tts_client_destroy(tts);
294 if (0 == tts_client_get_size()) {
295 if (0 != tts_dbus_close_connection()) {
296 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
302 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
303 SLOG(LOG_DEBUG, TAG_TTSC, " ");
305 return TTS_ERROR_NONE;
308 void __tts_screen_reader_changed_cb(bool value)
310 g_screen_reader = value;
313 int tts_set_mode(tts_h tts, tts_mode_e mode)
315 if (0 != __tts_get_feature_enabled()) {
316 return TTS_ERROR_NOT_SUPPORTED;
319 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
321 tts_client_s* client = tts_client_get(tts);
324 if (NULL == client) {
325 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
326 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
327 SLOG(LOG_DEBUG, TAG_TTSC, " ");
328 return TTS_ERROR_INVALID_PARAMETER;
332 if (client->current_state != TTS_STATE_CREATED) {
333 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
334 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
335 SLOG(LOG_DEBUG, TAG_TTSC, " ");
336 return TTS_ERROR_INVALID_STATE;
339 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
342 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
343 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
344 SLOG(LOG_DEBUG, TAG_TTSC, " ");
345 return TTS_ERROR_INVALID_PARAMETER;
348 if (TTS_MODE_SCREEN_READER == mode) {
351 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
353 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
354 return TTS_ERROR_OPERATION_FAILED;
356 g_screen_reader = (bool)screen_reader;
357 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
359 tts_config_unset_screen_reader_callback(client->uid);
362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
365 return TTS_ERROR_NONE;
368 int tts_get_mode(tts_h tts, tts_mode_e* mode)
370 if (0 != __tts_get_feature_enabled()) {
371 return TTS_ERROR_NOT_SUPPORTED;
374 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
376 tts_client_s* client = tts_client_get(tts);
379 if (NULL == client) {
380 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
381 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
382 SLOG(LOG_DEBUG, TAG_TTSC, " ");
383 return TTS_ERROR_INVALID_PARAMETER;
387 if (client->current_state != TTS_STATE_CREATED) {
388 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
389 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
390 SLOG(LOG_DEBUG, TAG_TTSC, " ");
391 return TTS_ERROR_INVALID_STATE;
395 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
396 return TTS_ERROR_INVALID_PARAMETER;
399 *mode = client->mode;
401 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
402 SLOG(LOG_DEBUG, TAG_TTSC, " ");
404 return TTS_ERROR_NONE;
407 int tts_set_credential(tts_h tts, const char* credential)
409 if (0 != __tts_get_feature_enabled()) {
410 return TTS_ERROR_NOT_SUPPORTED;
413 if (NULL == tts || NULL == credential) {
414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
415 return TTS_ERROR_INVALID_PARAMETER;
418 tts_client_s* client = tts_client_get(tts);
420 if (NULL == client) {
421 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
422 return TTS_ERROR_INVALID_PARAMETER;
425 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
426 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
427 return TTS_ERROR_INVALID_STATE;
430 if (NULL != client->credential) {
431 free(client->credential);
432 client->credential = NULL;
434 client->credential = strdup(credential);
436 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
437 SLOG(LOG_DEBUG, TAG_TTSC, " ");
439 return TTS_ERROR_NONE;
442 int tts_set_server_tts(tts_h tts, const char* credential)
444 if (0 != __tts_get_feature_enabled()) {
445 return TTS_ERROR_NOT_SUPPORTED;
448 if (NULL == tts || NULL == credential) {
449 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
450 return TTS_ERROR_INVALID_PARAMETER;
453 tts_client_s* client = tts_client_get(tts);
455 if (NULL == client) {
456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
457 return TTS_ERROR_INVALID_PARAMETER;
460 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
461 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
462 return TTS_ERROR_INVALID_STATE;
465 if (NULL != client->credential) {
466 free(client->credential);
467 client->credential = NULL;
470 client->credential = strdup(credential);
471 if (NULL == client->credential) {
472 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
473 return TTS_ERROR_OUT_OF_MEMORY;
476 client->internal = true;
479 if (NULL != credential)
480 key = strdup("EnableServerTTS");
482 key = strdup("DisableServerTTS");
484 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
485 return TTS_ERROR_OUT_OF_MEMORY;
490 int ret = app_manager_get_app_id(pid, &appid);
492 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
495 return TTS_ERROR_OPERATION_FAILED;
498 ret = tts_set_private_data(tts, key, appid);
500 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
511 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
512 SLOG(LOG_DEBUG, TAG_TTSC, " ");
514 return TTS_ERROR_NONE;
517 static Eina_Bool __tts_connect_daemon(void *data)
519 tts_h tts = (tts_h)data;
520 tts_client_s* client = tts_client_get(tts);
523 if (NULL == client) {
524 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
529 if (0 != tts_dbus_request_hello(client->uid)) {
533 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
535 /* do request initialize */
537 bool credential_needed = false;
539 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
541 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
542 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
544 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
547 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
548 client->conn_timer = NULL;
551 } else if (TTS_ERROR_NONE != ret) {
552 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
556 /* success to connect tts-daemon */
557 client->credential_needed = credential_needed;
558 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
561 client->conn_timer = NULL;
563 client = tts_client_get(tts);
565 if (NULL == client) {
566 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
570 client->before_state = client->current_state;
571 client->current_state = TTS_STATE_READY;
573 if (NULL != client->state_changed_cb) {
574 tts_client_use_callback(client);
575 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
576 tts_client_not_use_callback(client);
578 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
581 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
582 SLOG(LOG_DEBUG, TAG_TTSC, " ");
587 int tts_prepare(tts_h tts)
589 if (0 != __tts_get_feature_enabled()) {
590 return TTS_ERROR_NOT_SUPPORTED;
593 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
595 tts_client_s* client = tts_client_get(tts);
598 if (NULL == client) {
599 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
600 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
601 SLOG(LOG_DEBUG, TAG_TTSC, " ");
602 return TTS_ERROR_INVALID_PARAMETER;
606 if (client->current_state != TTS_STATE_CREATED) {
607 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
608 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
609 SLOG(LOG_DEBUG, TAG_TTSC, " ");
610 return TTS_ERROR_INVALID_STATE;
613 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
615 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
616 SLOG(LOG_DEBUG, TAG_TTSC, " ");
618 return TTS_ERROR_NONE;
621 int tts_unprepare(tts_h tts)
623 if (0 != __tts_get_feature_enabled()) {
624 return TTS_ERROR_NOT_SUPPORTED;
627 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
629 tts_client_s* client = tts_client_get(tts);
632 if (NULL == client) {
633 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
634 return TTS_ERROR_INVALID_PARAMETER;
638 if (client->current_state != TTS_STATE_READY) {
639 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
640 return TTS_ERROR_INVALID_STATE;
645 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
647 ret = tts_dbus_request_finalize(client->uid);
649 if (TTS_ERROR_TIMED_OUT != ret) {
650 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
653 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
656 if (TTS_RETRY_COUNT == count) {
657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
664 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
667 client->before_state = client->current_state;
668 client->current_state = TTS_STATE_CREATED;
670 if (NULL != client->state_changed_cb) {
671 tts_client_use_callback(client);
672 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
673 tts_client_not_use_callback(client);
674 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
677 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
678 SLOG(LOG_DEBUG, TAG_TTSC, " ");
680 return TTS_ERROR_NONE;
683 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
685 tts_h tts = (tts_h)user_data;
687 tts_client_s* client = tts_client_get(tts);
688 if (NULL == client) {
689 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
693 /* call callback function */
694 if (NULL != client->supported_voice_cb) {
695 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
697 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
703 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
705 if (0 != __tts_get_feature_enabled()) {
706 return TTS_ERROR_NOT_SUPPORTED;
709 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
711 if (NULL == tts || NULL == callback) {
712 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
713 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
714 SLOG(LOG_DEBUG, TAG_TTSC, " ");
715 return TTS_ERROR_INVALID_PARAMETER;
718 tts_client_s* client = tts_client_get(tts);
721 if (NULL == client) {
722 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
723 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
724 SLOG(LOG_DEBUG, TAG_TTSC, " ");
725 return TTS_ERROR_INVALID_PARAMETER;
729 char* current_engine = NULL;
730 ret = tts_config_mgr_get_engine(¤t_engine);
732 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
733 return __tts_convert_config_error_code(ret);
736 client->supported_voice_cb = callback;
737 client->supported_voice_user_data = user_data;
739 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
741 if (NULL != current_engine)
742 free(current_engine);
744 client->supported_voice_cb = NULL;
745 client->supported_voice_user_data = NULL;
748 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
749 ret = TTS_ERROR_OPERATION_FAILED;
752 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
753 SLOG(LOG_DEBUG, TAG_TTSC, " ");
758 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
760 if (0 != __tts_get_feature_enabled()) {
761 return TTS_ERROR_NOT_SUPPORTED;
764 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
767 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
768 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
769 SLOG(LOG_DEBUG, TAG_TTSC, " ");
770 return TTS_ERROR_INVALID_PARAMETER;
773 tts_client_s* client = tts_client_get(tts);
775 if (NULL == client) {
776 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
777 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
778 SLOG(LOG_DEBUG, TAG_TTSC, " ");
779 return TTS_ERROR_INVALID_PARAMETER;
782 /* Request call remote method */
784 ret = tts_config_mgr_get_voice(lang, vctype);
786 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
787 return __tts_convert_config_error_code(ret);
789 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
792 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
793 SLOG(LOG_DEBUG, TAG_TTSC, " ");
798 int tts_get_max_text_size(tts_h tts, unsigned int* size)
800 if (0 != __tts_get_feature_enabled()) {
801 return TTS_ERROR_NOT_SUPPORTED;
804 if (NULL == tts || NULL == size) {
805 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
806 return TTS_ERROR_INVALID_PARAMETER;
809 tts_client_s* client = tts_client_get(tts);
811 if (NULL == client) {
812 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
813 return TTS_ERROR_INVALID_PARAMETER;
816 if (TTS_STATE_READY != client->current_state) {
817 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
818 return TTS_ERROR_INVALID_STATE;
821 *size = TTS_MAX_TEXT_SIZE;
823 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
824 return TTS_ERROR_NONE;
827 int tts_get_state(tts_h tts, tts_state_e* state)
829 if (0 != __tts_get_feature_enabled()) {
830 return TTS_ERROR_NOT_SUPPORTED;
833 if (NULL == tts || NULL == state) {
834 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
835 return TTS_ERROR_INVALID_PARAMETER;
838 tts_client_s* client = tts_client_get(tts);
840 if (NULL == client) {
841 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
842 return TTS_ERROR_INVALID_PARAMETER;
845 *state = client->current_state;
848 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
849 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
850 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
851 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
852 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
855 return TTS_ERROR_NONE;
858 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
860 if (0 != __tts_get_feature_enabled()) {
861 return TTS_ERROR_NOT_SUPPORTED;
864 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
865 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
866 return TTS_ERROR_INVALID_PARAMETER;
869 tts_client_s* client = tts_client_get(tts);
871 if (NULL == client) {
872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
873 return TTS_ERROR_INVALID_PARAMETER;
876 *min = TTS_SPEED_MIN;
877 *normal = TTS_SPEED_NORMAL;
878 *max = TTS_SPEED_MAX;
880 return TTS_ERROR_NONE;
883 int tts_get_error_message(tts_h tts, char** err_msg)
885 if (0 != __tts_get_feature_enabled()) {
886 return TTS_ERROR_NOT_SUPPORTED;
889 if (NULL == tts || NULL == err_msg) {
890 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
891 return TTS_ERROR_INVALID_PARAMETER;
894 tts_client_s* client = tts_client_get(tts);
896 if (NULL == client) {
897 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
898 return TTS_ERROR_INVALID_PARAMETER;
901 if (NULL != client->err_msg) {
902 *err_msg = strdup(client->err_msg);
903 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
905 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
908 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
909 SLOG(LOG_DEBUG, TAG_TTSC, " ");
911 return TTS_ERROR_NONE;
914 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
916 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
918 if (0 != __tts_get_feature_enabled()) {
919 return TTS_ERROR_NOT_SUPPORTED;
923 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
924 return TTS_ERROR_INVALID_PARAMETER;
927 if (voice_type < 0) {
928 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
929 return TTS_ERROR_INVALID_PARAMETER;
932 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
934 if (NULL == tts || NULL == utt_id) {
935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
936 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
937 SLOG(LOG_DEBUG, TAG_TTSC, " ");
938 return TTS_ERROR_INVALID_PARAMETER;
941 tts_client_s* client = tts_client_get(tts);
943 if (NULL == client) {
944 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
945 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
946 SLOG(LOG_DEBUG, TAG_TTSC, " ");
947 return TTS_ERROR_INVALID_PARAMETER;
950 if (TTS_STATE_CREATED == client->current_state) {
951 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
952 return TTS_ERROR_INVALID_STATE;
955 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
956 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
957 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
958 SLOG(LOG_DEBUG, TAG_TTSC, " ");
959 return TTS_ERROR_INVALID_PARAMETER;
962 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
963 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
964 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
965 SLOG(LOG_DEBUG, TAG_TTSC, " ");
966 return TTS_ERROR_INVALID_PARAMETER;
969 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
970 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
971 return TTS_ERROR_INVALID_STATE;
974 if (true == client->credential_needed && NULL == client->credential) {
975 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
976 return TTS_ERROR_PERMISSION_DENIED;
979 /* check valid utf8 */
981 ict = iconv_open("utf-8", "");
982 if ((iconv_t)-1 == ict) {
983 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
984 return TTS_ERROR_OPERATION_FAILED;
987 size_t len = strlen(text);
989 char in_buf[TTS_MAX_TEXT_SIZE];
990 char *out_tmp = NULL;
991 char out_buf[TTS_MAX_TEXT_SIZE];
992 size_t len_tmp = sizeof(out_buf);
994 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
995 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
998 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
1002 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
1003 if ((size_t)-1 == st) {
1004 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
1006 return TTS_ERROR_INVALID_PARAMETER;
1009 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
1011 /* change default language value */
1014 if (NULL == language)
1015 temp = strdup("default");
1017 temp = strdup(language);
1019 client->current_utt_id++;
1020 if (client->current_utt_id == 10000) {
1021 client->current_utt_id = 1;
1028 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
1030 if (TTS_ERROR_TIMED_OUT != ret) {
1031 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1034 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1037 if (TTS_RETRY_MIN_COUNT == count) {
1038 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1043 *utt_id = client->current_utt_id;
1047 if (NULL != temp) free(temp);
1049 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1050 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1055 static void __tts_play_async(void *data)
1057 tts_h tts = (tts_h)data;
1058 tts_client_s* client = tts_client_get(tts);
1061 if (NULL == client) {
1062 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1069 ret = tts_dbus_request_play(client->uid, client->credential);
1071 if (TTS_ERROR_TIMED_OUT != ret) {
1072 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1075 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1078 if (TTS_RETRY_COUNT == count) {
1079 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1087 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1089 client->reason = ret;
1090 client->utt_id = -1;
1092 ecore_timer_add(0, __tts_notify_error, client->tts);
1096 client->before_state = client->current_state;
1097 client->current_state = TTS_STATE_PLAYING;
1099 if (NULL != client->state_changed_cb) {
1100 tts_client_use_callback(client);
1101 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1102 tts_client_not_use_callback(client);
1103 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1106 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1107 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1112 int tts_play_async(tts_h tts)
1114 if (0 != __tts_get_feature_enabled()) {
1115 return TTS_ERROR_NOT_SUPPORTED;
1118 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1121 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1122 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1123 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1124 return TTS_ERROR_INVALID_PARAMETER;
1127 tts_client_s* client = tts_client_get(tts);
1129 if (NULL == client) {
1130 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1131 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1132 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1133 return TTS_ERROR_INVALID_PARAMETER;
1136 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1137 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1138 return TTS_ERROR_INVALID_STATE;
1141 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1142 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1143 return TTS_ERROR_INVALID_STATE;
1146 if (true == client->credential_needed && NULL == client->credential) {
1147 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1148 return TTS_ERROR_PERMISSION_DENIED;
1151 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1153 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1154 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1156 return TTS_ERROR_NONE;
1159 int tts_play(tts_h tts)
1161 if (0 != __tts_get_feature_enabled()) {
1162 return TTS_ERROR_NOT_SUPPORTED;
1165 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1168 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1169 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1170 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1171 return TTS_ERROR_INVALID_PARAMETER;
1174 tts_client_s* client = tts_client_get(tts);
1176 if (NULL == client) {
1177 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1178 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1179 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1180 return TTS_ERROR_INVALID_PARAMETER;
1183 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1184 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1185 return TTS_ERROR_INVALID_STATE;
1188 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1189 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1190 return TTS_ERROR_INVALID_STATE;
1193 if (true == client->credential_needed && NULL == client->credential) {
1194 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1195 return TTS_ERROR_PERMISSION_DENIED;
1201 ret = tts_dbus_request_play(client->uid, client->credential);
1203 if (TTS_ERROR_TIMED_OUT != ret) {
1204 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1207 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1210 if (TTS_RETRY_COUNT == count) {
1211 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1218 client->before_state = client->current_state;
1219 client->current_state = TTS_STATE_PLAYING;
1221 if (NULL != client->state_changed_cb) {
1222 tts_client_use_callback(client);
1223 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1224 tts_client_not_use_callback(client);
1225 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1228 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1229 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1231 return TTS_ERROR_NONE;
1234 static void __tts_stop_async(void *data)
1236 tts_h tts = (tts_h)data;
1237 tts_client_s* client = tts_client_get(tts);
1240 if (NULL == client) {
1241 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1248 ret = tts_dbus_request_stop(client->uid);
1250 if (TTS_ERROR_TIMED_OUT != ret) {
1251 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1254 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1257 if (TTS_RETRY_COUNT == count) {
1258 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1266 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1268 client->reason = ret;
1269 client->utt_id = -1;
1271 ecore_timer_add(0, __tts_notify_error, client->tts);
1275 client->before_state = client->current_state;
1276 client->current_state = TTS_STATE_READY;
1278 if (NULL != client->state_changed_cb) {
1279 tts_client_use_callback(client);
1280 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1281 tts_client_not_use_callback(client);
1282 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1285 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1286 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1291 int tts_stop_aync(tts_h tts)
1293 if (0 != __tts_get_feature_enabled()) {
1294 return TTS_ERROR_NOT_SUPPORTED;
1297 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1300 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1301 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1302 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1303 return TTS_ERROR_INVALID_PARAMETER;
1306 tts_client_s* client = tts_client_get(tts);
1308 if (NULL == client) {
1309 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1310 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1311 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1312 return TTS_ERROR_INVALID_PARAMETER;
1315 if (TTS_STATE_CREATED == client->current_state) {
1316 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1317 return TTS_ERROR_INVALID_STATE;
1320 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1321 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1322 return TTS_ERROR_INVALID_STATE;
1325 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1327 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1328 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1330 return TTS_ERROR_NONE;
1333 int tts_stop(tts_h tts)
1335 if (0 != __tts_get_feature_enabled()) {
1336 return TTS_ERROR_NOT_SUPPORTED;
1339 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1342 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1343 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1344 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1345 return TTS_ERROR_INVALID_PARAMETER;
1348 tts_client_s* client = tts_client_get(tts);
1350 if (NULL == client) {
1351 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1352 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1353 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1354 return TTS_ERROR_INVALID_PARAMETER;
1357 if (TTS_STATE_CREATED == client->current_state) {
1358 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1359 return TTS_ERROR_INVALID_STATE;
1362 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1363 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1364 return TTS_ERROR_INVALID_STATE;
1370 ret = tts_dbus_request_stop(client->uid);
1372 if (TTS_ERROR_TIMED_OUT != ret) {
1373 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1376 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1379 if (TTS_RETRY_COUNT == count) {
1380 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1387 client->before_state = client->current_state;
1388 client->current_state = TTS_STATE_READY;
1390 if (NULL != client->state_changed_cb) {
1391 tts_client_use_callback(client);
1392 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1393 tts_client_not_use_callback(client);
1394 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1397 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1398 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1400 return TTS_ERROR_NONE;
1403 static void __tts_pause_async(void *data)
1405 tts_h tts = (tts_h)data;
1406 tts_client_s* client = tts_client_get(tts);
1409 if (NULL == client) {
1410 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1417 ret = tts_dbus_request_pause(client->uid);
1419 if (TTS_ERROR_TIMED_OUT != ret) {
1420 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1423 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1426 if (TTS_RETRY_COUNT == count) {
1427 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1437 client->reason = ret;
1438 client->utt_id = -1;
1440 ecore_timer_add(0, __tts_notify_error, client->tts);
1444 client->before_state = client->current_state;
1445 client->current_state = TTS_STATE_PAUSED;
1447 if (NULL != client->state_changed_cb) {
1448 tts_client_use_callback(client);
1449 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1450 tts_client_not_use_callback(client);
1451 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1454 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1455 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1460 int tts_pause_async(tts_h tts)
1462 if (0 != __tts_get_feature_enabled()) {
1463 return TTS_ERROR_NOT_SUPPORTED;
1466 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1469 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1470 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1471 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1472 return TTS_ERROR_INVALID_PARAMETER;
1475 tts_client_s* client = tts_client_get(tts);
1477 if (NULL == client) {
1478 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1479 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1480 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1481 return TTS_ERROR_INVALID_PARAMETER;
1484 if (TTS_STATE_PLAYING != client->current_state) {
1485 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1486 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1487 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1488 return TTS_ERROR_INVALID_STATE;
1491 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1492 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1493 return TTS_ERROR_INVALID_STATE;
1496 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1498 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1499 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1501 return TTS_ERROR_NONE;
1504 int tts_pause(tts_h tts)
1506 if (0 != __tts_get_feature_enabled()) {
1507 return TTS_ERROR_NOT_SUPPORTED;
1510 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1513 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1514 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1515 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1516 return TTS_ERROR_INVALID_PARAMETER;
1519 tts_client_s* client = tts_client_get(tts);
1521 if (NULL == client) {
1522 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1523 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1524 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1525 return TTS_ERROR_INVALID_PARAMETER;
1528 if (TTS_STATE_PLAYING != client->current_state) {
1529 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1530 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1531 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1532 return TTS_ERROR_INVALID_STATE;
1535 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1536 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1537 return TTS_ERROR_INVALID_STATE;
1543 ret = tts_dbus_request_pause(client->uid);
1545 if (TTS_ERROR_TIMED_OUT != ret) {
1546 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1549 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1552 if (TTS_RETRY_COUNT == count) {
1553 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1560 client->before_state = client->current_state;
1561 client->current_state = TTS_STATE_PAUSED;
1563 if (NULL != client->state_changed_cb) {
1564 tts_client_use_callback(client);
1565 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1566 tts_client_not_use_callback(client);
1567 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1570 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1571 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1573 return TTS_ERROR_NONE;
1576 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1578 if (0 != __tts_get_feature_enabled()) {
1579 return TTS_ERROR_NOT_SUPPORTED;
1582 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1585 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1586 return TTS_ERROR_INVALID_PARAMETER;
1589 if (NULL == key || NULL == data) {
1590 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1591 return TTS_ERROR_INVALID_PARAMETER;
1594 tts_client_s* client = tts_client_get(tts);
1596 if (NULL == client) {
1597 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1598 return TTS_ERROR_INVALID_PARAMETER;
1601 if (TTS_STATE_READY != client->current_state) {
1602 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1603 return TTS_ERROR_INVALID_STATE;
1606 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1607 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1608 return TTS_ERROR_INVALID_PARAMETER;
1614 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1616 if (TTS_ERROR_TIMED_OUT != ret) {
1617 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1620 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1623 if (TTS_RETRY_COUNT == count) {
1624 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1631 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1632 SLOG(LOG_DEBUG, TAG_TTSC, "");
1637 int tts_get_private_data(tts_h tts, const char* key, char** data)
1639 if (0 != __tts_get_feature_enabled()) {
1640 return TTS_ERROR_NOT_SUPPORTED;
1643 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1646 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1647 return TTS_ERROR_INVALID_PARAMETER;
1650 if (NULL == key || NULL == data) {
1651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1652 return TTS_ERROR_INVALID_PARAMETER;
1655 tts_client_s* client = tts_client_get(tts);
1657 if (NULL == client) {
1658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1659 return TTS_ERROR_INVALID_PARAMETER;
1662 if (TTS_STATE_READY != client->current_state) {
1663 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1664 return TTS_ERROR_INVALID_STATE;
1670 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1672 if (TTS_ERROR_TIMED_OUT != ret) {
1673 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1676 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1679 if (TTS_RETRY_COUNT == count) {
1680 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1687 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1692 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1693 SLOG(LOG_DEBUG, TAG_TTSC, "");
1698 static Eina_Bool __tts_notify_error(void *data)
1700 tts_h tts = (tts_h)data;
1702 tts_client_s* client = tts_client_get(tts);
1705 if (NULL == client) {
1706 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1710 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1712 if (NULL != client->error_cb) {
1713 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1714 tts_client_use_callback(client);
1715 g_err_callback_status = true;
1716 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1717 g_err_callback_status = false;
1718 tts_client_not_use_callback(client);
1720 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1726 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1728 tts_client_s* client = tts_client_get_by_uid(uid);
1730 if (NULL == client) {
1731 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1732 return TTS_ERROR_INVALID_PARAMETER;
1735 client->utt_id = utt_id;
1736 client->reason = reason;
1737 if (NULL != client->err_msg) {
1738 free(client->err_msg);
1739 client->err_msg = NULL;
1741 client->err_msg = strdup(err_msg);
1743 /* call callback function */
1744 if (NULL != client->error_cb) {
1745 ecore_timer_add(0, __tts_notify_error, client->tts);
1747 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1750 if (TTS_ERROR_SERVICE_RESET == reason) {
1751 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1753 client->current_state = TTS_STATE_CREATED;
1754 if (0 != tts_prepare(client->tts)) {
1755 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1762 static Eina_Bool __tts_notify_state_changed(void *data)
1764 tts_h tts = (tts_h)data;
1766 tts_client_s* client = tts_client_get(tts);
1769 if (NULL == client) {
1770 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1774 if (NULL != client->state_changed_cb) {
1775 tts_client_use_callback(client);
1776 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1777 tts_client_not_use_callback(client);
1778 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1780 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1786 int __tts_cb_set_state(int uid, int state)
1788 tts_client_s* client = tts_client_get_by_uid(uid);
1789 if (NULL == client) {
1790 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1794 tts_state_e state_from_daemon = (tts_state_e)state;
1796 if (client->current_state == state_from_daemon) {
1797 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1801 if (NULL != client->state_changed_cb) {
1802 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1804 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1807 client->before_state = client->current_state;
1808 client->current_state = state_from_daemon;
1813 int __tts_cb_utt_started(int uid, int utt_id)
1815 tts_client_s* client = tts_client_get_by_uid(uid);
1817 if (NULL == client) {
1818 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1819 return TTS_ERROR_INVALID_PARAMETER;
1822 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1824 client->utt_id = utt_id;
1826 /* call callback function */
1827 if (NULL != client->utt_started_cb) {
1828 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1829 tts_client_use_callback(client);
1830 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1831 tts_client_not_use_callback(client);
1833 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1839 int __tts_cb_utt_completed(int uid, int utt_id)
1841 tts_client_s* client = tts_client_get_by_uid(uid);
1843 if (NULL == client) {
1844 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1845 return TTS_ERROR_INVALID_PARAMETER;
1848 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1850 client->utt_id = utt_id;
1852 /* call callback function */
1853 if (NULL != client->utt_completeted_cb) {
1854 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1855 tts_client_use_callback(client);
1856 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1857 tts_client_not_use_callback(client);
1859 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1865 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1867 if (0 != __tts_get_feature_enabled()) {
1868 return TTS_ERROR_NOT_SUPPORTED;
1871 if (NULL == tts || NULL == callback) {
1872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1873 return TTS_ERROR_INVALID_PARAMETER;
1876 tts_client_s* client = tts_client_get(tts);
1878 if (NULL == client) {
1879 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1880 return TTS_ERROR_INVALID_PARAMETER;
1883 if (TTS_STATE_CREATED != client->current_state) {
1884 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1885 return TTS_ERROR_INVALID_STATE;
1888 client->state_changed_cb = callback;
1889 client->state_changed_user_data = user_data;
1891 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1896 int tts_unset_state_changed_cb(tts_h tts)
1898 if (0 != __tts_get_feature_enabled()) {
1899 return TTS_ERROR_NOT_SUPPORTED;
1903 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1904 return TTS_ERROR_INVALID_PARAMETER;
1907 tts_client_s* client = tts_client_get(tts);
1909 if (NULL == client) {
1910 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1911 return TTS_ERROR_INVALID_PARAMETER;
1914 if (TTS_STATE_CREATED != client->current_state) {
1915 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1916 return TTS_ERROR_INVALID_STATE;
1919 client->state_changed_cb = NULL;
1920 client->state_changed_user_data = NULL;
1922 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1927 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1929 if (0 != __tts_get_feature_enabled()) {
1930 return TTS_ERROR_NOT_SUPPORTED;
1933 if (NULL == tts || NULL == callback) {
1934 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1935 return TTS_ERROR_INVALID_PARAMETER;
1938 tts_client_s* client = tts_client_get(tts);
1940 if (NULL == client) {
1941 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1942 return TTS_ERROR_INVALID_PARAMETER;
1945 if (TTS_STATE_CREATED != client->current_state) {
1946 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1947 return TTS_ERROR_INVALID_STATE;
1950 client->utt_started_cb = callback;
1951 client->utt_started_user_data = user_data;
1953 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1958 int tts_unset_utterance_started_cb(tts_h tts)
1960 if (0 != __tts_get_feature_enabled()) {
1961 return TTS_ERROR_NOT_SUPPORTED;
1965 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1966 return TTS_ERROR_INVALID_PARAMETER;
1969 tts_client_s* client = tts_client_get(tts);
1971 if (NULL == client) {
1972 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1973 return TTS_ERROR_INVALID_PARAMETER;
1976 if (TTS_STATE_CREATED != client->current_state) {
1977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1978 return TTS_ERROR_INVALID_STATE;
1981 client->utt_started_cb = NULL;
1982 client->utt_started_user_data = NULL;
1984 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1989 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1991 if (0 != __tts_get_feature_enabled()) {
1992 return TTS_ERROR_NOT_SUPPORTED;
1995 if (NULL == tts || NULL == callback) {
1996 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1997 return TTS_ERROR_INVALID_PARAMETER;
2000 tts_client_s* client = tts_client_get(tts);
2002 if (NULL == client) {
2003 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2004 return TTS_ERROR_INVALID_PARAMETER;
2007 if (TTS_STATE_CREATED != client->current_state) {
2008 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2009 return TTS_ERROR_INVALID_STATE;
2012 client->utt_completeted_cb = callback;
2013 client->utt_completed_user_data = user_data;
2015 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2020 int tts_unset_utterance_completed_cb(tts_h tts)
2022 if (0 != __tts_get_feature_enabled()) {
2023 return TTS_ERROR_NOT_SUPPORTED;
2027 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2028 return TTS_ERROR_INVALID_PARAMETER;
2031 tts_client_s* client = tts_client_get(tts);
2033 if (NULL == client) {
2034 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2035 return TTS_ERROR_INVALID_PARAMETER;
2038 if (TTS_STATE_CREATED != client->current_state) {
2039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2040 return TTS_ERROR_INVALID_STATE;
2043 client->utt_completeted_cb = NULL;
2044 client->utt_completed_user_data = NULL;
2046 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2050 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2052 if (0 != __tts_get_feature_enabled()) {
2053 return TTS_ERROR_NOT_SUPPORTED;
2056 if (NULL == tts || NULL == callback) {
2057 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2058 return TTS_ERROR_INVALID_PARAMETER;
2061 tts_client_s* client = tts_client_get(tts);
2063 if (NULL == client) {
2064 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2065 return TTS_ERROR_INVALID_PARAMETER;
2068 if (TTS_STATE_CREATED != client->current_state) {
2069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2070 return TTS_ERROR_INVALID_STATE;
2073 client->error_cb = callback;
2074 client->error_user_data = user_data;
2076 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2081 int tts_unset_error_cb(tts_h tts)
2083 if (0 != __tts_get_feature_enabled()) {
2084 return TTS_ERROR_NOT_SUPPORTED;
2088 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2089 return TTS_ERROR_INVALID_PARAMETER;
2092 tts_client_s* client = tts_client_get(tts);
2094 if (NULL == client) {
2095 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2096 return TTS_ERROR_INVALID_PARAMETER;
2099 if (TTS_STATE_CREATED != client->current_state) {
2100 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2101 return TTS_ERROR_INVALID_STATE;
2104 client->error_cb = NULL;
2105 client->error_user_data = NULL;
2107 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2112 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2114 if (0 != __tts_get_feature_enabled()) {
2115 return TTS_ERROR_NOT_SUPPORTED;
2118 if (NULL == tts || NULL == callback) {
2119 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2120 return TTS_ERROR_INVALID_PARAMETER;
2123 tts_client_s* client = tts_client_get(tts);
2125 if (NULL == client) {
2126 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2127 return TTS_ERROR_INVALID_PARAMETER;
2130 if (TTS_STATE_CREATED != client->current_state) {
2131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2132 return TTS_ERROR_INVALID_STATE;
2135 client->default_voice_changed_cb = callback;
2136 client->default_voice_changed_user_data = user_data;
2138 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2143 int tts_unset_default_voice_changed_cb(tts_h tts)
2145 if (0 != __tts_get_feature_enabled()) {
2146 return TTS_ERROR_NOT_SUPPORTED;
2150 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2151 return TTS_ERROR_INVALID_PARAMETER;
2154 tts_client_s* client = tts_client_get(tts);
2156 if (NULL == client) {
2157 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2158 return TTS_ERROR_INVALID_PARAMETER;
2161 if (TTS_STATE_CREATED != client->current_state) {
2162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2163 return TTS_ERROR_INVALID_STATE;
2166 client->default_voice_changed_cb = NULL;
2167 client->default_voice_changed_user_data = NULL;
2169 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2174 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2176 if (0 != __tts_get_feature_enabled()) {
2177 return TTS_ERROR_NOT_SUPPORTED;
2180 if (NULL == tts || NULL == callback) {
2181 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2182 return TTS_ERROR_INVALID_PARAMETER;
2185 tts_client_s* client = tts_client_get(tts);
2187 if (NULL == client) {
2188 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2189 return TTS_ERROR_INVALID_PARAMETER;
2192 if (TTS_STATE_CREATED != client->current_state) {
2193 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2194 return TTS_ERROR_INVALID_STATE;
2197 client->engine_changed_cb = callback;
2198 client->engine_changed_user_data = user_data;
2200 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2205 int tts_unset_engine_changed_cb(tts_h tts)
2207 if (0 != __tts_get_feature_enabled()) {
2208 return TTS_ERROR_NOT_SUPPORTED;
2212 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2213 return TTS_ERROR_INVALID_PARAMETER;
2216 tts_client_s* client = tts_client_get(tts);
2218 if (NULL == client) {
2219 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2220 return TTS_ERROR_INVALID_PARAMETER;
2223 if (TTS_STATE_CREATED != client->current_state) {
2224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2225 return TTS_ERROR_INVALID_STATE;
2228 client->engine_changed_cb = NULL;
2229 client->engine_changed_user_data = NULL;
2231 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");