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;
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");
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;
}
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;
}
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");
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;
}
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) {
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;
/* 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();
}
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;
/* 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;
}
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;
}
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;
}
__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");
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;
}
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;
}
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;
}
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;
}
/* 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;
}
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;
}
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));
}
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;
}
}
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;
}
/* 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 {
}
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;
}
/* 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 {
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;
}
/* 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");
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));
}
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;
}
/* 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));
}
}
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;
}
/* 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);
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));
}
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;
}
/* 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 */
}
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;
}
/* 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);
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;
}
/* 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);
}
}
}
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;
}
/* 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");
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 {
}
/* 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 {
}
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;
}
/* 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;
}
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;
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;
}
/* 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;
}
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;
}
/* 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 {
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;
}
/* 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 {
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;
}
/* 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;
}
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;
}
/* 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;
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;
}
/* 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");
}
/* 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");
}
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;
}
/* 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;
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");
}
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;
}
/* 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;
}
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");
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;
}
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;
}
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);
}
}
/* 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);
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);
}
/* 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;
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");
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)) {
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);
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 */
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;
}
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 */
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)) {
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)
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);
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;
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;
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;
}
/* 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");
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
/* 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;
}
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");
}
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");
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;
}
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");
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;
}
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");
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;
}
/* 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;
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;
}
/* 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;
}
{
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) {
}
/* 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");
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;
}
/* 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;
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;
}
/* 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;
}
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;
}
/* 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;
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;
}
/* 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;
}
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;
}
/* 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;
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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");
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");
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");
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");
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
/* 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;
}
}
/* 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;
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;
}
{
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");
}
/* 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");
}
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;
}
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;
}
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;
}
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;
}
/* 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;
}
}
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;
}
/* 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;
}
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;
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;
}
/* 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");
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;
}
/* 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");
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;
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);
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;
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);
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;
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);
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;
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);
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);
}
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);
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);
}
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);
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;
}
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;
}
}
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;
}
/* 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);
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;
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;
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
}
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;
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;
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;
}
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;
}
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;
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;
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;
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;
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;
}
}
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;
}
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;
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;
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) {
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;
}
projects / platform / core / uifw / voice-control.git / commitdiff