X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=client%2Ftts.c;h=6e80252342cc02341f0e4d51295160ba37ee4d16;hb=187489e8896ab8c8fa35fdbe5ef2edc952ab4253;hp=254cabc64aa97760b77128a251175fb004d1d3d1;hpb=9050a59fe06f4a71ec437df7de159e351fb92f5a;p=platform%2Fcore%2Fuifw%2Ftts.git diff --git a/client/tts.c b/client/tts.c index 254cabc..6e80252 100644 --- a/client/tts.c +++ b/client/tts.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -11,6 +11,7 @@ * limitations under the License. */ +#include #include #include #include @@ -27,12 +28,12 @@ #include "tts_main.h" -static Ecore_Timer* g_connect_timer = NULL; - static bool g_screen_reader; static int g_feature_enabled = -1; +static bool g_err_callback_status = false; + /* Function definition */ static Eina_Bool __tts_notify_state_changed(void *data); static Eina_Bool __tts_notify_error(void *data); @@ -82,6 +83,8 @@ static const char* __tts_get_error_code(tts_error_e err) case TTS_ERROR_ENGINE_NOT_FOUND: return "TTS_ERROR_ENGINE_NOT_FOUND"; case TTS_ERROR_OPERATION_FAILED: return "TTS_ERROR_OPERATION_FAILED"; case TTS_ERROR_AUDIO_POLICY_BLOCKED: return "TTS_ERROR_AUDIO_POLICY_BLOCKED"; + case TTS_ERROR_NOT_SUPPORTED_FEATURE: return "TTS_ERROR_NOT_SUPPORTED_FEATURE"; + case TTS_ERROR_SERVICE_RESET: return "TTS_ERROR_SERVICE_RESET"; default: return "Invalid error code"; } @@ -98,7 +101,7 @@ static int __tts_convert_config_error_code(tts_config_error_e code) if (code == TTS_CONFIG_ERROR_INVALID_VOICE) return TTS_ERROR_INVALID_VOICE; if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND) return TTS_ERROR_ENGINE_NOT_FOUND; if (code == TTS_CONFIG_ERROR_OPERATION_FAILED) return TTS_ERROR_OPERATION_FAILED; - if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_OPERATION_FAILED; + if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE) return TTS_ERROR_NOT_SUPPORTED_FEATURE; return code; } @@ -134,6 +137,30 @@ void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_typ return; } +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) +{ + tts_h tts = (tts_h)user_data; + + tts_client_s* client = tts_client_get(tts); + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid"); + return; + } + + if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id); + if (NULL != setting) SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting); + if (NULL != language) SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language); + SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need"); + + /* call callback function */ + if (NULL != client->engine_changed_cb) { + client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine"); + } + return; +} + int tts_create(tts_h* tts) { if (0 != __tts_get_feature_enabled()) { @@ -175,7 +202,7 @@ int tts_create(tts_h* tts) return __tts_convert_config_error_code(ret); } - ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL); + ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL); if (0 != ret) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret); tts_client_destroy(*tts); @@ -251,9 +278,10 @@ int tts_destroy(tts_h tts) client->current_state = TTS_STATE_CREATED; case TTS_STATE_CREATED: - if (NULL != g_connect_timer) { + if (NULL != client->conn_timer) { SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted"); - ecore_timer_del(g_connect_timer); + ecore_timer_del(client->conn_timer); + client->conn_timer = NULL; } /* Free resources */ tts_client_destroy(tts); @@ -376,6 +404,117 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode) return TTS_ERROR_NONE; } +int tts_set_credential(tts_h tts, const char* credential) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + if (NULL == tts || NULL == credential) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state); + return TTS_ERROR_INVALID_STATE; + } + + if (NULL != client->credential) { + free(client->credential); + client->credential = NULL; + } + client->credential = strdup(credential); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_ERROR_NONE; +} + +int tts_set_server_tts(tts_h tts, const char* credential) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + if (NULL == tts) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state); + return TTS_ERROR_INVALID_STATE; + } + + if (NULL != client->credential) { + free(client->credential); + client->credential = NULL; + } + + client->internal = true; + + char* key = NULL; + if (NULL != credential) { + key = strdup("EnableServerTTS"); + client->credential = strdup(credential); + if (NULL == client->credential) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory"); + return TTS_ERROR_OUT_OF_MEMORY; + } + } else { + key = strdup("DisableServerTTS"); + } + + if (NULL == key) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory"); + return TTS_ERROR_OUT_OF_MEMORY; + } + + int pid = getpid(); + char* appid = NULL; + int ret = app_manager_get_app_id(pid, &appid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid); + free(key); + key = NULL; + return TTS_ERROR_OPERATION_FAILED; + } + + ret = tts_set_private_data(tts, key, appid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid); + free(key); + key = NULL; + return ret; + } + + free(appid); + appid = NULL; + free(key); + key = NULL; + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_ERROR_NONE; +} + static Eina_Bool __tts_connect_daemon(void *data) { tts_h tts = (tts_h)data; @@ -384,7 +523,6 @@ static Eina_Bool __tts_connect_daemon(void *data) /* check handle */ if (NULL == client) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); - g_connect_timer = NULL; return EINA_FALSE; } @@ -397,7 +535,9 @@ static Eina_Bool __tts_connect_daemon(void *data) /* do request initialize */ int ret = -1; - ret = tts_dbus_request_initialize(client->uid); + bool credential_needed = false; + + ret = tts_dbus_request_initialize(client->uid, &credential_needed); if (TTS_ERROR_ENGINE_NOT_FOUND == ret) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret)); @@ -406,7 +546,7 @@ static Eina_Bool __tts_connect_daemon(void *data) client->utt_id = -1; ecore_timer_add(0, __tts_notify_error, (void*)client->tts); - g_connect_timer = NULL; + client->conn_timer = NULL; return EINA_FALSE; } else if (TTS_ERROR_NONE != ret) { @@ -415,9 +555,11 @@ static Eina_Bool __tts_connect_daemon(void *data) } else { /* success to connect tts-daemon */ + client->credential_needed = credential_needed; + SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need"); } - g_connect_timer = NULL; + client->conn_timer = NULL; client = tts_client_get(tts); /* check handle */ @@ -469,7 +611,7 @@ int tts_prepare(tts_h tts) return TTS_ERROR_INVALID_STATE; } - g_connect_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts); + client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -704,11 +846,11 @@ int tts_get_state(tts_h tts, tts_state_e* state) *state = client->current_state; switch (*state) { - case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break; - case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break; - case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break; - case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break; - default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break; + case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break; + case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break; + case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break; + case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break; + default: SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value"); break; } return TTS_ERROR_NONE; @@ -739,8 +881,41 @@ int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max) return TTS_ERROR_NONE; } +int tts_get_error_message(tts_h tts, char** err_msg) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + if (NULL == tts || NULL == err_msg) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL != client->err_msg) { + *err_msg = strdup(client->err_msg); + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg); + } else { + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)"); + } + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_ERROR_NONE; +} + int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id) { + SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type); + if (0 != __tts_get_feature_enabled()) { return TTS_ERROR_NOT_SUPPORTED; } @@ -797,6 +972,11 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty return TTS_ERROR_INVALID_STATE; } + if (true == client->credential_needed && NULL == client->credential) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine"); + return TTS_ERROR_PERMISSION_DENIED; + } + /* check valid utf8 */ iconv_t *ict; ict = iconv_open("utf-8", ""); @@ -846,7 +1026,7 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty int ret = -1; int count = 0; while (0 != ret) { - ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id); + ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential); if (0 != ret) { if (TTS_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret)); @@ -855,7 +1035,7 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret)); usleep(10000); count++; - if (TTS_RETRY_COUNT == count) { + if (TTS_RETRY_MIN_COUNT == count) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request"); break; } @@ -887,7 +1067,7 @@ static void __tts_play_async(void *data) int ret = -1; int count = 0; while (0 != ret) { - ret = tts_dbus_request_play(client->uid); + ret = tts_dbus_request_play(client->uid, client->credential); if (0 != ret) { if (TTS_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret)); @@ -964,6 +1144,11 @@ int tts_play_async(tts_h tts) return TTS_ERROR_INVALID_STATE; } + if (true == client->credential_needed && NULL == client->credential) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine"); + return TTS_ERROR_PERMISSION_DENIED; + } + ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts); SLOG(LOG_DEBUG, TAG_TTSC, "====="); @@ -1006,10 +1191,15 @@ int tts_play(tts_h tts) return TTS_ERROR_INVALID_STATE; } + if (true == client->credential_needed && NULL == client->credential) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine"); + return TTS_ERROR_PERMISSION_DENIED; + } + int ret = -1; int count = 0; while (0 != ret) { - ret = tts_dbus_request_play(client->uid); + ret = tts_dbus_request_play(client->uid, client->credential); if (0 != ret) { if (TTS_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret)); @@ -1384,6 +1574,128 @@ int tts_pause(tts_h tts) return TTS_ERROR_NONE; } +int tts_set_private_data(tts_h tts, const char* key, const char* data) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data"); + + if (NULL == tts) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'"); + return TTS_ERROR_INVALID_STATE; + } + + if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app"); + return TTS_ERROR_INVALID_PARAMETER; + } + + int ret = -1; + int count = 0; + while (0 != ret) { + ret = tts_dbus_request_set_private_data(client->uid, key, data); + if (0 != ret) { + if (TTS_ERROR_TIMED_OUT != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret)); + return ret; + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret)); + usleep(10000); + count++; + if (TTS_RETRY_COUNT == count) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request"); + return ret; + } + } + } + } + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, ""); + + return 0; +} + +int tts_get_private_data(tts_h tts, const char* key, char** data) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data"); + + if (NULL == tts) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'"); + return TTS_ERROR_INVALID_STATE; + } + + int ret = -1; + int count = 0; + while (0 != ret) { + ret = tts_dbus_request_get_private_data(client->uid, key, data); + if (0 != ret) { + if (TTS_ERROR_TIMED_OUT != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret)); + return ret; + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret)); + usleep(10000); + count++; + if (TTS_RETRY_COUNT == count) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request"); + return ret; + } + } + } + } + + if (0 == strncmp(*data, "NULL", strlen(*data))) { + free(*data); + *data = NULL; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, ""); + + return 0; +} + static Eina_Bool __tts_notify_error(void *data) { tts_h tts = (tts_h)data; @@ -1401,7 +1713,9 @@ static Eina_Bool __tts_notify_error(void *data) if (NULL != client->error_cb) { SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error"); tts_client_use_callback(client); + g_err_callback_status = true; client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data); + g_err_callback_status = false; tts_client_not_use_callback(client); } else { SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error "); @@ -1410,23 +1724,83 @@ static Eina_Bool __tts_notify_error(void *data) return EINA_FALSE; } -int __tts_cb_error(int uid, tts_error_e reason, int utt_id) +int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg) { - tts_client_s* client = tts_client_get_by_uid(uid); + if (-1 == uid) { + GList* client_list = NULL; + client_list = tts_client_get_client_list(); - if (NULL == client) { - SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid"); - return TTS_ERROR_INVALID_PARAMETER; - } + GList *iter = NULL; + tts_client_s *data = NULL; - client->utt_id = utt_id; - client->reason = reason; + if (g_list_length(client_list) > 0) { + /* Get a first item */ + iter = g_list_first(client_list); - /* call callback function */ - if (NULL != client->error_cb) { - ecore_timer_add(0, __tts_notify_error, client->tts); + while (NULL != iter) { + data = iter->data; + + data->utt_id = utt_id; + data->reason = reason; + if (NULL != data->err_msg) { + free(data->err_msg); + data->err_msg = NULL; + } + if (NULL != err_msg) + data->err_msg = strdup(err_msg); + + /* call callback function */ + if (NULL != data->error_cb) { + ecore_timer_add(0, __tts_notify_error, data->tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error "); + } + + if (TTS_ERROR_SERVICE_RESET == reason) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset"); + + data->current_state = TTS_STATE_CREATED; + if (0 != tts_prepare(data->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare"); + } + } + + /* Next item */ + iter = g_list_next(iter); + } + } } else { - SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error "); + tts_client_s* client = tts_client_get_by_uid(uid); + + if (NULL == client) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + client->utt_id = utt_id; + client->reason = reason; + if (NULL != client->err_msg) { + free(client->err_msg); + client->err_msg = NULL; + } + if (NULL != err_msg) + client->err_msg = strdup(err_msg); + + /* call callback function */ + if (NULL != client->error_cb) { + ecore_timer_add(0, __tts_notify_error, client->tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error "); + } + + if (TTS_ERROR_SERVICE_RESET == reason) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset"); + + client->current_state = TTS_STATE_CREATED; + if (0 != tts_prepare(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare"); + } + } } return 0; @@ -1843,3 +2217,66 @@ int tts_unset_default_voice_changed_cb(tts_h tts) return 0; } + +int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + if (NULL == tts || NULL == callback) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'."); + return TTS_ERROR_INVALID_STATE; + } + + client->engine_changed_cb = callback; + client->engine_changed_user_data = user_data; + + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb"); + + return 0; +} + +int tts_unset_engine_changed_cb(tts_h tts) +{ + if (0 != __tts_get_feature_enabled()) { + return TTS_ERROR_NOT_SUPPORTED; + } + + if (NULL == tts) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null"); + return TTS_ERROR_INVALID_PARAMETER; + } + + tts_client_s* client = tts_client_get(tts); + + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid"); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'."); + return TTS_ERROR_INVALID_STATE; + } + + client->engine_changed_cb = NULL; + client->engine_changed_user_data = NULL; + + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb"); + + return 0; +} +