Make return value clear using enum

- Issue:
Return values of each function were not clear.

- Solution:
This patch makes each function use enum value as return value. And also,
this patch fixes the return values which are not matched with situation.

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

diff --git a/common/tts_config_mgr.c b/common/tts_config_mgr.c
index 8a208732af3576cb078e368500ca59a74a1f0200..8c535664b9a4a4dd6fad6a2eb9245bf85a356035 100644 (file)
--- a/common/tts_config_mgr.c
+++ b/common/tts_config_mgr.c
@@ -112,12 +112,12 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
 {
        if (NULL == engine_id) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
-               return -1;
+               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
        if (0 >= g_slist_length(g_engine_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
-               return -1;
+               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
        if (NULL != __get_engine_info(engine_id)) {
@@ -151,7 +151,7 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (NULL != engine_info->uuid) {
@@ -226,7 +226,7 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
@@ -239,7 +239,7 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
        }
 
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
@@ -313,7 +313,7 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
 {
        if (NULL == engine_id || NULL == language) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
-               return false;
+               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
        GSList *iter = NULL;
@@ -321,7 +321,7 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
 
        if (0 >= g_slist_length(g_engine_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
-               return false;
+               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
        /* Get a first item */
@@ -332,7 +332,7 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
 
                if (NULL == engine_info) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
-                       return false;
+                       return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
                }
 
                if (0 != strcmp(engine_id, engine_info->uuid)) {
@@ -345,7 +345,7 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
 
                if (g_slist_length(engine_info->voices) <= 0) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no voice : %s", engine_info->uuid);
-                       return -1;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
                /* Get a first item */
@@ -360,7 +360,7 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
                                        *type = voice->type;
 
                                        SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
-                                       return 0;
+                                       return TTS_CONFIG_ERROR_NONE;
                                }
                        }
                        iter_voice = g_slist_next(iter_voice);
@@ -372,12 +372,12 @@ int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* ty
                        *type = voice->type;
 
                        SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
-                       return 0;
+                       return TTS_CONFIG_ERROR_NONE;
                }
                break;
        }
 
-       return -1;
+       return TTS_CONFIG_ERROR_OPERATION_FAILED;
 }
 
 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
@@ -398,7 +398,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
        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_INVALID_PARAMETER;
+               return ECORE_CALLBACK_PASS_ON;
        }
 
        if (IN_CLOSE_WRITE == event.mask) {
@@ -579,7 +579,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
 
                if (0 != tts_parser_set_config_info(&config_info)){
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-                       return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+                       return ECORE_CALLBACK_PASS_ON;
                }
        } else if (IN_DELETE_SELF == event.mask) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] IN_DELETE_SELF event");
@@ -605,7 +605,7 @@ int __tts_config_mgr_register_config_event()
        fd = inotify_init();
        if (fd < 0) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail get inotify fd");
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
        g_config_fd_noti = fd;
 
@@ -616,7 +616,7 @@ int __tts_config_mgr_register_config_event()
                (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
        if (NULL == g_config_fd_handler_noti) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get handler_noti");
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        /* Set non-blocking mode of file */
@@ -628,7 +628,7 @@ int __tts_config_mgr_register_config_event()
                SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int __tts_config_mgr_unregister_config_event()
@@ -638,7 +638,7 @@ int __tts_config_mgr_unregister_config_event()
        inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
        close(g_config_fd_noti);
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int __tts_config_set_auto_language()
@@ -647,7 +647,7 @@ int __tts_config_set_auto_language()
        value = vconf_get_str(TTS_LANGSET_KEY);
        if (NULL == value) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get display language");
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        char temp_lang[6] = {'\0', };
@@ -658,14 +658,14 @@ int __tts_config_set_auto_language()
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (true == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, temp_lang, config_info.type)) {
                /* tts default voice change */
                if (NULL == config_info.language) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Current config language is NULL");
-                       return -1;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
                char* before_lang = NULL;
@@ -711,12 +711,12 @@ int __tts_config_set_auto_language()
                int tmp_type = -1;
                if (0 != __tts_config_mgr_select_lang(config_info.engine_id, &tmp_language, &tmp_type)) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
-                       return -1;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
                if (NULL == tmp_language) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] language is NULL");
-                       return -1;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
@@ -754,10 +754,10 @@ int __tts_config_set_auto_language()
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
@@ -900,7 +900,7 @@ int __tts_config_mgr_get_engine_info()
                                if (filesize >= 512) {
                                        SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
                                        closedir(dp);
-                                       return -1;
+                                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                                }
 
                                memset(filepath, '\0', 512);
@@ -938,7 +938,7 @@ int __tts_config_mgr_get_engine_info()
                                if (filesize >= 512) {
                                        SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
                                        closedir(dp);
-                                       return -1;
+                                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                                }
 
                                memset(filepath, '\0', 512);
@@ -960,10 +960,10 @@ int __tts_config_mgr_get_engine_info()
 
        if (0 >= g_slist_length(g_engine_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine");
-               return -1;
+               return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
@@ -993,7 +993,7 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
                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_INVALID_PARAMETER;
+                       return ECORE_CALLBACK_PASS_ON;
                }
                bool support = tts_config_check_default_voice_is_valid(config_info.language, config_info.type);
                if (false == support) {
@@ -1019,7 +1019,7 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
 
                if (0 != tts_parser_get_config_info(&config_info)){
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
-                       return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+                       return ECORE_CALLBACK_PASS_ON;
                }
 
                GSList *iter = NULL;
@@ -1054,14 +1054,14 @@ static int __tts_config_mgr_register_engine_config_updated_event(const char* pat
 {
        if (NULL == path) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Path is NULL");
-               return -1;
+               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
        /* For engine directory monitoring */
        tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
        if (NULL == ino) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
-               return -1;
+               return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
        }
 
        ino->dir_fd = inotify_init();
@@ -1070,7 +1070,7 @@ static int __tts_config_mgr_register_engine_config_updated_event(const char* pat
                free(ino);
                ino = NULL;
 
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
@@ -1079,7 +1079,7 @@ static int __tts_config_mgr_register_engine_config_updated_event(const char* pat
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add watch");
                free(ino);
                ino = NULL;
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        ino->dir_fd_handler = ecore_main_fd_handler_add(ino->dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)__tts_config_mgr_engine_config_inotify_event_callback, (void *)ino, NULL, NULL);
@@ -1087,7 +1087,7 @@ static int __tts_config_mgr_register_engine_config_updated_event(const char* pat
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add fd handler");
                free(ino);
                ino = NULL;
-               return -1;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        /* Set non-blocking mode of file */
@@ -1101,7 +1101,7 @@ static int __tts_config_mgr_register_engine_config_updated_event(const char* pat
 
        g_ino_list = g_list_append(g_ino_list, ino);
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 static int __tts_config_mgr_unregister_engine_config_updated_event()
@@ -1128,7 +1128,7 @@ static int __tts_config_mgr_unregister_engine_config_updated_event()
                }
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
@@ -1357,14 +1357,14 @@ int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_
        //      return TTS_CONFIG_ERROR_OPERATION_FAILED;
        //}
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_type)
 {
        if (0 < __tts_config_release_client(uid)) {
                g_client_type &= ~client_type;
-               return 0;
+               return TTS_CONFIG_ERROR_NONE;
        }
 
        SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
@@ -1383,7 +1383,7 @@ int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_ty
        vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
        vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_set_callback(unsigned int uid,
@@ -1416,7 +1416,7 @@ int tts_config_mgr_set_callback(unsigned int uid,
 
                iter = g_slist_next(iter);
        }
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_unset_callback(unsigned int uid)
@@ -1444,7 +1444,7 @@ int tts_config_mgr_unset_callback(unsigned int uid)
                iter = g_slist_next(iter);
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_screen_reader_changed_cb callback, void* user_data)
@@ -1472,7 +1472,7 @@ int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_scree
 
                iter = g_slist_next(iter);
        }
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
@@ -1495,7 +1495,7 @@ int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
 
                iter = g_slist_next(iter);
        }
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 
@@ -1529,7 +1529,7 @@ int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void
                iter = g_slist_next(iter);
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_get_engine(char** engine)
@@ -1547,7 +1547,7 @@ int tts_config_mgr_get_engine(char** engine)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (NULL != config_info.engine_id) {
@@ -1569,7 +1569,7 @@ int tts_config_mgr_get_engine(char** engine)
                        if (NULL != engine_info) {
                                if (0 == strcmp(engine_info->uuid, config_info.engine_id)) {
                                        *engine = strdup(config_info.engine_id);
-                                       return 0;
+                                       return TTS_CONFIG_ERROR_NONE;
                                }
                        }
                        iter = g_slist_next(iter);
@@ -1651,12 +1651,12 @@ int tts_config_mgr_set_engine(const char* engine)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        /* Check current engine id with new engine id */
        if (0 == strcmp(config_info.engine_id, engine))
-               return 0;
+               return TTS_CONFIG_ERROR_NONE;
 
        if (0 >= g_slist_length(g_engine_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
@@ -1780,7 +1780,7 @@ int tts_config_mgr_set_engine(const char* engine)
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
@@ -1836,14 +1836,14 @@ int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_vo
                break;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 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_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (0 >= g_slist_length(g_engine_list)) {
@@ -1857,7 +1857,7 @@ int tts_config_mgr_get_voice(char** language, int* type)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (0 != strlen(config_info.language)) {
@@ -1868,14 +1868,14 @@ int tts_config_mgr_get_voice(char** language, int* type)
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 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_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == language) {
@@ -1891,7 +1891,7 @@ int tts_config_mgr_set_voice(const char* language, int type)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        /* Check language is valid */
@@ -1912,17 +1912,17 @@ int tts_config_mgr_set_voice(const char* language, int type)
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_get_auto_voice(bool* value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == value)
@@ -1931,25 +1931,25 @@ int tts_config_mgr_get_auto_voice(bool* value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        *value = config_info.auto_voice;
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_set_auto_voice(bool value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (config_info.auto_voice != value) {
@@ -1981,17 +1981,17 @@ int tts_config_mgr_set_auto_voice(bool value)
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_get_speech_rate(int* value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == value) {
@@ -2001,19 +2001,19 @@ int tts_config_mgr_get_speech_rate(int* value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        *value = config_info.speech_rate;
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_set_speech_rate(int value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
@@ -2030,25 +2030,25 @@ int tts_config_mgr_set_speech_rate(int value)
                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_INVALID_PARAMETER;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
                config_info.speech_rate = value;
                if (0 != tts_parser_set_config_info(&config_info)){
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-                       return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+                       return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
        } else {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Speech rate is invalid : %d", value);
        }
 
-       return 0;
+       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_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == value) {
@@ -2069,7 +2069,7 @@ int tts_config_mgr_get_pitch(int* value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        while (NULL != iter) {
@@ -2094,14 +2094,14 @@ int tts_config_mgr_get_pitch(int* value)
 
        *value = config_info.pitch;
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 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 -1;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        GSList *iter = NULL;
@@ -2118,7 +2118,7 @@ int tts_config_mgr_set_pitch(int value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        while (NULL != iter) {
@@ -2154,7 +2154,7 @@ int tts_config_mgr_set_pitch(int value)
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
        return 0;
 }
@@ -2163,7 +2163,7 @@ int tts_config_mgr_get_bg_volume_ratio(double *value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == value)
@@ -2172,19 +2172,19 @@ int tts_config_mgr_get_bg_volume_ratio(double *value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        *value = config_info.bg_volume_ratio;
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 int tts_config_mgr_set_bg_volume_ratio(double value)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set bg volume ratio : %lf", value);
@@ -2200,24 +2200,24 @@ int tts_config_mgr_set_bg_volume_ratio(double value)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        config_info.bg_volume_ratio = value;
 
        if (0 != tts_parser_set_config_info(&config_info)){
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
-               return TTS_CONFIG_ERROR_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 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");
-               return -1;
+               return false;
        }
 
        if (NULL == engine)
@@ -2250,7 +2250,7 @@ bool tts_config_check_default_voice_is_valid(const char* language, int type)
 {
        if (0 >= g_slist_length(g_config_client_list)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
-               return -1;
+               return false;
        }
 
        if (NULL == language)
@@ -2259,7 +2259,7 @@ bool tts_config_check_default_voice_is_valid(const char* language, int type)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (0 == strlen(config_info.engine_id)) {
@@ -2322,7 +2322,7 @@ int __tts_config_mgr_print_engine_info()
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "-------------- engine list -----------------");
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  No Engine in engine directory");
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
-               return 0;
+               return TTS_CONFIG_ERROR_NONE;
        }
 
        /* Get a first item */
@@ -2366,14 +2366,14 @@ int __tts_config_mgr_print_engine_info()
        }
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }
 
 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_PARAMETER;
+               return TTS_CONFIG_ERROR_INVALID_STATE;
        }
 
        if (NULL == size) {
@@ -2394,7 +2394,7 @@ int tts_config_mgr_get_max_text_size(unsigned int* size)
        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_INVALID_PARAMETER;
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        while (NULL != iter) {
@@ -2421,5 +2421,5 @@ int tts_config_mgr_get_max_text_size(unsigned int* size)
        *size = engine_info->text_size;
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);
 
-       return 0;
+       return TTS_CONFIG_ERROR_NONE;
 }

diff --git a/server/ttsd_engine_agent.c b/server/ttsd_engine_agent.c
index cfb913d93bc1f22b30b069e69f75728cb0bb8b25..7376b4e1decef3b4b5c96322443130010bd6273b 100644 (file)
--- a/server/ttsd_engine_agent.c
+++ b/server/ttsd_engine_agent.c
@@ -130,14 +130,14 @@ int ttsd_engine_agent_init()
        g_agent_init = true;
 
        SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Initialize Engine Agent");
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_release()
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        /* unload current engine */
@@ -177,7 +177,7 @@ int ttsd_engine_agent_release()
 
        SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Release Engine Agent");
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 static bool __set_voice_info_cb(const char* language, int type, void* user_data)
@@ -214,7 +214,7 @@ static int __update_voice_list()
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        /* Get voice list */
@@ -248,13 +248,13 @@ static int __update_voice_list()
 
        if (0 != ret || 0 >= g_slist_length(g_cur_voices)) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] fail to get voice list : result(%d)", ret);
-               return -1;
+               return TTSD_ERROR_OPERATION_FAILED;
        }
 
 #ifdef ENGINE_AGENT_DEBUG
        ttsd_print_voicelist();
 #endif
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_load_current_engine(ttse_request_callback_s* callback)
@@ -264,7 +264,7 @@ int ttsd_engine_agent_load_current_engine(ttse_request_callback_s* callback)
 
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (NULL == callback) {
@@ -286,7 +286,7 @@ int ttsd_engine_agent_load_current_engine(ttse_request_callback_s* callback)
        /* check whether current engine is loaded or not */
        if (true == g_engine_info->is_loaded) {
                SLOG(LOG_INFO, tts_tag(), "[Engine Agent] Engine has already been loaded ");
-               return 0;
+               return TTSD_ERROR_NONE;
        }
 
        /* Get current engine info */
@@ -355,19 +355,19 @@ int ttsd_engine_agent_load_current_engine(ttse_request_callback_s* callback)
 
        g_engine_info->is_loaded = true;
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_unload_current_engine()
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
                SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Engine has already been unloaded ");
-               return 0;
+               return TTSD_ERROR_NONE;
        }
 
        /* shutdown engine */
@@ -402,14 +402,14 @@ int ttsd_engine_agent_unload_current_engine()
 
        SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent Success] Unload current engine");
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 bool ttsd_engine_agent_need_network()
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return false;
        }
 
        return g_engine_info->use_network;
@@ -608,17 +608,17 @@ int ttsd_engine_agent_set_default_voice(const char* language, int vctype)
 {
        if (NULL == language) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] language is NULL");
-               return false;
+               return TTSD_ERROR_INVALID_PARAMETER;
        }
 
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (NULL == g_engine_info) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] g_engine_info is NULL");
-               return false;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -699,31 +699,31 @@ int ttsd_engine_agent_set_default_voice(const char* language, int vctype)
        SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
                g_engine_info->default_lang, g_engine_info->default_vctype);
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_set_default_speed(int speed)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        g_engine_info->default_speed = speed;
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_set_default_pitch(int pitch)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (NULL == g_engine_info) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] No engine info");
-               return TTSD_ERROR_ENGINE_NOT_FOUND;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -741,7 +741,7 @@ int ttsd_engine_agent_set_default_pitch(int pitch)
        g_engine_info->default_pitch = pitch;
 
        SLOG(LOG_INFO, tts_tag(), "[Engine Agent] Set pitch(%d)", pitch);
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_agent_is_credential_needed(unsigned int uid, bool* credential_needed)
@@ -753,7 +753,7 @@ int ttsd_engine_agent_is_credential_needed(unsigned int uid, bool* credential_ne
 
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -782,7 +782,7 @@ int ttsd_engine_load_voice(const char* lang, const int vctype)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -829,14 +829,14 @@ int ttsd_engine_load_voice(const char* lang, const int vctype)
        ttsd_print_voicelist();
 #endif
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_unload_voice(const char* lang, const int vctype)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -882,7 +882,7 @@ int ttsd_engine_unload_voice(const char* lang, const int vctype)
 #ifdef ENGINE_AGENT_DEBUG
        ttsd_print_voicelist();
 #endif
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_start_synthesis(const char* lang, int vctype, const char* text, int speed, const char* appid, const char* credential, void* user_param)
@@ -894,7 +894,7 @@ int ttsd_engine_start_synthesis(const char* lang, int vctype, const char* text,
 
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -943,14 +943,14 @@ int ttsd_engine_start_synthesis(const char* lang, int vctype, const char* text,
                free(temp_lang);
                temp_lang = NULL;
        }
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_cancel_synthesis()
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1000,7 +1000,7 @@ int ttsd_engine_get_voice_list(GList** voice_list)
 
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1021,7 +1021,7 @@ int ttsd_engine_get_default_voice(char** lang, int* vctype)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1044,14 +1044,14 @@ int ttsd_engine_get_default_voice(char** lang, int* vctype)
                return TTSD_ERROR_OPERATION_FAILED;
        }
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 int ttsd_engine_set_private_data(const char* key, const char* data)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1082,7 +1082,7 @@ int ttsd_engine_get_private_data(const char* key, char** data)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1120,7 +1120,7 @@ int ttsd_engine_check_app_agreed(const char* appid, bool* is_agreed)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1205,7 +1205,7 @@ int ttsd_print_voicelist()
 
                        if (NULL == data || NULL == data->lang) {
                                SLOG(LOG_ERROR, tts_tag(), "[ERROR] Data is invalid");
-                               return 0;
+                               return TTSD_ERROR_NONE;
                        }
 
                        SLOG(LOG_DEBUG, tts_tag(), "[%dth] default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
@@ -1219,7 +1219,7 @@ int ttsd_print_voicelist()
 
        SLOG(LOG_DEBUG, tts_tag(), "@@@@@");
 
-       return 0;
+       return TTSD_ERROR_NONE;
 }
 
 static int __internal_get_engine_info(ttse_request_callback_s* callback)
@@ -1284,7 +1284,6 @@ static int __internal_get_engine_info(ttse_request_callback_s* callback)
        SLOG(LOG_DEBUG, tts_tag(), "  ");
 
        return TTSD_ERROR_NONE;
-
 }
 
 
@@ -1293,12 +1292,12 @@ int ttsd_engine_agent_set_private_data_set_cb(ttse_private_data_set_cb callback)
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (NULL == g_engine_info) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] The engine is not valid");
-               return TTSD_ERROR_INVALID_PARAMETER;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1315,12 +1314,12 @@ int ttsd_engine_agent_set_private_data_requested_cb(ttse_private_data_requested_
 {
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
-               return TTSD_ERROR_OPERATION_FAILED;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (NULL == g_engine_info) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] The engine is not valid");
-               return TTSD_ERROR_INVALID_PARAMETER;
+               return TTSD_ERROR_INVALID_STATE;
        }
 
        if (false == g_engine_info->is_loaded) {
@@ -1332,5 +1331,3 @@ int ttsd_engine_agent_set_private_data_requested_cb(ttse_private_data_requested_
 
        return TTSD_ERROR_NONE;
 }
-
-