Extract common code as functions for reducing duplicated code

Change-Id: I5de2dbe0c6e240ce364c4447c87bca048c59e6cc
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/common/tts_config_mgr.c b/common/tts_config_mgr.c
index fbc75fbf9bd118ff7b646c26b6b4c002315ce711..f244d789f2e49823eda50b6f0e8f25adc134459b 100644 (file)
--- a/common/tts_config_mgr.c
+++ b/common/tts_config_mgr.c
@@ -162,6 +162,20 @@ static bool __is_client_type(int type_flag)
        return false;
 }
 
+static void __set_language_into_config(tts_config_s* config_info, const char* language)
+{
+       if (NULL == config_info) {
+               return;
+       }
+
+       memset(g_language, '\0', sizeof(g_language));
+       config_info->language = g_language;
+
+       if (NULL != language) {
+               strncpy(config_info->language, language, sizeof(g_language) - 1);
+       }
+}
+
 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
 {
        if (NULL == engine_id) {
@@ -227,10 +241,7 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
        if (NULL != voice) {
                is_valid_voice = true;
 
-               memset(g_language, '\0', sizeof(g_language));
-               config_info.language = g_language;
-               strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
-
+               __set_language_into_config(&config_info, voice->language);
                config_info.type = voice->type;
 
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
@@ -249,10 +260,7 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
                /* Select first voice as default */
-               memset(g_language, '\0', sizeof(g_language));
-               config_info.language = g_language;
-
-               strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
+               __set_language_into_config(&config_info, voice->language);
 
                config_info.type = voice->type;
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
@@ -345,8 +353,11 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
        return TTS_CONFIG_ERROR_OPERATION_FAILED;
 }
 
-inline static void __invoke_engine_changed_cb(tts_config_client_s* client, engine_changed_cb_parameter_s* params)
+static void __invoke_engine_changed_cb(gpointer data, gpointer user_data)
 {
+       tts_config_client_s* client = (tts_config_client_s*)data;
+       engine_changed_cb_parameter_s* params = (engine_changed_cb_parameter_s*)user_data;
+
        if (NULL == client || NULL == params) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] parmeter is NULL. client(%p), params(%p)", client, params);
                return;
@@ -359,8 +370,11 @@ inline static void __invoke_engine_changed_cb(tts_config_client_s* client, engin
        }
 }
 
-inline static void __invoke_voice_changed_cb(tts_config_client_s* client, voice_changed_cb_parameter_s* params)
+static void __invoke_voice_changed_cb(gpointer data, gpointer user_data)
 {
+       tts_config_client_s* client = (tts_config_client_s*)data;
+       voice_changed_cb_parameter_s* params = (voice_changed_cb_parameter_s*)user_data;
+
        if (NULL == client || NULL == params) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] parmeter is NULL. client(%p), params(%p)", client, params);
                return;
@@ -427,16 +441,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                        SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", config_info.engine_id);
 
                        /* Call all callbacks of client*/
-                       iter = g_slist_nth(g_config_client_list, 0);
-
-                       while (NULL != iter) {
-                               temp_client = iter->data;
-                               engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
-                                               config_info.type, config_info.auto_voice, config_info.credential};
-                               __invoke_engine_changed_cb(temp_client, &params);
-
-                               iter = g_slist_next(iter);
-                       }
+                       engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
+                                       config_info.type, config_info.auto_voice, config_info.credential};
+                       g_slist_foreach(g_config_client_list, __invoke_engine_changed_cb, &params);
                }
 
                if (auto_voice != config_info.auto_voice) {
@@ -451,9 +458,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                        before_type = config_info.type;
 
                        if (NULL != lang) {
-                               memset(g_language, '\0', sizeof(g_language));
-                               config_info.language = g_language;
-                               strncpy(config_info.language, lang, sizeof(g_language) - 1);
+                               __set_language_into_config(&config_info, lang);
                        }
                        if (-1 != voice_type) {
                                config_info.type = voice_type;
@@ -462,16 +467,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                        SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", config_info.language, config_info.type);
 
                        /* Call all callbacks of client*/
-                       iter = g_slist_nth(g_config_client_list, 0);
-
-                       while (NULL != iter) {
-                               temp_client = iter->data;
-                               voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language,
-                                               config_info.type, config_info.auto_voice};
-                               __invoke_voice_changed_cb(temp_client, &params);
-
-                               iter = g_slist_next(iter);
-                       }
+                       voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language,
+                                       config_info.type, config_info.auto_voice};
+                       g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 
                        if (NULL != before_lang) {
                                free(before_lang);
@@ -655,27 +653,15 @@ int __tts_config_set_auto_language()
                before_lang = strdup(config_info.language);
                before_type = config_info.type;
 
-               memset(g_language, '\0', sizeof(g_language));
-               config_info.language = g_language;
-               strncpy(config_info.language, temp_lang, sizeof(g_language) - 1);
+               __set_language_into_config(&config_info, temp_lang);
 
                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
                        config_info.language, config_info.type);
 
-               GSList *iter = NULL;
-               tts_config_client_s* temp_client = NULL;
-
                /* Call all callbacks of client*/
-               iter = g_slist_nth(g_config_client_list, 0);
-
-               while (NULL != iter) {
-                       temp_client = iter->data;
-                       voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language, config_info.type,
-                                       config_info.auto_voice};
-                       __invoke_voice_changed_cb(temp_client, &params);
-
-                       iter = g_slist_next(iter);
-               }
+               voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language,
+                               config_info.type, config_info.auto_voice};
+               g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 
                if (NULL != before_lang) {
                        free(before_lang);
@@ -697,26 +683,12 @@ int __tts_config_set_auto_language()
 
                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)", tmp_language, tmp_type);
 
-               GSList *iter = NULL;
-               tts_config_client_s* temp_client = NULL;
-
                /* Call all callbacks of client*/
-               iter = g_slist_nth(g_config_client_list, 0);
-
-               while (NULL != iter) {
-                       temp_client = iter->data;
-                       voice_changed_cb_parameter_s params = {config_info.language, config_info.type, tmp_language, tmp_type,
-                                       config_info.auto_voice};
-                       __invoke_voice_changed_cb(temp_client, &params);
-
-                       iter = g_slist_next(iter);
-               }
-
-
-               memset(g_language, '\0', sizeof(g_language));
-               config_info.language = g_language;
-               strncpy(config_info.language, tmp_language, sizeof(g_language) - 1);
+               voice_changed_cb_parameter_s params = {config_info.language, config_info.type, tmp_language, tmp_type,
+                               config_info.auto_voice};
+               g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 
+               __set_language_into_config(&config_info, tmp_language);
                config_info.type = tmp_type;
 
                free(tmp_language);
@@ -993,19 +965,10 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
                        return ECORE_CALLBACK_PASS_ON;
                }
 
-               GSList *iter = NULL;
-               tts_config_client_s* temp_client = NULL;
                /* Call all callbacks of client*/
-               iter = g_slist_nth(g_config_client_list, 0);
-
-               while (NULL != iter) {
-                       temp_client = iter->data;
-                       engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
-                                       config_info.type, config_info.auto_voice, config_info.credential};
-                       __invoke_engine_changed_cb(temp_client, &params);
-
-                       iter = g_slist_next(iter);
-               }
+               engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
+                               config_info.type, config_info.auto_voice, config_info.credential};
+               g_slist_foreach(g_config_client_list, __invoke_engine_changed_cb, &params);
        } else {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event");
        }
@@ -1096,10 +1059,31 @@ static int __tts_config_mgr_unregister_engine_config_updated_event()
        return TTS_CONFIG_ERROR_NONE;
 }
 
-int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
+static int __add_new_config_client(unsigned int uid)
 {
        tts_config_client_s* new_client = NULL;
+       new_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
+       if (NULL == new_client) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
+               return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
+       }
+       new_client->uid = uid;
+       new_client->engine_cb = NULL;
+       new_client->voice_cb = NULL;
+       new_client->speech_cb = NULL;
+       new_client->pitch_cb = NULL;
+       new_client->screen_cb = NULL;
+       new_client->bg_volume_ratio_cb = NULL;
+       new_client->user_data = NULL;
+       new_client->screen_user_data = NULL;
+
+       g_config_client_list = g_slist_append(g_config_client_list, new_client);
+
+       return TTS_CONFIG_ERROR_NONE;
+}
 
+int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
+{
        /* Register uid */
        if (0 < g_slist_length(g_config_client_list)) {
                /* Check uid */
@@ -1116,22 +1100,10 @@ int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_
                        iter = g_slist_next(iter);
                }
 
-               new_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
-               if (NULL == new_client) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
-                       return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
+               int ret = __add_new_config_client(uid);
+               if (TTS_CONFIG_ERROR_NONE != ret) {
+                       return ret;
                }
-               new_client->uid = uid;
-               new_client->engine_cb = NULL;
-               new_client->voice_cb = NULL;
-               new_client->speech_cb = NULL;
-               new_client->pitch_cb = NULL;
-               new_client->screen_cb = NULL;
-               new_client->bg_volume_ratio_cb = NULL;
-               new_client->user_data = NULL;
-               new_client->screen_user_data = NULL;
-
-               g_config_client_list = g_slist_append(g_config_client_list, new_client);
 
                SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
                SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
@@ -1139,22 +1111,10 @@ int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_
 
                return TTS_CONFIG_ERROR_NONE;
        } else {
-               new_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
-               if (NULL == new_client) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
-                       return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
+               int ret = __add_new_config_client(uid);
+               if (TTS_CONFIG_ERROR_NONE != ret) {
+                       return ret;
                }
-               new_client->uid = uid;
-               new_client->engine_cb = NULL;
-               new_client->voice_cb = NULL;
-               new_client->speech_cb = NULL;
-               new_client->pitch_cb = NULL;
-               new_client->screen_cb = NULL;
-               new_client->bg_volume_ratio_cb = NULL;
-               new_client->user_data = NULL;
-               new_client->screen_user_data = NULL;
-
-               g_config_client_list = g_slist_append(g_config_client_list, new_client);
        }
 
        if (0 != access(TTS_CONFIG_BASE, F_OK)) {
@@ -1259,10 +1219,7 @@ int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_
                        }
 
                        if (NULL != tmp_language) {
-                               memset(g_language, '\0', sizeof(g_language));
-                               config_info.language = g_language;
-                               strncpy(config_info.language, tmp_language, sizeof(g_language) - 1);
-
+                               __set_language_into_config(&config_info, tmp_language);
                                config_info.type = tmp_type;
 
                                free(tmp_language);
@@ -1463,22 +1420,33 @@ int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
        return TTS_CONFIG_ERROR_NONE;
 }
 
-
-int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
+static int __check_precondition()
 {
        if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Not initialized");
                return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
-       GSList *iter = NULL;
-       tts_engine_info_s *engine_info = NULL;
-
        if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
                return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
+       return TTS_CONFIG_ERROR_NONE;
+}
+
+
+int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
+{
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
+       }
+
+       GSList *iter = NULL;
+       tts_engine_info_s *engine_info = NULL;
+
        /* Get a first item */
        iter = g_slist_nth(g_engine_list, 0);
 
@@ -1499,9 +1467,10 @@ int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void
 
 int tts_config_mgr_get_engine(char** engine)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == engine) {
@@ -1582,9 +1551,10 @@ int __tts_set_buxtonkey(const char* engine)
 
 int tts_config_mgr_set_engine(const char* engine)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == engine)
@@ -1600,14 +1570,9 @@ int tts_config_mgr_set_engine(const char* engine)
        if (0 == strcmp(config_info.engine_id, engine))
                return TTS_CONFIG_ERROR_NONE;
 
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "New engine id : %s", engine);
 
-       int ret = __tts_set_buxtonkey(engine);
+       ret = __tts_set_buxtonkey(engine);
        if (0 != ret) {
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] set_buxtonkey Fail!!");
                return ret;
@@ -1636,8 +1601,7 @@ int tts_config_mgr_set_engine(const char* engine)
                }
 
                if (false == is_valid_voice) {
-                       memset(g_language, '\0', sizeof(g_language));
-                       config_info.language = g_language;
+                       __set_language_into_config(&config_info, NULL);
 
                        GSList *iter_voice = g_slist_nth(engine_info->voices, 0);
                        if (NULL != iter_voice) {
@@ -1685,14 +1649,10 @@ int tts_config_mgr_set_engine(const char* engine)
 
 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
-       }
-
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        tts_engine_info_s *engine_info = __get_engine_info(engine_id);
@@ -1726,14 +1686,10 @@ int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_vo
 
 int tts_config_mgr_get_voice(char** language, int* type)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
-       }
-
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == language || NULL == type)
@@ -1758,9 +1714,10 @@ int tts_config_mgr_get_voice(char** language, int* type)
 
 int tts_config_mgr_set_voice(const char* language, int type)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == language) {
@@ -1768,11 +1725,6 @@ int tts_config_mgr_set_voice(const char* language, int type)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
        tts_config_s config_info;
        if (0 != tts_parser_get_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
@@ -1789,10 +1741,7 @@ int tts_config_mgr_set_voice(const char* language, int type)
                SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
        }
 
-       memset(g_language, '\0', sizeof(g_language));
-       config_info.language = g_language;
-       strncpy(config_info.language, language, sizeof(g_language) - 1);
-
+       __set_language_into_config(&config_info, language);
        config_info.type = type;
 
        if (0 != tts_parser_set_config_info(&config_info)){
@@ -1929,36 +1878,42 @@ int tts_config_mgr_set_speech_rate(int value)
        return TTS_CONFIG_ERROR_NONE;
 }
 
+static int __check_engine_support_pitch(const char* engine_id)
+{
+       tts_engine_info_s *engine_info = __get_engine_info(engine_id);
+       if (NULL == engine_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
+               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
+       }
+
+       if (false == engine_info->pitch_support) {
+               return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
+       }
+
+       return TTS_CONFIG_ERROR_NONE;
+}
+
 int tts_config_mgr_get_pitch(int* value)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == value) {
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
        tts_config_s config_info;
        if (0 != tts_parser_get_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
-       if (NULL == engine_info) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
-       if (false == engine_info->pitch_support) {
-               return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
+       ret = __check_engine_support_pitch(config_info.engine_id);
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               return ret;
        }
 
        *value = config_info.pitch;
@@ -1968,14 +1923,10 @@ int tts_config_mgr_get_pitch(int* value)
 
 int tts_config_mgr_set_pitch(int value)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
-       }
-
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        tts_config_s config_info;
@@ -1984,14 +1935,9 @@ int tts_config_mgr_set_pitch(int value)
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
-       if (NULL == engine_info) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
-       if (false == engine_info->pitch_support) {
-               return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
+       ret = __check_engine_support_pitch(config_info.engine_id);
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               return ret;
        }
 
        if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
@@ -2068,17 +2014,15 @@ int tts_config_mgr_set_bg_volume_ratio(double value)
 
 bool tts_config_check_default_engine_is_valid(const char* engine)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
                return false;
        }
 
        if (NULL == engine)
                return false;
 
-       if (0 >= g_slist_length(g_engine_list))
-               return false;
-
        tts_engine_info_s *engine_info = __get_engine_info(engine);
        if (NULL == engine_info) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
@@ -2168,20 +2112,16 @@ int __tts_config_mgr_print_engine_info()
 
 int tts_config_mgr_get_max_text_size(unsigned int* size)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_STATE;
+       int ret = __check_precondition();
+       if (TTS_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
+               return ret;
        }
 
        if (NULL == size) {
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       if (0 >= g_slist_length(g_engine_list)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
-               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
-       }
-
        tts_config_s config_info;
        if (0 != tts_parser_get_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");