SET(MANAGER_SRCS
vc_mgr.c
+ vc_mgr_core.c
vc_mgr_client.c
vc_mgr_data.cpp
vc_mgr_player.c
#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"
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;
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)
{
return VC_ERROR_NONE;
}
+static void __notify_error(void *data)
+{
+ vc_mgr_core_notify_error();
+}
+
static Eina_Bool __request_initialize(void *data)
{
/* request initialization */
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;
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 {
/* 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);
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);
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;
}
/* 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;
}
}
}
- 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)
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;
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;
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;
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;
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)
{
/* 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;
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;
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;
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;
}
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);
SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to recover volume");
return ret;
-}
+}
\ No newline at end of file
--- /dev/null
+/*
+* 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 <aul.h>
+#include <system_info.h>
+#include <pthread.h>
+#include <sound_manager.h>
+#include <sound_manager_internal.h>
+#include <math.h>
+
+#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
--- /dev/null
+/*
+* 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
#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;
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;
}
if (val) {
- __vc_mgr_cb_set_volume(volume);
+ vc_mgr_core_send_set_volume(volume);
g_volume_count++;
}
} /* VCD_MANAGER_METHOD_SET_VOLUME */
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))) {
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 */
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 */
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);
}
}
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))) {
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))) {
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;
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));
}
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
// 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 {
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");
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)
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");
}
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;
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);
}
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);
}
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);
}
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);
}
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);
}
projects / platform / core / uifw / voice-control.git / commitdiff