Remove vc handle in vc and vc_client

Change-Id: I6dc961c12e2949539df54251b8a0b4a752620c3a
Signed-off-by: sooyeon <sooyeon.kim@samsung.com>

diff --git a/client/vc.c b/client/vc.c
index 2d91a4847cf0ad161d1af332388879765a424dc1..4b872c243f263149dac5c5b8b7df90c5769ab6d3 100644 (file)
--- a/client/vc.c
+++ b/client/vc.c
@@ -49,7 +49,7 @@ static Ecore_Event_Handler* g_focus_out_handler = NULL;
 
 static Ecore_Thread* g_tts_thread = NULL;
 
-static vc_h g_vc = NULL;
+static unsigned int g_handle;
 
 static int g_daemon_pid = 0;
 
@@ -238,12 +238,12 @@ static void __vc_lang_changed_cb(const char* before_lang, const char* current_la
 
        vc_current_language_changed_cb callback;
        void* lang_user_data;
-       vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
+       vc_client_get_current_lang_changed_cb(&callback, &lang_user_data);
 
        if (NULL != callback) {
-               vc_client_use_callback(g_vc);
+               vc_client_use_callback();
                callback(before_lang, current_lang, lang_user_data);
-               vc_client_not_use_callback(g_vc);
+               vc_client_not_use_callback();
                SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
        } else {
                SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
@@ -257,17 +257,17 @@ static Eina_Bool __notify_auth_changed_cb(void *data)
        vc_auth_state_changed_cb callback = NULL;
        void* user_data;
 
-       vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
+       vc_client_get_auth_state_changed_cb(&callback, &user_data);
 
        vc_auth_state_e before = -1;
        vc_auth_state_e current = -1;
 
-       vc_client_get_before_auth_state(g_vc, &before, &current);
+       vc_client_get_before_auth_state(&before, &current);
 
        if (NULL != callback) {
-               vc_client_use_callback(g_vc);
+               vc_client_use_callback();
                callback(before, current, user_data);
-               vc_client_not_use_callback(g_vc);
+               vc_client_not_use_callback();
                SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
        } else {
                SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
@@ -288,18 +288,18 @@ static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
                }
 
-               ret = vc_client_set_is_foreground(g_vc, true);
+               ret = vc_client_set_is_foreground(true);
                if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
                }
 
                /* set authority valid */
                vc_auth_state_e state = VC_AUTH_STATE_NONE;
-               if (0 != vc_client_get_auth_state(g_vc, &state)) {
+               if (0 != vc_client_get_auth_state(&state)) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
                }
                if (VC_AUTH_STATE_INVALID == state) {
-                       vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
+                       vc_client_set_auth_state(VC_AUTH_STATE_VALID);
 
                        /* notify auth changed cb */
                        ecore_timer_add(0, __notify_auth_changed_cb, NULL);
@@ -311,18 +311,18 @@ static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
                }
 
-               ret = vc_client_set_is_foreground(g_vc, false);
+               ret = vc_client_set_is_foreground(false);
                if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
                }
 
                /* set authority valid */
                vc_auth_state_e state = VC_AUTH_STATE_NONE;
-               if (0 != vc_client_get_auth_state(g_vc, &state)) {
+               if (0 != vc_client_get_auth_state(&state)) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
                }
                if (VC_AUTH_STATE_VALID == state) {
-                       vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
+                       vc_client_set_auth_state(VC_AUTH_STATE_INVALID);
 
                        /* notify authority changed cb */
                        ecore_timer_add(0, __notify_auth_changed_cb, NULL);
@@ -347,12 +347,7 @@ int vc_initialize(void)
        SLOG(LOG_INFO, TAG_VCC, "@@@ [Client] Initialize");
 
        /* check handle */
-       if (true == vc_client_is_valid(g_vc)) {
-               SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
-               return VC_ERROR_NONE; //LCOV_EXCL_LINE
-       }
-
-       if (0 < vc_client_get_count()) {
+       if (true == vc_client_is_valid()) {
                SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized"); //LCOV_EXCL_LINE
                return VC_ERROR_NONE; //LCOV_EXCL_LINE
        }
@@ -362,28 +357,29 @@ int vc_initialize(void)
                return VC_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
        }
 
-       if (0 != vc_client_create(&g_vc)) {
+       if (0 != vc_client_create()) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!"); //LCOV_EXCL_LINE
                return VC_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
        }
 
-       ret = vc_config_mgr_initialize(g_vc->handle);
+       g_handle = getpid();
+       ret = vc_config_mgr_initialize(g_handle);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
                         __vc_get_error_code(__vc_convert_config_error_code(ret))); //LCOV_EXCL_LINE
-               vc_client_destroy(g_vc); //LCOV_EXCL_LINE
+               vc_client_destroy(); //LCOV_EXCL_LINE
                return __vc_convert_config_error_code(ret); //LCOV_EXCL_LINE
        }
 
-       ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
+       ret = vc_config_mgr_set_lang_cb(g_handle, __vc_lang_changed_cb);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret); //LCOV_EXCL_LINE
-               vc_config_mgr_finalize(g_vc->handle); //LCOV_EXCL_LINE
-               vc_client_destroy(g_vc); //LCOV_EXCL_LINE
+               vc_config_mgr_finalize(g_handle); //LCOV_EXCL_LINE
+               vc_client_destroy(); //LCOV_EXCL_LINE
                return __vc_convert_config_error_code(ret);
        }
 
-       SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
+       SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_handle);
 
 
        return VC_ERROR_NONE;
@@ -393,7 +389,7 @@ static void __vc_internal_unprepare(void)
 {
        /* return authority */
        vc_auth_state_e state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &state)) {
+       if (0 != vc_client_get_auth_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
        }
 
@@ -403,7 +399,7 @@ static void __vc_internal_unprepare(void)
                }
        }
 
-       int ret = vc_tidl_request_finalize(g_vc->handle);
+       int ret = vc_tidl_request_finalize(g_handle);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
        }
@@ -433,13 +429,13 @@ int vc_deinitialize(void)
 
        SLOG(LOG_INFO, TAG_VCC, "@@@ [Client] Deinitialize");
 
-       if (false == vc_client_is_valid(g_vc)) {
+       if (false == vc_client_is_valid()) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
                return VC_ERROR_INVALID_STATE;
        }
 
        vc_state_e state;
-       vc_client_get_client_state(g_vc, &state);
+       vc_client_get_client_state(&state);
 
        /* check state */
        switch (state) {
@@ -453,12 +449,12 @@ int vc_deinitialize(void)
                        g_connect_timer = NULL;
                }
 
-               vc_config_mgr_unset_lang_cb(g_vc->handle);
-               vc_config_mgr_finalize(g_vc->handle);
+               vc_config_mgr_unset_lang_cb(g_handle);
+               vc_config_mgr_finalize(g_handle);
 
                /* Free client resources */
-               vc_client_destroy(g_vc);
-               g_vc = NULL;
+               vc_client_destroy();
+               g_handle = 0;
                break;
        case VC_STATE_NONE:
                break;
@@ -499,8 +495,8 @@ static Eina_Bool __vc_connect_daemon(void *data)
        g_connect_timer = NULL;
 
        /* check handle */
-       if (true == vc_client_is_valid(g_vc)) {
-               SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] g_vc is valid");
+       if (true == vc_client_is_valid()) {
+               SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The current client is valid");
 
                /* Initialize DB */
                ret = vc_db_initialize();
@@ -513,21 +509,21 @@ static Eina_Bool __vc_connect_daemon(void *data)
                if (0 != ret)
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_FOREGROUND, ret); //LCOV_EXCL_LINE
 
-               ret = vc_tidl_request_initialize(g_vc->handle, &mgr_pid, &service_state, &g_daemon_pid);
+               ret = vc_tidl_request_initialize(g_handle, &mgr_pid, &service_state, &g_daemon_pid);
                //LCOV_EXCL_START
                if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
 
-                       vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
-                       ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
+                       vc_client_set_error(VC_ERROR_ENGINE_NOT_FOUND);
+                       ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 
                        return EINA_FALSE;
                //LCOV_EXCL_STOP
                } else if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret)); //LCOV_EXCL_LINE
 
-                       vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
-                       ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
+                       vc_client_set_error(VC_ERROR_TIMED_OUT);
+                       ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 
                        ret = vc_db_finalize();
                        if (0 != ret) {
@@ -541,18 +537,18 @@ static Eina_Bool __vc_connect_daemon(void *data)
 
                /* Set service state */
                vc_service_state_e previous_service_state;
-               vc_client_get_service_state(g_vc, &previous_service_state);
+               vc_client_get_service_state(&previous_service_state);
 
-               vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
+               vc_client_set_service_state((vc_service_state_e)service_state);
 
                vc_service_state_changed_cb service_changed_callback = NULL;
                void* user_data = NULL;
-               vc_client_get_service_state_changed_cb(g_vc, &service_changed_callback, &user_data);
+               vc_client_get_service_state_changed_cb(&service_changed_callback, &user_data);
 
                if (NULL != service_changed_callback) {
-                       vc_client_use_callback(g_vc);
+                       vc_client_use_callback();
                        service_changed_callback(previous_service_state, service_state, user_data);
-                       vc_client_not_use_callback(g_vc);
+                       vc_client_not_use_callback();
                        SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called"); //LCOV_EXCL_LINE
                } else {
                        SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null"); //LCOV_EXCL_LINE
@@ -577,30 +573,30 @@ static Eina_Bool __vc_connect_daemon(void *data)
                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret); //LCOV_EXCL_LINE
                        }
 
-                       ret = vc_client_set_is_foreground(g_vc, true);
+                       ret = vc_client_set_is_foreground(true);
                        if (0 != ret) {
                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret); //LCOV_EXCL_LINE
                        }
 
                        /* set authority valid */
                        vc_auth_state_e state = VC_AUTH_STATE_NONE;
-                       if (0 != vc_client_get_auth_state(g_vc, &state)) {
+                       if (0 != vc_client_get_auth_state(&state)) {
                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state"); //LCOV_EXCL_LINE
                        }
                        if (VC_AUTH_STATE_INVALID == state) {
-                               vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
+                               vc_client_set_auth_state(VC_AUTH_STATE_VALID);
 
                                /* notify auth changed cb */
                                ecore_idler_add(__notify_auth_changed_cb, NULL);
                        }
                }
 
-               vc_client_set_client_state(g_vc, VC_STATE_READY);
-               ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
+               vc_client_set_client_state(VC_STATE_READY);
+               ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
 
-               vc_client_set_mgr_pid(g_vc, mgr_pid);
+               vc_client_set_mgr_pid(mgr_pid);
        } else {
-               SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] g_vc is not valid. It is destroyed."); //LCOV_EXCL_LINE
+               SLOG(LOG_ERROR, TAG_VCC, "[Not ERROR] The current client is not valid. It is destroyed."); //LCOV_EXCL_LINE
                return EINA_FALSE;
        }
 
@@ -663,7 +659,7 @@ int vc_prepare(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available"); //LCOV_EXCL_LINE
                return VC_ERROR_INVALID_STATE;
        }
@@ -688,7 +684,7 @@ int vc_prepare_sync(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Prepare");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -717,7 +713,7 @@ int vc_unprepare(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -727,8 +723,8 @@ int vc_unprepare(void)
 
        __vc_internal_unprepare();
 
-       vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
-       ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
+       vc_client_set_client_state(VC_STATE_INITIALIZED);
+       ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
 
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Unprepare DONE");
 
@@ -745,7 +741,7 @@ int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -774,7 +770,7 @@ int vc_get_current_language(char** language)
        RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -803,7 +799,7 @@ int vc_get_state(vc_state_e* state)
        RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 
        vc_state_e temp;
-       if (0 != vc_client_get_client_state(g_vc, &temp)) {
+       if (0 != vc_client_get_client_state(&temp)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -837,7 +833,7 @@ int vc_get_service_state(vc_service_state_e* state)
        RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 
        vc_state_e temp;
-       if (0 != vc_client_get_client_state(g_vc, &temp)) {
+       if (0 != vc_client_get_client_state(&temp)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -846,7 +842,7 @@ int vc_get_service_state(vc_service_state_e* state)
 
        /* get service state */
        vc_service_state_e service_state;
-       if (0 != vc_client_get_service_state(g_vc, &service_state)) {
+       if (0 != vc_client_get_service_state(&service_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state"); //LCOV_EXCL_LINE
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -882,7 +878,7 @@ int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
        *vc_sys_cmd_list = NULL;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -892,7 +888,7 @@ int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
 
@@ -903,11 +899,11 @@ int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
        ret = -1;
        bool is_prepared = false;
        do {
-               ret = vc_tidl_request_is_system_command_valid(g_vc->handle, &is_sys_cmd_valid);
+               ret = vc_tidl_request_is_system_command_valid(g_handle, &is_sys_cmd_valid);
                if (0 != ret) {
                        //LCOV_EXCL_START
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -929,7 +925,7 @@ int vc_get_system_command_list(vc_cmd_list_h* vc_sys_cmd_list)
        } while (0 != ret);
 
        int mgr_pid = -1;
-       ret = vc_client_get_mgr_pid(g_vc, &mgr_pid);
+       ret = vc_client_get_mgr_pid(&mgr_pid);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get the manager pid"); //LCOV_EXCL_LINE
                return VC_ERROR_OPERATION_FAILED;
@@ -994,7 +990,7 @@ int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Is command format supported");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1024,7 +1020,7 @@ int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
 
 static int __vc_get_invocation_name(char** invocation_name)
 {
-       int ret = vc_client_get_invocation_name(g_vc, invocation_name);
+       int ret = vc_client_get_invocation_name(invocation_name);
        if (0 != ret) {
                SLOG(LOG_WARN, TAG_VCC, "Fail to get invocation name"); //LCOV_EXCL_LINE
                return ret; //LCOV_EXCL_LINE
@@ -1081,17 +1077,17 @@ static int __vc_get_invocation_name(char** invocation_name)
        return VC_ERROR_NONE;
 }
 
-void __set_command(vc_h vc, vc_cmd_type_e type)
+void __set_command(vc_cmd_type_e type)
 {
        int ret = -1;
        int count = 0;
        bool is_prepared = false;
        do {
-               ret = vc_tidl_request_set_command(vc->handle, type);
+               ret = vc_tidl_request_set_command(g_handle, type);
                if (0 != ret) {
                        //LCOV_EXCL_START
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -1125,7 +1121,7 @@ int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
        RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Input parameter is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1164,7 +1160,7 @@ int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
        } else {
-               __set_command(g_vc, (vc_cmd_type_e)type);
+               __set_command((vc_cmd_type_e)type);
        }
 
        FREE(invocation_name);
@@ -1185,7 +1181,7 @@ int vc_unset_command_list(int type)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1200,11 +1196,11 @@ int vc_unset_command_list(int type)
        ret = -1;
        bool is_prepared = false;
        while (0 != ret) {
-               ret = vc_tidl_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
+               ret = vc_tidl_request_unset_command(g_handle, (vc_cmd_type_e)type);
                if (0 != ret) {
                        //LCOV_EXCL_START
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -1245,7 +1241,7 @@ int vc_set_command_list_from_file(const char* file_path, int type)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1280,7 +1276,7 @@ int vc_set_command_list_from_file(const char* file_path, int type)
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
        } else {
-               __set_command(g_vc, (vc_cmd_type_e)type);
+               __set_command((vc_cmd_type_e)type);
        }
 
        FREE(invocation_name);
@@ -1550,19 +1546,17 @@ int vc_request_cancel(void)
 //LCOV_EXCL_START
 static void __vc_notify_error(void *data)
 {
-       vc_h vc = (vc_h)data;
-
        vc_error_cb callback = NULL;
        void* user_data;
        int reason;
 
-       vc_client_get_error_cb(vc, &callback, &user_data);
-       vc_client_get_error(vc, &reason);
+       vc_client_get_error_cb(&callback, &user_data);
+       vc_client_get_error(&reason);
 
        if (NULL != callback) {
-               vc_client_use_callback(vc);
+               vc_client_use_callback();
                callback(reason, user_data);
-               vc_client_not_use_callback(vc);
+               vc_client_not_use_callback();
                SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
        } else {
                SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
@@ -1572,7 +1566,7 @@ static void __vc_notify_error(void *data)
 int __vc_cb_error(int reason, int daemon_pid, char* msg)
 {
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
                return VC_ERROR_INVALID_PARAMETER;
        }
@@ -1590,8 +1584,8 @@ int __vc_cb_error(int reason, int daemon_pid, char* msg)
        if (VC_ERROR_SERVICE_RESET == reason) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
 
-               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
-               ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, (void*)g_vc);
+               vc_client_set_client_state(VC_STATE_INITIALIZED);
+               ecore_main_loop_thread_safe_call_async(__vc_notify_state_changed, NULL);
 
                if (0 != vc_prepare()) {
                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
@@ -1600,8 +1594,8 @@ int __vc_cb_error(int reason, int daemon_pid, char* msg)
 
        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
 
-       vc_client_set_error(g_vc, reason);
-       ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
+       vc_client_set_error(reason);
+       ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -1609,39 +1603,30 @@ int __vc_cb_error(int reason, int daemon_pid, char* msg)
 int __vc_cb_error_to_app(int pid, int reason, const char* msg)
 {
        SLOG(LOG_INFO, TAG_VCC, "[INFO] send error to app(%d)", pid);
-
-       vc_h vc;
-       if (0 != vc_client_get_handle(pid, &vc)) {
-               SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get vc handle");
-               return VC_ERROR_INVALID_PARAMETER;
-       }
-
        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
 
-       vc_client_set_error(vc, reason);
-       ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)vc);
+       vc_client_set_error(reason);
+       ecore_main_loop_thread_safe_call_async(__vc_notify_error, NULL);
 
        return VC_ERROR_NONE;
 }
 
 static void __vc_notify_state_changed(void *data)
 {
-       vc_h vc = (vc_h)data;
-
        vc_state_changed_cb changed_callback = NULL;
        void* user_data;
 
-       vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
+       vc_client_get_state_changed_cb(&changed_callback, &user_data);
 
        vc_state_e current_state;
        vc_state_e before_state;
 
-       vc_client_get_before_state(vc, &current_state, &before_state);
+       vc_client_get_before_state(&current_state, &before_state);
 
        if (NULL != changed_callback) {
-               vc_client_use_callback(vc);
+               vc_client_use_callback();
                changed_callback(before_state, current_state, user_data);
-               vc_client_not_use_callback(vc);
+               vc_client_not_use_callback();
                SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
        } else {
                SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
@@ -1657,7 +1642,7 @@ static Eina_Bool __vc_notify_result(void *data)
        vc_result_cb callback = NULL;
        void* user_data = NULL;
 
-       vc_client_get_result_cb(g_vc, &callback, &user_data);
+       vc_client_get_result_cb(&callback, &user_data);
 
        RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCC, "[ERROR] Client result callback is NULL");
 
@@ -1672,9 +1657,9 @@ static Eina_Bool __vc_notify_result(void *data)
 
        vc_cmd_print_list(vc_cmd_list);
 
-       vc_client_use_callback(g_vc);
+       vc_client_use_callback();
        callback(event, vc_cmd_list, temp_text, user_data);
-       vc_client_not_use_callback(g_vc);
+       vc_client_not_use_callback();
 
        SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
 
@@ -1703,7 +1688,7 @@ int vc_get_result(vc_result_cb callback, void* user_data)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1735,9 +1720,9 @@ int vc_get_result(vc_result_cb callback, void* user_data)
 
        vc_cmd_print_list(vc_cmd_list);
 
-       vc_client_use_callback(g_vc);
+       vc_client_use_callback();
        callback(event, vc_cmd_list, temp_text, user_data);
-       vc_client_not_use_callback(g_vc);
+       vc_client_not_use_callback();
 
        vc_cmd_list_destroy(vc_cmd_list, true);
        vc_cmd_list = NULL;
@@ -1760,7 +1745,7 @@ int vc_set_result_cb(vc_result_cb callback, void* user_data)
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client result callback is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1768,7 +1753,7 @@ int vc_set_result_cb(vc_result_cb callback, void* user_data)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_result_cb(g_vc, callback, user_data);
+       vc_client_set_result_cb(callback, user_data);
 
        return VC_ERROR_NONE;
 }
@@ -1781,7 +1766,7 @@ int vc_unset_result_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1789,7 +1774,7 @@ int vc_unset_result_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_result_cb(g_vc, NULL, NULL);
+       vc_client_set_result_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -1799,7 +1784,7 @@ int __vc_cb_service_state(int state)
 {
        vc_service_state_e current_state = (vc_service_state_e)state;
        vc_service_state_e before_state;
-       vc_client_get_service_state(g_vc, &before_state);
+       vc_client_get_service_state(&before_state);
 
        if (current_state == before_state) {
                return VC_ERROR_NONE;
@@ -1809,16 +1794,16 @@ int __vc_cb_service_state(int state)
                before_state, current_state);
 
        /* Save service state */
-       vc_client_set_service_state(g_vc, current_state);
+       vc_client_set_service_state(current_state);
 
        vc_service_state_changed_cb callback = NULL;
        void* service_user_data;
-       vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
+       vc_client_get_service_state_changed_cb(&callback, &service_user_data);
 
        if (NULL != callback) {
-               vc_client_use_callback(g_vc);
+               vc_client_use_callback();
                callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
-               vc_client_not_use_callback(g_vc);
+               vc_client_not_use_callback();
                SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
        } else {
                SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
@@ -1832,7 +1817,7 @@ int __vc_cb_manager_pid(int manager_pid)
        SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
 
        /* Save service state */
-       vc_client_set_mgr_pid(g_vc, manager_pid);
+       vc_client_set_mgr_pid(manager_pid);
 
        return VC_ERROR_NONE;
 }
@@ -1848,7 +1833,7 @@ int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void*
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client service state changed callback is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1856,7 +1841,7 @@ int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void*
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
+       vc_client_set_service_state_changed_cb(callback, user_data);
 
        return VC_ERROR_NONE;
 }
@@ -1869,7 +1854,7 @@ int vc_unset_service_state_changed_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1877,7 +1862,7 @@ int vc_unset_service_state_changed_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
+       vc_client_set_service_state_changed_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -1892,7 +1877,7 @@ int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client state changed callback is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1900,7 +1885,7 @@ int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_state_changed_cb(g_vc, callback, user_data);
+       vc_client_set_state_changed_cb(callback, user_data);
 
        return VC_ERROR_NONE;
 }
@@ -1913,7 +1898,7 @@ int vc_unset_state_changed_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1921,7 +1906,7 @@ int vc_unset_state_changed_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_state_changed_cb(g_vc, NULL, NULL);
+       vc_client_set_state_changed_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -1936,7 +1921,7 @@ int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback,
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client current language changed callback is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1944,7 +1929,7 @@ int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback,
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
+       vc_client_set_current_lang_changed_cb(callback, user_data);
 
        return VC_ERROR_NONE;
 }
@@ -1957,7 +1942,7 @@ int vc_unset_current_language_changed_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1965,7 +1950,7 @@ int vc_unset_current_language_changed_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
+       vc_client_set_current_lang_changed_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -1980,7 +1965,7 @@ int vc_set_error_cb(vc_error_cb callback, void* user_data)
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Client error callback is NULL");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -1988,7 +1973,7 @@ int vc_set_error_cb(vc_error_cb callback, void* user_data)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_error_cb(g_vc, callback,  user_data);
+       vc_client_set_error_cb(callback,  user_data);
 
        return VC_ERROR_NONE;
 }
@@ -2001,7 +1986,7 @@ int vc_unset_error_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2009,7 +1994,7 @@ int vc_unset_error_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_error_cb(g_vc, NULL, NULL);
+       vc_client_set_error_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -2024,7 +2009,7 @@ int vc_set_invocation_name(const char* name)
        vc_state_e state;
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
 
-       ret = vc_client_get_client_state(g_vc, &state);
+       ret = vc_client_get_client_state(&state);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return ret;
@@ -2033,7 +2018,7 @@ int vc_set_invocation_name(const char* name)
        /* check state */
        RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 
-       ret = vc_client_set_invocation_name(g_vc, name);
+       ret = vc_client_set_invocation_name(name);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
        }
@@ -2051,7 +2036,7 @@ int vc_set_server_dialog(const char* app_id, const char* credential)
 
        RETVM_IF(NULL == credential, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Credential is NULL");
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2061,7 +2046,7 @@ int vc_set_server_dialog(const char* app_id, const char* credential)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
 
@@ -2088,7 +2073,7 @@ int vc_set_server_dialog(const char* app_id, const char* credential)
                ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2125,7 +2110,7 @@ int vc_unset_server_dialog(const char* app_id)
        if (VC_ERROR_NONE != ret)
                return ret;
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2135,7 +2120,7 @@ int vc_unset_server_dialog(const char* app_id)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
 
@@ -2160,7 +2145,7 @@ int vc_unset_server_dialog(const char* app_id)
                ret = vc_tidl_request_set_server_dialog(pid, tmp_appid, credential);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2197,7 +2182,7 @@ int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_sta
        if (VC_ERROR_NONE != ret)
                return ret;
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2207,7 +2192,7 @@ int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_sta
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog : pid(%d) disp_text(%s), utt_text(%s), auto_start(%d)", getpid(), disp_text, utt_text, auto_start);
@@ -2228,7 +2213,7 @@ int vc_auth_enable(void)
 {
        /* check state */
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2236,7 +2221,7 @@ int vc_auth_enable(void)
 
        /* check already authority */
        vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2244,19 +2229,19 @@ int vc_auth_enable(void)
 
        /* request authority */
        int mgr_pid = -1;
-       if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
+       if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != vc_tidl_request_auth_enable(g_vc->handle, mgr_pid)) {
+       if (0 != vc_tidl_request_auth_enable(g_handle, mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
                return VC_ERROR_OPERATION_FAILED;
        }
 
        /* set authority into handle */
        bool is_foreground = false;
-       if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
+       if (0 != vc_client_get_is_foreground(&is_foreground)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2267,7 +2252,7 @@ int vc_auth_enable(void)
                auth_state = VC_AUTH_STATE_INVALID;
        }
 
-       if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
+       if (0 != vc_client_set_auth_state(auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2283,7 +2268,7 @@ int vc_auth_disable(void)
 {
        /* check state */
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2291,7 +2276,7 @@ int vc_auth_disable(void)
 
        /* check authority */
        vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2303,18 +2288,18 @@ int vc_auth_disable(void)
 
        /* request return authority by tidl */
        int mgr_pid = -1;
-       if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
+       if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != vc_tidl_request_auth_disable(g_vc->handle, mgr_pid)) {
+       if (0 != vc_tidl_request_auth_disable(g_handle, mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
                return VC_ERROR_OPERATION_FAILED;
        }
 
        /* unset authority from handle */
-       if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
+       if (0 != vc_client_set_auth_state(VC_AUTH_STATE_NONE)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2330,7 +2315,7 @@ int vc_auth_get_state(vc_auth_state_e* state)
 {
        /* check state */
        vc_state_e vc_state;
-       if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
+       if (0 != vc_client_get_client_state(&vc_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2338,7 +2323,7 @@ int vc_auth_get_state(vc_auth_state_e* state)
 
        /* get authority */
        vc_auth_state_e temp = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &temp)) {
+       if (0 != vc_client_get_auth_state(&temp)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2360,14 +2345,14 @@ int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_d
 
        /* check auth */
        vc_auth_state_e auth_state;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
        RETVM_IF(VC_AUTH_STATE_NONE == auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Auth is not enabled");
 
        /* set cb into handle */
-       if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
+       if (0 != vc_client_set_auth_state_changed_cb(callback, user_data)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2381,14 +2366,14 @@ int vc_auth_unset_state_changed_cb(void)
 {
        /* check auth */
        vc_auth_state_e auth_state;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
        RETVM_IF(VC_AUTH_STATE_NONE == auth_state, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Auth is not enabled");
 
        /* unset cb from handle */
-       if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
+       if (0 != vc_client_unset_auth_state_changed_cb()) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2403,7 +2388,7 @@ int vc_auth_start(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2413,12 +2398,12 @@ int vc_auth_start(void)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
        /* Check authority */
        vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2426,7 +2411,7 @@ int vc_auth_start(void)
 
        /* get mgr_pid */
        int mgr_pid = -1;
-       if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
+       if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2436,10 +2421,10 @@ int vc_auth_start(void)
        bool is_prepared = false;
        /* Request */
        while (0 != ret) {
-               ret = vc_tidl_request_auth_start(g_vc->handle, mgr_pid);
+               ret = vc_tidl_request_auth_start(g_handle, mgr_pid);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2471,7 +2456,7 @@ int vc_auth_stop(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2481,12 +2466,12 @@ int vc_auth_stop(void)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_RECORDING, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'RECORDING'", service_state);
 
        /* Check authority */
        vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2494,7 +2479,7 @@ int vc_auth_stop(void)
 
        /* get mgr_pid */
        int mgr_pid = -1;
-       if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
+       if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2504,10 +2489,10 @@ int vc_auth_stop(void)
        bool is_prepared = false;
        /* do request */
        while (0 != ret) {
-               ret = vc_tidl_request_auth_stop(g_vc->handle, mgr_pid);
+               ret = vc_tidl_request_auth_stop(g_handle, mgr_pid);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2539,7 +2524,7 @@ int vc_auth_cancel(void)
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2549,7 +2534,7 @@ int vc_auth_cancel(void)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
                return VC_ERROR_INVALID_STATE;
@@ -2557,7 +2542,7 @@ int vc_auth_cancel(void)
 
        /* Check authority */
        vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
-       if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
+       if (0 != vc_client_get_auth_state(&auth_state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2565,7 +2550,7 @@ int vc_auth_cancel(void)
 
        /* get mgr_pid */
        int mgr_pid = -1;
-       if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
+       if (0 != vc_client_get_mgr_pid(&mgr_pid)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
                return VC_ERROR_OPERATION_FAILED;
        }
@@ -2574,10 +2559,10 @@ int vc_auth_cancel(void)
        int count = 0;
        bool is_prepared = false;
        while (0 != ret) {
-               ret = vc_tidl_request_auth_cancel(g_vc->handle, mgr_pid);
+               ret = vc_tidl_request_auth_cancel(g_handle, mgr_pid);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2611,7 +2596,7 @@ static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
        vc_tts_streaming_cb callback = NULL;
        void* user_data = NULL;
 
-       vc_client_get_tts_streaming_cb(g_vc, &callback, &user_data);
+       vc_client_get_tts_streaming_cb(&callback, &user_data);
        RETM_IF(NULL == callback, TAG_VCC, "[WARNING] tts streaming callback is null");
 
        while (1) {
@@ -2648,9 +2633,9 @@ static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
 
                if (NULL != tts_data) {
                        SLOG(LOG_DEBUG, TAG_VCC, "tts streaming callback is called");
-                       vc_client_use_callback(g_vc);
+                       vc_client_use_callback();
                        callback(tts_data->event, tts_data->data, tts_data->data_size, tts_data->utt_id, user_data);
-                       vc_client_not_use_callback(g_vc);
+                       vc_client_not_use_callback();
 
                        /* If no tts data and EVENT_FINISH */
                        if (0 >= vc_data_get_tts_data_size() && VC_TTS_EVENT_FINISH == tts_data->event) {
@@ -2724,7 +2709,7 @@ int vc_tts_request(const char* text, const char* language, bool to_vc_manager, i
        if (VC_ERROR_NONE != ret)
                return ret;
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2734,7 +2719,7 @@ int vc_tts_request(const char* text, const char* language, bool to_vc_manager, i
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts request, pid(%d), text(%s), language(%s), to_vc_manager(%d)", pid, text, language, to_vc_manager);
@@ -2745,7 +2730,7 @@ int vc_tts_request(const char* text, const char* language, bool to_vc_manager, i
                ret = vc_tidl_request_request_tts(pid, text, language, to_vc_manager, utt_id);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2782,7 +2767,7 @@ int vc_tts_cancel(int utt_id)
        if (VC_ERROR_NONE != ret)
                return ret;
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2792,7 +2777,7 @@ int vc_tts_cancel(int utt_id)
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts cancel, pid(%d), utt_id(%d)", pid, utt_id);
@@ -2808,7 +2793,7 @@ int vc_tts_cancel(int utt_id)
                ret = vc_tidl_request_cancel_tts(pid, utt_id);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2845,7 +2830,7 @@ int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel,
        if (VC_ERROR_NONE != ret)
                return ret;
 
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2855,7 +2840,7 @@ int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel,
 
        /* Check service state */
        vc_service_state_e service_state = -1;
-       vc_client_get_service_state(g_vc, &service_state);
+       vc_client_get_service_state(&service_state);
        RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 
        SLOG(LOG_DEBUG, TAG_VCC, "@@@ get tts audio format, pid(%d)", pid);
@@ -2866,7 +2851,7 @@ int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel,
                ret = vc_tidl_request_get_tts_audio_format(pid, rate, channel, audio_type);
                if (0 != ret) {
                        if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
-                               vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
+                               vc_client_set_client_state(VC_STATE_INITIALIZED);
                                if (0 == vc_prepare_sync()) {
                                        is_prepared = true;
                                        SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
@@ -2902,7 +2887,7 @@ int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
                return VC_ERROR_INVALID_PARAMETER;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2910,7 +2895,7 @@ int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_tts_streaming_cb(g_vc, callback,  user_data);
+       vc_client_set_tts_streaming_cb(callback,        user_data);
 
        return VC_ERROR_NONE;
 }
@@ -2923,7 +2908,7 @@ int vc_tts_unset_streaming_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2931,7 +2916,7 @@ int vc_tts_unset_streaming_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_tts_streaming_cb(g_vc, NULL, NULL);
+       vc_client_set_tts_streaming_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }
@@ -2941,13 +2926,13 @@ int __vc_cb_utterance_status(int utt_id, int utt_status)
        vc_tts_utterance_status_cb callback = NULL;
        void* user_data = NULL;
 
-       vc_client_get_tts_utterance_status_cb(g_vc, &callback, &user_data);
+       vc_client_get_tts_utterance_status_cb(&callback, &user_data);
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Utterance status callback is null");
 
        SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
-       vc_client_use_callback(g_vc);
+       vc_client_use_callback();
        callback(utt_id, (vc_tts_utterance_status_e)utt_status, user_data);
-       vc_client_not_use_callback(g_vc);
+       vc_client_not_use_callback();
 
        return VC_ERROR_NONE;
 }
@@ -2962,7 +2947,7 @@ int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* us
        RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCC, "[ERROR] Utterance status callback is null");
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2970,7 +2955,7 @@ int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* us
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_tts_utterance_status_cb(g_vc, callback,  user_data);
+       vc_client_set_tts_utterance_status_cb(callback,  user_data);
 
        return VC_ERROR_NONE;
 }
@@ -2983,7 +2968,7 @@ int vc_tts_unset_utterance_status_cb(void)
                return ret;
 
        vc_state_e state;
-       if (0 != vc_client_get_client_state(g_vc, &state)) {
+       if (0 != vc_client_get_client_state(&state)) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : A handle is not available");
                return VC_ERROR_INVALID_STATE;
        }
@@ -2991,7 +2976,7 @@ int vc_tts_unset_utterance_status_cb(void)
        /* check state */
        RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 
-       vc_client_set_tts_utterance_status_cb(g_vc, NULL, NULL);
+       vc_client_set_tts_utterance_status_cb(NULL, NULL);
 
        return VC_ERROR_NONE;
 }

diff --git a/client/vc_client.c b/client/vc_client.c
index 5431b99c5907d2701f280a12e30e07f7fa09e619..4aacf8a10c7cd843e99153b8adde76e6f66d2f5f 100644 (file)
--- a/client/vc_client.c
+++ b/client/vc_client.c
@@ -19,7 +19,6 @@
 
 typedef struct {
        /* base info */
-       vc_h    vc;
        int     pid;
        unsigned int uid;               /*<< unique id = pid + handle */
        int     xid;            /*<< main X window id */
@@ -74,152 +73,92 @@ typedef struct {
        char*   invocation_name;
 } vc_client_s;
 
-/* client list */
-static GSList *g_client_list = NULL;
+static vc_client_s *g_client = NULL;
 
 
-static vc_client_s* __client_get(vc_h vc)
+int vc_client_create(void)
 {
-       if (vc == NULL) {
-               return NULL;
-       }
-
-       vc_client_s *data = NULL;
-
-       int count = g_slist_length(g_client_list);
-       int i;
-
-       for (i = 0; i < count; i++) {
-               data = g_slist_nth_data(g_client_list, i);
-
-               if (NULL != data) {
-                       if (vc->handle == data->vc->handle) {
-                               return data;
-                       }
-               }
-       }
-
-       SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Fail to get client by vc"); //LCOV_EXCL_LINE
-
-       return NULL;
-}
-
-int vc_client_create(vc_h* vc)
-{
-       vc_client_s *client = NULL;
-
-       client = (vc_client_s*)calloc(1, sizeof(vc_client_s));
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
-               return VC_ERROR_OUT_OF_MEMORY;
+       if (NULL != g_client) {
+               SLOG(LOG_WARN, TAG_VCC, "[WARNING] A client is already exist.");
+               return VC_ERROR_NONE;
        }
 
-       vc_h temp = (vc_h)calloc(1, sizeof(struct vc_s));
-       if (NULL == temp) {
+       g_client = (vc_client_s*)calloc(1, sizeof(vc_client_s));
+       if (NULL == g_client) {
                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
-               free(client);
                return VC_ERROR_OUT_OF_MEMORY;
        }
 
-       temp->handle = getpid();
-
        /* initialize client data */
-       client->vc = temp;
-       client->pid = getpid();
-       client->uid = temp->handle;
-       client->xid = -1;
-
-       client->result_cb = NULL;
-       client->result_user_data = NULL;
-       client->service_state_changed_cb = NULL;
-       client->service_state_changed_user_data = NULL;
-       client->state_changed_cb = NULL;
-       client->state_changed_user_data = NULL;
-       client->current_lang_changed_cb = NULL;
-       client->current_lang_changed_user_data = NULL;
-       client->error_cb = NULL;
-       client->error_user_data = NULL;
-       client->tts_streaming_cb = NULL;
-       client->tts_streaming_user_data = NULL;
-       client->tts_utterance_status_cb = NULL;
-       client->tts_utterance_status_user_data = NULL;
+       g_client->pid = getpid();
+       g_client->uid = getpid();
+       g_client->xid = -1;
+
+       g_client->result_cb = NULL;
+       g_client->result_user_data = NULL;
+       g_client->service_state_changed_cb = NULL;
+       g_client->service_state_changed_user_data = NULL;
+       g_client->state_changed_cb = NULL;
+       g_client->state_changed_user_data = NULL;
+       g_client->current_lang_changed_cb = NULL;
+       g_client->current_lang_changed_user_data = NULL;
+       g_client->error_cb = NULL;
+       g_client->error_user_data = NULL;
+       g_client->tts_streaming_cb = NULL;
+       g_client->tts_streaming_user_data = NULL;
+       g_client->tts_utterance_status_cb = NULL;
+       g_client->tts_utterance_status_user_data = NULL;
 
 #if 0
-       client->exclusive_cmd = false;
+       g_client->exclusive_cmd = false;
 #endif
 
-       client->service_state = VC_RUNTIME_INFO_NO_FOREGROUND;
+       g_client->service_state = VC_RUNTIME_INFO_NO_FOREGROUND;
 
-       client->before_state = VC_STATE_INITIALIZED;
-       client->current_state = VC_STATE_INITIALIZED;
+       g_client->before_state = VC_STATE_INITIALIZED;
+       g_client->current_state = VC_STATE_INITIALIZED;
 
-       client->cb_ref_count = 0;
+       g_client->cb_ref_count = 0;
 
        /* Authority */
-       client->auth_before_state = VC_AUTH_STATE_NONE;
-       client->auth_current_state = VC_AUTH_STATE_NONE;
-       client->auth_state_changed_cb = NULL;
-       client->auth_state_changed_user_data = NULL;
-
-       client->is_foreground = false;
-       client->invocation_name = NULL;
+       g_client->auth_before_state = VC_AUTH_STATE_NONE;
+       g_client->auth_current_state = VC_AUTH_STATE_NONE;
+       g_client->auth_state_changed_cb = NULL;
+       g_client->auth_state_changed_user_data = NULL;
 
-       SLOG(LOG_INFO, TAG_VCC, "[INFO] client create. uid(%u)", client->uid);
+       g_client->is_foreground = false;
+       g_client->invocation_name = NULL;
 
-       g_client_list = g_slist_append(g_client_list, client);
-
-       *vc = temp;
+       SLOG(LOG_INFO, TAG_VCC, "[INFO] client create. uid(%u)", g_client->uid);
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_destroy(vc_h vc)
+int vc_client_destroy(void)
 {
-       if (vc == NULL) {
-               SLOG(LOG_ERROR, TAG_VCC, "Input parameter is NULL"); //LCOV_EXCL_LINE
+       if (NULL == g_client) {
+               SLOG(LOG_ERROR, TAG_VCC, "A client is already NULL"); //LCOV_EXCL_LINE
                return VC_ERROR_NONE;
        }
 
-       vc_client_s *data = NULL;
-
-       int count = g_slist_length(g_client_list);
-       int i;
-
-       for (i = 0; i < count; i++) {
-               data = g_slist_nth_data(g_client_list, i);
-
-               if (NULL != data) {
-                       if (vc->handle == data->vc->handle) {
-                               g_client_list =  g_slist_remove(g_client_list, data);
-
-                               while (0 != data->cb_ref_count) {
-                                       /* wait for release callback function */
-                               }
-                               if (NULL != data->invocation_name) {
-                                       free(data->invocation_name);
-                                       data->invocation_name = NULL;
-                               }
-                               free(data);
-                               free(vc);
-                               data = NULL;
-                               vc = NULL;
-                               return VC_ERROR_NONE;
-                       }
-               }
+       while (0 != g_client->cb_ref_count) {
+               /* wait for release callback function */
        }
+       if (NULL != g_client->invocation_name) {
+               free(g_client->invocation_name);
+               g_client->invocation_name = NULL;
+       }
+       free(g_client);
+       g_client = NULL;
 
-       SLOG(LOG_ERROR, TAG_VCC, "[ERROR] client Not found");
-
-       return VC_ERROR_INVALID_PARAMETER;
+       return VC_ERROR_NONE;
 }
 
-bool vc_client_is_valid(vc_h vc)
+bool vc_client_is_valid(void)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client) {
-               SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] vc is not valid");
+       if (NULL == g_client) {
+               SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The current client is not valid");
                return false;
        }
 
@@ -227,303 +166,265 @@ bool vc_client_is_valid(vc_h vc)
 }
 
 //LCOV_EXCL_START
-int vc_client_get_handle(int pid, vc_h* vc)
-{
-       vc_client_s *data = NULL;
+// int vc_client_get_handle(int pid, vc_h* vc)
+// {
+//     vc_client_s *data = NULL;
 
-       int count = g_slist_length(g_client_list);
-       int i;
+//     int count = g_slist_length(g_client_list);
+//     int i;
 
-       SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The number of VC clients(%d)", count);
+//     SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] The number of VC clients(%d)", count);
 
-       for (i = 0; i < count; i++) {
-               data = g_slist_nth_data(g_client_list, i);
+//     for (i = 0; i < count; i++) {
+//             data = g_slist_nth_data(g_client_list, i);
 
-               if (NULL != data) {
-                       SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] pid(%d), handle(%d)", pid, data->vc->handle);
-                       if (pid == data->vc->handle) {
-                               *vc = data->vc;
-                               return VC_ERROR_NONE;
-                       }
-               }
-       }
+//             if (NULL != data) {
+//                     SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] pid(%d), handle(%d)", pid, data->vc->handle);
+//                     if (pid == data->vc->handle) {
+//                             *vc = data->vc;
+//                             return VC_ERROR_NONE;
+//                     }
+//             }
+//     }
 
-       return VC_ERROR_INVALID_PARAMETER;
-}
+//     return VC_ERROR_INVALID_PARAMETER;
+// }
 //LCOV_EXCL_STOP
 
 /* set/get callback function */
-int vc_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data)
+int vc_client_set_result_cb(vc_result_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->result_cb = callback;
-       client->result_user_data = user_data;
+       g_client->result_cb = callback;
+       g_client->result_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
-int vc_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data)
+int vc_client_get_result_cb(vc_result_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->result_cb;
-       *user_data = client->result_user_data;
+       *callback = g_client->result_cb;
+       *user_data = g_client->result_user_data;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
-int vc_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
+int vc_client_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->service_state_changed_cb = callback;
-       client->service_state_changed_user_data = user_data;
+       g_client->service_state_changed_cb = callback;
+       g_client->service_state_changed_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
-int vc_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data)
+int vc_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->service_state_changed_cb;
-       *user_data = client->service_state_changed_user_data;
+       *callback = g_client->service_state_changed_cb;
+       *user_data = g_client->service_state_changed_user_data;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
-int vc_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data)
+int vc_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->state_changed_cb = callback;
-       client->state_changed_user_data = user_data;
+       g_client->state_changed_cb = callback;
+       g_client->state_changed_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
-int vc_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data)
+int vc_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->state_changed_cb;
-       *user_data = client->state_changed_user_data;
+       *callback = g_client->state_changed_cb;
+       *user_data = g_client->state_changed_user_data;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
-int vc_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data)
+int vc_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->current_lang_changed_cb = callback;
-       client->current_lang_changed_user_data = user_data;
+       g_client->current_lang_changed_cb = callback;
+       g_client->current_lang_changed_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
-int vc_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data)
+int vc_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->current_lang_changed_cb;
-       *user_data = client->current_lang_changed_user_data;
+       *callback = g_client->current_lang_changed_cb;
+       *user_data = g_client->current_lang_changed_user_data;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
-int vc_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data)
+int vc_client_set_error_cb(vc_error_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->error_cb = callback;
-       client->error_user_data = user_data;
+       g_client->error_cb = callback;
+       g_client->error_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
-int vc_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data)
+int vc_client_get_error_cb(vc_error_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->error_cb;
-       *user_data = client->error_user_data;
+       *callback = g_client->error_cb;
+       *user_data = g_client->error_user_data;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
 /* set/get option */
-int vc_client_set_service_state(vc_h vc, vc_service_state_e state)
+int vc_client_set_service_state(vc_service_state_e state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->service_state = state;
+       g_client->service_state = state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_service_state(vc_h vc, vc_service_state_e* state)
+int vc_client_get_service_state(vc_service_state_e* state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *state = client->service_state;
+       *state = g_client->service_state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_client_state(vc_h vc, vc_state_e state)
+int vc_client_set_client_state(vc_state_e state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->before_state = client->current_state;
-       client->current_state = state;
+       g_client->before_state = g_client->current_state;
+       g_client->current_state = state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_client_state(vc_h vc, vc_state_e* state)
+int vc_client_get_client_state(vc_state_e* state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *state = client->current_state;
+       *state = g_client->current_state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_before_state(vc_h vc, vc_state_e* state, vc_state_e* before_state)
+int vc_client_get_before_state(vc_state_e* state, vc_state_e* before_state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *before_state = client->before_state;
-       *state = client->current_state;
+       *before_state = g_client->before_state;
+       *state = g_client->current_state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_invocation_name(vc_h vc, const char* invocation_name)
+int vc_client_set_invocation_name(const char* invocation_name)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       if (NULL != client->invocation_name) {
-               free(client->invocation_name);
-               client->invocation_name = NULL;
+       if (NULL != g_client->invocation_name) {
+               free(g_client->invocation_name);
+               g_client->invocation_name = NULL;
        }
 
        if (NULL != invocation_name) {
-               client->invocation_name = strdup(invocation_name);
+               g_client->invocation_name = strdup(invocation_name);
        }
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_invocation_name(vc_h vc, char** invocation_name)
+int vc_client_get_invocation_name(char** invocation_name)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       if (NULL != client->invocation_name)
-               *invocation_name = strdup(client->invocation_name);
+       if (NULL != g_client->invocation_name)
+               *invocation_name = strdup(g_client->invocation_name);
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_is_foreground(vc_h vc, bool value)
+int vc_client_set_is_foreground(bool value)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->is_foreground = value;
+       g_client->is_foreground = value;
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_is_foreground(vc_h vc, bool* value)
+int vc_client_get_is_foreground(bool* value)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *value = client->is_foreground;
+       *value = g_client->is_foreground;
 
        return VC_ERROR_NONE;
 }
@@ -558,227 +459,190 @@ int vc_client_get_exclusive_cmd(vc_h vc, bool* value)
 #endif
 //LCOV_EXCL_STOP
 
-int vc_client_set_error(vc_h vc, int reason)
+int vc_client_set_error(int reason)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->reason = reason;
+       g_client->reason = reason;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_error(vc_h vc, int* reason)
+int vc_client_get_error(int* reason)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *reason = client->reason;
+       *reason = g_client->reason;
 
        return VC_ERROR_NONE;
 }
 
 
 /* utils */
-int vc_client_get_count()
+int vc_client_use_callback(void)
 {
-       return g_slist_length(g_client_list);
-}
-
-int vc_client_use_callback(vc_h vc)
-{
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->cb_ref_count++;
+       g_client->cb_ref_count++;
        return VC_ERROR_NONE;
 }
 
-int vc_client_not_use_callback(vc_h vc)
+int vc_client_not_use_callback(void)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->cb_ref_count--;
+       g_client->cb_ref_count--;
        return VC_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
 /* Authority */
-int vc_client_set_auth_state_changed_cb(vc_h vc, vc_auth_state_changed_cb callback, void* user_data)
+int vc_client_set_auth_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->auth_state_changed_cb = callback;
-       client->auth_state_changed_user_data = user_data;
+       g_client->auth_state_changed_cb = callback;
+       g_client->auth_state_changed_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_auth_state_changed_cb(vc_h vc, vc_auth_state_changed_cb* callback, void** user_data)
+int vc_client_get_auth_state_changed_cb(vc_auth_state_changed_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->auth_state_changed_cb;
-       *user_data = client->auth_state_changed_user_data;
+       *callback = g_client->auth_state_changed_cb;
+       *user_data = g_client->auth_state_changed_user_data;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_unset_auth_state_changed_cb(vc_h vc)
+int vc_client_unset_auth_state_changed_cb(void)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->auth_state_changed_cb = NULL;
-       client->auth_state_changed_user_data = NULL;
+       g_client->auth_state_changed_cb = NULL;
+       g_client->auth_state_changed_user_data = NULL;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_auth_state(vc_h vc, vc_auth_state_e state)
+int vc_client_set_auth_state(vc_auth_state_e state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->auth_before_state = client->auth_current_state;
-       client->auth_current_state = state;
+       g_client->auth_before_state = g_client->auth_current_state;
+       g_client->auth_current_state = state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_auth_state(vc_h vc, vc_auth_state_e* state)
+int vc_client_get_auth_state(vc_auth_state_e* state)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *state = client->auth_current_state;
+       *state = g_client->auth_current_state;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_before_auth_state(vc_h vc, vc_auth_state_e* before, vc_auth_state_e* current)
+int vc_client_get_before_auth_state(vc_auth_state_e* before, vc_auth_state_e* current)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *before = client->auth_before_state;
-       *current = client->auth_current_state;
+       *before = g_client->auth_before_state;
+       *current = g_client->auth_current_state;
 
        return VC_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
-int vc_client_set_mgr_pid(vc_h vc, int mgr_pid)
+int vc_client_set_mgr_pid(int mgr_pid)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->mgr_pid = mgr_pid;
+       g_client->mgr_pid = mgr_pid;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_mgr_pid(vc_h vc, int* mgr_pid)
+int vc_client_get_mgr_pid(int* mgr_pid)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *mgr_pid = client->mgr_pid;
+       *mgr_pid = g_client->mgr_pid;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb callback, void* user_data)
+int vc_client_set_tts_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->tts_streaming_cb = callback;
-       client->tts_streaming_user_data = user_data;
+       g_client->tts_streaming_cb = callback;
+       g_client->tts_streaming_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb* callback, void** user_data)
+int vc_client_get_tts_streaming_cb(vc_tts_streaming_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->tts_streaming_cb;
-       *user_data = client->tts_streaming_user_data;
+       *callback = g_client->tts_streaming_cb;
+       *user_data = g_client->tts_streaming_user_data;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_set_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb callback, void* user_data)
+int vc_client_set_tts_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       client->tts_utterance_status_cb = callback;
-       client->tts_utterance_status_user_data = user_data;
+       g_client->tts_utterance_status_cb = callback;
+       g_client->tts_utterance_status_user_data = user_data;
 
        return VC_ERROR_NONE;
 }
 
-int vc_client_get_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb* callback, void** user_data)
+int vc_client_get_tts_utterance_status_cb(vc_tts_utterance_status_cb* callback, void** user_data)
 {
-       vc_client_s* client = __client_get(vc);
-
        /* check handle */
-       if (NULL == client)
+       if (NULL == g_client)
                return VC_ERROR_INVALID_PARAMETER;
 
-       *callback = client->tts_utterance_status_cb;
-       *user_data = client->tts_utterance_status_user_data;
+       *callback = g_client->tts_utterance_status_cb;
+       *user_data = g_client->tts_utterance_status_user_data;
 
        return VC_ERROR_NONE;
 }

diff --git a/client/vc_client.h b/client/vc_client.h
index b043d8744685b451598ace2008381128248d6b64..6f89ea7727754e74629e481fad72d2cca6cd9ff6 100644 (file)
--- a/client/vc_client.h
+++ b/client/vc_client.h
@@ -32,58 +32,58 @@ extern "C" {
 /*
 * Common function
 */
-int vc_client_create(vc_h* vc);
+int vc_client_create(void);
 
-int vc_client_destroy(vc_h vc);
+int vc_client_destroy(void);
 
-bool vc_client_is_valid(vc_h vc);
+bool vc_client_is_valid(void);
 
-int vc_client_get_handle(int pid, vc_h* vc);
+// int vc_client_get_handle(int pid, vc_h* vc);
 
 /*
 * set/get callback function
 */
-int vc_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data);
+int vc_client_set_result_cb(vc_result_cb callback, void* user_data);
 
-int vc_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data);
+int vc_client_get_result_cb(vc_result_cb* callback, void** user_data);
 
-int vc_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data);
+int vc_client_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data);
 
-int vc_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data);
+int vc_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data);
 
-int vc_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data);
+int vc_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data);
 
-int vc_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data);
+int vc_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data);
 
-int vc_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data);
+int vc_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data);
 
-int vc_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data);
+int vc_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data);
 
-int vc_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data);
+int vc_client_set_error_cb(vc_error_cb callback, void* user_data);
 
-int vc_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data);
+int vc_client_get_error_cb(vc_error_cb* callback, void** user_data);
 
 
 /*
 * set/get option
 */
-int vc_client_set_service_state(vc_h vc, vc_service_state_e state);
+int vc_client_set_service_state(vc_service_state_e state);
 
-int vc_client_get_service_state(vc_h vc, vc_service_state_e* state);
+int vc_client_get_service_state(vc_service_state_e* state);
 
-int vc_client_set_client_state(vc_h vc, vc_state_e state);
+int vc_client_set_client_state(vc_state_e state);
 
-int vc_client_get_client_state(vc_h vc, vc_state_e* state);
+int vc_client_get_client_state(vc_state_e* state);
 
-int vc_client_get_before_state(vc_h vc, vc_state_e* state, vc_state_e* before_state);
+int vc_client_get_before_state(vc_state_e* state, vc_state_e* before_state);
 
-int vc_client_set_invocation_name(vc_h vc, const char* invocation_name);
+int vc_client_set_invocation_name(const char* invocation_name);
 
-int vc_client_get_invocation_name(vc_h vc, char** invocation_name);
+int vc_client_get_invocation_name(char** invocation_name);
 
-int vc_client_set_is_foreground(vc_h vc, bool value);
+int vc_client_set_is_foreground(bool value);
 
-int vc_client_get_is_foreground(vc_h vc, bool* value);
+int vc_client_get_is_foreground(bool* value);
 
 #if 0
 int vc_client_set_exclusive_cmd(vc_h vc, bool value);
@@ -91,44 +91,42 @@ int vc_client_set_exclusive_cmd(vc_h vc, bool value);
 int vc_client_get_exclusive_cmd(vc_h vc, bool* value);
 #endif
 
-int vc_client_set_error(vc_h vc, int reason);
+int vc_client_set_error(int reason);
 
-int vc_client_get_error(vc_h vc, int* reason);
+int vc_client_get_error(int* reason);
 
 
 /* utils */
-int vc_client_get_count();
+int vc_client_use_callback(void);
 
-int vc_client_use_callback(vc_h vc);
-
-int vc_client_not_use_callback(vc_h vc);
+int vc_client_not_use_callback(void);
 
 /* Authority */
-int vc_client_set_auth_state_changed_cb(vc_h vc, vc_auth_state_changed_cb callback, void* user_data);
+int vc_client_set_auth_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data);
 
-int vc_client_get_auth_state_changed_cb(vc_h vc, vc_auth_state_changed_cb* callback, void** user_data);
+int vc_client_get_auth_state_changed_cb(vc_auth_state_changed_cb* callback, void** user_data);
 
-int vc_client_unset_auth_state_changed_cb(vc_h vc);
+int vc_client_unset_auth_state_changed_cb(void);
 
-int vc_client_set_auth_state(vc_h vc, vc_auth_state_e state);
+int vc_client_set_auth_state(vc_auth_state_e state);
 
-int vc_client_get_auth_state(vc_h vc, vc_auth_state_e* state);
+int vc_client_get_auth_state(vc_auth_state_e* state);
 
-int vc_client_get_before_auth_state(vc_h vc, vc_auth_state_e* before, vc_auth_state_e* current);
+int vc_client_get_before_auth_state(vc_auth_state_e* before, vc_auth_state_e* current);
 
-int vc_client_set_mgr_pid(vc_h vc, int mgr_pid);
+int vc_client_set_mgr_pid(int mgr_pid);
 
-int vc_client_get_mgr_pid(vc_h vc, int* mgr_pid);
+int vc_client_get_mgr_pid(int* mgr_pid);
 
 
 /* TTS feedback */
-int vc_client_set_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb callback, void* user_data);
+int vc_client_set_tts_streaming_cb(vc_tts_streaming_cb callback, void* user_data);
 
-int vc_client_get_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb* callback, void** user_data);
+int vc_client_get_tts_streaming_cb(vc_tts_streaming_cb* callback, void** user_data);
 
-int vc_client_set_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb callback, void* user_data);
+int vc_client_set_tts_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data);
 
-int vc_client_get_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb* callback, void** user_data);
+int vc_client_get_tts_utterance_status_cb(vc_tts_utterance_status_cb* callback, void** user_data);
 
 
 #ifdef __cplusplus