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;
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->internal = true;
473 if (NULL != credential) {
474 key = strdup("EnableServerTTS");
475 client->credential = strdup(credential);
476 if (NULL == client->credential) {
477 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
478 return TTS_ERROR_OUT_OF_MEMORY;
481 key = strdup("DisableServerTTS");
485 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
486 return TTS_ERROR_OUT_OF_MEMORY;
491 int ret = app_manager_get_app_id(pid, &appid);
493 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
496 return TTS_ERROR_OPERATION_FAILED;
499 ret = tts_set_private_data(tts, key, appid);
501 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
512 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
513 SLOG(LOG_DEBUG, TAG_TTSC, " ");
515 return TTS_ERROR_NONE;
518 static Eina_Bool __tts_connect_daemon(void *data)
520 tts_h tts = (tts_h)data;
521 tts_client_s* client = tts_client_get(tts);
524 if (NULL == client) {
525 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
530 if (0 != tts_dbus_request_hello(client->uid)) {
534 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
536 /* do request initialize */
538 bool credential_needed = false;
540 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
542 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
543 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
545 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
548 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
549 client->conn_timer = NULL;
552 } else if (TTS_ERROR_NONE != ret) {
553 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
557 /* success to connect tts-daemon */
558 client->credential_needed = credential_needed;
559 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
562 client->conn_timer = NULL;
564 client = tts_client_get(tts);
566 if (NULL == client) {
567 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
571 client->before_state = client->current_state;
572 client->current_state = TTS_STATE_READY;
574 if (NULL != client->state_changed_cb) {
575 tts_client_use_callback(client);
576 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
577 tts_client_not_use_callback(client);
579 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
582 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
583 SLOG(LOG_DEBUG, TAG_TTSC, " ");
588 int tts_prepare(tts_h tts)
590 if (0 != __tts_get_feature_enabled()) {
591 return TTS_ERROR_NOT_SUPPORTED;
594 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
596 tts_client_s* client = tts_client_get(tts);
599 if (NULL == client) {
600 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
601 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
602 SLOG(LOG_DEBUG, TAG_TTSC, " ");
603 return TTS_ERROR_INVALID_PARAMETER;
607 if (client->current_state != TTS_STATE_CREATED) {
608 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
609 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
610 SLOG(LOG_DEBUG, TAG_TTSC, " ");
611 return TTS_ERROR_INVALID_STATE;
614 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
616 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
617 SLOG(LOG_DEBUG, TAG_TTSC, " ");
619 return TTS_ERROR_NONE;
622 int tts_unprepare(tts_h tts)
624 if (0 != __tts_get_feature_enabled()) {
625 return TTS_ERROR_NOT_SUPPORTED;
628 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
630 tts_client_s* client = tts_client_get(tts);
633 if (NULL == client) {
634 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
635 return TTS_ERROR_INVALID_PARAMETER;
639 if (client->current_state != TTS_STATE_READY) {
640 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
641 return TTS_ERROR_INVALID_STATE;
646 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
648 ret = tts_dbus_request_finalize(client->uid);
650 if (TTS_ERROR_TIMED_OUT != ret) {
651 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
654 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
657 if (TTS_RETRY_COUNT == count) {
658 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
665 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
668 client->before_state = client->current_state;
669 client->current_state = TTS_STATE_CREATED;
671 if (NULL != client->state_changed_cb) {
672 tts_client_use_callback(client);
673 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
674 tts_client_not_use_callback(client);
675 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
678 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
679 SLOG(LOG_DEBUG, TAG_TTSC, " ");
681 return TTS_ERROR_NONE;
684 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
686 tts_h tts = (tts_h)user_data;
688 tts_client_s* client = tts_client_get(tts);
689 if (NULL == client) {
690 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
694 /* call callback function */
695 if (NULL != client->supported_voice_cb) {
696 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
698 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
704 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
706 if (0 != __tts_get_feature_enabled()) {
707 return TTS_ERROR_NOT_SUPPORTED;
710 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
712 if (NULL == tts || NULL == callback) {
713 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
714 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
715 SLOG(LOG_DEBUG, TAG_TTSC, " ");
716 return TTS_ERROR_INVALID_PARAMETER;
719 tts_client_s* client = tts_client_get(tts);
722 if (NULL == client) {
723 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
724 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
725 SLOG(LOG_DEBUG, TAG_TTSC, " ");
726 return TTS_ERROR_INVALID_PARAMETER;
730 char* current_engine = NULL;
731 ret = tts_config_mgr_get_engine(¤t_engine);
733 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
734 return __tts_convert_config_error_code(ret);
737 client->supported_voice_cb = callback;
738 client->supported_voice_user_data = user_data;
740 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
742 if (NULL != current_engine)
743 free(current_engine);
745 client->supported_voice_cb = NULL;
746 client->supported_voice_user_data = NULL;
749 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
750 ret = TTS_ERROR_OPERATION_FAILED;
753 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
754 SLOG(LOG_DEBUG, TAG_TTSC, " ");
759 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
761 if (0 != __tts_get_feature_enabled()) {
762 return TTS_ERROR_NOT_SUPPORTED;
765 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
768 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
769 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
770 SLOG(LOG_DEBUG, TAG_TTSC, " ");
771 return TTS_ERROR_INVALID_PARAMETER;
774 tts_client_s* client = tts_client_get(tts);
776 if (NULL == client) {
777 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
778 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
779 SLOG(LOG_DEBUG, TAG_TTSC, " ");
780 return TTS_ERROR_INVALID_PARAMETER;
783 /* Request call remote method */
785 ret = tts_config_mgr_get_voice(lang, vctype);
787 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
788 return __tts_convert_config_error_code(ret);
790 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
793 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
794 SLOG(LOG_DEBUG, TAG_TTSC, " ");
799 int tts_get_max_text_size(tts_h tts, unsigned int* size)
801 if (0 != __tts_get_feature_enabled()) {
802 return TTS_ERROR_NOT_SUPPORTED;
805 if (NULL == tts || NULL == size) {
806 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
807 return TTS_ERROR_INVALID_PARAMETER;
810 tts_client_s* client = tts_client_get(tts);
812 if (NULL == client) {
813 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
814 return TTS_ERROR_INVALID_PARAMETER;
817 if (TTS_STATE_READY != client->current_state) {
818 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
819 return TTS_ERROR_INVALID_STATE;
822 *size = TTS_MAX_TEXT_SIZE;
824 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
825 return TTS_ERROR_NONE;
828 int tts_get_state(tts_h tts, tts_state_e* state)
830 if (0 != __tts_get_feature_enabled()) {
831 return TTS_ERROR_NOT_SUPPORTED;
834 if (NULL == tts || NULL == state) {
835 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
836 return TTS_ERROR_INVALID_PARAMETER;
839 tts_client_s* client = tts_client_get(tts);
841 if (NULL == client) {
842 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
843 return TTS_ERROR_INVALID_PARAMETER;
846 *state = client->current_state;
849 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
850 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
851 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
852 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
853 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
856 return TTS_ERROR_NONE;
859 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
861 if (0 != __tts_get_feature_enabled()) {
862 return TTS_ERROR_NOT_SUPPORTED;
865 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
866 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
867 return TTS_ERROR_INVALID_PARAMETER;
870 tts_client_s* client = tts_client_get(tts);
872 if (NULL == client) {
873 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
874 return TTS_ERROR_INVALID_PARAMETER;
877 *min = TTS_SPEED_MIN;
878 *normal = TTS_SPEED_NORMAL;
879 *max = TTS_SPEED_MAX;
881 return TTS_ERROR_NONE;
884 int tts_get_error_message(tts_h tts, char** err_msg)
886 if (0 != __tts_get_feature_enabled()) {
887 return TTS_ERROR_NOT_SUPPORTED;
890 if (NULL == tts || NULL == err_msg) {
891 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
892 return TTS_ERROR_INVALID_PARAMETER;
895 tts_client_s* client = tts_client_get(tts);
897 if (NULL == client) {
898 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
899 return TTS_ERROR_INVALID_PARAMETER;
902 if (NULL != client->err_msg) {
903 *err_msg = strdup(client->err_msg);
904 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
906 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
909 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
910 SLOG(LOG_DEBUG, TAG_TTSC, " ");
912 return TTS_ERROR_NONE;
915 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
917 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
919 if (0 != __tts_get_feature_enabled()) {
920 return TTS_ERROR_NOT_SUPPORTED;
924 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
925 return TTS_ERROR_INVALID_PARAMETER;
928 if (voice_type < 0) {
929 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
930 return TTS_ERROR_INVALID_PARAMETER;
933 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
935 if (NULL == tts || NULL == utt_id) {
936 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
937 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
938 SLOG(LOG_DEBUG, TAG_TTSC, " ");
939 return TTS_ERROR_INVALID_PARAMETER;
942 tts_client_s* client = tts_client_get(tts);
944 if (NULL == client) {
945 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
946 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
947 SLOG(LOG_DEBUG, TAG_TTSC, " ");
948 return TTS_ERROR_INVALID_PARAMETER;
951 if (TTS_STATE_CREATED == client->current_state) {
952 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
953 return TTS_ERROR_INVALID_STATE;
956 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
957 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
958 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
959 SLOG(LOG_DEBUG, TAG_TTSC, " ");
960 return TTS_ERROR_INVALID_PARAMETER;
963 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
964 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
965 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
966 SLOG(LOG_DEBUG, TAG_TTSC, " ");
967 return TTS_ERROR_INVALID_PARAMETER;
970 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
971 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
972 return TTS_ERROR_INVALID_STATE;
975 if (true == client->credential_needed && NULL == client->credential) {
976 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
977 return TTS_ERROR_PERMISSION_DENIED;
980 /* check valid utf8 */
982 ict = iconv_open("utf-8", "");
983 if ((iconv_t)-1 == ict) {
984 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
985 return TTS_ERROR_OPERATION_FAILED;
988 size_t len = strlen(text);
990 char in_buf[TTS_MAX_TEXT_SIZE];
991 char *out_tmp = NULL;
992 char out_buf[TTS_MAX_TEXT_SIZE];
993 size_t len_tmp = sizeof(out_buf);
995 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
996 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
999 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
1003 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
1004 if ((size_t)-1 == st) {
1005 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
1007 return TTS_ERROR_INVALID_PARAMETER;
1010 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
1012 /* change default language value */
1015 if (NULL == language)
1016 temp = strdup("default");
1018 temp = strdup(language);
1020 client->current_utt_id++;
1021 if (client->current_utt_id == 10000) {
1022 client->current_utt_id = 1;
1029 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
1031 if (TTS_ERROR_TIMED_OUT != ret) {
1032 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1035 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1038 if (TTS_RETRY_MIN_COUNT == count) {
1039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1044 *utt_id = client->current_utt_id;
1048 if (NULL != temp) free(temp);
1050 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1051 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1056 static void __tts_play_async(void *data)
1058 tts_h tts = (tts_h)data;
1059 tts_client_s* client = tts_client_get(tts);
1062 if (NULL == client) {
1063 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1070 ret = tts_dbus_request_play(client->uid, client->credential);
1072 if (TTS_ERROR_TIMED_OUT != ret) {
1073 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1076 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1079 if (TTS_RETRY_COUNT == count) {
1080 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1088 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1090 client->reason = ret;
1091 client->utt_id = -1;
1093 ecore_timer_add(0, __tts_notify_error, client->tts);
1097 client->before_state = client->current_state;
1098 client->current_state = TTS_STATE_PLAYING;
1100 if (NULL != client->state_changed_cb) {
1101 tts_client_use_callback(client);
1102 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1103 tts_client_not_use_callback(client);
1104 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1107 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1108 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1113 int tts_play_async(tts_h tts)
1115 if (0 != __tts_get_feature_enabled()) {
1116 return TTS_ERROR_NOT_SUPPORTED;
1119 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1122 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1123 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1124 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1125 return TTS_ERROR_INVALID_PARAMETER;
1128 tts_client_s* client = tts_client_get(tts);
1130 if (NULL == client) {
1131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1132 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1133 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1134 return TTS_ERROR_INVALID_PARAMETER;
1137 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1138 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1139 return TTS_ERROR_INVALID_STATE;
1142 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1143 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1144 return TTS_ERROR_INVALID_STATE;
1147 if (true == client->credential_needed && NULL == client->credential) {
1148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1149 return TTS_ERROR_PERMISSION_DENIED;
1152 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1154 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1155 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1157 return TTS_ERROR_NONE;
1160 int tts_play(tts_h tts)
1162 if (0 != __tts_get_feature_enabled()) {
1163 return TTS_ERROR_NOT_SUPPORTED;
1166 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1170 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1171 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1172 return TTS_ERROR_INVALID_PARAMETER;
1175 tts_client_s* client = tts_client_get(tts);
1177 if (NULL == client) {
1178 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1179 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1180 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1181 return TTS_ERROR_INVALID_PARAMETER;
1184 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1185 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1186 return TTS_ERROR_INVALID_STATE;
1189 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1190 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1191 return TTS_ERROR_INVALID_STATE;
1194 if (true == client->credential_needed && NULL == client->credential) {
1195 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1196 return TTS_ERROR_PERMISSION_DENIED;
1202 ret = tts_dbus_request_play(client->uid, client->credential);
1204 if (TTS_ERROR_TIMED_OUT != ret) {
1205 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1208 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1211 if (TTS_RETRY_COUNT == count) {
1212 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1219 client->before_state = client->current_state;
1220 client->current_state = TTS_STATE_PLAYING;
1222 if (NULL != client->state_changed_cb) {
1223 tts_client_use_callback(client);
1224 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1225 tts_client_not_use_callback(client);
1226 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1229 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1230 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1232 return TTS_ERROR_NONE;
1235 static void __tts_stop_async(void *data)
1237 tts_h tts = (tts_h)data;
1238 tts_client_s* client = tts_client_get(tts);
1241 if (NULL == client) {
1242 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1249 ret = tts_dbus_request_stop(client->uid);
1251 if (TTS_ERROR_TIMED_OUT != ret) {
1252 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1255 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1258 if (TTS_RETRY_COUNT == count) {
1259 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1267 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1269 client->reason = ret;
1270 client->utt_id = -1;
1272 ecore_timer_add(0, __tts_notify_error, client->tts);
1276 client->before_state = client->current_state;
1277 client->current_state = TTS_STATE_READY;
1279 if (NULL != client->state_changed_cb) {
1280 tts_client_use_callback(client);
1281 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1282 tts_client_not_use_callback(client);
1283 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1286 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1287 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1292 int tts_stop_aync(tts_h tts)
1294 if (0 != __tts_get_feature_enabled()) {
1295 return TTS_ERROR_NOT_SUPPORTED;
1298 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1301 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1302 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1303 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1304 return TTS_ERROR_INVALID_PARAMETER;
1307 tts_client_s* client = tts_client_get(tts);
1309 if (NULL == client) {
1310 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1311 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1312 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1313 return TTS_ERROR_INVALID_PARAMETER;
1316 if (TTS_STATE_CREATED == client->current_state) {
1317 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1318 return TTS_ERROR_INVALID_STATE;
1321 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1322 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1323 return TTS_ERROR_INVALID_STATE;
1326 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1328 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1329 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1331 return TTS_ERROR_NONE;
1334 int tts_stop(tts_h tts)
1336 if (0 != __tts_get_feature_enabled()) {
1337 return TTS_ERROR_NOT_SUPPORTED;
1340 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1343 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1344 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1345 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1346 return TTS_ERROR_INVALID_PARAMETER;
1349 tts_client_s* client = tts_client_get(tts);
1351 if (NULL == client) {
1352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1353 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1354 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1355 return TTS_ERROR_INVALID_PARAMETER;
1358 if (TTS_STATE_CREATED == client->current_state) {
1359 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1360 return TTS_ERROR_INVALID_STATE;
1363 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1364 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1365 return TTS_ERROR_INVALID_STATE;
1371 ret = tts_dbus_request_stop(client->uid);
1373 if (TTS_ERROR_TIMED_OUT != ret) {
1374 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1377 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1380 if (TTS_RETRY_COUNT == count) {
1381 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1388 client->before_state = client->current_state;
1389 client->current_state = TTS_STATE_READY;
1391 if (NULL != client->state_changed_cb) {
1392 tts_client_use_callback(client);
1393 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1394 tts_client_not_use_callback(client);
1395 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1398 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1399 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1401 return TTS_ERROR_NONE;
1404 static void __tts_pause_async(void *data)
1406 tts_h tts = (tts_h)data;
1407 tts_client_s* client = tts_client_get(tts);
1410 if (NULL == client) {
1411 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1418 ret = tts_dbus_request_pause(client->uid);
1420 if (TTS_ERROR_TIMED_OUT != ret) {
1421 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1424 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1427 if (TTS_RETRY_COUNT == count) {
1428 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1436 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1438 client->reason = ret;
1439 client->utt_id = -1;
1441 ecore_timer_add(0, __tts_notify_error, client->tts);
1445 client->before_state = client->current_state;
1446 client->current_state = TTS_STATE_PAUSED;
1448 if (NULL != client->state_changed_cb) {
1449 tts_client_use_callback(client);
1450 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1451 tts_client_not_use_callback(client);
1452 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1455 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1456 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1461 int tts_pause_async(tts_h tts)
1463 if (0 != __tts_get_feature_enabled()) {
1464 return TTS_ERROR_NOT_SUPPORTED;
1467 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1470 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1471 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1472 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1473 return TTS_ERROR_INVALID_PARAMETER;
1476 tts_client_s* client = tts_client_get(tts);
1478 if (NULL == client) {
1479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1480 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1481 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1482 return TTS_ERROR_INVALID_PARAMETER;
1485 if (TTS_STATE_PLAYING != client->current_state) {
1486 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1487 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1488 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1489 return TTS_ERROR_INVALID_STATE;
1492 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1493 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1494 return TTS_ERROR_INVALID_STATE;
1497 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1499 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1500 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1502 return TTS_ERROR_NONE;
1505 int tts_pause(tts_h tts)
1507 if (0 != __tts_get_feature_enabled()) {
1508 return TTS_ERROR_NOT_SUPPORTED;
1511 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1514 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1515 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1516 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1517 return TTS_ERROR_INVALID_PARAMETER;
1520 tts_client_s* client = tts_client_get(tts);
1522 if (NULL == client) {
1523 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1524 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1525 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1526 return TTS_ERROR_INVALID_PARAMETER;
1529 if (TTS_STATE_PLAYING != client->current_state) {
1530 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1531 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1532 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1533 return TTS_ERROR_INVALID_STATE;
1536 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1537 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1538 return TTS_ERROR_INVALID_STATE;
1544 ret = tts_dbus_request_pause(client->uid);
1546 if (TTS_ERROR_TIMED_OUT != ret) {
1547 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1550 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1553 if (TTS_RETRY_COUNT == count) {
1554 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1561 client->before_state = client->current_state;
1562 client->current_state = TTS_STATE_PAUSED;
1564 if (NULL != client->state_changed_cb) {
1565 tts_client_use_callback(client);
1566 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1567 tts_client_not_use_callback(client);
1568 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1571 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1572 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1574 return TTS_ERROR_NONE;
1577 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1579 if (0 != __tts_get_feature_enabled()) {
1580 return TTS_ERROR_NOT_SUPPORTED;
1583 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1586 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1587 return TTS_ERROR_INVALID_PARAMETER;
1590 if (NULL == key || NULL == data) {
1591 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1592 return TTS_ERROR_INVALID_PARAMETER;
1595 tts_client_s* client = tts_client_get(tts);
1597 if (NULL == client) {
1598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1599 return TTS_ERROR_INVALID_PARAMETER;
1602 if (TTS_STATE_READY != client->current_state) {
1603 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1604 return TTS_ERROR_INVALID_STATE;
1607 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1608 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1609 return TTS_ERROR_INVALID_PARAMETER;
1615 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1617 if (TTS_ERROR_TIMED_OUT != ret) {
1618 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1621 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1624 if (TTS_RETRY_COUNT == count) {
1625 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1632 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1633 SLOG(LOG_DEBUG, TAG_TTSC, "");
1638 int tts_get_private_data(tts_h tts, const char* key, char** data)
1640 if (0 != __tts_get_feature_enabled()) {
1641 return TTS_ERROR_NOT_SUPPORTED;
1644 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1647 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1648 return TTS_ERROR_INVALID_PARAMETER;
1651 if (NULL == key || NULL == data) {
1652 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1653 return TTS_ERROR_INVALID_PARAMETER;
1656 tts_client_s* client = tts_client_get(tts);
1658 if (NULL == client) {
1659 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1660 return TTS_ERROR_INVALID_PARAMETER;
1663 if (TTS_STATE_READY != client->current_state) {
1664 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1665 return TTS_ERROR_INVALID_STATE;
1671 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1673 if (TTS_ERROR_TIMED_OUT != ret) {
1674 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1677 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1680 if (TTS_RETRY_COUNT == count) {
1681 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1688 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1693 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1694 SLOG(LOG_DEBUG, TAG_TTSC, "");
1699 static Eina_Bool __tts_notify_error(void *data)
1701 tts_h tts = (tts_h)data;
1703 tts_client_s* client = tts_client_get(tts);
1706 if (NULL == client) {
1707 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1711 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1713 if (NULL != client->error_cb) {
1714 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1715 tts_client_use_callback(client);
1716 g_err_callback_status = true;
1717 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1718 g_err_callback_status = false;
1719 tts_client_not_use_callback(client);
1721 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1727 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1729 tts_client_s* client = tts_client_get_by_uid(uid);
1731 if (NULL == client) {
1732 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1733 return TTS_ERROR_INVALID_PARAMETER;
1736 client->utt_id = utt_id;
1737 client->reason = reason;
1738 if (NULL != client->err_msg) {
1739 free(client->err_msg);
1740 client->err_msg = NULL;
1742 client->err_msg = strdup(err_msg);
1744 /* call callback function */
1745 if (NULL != client->error_cb) {
1746 ecore_timer_add(0, __tts_notify_error, client->tts);
1748 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1751 if (TTS_ERROR_SERVICE_RESET == reason) {
1752 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1754 client->current_state = TTS_STATE_CREATED;
1755 if (0 != tts_prepare(client->tts)) {
1756 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1763 static Eina_Bool __tts_notify_state_changed(void *data)
1765 tts_h tts = (tts_h)data;
1767 tts_client_s* client = tts_client_get(tts);
1770 if (NULL == client) {
1771 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1775 if (NULL != client->state_changed_cb) {
1776 tts_client_use_callback(client);
1777 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1778 tts_client_not_use_callback(client);
1779 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1781 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1787 int __tts_cb_set_state(int uid, int state)
1789 tts_client_s* client = tts_client_get_by_uid(uid);
1790 if (NULL == client) {
1791 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1795 tts_state_e state_from_daemon = (tts_state_e)state;
1797 if (client->current_state == state_from_daemon) {
1798 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1802 if (NULL != client->state_changed_cb) {
1803 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1805 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1808 client->before_state = client->current_state;
1809 client->current_state = state_from_daemon;
1814 int __tts_cb_utt_started(int uid, int utt_id)
1816 tts_client_s* client = tts_client_get_by_uid(uid);
1818 if (NULL == client) {
1819 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1820 return TTS_ERROR_INVALID_PARAMETER;
1823 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1825 client->utt_id = utt_id;
1827 /* call callback function */
1828 if (NULL != client->utt_started_cb) {
1829 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1830 tts_client_use_callback(client);
1831 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1832 tts_client_not_use_callback(client);
1834 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1840 int __tts_cb_utt_completed(int uid, int utt_id)
1842 tts_client_s* client = tts_client_get_by_uid(uid);
1844 if (NULL == client) {
1845 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1846 return TTS_ERROR_INVALID_PARAMETER;
1849 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1851 client->utt_id = utt_id;
1853 /* call callback function */
1854 if (NULL != client->utt_completeted_cb) {
1855 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1856 tts_client_use_callback(client);
1857 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1858 tts_client_not_use_callback(client);
1860 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1866 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1868 if (0 != __tts_get_feature_enabled()) {
1869 return TTS_ERROR_NOT_SUPPORTED;
1872 if (NULL == tts || NULL == callback) {
1873 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1874 return TTS_ERROR_INVALID_PARAMETER;
1877 tts_client_s* client = tts_client_get(tts);
1879 if (NULL == client) {
1880 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1881 return TTS_ERROR_INVALID_PARAMETER;
1884 if (TTS_STATE_CREATED != client->current_state) {
1885 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1886 return TTS_ERROR_INVALID_STATE;
1889 client->state_changed_cb = callback;
1890 client->state_changed_user_data = user_data;
1892 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1897 int tts_unset_state_changed_cb(tts_h tts)
1899 if (0 != __tts_get_feature_enabled()) {
1900 return TTS_ERROR_NOT_SUPPORTED;
1904 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1905 return TTS_ERROR_INVALID_PARAMETER;
1908 tts_client_s* client = tts_client_get(tts);
1910 if (NULL == client) {
1911 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1912 return TTS_ERROR_INVALID_PARAMETER;
1915 if (TTS_STATE_CREATED != client->current_state) {
1916 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1917 return TTS_ERROR_INVALID_STATE;
1920 client->state_changed_cb = NULL;
1921 client->state_changed_user_data = NULL;
1923 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1928 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1930 if (0 != __tts_get_feature_enabled()) {
1931 return TTS_ERROR_NOT_SUPPORTED;
1934 if (NULL == tts || NULL == callback) {
1935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1936 return TTS_ERROR_INVALID_PARAMETER;
1939 tts_client_s* client = tts_client_get(tts);
1941 if (NULL == client) {
1942 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1943 return TTS_ERROR_INVALID_PARAMETER;
1946 if (TTS_STATE_CREATED != client->current_state) {
1947 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1948 return TTS_ERROR_INVALID_STATE;
1951 client->utt_started_cb = callback;
1952 client->utt_started_user_data = user_data;
1954 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1959 int tts_unset_utterance_started_cb(tts_h tts)
1961 if (0 != __tts_get_feature_enabled()) {
1962 return TTS_ERROR_NOT_SUPPORTED;
1966 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1967 return TTS_ERROR_INVALID_PARAMETER;
1970 tts_client_s* client = tts_client_get(tts);
1972 if (NULL == client) {
1973 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1974 return TTS_ERROR_INVALID_PARAMETER;
1977 if (TTS_STATE_CREATED != client->current_state) {
1978 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1979 return TTS_ERROR_INVALID_STATE;
1982 client->utt_started_cb = NULL;
1983 client->utt_started_user_data = NULL;
1985 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1990 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1992 if (0 != __tts_get_feature_enabled()) {
1993 return TTS_ERROR_NOT_SUPPORTED;
1996 if (NULL == tts || NULL == callback) {
1997 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1998 return TTS_ERROR_INVALID_PARAMETER;
2001 tts_client_s* client = tts_client_get(tts);
2003 if (NULL == client) {
2004 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2005 return TTS_ERROR_INVALID_PARAMETER;
2008 if (TTS_STATE_CREATED != client->current_state) {
2009 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2010 return TTS_ERROR_INVALID_STATE;
2013 client->utt_completeted_cb = callback;
2014 client->utt_completed_user_data = user_data;
2016 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2021 int tts_unset_utterance_completed_cb(tts_h tts)
2023 if (0 != __tts_get_feature_enabled()) {
2024 return TTS_ERROR_NOT_SUPPORTED;
2028 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2029 return TTS_ERROR_INVALID_PARAMETER;
2032 tts_client_s* client = tts_client_get(tts);
2034 if (NULL == client) {
2035 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2036 return TTS_ERROR_INVALID_PARAMETER;
2039 if (TTS_STATE_CREATED != client->current_state) {
2040 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2041 return TTS_ERROR_INVALID_STATE;
2044 client->utt_completeted_cb = NULL;
2045 client->utt_completed_user_data = NULL;
2047 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2051 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2053 if (0 != __tts_get_feature_enabled()) {
2054 return TTS_ERROR_NOT_SUPPORTED;
2057 if (NULL == tts || NULL == callback) {
2058 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2059 return TTS_ERROR_INVALID_PARAMETER;
2062 tts_client_s* client = tts_client_get(tts);
2064 if (NULL == client) {
2065 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2066 return TTS_ERROR_INVALID_PARAMETER;
2069 if (TTS_STATE_CREATED != client->current_state) {
2070 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2071 return TTS_ERROR_INVALID_STATE;
2074 client->error_cb = callback;
2075 client->error_user_data = user_data;
2077 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2082 int tts_unset_error_cb(tts_h tts)
2084 if (0 != __tts_get_feature_enabled()) {
2085 return TTS_ERROR_NOT_SUPPORTED;
2089 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2090 return TTS_ERROR_INVALID_PARAMETER;
2093 tts_client_s* client = tts_client_get(tts);
2095 if (NULL == client) {
2096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2097 return TTS_ERROR_INVALID_PARAMETER;
2100 if (TTS_STATE_CREATED != client->current_state) {
2101 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2102 return TTS_ERROR_INVALID_STATE;
2105 client->error_cb = NULL;
2106 client->error_user_data = NULL;
2108 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2113 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2115 if (0 != __tts_get_feature_enabled()) {
2116 return TTS_ERROR_NOT_SUPPORTED;
2119 if (NULL == tts || NULL == callback) {
2120 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2121 return TTS_ERROR_INVALID_PARAMETER;
2124 tts_client_s* client = tts_client_get(tts);
2126 if (NULL == client) {
2127 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2128 return TTS_ERROR_INVALID_PARAMETER;
2131 if (TTS_STATE_CREATED != client->current_state) {
2132 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2133 return TTS_ERROR_INVALID_STATE;
2136 client->default_voice_changed_cb = callback;
2137 client->default_voice_changed_user_data = user_data;
2139 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2144 int tts_unset_default_voice_changed_cb(tts_h tts)
2146 if (0 != __tts_get_feature_enabled()) {
2147 return TTS_ERROR_NOT_SUPPORTED;
2151 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2152 return TTS_ERROR_INVALID_PARAMETER;
2155 tts_client_s* client = tts_client_get(tts);
2157 if (NULL == client) {
2158 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2159 return TTS_ERROR_INVALID_PARAMETER;
2162 if (TTS_STATE_CREATED != client->current_state) {
2163 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2164 return TTS_ERROR_INVALID_STATE;
2167 client->default_voice_changed_cb = NULL;
2168 client->default_voice_changed_user_data = NULL;
2170 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2175 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2177 if (0 != __tts_get_feature_enabled()) {
2178 return TTS_ERROR_NOT_SUPPORTED;
2181 if (NULL == tts || NULL == callback) {
2182 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2183 return TTS_ERROR_INVALID_PARAMETER;
2186 tts_client_s* client = tts_client_get(tts);
2188 if (NULL == client) {
2189 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2190 return TTS_ERROR_INVALID_PARAMETER;
2193 if (TTS_STATE_CREATED != client->current_state) {
2194 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2195 return TTS_ERROR_INVALID_STATE;
2198 client->engine_changed_cb = callback;
2199 client->engine_changed_user_data = user_data;
2201 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2206 int tts_unset_engine_changed_cb(tts_h tts)
2208 if (0 != __tts_get_feature_enabled()) {
2209 return TTS_ERROR_NOT_SUPPORTED;
2213 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2214 return TTS_ERROR_INVALID_PARAMETER;
2217 tts_client_s* client = tts_client_get(tts);
2219 if (NULL == client) {
2220 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2221 return TTS_ERROR_INVALID_PARAMETER;
2224 if (TTS_STATE_CREATED != client->current_state) {
2225 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2226 return TTS_ERROR_INVALID_STATE;
2229 client->engine_changed_cb = NULL;
2230 client->engine_changed_user_data = NULL;
2232 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");