Refactor logic for initialzing vc_config_mgr

- Issue:
The code in vc_config_mgr_initialize() has high complexity, and other
function has to use indirect method to check whether the module is
initialized.

- Solution:
This patch refactors the vc_config_mgr_initalize() function. Through
this patch, duplicated code in vc_config_mgr_initialize() is removed,
and also the new flag which shows whether the module is initialized is
introduced. The functions in this module will be able to check the
initialization of the module using this new flag.

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

diff --git a/common/vc_config_mgr.cpp b/common/vc_config_mgr.cpp
index 404d293..d81775f 100644 (file)
--- a/common/vc_config_mgr.cpp
+++ b/common/vc_config_mgr.cpp
@@ -27,6 +27,7 @@
 #include <vconf-internal-keys.h>
 #include <buxton2.h>
 #include <mutex>
+#include <atomic>
 
 #include "vc_config_mgr.h"
 #include "vc_config_parser.h"
@@ -72,6 +73,8 @@ static const char* vc_config_tag()
        return TAG_VCCONFIG;
 }
 
+static atomic<bool> g_config_mgr_initialized(false);
+
 static GSList* g_engine_list = NULL;
 
 static GSList* g_config_client_list = NULL;
@@ -415,7 +418,8 @@ void __vc_config_release_engine()
                }
        }
 
-       return;
+       g_slist_free(g_engine_list);
+       g_engine_list = nullptr;
 }
 
 int __vc_config_mgr_get_engine_info()
@@ -843,59 +847,20 @@ void __vc_config_language_changed_cb(keynode_t *key, void *data)
        return;
 }
 
-int vc_config_mgr_initialize(unsigned int uid)
+static int __initialize_vc_config_mgr()
 {
-       vc_config_client_s* temp_client = NULL;
-
-       SLOG(LOG_INFO, vc_config_tag(), "[WARNING] Enter critical section");
-       ecore_thread_main_loop_begin();
-       pthread_mutex_lock(&vc_config_mgr_mutex);
-
-       if (0 < g_slist_length(g_config_client_list)) {
-               /* Check uid */
-               if (NULL != __find_client_info(uid)) {
-                       SLOG(LOG_WARN, vc_config_tag(), "[CONFIG] uid(%u) has already registered", uid);
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
-                       return VC_CONFIG_ERROR_NONE;
-               }
-
-               temp_client = (vc_config_client_s*)calloc(1, sizeof(vc_config_client_s));
-               if (NULL == temp_client) {
-                       SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to allocate memory");
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       return VC_ERROR_OUT_OF_MEMORY;
-               }
-
-               temp_client->uid = uid;
-               temp_client->engine_cb = NULL;
-               temp_client->lang_cb = NULL;
-               temp_client->enabled_cb = NULL;
-
-               /* Add uid */
-               g_config_client_list = g_slist_append(g_config_client_list, temp_client);
-
-               SLOG(LOG_WARN, vc_config_tag(), "[CONFIG] Add uid(%u) but config has already initialized", uid);
-
-               __vc_config_mgr_print_client_info();
-               pthread_mutex_unlock(&vc_config_mgr_mutex);
-               ecore_thread_main_loop_end();
-               SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
-               return VC_ERROR_NONE;
+       if (g_config_mgr_initialized.load()) {
+               SLOG(LOG_DEBUG, vc_config_tag(), "Config mgr module is already initialized");
+               return VC_CONFIG_ERROR_NONE;
        }
 
        /* Get file name from default engine directory */
-       g_engine_list = NULL;
+       __vc_config_release_engine();
 
        if (0 != access(VC_CONFIG_BASE, F_OK)) {
                if (0 != mkdir(VC_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
                        SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_CONFIG_BASE);
-                       __vc_config_release_client(uid);
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       return -1;
+                       return VC_CONFIG_ERROR_OPERATION_FAILED;
                } else {
                        SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_CONFIG_BASE);
                }
@@ -903,10 +868,7 @@ int vc_config_mgr_initialize(unsigned int uid)
        if (0 != access(VC_RUNTIME_INFO_ROOT, F_OK)) {
                if (0 != mkdir(VC_RUNTIME_INFO_ROOT, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
                        SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_RUNTIME_INFO_ROOT);
-                       __vc_config_release_client(uid);
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       return -1;
+                       return VC_CONFIG_ERROR_OPERATION_FAILED;
                } else {
                        SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_RUNTIME_INFO_ROOT);
                }
@@ -915,10 +877,7 @@ int vc_config_mgr_initialize(unsigned int uid)
        if (0 != access(VC_DOWNLOAD_BASE, F_OK)) {
                if (0 != mkdir(VC_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
                        SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_DOWNLOAD_BASE);
-                       __vc_config_release_client(uid);
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       return -1;
+                       return VC_CONFIG_ERROR_OPERATION_FAILED;
                } else {
                        SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_DOWNLOAD_BASE);
                }
@@ -926,10 +885,7 @@ int vc_config_mgr_initialize(unsigned int uid)
        if (0 != access(VC_DOWNLOAD_ENGINE_INFO, F_OK)) {
                if (0 != mkdir(VC_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
                        SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_DOWNLOAD_ENGINE_INFO);
-                       __vc_config_release_client(uid);
-                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                       ecore_thread_main_loop_end();
-                       return -1;
+                       return VC_CONFIG_ERROR_OPERATION_FAILED;
                } else {
                        SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_DOWNLOAD_ENGINE_INFO);
                }
@@ -937,10 +893,7 @@ int vc_config_mgr_initialize(unsigned int uid)
 
        if (0 != __vc_config_mgr_get_engine_info()) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get engine info");
-               __vc_config_release_client(uid);
                __vc_config_release_engine();
-               pthread_mutex_unlock(&vc_config_mgr_mutex);
-               ecore_thread_main_loop_end();
                return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
@@ -948,21 +901,15 @@ int vc_config_mgr_initialize(unsigned int uid)
 
        if (0 != vc_parser_load_config(&g_config_info)) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to parse configure information");
-               __vc_config_release_client(uid);
                __vc_config_release_engine();
-               pthread_mutex_unlock(&vc_config_mgr_mutex);
-               ecore_thread_main_loop_end();
-               return -1;
+               return VC_CONFIG_ERROR_OPERATION_FAILED;
        }
 
        if (0 != __vc_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get default engine");
-               __vc_config_release_client(uid);
                __vc_config_release_engine();
                vc_parser_unload_config(g_config_info);
                g_config_info = NULL;
-               pthread_mutex_unlock(&vc_config_mgr_mutex);
-               ecore_thread_main_loop_end();
                return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
        }
 
@@ -975,13 +922,10 @@ int vc_config_mgr_initialize(unsigned int uid)
                        char* tmp_language;
                        if (0 != __vc_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
                                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to select language");
-                               __vc_config_release_client(uid);
                                __vc_config_release_engine();
                                vc_parser_unload_config(g_config_info);
                                g_config_info = NULL;
-                               pthread_mutex_unlock(&vc_config_mgr_mutex);
-                               ecore_thread_main_loop_end();
-                               return -1;
+                               return VC_CONFIG_ERROR_OPERATION_FAILED;
                        }
 
                        if (NULL != tmp_language) {
@@ -993,13 +937,10 @@ int vc_config_mgr_initialize(unsigned int uid)
                                if (0 != vc_parser_set_language(tmp_language)) {
                                        free(tmp_language);
                                        SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to save config");
-                                       __vc_config_release_client(uid);
                                        __vc_config_release_engine();
                                        vc_parser_unload_config(g_config_info);
                                        g_config_info = NULL;
-                                       pthread_mutex_unlock(&vc_config_mgr_mutex);
-                                       ecore_thread_main_loop_end();
-                                       return -1;
+                                       return VC_CONFIG_ERROR_OPERATION_FAILED;
                                }
 
                                free(tmp_language);
@@ -1017,15 +958,41 @@ int vc_config_mgr_initialize(unsigned int uid)
        g_lang_ref_count = 0;
 
        /* Register to detect display language change */
-       vconf_notify_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb, NULL);
+       vconf_notify_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb, nullptr);
+
+       g_config_mgr_initialized = true;
+       return VC_CONFIG_ERROR_NONE;
+}
+
+int vc_config_mgr_initialize(unsigned int uid)
+{
+       vc_config_client_s* temp_client = NULL;
+
+       SLOG(LOG_INFO, vc_config_tag(), "[WARNING] Enter critical section");
+       ecore_thread_main_loop_begin();
+       pthread_mutex_lock(&vc_config_mgr_mutex);
+
+       int ret = __initialize_vc_config_mgr();
+       if (VC_CONFIG_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to initialize vc_config_mgr");
+               pthread_mutex_unlock(&vc_config_mgr_mutex);
+               ecore_thread_main_loop_end();
+               SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
+               return ret;
+       }
+
+       /* Check uid */
+       if (NULL != __find_client_info(uid)) {
+               SLOG(LOG_WARN, vc_config_tag(), "[CONFIG] uid(%u) has already registered", uid);
+               pthread_mutex_unlock(&vc_config_mgr_mutex);
+               ecore_thread_main_loop_end();
+               SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
+               return VC_CONFIG_ERROR_NONE;
+       }
 
        temp_client = (vc_config_client_s*)calloc(1, sizeof(vc_config_client_s));
        if (NULL == temp_client) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to allocate memory");
-               __vc_config_release_client(uid);
-               __vc_config_release_engine();
-               vc_parser_unload_config(g_config_info);
-               g_config_info = NULL;
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                ecore_thread_main_loop_end();
                return VC_ERROR_OUT_OF_MEMORY;
@@ -1036,11 +1003,11 @@ int vc_config_mgr_initialize(unsigned int uid)
        temp_client->lang_cb = NULL;
        temp_client->enabled_cb = NULL;
 
-       SLOG(LOG_DEBUG, vc_config_tag(), "uid(%u) temp_uid(%u)", uid, temp_client->uid);
-
        /* Add uid */
        g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 
+       SLOG(LOG_INFO, vc_config_tag(), "[CONFIG] Add new client. uid(%u)", uid);
+
        __vc_config_mgr_print_client_info();
 
        pthread_mutex_unlock(&vc_config_mgr_mutex);
@@ -1074,6 +1041,7 @@ int vc_config_mgr_finalize(unsigned int uid)
        pthread_mutex_unlock(&vc_config_mgr_mutex);
        SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
 
+       g_config_mgr_initialized = false;
        SLOG(LOG_DEBUG, vc_config_tag(), "[Success] Finalize config");
        return VC_ERROR_NONE;
 }
@@ -1282,7 +1250,7 @@ int vc_config_mgr_get_auto_language(bool* value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
 
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1303,7 +1271,7 @@ int vc_config_mgr_set_auto_language(bool value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
 
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1332,7 +1300,7 @@ int vc_config_mgr_get_engine_list(vc_config_supported_engine_cb callback, void*
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
 
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return VC_CONFIG_ERROR_INVALID_STATE;
@@ -1379,7 +1347,7 @@ int vc_config_mgr_get_engine_list(vc_config_supported_engine_cb callback, void*
 int vc_config_mgr_get_engine(char** engine)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "Not initialized"); //LCOV_EXCL_LINE
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return VC_CONFIG_ERROR_INVALID_STATE;
@@ -1462,7 +1430,7 @@ int __vc_config_set_buxtonkey(const char* engine)
 int vc_config_mgr_set_engine(const char* engine)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return VC_CONFIG_ERROR_INVALID_STATE;
@@ -1505,7 +1473,7 @@ int vc_config_mgr_set_engine(const char* engine)
 
        /* Engine is valid*/
        bool is_language_valid = __is_language_valid(engine_info, g_config_info->language);
-       SLOG(LOG_ERROR, vc_config_tag(), "[INFO] Language(%s), is valid(%d)", g_config_info->language, (int)is_language_valid);
+       SLOG(LOG_ERROR, vc_config_tag(), "[INFO] Language(%s), is valid(%d)", (g_config_info->language ? g_config_info->language : "NULL"), (int)is_language_valid);
 
        char* lang = NULL;
        if (false == is_language_valid) {
@@ -1542,7 +1510,7 @@ int vc_config_mgr_set_engine(const char* engine)
 int vc_config_mgr_get_language_list(vc_supported_language_cb callback, void* user_data)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1585,7 +1553,7 @@ int vc_config_mgr_get_language_list(vc_supported_language_cb callback, void* use
 int vc_config_mgr_get_default_language(char** language)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1610,7 +1578,7 @@ int vc_config_mgr_get_default_language(char** language)
 
 static int __vc_config_mgr_set_default_language(const char* language)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                return -1;
        }
@@ -1647,7 +1615,7 @@ int vc_config_mgr_set_default_language(const char* language)
 int vc_config_mgr_get_enabled(bool* value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1667,7 +1635,7 @@ int vc_config_mgr_get_enabled(bool* value)
 int vc_config_mgr_set_enabled(bool value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1688,7 +1656,7 @@ int vc_config_mgr_set_enabled(bool value)
 int vc_config_mgr_get_nonfixed_support(bool* value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1728,7 +1696,7 @@ int vc_config_mgr_get_nonfixed_support(bool* value)
 bool vc_config_check_default_engine_is_valid(const char* engine)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1755,7 +1723,7 @@ bool vc_config_check_default_engine_is_valid(const char* engine)
 
 bool vc_config_check_default_language_is_valid(const char* language)
 {
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                return -1;
        }
@@ -1788,7 +1756,7 @@ bool vc_config_check_default_language_is_valid(const char* language)
 int vc_config_mgr_set_foreground(int pid, bool value)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;
@@ -1801,7 +1769,7 @@ int vc_config_mgr_set_foreground(int pid, bool value)
 int vc_config_mgr_get_foreground(int* pid)
 {
        pthread_mutex_lock(&vc_config_mgr_mutex);
-       if (0 >= g_slist_length(g_config_client_list)) {
+       if (g_config_mgr_initialized.load() == false) {
                SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Not initialized");
                pthread_mutex_unlock(&vc_config_mgr_mutex);
                return -1;