From 4b6657ae814c0fe0337895f5a521216594cb01ad Mon Sep 17 00:00:00 2001 From: Suyeon Hwang Date: Wed, 21 Oct 2020 19:53:12 +0900 Subject: [PATCH] Introduce tts_core.h/c as genral logic layer tts_core.c/h includes most of general logic to implement TTS FW. This patch introduces tts_core.c/h as a first step of refactoring client module. And also, this patch refactors logic to call client callback. Change-Id: I28428a7c6eca4522c960974f4a0183d327d97f17 Signed-off-by: Suyeon Hwang --- client/CMakeLists.txt | 3 +- client/tts.c | 147 +++++----------------------------- client/tts_core.c | 216 ++++++++++++++++++++++++++++++++++++++++++++++++++ client/tts_core.h | 37 +++++++++ 4 files changed, 274 insertions(+), 129 deletions(-) create mode 100644 client/tts_core.c create mode 100644 client/tts_core.h diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 6b6d9b6..0ce79cc 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -1,5 +1,6 @@ -SET(SRCS +SET(SRCS tts.c + tts_core.c tts_client.c tts_dbus.c ../common/tts_config_mgr.c diff --git a/client/tts.c b/client/tts.c index 3f6a1be..2ccd665 100644 --- a/client/tts.c +++ b/client/tts.c @@ -28,6 +28,7 @@ #include "tts_config_mgr.h" #include "tts_dbus.h" #include "tts_main.h" +#include "tts_core.h" #include "tts_internal.h" @@ -35,8 +36,6 @@ static bool g_screen_reader; static int g_feature_enabled = -1; -static bool g_err_callback_status = false; - static int g_max_text_size = -1; static Ecore_Timer* g_check_state_timer = NULL; @@ -158,11 +157,7 @@ void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_typ while (NULL != iter) { data = iter->data; - if (NULL != data->default_voice_changed_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid); - data->default_voice_changed_cb(data->tts, before_lang, before_voice_type, - language, voice_type, data->default_voice_changed_user_data); - } + tts_core_notify_default_voice_changed(data, before_lang, before_voice_type, language, voice_type); /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */ if (0 != strncmp(before_lang, language, strlen(before_lang))) { @@ -246,11 +241,7 @@ void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, c } /* 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"); - } + tts_core_notify_engine_changed(client, engine_id, language, voice_type, need_credential); return; } //LCOV_EXCL_STOP @@ -1049,12 +1040,8 @@ static Eina_Bool __tts_connect_daemon(void *data) client->before_state = client->current_state; client->current_state = TTS_STATE_READY; - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - } else { - SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL"); + if (0 != tts_core_notify_state_changed(client, client->before_state, client->current_state)) { + return EINA_FALSE; } SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -1408,12 +1395,7 @@ int tts_unprepare(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_CREATED; - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -1424,19 +1406,8 @@ bool __tts_supported_voice_cb(const char* engine_id, const char* language, int t { 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 false; - } - /* call callback function */ - if (NULL != client->supported_voice_cb) { - return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data); - } else { - SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice"); - } - + tts_core_notify_supported_voice(tts_client_get(tts), language, type); return false; } @@ -1914,13 +1885,7 @@ static void __tts_play_async(void *data) client->before_state = client->current_state; client->current_state = TTS_STATE_PLAYING; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2061,13 +2026,7 @@ int tts_play(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_PLAYING; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2128,13 +2087,7 @@ static void __tts_stop_async(void *data) client->before_state = client->current_state; client->current_state = TTS_STATE_READY; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2263,13 +2216,7 @@ int tts_stop(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_READY; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2330,13 +2277,7 @@ static void __tts_pause_async(void *data) client->before_state = client->current_state; client->current_state = TTS_STATE_PAUSED; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2466,13 +2407,7 @@ int tts_pause(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_PAUSED; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -2633,16 +2568,7 @@ static Eina_Bool __tts_notify_error(void *data) SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason)); - 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 "); - } + tts_core_notify_error(client, client->utt_id, client->reason); g_notify_error_timer = NULL; @@ -2857,14 +2783,7 @@ static Eina_Bool __tts_notify_state_changed(void *data) return EINA_FALSE; } - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state); - } else { - SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); g_check_state_timer = NULL; @@ -2915,16 +2834,7 @@ int __tts_cb_utt_started(int uid, int utt_id) SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id); client->utt_id = utt_id; - - /* call callback function */ - if (NULL != client->utt_started_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started "); - tts_client_use_callback(client); - client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data); - tts_client_not_use_callback(client); - } else { - SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started "); - } + tts_core_notify_utt_started(client, client->utt_id); return 0; } @@ -2943,14 +2853,7 @@ int __tts_cb_utt_completed(int uid, int utt_id) client->utt_id = utt_id; /* call callback function */ - if (NULL != client->utt_completed_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed "); - tts_client_use_callback(client); - client->utt_completed_cb(client->tts, client->utt_id, client->utt_completed_user_data); - tts_client_not_use_callback(client); - } else { - SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed "); - } + tts_core_notify_utt_completeted(client, client->utt_id); return 0; } @@ -3477,13 +3380,7 @@ int tts_play_pcm(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_PLAYING; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); @@ -3561,13 +3458,7 @@ int tts_stop_pcm(tts_h tts) client->before_state = client->current_state; client->current_state = TTS_STATE_READY; - - if (NULL != client->state_changed_cb) { - tts_client_use_callback(client); - client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); - tts_client_not_use_callback(client); - SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); - } + tts_core_notify_state_changed(client, client->before_state, client->current_state); SLOG(LOG_DEBUG, TAG_TTSC, "@@@"); diff --git a/client/tts_core.c b/client/tts_core.c new file mode 100644 index 0000000..69a3d2c --- /dev/null +++ b/client/tts_core.c @@ -0,0 +1,216 @@ +/* +* Copyright (c) 2020 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 +* http://www.apache.org/licenses/LICENSE-2.0 +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "tts_defs.h" +#include "tts_core.h" + +/* Static variables */ + +/* Static functions */ +static const char* __tts_get_error_code(tts_error_e err) +{ + switch (err) { + case TTS_ERROR_NONE: return "TTS_ERROR_NONE"; + case TTS_ERROR_OUT_OF_MEMORY: return "TTS_ERROR_OUT_OF_MEMORY"; + case TTS_ERROR_IO_ERROR: return "TTS_ERROR_IO_ERROR"; + case TTS_ERROR_INVALID_PARAMETER: return "TTS_ERROR_INVALID_PARAMETER"; + case TTS_ERROR_OUT_OF_NETWORK: return "TTS_ERROR_OUT_OF_NETWORK"; + case TTS_ERROR_TIMED_OUT: return "TTS_ERROR_TIMED_OUT"; + case TTS_ERROR_PERMISSION_DENIED: return "TTS_ERROR_PERMISSION_DENIED"; + case TTS_ERROR_NOT_SUPPORTED: return "TTS_ERROR_NOT_SUPPORTED"; + case TTS_ERROR_INVALID_STATE: return "TTS_ERROR_INVALID_STATE"; + case TTS_ERROR_INVALID_VOICE: return "TTS_ERROR_INVALID_VOICE"; + 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"; + } + return NULL; +} + +/* Public functions */ +int tts_core_notify_state_changed(tts_client_s* client, tts_state_e before_state, tts_state_e current_state) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "State changed data : before_state(%d) curret_state(%d)", before_state, current_state); + + if (NULL != client->state_changed_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify state changed"); + tts_client_use_callback(client); + client->state_changed_cb(client->tts, before_state, current_state, client->state_changed_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(state_changed)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_utt_started(tts_client_s* client, int utt_id) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Utterance started data : utt_id(%d)", client->utt_id); + + if (NULL != client->utt_started_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started"); + tts_client_use_callback(client); + client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_started)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_utt_completeted(tts_client_s* client, int utt_id) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Utterance completed data : utt_id(%d)", utt_id); + + if (NULL != client->utt_completed_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started"); + tts_client_use_callback(client); + client->utt_completed_cb(client->tts, utt_id, client->utt_completed_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_completed)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_error(tts_client_s* client, int utt_id, tts_error_e reason) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Error data : utt_id(%d) reason(%s)", utt_id, __tts_get_error_code(reason)); + + if (NULL != client->error_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify error"); + tts_client_use_callback(client); + client->error_cb(client->tts, utt_id, reason, client->error_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(error)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_default_voice_changed(tts_client_s* client, const char* before_lang, int before_voice_type, const char* language, int voice_type) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL == before_lang || NULL == language) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Default voice changed data : before_lang(%s), before_voice_type(%d), language(%s), voice_type(%d)", + before_lang, before_voice_type, language, voice_type); + + if (NULL != client->default_voice_changed_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify default voice changed"); + tts_client_use_callback(client); + client->default_voice_changed_cb(client->tts, before_lang, before_voice_type, language, voice_type, client->default_voice_changed_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(default_voice_changed)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_engine_changed(tts_client_s* client, const char* engine_id, const char* language, int voice_type, bool need_credential) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL == engine_id || NULL == language) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Engine changed data : engine_id(%s) language(%s), voicd_type(%d), need_credential(%d)", + engine_id, language, voice_type, need_credential); + + if (NULL != client->engine_changed_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify engine changed"); + tts_client_use_callback(client); + client->engine_changed_cb(client->tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(engine_changed)"); + } + + return TTS_ERROR_NONE; +} + +int tts_core_notify_supported_voice(tts_client_s* client, const char* language, int voice_type) +{ + /* check handle */ + if (NULL == client || false == tts_client_is_valid(client->tts)) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid."); + return TTS_ERROR_INVALID_PARAMETER; + } + + if (NULL == language) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter."); + return TTS_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "Supported voice data : language(%s), voicd_type(%d)", language, voice_type); + + if (NULL != client->supported_voice_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Notify supported voice"); + tts_client_use_callback(client); + client->supported_voice_cb(client->tts, language, voice_type, client->supported_voice_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback(supported_voice)"); + } + + return TTS_ERROR_NONE; +} diff --git a/client/tts_core.h b/client/tts_core.h new file mode 100644 index 0000000..c5e7d69 --- /dev/null +++ b/client/tts_core.h @@ -0,0 +1,37 @@ +/* +* Copyright (c) 2020 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 +* http://www.apache.org/licenses/LICENSE-2.0 +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + + +#ifndef __TTS_CORE_H_ +#define __TTS_CORE_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "tts_client.h" + +int tts_core_notify_state_changed(tts_client_s* client, tts_state_e before_state, tts_state_e current_state); +int tts_core_notify_utt_started(tts_client_s* client, int utt_id); +int tts_core_notify_utt_completeted(tts_client_s* client, int utt_id); +int tts_core_notify_error(tts_client_s* client, int utt_id, tts_error_e reason); +int tts_core_notify_default_voice_changed(tts_client_s* client, const char* before_lang, int before_voice_type, const char* language, int voice_type); +int tts_core_notify_engine_changed(tts_client_s* client, const char* engine_id, const char* language, int voice_type, bool need_credential); +int tts_core_notify_supported_voice(tts_client_s* client, const char* language, int voice_type); + + +#ifdef __cplusplus +} +#endif + +#endif /* __TTS_CORE_H_ */ -- 2.7.4