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 /* When the default engine is changed, please unload the old engine and load the new one. */
158 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
161 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
163 ret = tts_unprepare(tts);
165 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
167 ret = tts_prepare(tts);
169 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
171 } else if (TTS_STATE_READY == client->current_state) {
172 ret = tts_unprepare(tts);
174 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
176 ret = tts_prepare(tts);
178 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
182 /* call callback function */
183 if (NULL != client->engine_changed_cb) {
184 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
186 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
191 int tts_create(tts_h* tts)
193 if (0 != __tts_get_feature_enabled()) {
194 return TTS_ERROR_NOT_SUPPORTED;
197 SLOG(LOG_INFO, TAG_TTSC, "===== Create TTS");
201 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
202 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
203 SLOG(LOG_DEBUG, TAG_TTSC, " ");
204 return TTS_ERROR_INVALID_PARAMETER;
207 if (0 == tts_client_get_size()) {
208 if (0 != tts_dbus_open_connection()) {
209 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
210 return TTS_ERROR_OPERATION_FAILED;
214 if (0 != tts_client_new(tts)) {
215 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
216 return TTS_ERROR_OUT_OF_MEMORY;
219 tts_client_s* client = tts_client_get(*tts);
220 if (NULL == client) {
221 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
222 return TTS_ERROR_OPERATION_FAILED;
225 int ret = tts_config_mgr_initialize(client->uid);
227 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
228 tts_client_destroy(*tts);
229 return __tts_convert_config_error_code(ret);
232 ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL);
234 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
235 tts_client_destroy(*tts);
236 return __tts_convert_config_error_code(ret);
239 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
240 SLOG(LOG_DEBUG, TAG_TTSC, " ");
242 return TTS_ERROR_NONE;
245 int tts_destroy(tts_h tts)
247 if (0 != __tts_get_feature_enabled()) {
248 return TTS_ERROR_NOT_SUPPORTED;
251 SLOG(LOG_INFO, TAG_TTSC, "===== Destroy TTS");
254 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
255 return TTS_ERROR_INVALID_PARAMETER;
258 tts_client_s* client = tts_client_get(tts);
261 if (NULL == client) {
262 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
263 return TTS_ERROR_INVALID_PARAMETER;
266 /* check used callback */
267 if (0 != tts_client_get_use_callback(client)) {
268 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
269 return TTS_ERROR_OPERATION_FAILED;
272 tts_config_mgr_finalize(client->uid);
276 int screen_reader = -1;
279 switch (client->current_state) {
280 case TTS_STATE_PAUSED:
281 case TTS_STATE_PLAYING:
282 case TTS_STATE_READY:
283 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
285 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
287 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
288 g_screen_reader = (bool)screen_reader;
290 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
292 ret = tts_dbus_request_finalize(client->uid);
294 if (TTS_ERROR_TIMED_OUT != ret) {
295 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
298 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
301 if (TTS_RETRY_COUNT == count) {
302 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
309 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
312 client->before_state = client->current_state;
313 client->current_state = TTS_STATE_CREATED;
315 case TTS_STATE_CREATED:
316 if (NULL != client->conn_timer) {
317 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
318 ecore_timer_del(client->conn_timer);
319 client->conn_timer = NULL;
322 tts_client_destroy(tts);
329 if (0 == tts_client_get_size()) {
330 if (0 != tts_dbus_close_connection()) {
331 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
337 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
338 SLOG(LOG_DEBUG, TAG_TTSC, " ");
340 return TTS_ERROR_NONE;
343 void __tts_screen_reader_changed_cb(bool value)
345 g_screen_reader = value;
348 int tts_set_mode(tts_h tts, tts_mode_e mode)
350 if (0 != __tts_get_feature_enabled()) {
351 return TTS_ERROR_NOT_SUPPORTED;
354 SLOG(LOG_INFO, TAG_TTSC, "===== Set TTS mode(%d)", mode);
356 tts_client_s* client = tts_client_get(tts);
359 if (NULL == client) {
360 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
361 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
362 SLOG(LOG_DEBUG, TAG_TTSC, " ");
363 return TTS_ERROR_INVALID_PARAMETER;
367 if (client->current_state != TTS_STATE_CREATED) {
368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
369 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
370 SLOG(LOG_DEBUG, TAG_TTSC, " ");
371 return TTS_ERROR_INVALID_STATE;
374 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
377 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
378 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
379 SLOG(LOG_DEBUG, TAG_TTSC, " ");
380 return TTS_ERROR_INVALID_PARAMETER;
383 if (TTS_MODE_SCREEN_READER == mode) {
386 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
388 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
389 return TTS_ERROR_OPERATION_FAILED;
391 g_screen_reader = (bool)screen_reader;
392 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
394 tts_config_unset_screen_reader_callback(client->uid);
397 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
398 SLOG(LOG_DEBUG, TAG_TTSC, " ");
400 return TTS_ERROR_NONE;
403 int tts_get_mode(tts_h tts, tts_mode_e* mode)
405 if (0 != __tts_get_feature_enabled()) {
406 return TTS_ERROR_NOT_SUPPORTED;
409 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
411 tts_client_s* client = tts_client_get(tts);
414 if (NULL == client) {
415 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
416 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
417 SLOG(LOG_DEBUG, TAG_TTSC, " ");
418 return TTS_ERROR_INVALID_PARAMETER;
422 if (client->current_state != TTS_STATE_CREATED) {
423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
424 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
425 SLOG(LOG_DEBUG, TAG_TTSC, " ");
426 return TTS_ERROR_INVALID_STATE;
430 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
431 return TTS_ERROR_INVALID_PARAMETER;
434 *mode = client->mode;
436 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
437 SLOG(LOG_DEBUG, TAG_TTSC, " ");
439 return TTS_ERROR_NONE;
442 int tts_set_credential(tts_h tts, const char* credential)
444 if (0 != __tts_get_feature_enabled()) {
445 return TTS_ERROR_NOT_SUPPORTED;
448 if (NULL == tts || NULL == credential) {
449 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
450 return TTS_ERROR_INVALID_PARAMETER;
453 tts_client_s* client = tts_client_get(tts);
455 if (NULL == client) {
456 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
457 return TTS_ERROR_INVALID_PARAMETER;
460 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
461 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
462 return TTS_ERROR_INVALID_STATE;
465 if (NULL != client->credential) {
466 free(client->credential);
467 client->credential = NULL;
469 client->credential = strdup(credential);
471 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
472 SLOG(LOG_DEBUG, TAG_TTSC, " ");
474 return TTS_ERROR_NONE;
477 int tts_set_server_tts(tts_h tts, const char* credential)
479 if (0 != __tts_get_feature_enabled()) {
480 return TTS_ERROR_NOT_SUPPORTED;
484 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
485 return TTS_ERROR_INVALID_PARAMETER;
488 tts_client_s* client = tts_client_get(tts);
490 if (NULL == client) {
491 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
492 return TTS_ERROR_INVALID_PARAMETER;
495 if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
496 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
497 return TTS_ERROR_INVALID_STATE;
500 if (NULL != client->credential) {
501 free(client->credential);
502 client->credential = NULL;
505 client->internal = true;
508 if (NULL != credential) {
509 key = strdup("EnableServerTTS");
510 client->credential = strdup(credential);
511 if (NULL == client->credential) {
512 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
513 return TTS_ERROR_OUT_OF_MEMORY;
516 key = strdup("DisableServerTTS");
520 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
521 return TTS_ERROR_OUT_OF_MEMORY;
526 int ret = app_manager_get_app_id(pid, &appid);
528 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
531 return TTS_ERROR_OPERATION_FAILED;
534 ret = tts_set_private_data(tts, key, appid);
536 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
547 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
548 SLOG(LOG_DEBUG, TAG_TTSC, " ");
550 return TTS_ERROR_NONE;
553 static Eina_Bool __tts_connect_daemon(void *data)
555 tts_h tts = (tts_h)data;
556 tts_client_s* client = tts_client_get(tts);
559 if (NULL == client) {
560 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
565 if (0 != tts_dbus_request_hello(client->uid)) {
569 SLOG(LOG_INFO, TAG_TTSC, "===== Connect daemon");
571 /* do request initialize */
573 bool credential_needed = false;
575 ret = tts_dbus_request_initialize(client->uid, &credential_needed);
577 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
578 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
580 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
583 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
584 client->conn_timer = NULL;
587 } else if (TTS_ERROR_NONE != ret) {
588 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
592 /* success to connect tts-daemon */
593 client->credential_needed = credential_needed;
594 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
597 client->conn_timer = NULL;
599 client = tts_client_get(tts);
601 if (NULL == client) {
602 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
606 client->before_state = client->current_state;
607 client->current_state = TTS_STATE_READY;
609 if (NULL != client->state_changed_cb) {
610 tts_client_use_callback(client);
611 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
612 tts_client_not_use_callback(client);
614 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
617 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
618 SLOG(LOG_DEBUG, TAG_TTSC, " ");
623 int tts_prepare(tts_h tts)
625 if (0 != __tts_get_feature_enabled()) {
626 return TTS_ERROR_NOT_SUPPORTED;
629 SLOG(LOG_INFO, TAG_TTSC, "===== Prepare TTS");
631 tts_client_s* client = tts_client_get(tts);
634 if (NULL == client) {
635 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
636 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
637 SLOG(LOG_DEBUG, TAG_TTSC, " ");
638 return TTS_ERROR_INVALID_PARAMETER;
642 if (client->current_state != TTS_STATE_CREATED) {
643 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
644 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
645 SLOG(LOG_DEBUG, TAG_TTSC, " ");
646 return TTS_ERROR_INVALID_STATE;
649 client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
651 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
652 SLOG(LOG_DEBUG, TAG_TTSC, " ");
654 return TTS_ERROR_NONE;
657 int tts_unprepare(tts_h tts)
659 if (0 != __tts_get_feature_enabled()) {
660 return TTS_ERROR_NOT_SUPPORTED;
663 SLOG(LOG_INFO, TAG_TTSC, "===== Unprepare TTS");
665 tts_client_s* client = tts_client_get(tts);
668 if (NULL == client) {
669 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
670 return TTS_ERROR_INVALID_PARAMETER;
674 if (client->current_state != TTS_STATE_READY) {
675 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
676 return TTS_ERROR_INVALID_STATE;
681 int screen_reader = -1;
683 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
685 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
687 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
688 g_screen_reader = (bool)screen_reader;
691 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
693 ret = tts_dbus_request_finalize(client->uid);
695 if (TTS_ERROR_TIMED_OUT != ret) {
696 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
699 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
702 if (TTS_RETRY_COUNT == count) {
703 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
710 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
713 client->before_state = client->current_state;
714 client->current_state = TTS_STATE_CREATED;
716 if (NULL != client->state_changed_cb) {
717 tts_client_use_callback(client);
718 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
719 tts_client_not_use_callback(client);
720 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
723 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
724 SLOG(LOG_DEBUG, TAG_TTSC, " ");
726 return TTS_ERROR_NONE;
729 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
731 tts_h tts = (tts_h)user_data;
733 tts_client_s* client = tts_client_get(tts);
734 if (NULL == client) {
735 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
739 /* call callback function */
740 if (NULL != client->supported_voice_cb) {
741 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
743 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
749 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
751 if (0 != __tts_get_feature_enabled()) {
752 return TTS_ERROR_NOT_SUPPORTED;
755 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
757 if (NULL == tts || NULL == callback) {
758 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
759 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
760 SLOG(LOG_DEBUG, TAG_TTSC, " ");
761 return TTS_ERROR_INVALID_PARAMETER;
764 tts_client_s* client = tts_client_get(tts);
767 if (NULL == client) {
768 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
769 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
770 SLOG(LOG_DEBUG, TAG_TTSC, " ");
771 return TTS_ERROR_INVALID_PARAMETER;
775 char* current_engine = NULL;
776 ret = tts_config_mgr_get_engine(¤t_engine);
778 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
779 return __tts_convert_config_error_code(ret);
782 client->supported_voice_cb = callback;
783 client->supported_voice_user_data = user_data;
785 ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
787 if (NULL != current_engine) {
788 free(current_engine);
789 current_engine = NULL;
792 client->supported_voice_cb = NULL;
793 client->supported_voice_user_data = NULL;
796 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
797 ret = TTS_ERROR_OPERATION_FAILED;
800 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
801 SLOG(LOG_DEBUG, TAG_TTSC, " ");
806 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
808 if (0 != __tts_get_feature_enabled()) {
809 return TTS_ERROR_NOT_SUPPORTED;
812 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
815 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
816 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
817 SLOG(LOG_DEBUG, TAG_TTSC, " ");
818 return TTS_ERROR_INVALID_PARAMETER;
821 tts_client_s* client = tts_client_get(tts);
823 if (NULL == client) {
824 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
825 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
826 SLOG(LOG_DEBUG, TAG_TTSC, " ");
827 return TTS_ERROR_INVALID_PARAMETER;
830 /* Request call remote method */
832 ret = tts_config_mgr_get_voice(lang, vctype);
834 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
835 return __tts_convert_config_error_code(ret);
837 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
840 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
841 SLOG(LOG_DEBUG, TAG_TTSC, " ");
846 int tts_get_max_text_size(tts_h tts, unsigned int* size)
848 if (0 != __tts_get_feature_enabled()) {
849 return TTS_ERROR_NOT_SUPPORTED;
852 if (NULL == tts || NULL == size) {
853 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
854 return TTS_ERROR_INVALID_PARAMETER;
857 tts_client_s* client = tts_client_get(tts);
859 if (NULL == client) {
860 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
861 return TTS_ERROR_INVALID_PARAMETER;
864 if (TTS_STATE_READY != client->current_state) {
865 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
866 return TTS_ERROR_INVALID_STATE;
869 *size = TTS_MAX_TEXT_SIZE;
871 SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
872 return TTS_ERROR_NONE;
875 int tts_get_state(tts_h tts, tts_state_e* state)
877 if (0 != __tts_get_feature_enabled()) {
878 return TTS_ERROR_NOT_SUPPORTED;
881 if (NULL == tts || NULL == state) {
882 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
883 return TTS_ERROR_INVALID_PARAMETER;
886 tts_client_s* client = tts_client_get(tts);
888 if (NULL == client) {
889 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
890 return TTS_ERROR_INVALID_PARAMETER;
893 *state = client->current_state;
896 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
897 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
898 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
899 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
900 default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break;
903 return TTS_ERROR_NONE;
906 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
908 if (0 != __tts_get_feature_enabled()) {
909 return TTS_ERROR_NOT_SUPPORTED;
912 if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
913 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
914 return TTS_ERROR_INVALID_PARAMETER;
917 tts_client_s* client = tts_client_get(tts);
919 if (NULL == client) {
920 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
921 return TTS_ERROR_INVALID_PARAMETER;
924 *min = TTS_SPEED_MIN;
925 *normal = TTS_SPEED_NORMAL;
926 *max = TTS_SPEED_MAX;
928 return TTS_ERROR_NONE;
931 int tts_get_error_message(tts_h tts, char** err_msg)
933 if (0 != __tts_get_feature_enabled()) {
934 return TTS_ERROR_NOT_SUPPORTED;
937 if (NULL == tts || NULL == err_msg) {
938 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
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] Get state : A handle is not valid");
946 return TTS_ERROR_INVALID_PARAMETER;
949 if (NULL != client->err_msg) {
950 *err_msg = strdup(client->err_msg);
951 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
954 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
957 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
958 SLOG(LOG_DEBUG, TAG_TTSC, " ");
960 return TTS_ERROR_NONE;
963 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
965 SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
967 if (0 != __tts_get_feature_enabled()) {
968 return TTS_ERROR_NOT_SUPPORTED;
972 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
973 return TTS_ERROR_INVALID_PARAMETER;
976 if (voice_type < 0) {
977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
978 return TTS_ERROR_INVALID_PARAMETER;
981 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
983 if (NULL == tts || NULL == utt_id) {
984 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
985 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
986 SLOG(LOG_DEBUG, TAG_TTSC, " ");
987 return TTS_ERROR_INVALID_PARAMETER;
990 tts_client_s* client = tts_client_get(tts);
992 if (NULL == client) {
993 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
994 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
995 SLOG(LOG_DEBUG, TAG_TTSC, " ");
996 return TTS_ERROR_INVALID_PARAMETER;
999 if (TTS_STATE_CREATED == client->current_state) {
1000 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1001 return TTS_ERROR_INVALID_STATE;
1004 if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
1005 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1006 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1007 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1008 return TTS_ERROR_INVALID_PARAMETER;
1011 if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1012 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1013 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1014 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1015 return TTS_ERROR_INVALID_PARAMETER;
1018 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1019 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1020 return TTS_ERROR_INVALID_STATE;
1023 if (true == client->credential_needed && NULL == client->credential) {
1024 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1025 return TTS_ERROR_PERMISSION_DENIED;
1028 /* check valid utf8 */
1030 ict = iconv_open("utf-8", "");
1031 if ((iconv_t)-1 == ict) {
1032 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
1033 return TTS_ERROR_OPERATION_FAILED;
1036 size_t len = strlen(text);
1037 char *in_tmp = NULL;
1038 char in_buf[TTS_MAX_TEXT_SIZE];
1039 char *out_tmp = NULL;
1040 char out_buf[TTS_MAX_TEXT_SIZE];
1041 size_t len_tmp = sizeof(out_buf);
1043 memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
1044 snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
1047 memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
1051 st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
1052 if ((size_t)-1 == st) {
1053 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
1055 return TTS_ERROR_INVALID_PARAMETER;
1058 SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
1060 /* change default language value */
1063 if (NULL == language)
1064 temp = strdup("default");
1066 temp = strdup(language);
1068 client->current_utt_id++;
1069 if (client->current_utt_id == 10000) {
1070 client->current_utt_id = 1;
1077 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
1079 if (TTS_ERROR_TIMED_OUT != ret) {
1080 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1083 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1086 if (TTS_RETRY_MIN_COUNT == count) {
1087 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1092 *utt_id = client->current_utt_id;
1101 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1102 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1107 static void __tts_play_async(void *data)
1109 tts_h tts = (tts_h)data;
1110 tts_client_s* client = tts_client_get(tts);
1113 if (NULL == client) {
1114 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1121 ret = tts_dbus_request_play(client->uid, client->credential);
1123 if (TTS_ERROR_TIMED_OUT != ret) {
1124 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1127 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1130 if (TTS_RETRY_COUNT == count) {
1131 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1139 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1141 client->reason = ret;
1142 client->utt_id = -1;
1144 ecore_timer_add(0, __tts_notify_error, client->tts);
1148 client->before_state = client->current_state;
1149 client->current_state = TTS_STATE_PLAYING;
1151 if (NULL != client->state_changed_cb) {
1152 tts_client_use_callback(client);
1153 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1154 tts_client_not_use_callback(client);
1155 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1158 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1159 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1164 int tts_play_async(tts_h tts)
1166 if (0 != __tts_get_feature_enabled()) {
1167 return TTS_ERROR_NOT_SUPPORTED;
1170 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1173 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1174 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1175 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1176 return TTS_ERROR_INVALID_PARAMETER;
1179 tts_client_s* client = tts_client_get(tts);
1181 if (NULL == client) {
1182 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1183 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1184 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1185 return TTS_ERROR_INVALID_PARAMETER;
1188 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1189 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1190 return TTS_ERROR_INVALID_STATE;
1193 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1194 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1195 return TTS_ERROR_INVALID_STATE;
1198 if (true == client->credential_needed && NULL == client->credential) {
1199 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1200 return TTS_ERROR_PERMISSION_DENIED;
1203 ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1205 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1206 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1208 return TTS_ERROR_NONE;
1211 int tts_play(tts_h tts)
1213 if (0 != __tts_get_feature_enabled()) {
1214 return TTS_ERROR_NOT_SUPPORTED;
1217 SLOG(LOG_INFO, TAG_TTSC, "===== Play tts");
1220 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1221 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1222 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1223 return TTS_ERROR_INVALID_PARAMETER;
1226 tts_client_s* client = tts_client_get(tts);
1228 if (NULL == client) {
1229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1230 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1231 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1232 return TTS_ERROR_INVALID_PARAMETER;
1235 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1236 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1237 return TTS_ERROR_INVALID_STATE;
1240 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1241 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1242 return TTS_ERROR_INVALID_STATE;
1245 if (true == client->credential_needed && NULL == client->credential) {
1246 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1247 return TTS_ERROR_PERMISSION_DENIED;
1253 ret = tts_dbus_request_play(client->uid, client->credential);
1255 if (TTS_ERROR_TIMED_OUT != ret) {
1256 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1259 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1262 if (TTS_RETRY_COUNT == count) {
1263 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1270 client->before_state = client->current_state;
1271 client->current_state = TTS_STATE_PLAYING;
1273 if (NULL != client->state_changed_cb) {
1274 tts_client_use_callback(client);
1275 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1276 tts_client_not_use_callback(client);
1277 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1280 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1281 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1283 return TTS_ERROR_NONE;
1286 static void __tts_stop_async(void *data)
1288 tts_h tts = (tts_h)data;
1289 tts_client_s* client = tts_client_get(tts);
1292 if (NULL == client) {
1293 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1300 ret = tts_dbus_request_stop(client->uid);
1302 if (TTS_ERROR_TIMED_OUT != ret) {
1303 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1306 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1309 if (TTS_RETRY_COUNT == count) {
1310 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1318 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1320 client->reason = ret;
1321 client->utt_id = -1;
1323 ecore_timer_add(0, __tts_notify_error, client->tts);
1327 client->before_state = client->current_state;
1328 client->current_state = TTS_STATE_READY;
1330 if (NULL != client->state_changed_cb) {
1331 tts_client_use_callback(client);
1332 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1333 tts_client_not_use_callback(client);
1334 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1337 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1338 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1343 int tts_stop_aync(tts_h tts)
1345 if (0 != __tts_get_feature_enabled()) {
1346 return TTS_ERROR_NOT_SUPPORTED;
1349 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1353 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1354 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1355 return TTS_ERROR_INVALID_PARAMETER;
1358 tts_client_s* client = tts_client_get(tts);
1360 if (NULL == client) {
1361 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1364 return TTS_ERROR_INVALID_PARAMETER;
1367 if (TTS_STATE_CREATED == client->current_state) {
1368 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1369 return TTS_ERROR_INVALID_STATE;
1372 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1373 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1374 return TTS_ERROR_INVALID_STATE;
1377 ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1379 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1380 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1382 return TTS_ERROR_NONE;
1385 int tts_stop(tts_h tts)
1387 if (0 != __tts_get_feature_enabled()) {
1388 return TTS_ERROR_NOT_SUPPORTED;
1391 SLOG(LOG_INFO, TAG_TTSC, "===== Stop tts");
1394 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1395 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1396 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1397 return TTS_ERROR_INVALID_PARAMETER;
1400 tts_client_s* client = tts_client_get(tts);
1402 if (NULL == client) {
1403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1404 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1405 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1406 return TTS_ERROR_INVALID_PARAMETER;
1409 if (TTS_STATE_CREATED == client->current_state) {
1410 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1411 return TTS_ERROR_INVALID_STATE;
1414 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1415 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1416 return TTS_ERROR_INVALID_STATE;
1422 ret = tts_dbus_request_stop(client->uid);
1424 if (TTS_ERROR_TIMED_OUT != ret) {
1425 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1428 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1431 if (TTS_RETRY_COUNT == count) {
1432 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1439 client->before_state = client->current_state;
1440 client->current_state = TTS_STATE_READY;
1442 if (NULL != client->state_changed_cb) {
1443 tts_client_use_callback(client);
1444 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1445 tts_client_not_use_callback(client);
1446 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1449 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1450 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1452 return TTS_ERROR_NONE;
1455 static void __tts_pause_async(void *data)
1457 tts_h tts = (tts_h)data;
1458 tts_client_s* client = tts_client_get(tts);
1461 if (NULL == client) {
1462 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1469 ret = tts_dbus_request_pause(client->uid);
1471 if (TTS_ERROR_TIMED_OUT != ret) {
1472 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1475 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1478 if (TTS_RETRY_COUNT == count) {
1479 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1487 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1489 client->reason = ret;
1490 client->utt_id = -1;
1492 ecore_timer_add(0, __tts_notify_error, client->tts);
1496 client->before_state = client->current_state;
1497 client->current_state = TTS_STATE_PAUSED;
1499 if (NULL != client->state_changed_cb) {
1500 tts_client_use_callback(client);
1501 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1502 tts_client_not_use_callback(client);
1503 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1506 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1507 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1512 int tts_pause_async(tts_h tts)
1514 if (0 != __tts_get_feature_enabled()) {
1515 return TTS_ERROR_NOT_SUPPORTED;
1518 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1521 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1522 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1523 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1524 return TTS_ERROR_INVALID_PARAMETER;
1527 tts_client_s* client = tts_client_get(tts);
1529 if (NULL == client) {
1530 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1531 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1532 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1533 return TTS_ERROR_INVALID_PARAMETER;
1536 if (TTS_STATE_PLAYING != client->current_state) {
1537 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1538 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1539 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1540 return TTS_ERROR_INVALID_STATE;
1543 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1544 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1545 return TTS_ERROR_INVALID_STATE;
1548 ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1550 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1551 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1553 return TTS_ERROR_NONE;
1556 int tts_pause(tts_h tts)
1558 if (0 != __tts_get_feature_enabled()) {
1559 return TTS_ERROR_NOT_SUPPORTED;
1562 SLOG(LOG_INFO, TAG_TTSC, "===== Pause tts");
1565 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1566 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1567 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1568 return TTS_ERROR_INVALID_PARAMETER;
1571 tts_client_s* client = tts_client_get(tts);
1573 if (NULL == client) {
1574 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1575 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1576 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1577 return TTS_ERROR_INVALID_PARAMETER;
1580 if (TTS_STATE_PLAYING != client->current_state) {
1581 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1582 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1583 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1584 return TTS_ERROR_INVALID_STATE;
1587 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1588 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1589 return TTS_ERROR_INVALID_STATE;
1595 ret = tts_dbus_request_pause(client->uid);
1597 if (TTS_ERROR_TIMED_OUT != ret) {
1598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1601 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1604 if (TTS_RETRY_COUNT == count) {
1605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1612 client->before_state = client->current_state;
1613 client->current_state = TTS_STATE_PAUSED;
1615 if (NULL != client->state_changed_cb) {
1616 tts_client_use_callback(client);
1617 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1618 tts_client_not_use_callback(client);
1619 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1622 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1623 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1625 return TTS_ERROR_NONE;
1628 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1630 if (0 != __tts_get_feature_enabled()) {
1631 return TTS_ERROR_NOT_SUPPORTED;
1634 SLOG(LOG_INFO, TAG_TTSC, "===== Set private data, key(%s), data(%s)", key, data);
1637 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1638 return TTS_ERROR_INVALID_PARAMETER;
1641 if (NULL == key || NULL == data) {
1642 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1643 return TTS_ERROR_INVALID_PARAMETER;
1646 tts_client_s* client = tts_client_get(tts);
1648 if (NULL == client) {
1649 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1650 return TTS_ERROR_INVALID_PARAMETER;
1653 if (TTS_STATE_READY != client->current_state) {
1654 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1655 return TTS_ERROR_INVALID_STATE;
1658 if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1659 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1660 return TTS_ERROR_INVALID_PARAMETER;
1666 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1668 if (TTS_ERROR_TIMED_OUT != ret) {
1669 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1672 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1675 if (TTS_RETRY_COUNT == count) {
1676 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1683 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1684 SLOG(LOG_DEBUG, TAG_TTSC, "");
1689 int tts_get_private_data(tts_h tts, const char* key, char** data)
1691 if (0 != __tts_get_feature_enabled()) {
1692 return TTS_ERROR_NOT_SUPPORTED;
1695 SLOG(LOG_INFO, TAG_TTSC, "===== Get private data, key(%s)", key);
1698 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1699 return TTS_ERROR_INVALID_PARAMETER;
1702 if (NULL == key || NULL == data) {
1703 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1704 return TTS_ERROR_INVALID_PARAMETER;
1707 tts_client_s* client = tts_client_get(tts);
1709 if (NULL == client) {
1710 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1711 return TTS_ERROR_INVALID_PARAMETER;
1714 if (TTS_STATE_READY != client->current_state) {
1715 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1716 return TTS_ERROR_INVALID_STATE;
1722 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1724 if (TTS_ERROR_TIMED_OUT != ret) {
1725 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1728 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1731 if (TTS_RETRY_COUNT == count) {
1732 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1739 if (0 == strncmp(*data, "NULL", strlen(*data))) {
1744 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1745 SLOG(LOG_DEBUG, TAG_TTSC, "");
1750 static Eina_Bool __tts_notify_error(void *data)
1752 tts_h tts = (tts_h)data;
1754 tts_client_s* client = tts_client_get(tts);
1757 if (NULL == client) {
1758 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1762 SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1764 if (NULL != client->error_cb) {
1765 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1766 tts_client_use_callback(client);
1767 g_err_callback_status = true;
1768 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1769 g_err_callback_status = false;
1770 tts_client_not_use_callback(client);
1772 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1778 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1781 GList* client_list = NULL;
1782 client_list = tts_client_get_client_list();
1785 tts_client_s *data = NULL;
1787 if (g_list_length(client_list) > 0) {
1788 /* Get a first item */
1789 iter = g_list_first(client_list);
1791 while (NULL != iter) {
1794 data->utt_id = utt_id;
1795 data->reason = reason;
1796 if (NULL != data->err_msg) {
1797 free(data->err_msg);
1798 data->err_msg = NULL;
1800 if (NULL != err_msg)
1801 data->err_msg = strdup(err_msg);
1803 /* call callback function */
1804 if (NULL != data->error_cb) {
1805 ecore_timer_add(0, __tts_notify_error, data->tts);
1807 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1810 if (TTS_ERROR_SERVICE_RESET == reason) {
1811 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1813 data->current_state = TTS_STATE_CREATED;
1814 if (0 != tts_prepare(data->tts)) {
1815 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1820 iter = g_list_next(iter);
1824 tts_client_s* client = tts_client_get_by_uid(uid);
1826 if (NULL == client) {
1827 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1828 return TTS_ERROR_INVALID_PARAMETER;
1831 client->utt_id = utt_id;
1832 client->reason = reason;
1833 if (NULL != client->err_msg) {
1834 free(client->err_msg);
1835 client->err_msg = NULL;
1837 if (NULL != err_msg)
1838 client->err_msg = strdup(err_msg);
1840 /* call callback function */
1841 if (NULL != client->error_cb) {
1842 ecore_timer_add(0, __tts_notify_error, client->tts);
1844 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1847 if (TTS_ERROR_SERVICE_RESET == reason) {
1848 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1850 client->current_state = TTS_STATE_CREATED;
1851 if (0 != tts_prepare(client->tts)) {
1852 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1860 static Eina_Bool __tts_notify_state_changed(void *data)
1862 tts_h tts = (tts_h)data;
1864 tts_client_s* client = tts_client_get(tts);
1867 if (NULL == client) {
1868 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1872 if (NULL != client->state_changed_cb) {
1873 tts_client_use_callback(client);
1874 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1875 tts_client_not_use_callback(client);
1876 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1878 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1884 int __tts_cb_set_state(int uid, int state)
1886 tts_client_s* client = tts_client_get_by_uid(uid);
1887 if (NULL == client) {
1888 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1892 tts_state_e state_from_daemon = (tts_state_e)state;
1894 if (client->current_state == state_from_daemon) {
1895 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1899 if (NULL != client->state_changed_cb) {
1900 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1902 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1905 client->before_state = client->current_state;
1906 client->current_state = state_from_daemon;
1911 int __tts_cb_utt_started(int uid, int utt_id)
1913 tts_client_s* client = tts_client_get_by_uid(uid);
1915 if (NULL == client) {
1916 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1917 return TTS_ERROR_INVALID_PARAMETER;
1920 SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1922 client->utt_id = utt_id;
1924 /* call callback function */
1925 if (NULL != client->utt_started_cb) {
1926 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1927 tts_client_use_callback(client);
1928 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1929 tts_client_not_use_callback(client);
1931 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1937 int __tts_cb_utt_completed(int uid, int utt_id)
1939 tts_client_s* client = tts_client_get_by_uid(uid);
1941 if (NULL == client) {
1942 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1943 return TTS_ERROR_INVALID_PARAMETER;
1946 SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1948 client->utt_id = utt_id;
1950 /* call callback function */
1951 if (NULL != client->utt_completeted_cb) {
1952 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1953 tts_client_use_callback(client);
1954 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1955 tts_client_not_use_callback(client);
1957 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1963 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1965 if (0 != __tts_get_feature_enabled()) {
1966 return TTS_ERROR_NOT_SUPPORTED;
1969 if (NULL == tts || NULL == callback) {
1970 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1971 return TTS_ERROR_INVALID_PARAMETER;
1974 tts_client_s* client = tts_client_get(tts);
1976 if (NULL == client) {
1977 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1978 return TTS_ERROR_INVALID_PARAMETER;
1981 if (TTS_STATE_CREATED != client->current_state) {
1982 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1983 return TTS_ERROR_INVALID_STATE;
1986 client->state_changed_cb = callback;
1987 client->state_changed_user_data = user_data;
1989 SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
1994 int tts_unset_state_changed_cb(tts_h tts)
1996 if (0 != __tts_get_feature_enabled()) {
1997 return TTS_ERROR_NOT_SUPPORTED;
2001 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2002 return TTS_ERROR_INVALID_PARAMETER;
2005 tts_client_s* client = tts_client_get(tts);
2007 if (NULL == client) {
2008 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2009 return TTS_ERROR_INVALID_PARAMETER;
2012 if (TTS_STATE_CREATED != client->current_state) {
2013 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2014 return TTS_ERROR_INVALID_STATE;
2017 client->state_changed_cb = NULL;
2018 client->state_changed_user_data = NULL;
2020 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2025 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2027 if (0 != __tts_get_feature_enabled()) {
2028 return TTS_ERROR_NOT_SUPPORTED;
2031 if (NULL == tts || NULL == callback) {
2032 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2033 return TTS_ERROR_INVALID_PARAMETER;
2036 tts_client_s* client = tts_client_get(tts);
2038 if (NULL == client) {
2039 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2040 return TTS_ERROR_INVALID_PARAMETER;
2043 if (TTS_STATE_CREATED != client->current_state) {
2044 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2045 return TTS_ERROR_INVALID_STATE;
2048 client->utt_started_cb = callback;
2049 client->utt_started_user_data = user_data;
2051 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2056 int tts_unset_utterance_started_cb(tts_h tts)
2058 if (0 != __tts_get_feature_enabled()) {
2059 return TTS_ERROR_NOT_SUPPORTED;
2063 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2064 return TTS_ERROR_INVALID_PARAMETER;
2067 tts_client_s* client = tts_client_get(tts);
2069 if (NULL == client) {
2070 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2071 return TTS_ERROR_INVALID_PARAMETER;
2074 if (TTS_STATE_CREATED != client->current_state) {
2075 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2076 return TTS_ERROR_INVALID_STATE;
2079 client->utt_started_cb = NULL;
2080 client->utt_started_user_data = NULL;
2082 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2087 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2089 if (0 != __tts_get_feature_enabled()) {
2090 return TTS_ERROR_NOT_SUPPORTED;
2093 if (NULL == tts || NULL == callback) {
2094 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2095 return TTS_ERROR_INVALID_PARAMETER;
2098 tts_client_s* client = tts_client_get(tts);
2100 if (NULL == client) {
2101 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2102 return TTS_ERROR_INVALID_PARAMETER;
2105 if (TTS_STATE_CREATED != client->current_state) {
2106 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2107 return TTS_ERROR_INVALID_STATE;
2110 client->utt_completeted_cb = callback;
2111 client->utt_completed_user_data = user_data;
2113 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2118 int tts_unset_utterance_completed_cb(tts_h tts)
2120 if (0 != __tts_get_feature_enabled()) {
2121 return TTS_ERROR_NOT_SUPPORTED;
2125 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2126 return TTS_ERROR_INVALID_PARAMETER;
2129 tts_client_s* client = tts_client_get(tts);
2131 if (NULL == client) {
2132 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2133 return TTS_ERROR_INVALID_PARAMETER;
2136 if (TTS_STATE_CREATED != client->current_state) {
2137 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2138 return TTS_ERROR_INVALID_STATE;
2141 client->utt_completeted_cb = NULL;
2142 client->utt_completed_user_data = NULL;
2144 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2148 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2150 if (0 != __tts_get_feature_enabled()) {
2151 return TTS_ERROR_NOT_SUPPORTED;
2154 if (NULL == tts || NULL == callback) {
2155 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2156 return TTS_ERROR_INVALID_PARAMETER;
2159 tts_client_s* client = tts_client_get(tts);
2161 if (NULL == client) {
2162 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2163 return TTS_ERROR_INVALID_PARAMETER;
2166 if (TTS_STATE_CREATED != client->current_state) {
2167 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2168 return TTS_ERROR_INVALID_STATE;
2171 client->error_cb = callback;
2172 client->error_user_data = user_data;
2174 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2179 int tts_unset_error_cb(tts_h tts)
2181 if (0 != __tts_get_feature_enabled()) {
2182 return TTS_ERROR_NOT_SUPPORTED;
2186 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2187 return TTS_ERROR_INVALID_PARAMETER;
2190 tts_client_s* client = tts_client_get(tts);
2192 if (NULL == client) {
2193 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2194 return TTS_ERROR_INVALID_PARAMETER;
2197 if (TTS_STATE_CREATED != client->current_state) {
2198 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2199 return TTS_ERROR_INVALID_STATE;
2202 client->error_cb = NULL;
2203 client->error_user_data = NULL;
2205 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2210 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2212 if (0 != __tts_get_feature_enabled()) {
2213 return TTS_ERROR_NOT_SUPPORTED;
2216 if (NULL == tts || NULL == callback) {
2217 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2218 return TTS_ERROR_INVALID_PARAMETER;
2221 tts_client_s* client = tts_client_get(tts);
2223 if (NULL == client) {
2224 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2225 return TTS_ERROR_INVALID_PARAMETER;
2228 if (TTS_STATE_CREATED != client->current_state) {
2229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2230 return TTS_ERROR_INVALID_STATE;
2233 client->default_voice_changed_cb = callback;
2234 client->default_voice_changed_user_data = user_data;
2236 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2241 int tts_unset_default_voice_changed_cb(tts_h tts)
2243 if (0 != __tts_get_feature_enabled()) {
2244 return TTS_ERROR_NOT_SUPPORTED;
2248 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2249 return TTS_ERROR_INVALID_PARAMETER;
2252 tts_client_s* client = tts_client_get(tts);
2254 if (NULL == client) {
2255 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2256 return TTS_ERROR_INVALID_PARAMETER;
2259 if (TTS_STATE_CREATED != client->current_state) {
2260 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2261 return TTS_ERROR_INVALID_STATE;
2264 client->default_voice_changed_cb = NULL;
2265 client->default_voice_changed_user_data = NULL;
2267 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2272 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2274 if (0 != __tts_get_feature_enabled()) {
2275 return TTS_ERROR_NOT_SUPPORTED;
2278 if (NULL == tts || NULL == callback) {
2279 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2280 return TTS_ERROR_INVALID_PARAMETER;
2283 tts_client_s* client = tts_client_get(tts);
2285 if (NULL == client) {
2286 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2287 return TTS_ERROR_INVALID_PARAMETER;
2290 if (TTS_STATE_CREATED != client->current_state) {
2291 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2292 return TTS_ERROR_INVALID_STATE;
2295 client->engine_changed_cb = callback;
2296 client->engine_changed_user_data = user_data;
2298 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2303 int tts_unset_engine_changed_cb(tts_h tts)
2305 if (0 != __tts_get_feature_enabled()) {
2306 return TTS_ERROR_NOT_SUPPORTED;
2310 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2311 return TTS_ERROR_INVALID_PARAMETER;
2314 tts_client_s* client = tts_client_get(tts);
2316 if (NULL == client) {
2317 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2318 return TTS_ERROR_INVALID_PARAMETER;
2321 if (TTS_STATE_CREATED != client->current_state) {
2322 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2323 return TTS_ERROR_INVALID_STATE;
2326 client->engine_changed_cb = NULL;
2327 client->engine_changed_user_data = NULL;
2329 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2334 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2336 if (0 != __tts_get_feature_enabled()) {
2337 return TTS_ERROR_NOT_SUPPORTED;
2340 SLOG(LOG_INFO, TAG_TTSC, "===== Add pcm tts");
2343 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2344 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2345 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2346 return TTS_ERROR_INVALID_PARAMETER;
2349 tts_client_s* client = tts_client_get(tts);
2351 if (NULL == client) {
2352 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2353 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2354 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2355 return TTS_ERROR_INVALID_PARAMETER;
2358 if (TTS_STATE_PLAYING != client->current_state) {
2359 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2360 return TTS_ERROR_INVALID_STATE;
2363 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2364 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2365 return TTS_ERROR_INVALID_STATE;
2371 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2373 if (TTS_ERROR_TIMED_OUT != ret) {
2374 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2377 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2380 if (TTS_RETRY_COUNT == count) {
2381 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2388 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2389 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2391 return TTS_ERROR_NONE;
2394 int tts_play_pcm(tts_h tts)
2396 if (0 != __tts_get_feature_enabled()) {
2397 return TTS_ERROR_NOT_SUPPORTED;
2400 SLOG(LOG_INFO, TAG_TTSC, "===== Play pcm tts");
2403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2404 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2405 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2406 return TTS_ERROR_INVALID_PARAMETER;
2409 tts_client_s* client = tts_client_get(tts);
2411 if (NULL == client) {
2412 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2413 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2414 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2415 return TTS_ERROR_INVALID_PARAMETER;
2418 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2419 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2420 return TTS_ERROR_INVALID_STATE;
2423 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2424 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2425 return TTS_ERROR_INVALID_STATE;
2431 ret = tts_dbus_request_play_pcm(client->uid);
2433 if (TTS_ERROR_TIMED_OUT != ret) {
2434 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2437 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2440 if (TTS_RETRY_COUNT == count) {
2441 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2448 client->before_state = client->current_state;
2449 client->current_state = TTS_STATE_PLAYING;
2451 if (NULL != client->state_changed_cb) {
2452 tts_client_use_callback(client);
2453 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2454 tts_client_not_use_callback(client);
2455 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2458 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2459 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2461 return TTS_ERROR_NONE;
2464 int tts_stop_pcm(tts_h tts)
2466 if (0 != __tts_get_feature_enabled()) {
2467 return TTS_ERROR_NOT_SUPPORTED;
2470 SLOG(LOG_INFO, TAG_TTSC, "===== Stop pcm tts");
2473 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2474 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2475 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2476 return TTS_ERROR_INVALID_PARAMETER;
2479 tts_client_s* client = tts_client_get(tts);
2481 if (NULL == client) {
2482 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2483 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2484 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2485 return TTS_ERROR_INVALID_PARAMETER;
2488 if (TTS_STATE_PLAYING != client->current_state) {
2489 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2490 return TTS_ERROR_INVALID_STATE;
2493 if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2494 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2495 return TTS_ERROR_INVALID_STATE;
2501 ret = tts_dbus_request_stop_pcm(client->uid);
2503 if (TTS_ERROR_TIMED_OUT != ret) {
2504 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2507 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2510 if (TTS_RETRY_COUNT == count) {
2511 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2518 client->before_state = client->current_state;
2519 client->current_state = TTS_STATE_READY;
2521 if (NULL != client->state_changed_cb) {
2522 tts_client_use_callback(client);
2523 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2524 tts_client_not_use_callback(client);
2525 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2528 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
2529 SLOG(LOG_DEBUG, TAG_TTSC, " ");
2531 return TTS_ERROR_NONE;