Seperate memory of tts_config_info for thread safety

Change-Id: I15f7802301e03515f5f88081aa73c4e2c83efcdc

diff --git a/common/tts_config_mgr.c b/common/tts_config_mgr.c
index 6b61300..fbb8f13 100644 (file)
--- a/common/tts_config_mgr.c
+++ b/common/tts_config_mgr.c
@@ -42,7 +42,6 @@ static GSList* g_engine_list = NULL;
 
 static GSList* g_config_client_list = NULL;
 
-static tts_config_s* g_config_info = NULL;
 extern char g_engine_id[128];
 extern char g_setting[128];
 extern char g_language[128];
@@ -138,18 +137,24 @@ 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;
+       }
+
        if (NULL != engine_info->uuid) {
                memset(g_engine_id, '\0', sizeof(g_engine_id));
-               g_config_info->engine_id = g_engine_id;
-               strncpy(g_config_info->engine_id, engine_info->uuid, sizeof(g_engine_id) - 1);
+               config_info.engine_id = g_engine_id;
+               strncpy(config_info.engine_id, engine_info->uuid, sizeof(g_engine_id) - 1);
        }
        if (NULL != engine_info->setting) {
                memset(g_setting, '\0', sizeof(g_setting));
-               g_config_info->setting = g_setting;
-               strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
+               config_info.setting = g_setting;
+               strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is changed : %s", g_config_info->engine_id);
+       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is changed : %s", config_info.engine_id);
 
        /* Change is default voice */
        GSList *iter_voice = NULL;
@@ -165,16 +170,16 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
 
                if (NULL != voice) {
                        if (NULL != voice->language) {
-                               if (0 == strcmp(voice->language, g_config_info->language)) {
-                                       if (voice->type == g_config_info->type) {
+                               if (0 == strcmp(voice->language, config_info.language)) {
+                                       if (voice->type == config_info.type) {
                                                /* language is valid */
                                                is_valid_voice = true;
 
                                                memset(g_language, '\0', sizeof(g_language));
-                                               g_config_info->language = g_language;
-                                               strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
+                                               config_info.language = g_language;
+                                               strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
 
-                                               g_config_info->type = voice->type;
+                                               config_info.type = voice->type;
 
                                                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
                                                break;
@@ -187,10 +192,6 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
        }
 
        if (false == is_valid_voice) {
-               /* Select first voice as default */
-               memset(g_language, '\0', sizeof(g_language));
-               g_config_info->language = g_language;
-
                iter_voice = g_slist_nth(engine_info->voices, 0);
                if (NULL == iter_voice) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice list");
@@ -202,13 +203,22 @@ int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice info from list");
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
-               strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
+               /* 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);
 
-               g_config_info->type = voice->type;
+               config_info.type = voice->type;
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
        }
 
-       if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language, g_config_info->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;
+       }
+
+       if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting, config_info.language, config_info.type)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
@@ -369,12 +379,18 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                return ECORE_CALLBACK_DONE;
        }
 
+       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;
+       }
+
        if (IN_CLOSE_WRITE == event.mask) {
                /* check config changed state */
                char* engine = NULL;
                char* setting = NULL;
                char* lang = NULL;
-               bool auto_voice = g_config_info->auto_voice;
+               bool auto_voice = config_info.auto_voice;
                int voice_type = -1;
                int speech_rate = -1;
                int pitch = -1;
@@ -390,16 +406,16 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                if (NULL != engine || NULL != setting) {
                        if (NULL != engine) {
                                memset(g_engine_id, '\0', sizeof(g_engine_id));
-                               g_config_info->engine_id = g_engine_id;
-                               strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
+                               config_info.engine_id = g_engine_id;
+                               strncpy(config_info.engine_id, engine, sizeof(g_engine_id) - 1);
                        }
                        if (NULL != setting) {
                                memset(g_setting, '\0', sizeof(g_setting));
-                               g_config_info->setting = g_setting;
-                               strncpy(g_config_info->setting, setting, sizeof(g_setting) - 1);
+                               config_info.setting = g_setting;
+                               strncpy(config_info.setting, setting, sizeof(g_setting) - 1);
                        }
 
-                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", g_config_info->engine_id);
+                       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);
@@ -410,9 +426,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                                if (NULL != temp_client) {
                                        if (NULL != temp_client->engine_cb) {
                                                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
-                                               temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
-                                                       g_config_info->language, g_config_info->type,
-                                                       g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
+                                               temp_client->engine_cb(config_info.engine_id, config_info.setting,
+                                                       config_info.language, config_info.type,
+                                                       config_info.auto_voice, config_info.credential, temp_client->user_data);
                                        }
                                }
 
@@ -420,27 +436,27 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                        }
                }
 
-               if (auto_voice != g_config_info->auto_voice) {
-                       g_config_info->auto_voice = auto_voice;
+               if (auto_voice != config_info.auto_voice) {
+                       config_info.auto_voice = auto_voice;
                }
 
                if (NULL != lang || -1 != voice_type) {
                        char* before_lang = NULL;
                        int before_type;
 
-                       before_lang = strdup(g_config_info->language);
-                       before_type = g_config_info->type;
+                       before_lang = strdup(config_info.language);
+                       before_type = config_info.type;
 
                        if (NULL != lang) {
                                memset(g_language, '\0', sizeof(g_language));
-                               g_config_info->language = g_language;
-                               strncpy(g_config_info->language, lang, sizeof(g_language) - 1);
+                               config_info.language = g_language;
+                               strncpy(config_info.language, lang, sizeof(g_language) - 1);
                        }
                        if (-1 != voice_type) {
-                               g_config_info->type = voice_type;
+                               config_info.type = voice_type;
                        }
 
-                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
+                       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);
@@ -452,8 +468,8 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                                        if (NULL != temp_client->voice_cb) {
                                                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%d)", temp_client->uid);
                                                temp_client->voice_cb(before_lang, before_type,
-                                                       g_config_info->language, g_config_info->type,
-                                                       g_config_info->auto_voice, temp_client->user_data);
+                                                       config_info.language, config_info.type,
+                                                       config_info.auto_voice, temp_client->user_data);
                                        }
                                }
 
@@ -467,9 +483,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                }
 
                if (-1 != speech_rate) {
-                       g_config_info->speech_rate = speech_rate;
+                       config_info.speech_rate = speech_rate;
 
-                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate change(%d)", g_config_info->speech_rate);
+                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate change(%d)", config_info.speech_rate);
 
                        /* Call all callbacks of client*/
                        iter = g_slist_nth(g_config_client_list, 0);
@@ -480,7 +496,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                                if (NULL != temp_client) {
                                        if (NULL != temp_client->speech_cb) {
                                                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate changed callback : uid(%d)", temp_client->uid);
-                                               temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
+                                               temp_client->speech_cb(config_info.speech_rate, temp_client->user_data);
                                        }
                                }
 
@@ -489,9 +505,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                }
 
                if (-1 != pitch) {
-                       g_config_info->pitch = pitch;
+                       config_info.pitch = pitch;
 
-                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "pitch change(%d)", g_config_info->pitch);
+                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "pitch change(%d)", config_info.pitch);
 
                        /* Call all callbacks of client*/
                        iter = g_slist_nth(g_config_client_list, 0);
@@ -502,7 +518,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                                if (NULL != temp_client) {
                                        if (NULL != temp_client->pitch_cb) {
                                                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Pitch changed callback : uid(%d)", temp_client->uid);
-                                               temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
+                                               temp_client->pitch_cb(config_info.pitch, temp_client->user_data);
                                        }
                                }
 
@@ -511,9 +527,9 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                }
 
                if (-1 != bg_volume_ratio) {
-                       g_config_info->bg_volume_ratio = bg_volume_ratio;
+                       config_info.bg_volume_ratio = bg_volume_ratio;
 
-                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio change(%lf)", g_config_info->bg_volume_ratio);
+                       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio change(%lf)", config_info.bg_volume_ratio);
 
                        /* Call all callbacks of client*/
                        iter = g_slist_nth(g_config_client_list, 0);
@@ -524,7 +540,7 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                                if (NULL != temp_client) {
                                        if (NULL != temp_client->bg_volume_ratio_cb) {
                                                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio changed callback : uid(%d)", temp_client->uid);
-                                               temp_client->bg_volume_ratio_cb(g_config_info->bg_volume_ratio, temp_client->user_data);
+                                               temp_client->bg_volume_ratio_cb(config_info.bg_volume_ratio, temp_client->user_data);
                                        }
                                }
 
@@ -544,12 +560,17 @@ Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handl
                        free(lang);
                        lang = NULL;
                }
+
+               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;
+               }
        } else if (IN_DELETE_SELF == event.mask) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] IN_DELETE_SELF event");
 
-               tts_parser_unload_config(g_config_info);
+               tts_parser_unload_config();
                tts_parser_reset();
-               tts_parser_load_config(&g_config_info);
+               tts_parser_load_config();
        } else {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event (0x%x)", event.mask);
        }
@@ -618,9 +639,15 @@ int __tts_config_set_auto_language()
        free(value);
        value = NULL;
 
-       if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->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;
+       }
+
+       if (true == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, temp_lang, config_info.type)) {
                /* tts default voice change */
-               if (NULL == g_config_info->language) {
+               if (NULL == config_info.language) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Current config language is NULL");
                        return -1;
                }
@@ -628,20 +655,20 @@ int __tts_config_set_auto_language()
                char* before_lang = NULL;
                int before_type;
 
-               if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
+               if (0 != tts_parser_set_voice(temp_lang, config_info.type)) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
                        return -1;
                }
 
-               before_lang = strdup(g_config_info->language);
-               before_type = g_config_info->type;
+               before_lang = strdup(config_info.language);
+               before_type = config_info.type;
 
                memset(g_language, '\0', sizeof(g_language));
-               g_config_info->language = g_language;
-               strncpy(g_config_info->language, temp_lang, sizeof(g_language) - 1);
+               config_info.language = g_language;
+               strncpy(config_info.language, temp_lang, sizeof(g_language) - 1);
 
                SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
-                       g_config_info->language, g_config_info->type);
+                       config_info.language, config_info.type);
 
                GSList *iter = NULL;
                tts_config_client_s* temp_client = NULL;
@@ -655,8 +682,8 @@ int __tts_config_set_auto_language()
                        if (NULL != temp_client) {
                                if (NULL != temp_client->voice_cb) {
                                        temp_client->voice_cb(before_lang, before_type,
-                                               g_config_info->language, g_config_info->type,
-                                               g_config_info->auto_voice, temp_client->user_data);
+                                               config_info.language, config_info.type,
+                                               config_info.auto_voice, temp_client->user_data);
                                }
                        }
 
@@ -671,7 +698,7 @@ int __tts_config_set_auto_language()
                /* Display language is not valid */
                char* tmp_language = NULL;
                int tmp_type = -1;
-               if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
+               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;
                }
@@ -700,8 +727,8 @@ int __tts_config_set_auto_language()
 
                        if (NULL != temp_client) {
                                if (NULL != temp_client->voice_cb) {
-                                       temp_client->voice_cb(g_config_info->language, g_config_info->type,
-                                               tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
+                                       temp_client->voice_cb(config_info.language, config_info.type,
+                                               tmp_language, tmp_type, config_info.auto_voice, temp_client->user_data);
                                }
                        }
 
@@ -710,26 +737,30 @@ int __tts_config_set_auto_language()
 
 
                memset(g_language, '\0', sizeof(g_language));
-               g_config_info->language = g_language;
-               strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
+               config_info.language = g_language;
+               strncpy(config_info.language, tmp_language, sizeof(g_language) - 1);
 
-               g_config_info->type = tmp_type;
+               config_info.type = tmp_type;
 
                free(tmp_language);
                tmp_language = NULL;
        }
 
+       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 0;
 }
 
 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
 {
-       if (NULL == g_config_info) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Current config info is invalid.");
+       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;
        }
-
-       if (true == g_config_info->auto_voice) {
+       if (true == config_info.auto_voice) {
                __tts_config_set_auto_language();
        }
 
@@ -940,12 +971,17 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info when config updated");
                }
                __tts_config_mgr_print_engine_info();
-               bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->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;
+               }
+               bool support = tts_config_check_default_voice_is_valid(config_info.language, config_info.type);
                if (false == support) {
                        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[ERROR] Default voice is valid");
                        char* temp_lang = NULL;
                        int temp_type;
-                       ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
+                       ret = __tts_config_mgr_select_lang(config_info.engine_id, &temp_lang, &temp_type);
                        if (0 != ret) {
                                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get voice");
                        }
@@ -954,7 +990,7 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
                        if (0 != ret) {
                                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set voice");
                        } else {
-                               SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
+                               SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", config_info.language, config_info.type);
                        }
                        if (NULL != temp_lang) {
                                free(temp_lang);
@@ -973,9 +1009,9 @@ static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* dat
                        if (NULL != temp_client) {
                                if (NULL != temp_client->engine_cb) {
                                        SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
-                                       temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
-                                               g_config_info->language, g_config_info->type,
-                                               g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
+                                       temp_client->engine_cb(config_info.engine_id, config_info.setting,
+                                               config_info.language, config_info.type,
+                                               config_info.auto_voice, config_info.credential, temp_client->user_data);
                                }
                        }
 
@@ -1180,56 +1216,65 @@ int tts_config_mgr_initialize(int uid)
 
        __tts_config_mgr_print_engine_info();
 
-       if (0 != tts_parser_load_config(&g_config_info)) {
+       if (0 != tts_parser_load_config()) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to parse configure information");
                __tts_config_release_client(uid);
                __tts_config_release_engine();
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
+       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");
+               __tts_config_release_client(uid);
+               __tts_config_release_engine();
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
+       }
 
        /* Check whether engine id is valid */
-       if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
+       if (0 != __tts_config_mgr_check_engine_is_valid(config_info.engine_id)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get default engine");
                __tts_config_release_client(uid);
                __tts_config_release_engine();
-               tts_parser_unload_config(g_config_info);
-               g_config_info = NULL;
+               tts_parser_unload_config();
                return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
-       if (true == g_config_info->auto_voice) {
+       if (true == config_info.auto_voice) {
                /* Check language with display language */
                __tts_config_set_auto_language();
        } else {
-               if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
+               if (false == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, config_info.language, config_info.type)) {
                        /* Default language is not valid */
                        char* tmp_language = NULL;
                        int tmp_type = -1;
-                       if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
+                       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");
                                __tts_config_release_client(uid);
                                __tts_config_release_engine();
-                               tts_parser_unload_config(g_config_info);
-                               g_config_info = NULL;
+                               tts_parser_unload_config();
                                return TTS_CONFIG_ERROR_OPERATION_FAILED;
                        }
 
                        if (NULL != tmp_language) {
                                memset(g_language, '\0', sizeof(g_language));
-                               g_config_info->language = g_language;
-                               strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
+                               config_info.language = g_language;
+                               strncpy(config_info.language, tmp_language, sizeof(g_language) - 1);
 
-                               g_config_info->type = tmp_type;
+                               config_info.type = tmp_type;
 
                                free(tmp_language);
                                tmp_language = NULL;
 
-                               if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->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_OPERATION_FAILED;
+                               }
+
+                               if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
                                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
                                        __tts_config_release_client(uid);
                                        __tts_config_release_engine();
-                                       tts_parser_unload_config(g_config_info);
-                                       g_config_info = NULL;
+                                       tts_parser_unload_config();
                                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                                }
                        }
@@ -1238,22 +1283,21 @@ int tts_config_mgr_initialize(int uid)
 
        /* print daemon config */
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ TTS config @@@");
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " engine : %s", g_config_info->engine_id);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", g_config_info->setting);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " language : %s", g_config_info->language);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " voice type : %d", g_config_info->type);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " speech rate : %d", g_config_info->speech_rate);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " pitch : %d", g_config_info->pitch);
-       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " bg volume ratio : %lf", g_config_info->bg_volume_ratio);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " engine : %s", config_info.engine_id);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", config_info.setting);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " auto voice : %s", config_info.auto_voice ? "on" : "off");
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " language : %s", config_info.language);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " voice type : %d", config_info.type);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " speech rate : %d", config_info.speech_rate);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " pitch : %d", config_info.pitch);
+       SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " bg volume ratio : %lf", config_info.bg_volume_ratio);
        SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@@@");
 
        if (0 != __tts_config_mgr_register_config_event()) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register config event");
                __tts_config_release_client(uid);
                __tts_config_release_engine();
-               tts_parser_unload_config(g_config_info);
-               g_config_info = NULL;
+               tts_parser_unload_config();
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
@@ -1266,7 +1310,7 @@ int tts_config_mgr_initialize(int uid)
        //      SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
        //      __tts_config_release_client(uid);
        //      __tts_config_release_engine();
-       //      tts_parser_unload_config(g_config_info);
+       //      tts_parser_unload_config();
        //      __tts_config_mgr_unregister_config_event();
        //      return TTS_CONFIG_ERROR_OPERATION_FAILED;
        //}
@@ -1284,8 +1328,7 @@ int tts_config_mgr_finalize(int uid)
 
        __tts_config_release_engine();
 
-       tts_parser_unload_config(g_config_info);
-       g_config_info = NULL;
+       tts_parser_unload_config();
 
        __tts_config_mgr_unregister_engine_config_updated_event();
 
@@ -1455,7 +1498,13 @@ int tts_config_mgr_get_engine(char** engine)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       if (NULL != g_config_info->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;
+       }
+
+       if (NULL != config_info.engine_id) {
                /* Check engine id is valid */
                GSList *iter = NULL;
                tts_engine_info_s *engine_info = NULL;
@@ -1472,8 +1521,8 @@ int tts_config_mgr_get_engine(char** engine)
                        engine_info = iter->data;
 
                        if (NULL != engine_info) {
-                               if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
-                                       *engine = strdup(g_config_info->engine_id);
+                               if (0 == strcmp(engine_info->uuid, config_info.engine_id)) {
+                                       *engine = strdup(config_info.engine_id);
                                        return 0;
                                }
                        }
@@ -1553,8 +1602,14 @@ int tts_config_mgr_set_engine(const char* engine)
        if (NULL == engine)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 
+       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;
+       }
+
        /* Check current engine id with new engine id */
-       if (0 == strcmp(g_config_info->engine_id, engine))
+       if (0 == strcmp(config_info.engine_id, engine))
                return 0;
 
        if (0 >= g_slist_length(g_engine_list)) {
@@ -1593,13 +1648,13 @@ int tts_config_mgr_set_engine(const char* engine)
                }
 
                memset(g_engine_id, '\0', sizeof(g_engine_id));
-               g_config_info->engine_id = g_engine_id;
-               strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
+               config_info.engine_id = g_engine_id;
+               strncpy(config_info.engine_id, engine, sizeof(g_engine_id) - 1);
 
                if (NULL != engine_info->setting) {
                        memset(g_setting, '\0', sizeof(g_setting));
-                       g_config_info->setting = g_setting;
-                       strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
+                       config_info.setting = g_setting;
+                       strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
                }
 
                /* Engine is valid*/
@@ -1619,11 +1674,11 @@ int tts_config_mgr_set_engine(const char* engine)
                                        continue;
                                SLOG(LOG_DEBUG, TAG_TTSCONFIG, " lang(%s) type(%d)", voice->language, voice->type);
 
-                               if (0 == strcmp(voice->language, g_config_info->language)) {
-                                       if (voice->type == g_config_info->type) {
+                               if (0 == strcmp(voice->language, config_info.language)) {
+                                       if (voice->type == config_info.type) {
                                                /* language is valid */
                                                is_valid_voice = true;
-                                               g_config_info->type = voice->type;
+                                               config_info.type = voice->type;
                                        }
                                        break;
                                }
@@ -1635,16 +1690,16 @@ int tts_config_mgr_set_engine(const char* engine)
 
                if (false == is_valid_voice) {
                        memset(g_language, '\0', sizeof(g_language));
-                       g_config_info->language = g_language;
+                       config_info.language = g_language;
 
                        iter_voice = g_slist_nth(engine_info->voices, 0);
                        if (NULL != iter_voice) {
                                voice = iter_voice->data;
                                if (NULL != voice) {
                                        if (NULL != voice->language)
-                                               strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
+                                               strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
 
-                                       g_config_info->type = voice->type;
+                                       config_info.type = voice->type;
                                }
                        }
                }
@@ -1653,15 +1708,20 @@ int tts_config_mgr_set_engine(const char* engine)
                break;
        }
 
+       if (0 != tts_parser_set_config_info(&config_info)) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
+               return TTS_CONFIG_ERROR_OPERATION_FAILED;
+       }
+
        if (true == is_valid_engine) {
                SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Engine changed");
-               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Engine : %s", g_config_info->engine_id);
-               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Setting : %s", g_config_info->setting);
-               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Language : %s", g_config_info->language);
-               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Type : %d", g_config_info->type);
+               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Engine : %s", config_info.engine_id);
+               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Setting : %s", config_info.setting);
+               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Language : %s", config_info.language);
+               SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Type : %d", config_info.type);
 
-               if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
-                       g_config_info->language, g_config_info->type)) {
+               if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting,
+                       config_info.language, config_info.type)) {
                                SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
                                return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
@@ -1744,9 +1804,15 @@ int tts_config_mgr_get_voice(char** language, int* type)
        if (NULL == language || NULL == type)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 
-       if (0 != strlen(g_config_info->language)) {
-               *language = strdup(g_config_info->language);
-               *type = g_config_info->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;
+       }
+
+       if (0 != strlen(config_info.language)) {
+               *language = strdup(config_info.language);
+               *type = config_info.type;
        } else {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "language is NULL");
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
@@ -1772,16 +1838,27 @@ int tts_config_mgr_set_voice(const char* language, int type)
                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_INVALID_PARAMETER;
+       }
+
        /* Check language is valid */
        if (0 != tts_parser_set_voice(language, type)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
        memset(g_language, '\0', sizeof(g_language));
-       g_config_info->language = g_language;
-       strncpy(g_config_info->language, language, sizeof(g_language) - 1);
+       config_info.language = g_language;
+       strncpy(config_info.language, language, sizeof(g_language) - 1);
+
+       config_info.type = type;
 
-       g_config_info->type = 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 0;
 }
@@ -1796,7 +1873,13 @@ int tts_config_mgr_get_auto_voice(bool* value)
        if (NULL == value)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 
-       *value = g_config_info->auto_voice;
+       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;
+       }
+
+       *value = config_info.auto_voice;
 
        return 0;
 }
@@ -1808,19 +1891,30 @@ int tts_config_mgr_set_auto_voice(bool value)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       if (g_config_info->auto_voice != 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;
+       }
+
+       if (config_info.auto_voice != value) {
                /* Check language is valid */
                if (0 != tts_parser_set_auto_voice(value)) {
                        SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save auto voice option");
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
-               g_config_info->auto_voice = value;
+               config_info.auto_voice = value;
 
-               if (true == g_config_info->auto_voice) {
+               if (true == config_info.auto_voice) {
                        __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 0;
 }
 
@@ -1835,7 +1929,13 @@ int tts_config_mgr_get_speech_rate(int* value)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
        }
 
-       *value = g_config_info->speech_rate;
+       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;
+       }
+
+       *value = config_info.speech_rate;
 
        return 0;
 }
@@ -1854,7 +1954,16 @@ int tts_config_mgr_set_speech_rate(int value)
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
-               g_config_info->speech_rate = 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;
+               }
+               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;
+               }
        } else {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Speech rate is invalid : %d", value);
        }
@@ -1884,6 +1993,12 @@ int tts_config_mgr_get_pitch(int* value)
        /* Get a first item */
        iter = g_slist_nth(g_engine_list, 0);
 
+       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;
+       }
+
        while (NULL != iter) {
                engine_info = iter->data;
 
@@ -1892,7 +2007,7 @@ int tts_config_mgr_get_pitch(int* value)
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
-               if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
+               if (0 != strcmp(config_info.engine_id, engine_info->uuid)) {
                        iter = g_slist_next(iter);
                        continue;
                }
@@ -1904,7 +2019,7 @@ int tts_config_mgr_get_pitch(int* value)
                }
        }
 
-       *value = g_config_info->pitch;
+       *value = config_info.pitch;
 
        return 0;
 }
@@ -1927,6 +2042,12 @@ int tts_config_mgr_set_pitch(int value)
        /* Get a first item */
        iter = g_slist_nth(g_engine_list, 0);
 
+       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;
+       }
+
        while (NULL != iter) {
                engine_info = iter->data;
 
@@ -1935,7 +2056,7 @@ int tts_config_mgr_set_pitch(int value)
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
-               if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
+               if (0 != strcmp(config_info.engine_id, engine_info->uuid)) {
                        iter = g_slist_next(iter);
                        continue;
                }
@@ -1952,8 +2073,12 @@ int tts_config_mgr_set_pitch(int value)
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       g_config_info->pitch = value;
+       config_info.pitch = 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 0;
 }
 
@@ -1966,8 +2091,14 @@ int tts_config_mgr_get_bg_volume_ratio(double *value)
 
        if (NULL == value)
                return TTS_CONFIG_ERROR_INVALID_PARAMETER;
-       else
-               *value = g_config_info->bg_volume_ratio;
+
+       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;
+       }
+
+       *value = config_info.bg_volume_ratio;
 
        return 0;
 }
@@ -1986,7 +2117,18 @@ int tts_config_mgr_set_bg_volume_ratio(double value)
                return TTS_CONFIG_ERROR_OPERATION_FAILED;
        }
 
-       g_config_info->bg_volume_ratio = 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;
+       }
+
+       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 0;
 }
@@ -2034,7 +2176,13 @@ bool tts_config_check_default_voice_is_valid(const char* language, int type)
        if (NULL == language)
                return false;
 
-       if (0 == strlen(g_config_info->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;
+       }
+
+       if (0 == strlen(config_info.engine_id)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Default engine id is NULL");
                return false;
        }
@@ -2057,7 +2205,7 @@ bool tts_config_check_default_voice_is_valid(const char* language, int type)
                        continue;
                }
 
-               if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
+               if (0 != strcmp(config_info.engine_id, engine_info->uuid)) {
                        iter = g_slist_next(iter);
                        continue;
                }
@@ -2163,6 +2311,12 @@ int tts_config_mgr_get_max_text_size(unsigned int* size)
        /* Get a first item */
        iter = g_slist_nth(g_engine_list, 0);
 
+       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;
+       }
+
        while (NULL != iter) {
                engine_info = iter->data;
 
@@ -2171,7 +2325,7 @@ int tts_config_mgr_get_max_text_size(unsigned int* size)
                        return TTS_CONFIG_ERROR_OPERATION_FAILED;
                }
 
-               if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
+               if (0 != strcmp(config_info.engine_id, engine_info->uuid)) {
                        iter = g_slist_next(iter);
                        continue;
                }

diff --git a/common/tts_config_parser.c b/common/tts_config_parser.c
index 2c1e7b1..87604cd 100644 (file)
--- a/common/tts_config_parser.c
+++ b/common/tts_config_parser.c
@@ -51,6 +51,8 @@ char g_engine_id[128] = {0,};
 char g_setting[128] = {0,};
 char g_language[128] = {0,};
 
+static tts_config_s* g_config_info = NULL;
+
 int tts_parser_get_engine_info(const char* path, tts_engine_info_s** engine_info)
 {
        if (NULL == path || NULL == engine_info) {
@@ -349,13 +351,8 @@ int tts_parser_print_engine_info(tts_engine_info_s* engine_info)
        return 0;
 }
 
-int tts_parser_load_config(tts_config_s** config_info)
+int tts_parser_load_config(void)
 {
-       if (NULL == config_info) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
-               return -1;
-       }
-
        xmlDocPtr doc = NULL;
        xmlNodePtr cur = NULL;
        xmlChar *key;
@@ -540,7 +537,7 @@ int tts_parser_load_config(tts_config_s** config_info)
                cur = cur->next;
        }
 
-       *config_info = temp;
+       g_config_info = temp;
        g_config_doc = doc;
 
        if (true == is_default_open) {
@@ -570,17 +567,17 @@ int tts_parser_load_config(tts_config_s** config_info)
        return 0;
 }
 
-int tts_parser_unload_config(tts_config_s* config_info)
+int tts_parser_unload_config(void)
 {
        if (NULL != g_config_doc) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Free g_config_doc(%p)", g_config_doc);
                xmlFreeDoc(g_config_doc);
                g_config_doc = NULL;
        }
-       if (NULL != config_info) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Free config_info(%p)", config_info);
-               free(config_info);
-               config_info = NULL;
+       if (NULL != g_config_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Free config_info(%p)", g_config_info);
+               free(g_config_info);
+               g_config_info = NULL;
        }
 
        xmlCleanupParser();
@@ -588,6 +585,35 @@ int tts_parser_unload_config(tts_config_s* config_info)
        return 0;
 }
 
+int tts_parser_set_config_info(tts_config_s* config_info)
+{
+       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Set config info");
+       if (NULL == config_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] config_info is NULL");
+               return -1;
+       }
+       if (NULL == g_config_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] g_config_info is NULL");
+               return -1;
+       }
+       memcpy(g_config_info, config_info, sizeof(tts_config_s));
+       return 0;
+}
+
+int tts_parser_get_config_info(tts_config_s* config_info)
+{
+       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Get config info");
+       if (NULL == config_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] config_info is NULL");
+               return -1;
+       }
+       if (NULL == g_config_info) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] g_config_info is NULL");
+               return -1;
+       }
+       memcpy(config_info, g_config_info, sizeof(tts_config_s));
+       return 0;
+}
 
 int tts_parser_copy_xml(const char* original, const char* destination)
 {

diff --git a/common/tts_config_parser.h b/common/tts_config_parser.h
index cbe0952..a39d935 100644 (file)
--- a/common/tts_config_parser.h
+++ b/common/tts_config_parser.h
@@ -64,9 +64,13 @@ int tts_parser_get_engine_info(const char* path, tts_engine_info_s** engine_info
 int tts_parser_free_engine_info(tts_engine_info_s* engine_info);
 
 
-int tts_parser_load_config(tts_config_s** config_info);
+int tts_parser_load_config(void);
 
-int tts_parser_unload_config(tts_config_s* config_info);
+int tts_parser_unload_config(void);
+
+int tts_parser_set_config_info(tts_config_s* config_info);
+
+int tts_parser_get_config_info(tts_config_s* config_info);
 
 int tts_parser_set_engine(const char* engine_id, const char* setting, const char* language, int type);