From 40e0cb2fad649eaad4e2cb89f5c058c496d9b24a Mon Sep 17 00:00:00 2001 From: ulgal-park Date: Fri, 4 Nov 2022 12:51:47 +0900 Subject: [PATCH] Remove vc manager handle in vc_mgr and vc_mgr_client Change-Id: Ie30d4b328f0e22f57d59c9c8dfdbe601fbbe34a2 --- client/vc_mgr.c | 591 +++++++++++++------------- client/vc_mgr_client.c | 1100 ++++++++++++++++++------------------------------ client/vc_mgr_client.h | 152 ++++--- 3 files changed, 782 insertions(+), 1061 deletions(-) diff --git a/client/vc_mgr.c b/client/vc_mgr.c index 1202871..30c3c2a 100644 --- a/client/vc_mgr.c +++ b/client/vc_mgr.c @@ -48,7 +48,7 @@ static int g_tidl_send_hello_count = 0; static Ecore_Timer* g_m_set_volume_timer = NULL; -static vc_h g_vc_m = NULL; +static int g_pid; static GSList* g_demandable_client_list = NULL; @@ -110,12 +110,12 @@ static void __vc_mgr_lang_changed_cb(const char* previous_lang, const char* curr vc_current_language_changed_cb callback = NULL; void* lang_user_data; - vc_mgr_client_get_current_lang_changed_cb(g_vc_m, &callback, &lang_user_data); + vc_mgr_client_get_current_lang_changed_cb(&callback, &lang_user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(previous_lang, current_lang, lang_user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Language changed callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Language changed callback is null"); @@ -273,7 +273,7 @@ int vc_mgr_initialize(void) return ret; /* check handle */ - if (true == vc_mgr_client_is_valid(g_vc_m)) { + if (true == vc_mgr_client_is_valid()) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already initialized"); return VC_ERROR_NONE; } @@ -283,31 +283,32 @@ int vc_mgr_initialize(void) return VC_ERROR_OPERATION_FAILED; } - if (0 != vc_mgr_client_create(&g_vc_m)) { + if (0 != vc_mgr_client_create()) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create client!!!!!"); return VC_ERROR_OUT_OF_MEMORY; } - ret = vc_config_mgr_initialize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE); + g_pid = getpid(); + ret = vc_config_mgr_initialize(g_pid + VC_MANAGER_CONFIG_HANDLE); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to init config manager : %d", ret); - vc_mgr_client_destroy(g_vc_m); + vc_mgr_client_destroy(); return VC_ERROR_OPERATION_FAILED; } - ret = vc_config_mgr_set_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_lang_changed_cb); + ret = vc_config_mgr_set_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_lang_changed_cb); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set callback : %d", ret); - vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE); - vc_mgr_client_destroy(g_vc_m); + vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE); + vc_mgr_client_destroy(); return VC_ERROR_OPERATION_FAILED; } - ret = vc_mgr_client_set_audio_streaming_mode(g_vc_m, VC_AUDIO_STREAMING_MODE_VC_SERVICE); + ret = vc_mgr_client_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %d", ret); - vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE); - vc_mgr_client_destroy(g_vc_m); + vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE); + vc_mgr_client_destroy(); return ret; } @@ -323,7 +324,7 @@ int vc_mgr_initialize(void) SLOG(LOG_INFO, TAG_VCM, "[INFO] Fail to ducking create : %d", ret); } - SLOG(LOG_ERROR, TAG_VCM, "[Success] pid(%d)", g_vc_m->handle); + SLOG(LOG_ERROR, TAG_VCM, "[Success] pid(%d)", g_pid); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Initialize DONE"); @@ -332,12 +333,12 @@ int vc_mgr_initialize(void) static void __vc_mgr_internal_unprepare() { - int ret = vc_mgr_tidl_request_finalize(g_vc_m->handle); + int ret = vc_mgr_tidl_request_finalize(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret)); } - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); return; } @@ -350,13 +351,13 @@ int vc_mgr_deinitialize(void) if (VC_ERROR_NONE != ret) return ret; - if (false == vc_mgr_client_is_valid(g_vc_m)) { + if (false == vc_mgr_client_is_valid()) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NOT initialized"); return VC_ERROR_INVALID_STATE; } vc_state_e state; - vc_mgr_client_get_client_state(g_vc_m, &state); + vc_mgr_client_get_client_state(&state); /* check state */ switch (state) { @@ -375,12 +376,12 @@ int vc_mgr_deinitialize(void) g_request_init_timer = NULL; } - vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE); - vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE); + vc_config_mgr_unset_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE); + vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE); /* Free client resources */ - vc_mgr_client_destroy(g_vc_m); - g_vc_m = NULL; + vc_mgr_client_destroy(); + g_pid = 0; break; case VC_STATE_NONE: break; @@ -430,8 +431,8 @@ static Eina_Bool __request_initialize(void *data) /* check handle */ - if (true == vc_mgr_client_is_valid(g_vc_m)) { - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] g_vc_m is valid"); + if (true == vc_mgr_client_is_valid()) { + SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] is valid"); /* Initialize DB */ ret = vc_db_initialize(); @@ -441,15 +442,15 @@ static Eina_Bool __request_initialize(void *data) } vc_audio_streaming_mode_e streaming_mode; - vc_mgr_client_get_audio_streaming_mode(g_vc_m, &streaming_mode); + vc_mgr_client_get_audio_streaming_mode(&streaming_mode); - ret = vc_mgr_tidl_request_initialize(g_vc_m->handle, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid); + ret = vc_mgr_tidl_request_initialize(g_pid, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid); if (VC_ERROR_ENGINE_NOT_FOUND == ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret)); - vc_mgr_client_set_error(g_vc_m, VC_ERROR_ENGINE_NOT_FOUND); - ecore_main_loop_thread_safe_call_async(__vc_mgr_notify_error, (void*)g_vc_m); + vc_mgr_client_set_error(VC_ERROR_ENGINE_NOT_FOUND); + ecore_main_loop_thread_safe_call_async(__vc_mgr_notify_error, NULL); SLOG(LOG_DEBUG, TAG_VCM, "@@@"); g_request_init_timer = NULL; @@ -468,49 +469,49 @@ static Eina_Bool __request_initialize(void *data) /* Set service state */ vc_service_state_e previous_service_state; - vc_mgr_client_get_service_state(g_vc_m, &previous_service_state); - vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)service_state); + vc_mgr_client_get_service_state(&previous_service_state); + vc_mgr_client_set_service_state((vc_service_state_e)service_state); vc_service_state_changed_cb service_changed_callback = NULL; void* user_data = NULL; - vc_mgr_client_get_service_state_changed_cb(g_vc_m, &service_changed_callback, &user_data); + vc_mgr_client_get_service_state_changed_cb(&service_changed_callback, &user_data); if (NULL != service_changed_callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); service_changed_callback(previous_service_state, service_state, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null"); } /* Set foreground */ - vc_mgr_client_set_foreground(g_vc_m, foreground, true); + vc_mgr_client_set_foreground(foreground, true); SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Connected daemon"); /* Set client state */ - vc_mgr_client_set_client_state(g_vc_m, VC_STATE_READY); + vc_mgr_client_set_client_state(VC_STATE_READY); vc_state_changed_cb changed_callback = NULL; user_data = NULL; - vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data); + vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data); vc_state_e current_state; vc_state_e previous_state; - vc_mgr_client_get_previous_state(g_vc_m, ¤t_state, &previous_state); + vc_mgr_client_get_previous_state(¤t_state, &previous_state); if (NULL != changed_callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); changed_callback(previous_state, current_state, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "State changed callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null"); } } else { - SLOG(LOG_ERROR, TAG_VCM, "[Not ERROR] g_vc_m is not valid. It is destroyed."); //LCOV_EXCL_LINE + SLOG(LOG_ERROR, TAG_VCM, "[Not ERROR] is not valid. It is destroyed."); //LCOV_EXCL_LINE g_request_init_timer = NULL; return EINA_FALSE; } @@ -561,7 +562,7 @@ int vc_mgr_prepare(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -594,7 +595,7 @@ int vc_mgr_unprepare(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -604,8 +605,8 @@ int vc_mgr_unprepare(void) __vc_mgr_internal_unprepare(); - vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED); - ecore_timer_add(0, __vc_mgr_notify_state_changed, g_vc_m); + vc_mgr_client_set_client_state(VC_STATE_INITIALIZED); + ecore_timer_add(0, __vc_mgr_notify_state_changed, NULL); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Unprepare DONE"); @@ -624,7 +625,7 @@ int vc_mgr_foreach_supported_languages(vc_supported_language_cb callback, void* RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -650,7 +651,7 @@ int vc_mgr_get_current_language(char** language) RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -678,9 +679,7 @@ int vc_mgr_get_state(vc_state_e* state) RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); vc_state_e temp; - if (NULL == g_vc_m) { - temp = VC_STATE_NONE; - } else if (0 != vc_mgr_client_get_client_state(g_vc_m, &temp)) { + if (0 != vc_mgr_client_get_client_state(&temp)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -711,7 +710,7 @@ int vc_mgr_get_service_state(vc_service_state_e* state) RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); vc_state_e client_state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &client_state)) { + if (0 != vc_mgr_client_get_client_state(&client_state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -721,7 +720,7 @@ int vc_mgr_get_service_state(vc_service_state_e* state) /* get service state */ vc_service_state_e service_state; - if (0 != vc_mgr_client_get_service_state(g_vc_m, &service_state)) { + if (0 != vc_mgr_client_get_service_state(&service_state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state"); return VC_ERROR_OPERATION_FAILED; } @@ -751,7 +750,7 @@ int vc_mgr_set_demandable_client_rule(const char* rule) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -787,7 +786,7 @@ int vc_mgr_unset_demandable_client_rule(void) vc_info_parser_set_demandable_client(NULL); - ret = vc_mgr_tidl_request_demandable_client(g_vc_m->handle); + ret = vc_mgr_tidl_request_demandable_client(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset client rule to daemon : %s", __vc_mgr_get_error_code(ret)); } @@ -808,7 +807,7 @@ int vc_mgr_is_command_format_supported(int format, bool* support) RETVM_IF(NULL == support, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -850,7 +849,7 @@ int vc_mgr_enable_command_type(int cmd_type) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -860,10 +859,10 @@ int vc_mgr_enable_command_type(int cmd_type) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_client_enable_command_type(g_vc_m, (vc_cmd_type_e)cmd_type); // enable the cmd type + ret = vc_mgr_client_enable_command_type((vc_cmd_type_e)cmd_type); // enable the cmd type if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to enable the command type(%d). ret(%d)", cmd_type, ret); } else { @@ -890,7 +889,7 @@ int vc_mgr_disable_command_type(int cmd_type) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -900,10 +899,10 @@ int vc_mgr_disable_command_type(int cmd_type) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_client_disable_command_type(g_vc_m, (vc_cmd_type_e)cmd_type); // enable the cmd type + ret = vc_mgr_client_disable_command_type((vc_cmd_type_e)cmd_type); // enable the cmd type if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to disable the command type(%d). ret(%d)", cmd_type, ret); } else { @@ -925,7 +924,7 @@ int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -935,7 +934,7 @@ int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state); RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL"); @@ -966,7 +965,7 @@ int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list) ret = VC_ERROR_INVALID_PARAMETER; SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret)); } else { - ret = vc_mgr_tidl_request_set_command(g_vc_m->handle); + ret = vc_mgr_tidl_request_set_command(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret)); } @@ -987,7 +986,7 @@ int vc_mgr_unset_command_list(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -995,7 +994,7 @@ int vc_mgr_unset_command_list(void) /* check state */ RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state); - ret = vc_mgr_tidl_request_unset_command(g_vc_m->handle); + ret = vc_mgr_tidl_request_unset_command(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret)); } @@ -1032,7 +1031,7 @@ int vc_mgr_set_command_list_from_file(const char* file_path, int type) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1042,7 +1041,7 @@ int vc_mgr_set_command_list_from_file(const char* file_path, int type) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); ret = vc_cmd_parser_delete_file(getpid(), type); @@ -1053,7 +1052,7 @@ int vc_mgr_set_command_list_from_file(const char* file_path, int type) ret = VC_ERROR_INVALID_PARAMETER; SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command list (%d)", ret); } else { - ret = vc_mgr_tidl_request_set_command(g_vc_m->handle); + ret = vc_mgr_tidl_request_set_command(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret)); } @@ -1077,7 +1076,7 @@ int vc_mgr_set_preloaded_commands_from_file(const char* file_path) SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1087,7 +1086,7 @@ int vc_mgr_set_preloaded_commands_from_file(const char* file_path) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); /* Only support to set background commands for preloaded application */ @@ -1114,7 +1113,7 @@ int vc_mgr_set_audio_type(const char* audio_id) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1124,17 +1123,17 @@ int vc_mgr_set_audio_type(const char* audio_id) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); /* Request */ - ret = vc_mgr_tidl_request_set_audio_type(g_vc_m->handle, audio_id); + ret = vc_mgr_tidl_request_set_audio_type(g_pid, audio_id); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret)); } else { SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set audio type"); /* Save */ - vc_mgr_client_set_audio_type(g_vc_m, audio_id); + vc_mgr_client_set_audio_type(audio_id); } SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set audio type DONE, ret(%d)", ret); @@ -1154,7 +1153,7 @@ int vc_mgr_get_audio_type(char** audio_id) RETVM_IF(NULL == audio_id, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1164,24 +1163,24 @@ int vc_mgr_get_audio_type(char** audio_id) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); char* temp = NULL; - vc_mgr_client_get_audio_type(g_vc_m, &temp); + vc_mgr_client_get_audio_type(&temp); if (NULL == temp) { /* Not initiallized */ ret = -1; while (0 != ret) { - ret = vc_mgr_tidl_request_get_audio_type(g_vc_m->handle, &temp); + ret = vc_mgr_tidl_request_get_audio_type(g_pid, &temp); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret)); } else { SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Get audio type : %s", temp); /* Save */ - vc_mgr_client_set_audio_type(g_vc_m, temp); + vc_mgr_client_set_audio_type(temp); } } } @@ -1206,7 +1205,7 @@ int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1216,7 +1215,7 @@ int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state); RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid Parameter"); @@ -1233,14 +1232,14 @@ int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list) int mgr_pid = 0; /* Get foreground pid */ - if (0 != vc_mgr_client_get_foreground(g_vc_m, &fg_pid)) { + if (0 != vc_mgr_client_get_foreground(&fg_pid)) { /* There is no foreground app for voice control */ SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control"); } else { SLOG(LOG_INFO, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid); } - if (0 != vc_mgr_client_get_pid(g_vc_m, &mgr_pid)) { + if (0 != vc_mgr_client_get_pid(&mgr_pid)) { SLOG(LOG_ERROR, TAG_VCM, "[Manager] Fail to get manager pid"); return VC_ERROR_OPERATION_FAILED; } else { @@ -1254,7 +1253,7 @@ int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list) } /* Request */ - ret = vc_mgr_tidl_request_set_client_info(g_vc_m->handle); + ret = vc_mgr_tidl_request_set_client_info(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret)); } else { @@ -1381,7 +1380,7 @@ int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1391,10 +1390,10 @@ int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - vc_mgr_client_set_recognition_mode(g_vc_m, mode); + vc_mgr_client_set_recognition_mode(mode); return VC_ERROR_NONE; } @@ -1408,12 +1407,12 @@ int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode) RETVM_IF(NULL == mode, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter, mode is NULL ptr"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } - ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode); + ret = vc_mgr_client_get_recognition_mode(mode); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode"); return ret; @@ -1435,7 +1434,7 @@ int vc_mgr_set_private_data(const char* key, const char* data) RETVM_IF(NULL == key, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1445,10 +1444,10 @@ int vc_mgr_set_private_data(const char* key, const char* data) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_tidl_request_set_private_data(g_vc_m->handle, key, data); + ret = vc_mgr_tidl_request_set_private_data(g_pid, key, data); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -1476,7 +1475,7 @@ int vc_mgr_get_private_data(const char* key, char** data) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1486,11 +1485,11 @@ int vc_mgr_get_private_data(const char* key, char** data) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); char* temp = NULL; - ret = vc_mgr_tidl_request_get_private_data(g_vc_m->handle, key, &temp); + ret = vc_mgr_tidl_request_get_private_data(g_pid, key, &temp); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret)); } else { @@ -1521,7 +1520,7 @@ int vc_mgr_set_domain(const char* domain) RETVM_IF(NULL == domain, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1531,10 +1530,10 @@ int vc_mgr_set_domain(const char* domain) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_tidl_request_set_domain(g_vc_m->handle, domain); + ret = vc_mgr_tidl_request_set_domain(g_pid, domain); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret)); } else { @@ -1563,7 +1562,7 @@ int vc_mgr_do_action(vc_send_event_type_e type, char* send_event) RETVM_IF(NULL == send_event, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1573,10 +1572,10 @@ int vc_mgr_do_action(vc_send_event_type_e type, char* send_event) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_tidl_request_do_action(g_vc_m->handle, type, send_event); + ret = vc_mgr_tidl_request_do_action(g_pid, type, send_event); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -1609,7 +1608,7 @@ int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* e } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1619,10 +1618,10 @@ int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* e /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); - ret = vc_mgr_tidl_send_specific_engine_request(g_vc_m->handle, engine_app_id, event, request); + ret = vc_mgr_tidl_send_specific_engine_request(g_pid, engine_app_id, event, request); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -1644,7 +1643,7 @@ int vc_mgr_start(bool exclusive_command_option) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1654,26 +1653,26 @@ int vc_mgr_start(bool exclusive_command_option) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); /* Check internal state for async */ vc_internal_state_e internal_state = -1; - vc_mgr_client_get_internal_state(g_vc_m, &internal_state); + vc_mgr_client_get_internal_state(&internal_state); if (internal_state != VC_INTERNAL_STATE_NONE) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is NOT none : %d", internal_state); return VC_ERROR_IN_PROGRESS_TO_RECORDING; } - vc_mgr_client_set_exclusive_command(g_vc_m, exclusive_command_option); + vc_mgr_client_set_exclusive_command(exclusive_command_option); bool start_by_client = false; - if (0 != vc_mgr_client_get_start_by_client(g_vc_m, &start_by_client)) { + if (0 != vc_mgr_client_get_start_by_client(&start_by_client)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client"); } int disabled_cmd_type = 0; - if (0 != vc_mgr_client_get_disabled_command_type(g_vc_m, &disabled_cmd_type)) { + if (0 != vc_mgr_client_get_disabled_command_type(&disabled_cmd_type)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get disabled command type"); } @@ -1684,11 +1683,11 @@ int vc_mgr_start(bool exclusive_command_option) /* Request */ ret = -1; - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STARTING); - ret = vc_mgr_tidl_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STARTING); + ret = vc_mgr_tidl_request_start(g_pid, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret)); - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); } else { SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] start recognition"); } @@ -1712,7 +1711,7 @@ int vc_mgr_stop(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1722,12 +1721,12 @@ int vc_mgr_stop(void) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_RECORDING, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'RECORDING'", service_state); /* Check internal state for async */ vc_internal_state_e internal_state = -1; - vc_mgr_client_get_internal_state(g_vc_m, &internal_state); + vc_mgr_client_get_internal_state(&internal_state); if (VC_INTERNAL_STATE_STARTING == internal_state) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING"); return VC_ERROR_IN_PROGRESS_TO_RECORDING; @@ -1741,11 +1740,11 @@ int vc_mgr_stop(void) ret = -1; /* do request */ - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STOPPING); - ret = vc_mgr_tidl_request_stop(g_vc_m->handle); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STOPPING); + ret = vc_mgr_tidl_request_stop(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret)); - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); } else { SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Stop recognition"); } @@ -1765,7 +1764,7 @@ int vc_mgr_cancel(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1775,11 +1774,11 @@ int vc_mgr_cancel(void) /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state == VC_SERVICE_STATE_NONE, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state is NONE"); vc_internal_state_e internal_state = -1; - vc_mgr_client_get_internal_state(g_vc_m, &internal_state); + vc_mgr_client_get_internal_state(&internal_state); if (VC_INTERNAL_STATE_STARTING == internal_state) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING"); return VC_ERROR_IN_PROGRESS_TO_RECORDING; @@ -1792,16 +1791,16 @@ int vc_mgr_cancel(void) } ret = -1; - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_CANCELING); - ret = vc_mgr_tidl_request_cancel(g_vc_m->handle); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_CANCELING); + ret = vc_mgr_tidl_request_cancel(g_pid); if (0 != ret) { SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret)); - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); } else { SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel recognition"); } - vc_mgr_client_set_exclusive_command(g_vc_m, false); + vc_mgr_client_set_exclusive_command(false); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request cancel DONE"); @@ -1858,7 +1857,7 @@ int vc_mgr_get_recording_volume(float* volume) RETVM_IF(NULL == volume, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_service_state_e service_state = -1; - if (0 != vc_mgr_client_get_service_state(g_vc_m, &service_state)) { + if (0 != vc_mgr_client_get_service_state(&service_state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -1873,11 +1872,11 @@ int vc_mgr_get_recording_volume(float* volume) int __vc_mgr_cb_set_foreground(int pid, bool value) { - vc_mgr_client_set_foreground(g_vc_m, pid, value); + vc_mgr_client_set_foreground(pid, value); /* get authorized valid app */ int tmp_pid; - if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &tmp_pid)) { + if (0 != vc_mgr_client_get_valid_authorized_client(&tmp_pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app"); return VC_ERROR_INVALID_PARAMETER; } @@ -1888,18 +1887,18 @@ int __vc_mgr_cb_set_foreground(int pid, bool value) SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid); /* set authorized valid */ - if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) { + if (true == vc_mgr_client_is_authorized_client(pid)) { SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid); - vc_mgr_client_set_valid_authorized_client(g_vc_m, pid); + vc_mgr_client_set_valid_authorized_client(pid); } else { SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority"); - vc_mgr_client_set_valid_authorized_client(g_vc_m, -1); + vc_mgr_client_set_valid_authorized_client(-1); } } } else { if (tmp_pid == pid) { SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid); - vc_mgr_client_set_valid_authorized_client(g_vc_m, -1); + vc_mgr_client_set_valid_authorized_client(-1); } } @@ -1918,7 +1917,7 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) /* Do not check state for 'restart continuously' mode */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); if (service_state != VC_SERVICE_STATE_PROCESSING) { vc_recognition_mode_e recognition_mode; vc_mgr_get_recognition_mode(&recognition_mode); @@ -1933,7 +1932,7 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) int event = 0; char* result_text = NULL; - vc_mgr_client_get_all_result(g_vc_m, &event, &result_text); + vc_mgr_client_get_all_result(&event, &result_text); vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false); @@ -1944,7 +1943,7 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) } /* Request */ - ret = vc_mgr_tidl_send_result_selection(g_vc_m->handle); + ret = vc_mgr_tidl_send_result_selection(g_pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -1952,7 +1951,7 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] result selection"); } - vc_mgr_client_unset_all_result(g_vc_m); + vc_mgr_client_unset_all_result(); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Select result DONE"); @@ -1975,7 +1974,7 @@ static void __vc_mgr_notify_all_result(vc_result_type_e result_type) vc_mgr_all_result_cb all_callback = NULL; void* all_user_data = NULL; - vc_mgr_client_get_all_result_cb(g_vc_m, &all_callback, &all_user_data); + vc_mgr_client_get_all_result_cb(&all_callback, &all_user_data); RETM_IF(NULL == all_callback, TAG_VCM, "[ERROR] All result callback is NULL"); if (0 != vc_cmd_list_create(&vc_cmd_list)) { @@ -1983,7 +1982,7 @@ static void __vc_mgr_notify_all_result(vc_result_type_e result_type) return; } - vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command(g_vc_m)); + vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command()); SECURE_SLOG(LOG_INFO, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)", result_type, temp_text, event, temp_message); @@ -1992,23 +1991,23 @@ static void __vc_mgr_notify_all_result(vc_result_type_e result_type) bool cb_ret = false; - vc_mgr_client_set_all_result(g_vc_m, event, temp_text); + vc_mgr_client_set_all_result(event, temp_text); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); - if (true == vc_mgr_client_get_exclusive_command(g_vc_m)) { + if (true == vc_mgr_client_get_exclusive_command()) { /* exclusive */ vc_result_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_result_cb(&callback, &user_data); RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client result callback is NULL"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(event, vc_cmd_list, temp_text, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called"); /* Release result */ @@ -2026,7 +2025,7 @@ static void __vc_mgr_notify_all_result(vc_result_type_e result_type) vc_cmd_list_destroy(vc_cmd_list, true); vc_cmd_list = NULL; - vc_mgr_client_set_exclusive_command(g_vc_m, false); + vc_mgr_client_set_exclusive_command(false); return; } @@ -2046,8 +2045,8 @@ static void __vc_mgr_notify_all_result(vc_result_type_e result_type) if (VC_RESULT_TYPE_NOTIFICATION != result_type) ecore_idler_add(__vc_mgr_set_select_result, NULL); - vc_mgr_client_set_exclusive_command(g_vc_m, false); - vc_mgr_client_unset_all_result(g_vc_m); + vc_mgr_client_set_exclusive_command(false); + vc_mgr_client_unset_all_result(); } /* Release result */ @@ -2077,7 +2076,7 @@ static Eina_Bool __vc_mgr_notify_result(void *data) vc_result_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_result_cb(&callback, &user_data); RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCM, "[ERROR] Client result callback is NULL"); if (0 != vc_cmd_list_create(&vc_cmd_list)) { @@ -2091,9 +2090,9 @@ static Eina_Bool __vc_mgr_notify_result(void *data) vc_cmd_print_list(vc_cmd_list); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(event, vc_cmd_list, temp_text, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Result callback called"); if (vc_cmd_list) @@ -2110,7 +2109,7 @@ static Eina_Bool __vc_mgr_notify_result(void *data) void __vc_mgr_cb_all_result(vc_result_type_e type) { - if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) { + if (false == vc_mgr_client_get_exclusive_command()) { __vc_mgr_notify_all_result(type); } else { __vc_mgr_notify_result(0); @@ -2124,12 +2123,12 @@ void __vc_mgr_cb_pre_result(vc_pre_result_event_e event, const char* pre_result) vc_mgr_pre_result_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_pre_result_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_pre_result_cb(&callback, &user_data); RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client pre result callback is NULL"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(event, pre_result, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Pre result callback is called"); return; @@ -2146,12 +2145,12 @@ static Eina_Bool __vc_mgr_speech_detected(void *data) vc_mgr_begin_speech_detected_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_speech_detected_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_speech_detected_cb(&callback, &user_data); RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCM, "[ERROR] Client speech detected callback is NULL"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Speech detected callback called"); return EINA_FALSE; @@ -2174,7 +2173,7 @@ int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data) RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2182,7 +2181,7 @@ int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_all_result_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set all result callback"); @@ -2197,7 +2196,7 @@ int vc_mgr_unset_all_result_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2205,7 +2204,7 @@ int vc_mgr_unset_all_result_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_all_result_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_all_result_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2220,7 +2219,7 @@ int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data) RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2228,7 +2227,7 @@ int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_result_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_result_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2241,7 +2240,7 @@ int vc_mgr_unset_result_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2249,7 +2248,7 @@ int vc_mgr_unset_result_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_result_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_result_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2264,7 +2263,7 @@ int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data) RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set pre result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2272,7 +2271,7 @@ int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_pre_result_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_pre_result_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2285,7 +2284,7 @@ int vc_mgr_unset_pre_result_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset pre result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2293,7 +2292,7 @@ int vc_mgr_unset_pre_result_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_pre_result_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_pre_result_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2309,7 +2308,7 @@ int vc_mgr_get_error_message(char** err_msg) /* check state */ vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] vc_mgr handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2321,7 +2320,7 @@ int vc_mgr_get_error_message(char** err_msg) return VC_ERROR_OPERATION_FAILED; } - ret = vc_mgr_client_get_error_message(g_vc_m, err_msg); + ret = vc_mgr_client_get_error_message(err_msg); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message"); } @@ -2333,21 +2332,19 @@ int vc_mgr_get_error_message(char** err_msg) static void __vc_mgr_notify_error(void *data) { - vc_h vc_m = (vc_h)data; - vc_error_cb callback = NULL; void* user_data = NULL; int reason; - vc_mgr_client_get_error_cb(vc_m, &callback, &user_data); - vc_mgr_client_get_error(vc_m, &reason); + vc_mgr_client_get_error_cb(&callback, &user_data); + vc_mgr_client_get_error(&reason); if (NULL != callback) { - vc_mgr_client_use_callback(vc_m); + vc_mgr_client_use_callback(); g_err_callback_status = true; callback(reason, user_data); g_err_callback_status = false; - vc_mgr_client_not_use_callback(vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Error callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null"); @@ -2357,7 +2354,7 @@ static void __vc_mgr_notify_error(void *data) int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg) { vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client"); return VC_ERROR_INVALID_PARAMETER; } @@ -2368,20 +2365,20 @@ int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg) return VC_ERROR_INVALID_STATE; } - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); if (VC_ERROR_SERVICE_RESET == reason) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] VC daemon reset"); vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); if (VC_SERVICE_STATE_UPDATING == service_state) { SLOG(LOG_INFO, TAG_VCM, "[INFO] VC daemon is terminated by update manager"); return VC_ERROR_NONE; } - vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED); - __vc_mgr_notify_state_changed(g_vc_m); + vc_mgr_client_set_client_state(VC_STATE_INITIALIZED); + __vc_mgr_notify_state_changed(NULL); if (0 != vc_mgr_prepare()) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to prepare"); @@ -2390,9 +2387,9 @@ int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg) SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg); - vc_mgr_client_set_error(g_vc_m, reason); - vc_mgr_client_set_error_message(g_vc_m, msg); - __vc_mgr_notify_error(g_vc_m); + vc_mgr_client_set_error(reason); + vc_mgr_client_set_error_message(msg); + __vc_mgr_notify_error(NULL); return VC_ERROR_NONE; } @@ -2402,17 +2399,17 @@ static Eina_Bool __vc_mgr_notify_state_changed(void *data) vc_state_changed_cb changed_callback = NULL; void* user_data; - vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data); + vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data); vc_state_e current_state; vc_state_e previous_state; - vc_mgr_client_get_previous_state(g_vc_m, ¤t_state, &previous_state); + vc_mgr_client_get_previous_state(¤t_state, &previous_state); if (NULL != changed_callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); changed_callback(previous_state, current_state, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "State changed callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null"); @@ -2432,7 +2429,7 @@ int vc_mgr_set_state_changed_cb(vc_state_changed_cb callback, void* user_data) return VC_ERROR_INVALID_PARAMETER; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2440,7 +2437,7 @@ int vc_mgr_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_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_state_changed_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set state changed callback"); return VC_ERROR_NONE; @@ -2454,7 +2451,7 @@ int vc_mgr_unset_state_changed_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2462,7 +2459,7 @@ int vc_mgr_unset_state_changed_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_state_changed_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_state_changed_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2471,22 +2468,22 @@ int __vc_mgr_cb_service_state(int state) { vc_service_state_e current_state = (vc_service_state_e)state; vc_service_state_e previous_state; - vc_mgr_client_get_service_state(g_vc_m, &previous_state); + vc_mgr_client_get_service_state(&previous_state); SLOG(LOG_INFO, TAG_VCM, "Service State changed : previous(%d) current(%d)", previous_state, current_state); vc_internal_state_e internal_state = -1; - vc_mgr_client_get_internal_state(g_vc_m, &internal_state); + vc_mgr_client_get_internal_state(&internal_state); if ((VC_INTERNAL_STATE_STARTING == internal_state && VC_SERVICE_STATE_RECORDING == current_state) || (VC_INTERNAL_STATE_STOPPING == internal_state && VC_SERVICE_STATE_PROCESSING == current_state) || (VC_INTERNAL_STATE_CANCELING == internal_state && VC_SERVICE_STATE_READY == current_state)) { SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE"); - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); } if (VC_SERVICE_STATE_UPDATING == current_state) { SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE by updating"); - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); + vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE); } if (current_state == previous_state) { @@ -2496,16 +2493,16 @@ int __vc_mgr_cb_service_state(int state) } /* Save service state */ - vc_mgr_client_set_service_state(g_vc_m, current_state); + vc_mgr_client_set_service_state(current_state); vc_service_state_changed_cb callback = NULL; void* service_user_data = NULL; - vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data); + vc_mgr_client_get_service_state_changed_cb(&callback, &service_user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(previous_state, current_state, service_user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null"); @@ -2525,7 +2522,7 @@ int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, vo return VC_ERROR_INVALID_PARAMETER; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2533,7 +2530,7 @@ int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, vo /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_service_state_changed_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set service state changed callback"); return VC_ERROR_NONE; @@ -2547,7 +2544,7 @@ int vc_mgr_unset_service_state_changed_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2555,7 +2552,7 @@ int vc_mgr_unset_service_state_changed_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_service_state_changed_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_service_state_changed_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2570,7 +2567,7 @@ int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void return VC_ERROR_INVALID_PARAMETER; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2578,7 +2575,7 @@ int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_speech_detected_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_speech_detected_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set speech detected callback"); return VC_ERROR_NONE; @@ -2592,7 +2589,7 @@ int vc_mgr_unset_speech_detected_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2600,7 +2597,7 @@ int vc_mgr_unset_speech_detected_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_speech_detected_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_speech_detected_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2614,7 +2611,7 @@ int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callba RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2622,7 +2619,7 @@ int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callba /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_current_lang_changed_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_current_lang_changed_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set current language changed callback"); return VC_ERROR_NONE; @@ -2636,7 +2633,7 @@ int vc_mgr_unset_current_language_changed_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2644,7 +2641,7 @@ int vc_mgr_unset_current_language_changed_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_current_lang_changed_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_current_lang_changed_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2659,7 +2656,7 @@ int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data) RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2667,7 +2664,7 @@ int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_error_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_error_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2680,7 +2677,7 @@ int vc_mgr_unset_error_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2688,7 +2685,7 @@ int vc_mgr_unset_error_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_error_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_error_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2698,12 +2695,12 @@ int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, boo vc_mgr_dialog_request_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_dialog_request_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_dialog_request_cb(&callback, &user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(pid, disp_text, utt_text, continuous, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Dialog callback is called, disp_text(%s), utt)text(%s), continuous(%d)", disp_text, utt_text, continuous); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null"); @@ -2718,12 +2715,12 @@ int __vc_mgr_cb_private_data_set(const char* key, const char* data) void* user_data = NULL; int ret = -1; - vc_mgr_client_get_private_data_set_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_private_data_set_cb(&callback, &user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); ret = callback(key, data, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Private data set callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data set callback is null"); @@ -2738,12 +2735,12 @@ int __vc_mgr_cb_private_data_requested(const char* key, char** data) void* user_data = NULL; int ret = -1; - vc_mgr_client_get_private_data_requested_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_private_data_requested_cb(&callback, &user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); ret = callback(key, data, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Private data requested callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data requested callback is null"); @@ -2763,12 +2760,12 @@ int __vc_mgr_cb_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_a g_feedback_audio_channel = channel; g_feedback_audio_type = audio_type; - vc_mgr_client_get_feedback_audio_format_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_feedback_audio_format_cb(&callback, &user_data); if (NULL != callback) { - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(rate, channel, audio_type, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "TTS feedback audio format callback is called"); } else { SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback audio format callback is null"); @@ -2838,7 +2835,7 @@ int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_d RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2846,7 +2843,7 @@ int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_d /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_dialog_request_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_dialog_request_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2859,7 +2856,7 @@ int vc_mgr_unset_dialog_request_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2867,7 +2864,7 @@ int vc_mgr_unset_dialog_request_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_dialog_request_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_dialog_request_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2882,7 +2879,7 @@ int vc_mgr_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* us RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data set callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2890,7 +2887,7 @@ int vc_mgr_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* us /* check state */ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data set callback : Current state is not 'Initialized'"); - vc_mgr_client_set_private_data_set_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_private_data_set_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2903,7 +2900,7 @@ int vc_mgr_unset_private_data_set_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data set callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2911,7 +2908,7 @@ int vc_mgr_unset_private_data_set_cb(void) /* check state */ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data set callback : Current state is not 'Initialized'"); - vc_mgr_client_set_private_data_set_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_private_data_set_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -2926,7 +2923,7 @@ int vc_mgr_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callba RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data requested callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2934,7 +2931,7 @@ int vc_mgr_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callba /* check state*/ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data requested callback : Current state is not 'Initialized'"); - vc_mgr_client_set_private_data_requested_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_private_data_requested_cb(callback, user_data); return VC_ERROR_NONE; } @@ -2947,7 +2944,7 @@ int vc_mgr_unset_private_data_requested_cb(void) return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data requested callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -2955,7 +2952,7 @@ int vc_mgr_unset_private_data_requested_cb(void) /* check state */ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data requested callback : Current state is not 'Initialized'"); - vc_mgr_client_set_private_data_requested_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_private_data_requested_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -3005,26 +3002,26 @@ int __vc_mgr_request_auth_enable(int pid) } /* check already authorized */ - if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) { + if (true == vc_mgr_client_is_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already authorized"); return VC_ERROR_INVALID_PARAMETER; } /* add authorized list */ - if (0 != vc_mgr_client_add_authorized_client(g_vc_m, pid)) { + if (0 != vc_mgr_client_add_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add authorized client"); return VC_ERROR_OPERATION_FAILED; } /* foreground check */ int fore_pid = 0; - if (0 != vc_mgr_client_get_foreground(g_vc_m, &fore_pid)) { + if (0 != vc_mgr_client_get_foreground(&fore_pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground"); return VC_ERROR_OPERATION_FAILED; } if (pid == fore_pid) { - vc_mgr_client_set_valid_authorized_client(g_vc_m, pid); + vc_mgr_client_set_valid_authorized_client(pid); } return VC_ERROR_NONE; @@ -3033,21 +3030,21 @@ int __vc_mgr_request_auth_enable(int pid) int __vc_mgr_request_auth_disable(int pid) { /* check authorized */ - if (false == vc_mgr_client_is_authorized_client(g_vc_m, pid)) { + if (false == vc_mgr_client_is_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No authorized"); return VC_ERROR_INVALID_PARAMETER; } /* remove authorized list */ - if (0 != vc_mgr_client_remove_authorized_client(g_vc_m, pid)) { + if (0 != vc_mgr_client_remove_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to remove authorized client"); return VC_ERROR_OPERATION_FAILED; } /* check authority valid */ - if (true == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) { + if (true == vc_mgr_client_is_valid_authorized_client(pid)) { SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed"); - if (0 != vc_mgr_client_set_valid_authorized_client(g_vc_m, -1)) { + if (0 != vc_mgr_client_set_valid_authorized_client(-1)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set valid authorized client"); return VC_ERROR_OPERATION_FAILED; } @@ -3060,7 +3057,7 @@ static Eina_Bool __request_auth_start(void* data) { SLOG(LOG_INFO, TAG_VCM, "Request Start"); - if (0 != vc_mgr_client_set_start_by_client(g_vc_m, true)) { + if (0 != vc_mgr_client_set_start_by_client(true)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); } @@ -3069,7 +3066,7 @@ static Eina_Bool __request_auth_start(void* data) /* TODO - Error handling? */ } - if (0 != vc_mgr_client_set_start_by_client(g_vc_m, false)) { + if (0 != vc_mgr_client_set_start_by_client(false)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); } @@ -3080,7 +3077,7 @@ static Eina_Bool __request_auth_start(void* data) int __vc_mgr_request_auth_start(int pid) { /* check authorized */ - if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) { + if (false == vc_mgr_client_is_valid_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client"); return VC_ERROR_INVALID_PARAMETER; } @@ -3106,7 +3103,7 @@ static Eina_Bool __request_auth_stop(void* data) int __vc_mgr_request_auth_stop(int pid) { /* check authorized */ - if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) { + if (false == vc_mgr_client_is_valid_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client"); return VC_ERROR_INVALID_PARAMETER; } @@ -3132,7 +3129,7 @@ static Eina_Bool __request_auth_cancel(void* data) int __vc_mgr_request_auth_cancel(int pid) { /* check authorized */ - if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) { + if (false == vc_mgr_client_is_valid_authorized_client(pid)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client"); return VC_ERROR_INVALID_PARAMETER; } @@ -3153,7 +3150,7 @@ int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callba RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set specific engine result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3161,7 +3158,7 @@ int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callba /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_specific_engine_result_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_specific_engine_result_cb(callback, user_data); return VC_ERROR_NONE; } @@ -3172,7 +3169,7 @@ int vc_mgr_unset_specific_engine_result_cb(void) } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset specific engine result callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3180,7 +3177,7 @@ int vc_mgr_unset_specific_engine_result_cb(void) /* check state */ RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state); - vc_mgr_client_set_specific_engine_result_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_specific_engine_result_cb(NULL, NULL); return VC_ERROR_NONE; } @@ -3190,12 +3187,12 @@ void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* e vc_mgr_specific_engine_result_cb callback = NULL; void* user_data = NULL; - vc_mgr_client_get_specific_engine_result_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_specific_engine_result_cb(&callback, &user_data); RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client specific engine result callback is NULL"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(engine_app_id, event, result, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); SLOG(LOG_INFO, TAG_VCM, "Specific engine result callback is called, engine app id(%s), event(%s), result(%s)", engine_app_id, event, result); return; @@ -3214,7 +3211,7 @@ int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback audio format callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3222,7 +3219,7 @@ int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback /* check state */ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set feedback audio format callback : Current state is not 'Initialized'"); - vc_mgr_client_set_feedback_audio_format_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_feedback_audio_format_cb(callback, user_data); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback audio format callback"); @@ -3239,7 +3236,7 @@ int vc_mgr_unset_feedback_audio_format_cb() return ret; vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback audio format callback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3247,7 +3244,7 @@ int vc_mgr_unset_feedback_audio_format_cb() /* check state */ RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset feedback audio format callback : Current state is not 'Initialized'"); - vc_mgr_client_set_feedback_audio_format_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_feedback_audio_format_cb(NULL, NULL); SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback audio format callback"); @@ -3268,7 +3265,7 @@ int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void pthread_mutex_lock(&g_feedback_streaming_cb_mutex); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available"); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); return VC_ERROR_INVALID_STATE; @@ -3281,7 +3278,7 @@ int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void return VC_ERROR_INVALID_STATE; } - vc_mgr_client_set_feedback_streaming_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_feedback_streaming_cb(callback, user_data); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); @@ -3302,7 +3299,7 @@ int vc_mgr_unset_feedback_streaming_cb() pthread_mutex_lock(&g_feedback_streaming_cb_mutex); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available"); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); return VC_ERROR_INVALID_STATE; @@ -3315,7 +3312,7 @@ int vc_mgr_unset_feedback_streaming_cb() return VC_ERROR_INVALID_STATE; } - vc_mgr_client_set_feedback_streaming_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_feedback_streaming_cb(NULL, NULL); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); @@ -3338,7 +3335,7 @@ int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* us pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available"); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); return VC_ERROR_INVALID_STATE; @@ -3351,7 +3348,7 @@ int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* us return VC_ERROR_INVALID_STATE; } - vc_mgr_client_set_vc_tts_streaming_cb(g_vc_m, callback, user_data); + vc_mgr_client_set_vc_tts_streaming_cb(callback, user_data); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); @@ -3372,7 +3369,7 @@ int vc_mgr_unset_vc_tts_streaming_cb() pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available"); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); return VC_ERROR_INVALID_STATE; @@ -3385,7 +3382,7 @@ int vc_mgr_unset_vc_tts_streaming_cb() return VC_ERROR_INVALID_STATE; } - vc_mgr_client_set_vc_tts_streaming_cb(g_vc_m, NULL, NULL); + vc_mgr_client_set_vc_tts_streaming_cb(NULL, NULL); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); @@ -3438,7 +3435,7 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) pthread_mutex_lock(&g_feedback_streaming_cb_mutex); - vc_mgr_client_get_feedback_streaming_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_feedback_streaming_cb(&callback, &user_data); if (NULL == callback) { SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback streaming callback is null"); vc_mgr_data_clear_feedback_data(&feedback_data); @@ -3447,9 +3444,9 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) } SLOG(LOG_DEBUG, TAG_VCM, "TTS feedback streaming callback is called"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(feedback_data->event, feedback_data->data, feedback_data->data_size, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); @@ -3468,7 +3465,7 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex); - vc_mgr_client_get_vc_tts_streaming_cb(g_vc_m, &callback, &user_data); + vc_mgr_client_get_vc_tts_streaming_cb(&callback, &user_data); if (NULL == callback) { SLOG(LOG_WARN, TAG_VCM, "[WARNING] vc tts streaming callback is null"); vc_mgr_data_clear_feedback_data(&feedback_data); @@ -3477,9 +3474,9 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) } SLOG(LOG_DEBUG, TAG_VCM, "vc tts feedback streaming callback is called"); - vc_mgr_client_use_callback(g_vc_m); + vc_mgr_client_use_callback(); callback(feedback_data->pid, feedback_data->utt_id, feedback_data->event, feedback_data->data, feedback_data->data_size, user_data); - vc_mgr_client_not_use_callback(g_vc_m); + vc_mgr_client_not_use_callback(); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); @@ -3517,7 +3514,7 @@ int vc_mgr_start_feedback(void) SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request start TTS feedback"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Start feedback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3554,7 +3551,7 @@ int vc_mgr_stop_feedback(void) SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request stop TTS feedback"); vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stop feedback : A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3607,7 +3604,7 @@ int vc_mgr_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e } vc_state_e state; - if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) { + if (0 != vc_mgr_client_get_client_state(&state)) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } @@ -3617,7 +3614,7 @@ int vc_mgr_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e /* Check service state */ vc_service_state_e service_state = -1; - vc_mgr_client_get_service_state(g_vc_m, &service_state); + vc_mgr_client_get_service_state(&service_state); RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state); ret = vc_mgr_tidl_send_utterance_status(pid, utt_id, utt_status); @@ -3679,7 +3676,7 @@ int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* RETVM_IF(NULL == buffer, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); vc_state_e state = VC_STATE_NONE; - ret = vc_mgr_client_get_client_state(g_vc_m, &state); + ret = vc_mgr_client_get_client_state(&state); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; @@ -3688,7 +3685,7 @@ int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state); vc_service_state_e service_state = VC_SERVICE_STATE_NONE; - ret = vc_mgr_client_get_service_state(g_vc_m, &service_state); + ret = vc_mgr_client_get_service_state(&service_state); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; @@ -3702,7 +3699,7 @@ int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* float volume = __get_volume_decibel((char*)buffer, len); __vc_mgr_set_volume(volume); - ret = vc_mgr_tidl_send_audio_streaming(g_vc_m->handle, event, buffer, len); + ret = vc_mgr_tidl_send_audio_streaming(g_pid, event, buffer, len); if (0 != ret) SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data"); else @@ -3725,21 +3722,21 @@ int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode) } vc_state_e state = VC_STATE_NONE; - ret = vc_mgr_client_get_client_state(g_vc_m, &state); + ret = vc_mgr_client_get_client_state(&state); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } vc_service_state_e service_state = VC_SERVICE_STATE_NONE; - ret = vc_mgr_client_get_service_state(g_vc_m, &service_state); + ret = vc_mgr_client_get_service_state(&service_state); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; } if (VC_STATE_INITIALIZED == state && VC_SERVICE_STATE_NONE == service_state) { - ret = vc_mgr_client_set_audio_streaming_mode(g_vc_m, mode); + ret = vc_mgr_client_set_audio_streaming_mode(mode); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret)); return VC_ERROR_INVALID_STATE; @@ -3747,7 +3744,7 @@ int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode) SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client"); } } else if (VC_STATE_READY == state && VC_SERVICE_STATE_READY == service_state) { - ret = vc_mgr_client_set_audio_streaming_mode(g_vc_m, mode); + ret = vc_mgr_client_set_audio_streaming_mode(mode); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret)); return VC_ERROR_INVALID_STATE; @@ -3755,7 +3752,7 @@ int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode) SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client"); } - ret = vc_mgr_tidl_request_set_audio_streaming_mode(g_vc_m->handle, mode); + ret = vc_mgr_tidl_request_set_audio_streaming_mode(g_pid, mode); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %s", __vc_mgr_get_error_code(ret)); return VC_ERROR_OPERATION_FAILED; @@ -3798,7 +3795,7 @@ int vc_mgr_change_background_volume(vc_background_volume_event_e event) } vc_state_e state = VC_STATE_NONE; - ret = vc_mgr_client_get_client_state(g_vc_m, &state); + ret = vc_mgr_client_get_client_state(&state); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; @@ -3838,7 +3835,7 @@ int vc_mgr_change_background_volume_by_ratio(double ratio) } vc_state_e state = VC_STATE_NONE; - ret = vc_mgr_client_get_client_state(g_vc_m, &state); + ret = vc_mgr_client_get_client_state(&state); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; @@ -3868,7 +3865,7 @@ int vc_mgr_reset_background_volume(void) return ret; vc_state_e state = VC_STATE_NONE; - ret = vc_mgr_client_get_client_state(g_vc_m, &state); + ret = vc_mgr_client_get_client_state(&state); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available"); return VC_ERROR_INVALID_STATE; diff --git a/client/vc_mgr_client.c b/client/vc_mgr_client.c index f10480b..867f9d3 100644 --- a/client/vc_mgr_client.c +++ b/client/vc_mgr_client.c @@ -20,9 +20,7 @@ typedef struct { /* base info */ - vc_h vc; int pid; - unsigned int uid; /*<< unique id = pid + handle */ vc_mgr_all_result_cb all_result_cb; void* all_result_user_data; @@ -41,7 +39,7 @@ typedef struct { void* speech_detected_user_data; vc_current_language_changed_cb current_lang_changed_cb; void* current_lang_changed_user_data; - vc_mgr_dialog_request_cb diaglog_requst_cb; + vc_mgr_dialog_request_cb dialog_request_cb; void* dialog_request_user_data; vc_mgr_private_data_set_cb private_data_set_cb; void* private_data_set_user_data; @@ -114,808 +112,603 @@ typedef struct { int pid; } vc_authorized_client_s; -static GSList *g_mgr_client_list = NULL; +static vc_mgr_client_s *g_mgr_client = NULL; -static vc_mgr_client_s* __mgr_client_get(vc_h vc) +int vc_mgr_client_create() { - if (vc == NULL) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL"); - return NULL; - } - - vc_mgr_client_s *data = NULL; - - int count = g_slist_length(g_mgr_client_list); - int i; - - for (i = 0; i < count; i++) { - data = g_slist_nth_data(g_mgr_client_list, i); - - if (NULL != data) { - if (vc->handle == data->vc->handle) { - return data; - } - } - } - - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Fail to get client by vc"); - - return NULL; -} - -int vc_mgr_client_create(vc_h* vc) -{ - vc_mgr_client_s *client = NULL; - - client = (vc_mgr_client_s*)calloc(1, sizeof(vc_mgr_client_s)); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to allocate memory"); - return VC_ERROR_OUT_OF_MEMORY; + if (NULL != g_mgr_client) { + SLOG(LOG_WARN, TAG_VCM, "[WARNING] A manager client is already exist."); + return VC_ERROR_NONE; } - vc_h temp = (vc_h)calloc(1, sizeof(struct vc_s)); - if (NULL == temp) { + g_mgr_client = (vc_mgr_client_s*)calloc(1, sizeof(vc_mgr_client_s)); + if (NULL == g_mgr_client) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to allocate memory"); - 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->all_result_cb = NULL; - client->all_result_user_data = NULL; - client->result_cb = NULL; - client->result_user_data = NULL; - client->pre_result_cb = NULL; - client->pre_result_user_data = NULL; - - client->error_cb = NULL; - client->error_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->speech_detected_cb = NULL; - client->speech_detected_user_data = NULL; - client->current_lang_changed_cb = NULL; - client->current_lang_changed_user_data = NULL; - client->diaglog_requst_cb = NULL; - client->dialog_request_user_data = NULL; - client->private_data_set_cb = NULL; - client->private_data_set_user_data = NULL; - client->private_data_requested_cb = NULL; - client->private_data_requested_user_data = NULL; - client->specific_engine_result_cb = NULL; - client->specific_engine_result_user_data = NULL; - - client->feedback_audio_format_cb = NULL; - client->feedback_audio_format_user_data = NULL; - client->feedback_streaming_cb = NULL; - client->feedback_streaming_user_data = NULL; - client->vc_tts_streaming_cb = NULL; - client->vc_tts_streaming_user_data = NULL; - - client->exclusive_cmd_option = false; - - client->all_result_event = 0; - client->all_result_text = NULL; - - client->result_event = -1; - client->result_text = NULL; - - client->service_state = VC_SERVICE_STATE_NONE; - - client->internal_state = VC_INTERNAL_STATE_NONE; - - client->previous_state = VC_STATE_INITIALIZED; - client->current_state = VC_STATE_INITIALIZED; - - client->previous_language = NULL; - client->current_language = NULL; - - client->audio_id = NULL; - client->recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE; - - client->reason = 0; - client->err_msg = NULL; - - client->cb_ref_count = 0; - - client->disabled_cmd_type = 0x00; + g_mgr_client->pid = getpid(); - /* Authority */ - client->authorized_client_list = NULL; - client->valid_authorized_pid = -1; - client->start_by_client = false; + g_mgr_client->all_result_cb = NULL; + g_mgr_client->all_result_user_data = NULL; + g_mgr_client->result_cb = NULL; + g_mgr_client->result_user_data = NULL; + g_mgr_client->pre_result_cb = NULL; + g_mgr_client->pre_result_user_data = NULL; - client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND; + g_mgr_client->error_cb = NULL; + g_mgr_client->error_user_data = NULL; + g_mgr_client->service_state_changed_cb = NULL; + g_mgr_client->service_state_changed_user_data = NULL; + g_mgr_client->state_changed_cb = NULL; + g_mgr_client->state_changed_user_data = NULL; + g_mgr_client->speech_detected_cb = NULL; + g_mgr_client->speech_detected_user_data = NULL; + g_mgr_client->current_lang_changed_cb = NULL; + g_mgr_client->current_lang_changed_user_data = NULL; + g_mgr_client->dialog_request_cb = NULL; + g_mgr_client->dialog_request_user_data = NULL; + g_mgr_client->private_data_set_cb = NULL; + g_mgr_client->private_data_set_user_data = NULL; + g_mgr_client->private_data_requested_cb = NULL; + g_mgr_client->private_data_requested_user_data = NULL; + g_mgr_client->specific_engine_result_cb = NULL; + g_mgr_client->specific_engine_result_user_data = NULL; - client->streaming_mode = VC_AUDIO_STREAMING_MODE_VC_SERVICE; + g_mgr_client->feedback_audio_format_cb = NULL; + g_mgr_client->feedback_audio_format_user_data = NULL; + g_mgr_client->feedback_streaming_cb = NULL; + g_mgr_client->feedback_streaming_user_data = NULL; + g_mgr_client->vc_tts_streaming_cb = NULL; + g_mgr_client->vc_tts_streaming_user_data = NULL; - g_mgr_client_list = g_slist_append(g_mgr_client_list, client); + g_mgr_client->exclusive_cmd_option = false; - *vc = temp; + g_mgr_client->all_result_event = 0; + g_mgr_client->all_result_text = NULL; - return VC_ERROR_NONE; -} + g_mgr_client->result_event = -1; + g_mgr_client->result_text = NULL; -int vc_mgr_client_destroy(vc_h vc) -{ - if (vc == NULL) { - SLOG(LOG_ERROR, TAG_VCM, "Input parameter is NULL"); - return VC_ERROR_NONE; - } + g_mgr_client->service_state = VC_SERVICE_STATE_NONE; - vc_mgr_client_s *data = NULL; + g_mgr_client->internal_state = VC_INTERNAL_STATE_NONE; - int count = g_slist_length(g_mgr_client_list); - int i; + g_mgr_client->previous_state = VC_STATE_INITIALIZED; + g_mgr_client->current_state = VC_STATE_INITIALIZED; - for (i = 0; i < count; i++) { - data = g_slist_nth_data(g_mgr_client_list, i); + g_mgr_client->previous_language = NULL; + g_mgr_client->current_language = NULL; - if (NULL != data) { - if (vc->handle == data->vc->handle) { - g_mgr_client_list = g_slist_remove(g_mgr_client_list, data); + g_mgr_client->audio_id = NULL; + g_mgr_client->recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE; - while (0 != data->cb_ref_count) { - /* wait for release callback function */ - } + g_mgr_client->reason = 0; + g_mgr_client->err_msg = NULL; - if (NULL != data->audio_id) { - free(data->audio_id); - } + g_mgr_client->cb_ref_count = 0; - if (NULL != data->all_result_text) { - free(data->all_result_text); - } + g_mgr_client->disabled_cmd_type = 0x00; - if (NULL != data->err_msg) { - free(data->err_msg); - } + /* Authority */ + g_mgr_client->authorized_client_list = NULL; + g_mgr_client->valid_authorized_pid = -1; + g_mgr_client->start_by_client = false; - free(data); - free(vc); + g_mgr_client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND; - data = NULL; - vc = NULL; + g_mgr_client->streaming_mode = VC_AUDIO_STREAMING_MODE_VC_SERVICE; - return VC_ERROR_NONE; - } - } - } - - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] client Not found"); - - return VC_ERROR_INVALID_PARAMETER; + return VC_ERROR_NONE; } -bool vc_mgr_client_is_valid(vc_h vc) +int vc_mgr_client_destroy() { - vc_mgr_client_s* client = __mgr_client_get(vc); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] vc is not valid"); - return false; + if (NULL == g_mgr_client) { + SLOG(LOG_ERROR, TAG_VCM, "A manager client is already NULL"); //LCOV_EXCL_LINE + return VC_ERROR_NONE; } - return true; -} - -bool vc_mgr_client_is_valid_by_uid(unsigned int uid) -{ - vc_mgr_client_s *data = NULL; + while (0 != g_mgr_client->cb_ref_count) { + /* wait for release callback function */ + usleep(10000); + } - int count = g_slist_length(g_mgr_client_list); - int i; + if (NULL != g_mgr_client->audio_id) { + free(g_mgr_client->audio_id); + } - for (i = 0; i < count; i++) { - data = g_slist_nth_data(g_mgr_client_list, i); + if (NULL != g_mgr_client->all_result_text) { + free(g_mgr_client->all_result_text); + } - if (NULL != data) { - if (uid == data->vc->handle) - return true; - } + if (NULL != g_mgr_client->err_msg) { + free(g_mgr_client->err_msg); } - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Fail to get client by vc"); + free(g_mgr_client); - return false; + return VC_ERROR_NONE; } -int vc_mgr_client_get_handle(unsigned int uid, vc_h* vc) +bool vc_mgr_client_is_valid() { - vc_mgr_client_s *data = NULL; - - int count = g_slist_length(g_mgr_client_list); - int i; - - for (i = 0; i < count; i++) { - data = g_slist_nth_data(g_mgr_client_list, i); - - if (NULL != data) { - if (uid == data->vc->handle) { - *vc = data->vc; - return VC_ERROR_NONE; - } - } + /* check handle */ + if (NULL == g_mgr_client) { + SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] manager client not allocated"); + return false; } - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to find the corresponding handle."); - return VC_ERROR_INVALID_PARAMETER; + return true; } -int vc_mgr_client_get_pid(vc_h vc, int* pid) +int vc_mgr_client_get_pid(int* pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) { - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] vc is not valid"); - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) { + SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] manager client not allocated"); + return VC_ERROR_OPERATION_FAILED; } - *pid = client->pid; + *pid = g_mgr_client->pid; return VC_ERROR_NONE; } /* set/get callback function */ -int vc_mgr_client_set_all_result_cb(vc_h vc, vc_mgr_all_result_cb callback, void* user_data) +int vc_mgr_client_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->all_result_cb = callback; - client->all_result_user_data = user_data; + g_mgr_client->all_result_cb = callback; + g_mgr_client->all_result_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_all_result_cb(vc_h vc, vc_mgr_all_result_cb* callback, void** user_data) +int vc_mgr_client_get_all_result_cb(vc_mgr_all_result_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->all_result_cb; - *user_data = client->all_result_user_data; + *callback = g_mgr_client->all_result_cb; + *user_data = g_mgr_client->all_result_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data) +int vc_mgr_client_set_result_cb(vc_result_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->result_cb = callback; - client->result_user_data = user_data; + g_mgr_client->result_cb = callback; + g_mgr_client->result_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data) +int vc_mgr_client_get_result_cb(vc_result_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->result_cb; - *user_data = client->result_user_data; + *callback = g_mgr_client->result_cb; + *user_data = g_mgr_client->result_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb callback, void* user_data) +int vc_mgr_client_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->pre_result_cb = callback; - client->pre_result_user_data = user_data; + g_mgr_client->pre_result_cb = callback; + g_mgr_client->pre_result_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb* callback, void** user_data) +int vc_mgr_client_get_pre_result_cb(vc_mgr_pre_result_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->pre_result_cb; - *user_data = client->pre_result_user_data; + *callback = g_mgr_client->pre_result_cb; + *user_data = g_mgr_client->pre_result_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data) +int vc_mgr_client_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->service_state_changed_cb = callback; - client->service_state_changed_user_data = user_data; + g_mgr_client->service_state_changed_cb = callback; + g_mgr_client->service_state_changed_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data) +int vc_mgr_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->service_state_changed_cb; - *user_data = client->service_state_changed_user_data; + *callback = g_mgr_client->service_state_changed_cb; + *user_data = g_mgr_client->service_state_changed_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data) +int vc_mgr_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->state_changed_cb = callback; - client->state_changed_user_data = user_data; + g_mgr_client->state_changed_cb = callback; + g_mgr_client->state_changed_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data) +int vc_mgr_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->state_changed_cb; - *user_data = client->state_changed_user_data; + *callback = g_mgr_client->state_changed_cb; + *user_data = g_mgr_client->state_changed_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb callback, void* user_data) +int vc_mgr_client_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->speech_detected_cb = callback; - client->speech_detected_user_data = user_data; + g_mgr_client->speech_detected_cb = callback; + g_mgr_client->speech_detected_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb* callback, void** user_data) +int vc_mgr_client_get_speech_detected_cb(vc_mgr_begin_speech_detected_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->speech_detected_cb; - *user_data = client->speech_detected_user_data; + *callback = g_mgr_client->speech_detected_cb; + *user_data = g_mgr_client->speech_detected_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data) +int vc_mgr_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->current_lang_changed_cb = callback; - client->current_lang_changed_user_data = user_data; + g_mgr_client->current_lang_changed_cb = callback; + g_mgr_client->current_lang_changed_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data) +int vc_mgr_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->current_lang_changed_cb; - *user_data = client->current_lang_changed_user_data; + *callback = g_mgr_client->current_lang_changed_cb; + *user_data = g_mgr_client->current_lang_changed_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data) +int vc_mgr_client_set_error_cb(vc_error_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->error_cb = callback; - client->error_user_data = user_data; + g_mgr_client->error_cb = callback; + g_mgr_client->error_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data) +int vc_mgr_client_get_error_cb(vc_error_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->error_cb; - *user_data = client->error_user_data; + *callback = g_mgr_client->error_cb; + *user_data = g_mgr_client->error_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb callback, void* user_data) +int vc_mgr_client_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->diaglog_requst_cb = callback; - client->dialog_request_user_data = user_data; + g_mgr_client->dialog_request_cb = callback; + g_mgr_client->dialog_request_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb* callback, void** user_data) +int vc_mgr_client_get_dialog_request_cb(vc_mgr_dialog_request_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->diaglog_requst_cb; - *user_data = client->dialog_request_user_data; + *callback = g_mgr_client->dialog_request_cb; + *user_data = g_mgr_client->dialog_request_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_private_data_set_cb(vc_h vc, vc_mgr_private_data_set_cb callback, void* user_data) +int vc_mgr_client_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->private_data_set_cb = callback; - client->private_data_set_user_data = user_data; + g_mgr_client->private_data_set_cb = callback; + g_mgr_client->private_data_set_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_private_data_set_cb(vc_h vc, vc_mgr_private_data_set_cb* callback, void** user_data) +int vc_mgr_client_get_private_data_set_cb(vc_mgr_private_data_set_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->private_data_set_cb; - *user_data = client->private_data_set_user_data; + *callback = g_mgr_client->private_data_set_cb; + *user_data = g_mgr_client->private_data_set_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb callback, void* user_data) +int vc_mgr_client_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->private_data_requested_cb = callback; - client->private_data_requested_user_data = user_data; + g_mgr_client->private_data_requested_cb = callback; + g_mgr_client->private_data_requested_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb* callback, void** user_data) +int vc_mgr_client_get_private_data_requested_cb(vc_mgr_private_data_requested_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->private_data_requested_cb; - *user_data = client->private_data_requested_user_data; + *callback = g_mgr_client->private_data_requested_cb; + *user_data = g_mgr_client->private_data_requested_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb callback, void* user_data) +int vc_mgr_client_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->feedback_audio_format_cb = callback; - client->feedback_audio_format_user_data = user_data; + g_mgr_client->feedback_audio_format_cb = callback; + g_mgr_client->feedback_audio_format_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb* callback, void** user_data) +int vc_mgr_client_get_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->feedback_audio_format_cb; - *user_data = client->feedback_audio_format_user_data; + *callback = g_mgr_client->feedback_audio_format_cb; + *user_data = g_mgr_client->feedback_audio_format_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb callback, void* user_data) +int vc_mgr_client_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->feedback_streaming_cb = callback; - client->feedback_streaming_user_data = user_data; + g_mgr_client->feedback_streaming_cb = callback; + g_mgr_client->feedback_streaming_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb* callback, void** user_data) +int vc_mgr_client_get_feedback_streaming_cb(vc_mgr_feedback_streaming_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->feedback_streaming_cb; - *user_data = client->feedback_streaming_user_data; + *callback = g_mgr_client->feedback_streaming_cb; + *user_data = g_mgr_client->feedback_streaming_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb callback, void* user_data) +int vc_mgr_client_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->vc_tts_streaming_cb = callback; - client->vc_tts_streaming_user_data = user_data; + g_mgr_client->vc_tts_streaming_cb = callback; + g_mgr_client->vc_tts_streaming_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb* callback, void** user_data) +int vc_mgr_client_get_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->vc_tts_streaming_cb; - *user_data = client->vc_tts_streaming_user_data; + *callback = g_mgr_client->vc_tts_streaming_cb; + *user_data = g_mgr_client->vc_tts_streaming_user_data; return VC_ERROR_NONE; } /* set/get option */ -int vc_mgr_client_set_service_state(vc_h vc, vc_service_state_e state) +int vc_mgr_client_set_service_state(vc_service_state_e state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->service_state = state; + g_mgr_client->service_state = state; return VC_ERROR_NONE; } -int vc_mgr_client_get_service_state(vc_h vc, vc_service_state_e* state) +int vc_mgr_client_get_service_state(vc_service_state_e* state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *state = client->service_state; + *state = g_mgr_client->service_state; return VC_ERROR_NONE; } -int vc_mgr_client_set_internal_state(vc_h vc, vc_internal_state_e state) +int vc_mgr_client_set_internal_state(vc_internal_state_e state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->internal_state = state; + g_mgr_client->internal_state = state; return VC_ERROR_NONE; } -int vc_mgr_client_get_internal_state(vc_h vc, vc_internal_state_e* state) +int vc_mgr_client_get_internal_state(vc_internal_state_e* state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *state = client->internal_state; + *state = g_mgr_client->internal_state; return VC_ERROR_NONE; } -int vc_mgr_client_set_client_state(vc_h vc, vc_state_e state) +int vc_mgr_client_set_client_state(vc_state_e state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->previous_state = client->current_state; - client->current_state = state; + g_mgr_client->previous_state = g_mgr_client->current_state; + g_mgr_client->current_state = state; return VC_ERROR_NONE; } -int vc_mgr_client_get_client_state(vc_h vc, vc_state_e* state) +int vc_mgr_client_get_client_state(vc_state_e* state) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *state = client->current_state; + *state = g_mgr_client->current_state; return VC_ERROR_NONE; } -int vc_mgr_client_get_client_state_by_uid(unsigned int uid, vc_state_e* state) +int vc_mgr_client_get_previous_state(vc_state_e* state, vc_state_e* previous_state) { - vc_mgr_client_s *data = NULL; - - int count = g_slist_length(g_mgr_client_list); - int i; - - for (i = 0; i < count; i++) { - data = g_slist_nth_data(g_mgr_client_list, i); - - if (NULL != data) { - if (uid == data->vc->handle) { - *state = data->current_state; - return VC_ERROR_NONE; - } - } - } - - return VC_ERROR_INVALID_PARAMETER; -} - -int vc_mgr_client_get_previous_state(vc_h vc, vc_state_e* state, vc_state_e* previous_state) -{ - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *previous_state = client->previous_state; - *state = client->current_state; + *previous_state = g_mgr_client->previous_state; + *state = g_mgr_client->current_state; return VC_ERROR_NONE; } -int vc_mgr_client_set_error(vc_h vc, int reason) +int vc_mgr_client_set_error(int reason) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->reason = reason; + g_mgr_client->reason = reason; return VC_ERROR_NONE; } -int vc_mgr_client_get_error(vc_h vc, int* reason) +int vc_mgr_client_get_error(int* reason) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *reason = client->reason; + *reason = g_mgr_client->reason; return VC_ERROR_NONE; } -int vc_mgr_client_set_error_message(vc_h vc, const char* err_msg) +int vc_mgr_client_set_error_message(const char* err_msg) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - if (NULL != client->err_msg) { - free(client->err_msg); - client->err_msg = NULL; + if (NULL != g_mgr_client->err_msg) { + free(g_mgr_client->err_msg); + g_mgr_client->err_msg = NULL; } if (NULL != err_msg) { - client->err_msg = strdup(err_msg); - if (NULL == client->err_msg) { + g_mgr_client->err_msg = strdup(err_msg); + if (NULL == g_mgr_client->err_msg) { return VC_ERROR_OUT_OF_MEMORY; } } @@ -923,16 +716,14 @@ int vc_mgr_client_set_error_message(vc_h vc, const char* err_msg) return VC_ERROR_NONE; } -int vc_mgr_client_get_error_message(vc_h vc, char** err_msg) +int vc_mgr_client_get_error_message(char** err_msg) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - if (NULL != client->err_msg) { - *err_msg = strdup(client->err_msg); + if (NULL != g_mgr_client->err_msg) { + *err_msg = strdup(g_mgr_client->err_msg); if (NULL == *err_msg) { return VC_ERROR_OUT_OF_MEMORY; } @@ -941,269 +732,230 @@ int vc_mgr_client_get_error_message(vc_h vc, char** err_msg) return VC_ERROR_NONE; } -int vc_mgr_client_enable_command_type(vc_h vc, vc_cmd_type_e cmd_type) +int vc_mgr_client_enable_command_type(vc_cmd_type_e cmd_type) { SLOG(LOG_INFO, TAG_VCM, "[Manager INFO] enable command type (%d)", cmd_type); - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->disabled_cmd_type &= ~(1 << cmd_type); + g_mgr_client->disabled_cmd_type &= ~(1 << cmd_type); return VC_ERROR_NONE; } -int vc_mgr_client_disable_command_type(vc_h vc, vc_cmd_type_e cmd_type) +int vc_mgr_client_disable_command_type(vc_cmd_type_e cmd_type) { SLOG(LOG_INFO, TAG_VCM, "[Manager INFO] disable command type (%d)", cmd_type); - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->disabled_cmd_type |= (1 << cmd_type); + g_mgr_client->disabled_cmd_type |= (1 << cmd_type); return VC_ERROR_NONE; } -int vc_mgr_client_get_disabled_command_type(vc_h vc, int* disabled_cmd_type) +int vc_mgr_client_get_disabled_command_type(int* disabled_cmd_type) { SLOG(LOG_INFO, TAG_VCM, "[Manager INFO] get disabled command type"); - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *disabled_cmd_type = client->disabled_cmd_type; + *disabled_cmd_type = g_mgr_client->disabled_cmd_type; return VC_ERROR_NONE; } -int vc_mgr_client_set_exclusive_command(vc_h vc, bool value) +int vc_mgr_client_set_exclusive_command(bool value) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->exclusive_cmd_option = value; + g_mgr_client->exclusive_cmd_option = value; return VC_ERROR_NONE; } -bool vc_mgr_client_get_exclusive_command(vc_h vc) +bool vc_mgr_client_get_exclusive_command() { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - return client->exclusive_cmd_option; + return g_mgr_client->exclusive_cmd_option; } -int vc_mgr_client_set_all_result(vc_h vc, int event, const char* result_text) +int vc_mgr_client_set_all_result(int event, const char* result_text) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->all_result_event = event; + g_mgr_client->all_result_event = event; - if (NULL != client->all_result_text) { - free(client->all_result_text); - client->all_result_text = NULL; + if (NULL != g_mgr_client->all_result_text) { + free(g_mgr_client->all_result_text); + g_mgr_client->all_result_text = NULL; } if (NULL != result_text) { - client->all_result_text = strdup(result_text); + g_mgr_client->all_result_text = strdup(result_text); } return VC_ERROR_NONE; } -int vc_mgr_client_get_all_result(vc_h vc, int* event, char** result_text) +int vc_mgr_client_get_all_result(int* event, char** result_text) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *event = client->all_result_event; + *event = g_mgr_client->all_result_event; if (NULL != result_text) { - if (NULL != client->all_result_text) { - *result_text = strdup(client->all_result_text); + if (NULL != g_mgr_client->all_result_text) { + *result_text = strdup(g_mgr_client->all_result_text); } } return VC_ERROR_NONE; } -int vc_mgr_client_unset_all_result(vc_h vc) +int vc_mgr_client_unset_all_result() { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->all_result_event = -1; + g_mgr_client->all_result_event = -1; - if (NULL != client->all_result_text) { - free(client->all_result_text); - client->all_result_text = NULL; + if (NULL != g_mgr_client->all_result_text) { + free(g_mgr_client->all_result_text); + g_mgr_client->all_result_text = NULL; } return VC_ERROR_NONE; } -int vc_mgr_client_set_audio_type(vc_h vc, const char* audio_id) +int vc_mgr_client_set_audio_type(const char* audio_id) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; if (NULL != audio_id) { - if (NULL != client->audio_id) { - free(client->audio_id); - client->audio_id = NULL; + if (NULL != g_mgr_client->audio_id) { + free(g_mgr_client->audio_id); + g_mgr_client->audio_id = NULL; } - client->audio_id = strdup(audio_id); + g_mgr_client->audio_id = strdup(audio_id); } return VC_ERROR_NONE; } -int vc_mgr_client_get_audio_type(vc_h vc, char** audio_id) +int vc_mgr_client_get_audio_type(char** audio_id) { if (NULL == audio_id) { return VC_ERROR_INVALID_PARAMETER; } - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - if (NULL != client->audio_id) - *audio_id = strdup(client->audio_id); + if (NULL != g_mgr_client->audio_id) + *audio_id = strdup(g_mgr_client->audio_id); else *audio_id = NULL; return VC_ERROR_NONE; } -int vc_mgr_client_set_recognition_mode(vc_h vc, vc_recognition_mode_e mode) +int vc_mgr_client_set_recognition_mode(vc_recognition_mode_e mode) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->recognition_mode = mode; + g_mgr_client->recognition_mode = mode; return VC_ERROR_NONE; } -int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode) +int vc_mgr_client_get_recognition_mode(vc_recognition_mode_e* mode) { if (NULL == mode) { return VC_ERROR_INVALID_PARAMETER; } - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *mode = client->recognition_mode; + *mode = g_mgr_client->recognition_mode; return VC_ERROR_NONE; } -int vc_mgr_client_set_foreground(vc_h vc, int pid, bool value) +int vc_mgr_client_set_foreground(int pid, bool value) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; if (true == value) { - client->foreground_pid = pid; + g_mgr_client->foreground_pid = pid; } else { - if (pid == client->foreground_pid) { - client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND; + if (pid == g_mgr_client->foreground_pid) { + g_mgr_client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND; } } return VC_ERROR_NONE; } -int vc_mgr_client_get_foreground(vc_h vc, int* pid) +int vc_mgr_client_get_foreground(int* pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *pid = client->foreground_pid; + *pid = g_mgr_client->foreground_pid; return VC_ERROR_NONE; } /* utils */ -int vc_mgr_client_get_count() +int vc_mgr_client_use_callback() { - return g_slist_length(g_mgr_client_list); -} - -int vc_mgr_client_use_callback(vc_h vc) -{ - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->cb_ref_count++; + g_mgr_client->cb_ref_count++; return VC_ERROR_NONE; } -int vc_mgr_client_not_use_callback(vc_h vc) +int vc_mgr_client_not_use_callback() { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->cb_ref_count--; + g_mgr_client->cb_ref_count--; return VC_ERROR_NONE; } /* Authority */ -int vc_mgr_client_add_authorized_client(vc_h vc, int pid) +int vc_mgr_client_add_authorized_client(int pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; vc_authorized_client_s *authorized_client = NULL; @@ -1215,32 +967,30 @@ int vc_mgr_client_add_authorized_client(vc_h vc, int pid) authorized_client->pid = pid; - client->authorized_client_list = g_slist_append(client->authorized_client_list, authorized_client); + g_mgr_client->authorized_client_list = g_slist_append(g_mgr_client->authorized_client_list, authorized_client); SLOG(LOG_DEBUG, TAG_VCM, "Add authorized client - %d", pid); return VC_ERROR_NONE; } -int vc_mgr_client_remove_authorized_client(vc_h vc, int pid) +int vc_mgr_client_remove_authorized_client(int pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; vc_authorized_client_s *data = NULL; - int count = g_slist_length(client->authorized_client_list); + int count = g_slist_length(g_mgr_client->authorized_client_list); int i; for (i = 0; i < count; i++) { - data = g_slist_nth_data(client->authorized_client_list, i); + data = g_slist_nth_data(g_mgr_client->authorized_client_list, i); if (NULL != data) { if (pid == data->pid) { - client->authorized_client_list = g_slist_remove(client->authorized_client_list, data); + g_mgr_client->authorized_client_list = g_slist_remove(g_mgr_client->authorized_client_list, data); free(data); data = NULL; @@ -1256,21 +1006,19 @@ int vc_mgr_client_remove_authorized_client(vc_h vc, int pid) return VC_ERROR_OPERATION_FAILED; } -bool vc_mgr_client_is_authorized_client(vc_h vc, int pid) +bool vc_mgr_client_is_authorized_client(int pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; vc_authorized_client_s *data = NULL; - int count = g_slist_length(client->authorized_client_list); + int count = g_slist_length(g_mgr_client->authorized_client_list); int i; for (i = 0; i < count; i++) { - data = g_slist_nth_data(client->authorized_client_list, i); + data = g_slist_nth_data(g_mgr_client->authorized_client_list, i); if (NULL != data) { if (pid == data->pid) { @@ -1285,122 +1033,104 @@ bool vc_mgr_client_is_authorized_client(vc_h vc, int pid) return false; } -int vc_mgr_client_set_valid_authorized_client(vc_h vc, int pid) +int vc_mgr_client_set_valid_authorized_client(int pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->valid_authorized_pid = pid; + g_mgr_client->valid_authorized_pid = pid; return VC_ERROR_NONE; } -int vc_mgr_client_get_valid_authorized_client(vc_h vc, int* pid) +int vc_mgr_client_get_valid_authorized_client(int* pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *pid = client->valid_authorized_pid; + *pid = g_mgr_client->valid_authorized_pid; return VC_ERROR_NONE; } -bool vc_mgr_client_is_valid_authorized_client(vc_h vc, int pid) +bool vc_mgr_client_is_valid_authorized_client(int pid) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - if (pid == client->valid_authorized_pid) + if (pid == g_mgr_client->valid_authorized_pid) return true; else return false; } -int vc_mgr_client_set_start_by_client(vc_h vc, bool option) +int vc_mgr_client_set_start_by_client(bool option) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->start_by_client = option; + g_mgr_client->start_by_client = option; return VC_ERROR_NONE; } -int vc_mgr_client_get_start_by_client(vc_h vc, bool* option) +int vc_mgr_client_get_start_by_client(bool* option) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *option = client->start_by_client; + *option = g_mgr_client->start_by_client; return VC_ERROR_NONE; } -int vc_mgr_client_set_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb callback, void* user_data) +int vc_mgr_client_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->specific_engine_result_cb = callback; - client->specific_engine_result_user_data = user_data; + g_mgr_client->specific_engine_result_cb = callback; + g_mgr_client->specific_engine_result_user_data = user_data; return VC_ERROR_NONE; } -int vc_mgr_client_get_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb* callback, void** user_data) +int vc_mgr_client_get_specific_engine_result_cb(vc_mgr_specific_engine_result_cb* callback, void** user_data) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *callback = client->specific_engine_result_cb; - *user_data = client->specific_engine_result_user_data; + *callback = g_mgr_client->specific_engine_result_cb; + *user_data = g_mgr_client->specific_engine_result_user_data; return VC_ERROR_NONE; } -int vc_mgr_client_set_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e streaming_mode) +int vc_mgr_client_set_audio_streaming_mode(vc_audio_streaming_mode_e streaming_mode) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - client->streaming_mode = streaming_mode; + g_mgr_client->streaming_mode = streaming_mode; return VC_ERROR_NONE; } -int vc_mgr_client_get_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e* streaming_mode) +int vc_mgr_client_get_audio_streaming_mode(vc_audio_streaming_mode_e* streaming_mode) { - vc_mgr_client_s* client = __mgr_client_get(vc); - /* check handle */ - if (NULL == client) - return VC_ERROR_INVALID_PARAMETER; + if (NULL == g_mgr_client) + return VC_ERROR_OPERATION_FAILED; - *streaming_mode = client->streaming_mode; + *streaming_mode = g_mgr_client->streaming_mode; return VC_ERROR_NONE; } diff --git a/client/vc_mgr_client.h b/client/vc_mgr_client.h index ffa4e08..3d6b40c 100644 --- a/client/vc_mgr_client.h +++ b/client/vc_mgr_client.h @@ -37,169 +37,163 @@ typedef enum { /* * Common function */ -int vc_mgr_client_create(vc_h* vc); +int vc_mgr_client_create(); -int vc_mgr_client_destroy(vc_h vc); +int vc_mgr_client_destroy(); -bool vc_mgr_client_is_valid(vc_h vc); +bool vc_mgr_client_is_valid(); -bool vc_mgr_client_is_valid_by_uid(unsigned int uid); - -int vc_mgr_client_get_handle(unsigned int uid, vc_h* vc); - -int vc_mgr_client_get_pid(vc_h vc, int* pid); +int vc_mgr_client_get_pid(int* pid); /* * set/get callback function */ -int vc_mgr_client_set_all_result_cb(vc_h vc, vc_mgr_all_result_cb callback, void* user_data); +int vc_mgr_client_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data); -int vc_mgr_client_get_all_result_cb(vc_h vc, vc_mgr_all_result_cb* callback, void** user_data); +int vc_mgr_client_get_all_result_cb(vc_mgr_all_result_cb* callback, void** user_data); -int vc_mgr_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data); +int vc_mgr_client_set_result_cb(vc_result_cb callback, void* user_data); -int vc_mgr_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data); +int vc_mgr_client_get_result_cb(vc_result_cb* callback, void** user_data); -int vc_mgr_client_set_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb callback, void* user_data); +int vc_mgr_client_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data); -int vc_mgr_client_get_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb* callback, void** user_data); +int vc_mgr_client_get_pre_result_cb(vc_mgr_pre_result_cb* callback, void** user_data); -int vc_mgr_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data); +int vc_mgr_client_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data); -int vc_mgr_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data); +int vc_mgr_client_get_service_state_changed_cb(vc_service_state_changed_cb* callback, void** user_data); -int vc_mgr_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data); +int vc_mgr_client_set_state_changed_cb(vc_state_changed_cb callback, void* user_data); -int vc_mgr_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data); +int vc_mgr_client_get_state_changed_cb(vc_state_changed_cb* callback, void** user_data); -int vc_mgr_client_set_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb callback, void* user_data); +int vc_mgr_client_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data); -int vc_mgr_client_get_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb* callback, void** user_data); +int vc_mgr_client_get_speech_detected_cb(vc_mgr_begin_speech_detected_cb* callback, void** user_data); -int vc_mgr_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data); +int vc_mgr_client_set_current_lang_changed_cb(vc_current_language_changed_cb callback, void* user_data); -int vc_mgr_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data); +int vc_mgr_client_get_current_lang_changed_cb(vc_current_language_changed_cb* callback, void** user_data); -int vc_mgr_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data); +int vc_mgr_client_set_error_cb(vc_error_cb callback, void* user_data); -int vc_mgr_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data); +int vc_mgr_client_get_error_cb(vc_error_cb* callback, void** user_data); -int vc_mgr_client_set_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb callback, void* user_data); +int vc_mgr_client_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data); -int vc_mgr_client_get_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb* callback, void** user_data); +int vc_mgr_client_get_dialog_request_cb(vc_mgr_dialog_request_cb* callback, void** user_data); -int vc_mgr_client_set_private_data_set_cb(vc_h vc, vc_mgr_private_data_set_cb callback, void* user_data); +int vc_mgr_client_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* user_data); -int vc_mgr_client_get_private_data_set_cb(vc_h vc, vc_mgr_private_data_set_cb* callback, void** user_data); +int vc_mgr_client_get_private_data_set_cb(vc_mgr_private_data_set_cb* callback, void** user_data); -int vc_mgr_client_set_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb callback, void* user_data); +int vc_mgr_client_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callback, void* user_data); -int vc_mgr_client_get_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb* callback, void** user_data); +int vc_mgr_client_get_private_data_requested_cb(vc_mgr_private_data_requested_cb* callback, void** user_data); -int vc_mgr_client_set_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb callback, void* user_data); +int vc_mgr_client_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data); -int vc_mgr_client_get_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb* callback, void** user_data); +int vc_mgr_client_get_specific_engine_result_cb(vc_mgr_specific_engine_result_cb* callback, void** user_data); -int vc_mgr_client_set_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb callback, void* user_data); +int vc_mgr_client_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data); -int vc_mgr_client_get_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb* callback, void** user_data); +int vc_mgr_client_get_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb* callback, void** user_data); -int vc_mgr_client_set_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb callback, void* user_data); +int vc_mgr_client_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data); -int vc_mgr_client_get_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb* callback, void** user_data); +int vc_mgr_client_get_feedback_streaming_cb(vc_mgr_feedback_streaming_cb* callback, void** user_data); -int vc_mgr_client_set_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb callback, void* user_data); +int vc_mgr_client_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* user_data); -int vc_mgr_client_get_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb* callback, void** user_data); +int vc_mgr_client_get_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb* callback, void** user_data); /* * set/get option */ -int vc_mgr_client_set_service_state(vc_h vc, vc_service_state_e state); +int vc_mgr_client_set_service_state(vc_service_state_e state); -int vc_mgr_client_get_service_state(vc_h vc, vc_service_state_e* state); +int vc_mgr_client_get_service_state(vc_service_state_e* state); -int vc_mgr_client_set_internal_state(vc_h vc, vc_internal_state_e state); +int vc_mgr_client_set_internal_state(vc_internal_state_e state); -int vc_mgr_client_get_internal_state(vc_h vc, vc_internal_state_e* state); +int vc_mgr_client_get_internal_state(vc_internal_state_e* state); -int vc_mgr_client_set_client_state(vc_h vc, vc_state_e state); +int vc_mgr_client_set_client_state(vc_state_e state); -int vc_mgr_client_get_client_state(vc_h vc, vc_state_e* state); +int vc_mgr_client_get_client_state(vc_state_e* state); int vc_mgr_client_get_client_state_by_uid(unsigned int uid, vc_state_e* state); -int vc_mgr_client_get_previous_state(vc_h vc, vc_state_e* state, vc_state_e* previous_state); +int vc_mgr_client_get_previous_state(vc_state_e* state, vc_state_e* previous_state); -int vc_mgr_client_set_error(vc_h vc, int reason); +int vc_mgr_client_set_error(int reason); -int vc_mgr_client_get_error(vc_h vc, int* reason); +int vc_mgr_client_get_error(int* reason); -int vc_mgr_client_set_error_message(vc_h vc, const char* err_msg); +int vc_mgr_client_set_error_message(const char* err_msg); -int vc_mgr_client_get_error_message(vc_h vc, char** err_msg); +int vc_mgr_client_get_error_message(char** err_msg); -int vc_mgr_client_enable_command_type(vc_h vc, vc_cmd_type_e cmd_type); +int vc_mgr_client_enable_command_type(vc_cmd_type_e cmd_type); -int vc_mgr_client_disable_command_type(vc_h vc, vc_cmd_type_e cmd_type); +int vc_mgr_client_disable_command_type(vc_cmd_type_e cmd_type); -int vc_mgr_client_get_disabled_command_type(vc_h vc, int* disabled_cmd_type); +int vc_mgr_client_get_disabled_command_type(int* disabled_cmd_type); -int vc_mgr_client_set_exclusive_command(vc_h vc, bool value); +int vc_mgr_client_set_exclusive_command(bool value); -bool vc_mgr_client_get_exclusive_command(vc_h vc); +bool vc_mgr_client_get_exclusive_command(); -int vc_mgr_client_set_all_result(vc_h vc, int event, const char* result_text); +int vc_mgr_client_set_all_result(int event, const char* result_text); -int vc_mgr_client_get_all_result(vc_h vc, int* event, char** result_text); +int vc_mgr_client_get_all_result(int* event, char** result_text); -int vc_mgr_client_unset_all_result(vc_h vc); +int vc_mgr_client_unset_all_result(); -int vc_mgr_client_set_audio_type(vc_h vc, const char* audio_id); +int vc_mgr_client_set_audio_type(const char* audio_id); -int vc_mgr_client_get_audio_type(vc_h vc, char** audio_id); +int vc_mgr_client_get_audio_type(char** audio_id); -int vc_mgr_client_set_recognition_mode(vc_h vc, vc_recognition_mode_e mode); +int vc_mgr_client_set_recognition_mode(vc_recognition_mode_e mode); -int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode); +int vc_mgr_client_get_recognition_mode(vc_recognition_mode_e* mode); -int vc_mgr_client_set_foreground(vc_h vc, int pid, bool value); +int vc_mgr_client_set_foreground(int pid, bool value); -int vc_mgr_client_get_foreground(vc_h vc, int* pid); +int vc_mgr_client_get_foreground(int* pid); -int vc_mgr_client_set_multi_assistant(vc_h vc, bool use_multi_assistant); +int vc_mgr_client_set_multi_assistant(bool use_multi_assistant); -int vc_mgr_client_get_multi_assistant(vc_h vc, bool* use_multi_assistant); +int vc_mgr_client_get_multi_assistant(bool* use_multi_assistant); /* utils */ -int vc_mgr_client_get_count(); - -int vc_mgr_client_use_callback(vc_h vc); +int vc_mgr_client_use_callback(); -int vc_mgr_client_not_use_callback(vc_h vc); +int vc_mgr_client_not_use_callback(); /* Authority */ -int vc_mgr_client_add_authorized_client(vc_h vc, int pid); +int vc_mgr_client_add_authorized_client(int pid); -int vc_mgr_client_remove_authorized_client(vc_h vc, int pid); +int vc_mgr_client_remove_authorized_client(int pid); -bool vc_mgr_client_is_authorized_client(vc_h vc, int pid); +bool vc_mgr_client_is_authorized_client(int pid); -int vc_mgr_client_set_valid_authorized_client(vc_h vc, int pid); +int vc_mgr_client_set_valid_authorized_client(int pid); -int vc_mgr_client_get_valid_authorized_client(vc_h vc, int* pid); +int vc_mgr_client_get_valid_authorized_client(int* pid); -bool vc_mgr_client_is_valid_authorized_client(vc_h vc, int pid); +bool vc_mgr_client_is_valid_authorized_client(int pid); -int vc_mgr_client_set_start_by_client(vc_h vc, bool option); +int vc_mgr_client_set_start_by_client(bool option); -int vc_mgr_client_get_start_by_client(vc_h vc, bool* option); +int vc_mgr_client_get_start_by_client(bool* option); /* multi assistant */ -int vc_mgr_client_set_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e streaming_mode); +int vc_mgr_client_set_audio_streaming_mode(vc_audio_streaming_mode_e streaming_mode); -int vc_mgr_client_get_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e* streaming_mode); +int vc_mgr_client_get_audio_streaming_mode(vc_audio_streaming_mode_e* streaming_mode); #ifdef __cplusplus -- 2.7.4