From ba8c2dcf681654b742e453f12e07706cc1a02a8a Mon Sep 17 00:00:00 2001 From: ulgal-park Date: Fri, 4 Nov 2022 15:15:31 +0900 Subject: [PATCH] Add core layer to remove extern dependency at vc_mgr_tidl Change-Id: Iba2ad7072b8f3f79080c6e979b60e0c39d2dc060 --- client/CMakeLists.txt | 1 + client/vc_mgr.c | 852 ++-------------------------------------- client/vc_mgr_core.c | 878 ++++++++++++++++++++++++++++++++++++++++++ client/vc_mgr_core.h | 68 ++++ client/vc_mgr_tidl.c | 89 ++--- 5 files changed, 1011 insertions(+), 877 deletions(-) create mode 100644 client/vc_mgr_core.c create mode 100644 client/vc_mgr_core.h diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 9d11b1f..c5e8b31 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -38,6 +38,7 @@ SET(WIDGET_SRCS SET(MANAGER_SRCS vc_mgr.c + vc_mgr_core.c vc_mgr_client.c vc_mgr_data.cpp vc_mgr_player.c diff --git a/client/vc_mgr.c b/client/vc_mgr.c index 1b02441..e974664 100644 --- a/client/vc_mgr.c +++ b/client/vc_mgr.c @@ -28,6 +28,7 @@ #include "vc_info_parser.h" #include "vc_json_parser.h" #include "vc_main.h" +#include "vc_mgr_core.h" #include "vc_mgr_client.h" #include "vc_mgr_tidl.h" #include "vc_mgr_data.h" @@ -46,18 +47,8 @@ static Ecore_Timer* g_send_hello_timer = NULL; static Ecore_Timer* g_request_init_timer = NULL; static int g_tidl_send_hello_count = 0; -static Ecore_Timer* g_m_set_volume_timer = NULL; - static int g_pid; -static GSList* g_demandable_client_list = NULL; - -static float g_volume_db = 0; - -static float g_prev_volume_db = 0; - -static float g_cur_volume_db = 0; - static int g_daemon_pid = 0; static int g_feature_enabled = -1; @@ -67,24 +58,13 @@ static bool g_privilege_allowed = false; static cynara *p_cynara = NULL; static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER; -static bool g_err_callback_status = false; -static bool g_all_result_callback_status = false; - /* for TTS feedback */ -static int g_feedback_rate = 16000; -static vc_audio_channel_e g_feedback_audio_channel = 0; -static vc_audio_type_e g_feedback_audio_type = 0; static Ecore_Thread* g_feedback_thread = NULL; static pthread_mutex_t g_feedback_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_vc_tts_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER; static Eina_Bool __vc_mgr_notify_state_changed(void *data); -static void __vc_mgr_notify_error(void *data); -static Eina_Bool __vc_mgr_notify_result(void *data); - -int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg); - static const char* __vc_mgr_get_error_code(vc_error_e err) { @@ -423,6 +403,11 @@ int vc_mgr_deinitialize(void) return VC_ERROR_NONE; } +static void __notify_error(void *data) +{ + vc_mgr_core_notify_error(); +} + static Eina_Bool __request_initialize(void *data) { /* request initialization */ @@ -451,7 +436,7 @@ static Eina_Bool __request_initialize(void *data) SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret)); vc_mgr_client_set_error(VC_ERROR_ENGINE_NOT_FOUND); - ecore_main_loop_thread_safe_call_async(__vc_mgr_notify_error, NULL); + ecore_main_loop_thread_safe_call_async(__notify_error, NULL); SLOG(LOG_DEBUG, TAG_VCM, "@@@"); g_request_init_timer = NULL; @@ -531,7 +516,7 @@ static Eina_Bool __send_hello_message(void *data) if (g_tidl_send_hello_count == VCM_TIDL_RETRY_COUNT) { g_tidl_send_hello_count = 0; SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request hello !! send error to manager"); - __vc_mgr_cb_error(VC_ERROR_TIMED_OUT, -1, "voice_framework.error.vcfw.connect_engine_fail"); + vc_mgr_core_send_error(VC_ERROR_TIMED_OUT, -1, "voice_framework.error.vcfw.connect_engine_fail"); g_send_hello_timer = NULL; return EINA_FALSE; } else { @@ -761,17 +746,7 @@ int vc_mgr_set_demandable_client_rule(const char* rule) /* 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_info_parser_set_demandable_client(rule); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] rule is NOT valid"); - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - return VC_ERROR_INVALID_PARAMETER; - } - - if (0 != vc_info_parser_get_demandable_clients(&g_demandable_client_list)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get demandable clients"); - return VC_ERROR_OPERATION_FAILED; - } + ret = vc_mgr_core_set_demandable_client_rule(rule); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s) DONE", rule); @@ -1704,9 +1679,7 @@ int vc_mgr_start(bool exclusive_command_option) SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] start recognition"); } - g_volume_db = 0; - g_prev_volume_db = 0; - g_cur_volume_db = 0; + vc_mgr_core_initialize_volume_variable(); SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request start DONE, ret(%d)", ret); @@ -1819,43 +1792,12 @@ int vc_mgr_cancel(void) return ret; } -static int g_cnt = 0; -static Eina_Bool __vc_mgr_set_volume_timer_cb(void* data) -{ - g_cnt++; - g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5 * g_cnt; - - SLOG(LOG_INFO, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db); - - if (0 == g_cnt % 5) { - return EINA_FALSE; - } - return EINA_TRUE; -} - -int __vc_mgr_cb_set_volume(float volume) -{ - // called in vc_mgr_tidl - g_prev_volume_db = g_volume_db; - g_cur_volume_db = volume; - - g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5; - - if (NULL != g_m_set_volume_timer) { - ecore_timer_del(g_m_set_volume_timer); - } - - g_cnt = 1; - g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_set_volume_timer_cb, NULL); - - return VC_ERROR_NONE; -} - +// TODO: check called by app direactly meaning int __vc_mgr_set_volume(float volume) { // called by app directly - g_volume_db = volume; - + vc_mgr_core_set_volume(volume); + return VC_ERROR_NONE; } @@ -1877,42 +1819,7 @@ int vc_mgr_get_recording_volume(float* volume) /* check state */ RETVM_IF(VC_SERVICE_STATE_RECORDING != service_state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Service state is not 'RECORDING'"); - *volume = g_volume_db; - - return VC_ERROR_NONE; -} - -int __vc_mgr_cb_set_foreground(int pid, bool value) -{ - vc_mgr_client_set_foreground(pid, value); - - /* get authorized valid app */ - int 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; - } - - if (true == value) { - /* compare & set valid */ - if (tmp_pid != pid) { - SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid); - - /* set authorized valid */ - 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(pid); - } else { - SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority"); - 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(-1); - } - } + *volume = vc_mgr_core_get_volume(); return VC_ERROR_NONE; } @@ -1940,246 +1847,9 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) } } - if (false == g_all_result_callback_status) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in all result callback"); - return VC_ERROR_OPERATION_FAILED; - } - - if (NULL != vc_cmd_list) { - int event = 0; - char* result_text = NULL; - - vc_mgr_client_get_all_result(&event, &result_text); - - vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false); - - if (NULL != result_text) { - free(result_text); - result_text = NULL; - } - } - - /* Request */ - 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; - } else { - SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] result selection"); - } - - vc_mgr_client_unset_all_result(); - - SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Select result DONE"); - - return VC_ERROR_NONE; -} - -static Eina_Bool __vc_mgr_set_select_result(void *data) -{ - vc_mgr_set_selected_results(NULL); - return EINA_FALSE; -} - -static void __vc_mgr_notify_all_result(vc_result_type_e result_type) -{ - char* temp_text = NULL; - int event; - char* temp_message = NULL; - vc_cmd_list_h vc_cmd_list = NULL; - - vc_mgr_all_result_cb all_callback = NULL; - void* all_user_data = NULL; - - 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)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list"); - return; - } - - 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); - - vc_cmd_print_list(vc_cmd_list); - - bool cb_ret = false; - - vc_mgr_client_set_all_result(event, temp_text); - - vc_mgr_client_use_callback(); - g_all_result_callback_status = true; - cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data); - g_all_result_callback_status = false; - vc_mgr_client_not_use_callback(); - - if (true == vc_mgr_client_get_exclusive_command()) { - /* exclusive */ - vc_result_cb callback = NULL; - void* user_data = NULL; - - 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(); - callback(event, vc_cmd_list, temp_text, user_data); - vc_mgr_client_not_use_callback(); - SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called"); - - /* Release result */ - if (NULL != temp_text) { - free(temp_text); - temp_text = NULL; - } - if (NULL != temp_message) { - free(temp_message); - temp_message = NULL; - } - - /* Release list */ - if (vc_cmd_list) - vc_cmd_list_destroy(vc_cmd_list, true); - vc_cmd_list = NULL; - - vc_mgr_client_set_exclusive_command(false); - - return; - } - - int count = 0; - vc_cmd_list_get_count(vc_cmd_list, &count); - if (0 < count) { - if (true == cb_ret) { - SLOG(LOG_INFO, TAG_VCM, "Callback result is true"); - if (VC_RESULT_TYPE_NOTIFICATION != result_type) - ecore_idler_add(__vc_mgr_set_select_result, NULL); - } else { - SLOG(LOG_INFO, TAG_VCM, "Callback result is false"); - /* need to select conflicted result */ - } - } else { - if (VC_RESULT_TYPE_NOTIFICATION != result_type) - ecore_idler_add(__vc_mgr_set_select_result, NULL); + ret = vc_mgr_core_set_selected_results(vc_cmd_list, g_pid); - vc_mgr_client_set_exclusive_command(false); - vc_mgr_client_unset_all_result(); - } - - /* Release result */ - if (NULL != temp_text) { - free(temp_text); - temp_text = NULL; - } - if (NULL != temp_message) { - free(temp_message); - temp_message = NULL; - } - - /* Release list */ - if (vc_cmd_list) - vc_cmd_list_destroy(vc_cmd_list, true); - vc_cmd_list = NULL; - - return; -} - -static Eina_Bool __vc_mgr_notify_result(void *data) -{ - char* temp_text = NULL; - int event; - vc_cmd_list_h vc_cmd_list = NULL; - - vc_result_cb callback = NULL; - void* user_data = NULL; - - 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)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list"); - return EINA_FALSE; - } - - vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false); - - SECURE_SLOG(LOG_INFO, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event); - - vc_cmd_print_list(vc_cmd_list); - - vc_mgr_client_use_callback(); - callback(event, vc_cmd_list, temp_text, user_data); - vc_mgr_client_not_use_callback(); - SLOG(LOG_INFO, TAG_VCM, "Result callback called"); - - if (vc_cmd_list) - vc_cmd_list_destroy(vc_cmd_list, true); - vc_cmd_list = NULL; - - /* Release result */ - if (temp_text) - free(temp_text); - temp_text = NULL; - - return EINA_FALSE; -} - -void __vc_mgr_cb_all_result(vc_result_type_e type) -{ - if (false == vc_mgr_client_get_exclusive_command()) { - __vc_mgr_notify_all_result(type); - } else { - __vc_mgr_notify_result(0); - } - - return; -} - -void __vc_mgr_cb_pre_result(vc_pre_result_event_e event, const char* pre_result) -{ - vc_mgr_pre_result_cb callback = NULL; - void* user_data = NULL; - - vc_mgr_client_get_pre_result_cb(&callback, &user_data); - RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client pre result callback is NULL"); - - vc_mgr_client_use_callback(); - callback(event, pre_result, user_data); - vc_mgr_client_not_use_callback(); - SLOG(LOG_INFO, TAG_VCM, "Pre result callback is called"); - - return; -} - -void __vc_mgr_cb_system_result() -{ - __vc_mgr_notify_result(NULL); - return; -} - -static Eina_Bool __vc_mgr_speech_detected(void *data) -{ - vc_mgr_begin_speech_detected_cb callback = NULL; - void* user_data = NULL; - - vc_mgr_client_get_speech_detected_cb(&callback, &user_data); - RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCM, "[ERROR] Client speech detected callback is NULL"); - - vc_mgr_client_use_callback(); - callback(user_data); - vc_mgr_client_not_use_callback(); - SLOG(LOG_INFO, TAG_VCM, "Speech detected callback called"); - - return EINA_FALSE; -} - -void __vc_mgr_cb_speech_detected() -{ - __vc_mgr_speech_detected(NULL); - - return; + return ret; } int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data) @@ -2334,85 +2004,13 @@ int vc_mgr_get_error_message(char** err_msg) RETVM_IF(NULL == err_msg, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter"); - if (false == g_err_callback_status) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in error callback"); - return VC_ERROR_OPERATION_FAILED; - } - - ret = vc_mgr_client_get_error_message(err_msg); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message"); - } + ret = vc_mgr_core_get_error_message(err_msg); SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get error message DONE"); return ret; } -static void __vc_mgr_notify_error(void *data) -{ - vc_error_cb callback = NULL; - void* user_data = NULL; - int reason; - - vc_mgr_client_get_error_cb(&callback, &user_data); - vc_mgr_client_get_error(&reason); - - if (NULL != callback) { - 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(); - 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(&state)) { - SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client"); - return VC_ERROR_INVALID_PARAMETER; - } - - /* check state */ - if (state != VC_STATE_INITIALIZED && state != VC_STATE_READY) { - SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet"); - return VC_ERROR_INVALID_STATE; - } - - 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(&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(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(reason); - vc_mgr_client_set_error_message(msg); - __vc_mgr_notify_error(NULL); - - return VC_ERROR_NONE; -} - static Eina_Bool __vc_mgr_notify_state_changed(void *data) { vc_state_changed_cb changed_callback = NULL; @@ -2483,53 +2081,6 @@ int vc_mgr_unset_state_changed_cb(void) return VC_ERROR_NONE; } -int __vc_mgr_cb_service_state(int state) -{ - vc_service_state_e current_state = (vc_service_state_e)state; - vc_service_state_e previous_state; - vc_mgr_client_get_service_state(&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(&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(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(VC_INTERNAL_STATE_NONE); - } - - if (current_state == previous_state) { - SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : previous(%d) current(%d)", - previous_state, current_state); - return VC_ERROR_NONE; - } - - /* Save service 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(&callback, &service_user_data); - - if (NULL != callback) { - vc_mgr_client_use_callback(); - callback(previous_state, current_state, service_user_data); - 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_NONE; -} - int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data) { int ret; @@ -2709,141 +2260,6 @@ int vc_mgr_unset_error_cb(void) return VC_ERROR_NONE; } -int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous) -{ - vc_mgr_dialog_request_cb callback = NULL; - void* user_data = NULL; - - vc_mgr_client_get_dialog_request_cb(&callback, &user_data); - - if (NULL != callback) { - vc_mgr_client_use_callback(); - callback(pid, disp_text, utt_text, continuous, user_data); - 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"); - } - - return VC_ERROR_NONE; -} - -int __vc_mgr_cb_private_data_set(const char* key, const char* data) -{ - vc_mgr_private_data_set_cb callback = NULL; - void* user_data = NULL; - int ret = -1; - - vc_mgr_client_get_private_data_set_cb(&callback, &user_data); - - if (NULL != callback) { - vc_mgr_client_use_callback(); - ret = callback(key, data, user_data); - 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"); - } - - return ret; -} - -int __vc_mgr_cb_private_data_requested(const char* key, char** data) -{ - vc_mgr_private_data_requested_cb callback = NULL; - void* user_data = NULL; - int ret = -1; - - vc_mgr_client_get_private_data_requested_cb(&callback, &user_data); - - if (NULL != callback) { - vc_mgr_client_use_callback(); - ret = callback(key, data, user_data); - 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"); - } - - return ret; -} - -/* for TTS feedback */ -int __vc_mgr_cb_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type) -{ - vc_mgr_feedback_audio_format_cb callback = NULL; - void* user_data = NULL; - - /* set global audio formats */ - g_feedback_rate = rate; - g_feedback_audio_channel = channel; - g_feedback_audio_type = audio_type; - - vc_mgr_client_get_feedback_audio_format_cb(&callback, &user_data); - - if (NULL != callback) { - vc_mgr_client_use_callback(); - callback(rate, channel, audio_type, user_data); - 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"); - } - - return VC_ERROR_NONE; -} - -int __vc_mgr_cb_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) -{ - /* add feedback data */ - vc_feedback_data_s* temp_feedback_data = NULL; - temp_feedback_data = (vc_feedback_data_s*)calloc(1, sizeof(vc_feedback_data_s)); - RETVM_IF(NULL == temp_feedback_data, VC_ERROR_OUT_OF_MEMORY, TAG_VCM, "[ERROR] Out of memory"); - SLOG(LOG_INFO, TAG_VCM, "[INFO] feedback streaming before queing"); - - temp_feedback_data->data = NULL; - temp_feedback_data->rate = g_feedback_rate; - temp_feedback_data->data_size = 0; - - if (0 < len) { - temp_feedback_data->data = (char*)calloc(len + 5, sizeof(char)); - if (NULL != temp_feedback_data->data) { - memcpy(temp_feedback_data->data, buffer, len); - temp_feedback_data->data_size = len; - SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG][memcpy] data(%p) size(%d)", - temp_feedback_data->data, temp_feedback_data->data_size); - } else { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to allocate memory"); - } - } else { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] feedback data is NULL"); - } - - temp_feedback_data->pid = pid; - temp_feedback_data->utt_id = utt_id; - temp_feedback_data->event = event; - temp_feedback_data->audio_type = g_feedback_audio_type; - temp_feedback_data->channel = g_feedback_audio_channel; - - SLOG(LOG_INFO, TAG_VCM, "[INFO] add feedback data, pid(%d), utt_id(%d), event(%d), audio_type(%d), channel(%d)", pid, utt_id, event, g_feedback_audio_type, g_feedback_audio_channel); - - int ret = vc_mgr_data_add_feedback_data(temp_feedback_data); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add feedback data"); - if (NULL != temp_feedback_data->data) { - free(temp_feedback_data->data); - temp_feedback_data->data = NULL; - } - if (NULL != temp_feedback_data) { - free(temp_feedback_data); - temp_feedback_data = NULL; - } - } - - return ret; -} - - int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data) { int ret; @@ -2976,189 +2392,6 @@ int vc_mgr_unset_private_data_requested_cb(void) return VC_ERROR_NONE; } -static bool __vc_mgr_check_demandable_client(int pid) -{ - if (0 == g_slist_length(g_demandable_client_list)) { - SLOG(LOG_WARN, TAG_VCM, "[WARNING] No demandable clients"); - return false; - } - - char appid[1024] = {'\0', }; - if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get callee appid by pid"); - return false; - } - SLOG(LOG_INFO, TAG_VCM, "[CHECK] Appid - %s", appid); - - GSList *iter = NULL; - vc_demandable_client_s* temp_client; - iter = g_slist_nth(g_demandable_client_list, 0); - - while (NULL != iter) { - temp_client = iter->data; - - if (NULL != temp_client) { - if (NULL != temp_client->appid) { - if (!strcmp(temp_client->appid, appid)) { - SLOG(LOG_DEBUG, TAG_VCM, "pid(%d) is available", pid); - return true; - } - } - } - - iter = g_slist_next(iter); - } - - return false; -} - -/* Authority */ -int __vc_mgr_request_auth_enable(int pid) -{ - if (false == __vc_mgr_check_demandable_client(pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not demandable client"); - return VC_ERROR_INVALID_PARAMETER; - } - - /* check already authorized */ - 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(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(&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(pid); - } - - return VC_ERROR_NONE; -} - -int __vc_mgr_request_auth_disable(int pid) -{ - /* check authorized */ - 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(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(pid)) { - SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed"); - 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; - } - } - - return VC_ERROR_NONE; -} - -static Eina_Bool __request_auth_start(void* data) -{ - SLOG(LOG_INFO, TAG_VCM, "Request Start"); - - if (0 != vc_mgr_client_set_start_by_client(true)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); - } - - if (0 != vc_mgr_start(false)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed"); - /* TODO - Error handling? */ - } - - if (0 != vc_mgr_client_set_start_by_client(false)) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); - } - - - return EINA_FALSE; -} - -int __vc_mgr_request_auth_start(int pid) -{ - /* check authorized */ - 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; - } - - /* add timer for start recording */ - ecore_timer_add(0, __request_auth_start, NULL); - - return VC_ERROR_NONE; -} - -static Eina_Bool __request_auth_stop(void* data) -{ - SLOG(LOG_INFO, TAG_VCM, "Request Stop"); - - if (0 != vc_mgr_stop()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed"); - /* TODO - Error handling? */ - } - - return EINA_FALSE; -} - -int __vc_mgr_request_auth_stop(int pid) -{ - /* check authorized */ - 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; - } - - /* add timer for start recording */ - ecore_timer_add(0, __request_auth_stop, NULL); - - return VC_ERROR_NONE; -} - -static Eina_Bool __request_auth_cancel(void* data) -{ - SLOG(LOG_INFO, TAG_VCM, "Request Cancel"); - - if (0 != vc_mgr_cancel()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed"); - /* TODO - Error handling? */ - } - - return EINA_FALSE; -} - -int __vc_mgr_request_auth_cancel(int pid) -{ - /* check authorized */ - 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; - } - - /* add timer for start recording */ - ecore_timer_add(0, __request_auth_cancel, NULL); - - return VC_ERROR_NONE; -} - int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data) { int ret; @@ -3201,22 +2434,6 @@ int vc_mgr_unset_specific_engine_result_cb(void) return VC_ERROR_NONE; } -void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result) -{ - vc_mgr_specific_engine_result_cb callback = NULL; - void* user_data = NULL; - - 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(); - callback(engine_app_id, event, result, user_data); - 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; -} - /* for TTS feedback */ int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data) { @@ -3428,13 +2645,7 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) /* waiting */ while (1) { - if (ecore_thread_check(thread) == EINA_TRUE) { - SLOG(LOG_INFO, TAG_VCM, "[INFO] Stop feedback is called"); - return; - } - usleep(10000); - if (0 < vc_mgr_data_get_feedback_data_size()) { SLOG(LOG_INFO, TAG_VCM, "[INFO] Resume thread"); break; @@ -3474,6 +2685,16 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) vc_mgr_client_not_use_callback(); pthread_mutex_unlock(&g_feedback_streaming_cb_mutex); + + /* If no feedback data and EVENT_FINISH */ + if (0 >= vc_mgr_data_get_feedback_data_size() && VC_FEEDBACK_EVENT_FINISH == feedback_data->event) { + SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish feedback"); + if (feedback_data) { + free(feedback_data); + feedback_data = NULL; + } + break; + } } else { vc_mgr_vc_tts_streaming_cb callback = NULL; void* user_data = NULL; @@ -3494,6 +2715,16 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread) vc_mgr_client_not_use_callback(); pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex); + + /* If no feedback data and EVENT_FINISH */ + if (0 >= vc_mgr_data_get_feedback_data_size() && VC_FEEDBACK_EVENT_FINISH == feedback_data->event) { + SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish vc tts feedback"); + if (feedback_data) { + free(feedback_data); + feedback_data = NULL; + } + break; + } } free(feedback_data); feedback_data = NULL; @@ -3571,12 +2802,8 @@ int vc_mgr_stop_feedback(void) RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Stop feedback : Current state is not 'Ready' (%d)", state); #if 1 - if (g_feedback_thread) { - ecore_thread_cancel(g_feedback_thread); - g_feedback_thread = NULL; - } - ret = -1; + while (1) { vc_feedback_data_s* feedback_data = NULL; @@ -3712,6 +2939,7 @@ int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* } float volume = __get_volume_decibel((char*)buffer, len); + // TODO: check __vc_mgr_set_volume need to move __vc_mgr_set_volume(volume); ret = vc_mgr_tidl_send_audio_streaming(g_pid, event, buffer, len); @@ -3898,4 +3126,4 @@ int vc_mgr_reset_background_volume(void) SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to recover volume"); return ret; -} +} \ No newline at end of file diff --git a/client/vc_mgr_core.c b/client/vc_mgr_core.c new file mode 100644 index 0000000..fc04ea6 --- /dev/null +++ b/client/vc_mgr_core.c @@ -0,0 +1,878 @@ +/* +* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the License); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an AS IS BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include +#include +#include +#include +#include +#include + +#include "vc_cmd_db.h" +#include "vc_command.h" +#include "vc_config_mgr.h" +#include "vc_info_parser.h" +#include "vc_json_parser.h" +#include "vc_main.h" +#include "vc_mgr_core.h" +#include "vc_mgr_client.h" +#include "vc_mgr_tidl.h" +#include "vc_mgr_data.h" +#include "vc_mgr_player.h" +#include "voice_control_command.h" +#include "voice_control_command_expand.h" +#include "voice_control_common.h" +#include "voice_control_manager.h" +#include "voice_control_manager_internal.h" + + +static Ecore_Timer* g_m_set_volume_timer = NULL; + +static GSList* g_demandable_client_list = NULL; + +static float g_volume_db = 0; + +static float g_prev_volume_db = 0; + +static float g_cur_volume_db = 0; + +static int g_volume_timer_cnt = 0; + +static bool g_err_callback_status = false; + +static bool g_all_result_callback_status = false; + +/* for TTS feedback */ +static int g_feedback_rate = 16000; +static vc_audio_channel_e g_feedback_audio_channel = 0; +static vc_audio_type_e g_feedback_audio_type = 0; + +static Eina_Bool __vc_mgr_core_set_volume_timer_cb(void* data) +{ + g_volume_timer_cnt++; + g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5 * g_volume_timer_cnt; + + SLOG(LOG_INFO, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db); + + if (0 == g_volume_timer_cnt % 5) { + return EINA_FALSE; + } + return EINA_TRUE; +} + +static Eina_Bool __vc_mgr_core_set_select_result(void *data) +{ + // TODO: remove vc_mgr dependency by separate vc_mgr_set_selected_results core logic to core layer + vc_mgr_set_selected_results(NULL); + return EINA_FALSE; +} + +static void __vc_mgr_core_notify_all_result(vc_result_type_e result_type) +{ + char* temp_text = NULL; + int event; + char* temp_message = NULL; + vc_cmd_list_h vc_cmd_list = NULL; + + vc_mgr_all_result_cb all_callback = NULL; + void* all_user_data = NULL; + + 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 (VC_ERROR_NONE != vc_cmd_list_create(&vc_cmd_list)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list"); + return; + } + + 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); + + vc_cmd_print_list(vc_cmd_list); + + bool cb_ret = false; + + vc_mgr_client_set_all_result(event, temp_text); + + vc_mgr_client_use_callback(); + g_all_result_callback_status = true; + cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data); + g_all_result_callback_status = false; + vc_mgr_client_not_use_callback(); + + if (true == vc_mgr_client_get_exclusive_command()) { + /* exclusive */ + vc_result_cb callback = NULL; + void* user_data = NULL; + + 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(); + callback(event, vc_cmd_list, temp_text, user_data); + vc_mgr_client_not_use_callback(); + SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called"); + + /* Release result */ + if (NULL != temp_text) { + free(temp_text); + temp_text = NULL; + } + if (NULL != temp_message) { + free(temp_message); + temp_message = NULL; + } + + /* Release list */ + if (vc_cmd_list) + vc_cmd_list_destroy(vc_cmd_list, true); + vc_cmd_list = NULL; + + vc_mgr_client_set_exclusive_command(false); + + return; + } + + int count = 0; + vc_cmd_list_get_count(vc_cmd_list, &count); + if (0 < count) { + if (true == cb_ret) { + SLOG(LOG_INFO, TAG_VCM, "Callback result is true"); + if (VC_RESULT_TYPE_NOTIFICATION != result_type) + ecore_idler_add(__vc_mgr_core_set_select_result, NULL); + } else { + SLOG(LOG_INFO, TAG_VCM, "Callback result is false"); + /* need to select conflicted result */ + } + } else { + if (VC_RESULT_TYPE_NOTIFICATION != result_type) + ecore_idler_add(__vc_mgr_core_set_select_result, NULL); + + vc_mgr_client_set_exclusive_command(false); + vc_mgr_client_unset_all_result(); + } + + /* Release result */ + if (NULL != temp_text) { + free(temp_text); + temp_text = NULL; + } + if (NULL != temp_message) { + free(temp_message); + temp_message = NULL; + } + + /* Release list */ + if (vc_cmd_list) + vc_cmd_list_destroy(vc_cmd_list, true); + vc_cmd_list = NULL; + + return; +} + +static void __vc_mgr_core_notify_result() +{ + char* temp_text = NULL; + int event; + vc_cmd_list_h vc_cmd_list = NULL; + + vc_result_cb callback = NULL; + void* user_data = NULL; + + vc_mgr_client_get_result_cb(&callback, &user_data); + RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client result callback is NULL"); + + if (VC_ERROR_NONE != vc_cmd_list_create(&vc_cmd_list)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list"); + return; + } + + vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false); + + SECURE_SLOG(LOG_INFO, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event); + + vc_cmd_print_list(vc_cmd_list); + + vc_mgr_client_use_callback(); + callback(event, vc_cmd_list, temp_text, user_data); + vc_mgr_client_not_use_callback(); + SLOG(LOG_INFO, TAG_VCM, "Result callback called"); + + if (vc_cmd_list) + vc_cmd_list_destroy(vc_cmd_list, true); + vc_cmd_list = NULL; + + /* Release result */ + if (temp_text) + free(temp_text); + temp_text = NULL; +} + +void vc_mgr_core_send_all_result(vc_result_type_e type) +{ + if (false == vc_mgr_client_get_exclusive_command()) { + __vc_mgr_core_notify_all_result(type); + } else { + __vc_mgr_core_notify_result(); + } + + return; +} + +void vc_mgr_core_send_pre_result(vc_pre_result_event_e event, const char* pre_result) +{ + vc_mgr_pre_result_cb callback = NULL; + void* user_data = NULL; + + vc_mgr_client_get_pre_result_cb(&callback, &user_data); + RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client pre result callback is NULL"); + + vc_mgr_client_use_callback(); + callback(event, pre_result, user_data); + vc_mgr_client_not_use_callback(); + SLOG(LOG_INFO, TAG_VCM, "Pre result callback is called"); + + return; +} + +void vc_mgr_core_send_system_result() +{ + __vc_mgr_core_notify_result(); + return; +} + +void vc_mgr_core_send_speech_detected() +{ + vc_mgr_begin_speech_detected_cb callback = NULL; + void* user_data = NULL; + + vc_mgr_client_get_speech_detected_cb(&callback, &user_data); + RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client speech detected callback is NULL"); + + vc_mgr_client_use_callback(); + callback(user_data); + vc_mgr_client_not_use_callback(); + SLOG(LOG_INFO, TAG_VCM, "Speech detected callback called"); + + + return; +} + +void vc_mgr_core_notify_error() +{ + vc_error_cb callback = NULL; + void* user_data = NULL; + int reason; + + vc_mgr_client_get_error_cb(&callback, &user_data); + vc_mgr_client_get_error(&reason); + + if (NULL != callback) { + 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(); + SLOG(LOG_INFO, TAG_VCM, "Error callback is called"); + } else { + SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null"); + } +} + +int vc_mgr_core_set_selected_results(vc_cmd_list_h vc_cmd_list, int pid) +{ + if (false == g_all_result_callback_status) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in all result callback"); + return VC_ERROR_OPERATION_FAILED; + } + + if (NULL != vc_cmd_list) { + int event = 0; + char* result_text = NULL; + + vc_mgr_client_get_all_result(&event, &result_text); + + vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false); + + if (NULL != result_text) { + free(result_text); + result_text = NULL; + } + } + + /* Request */ + int ret = vc_mgr_tidl_send_result_selection(pid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %d", ret); + return ret; + } else { + SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] result selection"); + } + + vc_mgr_client_unset_all_result(); + + SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Select result DONE"); + + return VC_ERROR_NONE; +} + +static void vc_mgr_core_notify_state_changed() +{ + vc_state_changed_cb changed_callback = NULL; + void* 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(¤t_state, &previous_state); + + if (NULL != changed_callback) { + vc_mgr_client_use_callback(); + changed_callback(previous_state, current_state, user_data); + 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"); + } +} + +int vc_mgr_core_send_error(int reason, int daemon_pid, char* msg) +{ + vc_state_e state; + if (VC_ERROR_NONE != vc_mgr_client_get_client_state(&state)) { + SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client"); + return VC_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (state != VC_STATE_INITIALIZED && state != VC_STATE_READY) { + SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet"); + return VC_ERROR_INVALID_STATE; + } + + 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(&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(VC_STATE_INITIALIZED); + vc_mgr_core_notify_state_changed(); + + if (VC_ERROR_NONE != 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(reason); + vc_mgr_client_set_error_message(msg); + vc_mgr_core_notify_error(); + + return VC_ERROR_NONE; +} + +int vc_mgr_core_get_error_message(char** err_msg) +{ + if (false == g_err_callback_status) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in error callback"); + return VC_ERROR_OPERATION_FAILED; + } + + int ret = vc_mgr_client_get_error_message(err_msg); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message"); + } + + return ret; +} + + + +int vc_mgr_core_send_service_state(int state) +{ + vc_service_state_e current_state = (vc_service_state_e)state; + vc_service_state_e previous_state; + vc_mgr_client_get_service_state(&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(&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(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(VC_INTERNAL_STATE_NONE); + } + + if (current_state == previous_state) { + SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : previous(%d) current(%d)", + previous_state, current_state); + return VC_ERROR_NONE; + } + + /* Save service 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(&callback, &service_user_data); + + if (NULL != callback) { + vc_mgr_client_use_callback(); + callback(previous_state, current_state, service_user_data); + 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_NONE; +} + +int vc_mgr_core_send_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous) +{ + vc_mgr_dialog_request_cb callback = NULL; + void* user_data = NULL; + + vc_mgr_client_get_dialog_request_cb(&callback, &user_data); + + if (NULL != callback) { + vc_mgr_client_use_callback(); + callback(pid, disp_text, utt_text, continuous, user_data); + 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"); + } + + return VC_ERROR_NONE; +} + +int vc_mgr_core_send_private_data_set(const char* key, const char* data) +{ + vc_mgr_private_data_set_cb callback = NULL; + void* user_data = NULL; + int ret = -1; + + vc_mgr_client_get_private_data_set_cb(&callback, &user_data); + + if (NULL != callback) { + vc_mgr_client_use_callback(); + ret = callback(key, data, user_data); + 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"); + } + + return ret; +} + +int vc_mgr_core_send_private_data_requested(const char* key, char** data) +{ + vc_mgr_private_data_requested_cb callback = NULL; + void* user_data = NULL; + int ret = -1; + + vc_mgr_client_get_private_data_requested_cb(&callback, &user_data); + + if (NULL != callback) { + vc_mgr_client_use_callback(); + ret = callback(key, data, user_data); + 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"); + } + + return ret; +} + +void vc_mgr_core_send_specific_engine_result(const char* engine_app_id, const char* event, const char* result) +{ + vc_mgr_specific_engine_result_cb callback = NULL; + void* user_data = NULL; + + 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(); + callback(engine_app_id, event, result, user_data); + 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; +} + +int vc_mgr_core_send_set_volume(float volume) +{ + g_prev_volume_db = g_volume_db; + g_cur_volume_db = volume; + + g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5; + + if (NULL != g_m_set_volume_timer) { + ecore_timer_del(g_m_set_volume_timer); + } + + g_volume_timer_cnt = 1; + g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_core_set_volume_timer_cb, NULL); + + return VC_ERROR_NONE; +} + +void vc_mgr_core_set_volume(float volume) +{ + g_volume_db = volume; +} + +float vc_mgr_core_get_volume() +{ + return g_volume_db; +} + +void vc_mgr_core_initialize_volume_variable() +{ + g_volume_db = 0; + g_prev_volume_db = 0; + g_cur_volume_db = 0; +} + +int vc_mgr_core_send_set_foreground(int pid, bool value) +{ + vc_mgr_client_set_foreground(pid, value); + + /* get authorized valid app */ + int tmp_pid; + if (VC_ERROR_NONE != 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; + } + + if (true == value) { + /* compare & set valid */ + if (tmp_pid != pid) { + SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid); + + /* set authorized valid */ + 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(pid); + } else { + SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority"); + 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(-1); + } + } + + return VC_ERROR_NONE; +} + +/* for TTS feedback */ +int vc_mgr_core_send_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type) +{ + vc_mgr_feedback_audio_format_cb callback = NULL; + void* user_data = NULL; + + /* set global audio formats */ + g_feedback_rate = rate; + g_feedback_audio_channel = channel; + g_feedback_audio_type = audio_type; + + vc_mgr_client_get_feedback_audio_format_cb(&callback, &user_data); + + if (NULL != callback) { + vc_mgr_client_use_callback(); + callback(rate, channel, audio_type, user_data); + 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"); + } + + return VC_ERROR_NONE; +} + +int vc_mgr_core_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) +{ + /* add feedback data */ + vc_feedback_data_s* temp_feedback_data = NULL; + temp_feedback_data = (vc_feedback_data_s*)calloc(1, sizeof(vc_feedback_data_s)); + RETVM_IF(NULL == temp_feedback_data, VC_ERROR_OUT_OF_MEMORY, TAG_VCM, "[ERROR] Out of memory"); + SLOG(LOG_INFO, TAG_VCM, "[INFO] feedback streaming before queuing"); + + temp_feedback_data->data = NULL; + temp_feedback_data->rate = g_feedback_rate; + temp_feedback_data->data_size = 0; + + if (0 < len) { + temp_feedback_data->data = (char*)calloc(len + 5, sizeof(char)); + if (NULL != temp_feedback_data->data) { + memcpy(temp_feedback_data->data, buffer, len); + temp_feedback_data->data_size = len; + SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG][memcpy] data(%p) size(%d)", + temp_feedback_data->data, temp_feedback_data->data_size); + } else { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to allocate memory"); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] feedback data is NULL"); + } + + temp_feedback_data->pid = pid; + temp_feedback_data->utt_id = utt_id; + temp_feedback_data->event = event; + temp_feedback_data->audio_type = g_feedback_audio_type; + temp_feedback_data->channel = g_feedback_audio_channel; + + SLOG(LOG_INFO, TAG_VCM, "[INFO] add feedback data, pid(%d), utt_id(%d), event(%d), audio_type(%d), channel(%d)", pid, utt_id, event, g_feedback_audio_type, g_feedback_audio_channel); + + int ret = vc_mgr_data_add_feedback_data(temp_feedback_data); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add feedback data"); + if (NULL != temp_feedback_data->data) { + free(temp_feedback_data->data); + temp_feedback_data->data = NULL; + } + if (NULL != temp_feedback_data) { + free(temp_feedback_data); + temp_feedback_data = NULL; + } + } + + return ret; +} + +/* Authority */ +static bool __vc_mgr_core_check_demandable_client(int pid) +{ + if (0 == g_slist_length(g_demandable_client_list)) { + SLOG(LOG_WARN, TAG_VCM, "[WARNING] No demandable clients"); + return false; + } + + char appid[1024] = {'\0', }; + if (VC_ERROR_NONE != aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get callee appid by pid"); + return false; + } + SLOG(LOG_INFO, TAG_VCM, "[CHECK] Appid - %s", appid); + + GSList *iter = NULL; + vc_demandable_client_s* temp_client; + iter = g_slist_nth(g_demandable_client_list, 0); + + while (NULL != iter) { + temp_client = iter->data; + + if (NULL != temp_client) { + if (NULL != temp_client->appid) { + if (!strcmp(temp_client->appid, appid)) { + SLOG(LOG_DEBUG, TAG_VCM, "pid(%d) is available", pid); + return true; + } + } + } + + iter = g_slist_next(iter); + } + + return false; +} + +int vc_mgr_core_set_demandable_client_rule(const char* rule) +{ + if (0 != vc_info_parser_set_demandable_client(rule)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] rule is NOT valid"); + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + return VC_ERROR_INVALID_PARAMETER; + } + + if (0 != vc_info_parser_get_demandable_clients(&g_demandable_client_list)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get demandable clients"); + return VC_ERROR_OPERATION_FAILED; + } + + return VC_ERROR_NONE; +} + +int vc_mgr_core_request_auth_enable(int pid) +{ + if (false == __vc_mgr_core_check_demandable_client(pid)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not demandable client"); + return VC_ERROR_INVALID_PARAMETER; + } + + /* check already authorized */ + 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 (VC_ERROR_NONE != 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 (VC_ERROR_NONE != 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(pid); + } + + return VC_ERROR_NONE; +} + +int vc_mgr_core_request_auth_disable(int pid) +{ + /* check authorized */ + 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 (VC_ERROR_NONE != 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(pid)) { + SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed"); + if (VC_ERROR_NONE != 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; + } + } + + return VC_ERROR_NONE; +} + +static Eina_Bool __request_auth_start(void* data) +{ + SLOG(LOG_INFO, TAG_VCM, "Request Start"); + + if (VC_ERROR_NONE != vc_mgr_client_set_start_by_client(true)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); + } + + if (VC_ERROR_NONE != vc_mgr_start(false)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed"); + /* TODO - Error handling? */ + } + + if (VC_ERROR_NONE != vc_mgr_client_set_start_by_client(false)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client"); + } + + + return EINA_FALSE; +} + +int vc_mgr_core_request_auth_start(int pid) +{ + /* check authorized */ + 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; + } + + /* add timer for start recording */ + ecore_timer_add(0, __request_auth_start, NULL); + + return VC_ERROR_NONE; +} + +static Eina_Bool __request_auth_stop(void* data) +{ + SLOG(LOG_INFO, TAG_VCM, "Request Stop"); + + if (VC_ERROR_NONE != vc_mgr_stop()) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed"); + /* TODO - Error handling? */ + } + + return EINA_FALSE; +} + +int vc_mgr_core_request_auth_stop(int pid) +{ + /* check authorized */ + 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; + } + + /* add timer for start recording */ + ecore_timer_add(0, __request_auth_stop, NULL); + + return VC_ERROR_NONE; +} + +static Eina_Bool __request_auth_cancel(void* data) +{ + SLOG(LOG_INFO, TAG_VCM, "Request Cancel"); + + if (VC_ERROR_NONE != vc_mgr_cancel()) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed"); + /* TODO - Error handling? */ + } + + return EINA_FALSE; +} + +int vc_mgr_core_request_auth_cancel(int pid) +{ + /* check authorized */ + 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; + } + + /* add timer for start recording */ + ecore_timer_add(0, __request_auth_cancel, NULL); + + return VC_ERROR_NONE; +} \ No newline at end of file diff --git a/client/vc_mgr_core.h b/client/vc_mgr_core.h new file mode 100644 index 0000000..d828c8b --- /dev/null +++ b/client/vc_mgr_core.h @@ -0,0 +1,68 @@ +/* +* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the License); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an AS IS BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef __VC_MGR_CORE_H_ +#define __VC_MGR_CORE_H_ + +#include "voice_control_manager_internal.h" +#include "voice_control_command.h" +#include "voice_control_common.h" +#include "voice_control_manager.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +int vc_mgr_core_send_error(int reason, int daemon_pid, char* msg); + +// called by vc_mgr.c +int vc_mgr_core_set_demandable_client_rule(const char* rule); +void vc_mgr_core_initialize_volume_variable(); +void vc_mgr_core_set_volume(float volume); +float vc_mgr_core_get_volume(); +int vc_mgr_core_get_error_message(char** err_msg); +void vc_mgr_core_notify_error(); +int vc_mgr_core_set_selected_results(vc_cmd_list_h vc_cmd_list, int pid); + + +// called by vc_mgr_tidl.c +void vc_mgr_core_send_all_result(vc_result_type_e type); +void vc_mgr_core_send_pre_result(vc_pre_result_event_e event, const char* pre_result); +void vc_mgr_core_send_system_result(); +void vc_mgr_core_send_speech_detected(); +int vc_mgr_core_send_set_volume(float volume); +int vc_mgr_core_send_service_state(int state); +int vc_mgr_core_send_set_foreground(int pid, bool value); +int vc_mgr_core_send_private_data_set(const char* key, const char* data); +int vc_mgr_core_send_private_data_requested(const char* key, char** data); +int vc_mgr_core_send_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous); +void vc_mgr_core_send_specific_engine_result(const char* engine_app_id, const char* event, const char* result); +/* for TTS feedback */ +int vc_mgr_core_send_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type); +int vc_mgr_core_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); +/* Authority */ +int vc_mgr_core_request_auth_enable(int pid); +int vc_mgr_core_request_auth_disable(int pid); +int vc_mgr_core_request_auth_start(int pid); +int vc_mgr_core_request_auth_stop(int pid); +int vc_mgr_core_request_auth_cancel(int pid); + +#ifdef __cplusplus +} +#endif + +#endif /* __VC_MGR_CORE_H_ */ \ No newline at end of file diff --git a/client/vc_mgr_tidl.c b/client/vc_mgr_tidl.c index 02b6f81..4d1937c 100644 --- a/client/vc_mgr_tidl.c +++ b/client/vc_mgr_tidl.c @@ -23,7 +23,7 @@ #include "vc_mgr_tidl.h" #include "vc_mgr_proxy.h" #include "vc_mgr_stub.h" -#include "vc_command.h" +#include "vc_mgr_core.h" typedef struct { bool connected; @@ -49,47 +49,6 @@ static rpc_port_stub_vc_mgr_stub_vcd_mgr_callback_s g_mgr_callback; static int g_volume_count = 0; - -extern void __vc_mgr_cb_all_result(vc_result_type_e type); - -extern void __vc_mgr_cb_pre_result(int event, const char* pre_result); - -extern void __vc_mgr_cb_system_result(); - -extern void __vc_mgr_cb_speech_detected(); - -extern int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg); - -extern int __vc_mgr_cb_set_volume(float volume); - -extern int __vc_mgr_cb_service_state(int state); - -extern int __vc_mgr_cb_set_foreground(int pid, bool value); - -extern int __vc_mgr_cb_private_data_set(const char* key, const char* data); - -extern int __vc_mgr_cb_private_data_requested(const char* key, char** data); - -/* for TTS feedback */ -extern int __vc_mgr_cb_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type); - -extern int __vc_mgr_cb_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); - -/* Authority */ -extern int __vc_mgr_request_auth_enable(int pid); - -extern int __vc_mgr_request_auth_disable(int pid); - -extern int __vc_mgr_request_auth_start(int pid); - -extern int __vc_mgr_request_auth_stop(int pid); - -extern int __vc_mgr_request_auth_cancel(int pid); - -extern int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous); - -extern void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result); - static void __notify_cb(void *user_data, bundle *msg) { char *method = NULL; @@ -113,7 +72,7 @@ static void __notify_cb(void *user_data, bundle *msg) } if (val) { - __vc_mgr_cb_set_volume(volume); + vc_mgr_core_send_set_volume(volume); g_volume_count++; } } /* VCD_MANAGER_METHOD_SET_VOLUME */ @@ -124,14 +83,14 @@ static void __notify_cb(void *user_data, bundle *msg) if (val) { state = atoi(val); SLOG(LOG_INFO, TAG_VCM, "@@ state changed : %d", state); - __vc_mgr_cb_service_state(state); + vc_mgr_core_send_service_state(state); } } /* VCD_METHOD_SET_SERVICE_STATE */ else if (0 == strncmp(VCD_MANAGER_METHOD_SPEECH_DETECTED, method, strlen(VCD_MANAGER_METHOD_SPEECH_DETECTED))) { SLOG(LOG_INFO, TAG_VCM, "@@@ Get Speech detected"); - __vc_mgr_cb_speech_detected(); + vc_mgr_core_send_speech_detected(); } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */ else if (0 == strncmp(VCD_MANAGER_METHOD_ALL_RESULT, method, strlen(VCD_MANAGER_METHOD_ALL_RESULT))) { @@ -140,7 +99,7 @@ static void __notify_cb(void *user_data, bundle *msg) bundle_get_str(msg, VC_BUNDLE_RESULT, &val); if (val) { - __vc_mgr_cb_all_result((vc_result_type_e)atoi(val)); + vc_mgr_core_send_all_result((vc_result_type_e)atoi(val)); } } /* VCD_MANAGER_METHOD_ALL_RESULT */ @@ -153,7 +112,7 @@ static void __notify_cb(void *user_data, bundle *msg) bundle_get_str(msg, VC_BUNDLE_PRE_RESULT, &pre_result); if (NULL != pre_result) { - __vc_mgr_cb_pre_result((vc_pre_result_event_e)atoi(event), pre_result); + vc_mgr_core_send_pre_result((vc_pre_result_event_e)atoi(event), pre_result); } } /* VCD_MANAGER_METHOD_PRE_RESULT */ @@ -173,7 +132,7 @@ static void __notify_cb(void *user_data, bundle *msg) if (gDecodedResult) { SLOG(LOG_WARN, TAG_VCM, "@@@ Get specific engine result --> %s", gDecodedResult); - __vc_mgr_cb_specific_engine_result(engine_app_id, event, gDecodedResult); + vc_mgr_core_send_specific_engine_result(engine_app_id, event, gDecodedResult); g_free(gDecodedResult); } } @@ -182,7 +141,7 @@ static void __notify_cb(void *user_data, bundle *msg) else if (0 == strncmp(VCD_MANAGER_METHOD_RESULT, method, strlen(VCD_MANAGER_METHOD_RESULT))) { SLOG(LOG_INFO, TAG_VCM, "@@@ Get System Result"); - __vc_mgr_cb_system_result(); + vc_mgr_core_send_system_result(); } /* VCD_MANAGER_METHOD_RESULT */ else if (0 == strncmp(VCD_MANAGER_METHOD_DIALOG, method, strlen(VCD_MANAGER_METHOD_DIALOG))) { @@ -190,19 +149,19 @@ static void __notify_cb(void *user_data, bundle *msg) char* pid = NULL; char* disp_text = NULL; char* utt_text = NULL; - char* continous = NULL; + char* continuous = NULL; bundle_get_str(msg, VC_BUNDLE_PID, &pid); bundle_get_str(msg, VC_BUNDLE_DISP_TEXT, &disp_text); bundle_get_str(msg, VC_BUNDLE_UTT_TEXT, &utt_text); - bundle_get_str(msg, VC_BUNDLE_CONTINUOUS, &continous); + bundle_get_str(msg, VC_BUNDLE_CONTINUOUS, &continuous); if (!strncmp(disp_text, "#NULL", strlen("#NULL") + 1)) disp_text = NULL; if (!strncmp(utt_text, "#NULL", strlen("#NULL") + 1)) utt_text = NULL; - __vc_mgr_cb_dialog(atoi(pid), disp_text, utt_text, (bool)atoi(continous)); + vc_mgr_core_send_dialog(atoi(pid), disp_text, utt_text, (bool)atoi(continuous)); } /* VCD_MANAGER_METHOD_DIALOG */ else if (0 == strncmp(VCD_MANAGER_METHOD_ERROR, method, strlen(VCD_MANAGER_METHOD_ERROR))) { @@ -220,7 +179,7 @@ static void __notify_cb(void *user_data, bundle *msg) temp_msg = strdup(err_msg); } SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr Get Error message : reason(%d), daemon_pid(%d), msg(%s)", atoi(reason), atoi(daemon_pid), (temp_msg) ? temp_msg : "NULL"); - __vc_mgr_cb_error(atoi(reason), atoi(daemon_pid), temp_msg); + vc_mgr_core_send_error(atoi(reason), atoi(daemon_pid), temp_msg); if (NULL != temp_msg) { free(temp_msg); temp_msg = NULL; @@ -239,7 +198,7 @@ static void __notify_cb(void *user_data, bundle *msg) SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", atoi(pid)); if (pid > 0) { - __vc_mgr_cb_private_data_set(key, private_data); + vc_mgr_core_send_private_data_set(key, private_data); } else { SLOG(LOG_ERROR, TAG_VCM, "@@ got invalid pid(%d)", atoi(pid)); } @@ -255,7 +214,7 @@ static void __notify_cb(void *user_data, bundle *msg) bundle_get_str(msg, VC_BUNDLE_AUDIO_TYPE, &audio_type); bundle_get_str(msg, VC_BUNDLE_AUDIO_RATE, &rate); - __vc_mgr_cb_feedback_audio_format(atoi(rate), (vc_audio_channel_e)atoi(channel), (vc_audio_type_e)atoi(audio_type)); + vc_mgr_core_send_feedback_audio_format(atoi(rate), (vc_audio_channel_e)atoi(channel), (vc_audio_type_e)atoi(audio_type)); } /* VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT */ // TODO: uncomment this line after vcc done @@ -274,7 +233,7 @@ static void __notify_cb(void *user_data, bundle *msg) // SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false"); - // __vc_mgr_cb_set_foreground(pid, (bool)value); + // vc_mgr_core_send_set_foreground(pid, (bool)value); // } /* VCC_MANAGER_METHOD_SET_FOREGROUND */ else { @@ -304,7 +263,7 @@ static void __send_buffer_cb(void *user_data, rpc_port_proxy_vc_mgr_proxy_array_ bundle_get_str(msg, VC_BUNDLE_EVENT, &event); rpc_port_proxy_vc_mgr_proxy_array_char_get(data_in, &buffer, &len); - __vc_mgr_cb_feedback_streaming(atoi(val), atoi(utt_id), atoi(event), buffer, len); + vc_mgr_core_send_feedback_streaming(atoi(val), atoi(utt_id), atoi(event), buffer, len); free(buffer); SLOG(LOG_INFO, TAG_VCM, "@@@ __send_buffer_cb DONE"); @@ -333,7 +292,7 @@ static void __on_disconnected(rpc_port_proxy_vc_mgr_proxy_vc_mgr_h h, void *user SLOG(LOG_INFO, TAG_VCM, "Disonnected to server"); - __vc_mgr_cb_error(VC_ERROR_SERVICE_RESET, -1, "Server Disconnected"); + vc_mgr_core_send_error(VC_ERROR_SERVICE_RESET, -1, "Server Disconnected"); } static void __on_rejected(rpc_port_proxy_vc_mgr_proxy_vc_mgr_h h, void *user_data) @@ -405,7 +364,7 @@ static void __vcd_mgr_set_foreground_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_contex SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground"); SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false"); - __vc_mgr_cb_set_foreground(pid, (bool)value); + vc_mgr_core_send_set_foreground(pid, (bool)value); SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set foreground DONE"); } @@ -418,7 +377,7 @@ static int __vcd_mgr_get_private_data_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_conte int ret = -1; char *temp_data = NULL; - ret = __vc_mgr_cb_private_data_requested(key, &temp_data); + ret = vc_mgr_core_send_private_data_requested(key, &temp_data); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); return ret; @@ -440,7 +399,7 @@ static int __vcd_mgr_auth_enable_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h int ret = -1; - ret = __vc_mgr_request_auth_enable(pid); + ret = vc_mgr_core_request_auth_enable(pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); } @@ -457,7 +416,7 @@ static int __vcd_mgr_auth_disable_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h int ret = -1; - ret = __vc_mgr_request_auth_disable(pid); + ret = vc_mgr_core_request_auth_disable(pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); } @@ -474,7 +433,7 @@ static int __vcd_mgr_auth_start_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h c int ret = -1; - ret = __vc_mgr_request_auth_start(pid); + ret = vc_mgr_core_request_auth_start(pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); } @@ -491,7 +450,7 @@ static int __vcd_mgr_auth_stop_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h co int ret = -1; - ret = __vc_mgr_request_auth_stop(pid); + ret = vc_mgr_core_request_auth_stop(pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); } @@ -508,7 +467,7 @@ static int __vcd_mgr_auth_cancel_cb(rpc_port_stub_vc_mgr_stub_vcd_mgr_context_h int ret = -1; - ret = __vc_mgr_request_auth_cancel(pid); + ret = vc_mgr_core_request_auth_cancel(pid); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); } -- 2.34.1