2 * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
18 #include <sys/types.h>
20 #include <system_info.h>
24 #include "tts_client.h"
25 #include "tts_config_mgr.h"
30 static bool g_screen_reader;
32 static int g_feature_enabled = -1;
34 static bool g_err_callback_status = false;
36 /* Function definition */
37 static Eina_Bool __tts_notify_state_changed(void *data);
38 static Eina_Bool __tts_notify_error(void *data);
45 static int __tts_get_feature_enabled()
47 if (0 == g_feature_enabled) {
48 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
49 return TTS_ERROR_NOT_SUPPORTED;
50 } else if (-1 == g_feature_enabled) {
51 bool tts_supported = false;
52 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
53 if (false == tts_supported) {
54 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
55 g_feature_enabled = 0;
56 return TTS_ERROR_NOT_SUPPORTED;
59 g_feature_enabled = 1;
61 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
62 return TTS_ERROR_NOT_SUPPORTED;
69 static const char* __tts_get_error_code(tts_error_e err)
72 case TTS_ERROR_NONE: return "TTS_ERROR_NONE";
73 case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY";
74 case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR";
75 case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER";
76 case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK";
77 case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT";
78 case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED";
79 case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED";
80 case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE";
81 case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE";
82 case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND";
83 case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED";
84 case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
86 return "Invalid error code";
91 static int __tts_convert_config_error_code(tts_config_error_e code)
93 if (code == TTS_CONFIG_ERROR_NONE) return TTS_ERROR_NONE;
94 if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY) return TTS_ERROR_OUT_OF_MEMORY;
95 if (code == TTS_CONFIG_ERROR_IO_ERROR) return TTS_ERROR_IO_ERROR;
96 if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER) return TTS_ERROR_INVALID_PARAMETER;
97 if (code == TTS_CONFIG_ERROR_INVALID_STATE) return TTS_ERROR_INVALID_STATE;
98 if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE;
99 if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND;
100 if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED;
101 if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_OPERATION_FAILED;
106 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
108 SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
109 before_lang, before_voice_type, language, voice_type);
111 GList* client_list = NULL;
112 client_list = tts_client_get_client_list();
115 tts_client_s *data = NULL;
117 if (g_list_length(client_list) > 0) {
118 /* Get a first item */
119 iter = g_list_first(client_list);
121 while (NULL != iter) {
123 if (NULL != data->default_voice_changed_cb) {
124 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
125 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
126 language, voice_type, data->default_voice_changed_user_data);
130 iter = g_list_next(iter);
137 int tts_create(tts_h* tts)
139 if (0 != __tts_get_feature_enabled()) {
140 return TTS_ERROR_NOT_SUPPORTED;
143 SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
147 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
148 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
149 SLOG(LOG_DEBUG, TAG_TTSC, " ");
150 return TTS_ERROR_INVALID_PARAMETER;
153 if (0 == tts_client_get_size()) {
154 if (0 != tts_dbus_open_connection()) {
155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
156 return TTS_ERROR_OPERATION_FAILED;
160 if (0 != tts_client_new(tts)) {
161 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
162 return TTS_ERROR_OUT_OF_MEMORY;
165 tts_client_s* client = tts_client_get(*tts);
166 if (NULL == client) {
167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
168 return TTS_ERROR_OPERATION_FAILED;
171 int ret = tts_config_mgr_initialize(client->uid);
173 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
174 tts_client_destroy(*tts);
175 return __tts_convert_config_error_code(ret);
178 ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
180 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
181 tts_client_destroy(*tts);
182 return __tts_convert_config_error_code(ret);
185 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
186 SLOG(LOG_DEBUG, TAG_TTSC, " ");
188 return TTS_ERROR_NONE;
191 int tts_destroy(tts_h tts)
193 if (0 != __tts_get_feature_enabled()) {
194 return TTS_ERROR_NOT_SUPPORTED;
197 SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
200 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
201 return TTS_ERROR_INVALID_PARAMETER;
204 tts_client_s* client = tts_client_get(tts);
207 if (NULL == client) {
208 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
209 return TTS_ERROR_INVALID_PARAMETER;
212 /* check used callback */
213 if (0 != tts_client_get_use_callback(client)) {
214 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
215 return TTS_ERROR_OPERATION_FAILED;
218 tts_config_mgr_finalize(client->uid);
224 switch (client->current_state) {
225 case TTS_STATE_PAUSED:
226 case TTS_STATE_PLAYING:
227 case TTS_STATE_READY:
228 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
230 ret = tts_dbus_request_finalize(client->uid);
232 if (TTS_ERROR_TIMED_OUT != ret) {
233 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
236 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
239 if (TTS_RETRY_COUNT == count) {
240 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
247 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
250 client->before_state = client->current_state;
251 client->current_state = TTS_STATE_CREATED;
253 case TTS_STATE_CREATED:
254 if (NULL != client->conn_timer) {
255 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
256 ecore_timer_del(client->conn_timer);
257 client->conn_timer = NULL;
260 tts_client_destroy(tts);
267 if (0 == tts_client_get_size()) {
268 if (0 != tts_dbus_close_connection()) {
269 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
275 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
276 SLOG(LOG_DEBUG, TAG_TTSC, " ");
278 return TTS_ERROR_NONE;
281 void __tts_screen_reader_changed_cb(bool value)
283 g_screen_reader = value;
286 int tts_set_mode(tts_h tts, tts_mode_e mode)
288 if (0 != __tts_get_feature_enabled()) {
289 return TTS_ERROR_NOT_SUPPORTED;
292 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
294 tts_client_s* client = tts_client_get(tts);
297 if (NULL == client) {
298 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
299 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
300 SLOG(LOG_DEBUG, TAG_TTSC, " ");
301 return TTS_ERROR_INVALID_PARAMETER;
305 if (client->current_state != TTS_STATE_CREATED) {
306 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
307 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
308 SLOG(LOG_DEBUG, TAG_TTSC, " ");
309 return TTS_ERROR_INVALID_STATE;
312 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
315 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
316 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
317 SLOG(LOG_DEBUG, TAG_TTSC, " ");
318 return TTS_ERROR_INVALID_PARAMETER;
321 if (TTS_MODE_SCREEN_READER == mode) {
324 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
326 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
327 return TTS_ERROR_OPERATION_FAILED;
329 g_screen_reader = (bool)screen_reader;
330 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
332 tts_config_unset_screen_reader_callback(client->uid);
335 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
336 SLOG(LOG_DEBUG, TAG_TTSC, " ");
338 return TTS_ERROR_NONE;
341 int tts_get_mode(tts_h tts, tts_mode_e* mode)
343 if (0 != __tts_get_feature_enabled()) {
344 return TTS_ERROR_NOT_SUPPORTED;
347 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
349 tts_client_s* client = tts_client_get(tts);
352 if (NULL == client) {
353 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
354 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
355 SLOG(LOG_DEBUG, TAG_TTSC, " ");
356 return TTS_ERROR_INVALID_PARAMETER;
360 if (client->current_state != TTS_STATE_CREATED) {
361 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
364 return TTS_ERROR_INVALID_STATE;
368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
369 return TTS_ERROR_INVALID_PARAMETER;
372 *mode = client->mode;
374 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
375 SLOG(LOG_DEBUG, TAG_TTSC, " ");
377 return TTS_ERROR_NONE;
380 int tts_set_credential(tts_h tts, const char* credential)
382 if(0 != __tts_get_feature_enabled()) {
383 return TTS_ERROR_NOT_SUPPORTED;
386 if (NULL == tts || NULL == credential) {
387 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
388 return TTS_ERROR_INVALID_PARAMETER;
391 tts_client_s* client = tts_client_get(tts);
393 if (NULL == client) {
394 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
395 return TTS_ERROR_INVALID_PARAMETER;
398 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
399 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
400 return TTS_ERROR_INVALID_STATE;
403 client->credential = strdup(credential);
405 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
406 SLOG(LOG_DEBUG, TAG_TTSC, " ");
408 return TTS_ERROR_NONE;
411 static Eina_Bool __tts_connect_daemon(void *data)
413 tts_h tts = (tts_h)data;
414 tts_client_s* client = tts_client_get(tts);
417 if (NULL == client) {
418 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
423 if (0 != tts_dbus_request_hello(client->uid)) {
427 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
429 /* do request initialize */
431 bool credential_needed = false;
433 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
435 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
436 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
438 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
441 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
442 client->conn_timer = NULL;
445 } else if (TTS_ERROR_NONE != ret) {
446 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
450 /* success to connect tts-daemon */
451 client->credential_needed = credential_needed;
452 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
455 client->conn_timer = NULL;
457 client = tts_client_get(tts);
459 if (NULL == client) {
460 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
464 client->before_state = client->current_state;
465 client->current_state = TTS_STATE_READY;
467 if (NULL != client->state_changed_cb) {
468 tts_client_use_callback(client);
469 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
470 tts_client_not_use_callback(client);
472 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
475 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
476 SLOG(LOG_DEBUG, TAG_TTSC, " ");
481 int tts_prepare(tts_h tts)
483 if (0 != __tts_get_feature_enabled()) {
484 return TTS_ERROR_NOT_SUPPORTED;
487 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
489 tts_client_s* client = tts_client_get(tts);
492 if (NULL == client) {
493 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
494 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
495 SLOG(LOG_DEBUG, TAG_TTSC, " ");
496 return TTS_ERROR_INVALID_PARAMETER;
500 if (client->current_state != TTS_STATE_CREATED) {
501 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
502 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
503 SLOG(LOG_DEBUG, TAG_TTSC, " ");
504 return TTS_ERROR_INVALID_STATE;
507 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
509 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
510 SLOG(LOG_DEBUG, TAG_TTSC, " ");
512 return TTS_ERROR_NONE;
515 int tts_unprepare(tts_h tts)
517 if (0 != __tts_get_feature_enabled()) {
518 return TTS_ERROR_NOT_SUPPORTED;
521 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
523 tts_client_s* client = tts_client_get(tts);
526 if (NULL == client) {
527 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
528 return TTS_ERROR_INVALID_PARAMETER;
532 if (client->current_state != TTS_STATE_READY) {
533 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
534 return TTS_ERROR_INVALID_STATE;
539 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
541 ret = tts_dbus_request_finalize(client->uid);
543 if (TTS_ERROR_TIMED_OUT != ret) {
544 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
547 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
550 if (TTS_RETRY_COUNT == count) {
551 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
558 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
561 client->before_state = client->current_state;
562 client->current_state = TTS_STATE_CREATED;
564 if (NULL != client->state_changed_cb) {
565 tts_client_use_callback(client);
566 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
567 tts_client_not_use_callback(client);
568 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
571 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
572 SLOG(LOG_DEBUG, TAG_TTSC, " ");
574 return TTS_ERROR_NONE;
577 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
579 tts_h tts = (tts_h)user_data;
581 tts_client_s* client = tts_client_get(tts);
582 if (NULL == client) {
583 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
587 /* call callback function */
588 if (NULL != client->supported_voice_cb) {
589 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
591 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
597 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
599 if (0 != __tts_get_feature_enabled()) {
600 return TTS_ERROR_NOT_SUPPORTED;
603 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
605 if (NULL == tts || NULL == callback) {
606 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
607 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
608 SLOG(LOG_DEBUG, TAG_TTSC, " ");
609 return TTS_ERROR_INVALID_PARAMETER;
612 tts_client_s* client = tts_client_get(tts);
615 if (NULL == client) {
616 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
617 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
618 SLOG(LOG_DEBUG, TAG_TTSC, " ");
619 return TTS_ERROR_INVALID_PARAMETER;
623 char* current_engine = NULL;
624 ret = tts_config_mgr_get_engine(¤t_engine);
626 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
627 return __tts_convert_config_error_code(ret);
630 client->supported_voice_cb = callback;
631 client->supported_voice_user_data = user_data;
633 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
635 if (NULL != current_engine)
636 free(current_engine);
638 client->supported_voice_cb = NULL;
639 client->supported_voice_user_data = NULL;
642 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
643 ret = TTS_ERROR_OPERATION_FAILED;
646 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
647 SLOG(LOG_DEBUG, TAG_TTSC, " ");
652 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
654 if (0 != __tts_get_feature_enabled()) {
655 return TTS_ERROR_NOT_SUPPORTED;
658 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
661 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
662 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
663 SLOG(LOG_DEBUG, TAG_TTSC, " ");
664 return TTS_ERROR_INVALID_PARAMETER;
667 tts_client_s* client = tts_client_get(tts);
669 if (NULL == client) {
670 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
671 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
672 SLOG(LOG_DEBUG, TAG_TTSC, " ");
673 return TTS_ERROR_INVALID_PARAMETER;
676 /* Request call remote method */
678 ret = tts_config_mgr_get_voice(lang, vctype);
680 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
681 return __tts_convert_config_error_code(ret);
683 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
686 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
687 SLOG(LOG_DEBUG, TAG_TTSC, " ");
692 int tts_get_max_text_size(tts_h tts, unsigned int* size)
694 if (0 != __tts_get_feature_enabled()) {
695 return TTS_ERROR_NOT_SUPPORTED;
698 if (NULL == tts || NULL == size) {
699 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
700 return TTS_ERROR_INVALID_PARAMETER;
703 tts_client_s* client = tts_client_get(tts);
705 if (NULL == client) {
706 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
707 return TTS_ERROR_INVALID_PARAMETER;
710 if (TTS_STATE_READY != client->current_state) {
711 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
712 return TTS_ERROR_INVALID_STATE;
715 *size = TTS_MAX_TEXT_SIZE;
717 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
718 return TTS_ERROR_NONE;
721 int tts_get_state(tts_h tts, tts_state_e* state)
723 if (0 != __tts_get_feature_enabled()) {
724 return TTS_ERROR_NOT_SUPPORTED;
727 if (NULL == tts || NULL == state) {
728 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
729 return TTS_ERROR_INVALID_PARAMETER;
732 tts_client_s* client = tts_client_get(tts);
734 if (NULL == client) {
735 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
736 return TTS_ERROR_INVALID_PARAMETER;
739 *state = client->current_state;
742 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
743 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
744 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
745 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
746 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
749 return TTS_ERROR_NONE;
752 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
754 if (0 != __tts_get_feature_enabled()) {
755 return TTS_ERROR_NOT_SUPPORTED;
758 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
759 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
760 return TTS_ERROR_INVALID_PARAMETER;
763 tts_client_s* client = tts_client_get(tts);
765 if (NULL == client) {
766 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
767 return TTS_ERROR_INVALID_PARAMETER;
770 *min = TTS_SPEED_MIN;
771 *normal = TTS_SPEED_NORMAL;
772 *max = TTS_SPEED_MAX;
774 return TTS_ERROR_NONE;
777 int tts_get_error_message(tts_h tts, char** err_msg)
779 if(0 != __tts_get_feature_enabled()) {
780 return TTS_ERROR_NOT_SUPPORTED;
783 if (NULL == tts || NULL == err_msg) {
784 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
785 return TTS_ERROR_INVALID_PARAMETER;
788 tts_client_s* client = tts_client_get(tts);
790 if (NULL == client) {
791 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
792 return TTS_ERROR_INVALID_PARAMETER;
795 if (NULL != client->err_msg) {
796 *err_msg = strdup(client->err_msg);
797 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
799 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
802 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
803 SLOG(LOG_DEBUG, TAG_TTSC, " ");
805 return TTS_ERROR_NONE;
808 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
810 if (0 != __tts_get_feature_enabled()) {
811 return TTS_ERROR_NOT_SUPPORTED;
815 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
816 return TTS_ERROR_INVALID_PARAMETER;
819 if (voice_type < 0) {
820 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
821 return TTS_ERROR_INVALID_PARAMETER;
824 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
826 if (NULL == tts || NULL == utt_id) {
827 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
828 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
829 SLOG(LOG_DEBUG, TAG_TTSC, " ");
830 return TTS_ERROR_INVALID_PARAMETER;
833 tts_client_s* client = tts_client_get(tts);
835 if (NULL == client) {
836 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
837 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
838 SLOG(LOG_DEBUG, TAG_TTSC, " ");
839 return TTS_ERROR_INVALID_PARAMETER;
842 if (TTS_STATE_CREATED == client->current_state) {
843 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
844 return TTS_ERROR_INVALID_STATE;
847 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
848 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
849 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
850 SLOG(LOG_DEBUG, TAG_TTSC, " ");
851 return TTS_ERROR_INVALID_PARAMETER;
854 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
855 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
856 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
857 SLOG(LOG_DEBUG, TAG_TTSC, " ");
858 return TTS_ERROR_INVALID_PARAMETER;
861 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
862 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
863 return TTS_ERROR_INVALID_STATE;
866 if (true == client->credential_needed && NULL == client->credential) {
867 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
868 return TTS_ERROR_PERMISSION_DENIED;
871 /* check valid utf8 */
873 ict = iconv_open("utf-8", "");
874 if ((iconv_t)-1 == ict) {
875 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
876 return TTS_ERROR_OPERATION_FAILED;
879 size_t len = strlen(text);
881 char in_buf[TTS_MAX_TEXT_SIZE];
882 char *out_tmp = NULL;
883 char out_buf[TTS_MAX_TEXT_SIZE];
884 size_t len_tmp = sizeof(out_buf);
886 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
887 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
890 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
894 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
895 if ((size_t)-1 == st) {
896 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
898 return TTS_ERROR_INVALID_PARAMETER;
901 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
903 /* change default language value */
906 if (NULL == language)
907 temp = strdup("default");
909 temp = strdup(language);
911 client->current_utt_id++;
912 if (client->current_utt_id == 10000) {
913 client->current_utt_id = 1;
920 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
922 if (TTS_ERROR_TIMED_OUT != ret) {
923 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
926 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
929 if (TTS_RETRY_COUNT == count) {
930 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
935 *utt_id = client->current_utt_id;
939 if (NULL != temp) free(temp);
941 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
942 SLOG(LOG_DEBUG, TAG_TTSC, " ");
947 static void __tts_play_async(void *data)
949 tts_h tts = (tts_h)data;
950 tts_client_s* client = tts_client_get(tts);
953 if (NULL == client) {
954 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
961 ret = tts_dbus_request_play(client->uid, client->credential);
963 if (TTS_ERROR_TIMED_OUT != ret) {
964 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
967 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
970 if (TTS_RETRY_COUNT == count) {
971 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
979 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
981 client->reason = ret;
984 ecore_timer_add(0, __tts_notify_error, client->tts);
988 client->before_state = client->current_state;
989 client->current_state = TTS_STATE_PLAYING;
991 if (NULL != client->state_changed_cb) {
992 tts_client_use_callback(client);
993 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
994 tts_client_not_use_callback(client);
995 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
998 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
999 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1004 int tts_play_async(tts_h tts)
1006 if (0 != __tts_get_feature_enabled()) {
1007 return TTS_ERROR_NOT_SUPPORTED;
1010 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1013 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle 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_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1029 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1030 return TTS_ERROR_INVALID_STATE;
1033 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1034 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1035 return TTS_ERROR_INVALID_STATE;
1038 if (true == client->credential_needed && NULL == client->credential) {
1039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1040 return TTS_ERROR_PERMISSION_DENIED;
1043 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1045 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1046 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1048 return TTS_ERROR_NONE;
1051 int tts_play(tts_h tts)
1053 if (0 != __tts_get_feature_enabled()) {
1054 return TTS_ERROR_NOT_SUPPORTED;
1057 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1061 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1062 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1063 return TTS_ERROR_INVALID_PARAMETER;
1066 tts_client_s* client = tts_client_get(tts);
1068 if (NULL == client) {
1069 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1070 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1071 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1072 return TTS_ERROR_INVALID_PARAMETER;
1075 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1076 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1077 return TTS_ERROR_INVALID_STATE;
1080 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1081 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1082 return TTS_ERROR_INVALID_STATE;
1085 if (true == client->credential_needed && NULL == client->credential) {
1086 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1087 return TTS_ERROR_PERMISSION_DENIED;
1093 ret = tts_dbus_request_play(client->uid, client->credential);
1095 if (TTS_ERROR_TIMED_OUT != ret) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1099 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1102 if (TTS_RETRY_COUNT == count) {
1103 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1110 client->before_state = client->current_state;
1111 client->current_state = TTS_STATE_PLAYING;
1113 if (NULL != client->state_changed_cb) {
1114 tts_client_use_callback(client);
1115 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1116 tts_client_not_use_callback(client);
1117 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1120 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1121 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1123 return TTS_ERROR_NONE;
1126 static void __tts_stop_async(void *data)
1128 tts_h tts = (tts_h)data;
1129 tts_client_s* client = tts_client_get(tts);
1132 if (NULL == client) {
1133 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1140 ret = tts_dbus_request_stop(client->uid);
1142 if (TTS_ERROR_TIMED_OUT != ret) {
1143 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1146 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1149 if (TTS_RETRY_COUNT == count) {
1150 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1158 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1160 client->reason = ret;
1161 client->utt_id = -1;
1163 ecore_timer_add(0, __tts_notify_error, client->tts);
1167 client->before_state = client->current_state;
1168 client->current_state = TTS_STATE_READY;
1170 if (NULL != client->state_changed_cb) {
1171 tts_client_use_callback(client);
1172 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1173 tts_client_not_use_callback(client);
1174 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1177 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1178 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1183 int tts_stop_aync(tts_h tts)
1185 if (0 != __tts_get_feature_enabled()) {
1186 return TTS_ERROR_NOT_SUPPORTED;
1189 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1192 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1193 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1194 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1195 return TTS_ERROR_INVALID_PARAMETER;
1198 tts_client_s* client = tts_client_get(tts);
1200 if (NULL == client) {
1201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1202 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1203 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1204 return TTS_ERROR_INVALID_PARAMETER;
1207 if (TTS_STATE_CREATED == client->current_state) {
1208 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1209 return TTS_ERROR_INVALID_STATE;
1212 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1213 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1214 return TTS_ERROR_INVALID_STATE;
1217 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1219 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1220 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1222 return TTS_ERROR_NONE;
1225 int tts_stop(tts_h tts)
1227 if (0 != __tts_get_feature_enabled()) {
1228 return TTS_ERROR_NOT_SUPPORTED;
1231 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1234 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1235 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1236 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1237 return TTS_ERROR_INVALID_PARAMETER;
1240 tts_client_s* client = tts_client_get(tts);
1242 if (NULL == client) {
1243 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1244 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1245 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1246 return TTS_ERROR_INVALID_PARAMETER;
1249 if (TTS_STATE_CREATED == client->current_state) {
1250 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1251 return TTS_ERROR_INVALID_STATE;
1254 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1255 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1256 return TTS_ERROR_INVALID_STATE;
1262 ret = tts_dbus_request_stop(client->uid);
1264 if (TTS_ERROR_TIMED_OUT != ret) {
1265 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1268 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1271 if (TTS_RETRY_COUNT == count) {
1272 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1279 client->before_state = client->current_state;
1280 client->current_state = TTS_STATE_READY;
1282 if (NULL != client->state_changed_cb) {
1283 tts_client_use_callback(client);
1284 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1285 tts_client_not_use_callback(client);
1286 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1289 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1290 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1292 return TTS_ERROR_NONE;
1295 static void __tts_pause_async(void *data)
1297 tts_h tts = (tts_h)data;
1298 tts_client_s* client = tts_client_get(tts);
1301 if (NULL == client) {
1302 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1309 ret = tts_dbus_request_pause(client->uid);
1311 if (TTS_ERROR_TIMED_OUT != ret) {
1312 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1315 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1318 if (TTS_RETRY_COUNT == count) {
1319 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1327 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1329 client->reason = ret;
1330 client->utt_id = -1;
1332 ecore_timer_add(0, __tts_notify_error, client->tts);
1336 client->before_state = client->current_state;
1337 client->current_state = TTS_STATE_PAUSED;
1339 if (NULL != client->state_changed_cb) {
1340 tts_client_use_callback(client);
1341 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1342 tts_client_not_use_callback(client);
1343 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1346 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1347 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1352 int tts_pause_async(tts_h tts)
1354 if (0 != __tts_get_feature_enabled()) {
1355 return TTS_ERROR_NOT_SUPPORTED;
1358 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1361 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1364 return TTS_ERROR_INVALID_PARAMETER;
1367 tts_client_s* client = tts_client_get(tts);
1369 if (NULL == client) {
1370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1371 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1372 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1373 return TTS_ERROR_INVALID_PARAMETER;
1376 if (TTS_STATE_PLAYING != client->current_state) {
1377 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1378 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1379 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1380 return TTS_ERROR_INVALID_STATE;
1383 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1384 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1385 return TTS_ERROR_INVALID_STATE;
1388 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1390 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1391 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1393 return TTS_ERROR_NONE;
1396 int tts_pause(tts_h tts)
1398 if (0 != __tts_get_feature_enabled()) {
1399 return TTS_ERROR_NOT_SUPPORTED;
1402 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1405 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1406 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1407 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1408 return TTS_ERROR_INVALID_PARAMETER;
1411 tts_client_s* client = tts_client_get(tts);
1413 if (NULL == client) {
1414 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1415 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1416 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1417 return TTS_ERROR_INVALID_PARAMETER;
1420 if (TTS_STATE_PLAYING != client->current_state) {
1421 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1422 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1423 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1424 return TTS_ERROR_INVALID_STATE;
1427 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1428 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1429 return TTS_ERROR_INVALID_STATE;
1435 ret = tts_dbus_request_pause(client->uid);
1437 if (TTS_ERROR_TIMED_OUT != ret) {
1438 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1441 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1444 if (TTS_RETRY_COUNT == count) {
1445 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1452 client->before_state = client->current_state;
1453 client->current_state = TTS_STATE_PAUSED;
1455 if (NULL != client->state_changed_cb) {
1456 tts_client_use_callback(client);
1457 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1458 tts_client_not_use_callback(client);
1459 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1462 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1463 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1465 return TTS_ERROR_NONE;
1468 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1470 if (0 != __tts_get_feature_enabled()) {
1471 return TTS_ERROR_NOT_SUPPORTED;
1474 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1477 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1478 return TTS_ERROR_INVALID_PARAMETER;
1481 if (NULL == key || NULL == data) {
1482 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1483 return TTS_ERROR_INVALID_PARAMETER;
1486 tts_client_s* client = tts_client_get(tts);
1488 if (NULL == client) {
1489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1490 return TTS_ERROR_INVALID_PARAMETER;
1493 if (TTS_STATE_READY != client->current_state) {
1494 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1495 return TTS_ERROR_INVALID_STATE;
1498 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1499 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1500 return TTS_ERROR_INVALID_STATE;
1506 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1508 if (TTS_ERROR_TIMED_OUT != ret) {
1509 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1512 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1515 if (TTS_RETRY_COUNT == count) {
1516 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1523 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1524 SLOG(LOG_DEBUG, TAG_TTSC, "");
1529 int tts_get_private_data(tts_h tts, const char* key, char** data)
1531 if (0 != __tts_get_feature_enabled()) {
1532 return TTS_ERROR_NOT_SUPPORTED;
1535 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1538 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1539 return TTS_ERROR_INVALID_PARAMETER;
1542 if (NULL == key || NULL == data) {
1543 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1544 return TTS_ERROR_INVALID_PARAMETER;
1547 tts_client_s* client = tts_client_get(tts);
1549 if (NULL == client) {
1550 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1551 return TTS_ERROR_INVALID_PARAMETER;
1554 if (TTS_STATE_READY != client->current_state) {
1555 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1556 return TTS_ERROR_INVALID_STATE;
1559 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1560 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1561 return TTS_ERROR_INVALID_STATE;
1567 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1569 if (TTS_ERROR_TIMED_OUT != ret) {
1570 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1573 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1576 if (TTS_RETRY_COUNT == count) {
1577 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1584 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1585 SLOG(LOG_DEBUG, TAG_TTSC, "");
1590 static Eina_Bool __tts_notify_error(void *data)
1592 tts_h tts = (tts_h)data;
1594 tts_client_s* client = tts_client_get(tts);
1597 if (NULL == client) {
1598 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1602 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1604 if (NULL != client->error_cb) {
1605 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1606 tts_client_use_callback(client);
1607 g_err_callback_status = true;
1608 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1609 g_err_callback_status = false;
1610 tts_client_not_use_callback(client);
1612 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1618 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1620 tts_client_s* client = tts_client_get_by_uid(uid);
1622 if (NULL == client) {
1623 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1624 return TTS_ERROR_INVALID_PARAMETER;
1627 client->utt_id = utt_id;
1628 client->reason = reason;
1629 if (NULL != client->err_msg) {
1630 free(client->err_msg);
1631 client->err_msg = NULL;
1633 client->err_msg = strdup(err_msg);
1635 /* call callback function */
1636 if (NULL != client->error_cb) {
1637 ecore_timer_add(0, __tts_notify_error, client->tts);
1639 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1645 static Eina_Bool __tts_notify_state_changed(void *data)
1647 tts_h tts = (tts_h)data;
1649 tts_client_s* client = tts_client_get(tts);
1652 if (NULL == client) {
1653 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1657 if (NULL != client->state_changed_cb) {
1658 tts_client_use_callback(client);
1659 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1660 tts_client_not_use_callback(client);
1661 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1663 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1669 int __tts_cb_set_state(int uid, int state)
1671 tts_client_s* client = tts_client_get_by_uid(uid);
1672 if (NULL == client) {
1673 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1677 tts_state_e state_from_daemon = (tts_state_e)state;
1679 if (client->current_state == state_from_daemon) {
1680 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1684 if (NULL != client->state_changed_cb) {
1685 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1687 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1690 client->before_state = client->current_state;
1691 client->current_state = state_from_daemon;
1696 int __tts_cb_utt_started(int uid, int utt_id)
1698 tts_client_s* client = tts_client_get_by_uid(uid);
1700 if (NULL == client) {
1701 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1702 return TTS_ERROR_INVALID_PARAMETER;
1705 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1707 client->utt_id = utt_id;
1709 /* call callback function */
1710 if (NULL != client->utt_started_cb) {
1711 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1712 tts_client_use_callback(client);
1713 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1714 tts_client_not_use_callback(client);
1716 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1722 int __tts_cb_utt_completed(int uid, int utt_id)
1724 tts_client_s* client = tts_client_get_by_uid(uid);
1726 if (NULL == client) {
1727 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1728 return TTS_ERROR_INVALID_PARAMETER;
1731 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1733 client->utt_id = utt_id;
1735 /* call callback function */
1736 if (NULL != client->utt_completeted_cb) {
1737 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1738 tts_client_use_callback(client);
1739 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1740 tts_client_not_use_callback(client);
1742 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1748 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1750 if (0 != __tts_get_feature_enabled()) {
1751 return TTS_ERROR_NOT_SUPPORTED;
1754 if (NULL == tts || NULL == callback) {
1755 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1756 return TTS_ERROR_INVALID_PARAMETER;
1759 tts_client_s* client = tts_client_get(tts);
1761 if (NULL == client) {
1762 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1763 return TTS_ERROR_INVALID_PARAMETER;
1766 if (TTS_STATE_CREATED != client->current_state) {
1767 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1768 return TTS_ERROR_INVALID_STATE;
1771 client->state_changed_cb = callback;
1772 client->state_changed_user_data = user_data;
1774 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1779 int tts_unset_state_changed_cb(tts_h tts)
1781 if (0 != __tts_get_feature_enabled()) {
1782 return TTS_ERROR_NOT_SUPPORTED;
1786 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1787 return TTS_ERROR_INVALID_PARAMETER;
1790 tts_client_s* client = tts_client_get(tts);
1792 if (NULL == client) {
1793 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1794 return TTS_ERROR_INVALID_PARAMETER;
1797 if (TTS_STATE_CREATED != client->current_state) {
1798 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1799 return TTS_ERROR_INVALID_STATE;
1802 client->state_changed_cb = NULL;
1803 client->state_changed_user_data = NULL;
1805 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1810 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1812 if (0 != __tts_get_feature_enabled()) {
1813 return TTS_ERROR_NOT_SUPPORTED;
1816 if (NULL == tts || NULL == callback) {
1817 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1818 return TTS_ERROR_INVALID_PARAMETER;
1821 tts_client_s* client = tts_client_get(tts);
1823 if (NULL == client) {
1824 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1825 return TTS_ERROR_INVALID_PARAMETER;
1828 if (TTS_STATE_CREATED != client->current_state) {
1829 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1830 return TTS_ERROR_INVALID_STATE;
1833 client->utt_started_cb = callback;
1834 client->utt_started_user_data = user_data;
1836 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1841 int tts_unset_utterance_started_cb(tts_h tts)
1843 if (0 != __tts_get_feature_enabled()) {
1844 return TTS_ERROR_NOT_SUPPORTED;
1848 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1849 return TTS_ERROR_INVALID_PARAMETER;
1852 tts_client_s* client = tts_client_get(tts);
1854 if (NULL == client) {
1855 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1856 return TTS_ERROR_INVALID_PARAMETER;
1859 if (TTS_STATE_CREATED != client->current_state) {
1860 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1861 return TTS_ERROR_INVALID_STATE;
1864 client->utt_started_cb = NULL;
1865 client->utt_started_user_data = NULL;
1867 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1872 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1874 if (0 != __tts_get_feature_enabled()) {
1875 return TTS_ERROR_NOT_SUPPORTED;
1878 if (NULL == tts || NULL == callback) {
1879 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1880 return TTS_ERROR_INVALID_PARAMETER;
1883 tts_client_s* client = tts_client_get(tts);
1885 if (NULL == client) {
1886 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1887 return TTS_ERROR_INVALID_PARAMETER;
1890 if (TTS_STATE_CREATED != client->current_state) {
1891 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1892 return TTS_ERROR_INVALID_STATE;
1895 client->utt_completeted_cb = callback;
1896 client->utt_completed_user_data = user_data;
1898 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1903 int tts_unset_utterance_completed_cb(tts_h tts)
1905 if (0 != __tts_get_feature_enabled()) {
1906 return TTS_ERROR_NOT_SUPPORTED;
1910 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1911 return TTS_ERROR_INVALID_PARAMETER;
1914 tts_client_s* client = tts_client_get(tts);
1916 if (NULL == client) {
1917 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1918 return TTS_ERROR_INVALID_PARAMETER;
1921 if (TTS_STATE_CREATED != client->current_state) {
1922 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1923 return TTS_ERROR_INVALID_STATE;
1926 client->utt_completeted_cb = NULL;
1927 client->utt_completed_user_data = NULL;
1929 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1933 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1935 if (0 != __tts_get_feature_enabled()) {
1936 return TTS_ERROR_NOT_SUPPORTED;
1939 if (NULL == tts || NULL == callback) {
1940 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1941 return TTS_ERROR_INVALID_PARAMETER;
1944 tts_client_s* client = tts_client_get(tts);
1946 if (NULL == client) {
1947 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1948 return TTS_ERROR_INVALID_PARAMETER;
1951 if (TTS_STATE_CREATED != client->current_state) {
1952 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1953 return TTS_ERROR_INVALID_STATE;
1956 client->error_cb = callback;
1957 client->error_user_data = user_data;
1959 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1964 int tts_unset_error_cb(tts_h tts)
1966 if (0 != __tts_get_feature_enabled()) {
1967 return TTS_ERROR_NOT_SUPPORTED;
1971 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1972 return TTS_ERROR_INVALID_PARAMETER;
1975 tts_client_s* client = tts_client_get(tts);
1977 if (NULL == client) {
1978 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1979 return TTS_ERROR_INVALID_PARAMETER;
1982 if (TTS_STATE_CREATED != client->current_state) {
1983 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1984 return TTS_ERROR_INVALID_STATE;
1987 client->error_cb = NULL;
1988 client->error_user_data = NULL;
1990 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1995 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1997 if (0 != __tts_get_feature_enabled()) {
1998 return TTS_ERROR_NOT_SUPPORTED;
2001 if (NULL == tts || NULL == callback) {
2002 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2003 return TTS_ERROR_INVALID_PARAMETER;
2006 tts_client_s* client = tts_client_get(tts);
2008 if (NULL == client) {
2009 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2010 return TTS_ERROR_INVALID_PARAMETER;
2013 if (TTS_STATE_CREATED != client->current_state) {
2014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2015 return TTS_ERROR_INVALID_STATE;
2018 client->default_voice_changed_cb = callback;
2019 client->default_voice_changed_user_data = user_data;
2021 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2026 int tts_unset_default_voice_changed_cb(tts_h tts)
2028 if (0 != __tts_get_feature_enabled()) {
2029 return TTS_ERROR_NOT_SUPPORTED;
2033 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2034 return TTS_ERROR_INVALID_PARAMETER;
2037 tts_client_s* client = tts_client_get(tts);
2039 if (NULL == client) {
2040 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2041 return TTS_ERROR_INVALID_PARAMETER;
2044 if (TTS_STATE_CREATED != client->current_state) {
2045 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2046 return TTS_ERROR_INVALID_STATE;
2049 client->default_voice_changed_cb = NULL;
2050 client->default_voice_changed_user_data = NULL;
2052 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");