From: Seongmin Park Date: Fri, 29 Apr 2022 05:14:03 +0000 (+0000) Subject: Revert "Replace IPC between manager and server from dbus to tidl" X-Git-Tag: submit/tizen/20220429.072034^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ef8eb09a20af1a7cb4da76c8528cfc93c3a6b460;p=platform%2Fcore%2Fuifw%2Fvoice-control.git Revert "Replace IPC between manager and server from dbus to tidl" This reverts commit 58c72fc9dde94ee12ecae41b579b724c86269eba. Reason for revert: this commit will be re-merged when all dbus replaced to tidl Change-Id: Ic50ef53ff4b1e455464e587a9282f0b1989f5414 --- diff --git a/CMakeLists.txt b/CMakeLists.txt index a180809..d72a322 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -47,7 +47,7 @@ INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/include") INCLUDE(FindPkgConfig) pkg_check_modules(pkgs REQUIRED aul buxton2 capi-appfw-app-control capi-appfw-app-manager capi-base-common capi-media-audio-io capi-media-sound-manager ecore-wl2 - capi-system-info cynara-client cynara-session dbus-1 db-util dlog ecore glib-2.0 json-glib-1.0 libgum libtzplatform-config libxml-2.0 sqlite3 vconf gmock bundle rpc-port + capi-system-info cynara-client cynara-session dbus-1 db-util dlog ecore glib-2.0 json-glib-1.0 libgum libtzplatform-config libxml-2.0 sqlite3 vconf gmock ) diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 5815fa0..29a1049 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -37,9 +37,6 @@ SET(MANAGER_SRCS vc_mgr_client.c vc_mgr_data.cpp vc_mgr_player.c - vc_mgr_tidl.c - vc_mgr_proxy.c - vc_mgr_stub.c vc_mgr_dbus.c ../common/vc_cmd_db.c ../common/vc_command.c diff --git a/client/vc_mgr.c b/client/vc_mgr.c index c02b61b..9c07f62 100755 --- a/client/vc_mgr.c +++ b/client/vc_mgr.c @@ -31,7 +31,6 @@ #include "vc_json_parser.h" #include "vc_main.h" #include "vc_mgr_client.h" -#include "vc_mgr_tidl.h" #include "vc_mgr_dbus.h" #include "vc_mgr_data.h" #include "vc_mgr_player.h" @@ -47,8 +46,7 @@ static Ecore_Timer* g_send_hello_timer = NULL; static Ecore_Timer* g_request_init_timer = NULL; -static int g_dbus_send_hello_count = 0; -static int g_tidl_send_hello_count = 0; +static int g_send_hello_count = 0; static Ecore_Timer* g_m_set_volume_timer = NULL; @@ -278,14 +276,8 @@ int vc_mgr_initialize(void) return VC_ERROR_NONE; } - // TODO: remove dbus after migrate from dbus to tidl done if (0 != vc_mgr_dbus_open_connection()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open dbus connection"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != vc_mgr_tidl_open_connection()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open tidl connection"); + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open connection"); return VC_ERROR_OPERATION_FAILED; } @@ -332,16 +324,11 @@ int vc_mgr_initialize(void) static void __vc_mgr_internal_unprepare() { - int ret = vc_mgr_tidl_request_finalize(g_vc_m->handle); + int ret = vc_mgr_dbus_request_finalize(g_vc_m->handle); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret)); } - ret = vc_mgr_dbus_request_finalize(g_vc_m->handle); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request dbus finalize : %s", __vc_mgr_get_error_code(ret)); - } - vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE); return; } @@ -416,15 +403,10 @@ int vc_mgr_deinitialize(void) SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to release VC mgr player(%d)", ret); } */ - // TODO: remove dbus after migrate from dbus to tidl done if (0 != vc_mgr_dbus_close_connection()) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection"); } - if (0 != vc_mgr_tidl_close_connection()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection"); - } - SLOG(LOG_ERROR, TAG_VCM, "@@@"); return VC_ERROR_NONE; @@ -452,7 +434,7 @@ static Eina_Bool __request_initialize(void *data) vc_audio_streaming_mode_e streaming_mode; vc_mgr_client_get_audio_streaming_mode(g_vc_m, &streaming_mode); - ret = vc_mgr_tidl_request_initialize(g_vc_m->handle, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid); + ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid); if (VC_ERROR_ENGINE_NOT_FOUND == ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret)); @@ -534,30 +516,15 @@ static Eina_Bool __request_initialize(void *data) static Eina_Bool __send_hello_message(void *data) { /* Send hello */ - // TODO: remove dbus after migrate from dbus to tidl done if (0 != vc_mgr_dbus_request_hello()) { - if (g_dbus_send_hello_count == 20) { - g_dbus_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"); - g_send_hello_timer = NULL; - return EINA_FALSE; - } else { - g_dbus_send_hello_count++; - return EINA_TRUE; - } - } - - /* Send hello */ - if (0 != vc_mgr_tidl_request_hello()) { - if (g_tidl_send_hello_count == 20) { - g_tidl_send_hello_count = 0; + if (g_send_hello_count == 20) { + g_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"); g_send_hello_timer = NULL; return EINA_FALSE; } else { - g_tidl_send_hello_count++; + g_send_hello_count++; return EINA_TRUE; } } @@ -603,8 +570,7 @@ int vc_mgr_prepare(void) } if (NULL == g_send_hello_timer) { - g_dbus_send_hello_count = 0; - g_tidl_send_hello_count = 0; + g_send_hello_count = 0; SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new timer for preparation"); ecore_thread_main_loop_begin(); g_send_hello_timer = ecore_timer_add(0.02, __send_hello_message, NULL); @@ -883,7 +849,7 @@ int vc_mgr_unset_demandable_client_rule(void) int count = 0; int ret = -1; while (0 != ret) { - ret = vc_mgr_tidl_request_demandable_client(g_vc_m->handle); + ret = vc_mgr_dbus_request_demandable_client(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset client rule to daemon : %s", __vc_mgr_get_error_code(ret)); @@ -1133,7 +1099,7 @@ int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list) } else { int count = 0; do { - ret = vc_mgr_tidl_request_set_command(g_vc_m->handle); + ret = vc_mgr_dbus_request_set_command(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret)); @@ -1184,7 +1150,7 @@ int vc_mgr_unset_command_list(void) int count = 0; int ret = -1; while (0 != ret) { - ret = vc_mgr_tidl_request_unset_command(g_vc_m->handle); + ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret)); @@ -1270,7 +1236,7 @@ int vc_mgr_set_command_list_from_file(const char* file_path, int type) } else { int count = 0; do { - ret = vc_mgr_tidl_request_set_command(g_vc_m->handle); + ret = vc_mgr_dbus_request_set_command(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret)); @@ -1388,7 +1354,7 @@ int vc_mgr_set_audio_type(const char* audio_id) /* Request */ while (0 != ret) { - ret = vc_mgr_tidl_request_set_audio_type(g_vc_m->handle, audio_id); + ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret)); @@ -1464,7 +1430,7 @@ int vc_mgr_get_audio_type(char** audio_id) int ret = -1; int count = 0; while (0 != ret) { - ret = vc_mgr_tidl_request_get_audio_type(g_vc_m->handle, &temp); + ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret)); @@ -1575,7 +1541,7 @@ int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list) ret = -1; count = 0; while (0 != ret) { - ret = vc_mgr_tidl_request_set_client_info(g_vc_m->handle); + ret = vc_mgr_dbus_request_set_client_info(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret)); @@ -1820,7 +1786,7 @@ int vc_mgr_set_private_data(const char* key, const char* data) } int ret = -1; - ret = vc_mgr_tidl_request_set_private_data(g_vc_m->handle, key, data); + ret = vc_mgr_dbus_request_set_private_data(g_vc_m->handle, key, data); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -1879,7 +1845,7 @@ int vc_mgr_get_private_data(const char* key, char** data) char* temp = NULL; while (0 != ret) { - ret = vc_mgr_tidl_request_get_private_data(g_vc_m->handle, key, &temp); + ret = vc_mgr_dbus_request_get_private_data(g_vc_m->handle, key, &temp); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret)); @@ -1953,7 +1919,7 @@ int vc_mgr_set_domain(const char* domain) int ret = -1; int count = 0; while (0 != ret) { - ret = vc_mgr_tidl_request_set_domain(g_vc_m->handle, domain); + ret = vc_mgr_dbus_request_set_domain(g_vc_m->handle, domain); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret)); @@ -2023,7 +1989,7 @@ int vc_mgr_do_action(vc_send_event_type_e type, char* send_event) } int ret = -1; - ret = vc_mgr_tidl_request_do_action(g_vc_m->handle, type, send_event); + ret = vc_mgr_dbus_request_do_action(g_vc_m->handle, type, send_event); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -2083,7 +2049,7 @@ int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* e } int ret = -1; - ret = vc_mgr_tidl_send_specific_engine_request(g_vc_m->handle, engine_app_id, event, request); + ret = vc_mgr_dbus_send_specific_engine_request(g_vc_m->handle, engine_app_id, event, request); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -2163,7 +2129,7 @@ int vc_mgr_start(bool exclusive_command_option) count = 0; while (0 != ret) { vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STARTING); - ret = vc_mgr_tidl_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type); + ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret)); @@ -2249,7 +2215,7 @@ int vc_mgr_stop(void) /* do request */ while (0 != ret) { vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STOPPING); - ret = vc_mgr_tidl_request_stop(g_vc_m->handle); + ret = vc_mgr_dbus_request_stop(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret)); @@ -2328,7 +2294,7 @@ int vc_mgr_cancel(void) int count = 0; while (0 != ret) { vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_CANCELING); - ret = vc_mgr_tidl_request_cancel(g_vc_m->handle); + ret = vc_mgr_dbus_request_cancel(g_vc_m->handle); if (0 != ret) { if (VC_ERROR_TIMED_OUT != ret) { SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret)); @@ -2372,7 +2338,7 @@ static Eina_Bool __vc_mgr_set_volume_timer_cb(void* data) int __vc_mgr_cb_set_volume(float volume) { - // called in vc_mgr_tidl + // called in vc_mgr_dbus g_prev_volume_db = g_volume_db; g_cur_volume_db = volume; @@ -2508,7 +2474,7 @@ int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list) /* Request */ int ret = -1; - ret = vc_mgr_tidl_send_result_selection(g_vc_m->handle); + ret = vc_mgr_dbus_send_result_selection(g_vc_m->handle); if (0 != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret)); return ret; @@ -4535,7 +4501,7 @@ int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* float volume = __get_volume_decibel((char*)buffer, len); __vc_mgr_set_volume(volume); - ret = vc_mgr_tidl_send_audio_streaming(g_vc_m->handle, event, buffer, len); + ret = vc_mgr_dbus_send_audio_streaming(g_vc_m->handle, event, buffer, len); if (0 != ret) SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data"); else @@ -4594,12 +4560,12 @@ int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode) SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client"); } - ret = vc_mgr_tidl_request_set_audio_streaming_mode(g_vc_m->handle, mode); + ret = vc_mgr_dbus_request_set_audio_streaming_mode(g_vc_m->handle, mode); if (VC_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %s", __vc_mgr_get_error_code(ret)); return VC_ERROR_OPERATION_FAILED; } else { - SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr tidl"); + SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr dbus"); } } else { SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'INITIALIZED', state(%d)", state); diff --git a/client/vc_mgr_dbus.c b/client/vc_mgr_dbus.c index c59a3d9..7e2b875 100755 --- a/client/vc_mgr_dbus.c +++ b/client/vc_mgr_dbus.c @@ -23,6 +23,7 @@ static pthread_mutex_t g_m_dbus_mutex = PTHREAD_MUTEX_INITIALIZER; +static int g_m_waiting_time = 3000; static int g_m_waiting_short_time = 200; static bool g_is_connection_opened = false; @@ -31,13 +32,32 @@ static Ecore_Fd_Handler* g_m_fd_handler = NULL; static DBusConnection* g_m_conn_sender = NULL; static DBusConnection* g_m_conn_listener = NULL; +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 */ @@ -51,7 +71,10 @@ extern int __vc_mgr_request_auth_stop(int pid); extern int __vc_mgr_request_auth_cancel(int pid); -// TODO: remove listener event callback +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 Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler) { if (NULL == g_m_conn_listener) return ECORE_CALLBACK_RENEW; @@ -75,7 +98,145 @@ static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd char if_name[64] = {0, }; snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE); - if (dbus_message_is_signal(msg, if_name, VCC_MANAGER_METHOD_SET_FOREGROUND)) { + if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get Hello"); + int pid = 0; + int response = -1; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (pid > 0) { + SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get hello : pid(%d) ", pid); + response = 1; + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get hello : invalid pid "); + } + + DBusMessage *reply = NULL; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID); + + if (!dbus_connection_send(g_m_conn_listener, reply, NULL)) + SLOG(LOG_ERROR, TAG_VCM, "@@ vc get hello : fail to send reply"); + else + SLOG(LOG_INFO, TAG_VCM, "@@ vc get hello : result(%d)", response); + + dbus_connection_flush(g_m_conn_listener); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get hello : fail to create reply message"); + } + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + } /* VCD_METHOD_HELLO */ + + else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_VOLUME)) { + float volume = 0; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message); + dbus_error_free(&err); + } + + if (10 == g_volume_count) { + SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set volume"); + SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set volume : volume(%f)", volume); + g_volume_count = 0; + } + + __vc_mgr_cb_set_volume(volume); + g_volume_count++; + + } /* VCD_MANAGER_METHOD_SET_VOLUME */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SET_SERVICE_STATE)) { + int state = 0; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message); + dbus_error_free(&err); + } + + SLOG(LOG_INFO, TAG_VCM, "@@ state changed : %d", state); + + __vc_mgr_cb_service_state(state); + + } /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get Speech detected"); + + __vc_mgr_cb_speech_detected(); + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + + } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get All Result"); + int result_type = 0; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID); + + __vc_mgr_cb_all_result((vc_result_type_e)result_type); + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + + } /* VCD_MANAGER_METHOD_ALL_RESULT */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_PRE_RESULT)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get Pre Result"); + int event; + char* pre_result = NULL; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID); + + if (NULL != pre_result) { + __vc_mgr_cb_pre_result((vc_pre_result_event_e)event, pre_result); + } + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_PRE_RESULT */ + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get specific engine result"); + char* engine_app_id = NULL; + char* event = NULL; + char* result = NULL; + + dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &engine_app_id, DBUS_TYPE_STRING, &event, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID); + + if (NULL != result) { + gsize decodingSize=0; + gchar *gDecodedResult = (gchar *)g_base64_decode((const gchar *)result, &decodingSize); + if (gDecodedResult) + { + SLOG(LOG_WARN, TAG_VCM, "@@@ Get specific engine result --> %s", gDecodedResult); + __vc_mgr_cb_specific_engine_result(engine_app_id, event, gDecodedResult); + g_free(gDecodedResult); + } + } + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT */ + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get System Result"); + + __vc_mgr_cb_system_result(); + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + + } /* VCD_MANAGER_METHOD_RESULT */ + + else if (dbus_message_is_signal(msg, if_name, VCC_MANAGER_METHOD_SET_FOREGROUND)) { SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground"); int pid = 0; int value = 0; @@ -95,6 +256,89 @@ static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd SLOG(LOG_DEBUG, TAG_VCM, "@@@"); } /* VCC_MANAGER_METHOD_SET_FOREGROUND */ + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_DIALOG)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Request Dialog"); + int pid = -1; + char* disp_text = NULL; + char* utt_text = NULL; + int tmp_continue; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &disp_text, + DBUS_TYPE_STRING, &utt_text, + DBUS_TYPE_INT32, &tmp_continue, + DBUS_TYPE_INVALID); + + if (!strcmp(disp_text, "NNUULLLL")) + disp_text = NULL; + if (!strcmp(utt_text, "NNUULLLL")) + utt_text = NULL; + + __vc_mgr_cb_dialog(pid, disp_text, utt_text, (bool)tmp_continue); + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + + } /* VCD_MANAGER_METHOD_DIALOG */ + + else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ERROR)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get Error"); + int reason; + int daemon_pid; + char* err_msg = NULL; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &reason, + DBUS_TYPE_INT32, &daemon_pid, + DBUS_TYPE_STRING, &err_msg, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr Get Error message : Get arguments error (%s)", err.message); + dbus_error_free(&err); + } else { + char* temp_msg = NULL; + if (NULL != err_msg && strcmp("#NULL", err_msg)) { + temp_msg = strdup(err_msg); + } + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr Get Error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, (temp_msg) ? temp_msg : "NULL"); + __vc_mgr_cb_error(reason, daemon_pid, temp_msg); + if (NULL != temp_msg) { + free(temp_msg); + temp_msg = NULL; + } + } + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_ERROR */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SET_PRIVATE_DATA)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get request set private data"); + int pid = 0; + char* key = NULL; + char* private_data = NULL; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_STRING, &private_data, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (pid > 0) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", pid); + __vc_mgr_cb_private_data_set(key, private_data); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get request set private data : invalid pid "); + } + + SLOG(LOG_DEBUG, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_SET_PRIVATE_DATA */ + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_GET_PRIVATE_DATA)) { SLOG(LOG_INFO, TAG_VCM, "@@@ Get request get private data"); int pid = 0; @@ -141,6 +385,44 @@ static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd SLOG(LOG_DEBUG, TAG_VCM, "@@@"); } /* VCD_MANAGER_METHOD_GET_PRIVATE_DATA */ + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get TTS feedback audio format"); + int rate; + vc_audio_channel_e channel; + vc_audio_type_e audio_type; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &rate, + DBUS_TYPE_INT32, &channel, + DBUS_TYPE_INT32, &audio_type, + DBUS_TYPE_INVALID); + + __vc_mgr_cb_feedback_audio_format(rate, channel, audio_type); + + SLOG(LOG_INFO, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT */ + + else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_FEEDBACK_STREAMING)) { + SLOG(LOG_INFO, TAG_VCM, "@@@ Get TTS feedback streaming"); + int pid = -1; + int utt_id = -1;; + vc_feedback_event_e event; + char* buffer = NULL; + int len; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &utt_id, + DBUS_TYPE_INT32, &event, + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, + &buffer, &len, + DBUS_TYPE_INVALID); + + __vc_mgr_cb_feedback_streaming(pid, utt_id, event, buffer, len); + + SLOG(LOG_INFO, TAG_VCM, "@@@"); + } /* VCD_MANAGER_METHOD_FEEDBACK_STREAMING */ + /* Authority */ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) { SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth enable"); @@ -577,7 +859,6 @@ static int __dbus_check() int vc_mgr_dbus_request_hello() { - SLOG(LOG_DEBUG, TAG_VCM, "@@ Request vc hello start"); if (0 != __dbus_check()) { return VC_ERROR_OPERATION_FAILED; } @@ -617,7 +898,6 @@ int vc_mgr_dbus_request_hello() result = VC_ERROR_TIMED_OUT; } - SLOG(LOG_DEBUG, TAG_VCM, "@@ Request vc hello end"); return result; } @@ -647,7 +927,7 @@ static int __dbus_restore_daemon() return ret; } -int vc_mgr_dbus_request_finalize(int pid) +int vc_mgr_dbus_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid) { if (0 != __dbus_check()) { return VC_ERROR_OPERATION_FAILED; @@ -672,123 +952,1526 @@ int vc_mgr_dbus_request_finalize(int pid) return VC_ERROR_OPERATION_FAILED; } - /* remove a rule for daemon error */ - char rule_err[256] = {0, }; - snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE); - dbus_bus_remove_match(g_m_conn_listener, rule_err, &err); - dbus_connection_flush(g_m_conn_listener); + DBusMessage* msg; + + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_INITIALIZE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr initialize : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr initialize : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &audio_streaming_mode, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message); + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); dbus_error_free(&err); - return VC_ERROR_OPERATION_FAILED; } - return VC_ERROR_NONE; -} + if (NULL != result_msg) { + int tmp_service_state = 0; + int tmp_foreground = 0; + int tmp_daemon_pid = 0; + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INT32, &tmp_service_state, + DBUS_TYPE_INT32, &tmp_foreground, + DBUS_TYPE_INT32, &tmp_daemon_pid, + DBUS_TYPE_INVALID); -static DBusMessage* __get_message(int pid, const char* method, int type) -{ - char service_name[64]; - char object_path[64]; - char target_if_name[128]; + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } - memset(service_name, '\0', 64); - memset(object_path, '\0', 64); - memset(target_if_name, '\0', 128); + dbus_message_unref(result_msg); - if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) { - snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid); - snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH); - snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid); - } else if (VC_COMMAND_TYPE_WIDGET == type) { - snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid); - snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH); - snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid); + if (0 == result) { + *service_state = tmp_service_state; + *foreground = tmp_foreground; + *daemon_pid = tmp_daemon_pid; + + /* add a rule for daemon error */ + char rule_err[256] = {0, }; + snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE); + if (NULL == g_m_conn_listener) { + if (g_is_connection_opened) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] g_m_conn_listener is NULL abnormally"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[INFO] g_m_conn_listener is NULL and DBUS connection was closed"); + return VC_ERROR_NONE; + } + } + dbus_bus_add_match(g_m_conn_listener, rule_err, NULL); + + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr initialize : result = %d, service state = %d, foreground = %d, daemon_pid = %d", + result, *service_state, *foreground, *daemon_pid); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr initialize : result = %d", result); + } } else { - return NULL; + SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL "); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; } - SLOG(LOG_INFO, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name); - - return dbus_message_new_method_call(service_name, object_path, target_if_name, method); + return result; } -// int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id) -// { -// if (0 != __dbus_check()) { -// return VC_ERROR_OPERATION_FAILED; -// } - -// DBusMessage* msg = NULL; - -// switch (cmd_type) { -// case VC_COMMAND_TYPE_FOREGROUND: -// case VC_COMMAND_TYPE_BACKGROUND: -// msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type); -// break; -// case VC_COMMAND_TYPE_WIDGET: -// msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, cmd_type); -// break; -// default: -// SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type); -// return -1; -// } - -// if (NULL == msg) -// SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Message is NULL"); - -// dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_id, DBUS_TYPE_INVALID); - -// dbus_message_set_no_reply(msg, TRUE); - -// /* send the message and flush the connection */ -// if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { -// SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); -// dbus_message_unref(msg); -// return VC_ERROR_OPERATION_FAILED; -// } else { -// SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); -// dbus_connection_flush(g_m_conn_sender); -// } - -// dbus_message_unref(msg); -// return 0; -// } - -int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status) +int vc_mgr_dbus_request_finalize(int pid) { if (0 != __dbus_check()) { return VC_ERROR_OPERATION_FAILED; } - DBusMessage* msg; - msg = __get_message(pid, VC_MANAGER_METHOD_UTTERANCE_STATUS, VC_COMMAND_TYPE_FOREGROUND); + DBusError err; + dbus_error_init(&err); - if (NULL == msg) { - SLOG(LOG_ERROR, TAG_VCM, "@@ vc send utterance status : Fail to make message"); + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } return VC_ERROR_OPERATION_FAILED; - } else { - SLOG(LOG_INFO, TAG_VCM, "@@ vc send utterance status : pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status); } - dbus_message_append_args(msg, - DBUS_TYPE_INT32, &utt_id, - DBUS_TYPE_INT32, &utt_status, - DBUS_TYPE_INVALID); + /* remove a rule for daemon error */ + char rule_err[256] = {0, }; + snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE); + dbus_bus_remove_match(g_m_conn_listener, rule_err, &err); + dbus_connection_flush(g_m_conn_listener); - dbus_message_set_no_reply(msg, TRUE); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message); + dbus_error_free(&err); + return VC_ERROR_OPERATION_FAILED; + } - /* send the message and flush the connection */ - if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { - SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); - dbus_message_unref(msg); + DBusMessage* msg; + + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_FINALIZE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : Fail to make message "); return VC_ERROR_OPERATION_FAILED; } else { - SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); - dbus_connection_flush(g_m_conn_sender); + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr finalize : pid(%d)", pid); } + dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); dbus_message_unref(msg); - return 0; -} \ No newline at end of file + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr finalize : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL "); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_command(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_SET_COMMAND); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set command : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set command : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_unset_command(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_UNSET_COMMAND); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr unset command : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr unset command : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_demandable_client(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_SET_DEMANDABLE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set demandable client : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_SET_AUDIO_TYPE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &(audio_type), + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set audio type : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_GET_AUDIO_TYPE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get audio type : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + char* temp = NULL; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_STRING, &temp, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + if (NULL != audio_type && NULL != temp) { + *audio_type = strdup(temp); + } + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get audio type : result = %d audio type = %s", result, temp); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_private_data(int pid, const char* key, const char* data) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_SET_PRIVATE_DATA); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc set private data : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc set private data : pid(%d), data(%s)", pid, data); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_STRING, &data, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send private data"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus] Success to send private data"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + + return VC_ERROR_NONE; +} + +int vc_mgr_dbus_request_get_private_data(int pid, const char* key, char** data) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_GET_PRIVATE_DATA); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get private data : pid(%d), key(%s)", pid, key); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_INVALID); + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + char* temp = NULL; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_STRING, &temp, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + if (0 == strncmp(temp, "#NULL", 5)) { + *data = NULL; + } else { + *data = strdup(temp); + } + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get private data : result = %d private data = %s", result, *data); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : result = %d", result); + } + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_client_info(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_SET_CLIENT_INFO); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set client info : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set client info : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_domain(int pid, const char* domain) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_SET_DOMAIN); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : pid(%d), domain(%s)", pid, domain); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_INVALID); + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_do_action(int pid, vc_send_event_type_e type, char* send_event) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_DO_ACTION); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : pid(%d), type(%d), send_event(%s)", pid, type, send_event); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &type, + DBUS_TYPE_STRING, &send_event, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + return 0; +} + +int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_START); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d) disabled cmd type(%d)", + pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type); + } + + int exclusive = (int)exclusive_command_option; + int by = (int)start_by_client; + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &(recognition_mode), + DBUS_TYPE_INT32, &(exclusive), + DBUS_TYPE_INT32, &(by), + DBUS_TYPE_INT32, &(disabled_cmd_type), + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr start : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_stop(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_STOP); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr stop : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr stop : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_cancel(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_CANCEL); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc cancel : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc cancel : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} + +int vc_mgr_dbus_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_SET_AUDIO_STREAMING_MODE); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio streaming mode : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set audio streaming mode : pid(%d) mode(%d)", pid, mode); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &mode, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to set audio streaming mode"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] Success to set audio streaming mode"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + + return VC_ERROR_NONE; +} + +static DBusMessage* __get_message(int pid, const char* method, int type) +{ + char service_name[64]; + char object_path[64]; + char target_if_name[128]; + + memset(service_name, '\0', 64); + memset(object_path, '\0', 64); + memset(target_if_name, '\0', 128); + + if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) { + snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid); + snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH); + snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid); + } else if (VC_COMMAND_TYPE_WIDGET == type) { + snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid); + snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH); + snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid); + } else { + return NULL; + } + + SLOG(LOG_INFO, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name); + + return dbus_message_new_method_call(service_name, object_path, target_if_name, method); +} + +int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg = NULL; + + switch (cmd_type) { + case VC_COMMAND_TYPE_FOREGROUND: + case VC_COMMAND_TYPE_BACKGROUND: + msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type); + break; + case VC_COMMAND_TYPE_WIDGET: + msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, cmd_type); + break; + default: + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type); + return -1; + } + + if (NULL == msg) + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Message is NULL"); + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_id, DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + return 0; +} + +int vc_mgr_dbus_send_result_selection(int pid) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_RESULT_SELECTION); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc result selection : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc result selection : pid(%d)", pid); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + return 0; +} + +int vc_mgr_dbus_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_SPECIFIC_ENGINE_REQUEST); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc send specific engine : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc send specific engine : pid(%d), engine_app_id(%s), event(%s), request(%s)", pid, engine_app_id, event, request); + } + + gchar *gEncodedRequest = g_base64_encode((const guchar*)request, strlen(request)); + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &engine_app_id, + DBUS_TYPE_STRING, &event, + DBUS_TYPE_STRING, &gEncodedRequest, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); + if (gEncodedRequest) + g_free(gEncodedRequest); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_m_conn_sender); + } + + if (gEncodedRequest) + g_free(gEncodedRequest); + dbus_message_unref(msg); + return 0; +} + +int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + msg = __get_message(pid, VC_MANAGER_METHOD_UTTERANCE_STATUS, VC_COMMAND_TYPE_FOREGROUND); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc send utterance status : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc send utterance status : pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &utt_id, + DBUS_TYPE_INT32, &utt_status, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send the message and flush the connection */ + if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send"); + dbus_message_unref(msg); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + return 0; +} + +int vc_mgr_dbus_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_MANAGER_METHOD_SEND_AUDIO_STREAMING); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc send audio streaming : Fail to make message"); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &event, + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, + &buffer, len, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + /* send dbus message and flush the connection */ + if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send audio streaming"); + } else { + SLOG(LOG_INFO, TAG_VCM, "[Dbus DEBUG] Success to send audio streaming"); + dbus_connection_flush(g_m_conn_sender); + } + + dbus_message_unref(msg); + + return 0; +} + +int vc_mgr_dbus_change_system_volume(int pid, vc_system_volume_event_e volume_event) +{ + if (0 != __dbus_check()) { + return VC_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err); + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + int ret; + int temp_event = (int)volume_event; + if (false == exist) { + ret = __dbus_restore_daemon(); + if (VC_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon"); + return VC_ERROR_TIMED_OUT; + } + return VC_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */ + VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */ + VC_MANAGER_METHOD_CHANGE_SYSTEM_VOLUME); /* name of the signal */ + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc change system volume : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCM, "@@ vc change system volume : pid(%d) volume_event(%d)", pid, temp_event); + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &temp_event, + DBUS_TYPE_INVALID); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_INFO, TAG_VCM, "@@ vc change system volume : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ vc change system volume : result = %d", result); + } + } else { + SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL"); + vc_mgr_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} diff --git a/client/vc_mgr_dbus.h b/client/vc_mgr_dbus.h index 4c82e19..c144024 100644 --- a/client/vc_mgr_dbus.h +++ b/client/vc_mgr_dbus.h @@ -32,10 +32,54 @@ int vc_mgr_dbus_close_connection(); int vc_mgr_dbus_request_hello(); +int vc_mgr_dbus_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid); + int vc_mgr_dbus_request_finalize(int pid); +int vc_mgr_dbus_request_set_command(int pid); + +int vc_mgr_dbus_request_unset_command(int pid); + +int vc_mgr_dbus_request_demandable_client(int pid); + +int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type); + +int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type); + +int vc_mgr_dbus_request_set_private_data(int pid, const char* key, const char* data); + +int vc_mgr_dbus_request_get_private_data(int pid, const char* key, char** data); + +int vc_mgr_dbus_request_set_client_info(int pid); + +int vc_mgr_dbus_request_set_domain(int pid, const char* domain); + +int vc_mgr_dbus_request_do_action(int pid, vc_send_event_type_e type, char* send_event); + +int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type); + +int vc_mgr_dbus_request_stop(int pid); + +int vc_mgr_dbus_request_cancel(int pid); + +int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id); + +int vc_mgr_dbus_send_result_selection(int pid); + +int vc_mgr_dbus_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request); + +int vc_mgr_dbus_request_start_feedback(int pid); + +int vc_mgr_dbus_request_stop_feedback(int pid); + int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status); +int vc_mgr_dbus_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len); + +int vc_mgr_dbus_change_system_volume(int pid, vc_system_volume_event_e volume_event); + +int vc_mgr_dbus_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode); + #ifdef __cplusplus } #endif diff --git a/client/vc_mgr_tidl.c b/client/vc_mgr_tidl.c deleted file mode 100755 index fc9781f..0000000 --- a/client/vc_mgr_tidl.c +++ /dev/null @@ -1,1204 +0,0 @@ -/* -* 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 "vc_main.h" -#include "vc_mgr_client.h" -#include "vc_mgr_tidl.h" -#include "vc_mgr_proxy.h" -#include "vc_mgr_stub.h" -#include "vc_command.h" - -typedef struct { - bool connected; - bool connection_requesting; - bool register_callback_invoked; - rpc_port_proxy_vc_mgr_h rpc_h; - rpc_port_proxy_vc_mgr_notify_cb_h notify_cb_h; - rpc_port_proxy_vc_mgr_send_buffer_cb_h send_buffer_cb_h; -} vc_mgr_tidl_info_s; - -typedef struct { - bool connected; - bool register_callback_requesting; -} vcd_mgr_tidl_info_s; - -static vc_mgr_tidl_info_s* g_proxy_tidl_info = NULL; - -static vcd_mgr_tidl_info_s* g_stub_tidl_info = NULL; - -static pthread_mutex_t g_tidl_mutex = PTHREAD_MUTEX_INITIALIZER; - -static rpc_port_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; - char *val = NULL; - - SLOG(LOG_DEBUG, TAG_VCM, "__notify_cb is invoked"); - - bundle_get_str(msg, VC_MANAGER_BUNDLE_METHOD, &method); - - if (0 == strncmp(VCD_MANAGER_METHOD_SET_VOLUME, method, strlen(VCD_MANAGER_METHOD_SET_VOLUME))) { - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &val); - float volume = 0; - - if (val) { - volume = atof(val); - } - if (10 == g_volume_count) { - SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set volume"); - SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set volume : volume(%f)", volume); - g_volume_count = 0; - } - - if (val) { - __vc_mgr_cb_set_volume(volume); - g_volume_count++; - } - } /* VCD_MANAGER_METHOD_SET_VOLUME */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_SET_SERVICE_STATE, method, strlen(VCD_MANAGER_METHOD_SET_SERVICE_STATE))) { - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &val); - int state = 0; - if (val) { - state = atoi(val); - SLOG(LOG_INFO, TAG_VCM, "@@ state changed : %d", state); - __vc_mgr_cb_service_state(state); - } - } /* VCD_MANAGER_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(); - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_ALL_RESULT, method, strlen(VCD_MANAGER_METHOD_ALL_RESULT))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get All Result"); - - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &val); - - if (val) { - __vc_mgr_cb_all_result((vc_result_type_e)atoi(val)); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_ALL_RESULT */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_PRE_RESULT, method, strlen(VCD_MANAGER_METHOD_PRE_RESULT))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get Pre Result"); - char* event = NULL; - char* pre_result = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_EVENT, &event); - bundle_get_str(msg, VC_MANAGER_BUNDLE_PRE_RESULT, &pre_result); - - if (NULL != pre_result) { - __vc_mgr_cb_pre_result((vc_pre_result_event_e)atoi(event), pre_result); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_PRE_RESULT */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT, method, strlen(VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get specific engine result"); - char* engine_app_id = NULL; - char* event = NULL; - char* result = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_ENGINE_APP_ID, &engine_app_id); - bundle_get_str(msg, VC_MANAGER_BUNDLE_EVENT, &event); - bundle_get_str(msg, VC_MANAGER_BUNDLE_RESULT, &result); - - if (NULL != result) { - gsize decodingSize=0; - gchar *gDecodedResult = (gchar *)g_base64_decode((const gchar *)result, &decodingSize); - if (gDecodedResult) - { - SLOG(LOG_WARN, TAG_VCM, "@@@ Get specific engine result --> %s", gDecodedResult); - __vc_mgr_cb_specific_engine_result(engine_app_id, event, gDecodedResult); - g_free(gDecodedResult); - } - } - } /* VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT */ - - 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(); - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - } /* VCD_MANAGER_METHOD_RESULT */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_DIALOG, method, strlen(VCD_MANAGER_METHOD_DIALOG))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Request Dialog"); - char* pid = NULL; - char* disp_text = NULL; - char* utt_text = NULL; - char* continous = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &pid); - bundle_get_str(msg, VC_MANAGER_BUNDLE_DISP_TEXT, &disp_text); - bundle_get_str(msg, VC_MANAGER_BUNDLE_UTT_TEXT, &utt_text); - bundle_get_str(msg, VC_MANAGER_BUNDLE_CONTINUOUS, &continous); - - 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)); - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_DIALOG */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_ERROR, method, strlen(VCD_MANAGER_METHOD_ERROR))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get Error"); - char* reason = NULL; - char* daemon_pid = NULL; - char* err_msg = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_REASON, &reason); - bundle_get_str(msg, VC_MANAGER_BUNDLE_DAEMON_PID, &daemon_pid); - bundle_get_str(msg, VC_MANAGER_BUNDLE_ERROR_MESSAGE, &err_msg); - - char* temp_msg = NULL; - if (NULL != err_msg && strncmp(err_msg, "#NULL", strlen("#NULL") + 1)) { - 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); - if (NULL != temp_msg) { - free(temp_msg); - temp_msg = NULL; - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_ERROR */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_SET_PRIVATE_DATA, method, strlen(VCD_MANAGER_METHOD_SET_PRIVATE_DATA))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request set private data"); - char* pid = NULL; - char* key = NULL; - char* private_data = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &pid); - bundle_get_str(msg, VC_MANAGER_BUNDLE_KEY, &key); - bundle_get_str(msg, VC_MANAGER_BUNDLE_PRIVATE_DATA, &private_data); - - 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); - } else { - SLOG(LOG_ERROR, TAG_VCM, "@@ got invalid pid(%d)", atoi(pid)); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_SET_PRIVATE_DATA */ - - else if (0 == strncmp(VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT, method, strlen(VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT))) { - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request feedback audio format"); - char* channel = NULL; - char* audio_type = NULL; - char* rate = NULL; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_AUDIO_CHANNEL, &channel); - bundle_get_str(msg, VC_MANAGER_BUNDLE_AUDIO_TYPE, &audio_type); - bundle_get_str(msg, VC_MANAGER_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)); - - SLOG(LOG_INFO, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT */ - - // TODO: uncomment this line after vcc done - // else if (0 == strncmp(VCC_MANAGER_METHOD_SET_FOREGROUND, method, strlen(VCC_MANAGER_METHOD_SET_FOREGROUND))) { - // SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground"); - // char* temp_pid = NULL; - // char* temp_value = NULL; - // int pid = 0; - // int value = 0; - - // bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &temp_pid); - // bundle_get_str(msg, VC_MANAGER_BUNDLE_VALUE, &temp_value); - // pid = atoi(temp_pid); - // value = atoi(temp_value); - - // SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false"); - - // __vc_mgr_cb_set_foreground(pid, (bool)value); - // SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - // } /* VCC_MANAGER_METHOD_SET_FOREGROUND */ - - else { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg"); - } - -} - -static void __send_buffer_cb(void *user_data, rpc_port_proxy_array_char_h data_in, bundle *msg) -{ - char *method = NULL; - char *val = NULL; - - SLOG(LOG_DEBUG, TAG_VCM, "__send_buffer_cb is invoked"); - - bundle_get_str(msg, VC_MANAGER_BUNDLE_METHOD, &method); - - if (0 == strncmp(VCD_MANAGER_METHOD_FEEDBACK_STREAMING, method, strlen(VCD_MANAGER_METHOD_FEEDBACK_STREAMING))) { - char *utt_id = NULL; - char *event = NULL; - char* buffer = NULL; - int len = 0; - - bundle_get_str(msg, VC_MANAGER_BUNDLE_MESSAGE, &val); - bundle_get_str(msg, VC_MANAGER_BUNDLE_UTTID, &utt_id); - bundle_get_str(msg, VC_MANAGER_BUNDLE_EVENT, &event); - - rpc_port_proxy_array_char_get(data_in, &buffer, &len); - __vc_mgr_cb_feedback_streaming(atoi(val), atoi(utt_id), atoi(event), buffer, len); - free(buffer); - - SLOG(LOG_INFO, TAG_VCM, "@@@"); - } /* VCD_MANAGER_METHOD_FEEDBACK_STREAMING */ - - else { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid msg"); - } - -} - -static void __on_connected(rpc_port_proxy_vc_mgr_h h, void *user_data) -{ - g_proxy_tidl_info->connected = true; - g_proxy_tidl_info->connection_requesting = false; - g_proxy_tidl_info->register_callback_invoked = false; - - SLOG(LOG_INFO, TAG_VCM, "Connected to server"); -} - -static void __on_disconnected(rpc_port_proxy_vc_mgr_h h, void *user_data) -{ - g_proxy_tidl_info->connected = false; - g_proxy_tidl_info->connection_requesting = false; - g_proxy_tidl_info->register_callback_invoked = false; - - SLOG(LOG_INFO, TAG_VCM, "Disonnected to server"); -} - -static void __on_rejected(rpc_port_proxy_vc_mgr_h h, void *user_data) -{ - g_proxy_tidl_info->connection_requesting = false; - g_proxy_tidl_info->register_callback_invoked = false; - - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Rejected from server"); -} - - -static rpc_port_proxy_vc_mgr_h __create_rpc_port(const char* engine_app_id) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __create_rpc_port"); - rpc_port_proxy_vc_mgr_callback_s rpc_callback = { - .connected = __on_connected, - .disconnected = __on_disconnected, - .rejected = __on_rejected - }; - - rpc_port_proxy_vc_mgr_h handle = NULL; - if (0 != rpc_port_proxy_vc_mgr_create(engine_app_id, &rpc_callback, NULL, &handle)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy"); - return NULL; - } - - return handle; -} - -static void __vcd_mgr_create_cb(rpc_port_stub_vcd_mgr_context_h context, void *user_data) -{ - g_stub_tidl_info->connected = true; - g_stub_tidl_info->register_callback_requesting = false; - - SLOG(LOG_DEBUG, TAG_VCM, "Connected to server"); - - char *sender = NULL; - - rpc_port_stub_vcd_mgr_context_get_sender(context, &sender); - if (!sender) { - SLOG(LOG_ERROR, TAG_VCM, "@@@ Sender is NULL"); - return; - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@ Server connect. appid(%s)", sender); - free(sender); -} - -static void __vcd_mgr_terminate_cb(rpc_port_stub_vcd_mgr_context_h context, void *user_data) -{ - g_stub_tidl_info->connected = false; - g_stub_tidl_info->register_callback_requesting = false; - - rpc_port_stub_vcd_mgr_context_set_tag(context, NULL); - - char *sender = NULL; - rpc_port_stub_vcd_mgr_context_get_sender(context, &sender); - if (!sender) - return; - - SLOG(LOG_INFO, TAG_VCM, "@@@ Server disconnect. appid(%s)", sender); - free(sender); -} - -static void __vcd_mgr_set_foreground_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, int value, 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); - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); -} - -static int __vcd_mgr_get_private_data_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, const char *key, char **data, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request get private data"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid); - - int ret = -1; - char *temp_data = NULL; - - ret = __vc_mgr_cb_private_data_requested(key, &temp_data); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - return ret; - } - if (NULL == temp_data) { - SLOG(LOG_INFO, TAG_VCM, "data parameter is NULL"); - temp_data = strdup("#NULL"); - } - *data = temp_data; - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static int __vcd_mgr_auth_enable_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth enable"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth enable : pid(%d)", pid); - - int ret = -1; - - ret = __vc_mgr_request_auth_enable(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static int __vcd_mgr_auth_disable_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth disable"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth disable : pid(%d)", pid); - - int ret = -1; - - ret = __vc_mgr_request_auth_disable(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static int __vcd_mgr_auth_start_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth start"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth start : pid(%d)", pid); - - int ret = -1; - - ret = __vc_mgr_request_auth_start(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static int __vcd_mgr_auth_stop_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth stop"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth stop : pid(%d)", pid); - - int ret = -1; - - ret = __vc_mgr_request_auth_stop(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static int __vcd_mgr_auth_cancel_cb(rpc_port_stub_vcd_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth cancel"); - SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth cancel : pid(%d)", pid); - - int ret = -1; - - ret = __vc_mgr_request_auth_cancel(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCM, "@@@"); - - return ret; -} - -static void __register_stub_callback() -{ - if (g_stub_tidl_info->register_callback_requesting) { - return; - } - - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] __register_stub_callback"); - - g_mgr_callback.create = __vcd_mgr_create_cb; - g_mgr_callback.terminate = __vcd_mgr_terminate_cb; - g_mgr_callback.set_foreground = __vcd_mgr_set_foreground_cb; - g_mgr_callback.get_private_data = __vcd_mgr_get_private_data_cb; - g_mgr_callback.auth_enable = __vcd_mgr_auth_enable_cb; - g_mgr_callback.auth_disable = __vcd_mgr_auth_disable_cb; - g_mgr_callback.auth_start = __vcd_mgr_auth_start_cb; - g_mgr_callback.auth_stop = __vcd_mgr_auth_stop_cb; - g_mgr_callback.auth_cancel = __vcd_mgr_auth_cancel_cb; - - int ret = -1; - ret = rpc_port_stub_vcd_mgr_register(&g_mgr_callback, NULL); - if (0 == ret) { - SLOG(LOG_DEBUG, TAG_VCM, "register callback"); - g_stub_tidl_info->register_callback_requesting = true; - return; - } - - SLOG(LOG_ERROR, TAG_VCM, "Fail to rister callback(%d)", ret); - return; -} - -int vc_mgr_tidl_open_connection() -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_open_connection"); - pthread_mutex_lock(&g_tidl_mutex); - - if (NULL != g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] g_proxy_tidl_info already created"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_NONE; - } - - g_proxy_tidl_info = (vc_mgr_tidl_info_s*)calloc(1, sizeof(vc_mgr_tidl_info_s)); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vc_mgr_tidl_info_s"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_OUT_OF_MEMORY; - } - - char* engine_app_id = vconf_get_str(VC_ENGINE_DB_DEFAULT); - if (NULL == engine_app_id) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL] vconf not found"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_ENGINE_NOT_FOUND; - } - - g_proxy_tidl_info->rpc_h = __create_rpc_port(engine_app_id); - if (NULL == g_proxy_tidl_info->rpc_h) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create proxy"); - free(engine_app_id); - free(g_proxy_tidl_info); - g_proxy_tidl_info = NULL; - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_OPERATION_FAILED; - } - - SLOG(LOG_INFO, TAG_VCM, "[TIDL] rpc_h(%p), engine_app_id(%s)", g_proxy_tidl_info->rpc_h, engine_app_id); - free(engine_app_id); - - g_stub_tidl_info = (vcd_mgr_tidl_info_s*)calloc(1, sizeof(vcd_mgr_tidl_info_s)); - - if (NULL == g_stub_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to create vcd_mgr_tidl_info_s"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_OUT_OF_MEMORY; - } - - __register_stub_callback(); - - pthread_mutex_unlock(&g_tidl_mutex); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_close_connection() -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_close_connection"); - pthread_mutex_lock(&g_tidl_mutex); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_destroy(g_proxy_tidl_info->rpc_h)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Fail to destroy tidl handle"); - pthread_mutex_unlock(&g_tidl_mutex); - return VC_ERROR_OPERATION_FAILED; - } - - g_proxy_tidl_info->rpc_h = NULL; - g_proxy_tidl_info->notify_cb_h = NULL; - g_proxy_tidl_info->send_buffer_cb_h = NULL; - - free(g_proxy_tidl_info); - g_proxy_tidl_info = NULL; - - free(g_stub_tidl_info); - g_stub_tidl_info = NULL; - - pthread_mutex_unlock(&g_tidl_mutex); - - return VC_ERROR_NONE; -} - -static void __request_tidl_connect() -{ - if (g_proxy_tidl_info->connection_requesting) { - return; - } - - int ret = rpc_port_proxy_vc_mgr_connect(g_proxy_tidl_info->rpc_h); - SLOG(LOG_INFO, TAG_VCM, "[INFO] Request connection to stub. ret(%d)", ret); - - if (0 == ret) { - g_proxy_tidl_info->connection_requesting = true; - } -} - -static int __create_callback_handles() -{ - if (NULL != g_proxy_tidl_info->notify_cb_h) { - rpc_port_proxy_vc_mgr_notify_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->notify_cb_h); - g_proxy_tidl_info->notify_cb_h = NULL; - } - - if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_notify_cb_create(&g_proxy_tidl_info->notify_cb_h)) { - return VC_ERROR_OUT_OF_MEMORY; - } - - rpc_port_proxy_vc_mgr_notify_cb_set_callback(g_proxy_tidl_info->notify_cb_h, __notify_cb, NULL); - - rpc_port_proxy_vc_mgr_notify_cb_set_once(g_proxy_tidl_info->notify_cb_h, false); - - if (NULL != g_proxy_tidl_info->send_buffer_cb_h) { - rpc_port_proxy_vc_mgr_send_buffer_cb_dispose(g_proxy_tidl_info->rpc_h, g_proxy_tidl_info->send_buffer_cb_h); - g_proxy_tidl_info->send_buffer_cb_h = NULL; - } - - if (RPC_PORT_ERROR_NONE != rpc_port_proxy_vc_mgr_send_buffer_cb_create(&g_proxy_tidl_info->send_buffer_cb_h)) { - return VC_ERROR_OUT_OF_MEMORY; - } - - rpc_port_proxy_vc_mgr_send_buffer_cb_set_callback(g_proxy_tidl_info->send_buffer_cb_h, __send_buffer_cb, NULL); - - rpc_port_proxy_vc_mgr_send_buffer_cb_set_once(g_proxy_tidl_info->send_buffer_cb_h, false); - - return VC_ERROR_NONE; -} - -static int __invoke_register_callback() -{ - if (g_proxy_tidl_info->register_callback_invoked) { - SLOG(LOG_ERROR, TAG_VCM, "[INFO] Already register callback is invoked"); - return VC_ERROR_NONE; - } - - int ret = __create_callback_handles(g_proxy_tidl_info); - if (VC_ERROR_NONE != ret) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create callback handle. ret(%d)", ret); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_register_cb(g_proxy_tidl_info->rpc_h, getpid(), g_proxy_tidl_info->notify_cb_h, g_proxy_tidl_info->send_buffer_cb_h); - g_proxy_tidl_info->register_callback_invoked = true; - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_hello() -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_hello"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get proxy tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Proxy Not Connected"); - __request_tidl_connect(); - return VC_ERROR_OPERATION_FAILED; - } - - if (VC_ERROR_NONE != __invoke_register_callback()) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to invoke register callback"); - return VC_ERROR_OPERATION_FAILED; - } - - if (NULL == g_stub_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get stub tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_stub_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stub Not Connected"); - __register_stub_callback(); - return VC_ERROR_OPERATION_FAILED; - } - - SLOG(LOG_DEBUG, TAG_VCM, ">>>>> VCM Hello"); - - SLOG(LOG_DEBUG, TAG_VCM, "<<<<"); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_initialize"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - int tmp_service_state = 0; - int tmp_forground = 0; - int tmp_daemon_pid = 0; - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, audio_streaming_mode, &tmp_service_state, &tmp_forground, &tmp_daemon_pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - *service_state = tmp_service_state; - *foreground = tmp_forground; - *daemon_pid = tmp_daemon_pid; - - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc manager initialize: service_state(%d), foreground(%d), daemon_pid(%d)", *service_state, *foreground, *daemon_pid); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_finalize(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_finalize"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_command(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_command"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_unset_command(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_unset_command"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_demandable_client(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_demandable_client"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_type"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_audio_type"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - char *tmp = NULL; - if (0 != rpc_port_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get audio type : Success"); - - *audio_type = tmp; - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_private_data(int pid, const char* key, const char* data) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_private_data"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_set_private_data(g_proxy_tidl_info->rpc_h, pid, key, data); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_get_private_data"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - char *tmp = NULL; - if (0 != rpc_port_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get private data : Success"); - - *data = tmp; - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_client_info(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_client_info"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_domain(int pid, const char* domain) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_domain"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_do_action(int pid, vc_send_event_type_e type, char* send_event) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_do_action"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_do_action(g_proxy_tidl_info->rpc_h, pid, type, send_event); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_start"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_start(g_proxy_tidl_info->rpc_h, pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_stop(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_stop"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_cancel(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_cancel"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_request_set_audio_streaming_mode"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_set_audio_streaming_mode(g_proxy_tidl_info->rpc_h, pid, mode); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_send_result_selection(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_send_result_selection(g_proxy_tidl_info->rpc_h, pid); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_result_selection"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - gchar *gEncodedRequest = g_base64_encode((const guchar*)request, strlen(request)); - - rpc_port_proxy_vc_mgr_invoke_send_specific_engine_request(g_proxy_tidl_info->rpc_h, pid, engine_app_id, event, gEncodedRequest); - - if (gEncodedRequest) - g_free(gEncodedRequest); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_utterance_status"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_vc_mgr_invoke_send_utterance_status(g_proxy_tidl_info->rpc_h, utt_id, utt_status); - - return VC_ERROR_NONE; -} - -int vc_mgr_tidl_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len) -{ - SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] vc_mgr_tidl_send_audio_streaming"); - - if (NULL == g_proxy_tidl_info) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!g_proxy_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - rpc_port_proxy_array_char_h data = NULL; - rpc_port_proxy_array_char_create(&data); - if (NULL == data) { - SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create data handle"); - return VC_ERROR_OUT_OF_MEMORY; - } - - if (NULL != buffer && 0 < len) { - rpc_port_proxy_array_char_set(data, (char*)buffer, len); - } else { - SLOG(LOG_ERROR, TAG_VCM, "[TIDL] buffer is empty"); - } - - rpc_port_proxy_vc_mgr_invoke_send_audio_streaming(g_proxy_tidl_info->rpc_h, pid, event, data); - rpc_port_proxy_array_char_destroy(data); - - return VC_ERROR_NONE; -} diff --git a/client/vc_mgr_tidl.h b/client/vc_mgr_tidl.h deleted file mode 100644 index fd91d7f..0000000 --- a/client/vc_mgr_tidl.h +++ /dev/null @@ -1,85 +0,0 @@ -/* -* 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_TIDL_H_ -#define __VC_TIDL_H_ - -#include "voice_control_manager_internal.h" - - -#ifdef __cplusplus -extern "C" { -#endif - -int vc_mgr_tidl_open_connection(); - -int vc_mgr_tidl_close_connection(); - - -int vc_mgr_tidl_request_hello(); - -int vc_mgr_tidl_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid); - -int vc_mgr_tidl_request_finalize(int pid); - -int vc_mgr_tidl_request_set_command(int pid); - -int vc_mgr_tidl_request_unset_command(int pid); - -int vc_mgr_tidl_request_demandable_client(int pid); - -int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type); - -int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type); - -int vc_mgr_tidl_request_set_private_data(int pid, const char* key, const char* data); - -int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data); - -int vc_mgr_tidl_request_set_client_info(int pid); - -int vc_mgr_tidl_request_set_domain(int pid, const char* domain); - -int vc_mgr_tidl_request_do_action(int pid, vc_send_event_type_e type, char* send_event); - -int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type); - -int vc_mgr_tidl_request_stop(int pid); - -int vc_mgr_tidl_request_cancel(int pid); - -int vc_mgr_tidl_send_result(int pid, int cmd_type, int result_id); - -int vc_mgr_tidl_send_result_selection(int pid); - -int vc_mgr_tidl_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request); - -int vc_mgr_tidl_request_start_feedback(int pid); - -int vc_mgr_tidl_request_stop_feedback(int pid); - -int vc_mgr_tidl_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status); - -int vc_mgr_tidl_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len); - -int vc_mgr_tidl_request_set_audio_streaming_mode(int pid, vc_audio_streaming_mode_e mode); - -#ifdef __cplusplus -} -#endif - -#endif /* __VC_TIDL_H_ */ diff --git a/common/vc_defs.h b/common/vc_defs.h index 0f906d6..4570918 100644 --- a/common/vc_defs.h +++ b/common/vc_defs.h @@ -19,7 +19,6 @@ #define __VC_DEFS_H__ #include -#include #ifdef __cplusplus extern "C" { @@ -27,7 +26,7 @@ extern "C" { /****************************************************************************************** -* Definitions for IPC +* Definitions for Dbus *******************************************************************************************/ #define VC_CLIENT_SERVICE_NAME "org.tizen.voice.vcclient" @@ -50,8 +49,6 @@ extern "C" { #define VC_SETTING_SERVICE_OBJECT_PATH "/org/tize/voice/vcsetting" #define VC_SETTING_SERVICE_INTERFACE "org.tizen.voice.vcsetting" -#define VC_SERVER_ENGINE_DEFAULT "org.tizen.vc-engine-default" - /****************************************************************************************** * Definitions for Vconf Keys *******************************************************************************************/ @@ -165,26 +162,6 @@ extern "C" { #define VC_MANAGER_METHOD_SEND_AUDIO_STREAMING "vc_manager_method_send_audio_streaming" #define VC_MANAGER_METHOD_CHANGE_SYSTEM_VOLUME "vc_manager_method_change_system_volume" -#define VC_MANAGER_BUNDLE_METHOD "vc_manager_bundle_method" -#define VC_MANAGER_BUNDLE_MESSAGE "vc_manager_bundle_message" -#define VC_MANAGER_BUNDLE_EVENT "vc_manager_bundle_event" -#define VC_MANAGER_BUNDLE_PRE_RESULT "vc_manager_bundle_pre_result" -#define VC_MANAGER_BUNDLE_ENGINE_APP_ID "vc_manager_bundle_engine_app_id" -#define VC_MANAGER_BUNDLE_RESULT "vc_manager_bundle_result" -#define VC_MANAGER_BUNDLE_DISP_TEXT "vc_manager_bundle_disp_text" -#define VC_MANAGER_BUNDLE_UTT_TEXT "vc_manager_bundle_utt_text" -#define VC_MANAGER_BUNDLE_CONTINUOUS "vc_manager_bundle_continuous" -#define VC_MANAGER_BUNDLE_REASON "vc_manager_bundle_reason" -#define VC_MANAGER_BUNDLE_DAEMON_PID "vc_manager_bundle_daemon_pid" -#define VC_MANAGER_BUNDLE_ERROR_MESSAGE "vc_manager_bundle_error_message" -#define VC_MANAGER_BUNDLE_KEY "vc_manager_bundle_key" -#define VC_MANAGER_BUNDLE_PRIVATE_DATA "vc_manager_bundle_private_data" -#define VC_MANAGER_BUNDLE_AUDIO_CHANNEL "vc_manager_bundle_audio_channel" -#define VC_MANAGER_BUNDLE_AUDIO_TYPE "vc_manager_bundle_audio_type" -#define VC_MANAGER_BUNDLE_AUDIO_RATE "vc_manager_bundle_audio_rate" -#define VC_MANAGER_BUNDLE_UTTID "vc_manager_bundle_uttid" -#define VC_MANAGER_BUNDLE_BUFFER "vc_manager_bundle_buffer" - #define VCD_MANAGER_METHOD_HELLO "vcd_manager_method_hello" #define VCD_MANAGER_METHOD_SPEECH_DETECTED "vcd_manager_method_speech_detected" #define VCD_MANAGER_METHOD_ALL_RESULT "vcd_manager_method_all_result" @@ -254,7 +231,6 @@ extern "C" { #define VC_NO_FOREGROUND_PID -1 #define VC_BASE_LANGUAGE "en_US" #define VC_RETRY_COUNT 5 -#define VC_RETRY_MIN_COUNT 2 #define VC_RUNTIME_INFO_NO_FOREGROUND -1 #define VC_CONNECTION_RETRY_COUNT 10 #define VC_INVALID_TTS_UID 0 diff --git a/packaging/voice-control.spec b/packaging/voice-control.spec index d776104..9c5e914 100644 --- a/packaging/voice-control.spec +++ b/packaging/voice-control.spec @@ -36,9 +36,6 @@ BuildRequires: pkgconfig(pkgmgr-installer) BuildRequires: pkgconfig(vconf) BuildRequires: cmake BuildRequires: pkgconfig(gmock) -BuildRequires: tidl -BuildRequires: pkgconfig(rpc-port) -BuildRequires: pkgconfig(bundle) %if 0%{?gcov:1} BuildRequires: lcov @@ -114,13 +111,6 @@ GTest for Voice Control %setup -q -n %{name}-%{version} cp %{SOURCE1001} %{SOURCE1002} . -tidlc -p -l C -i tidl/vc_mgr.tidl -o vc_mgr_proxy -tidlc -s -l C -i tidl/vc_mgr.tidl -o vcd_mgr_stub -tidlc -s -l C -i tidl/vcd_mgr.tidl -o vc_mgr_stub -tidlc -p -l C -i tidl/vcd_mgr.tidl -o vcd_mgr_proxy - -mv vc_* client -mv vcd_* server %build %if 0%{?gcov:1} diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index c557c71..b5e14ce 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -11,9 +11,6 @@ SET(SRCS vcd_config.c vcd_dbus_server.c vcd_dbus.c - vcd_tidl.c - vcd_mgr_stub.c - vcd_mgr_proxy.c vcd_engine_agent.c # vcd_main.c vcd_recorder.c diff --git a/server/vcd_client_data.c b/server/vcd_client_data.c index ddb298b..202c2e0 100644 --- a/server/vcd_client_data.c +++ b/server/vcd_client_data.c @@ -31,9 +31,6 @@ static GSList* g_widget_list = NULL; static manager_info_s g_manager; -/* Manager IPC info */ -static manager_tidl_info_s* g_mgr_tidl_info = NULL; - /* Command list */ static current_commands_list_s g_cur_cmd_list; @@ -256,141 +253,6 @@ char* vcd_client_manager_get_result_text() return g_result_text; } -int vcd_client_manger_create_tidl_info(int pid) -{ - /*Check already created*/ - if (NULL != g_mgr_tidl_info) { - SLOG(LOG_WARN, TAG_VCD, "[Client Data] Manager tidl info pid is already registered"); - if (pid != g_mgr_tidl_info->pid) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Manager pid is different"); - return VCD_ERROR_OPERATION_FAILED; - } - return VCD_ERROR_NONE; - } - - SLOG(LOG_INFO, TAG_VCD, "[Client Data] There is no manager tidl info. Create new one."); - g_mgr_tidl_info = (manager_tidl_info_s*)calloc(1, sizeof(manager_tidl_info_s)); - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to allocate memory"); - return VCD_ERROR_OUT_OF_MEMORY; - } - - g_mgr_tidl_info->pid = pid; - g_mgr_tidl_info->notify_cb = NULL; - g_mgr_tidl_info->notify_cb_user_data = NULL; - g_mgr_tidl_info->send_buffer_cb = NULL; - g_mgr_tidl_info->send_buffer_cb_user_data = NULL; - - g_mgr_tidl_info->connected = false; - g_mgr_tidl_info->connection_requesting = false; - g_mgr_tidl_info->rpc_h = NULL; - - SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new manager tidl info. pid(%d)", pid); - - return VCD_ERROR_NONE; -} - -int vcd_client_manager_set_tidl_notify_cb(rpc_port_stub_vc_mgr_notify_cb_h callback, void* user_data) -{ - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no manager tidl info"); - return VCD_ERROR_INVALID_PARAMETER; - } - - int ret = -1; - ret = rpc_port_stub_vc_mgr_notify_cb_clone(callback, &(g_mgr_tidl_info->notify_cb)); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to clone notify callback. ret(%d)", ret); - } else { - SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to clone notify callback. ret(%d)", ret); - } - g_mgr_tidl_info->notify_cb_user_data = user_data; - - return VCD_ERROR_NONE; -} - -int vcd_client_manager_unset_tidl_notify_cb() -{ - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no manager tidl info"); - return VCD_ERROR_INVALID_PARAMETER; - } - - int ret = -1; - ret = rpc_port_stub_vc_mgr_notify_cb_destroy(g_mgr_tidl_info->notify_cb); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to destroy notify callback. ret(%d)", ret); - } else { - SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to destroy notify callback. ret(%d)", ret); - } - g_mgr_tidl_info->notify_cb = NULL; - g_mgr_tidl_info->notify_cb_user_data = NULL; - - return VCD_ERROR_NONE; -} - -int vcd_client_manager_set_tidl_send_buffer_cb(rpc_port_stub_vc_mgr_send_buffer_cb_h callback, void* user_data) -{ - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no manager tidl info"); - return VCD_ERROR_INVALID_PARAMETER; - } - - int ret = -1; - ret = rpc_port_stub_vc_mgr_send_buffer_cb_clone(callback, &(g_mgr_tidl_info->send_buffer_cb)); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to clone feedback callback. ret(%d)", ret); - } else { - SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to clone feedback callback. ret(%d)", ret); - } - g_mgr_tidl_info->send_buffer_cb_user_data = user_data; - - return VCD_ERROR_NONE; -} - -int vcd_client_manager_unset_tidl_send_buffer_cb() -{ - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no manager tidl info"); - return VCD_ERROR_INVALID_PARAMETER; - } - - int ret = -1; - ret = rpc_port_stub_vc_mgr_send_buffer_cb_destroy(g_mgr_tidl_info->send_buffer_cb); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to destroy feedback callback. ret(%d)", ret); - } else { - SLOG(LOG_INFO, TAG_VCD, "[Client Data] Succeed to destroy feedback callback. ret(%d)", ret); - } - g_mgr_tidl_info->send_buffer_cb = NULL; - g_mgr_tidl_info->send_buffer_cb_user_data = NULL; - - return VCD_ERROR_NONE; -} - -int vcd_client_manager_delete_tidl_info() -{ - if (NULL == g_mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] There is no manager tidl info"); - return VCD_ERROR_INVALID_PARAMETER; - } - - if (0 != rpc_port_proxy_vcd_mgr_destroy(g_mgr_tidl_info->rpc_h)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to destroy tidl handle"); - } - - g_mgr_tidl_info->rpc_h = NULL; - free(g_mgr_tidl_info); - g_mgr_tidl_info = NULL; - - return 0; -} - -manager_tidl_info_s* vcd_client_manager_get_tidl_info() -{ - return g_mgr_tidl_info; -} - static void __vcd_client_release_each_commands(GSList** cmds) { GSList *iter = NULL; diff --git a/server/vcd_client_data.h b/server/vcd_client_data.h index 260c984..6060c81 100644 --- a/server/vcd_client_data.h +++ b/server/vcd_client_data.h @@ -21,8 +21,6 @@ #include #include "vc_command.h" #include "vc_info_parser.h" -#include "vcd_mgr_stub.h" -#include "vcd_mgr_proxy.h" #ifdef __cplusplus extern "C" { @@ -67,20 +65,6 @@ typedef struct { bool asr_result_enabled; } widget_info_s; -typedef struct { - int pid; - - rpc_port_stub_vc_mgr_notify_cb_h notify_cb; - void* notify_cb_user_data; - rpc_port_stub_vc_mgr_send_buffer_cb_h send_buffer_cb; - void* send_buffer_cb_user_data; - - bool connected; - bool connection_requesting; - - rpc_port_proxy_vcd_mgr_h rpc_h; -} manager_tidl_info_s; - typedef enum { VCD_RECOGNITION_MODE_STOP_BY_SILENCE, /**< Default mode */ VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT, /**< Restart recognition after rejected result */ @@ -147,20 +131,6 @@ char* vcd_client_manager_get_result_text(); bool vcd_client_manager_is_system_command_valid(int pid); -int vcd_client_manger_create_tidl_info(int pid); - -int vcd_client_manager_set_tidl_notify_cb(rpc_port_stub_vc_mgr_notify_cb_h callback, void* user_data); - -int vcd_client_manager_unset_tidl_notify_cb(); - -int vcd_client_manager_set_tidl_send_buffer_cb(rpc_port_stub_vc_mgr_send_buffer_cb_h callback, void* user_data); - -int vcd_client_manager_unset_tidl_send_buffer_cb(); - -int vcd_client_manager_delete_tidl_info(); - -manager_tidl_info_s* vcd_client_manager_get_tidl_info(); - /* * client API */ diff --git a/server/vcd_dbus.c b/server/vcd_dbus.c index b37e486..9ac4f0c 100755 --- a/server/vcd_dbus.c +++ b/server/vcd_dbus.c @@ -18,7 +18,6 @@ #include "vcd_client_data.h" #include "vcd_dbus.h" #include "vcd_dbus_server.h" -#include "vcd_tidl.h" #include "vcd_main.h" @@ -29,7 +28,7 @@ static Ecore_Fd_Handler* g_dbus_fd_handler = NULL; static int g_waiting_time = 3000; -// static int g_volume_count = 0; +static int g_volume_count = 0; static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type) @@ -121,8 +120,7 @@ int vcdc_send_hello(int pid, vcd_client_type_e type) } else if (VCD_CLIENT_TYPE_WIDGET == type) { msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET); } else if (VCD_CLIENT_TYPE_MANAGER == type) { - vcdc_tidl_send_hello(pid, type); - return VCD_ERROR_NONE; + msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER); } else { SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid"); return -1; @@ -230,6 +228,48 @@ int vcdc_send_show_tooltip(int pid, bool show) return 0; } +int vcdc_send_set_volume(int manger_pid, float volume) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg = NULL; + + /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */ + + msg = dbus_message_new_signal( + VC_MANAGER_SERVICE_OBJECT_PATH, + VC_MANAGER_SERVICE_INTERFACE, + VCD_MANAGER_METHOD_SET_VOLUME); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + dbus_message_unref(msg); + return -1; + } else { + if (20 == g_volume_count) { + SLOG(LOG_INFO, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume); + g_volume_count = 0; + } + + dbus_connection_flush(g_conn_sender); + + g_volume_count++; + } + + dbus_message_unref(msg); + + return 0; +} + int vcdc_send_result(int pid, int manager_pid, int cmd_type) { if (0 != __dbus_check()) { @@ -244,9 +284,7 @@ int vcdc_send_result(int pid, int manager_pid, int cmd_type) case VC_COMMAND_TYPE_FOREGROUND: case VC_COMMAND_TYPE_BACKGROUND: if (pid == manager_pid) { - // msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER); - vcdc_tidl_send_result(pid, manager_pid, cmd_type); - return 0; + msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER); } else { msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL); } @@ -257,10 +295,8 @@ int vcdc_send_result(int pid, int manager_pid, int cmd_type) case VC_COMMAND_TYPE_SYSTEM: case VC_COMMAND_TYPE_SYSTEM_BACKGROUND: case VC_COMMAND_TYPE_EXCLUSIVE: - // msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER); - // break; - vcdc_tidl_send_result(pid, manager_pid, cmd_type); - return 0; + msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER); + break; default: SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type); @@ -348,6 +384,241 @@ int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_typ } } +int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* msg = NULL; + + msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + return 0; +} + +int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result) +{ + SLOG(LOG_INFO, TAG_VCD, "[VCDC] send specific engine result to manager, mgr pid(%d), engine app id(%s), event(%s), result(%s),", + manager_pid, engine_app_id, event, result); + + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* msg = NULL; + + msg = __get_message(manager_pid, VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + gchar *gEncodedResult = g_base64_encode((const guchar*)result, strlen(result)); + + dbus_message_append_args(msg, DBUS_TYPE_STRING, &engine_app_id, DBUS_TYPE_STRING, &event, DBUS_TYPE_STRING, &gEncodedResult, DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + if (gEncodedResult) + g_free(gEncodedResult); + dbus_message_unref(msg); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + if (gEncodedResult) + g_free(gEncodedResult); + + dbus_message_unref(msg); + + return 0; +} + +int vcdc_send_result_to_manager(int manger_pid, int result_type) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* msg = NULL; + + msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + SLOG(LOG_INFO, TAG_VCD, "[Dbus] send result : result type(%d)", result_type); + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return 0; +} + +int vcdc_send_speech_detected(int manger_pid) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + /* Send to manager */ + DBusMessage* msg = NULL; + + msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return 0; +} + +int vcdc_send_service_state(vcd_state_e state) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* msg = NULL; + + msg = __get_message(vcd_client_manager_get_pid(), VCD_MANAGER_METHOD_SET_SERVICE_STATE, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to manager : state(%d)", state); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + /* Send to client */ + msg = NULL; + + msg = dbus_message_new_signal( + VC_CLIENT_SERVICE_OBJECT_PATH, + VC_CLIENT_SERVICE_INTERFACE, + VCD_METHOD_SET_SERVICE_STATE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to client : state(%d)", state); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + msg = NULL; + + /* Send to widget client */ + msg = dbus_message_new_signal( + VC_WIDGET_SERVICE_OBJECT_PATH, + VC_WIDGET_SERVICE_INTERFACE, + VCD_WIDGET_METHOD_SET_SERVICE_STATE); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to widget client : state(%d)", state); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return 0; +} + int vcdc_send_manager_pid(int manager_pid) { DBusError err; @@ -381,6 +652,71 @@ int vcdc_send_manager_pid(int manager_pid) return 0; } +int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* msg = NULL; + + msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + SLOG(LOG_INFO, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous); + + char* disp_null = NULL; + char* utt_null = NULL; + int ret = VCD_ERROR_NONE; + if (NULL == disp_text) { + disp_null = strdup("NNUULLLL"); + disp_text = disp_null; + } + + if (NULL == utt_text) { + utt_null = strdup("NNUULLLL"); + utt_text = utt_null; + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &disp_text, + DBUS_TYPE_STRING, &utt_text, + DBUS_TYPE_INT32, &continuous, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + if (NULL != disp_null) { + free(disp_null); + disp_null = NULL; + } + + if (NULL != utt_null) { + free(utt_null); + utt_null = NULL; + } + + return ret; +} + int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg) { SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal to manager"); @@ -456,32 +792,30 @@ int vcdc_send_error_signal(int reason, char *err_msg) DBusMessage* msg = NULL; - // msg = dbus_message_new_signal( - // VC_MANAGER_SERVICE_OBJECT_PATH, - // VC_MANAGER_SERVICE_INTERFACE, - // VCD_MANAGER_METHOD_ERROR); - - // if (NULL == msg) { - // SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); - // return VCD_ERROR_OUT_OF_MEMORY; - // } + msg = dbus_message_new_signal( + VC_MANAGER_SERVICE_OBJECT_PATH, + VC_MANAGER_SERVICE_INTERFACE, + VCD_MANAGER_METHOD_ERROR); - // daemon_pid = getpid(); - // dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID); + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } - // if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { - // SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); - // return VCD_ERROR_OPERATION_FAILED; - // } else { - // SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg); - // dbus_connection_flush(g_conn_sender); - // } + daemon_pid = getpid(); + dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID); - // dbus_message_unref(msg); + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg); + dbus_connection_flush(g_conn_sender); + } - // msg = NULL; + dbus_message_unref(msg); - vcdc_tidl_send_error(reason, err_msg); + msg = NULL; msg = dbus_message_new_signal( VC_CLIENT_SERVICE_OBJECT_PATH, VC_CLIENT_SERVICE_INTERFACE, @@ -570,6 +904,188 @@ int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg) return VCD_ERROR_NONE; } +int vcdc_send_request_set_private_data(int pid, const char* key, const char* data) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg = NULL; + msg = __get_message(pid, VCD_MANAGER_METHOD_SET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER); + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_STRING, &data, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send request set private data"); + dbus_message_unref(msg); + return VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send request set private data"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return VCD_ERROR_NONE; +} + +int vcdc_send_request_get_private_data(int pid, const char* key, char** data) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg = NULL; + msg = __get_message(pid, VCD_MANAGER_METHOD_GET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER); + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_INVALID); + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + int result = -1; + char* temp = NULL; + + result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message); + if (NULL != err.name) { + if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available"); + dbus_error_free(&err); + return VCD_ERROR_NONE; + } + } + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &temp, DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VCD_ERROR_OPERATION_FAILED; + } + + dbus_message_unref(result_msg); + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] Result message is NULL. Client is not available"); + } + + if (NULL != data && NULL != temp) { + *data = strdup(temp); + } + + return result; +} + +int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_audio_channel_e channel, vce_audio_type_e audio_type) +{ + SLOG(LOG_INFO, TAG_VCD, "[Dbus] Send TTS feedback audio format : manager_pid(%d), rate(%d), audio channel(%d), audio type(%d)", manager_pid, rate, channel, audio_type); + + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + /* make dbus message */ + DBusMessage* msg = NULL; + msg = __get_message(manager_pid, VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT, VCD_CLIENT_TYPE_MANAGER); + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &rate, + DBUS_TYPE_INT32, &channel, + DBUS_TYPE_INT32, &audio_type, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + int ret = VCD_ERROR_NONE; + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return ret; +} + +int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) +{ + SLOG(LOG_INFO, TAG_VCD, "[Dbus] Send TTS feedback streaming : manager_pid(%d), pid(%d), utt_id(%d) feedback event(%d), buffer(%p), length(%d)", manager_pid, pid, utt_id, event, buffer, len); + + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusError err; + dbus_error_init(&err); + + /* make dbus message */ + DBusMessage* msg = NULL; + msg = __get_message(manager_pid, VCD_MANAGER_METHOD_FEEDBACK_STREAMING, VCD_CLIENT_TYPE_MANAGER); + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + dbus_message_append_args(msg, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &utt_id, + DBUS_TYPE_INT32, &event, + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, + &buffer, len, + DBUS_TYPE_INVALID); + + dbus_message_set_no_reply(msg, TRUE); + + int ret = VCD_ERROR_NONE; + + if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send"); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send"); + dbus_connection_flush(g_conn_sender); + } + + dbus_message_unref(msg); + + return ret; +} + int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) { SLOG(LOG_INFO, TAG_VCD, "[Dbus] Send TTS feedback streaming : pid(%d), utt_id(%d), feedback event(%d), buffer(%p), length(%d)", pid, utt_id, event, buffer, len); @@ -633,6 +1149,73 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO)) vcd_dbus_server_hello(g_conn_listener, msg); + /* manager event */ + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE)) + vcd_dbus_server_mgr_initialize(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE)) + vcd_dbus_server_mgr_finalize(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND)) + vcd_dbus_server_mgr_set_command(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND)) + vcd_dbus_server_mgr_unset_command(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE)) + vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE)) + vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE)) + vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO)) + vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA)) + vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA)) + vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START)) + vcd_dbus_server_mgr_start(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP)) + vcd_dbus_server_mgr_stop(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL)) + vcd_dbus_server_mgr_cancel(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION)) + vcd_dbus_server_mgr_result_selection(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN)) + vcd_dbus_server_mgr_set_domain(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION)) + vcd_dbus_server_mgr_do_action(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SPECIFIC_ENGINE_REQUEST)) + vcd_dbus_server_mgr_send_specific_engine_request(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START_FEEDBACK)) + vcd_dbus_server_mgr_start_feedback(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP_FEEDBACK)) + vcd_dbus_server_mgr_stop_feedback(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SEND_AUDIO_STREAMING)) + vcd_dbus_server_mgr_send_audio_streaming(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CHANGE_SYSTEM_VOLUME)) + vcd_dbus_server_mgr_change_system_volume(g_conn_listener, msg); + + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_STREAMING_MODE)) + vcd_dbus_server_mgr_set_audio_streaming_mode(g_conn_listener, msg); + /* client event */ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE)) vcd_dbus_server_initialize(g_conn_listener, msg); diff --git a/server/vcd_dbus.h b/server/vcd_dbus.h index 7f07726..5fd1b7b 100644 --- a/server/vcd_dbus.h +++ b/server/vcd_dbus.h @@ -24,6 +24,12 @@ extern "C" { #endif +typedef enum { + VCD_CLIENT_TYPE_NORMAL, + VCD_CLIENT_TYPE_WIDGET, + VCD_CLIENT_TYPE_MANAGER +} vcd_client_type_e; + int vcd_dbus_open_connection(); int vcd_dbus_close_connection(); @@ -34,22 +40,43 @@ int vcdc_send_hello(int pid, vcd_client_type_e type); int vcdc_send_show_tooltip(int pid, bool show); +int vcdc_send_set_volume(int manger_pid, float volume); + int vcdc_send_result(int pid, int manager_pid, int cmd_type); int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_type, bool* is_consumed); +int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result); + +int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result); + +int vcdc_send_result_to_manager(int manger_pid, int result_type); + +int vcdc_send_speech_detected(int manger_pid); + int vcdc_send_error_signal(int reason, char *err_msg); +int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg); + int vcdc_send_error_signal_to_app(int pid, int reason, char *err_msg); +int vcdc_send_service_state(vcd_state_e state); + +int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous); + int vcdc_send_manager_pid(int manager_pid); -// int vcdc_send_request_get_private_data(int pid, const char* key, char** data); +int vcdc_send_request_set_private_data(int pid, const char* key, const char* data); + +int vcdc_send_request_get_private_data(int pid, const char* key, char** data); /* for TTS feedback */ +int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_audio_channel_e channel, vce_audio_type_e audio_type); + +int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); + int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); -// int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); #ifdef __cplusplus } diff --git a/server/vcd_dbus_server.c b/server/vcd_dbus_server.c index d5d4ac1..d30dd2b 100755 --- a/server/vcd_dbus_server.c +++ b/server/vcd_dbus_server.c @@ -17,7 +17,6 @@ #include "vcd_client_data.h" #include "vcd_dbus.h" -#include "vcd_tidl.h" #include "vcd_dbus_server.h" #include "vcd_main.h" #include "vcd_server.h" @@ -86,6 +85,853 @@ int vcd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg) return 0; } +/* +* Dbus Server functions for manager +*/ + +int vcd_dbus_server_mgr_initialize(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int streaming_mode; + int service_state; + int foreground; + int daemon_pid; + int ret = VCD_ERROR_OPERATION_FAILED; + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &streaming_mode, + DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Initialize"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr initialize : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + vcd_config_set_audio_streaming_mode((vcd_audio_streaming_mode_e)streaming_mode); + ret = vcd_server_mgr_initialize(pid, streaming_mode); + service_state = vcd_server_get_service_state(); + foreground = vcd_server_get_foreground(); + daemon_pid = getpid(); + + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, + DBUS_TYPE_INT32, &ret, + DBUS_TYPE_INT32, &service_state, + DBUS_TYPE_INT32, &foreground, + DBUS_TYPE_INT32, &daemon_pid, + DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_finalize(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Finalize"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr finalize : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid); + ret = vcd_server_mgr_finalize(pid); + } + + DBusMessage* reply; + + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_set_command(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set command"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set command : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid); + ret = vcd_server_mgr_set_command(pid); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + if (0 == ret) { + /* Append result and language */ + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_unset_command(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD manager unset command"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr unset command : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid); + ret = vcd_server_mgr_unset_command(pid); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + if (0 == ret) { + /* Append result and language */ + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_set_demandable_client(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set demandable client"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set demandable client : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid); + ret = vcd_server_mgr_set_demandable_client(pid); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + if (0 == ret) { + /* Append result and language */ + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_set_audio_type(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* audio_type = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set audio type"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &audio_type, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type); + ret = vcd_server_mgr_set_audio_type(pid, audio_type); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_get_audio_type(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* audio_type = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get audio type"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d)", pid); + ret = vcd_server_mgr_get_audio_type(pid, &audio_type); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, + DBUS_TYPE_INT32, &ret, + DBUS_TYPE_STRING, &audio_type, + DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), audio type(%s)", ret, audio_type); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + if (NULL != audio_type) free(audio_type); + + return 0; +} + +int vcd_dbus_server_mgr_set_client_info(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set client info"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set client info : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid); + ret = vcd_server_mgr_set_client_info(pid); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, + DBUS_TYPE_INT32, &ret, + DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_set_private_data(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* key = NULL; + char* data = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set private data"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_STRING, &data, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set private data : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data); + ret = vcd_server_mgr_set_private_data(pid, key, data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data"); + } + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_get_private_data(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* key = NULL; + char* data = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get private data"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &key, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key); + ret = vcd_server_mgr_get_private_data(pid, key, &data); + } + + char *temp_data = NULL; + if (NULL == data) { + SLOG(LOG_INFO, TAG_VCD, "[Dbus INFO] data parameter is NULL"); + temp_data = strdup("#NULL"); + } else { + temp_data = strdup(data); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, + DBUS_TYPE_INT32, &ret, + DBUS_TYPE_STRING, &temp_data, + DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), private data(%s)", ret, temp_data); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + if (NULL != data) { + free(data); + data = NULL; + } + if (NULL != temp_data) { + free(temp_data); + temp_data = NULL; + } + + return 0; +} + +int vcd_dbus_server_mgr_send_specific_engine_request(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* engine_app_id = NULL; + char* event = NULL; + char* request = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager specific engine request"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &engine_app_id, + DBUS_TYPE_STRING, &event, + DBUS_TYPE_STRING, &request, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr specific engine request : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + gsize decodingSize=0; + gchar *gDecodedRequest = (gchar *)g_base64_decode((const gchar *)request, &decodingSize); + if (gDecodedRequest) + { + ret = vcd_server_mgr_send_specific_engine_request(pid, engine_app_id, event, gDecodedRequest); + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr specific engine request : pid(%d), engine_app_id(%s), event(%s), request(%s), ret(%d)", pid, engine_app_id, event, gDecodedRequest, ret); + g_free(gDecodedRequest); + } + } + + return 0; +} + +int vcd_dbus_server_mgr_set_domain(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + char* domain = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set domain type"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_STRING, &domain, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set domain : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain); + ret = vcd_server_mgr_set_domain(pid, domain); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_do_action(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + int type = 0; + char* send_event = NULL; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager request to do action"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &type, + DBUS_TYPE_STRING, &send_event, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr request to do action : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event); + ret = vcd_server_mgr_do_action(pid, type, send_event); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to do action"); + } + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_start(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid = 0; + int recognition_mode = 0; + int exclusive = 0; + int start_by_client = 0; + int disabled_cmd_type = 0; + + int ret = VCD_ERROR_OPERATION_FAILED; + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager start"); + + dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &pid, + DBUS_TYPE_INT32, &recognition_mode, + DBUS_TYPE_INT32, &exclusive, + DBUS_TYPE_INT32, &start_by_client, + DBUS_TYPE_INT32, &disabled_cmd_type, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr start : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd check enabled or disabled command types. disabled cmd type(%d)", disabled_cmd_type); + vcd_server_mgr_set_disabled_command_type(pid, disabled_cmd_type); + + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive, start_by_client); + ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, (bool)exclusive, (bool)start_by_client); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_stop(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager stop"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr stop : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid); + ret = vcd_server_mgr_stop(); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_cancel(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int ret = VCD_ERROR_OPERATION_FAILED; + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager cancel"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr cancel : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid); + ret = vcd_server_mgr_cancel(); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + + if (0 == ret) { + SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "@@@"); + + return 0; +} + +int vcd_dbus_server_mgr_result_selection(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager result selection"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr result selection : get arguments error (%s)", err.message); + dbus_error_free(&err); + } else { + SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid); + vcd_server_mgr_result_select(); + } + return 0; +} + /* for TTS feedback */ int vcd_dbus_server_mgr_start_feedback(DBusConnection* conn, DBusMessage* msg) { diff --git a/server/vcd_dbus_server.h b/server/vcd_dbus_server.h index 0d0ec0a..dca8add 100644 --- a/server/vcd_dbus_server.h +++ b/server/vcd_dbus_server.h @@ -30,6 +30,45 @@ int vcd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg); /* * Dbus Server functions for manager */ + +int vcd_dbus_server_mgr_initialize(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_finalize(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_command(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_unset_command(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_demandable_client(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_audio_type(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_get_audio_type(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_client_info(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_private_data(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_get_private_data(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_domain(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_do_action(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_start(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_stop(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_cancel(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_result_selection(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_send_specific_engine_request(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_change_system_volume(DBusConnection* conn, DBusMessage* msg); + +int vcd_dbus_server_mgr_set_audio_streaming_mode(DBusConnection* conn, DBusMessage* msg); + /* for TTS feedback */ int vcd_dbus_server_mgr_start_feedback(DBusConnection* conn, DBusMessage* msg); diff --git a/server/vcd_engine_agent.c b/server/vcd_engine_agent.c index 6e45a4d..531dbdf 100644 --- a/server/vcd_engine_agent.c +++ b/server/vcd_engine_agent.c @@ -24,7 +24,6 @@ #include "vcd_main.h" #include "vcd_recorder.h" #include "vcd_dbus.h" -#include "vcd_tidl.h" #include "vce_internal.h" /* @@ -923,7 +922,7 @@ int vcd_engine_agent_start_recording() SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to start recorder : result(%d)", ret); vcd_engine_recognize_cancel(); /* Send error cb to manager */ - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail"); return ret; } diff --git a/server/vcd_main.h b/server/vcd_main.h index 7636495..70bcd18 100644 --- a/server/vcd_main.h +++ b/server/vcd_main.h @@ -98,12 +98,6 @@ struct vce_cmd_s { int index; }; -// TODO: move vcd_client_type_e to vcd_tidl.h after migrate from dbus to tidl done -typedef enum { - VCD_CLIENT_TYPE_NORMAL, - VCD_CLIENT_TYPE_WIDGET, - VCD_CLIENT_TYPE_MANAGER -} vcd_client_type_e; #ifdef __cplusplus } diff --git a/server/vcd_recorder.c b/server/vcd_recorder.c index 9c4845f..cadb81d 100644 --- a/server/vcd_recorder.c +++ b/server/vcd_recorder.c @@ -22,7 +22,6 @@ #include "vcd_client_data.h" #include "vcd_config.h" #include "vcd_dbus.h" -#include "vcd_tidl.h" #include "vcd_engine_agent.h" #include "vcd_recorder.h" #include "dependency_audio_manager.h" diff --git a/server/vcd_server.c b/server/vcd_server.c index 7f0d713..faf41e5 100644 --- a/server/vcd_server.c +++ b/server/vcd_server.c @@ -29,7 +29,6 @@ #include "vcd_config.h" #include "vcd_recorder.h" #include "vcd_dbus.h" -#include "vcd_tidl.h" #include "vce_internal.h" #include "voice_control_command_expand.h" @@ -146,9 +145,9 @@ static int __server_recorder_callback(const void* data, const unsigned int lengt ecore_timer_add(0, __cancel_by_interrupt, NULL); /* Send error cb to manager */ if (VCE_ERROR_OUT_OF_NETWORK == ret) { - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_TIMED_OUT, "voice_framework.error.engine.set_recording_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_TIMED_OUT, "voice_framework.error.engine.set_recording_fail"); } else { - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.set_recording_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.set_recording_fail"); } return 0; } @@ -1124,7 +1123,7 @@ int vcd_send_error(vce_error_e error, const char* msg, void *user_data) int pid = __get_tts_played_pid(); ret = vcdc_send_error_signal_to_app(pid, error, error_msg); } else { - ret = vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), error, error_msg); + ret = vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), error, error_msg); ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL); } @@ -1348,15 +1347,6 @@ int vcd_initialize(vce_request_callback_s *callback) } return VCD_ERROR_OPERATION_FAILED; } - - /* Open tidl connection */ - if (0 != vcd_mgr_tidl_open_connection()) { - SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to open tidl connection"); - if (TRUE != vcd_finalize()) { - SLOG(LOG_ERROR, TAG_VCD, "[Server Error] Fail to finalize"); - } - return VCD_ERROR_OPERATION_FAILED; - } // } vcd_config_set_service_state(VCD_STATE_READY); @@ -1436,16 +1426,11 @@ bool vcd_finalize() vcdc_send_service_state(VCD_STATE_NONE); } - /* Close dbus connection */ + /* Open dbus connection */ if (0 != vcd_dbus_close_connection()) { SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to close connection"); } - /* Close tidl connection */ - if (0 != vcd_mgr_tidl_close_connection()) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to close connection"); - } - SLOG(LOG_ERROR, TAG_VCD, "[Server] mode finalize"); return true; @@ -1913,7 +1898,7 @@ static int __start_internal_recognition() /* Send error cb to manager */ int pid = vcd_client_widget_get_foreground_pid(); if (-1 != pid) - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.collect_command_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.collect_command_fail"); return VCD_ERROR_OPERATION_FAILED; } @@ -1924,7 +1909,7 @@ static int __start_internal_recognition() /* Send error cb to manager */ int pid = vcd_client_widget_get_foreground_pid(); if (-1 != pid) - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.engine.set_commands_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.engine.set_commands_fail"); return VCD_ERROR_OPERATION_FAILED; } @@ -1944,7 +1929,7 @@ static int __start_internal_recognition() /* Send error cb to manager */ int pid = vcd_client_widget_get_foreground_pid(); if (-1 != pid) - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.start_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.start_fail"); return ret; } @@ -1959,7 +1944,7 @@ static int __start_internal_recognition() /* Send error cb to manager */ int pid = vcd_client_widget_get_foreground_pid(); if (-1 != pid) - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail"); + vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail"); return ret; } #endif @@ -2345,7 +2330,7 @@ int vcd_server_mgr_stop_feedback(void) return VCD_ERROR_NONE; } -int vcd_server_mgr_send_audio_streaming(int pid, int event, const char* buffer, unsigned int len) +int vcd_server_mgr_send_audio_streaming(int pid, int event, char* buffer, unsigned int len) { SLOG(LOG_INFO, TAG_VCD, "[DEBUG] Send Audio Streaming from Multi-assistant. event(%d), buffer(%p), len(%d)", event, &buffer, len); diff --git a/server/vcd_server.h b/server/vcd_server.h index 4f1286d..7597b3d 100644 --- a/server/vcd_server.h +++ b/server/vcd_server.h @@ -87,7 +87,7 @@ int vcd_server_mgr_start_feedback(void); int vcd_server_mgr_stop_feedback(void); /* for Multi-assistant */ -int vcd_server_mgr_send_audio_streaming(int pid, int event, const char* buffer, unsigned int len); +int vcd_server_mgr_send_audio_streaming(int pid, int event, char* buffer, unsigned int len); /* diff --git a/server/vcd_tidl.c b/server/vcd_tidl.c deleted file mode 100644 index d5917a5..0000000 --- a/server/vcd_tidl.c +++ /dev/null @@ -1,1204 +0,0 @@ -/* -* 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 "vcd_client_data.h" -#include "vcd_main.h" -#include "vcd_server.h" -#include "vcd_config.h" - -#include "vcd_tidl.h" -#include "vcd_mgr_stub.h" -#include "vcd_mgr_proxy.h" - -static rpc_port_stub_vc_mgr_callback_s g_mgr_callback; - -static pthread_mutex_t g_mgr_tidl_info_mutex = PTHREAD_MUTEX_INITIALIZER; - -static int g_volume_count = 0; - -static void __on_connected(rpc_port_proxy_vcd_mgr_h h, void *user_data) -{ - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] tidl proxy info not allocated"); - return; - } - - mgr_tidl_info->connected = true; - mgr_tidl_info->connection_requesting = false; - - SLOG(LOG_INFO, TAG_VCD, "Connected to manager"); -} - -static void __on_disconnected(rpc_port_proxy_vcd_mgr_h h, void *user_data) -{ - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] tidl proxy info not allocated"); - return; - } - - mgr_tidl_info->connected = false; - mgr_tidl_info->connection_requesting = false; - - SLOG(LOG_INFO, TAG_VCD, "Disonnected to manager"); -} - -static void __on_rejected(rpc_port_proxy_vcd_mgr_h h, void *user_data) -{ - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] tidl proxy info not allocated"); - return; - } - - mgr_tidl_info->connection_requesting = false; - - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Rejected from manager"); -} - -static rpc_port_proxy_vcd_mgr_h __create_rpc_port(const char* engine_app_id, manager_tidl_info_s* mgr_tidl_info) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] __create_rpc_port"); - rpc_port_proxy_vcd_mgr_callback_s rpc_callback = { - .connected = __on_connected, - .disconnected = __on_disconnected, - .rejected = __on_rejected - }; - - rpc_port_proxy_vcd_mgr_h handle = NULL; - if (0 != rpc_port_proxy_vcd_mgr_create(engine_app_id, &rpc_callback, NULL, &handle)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create proxy"); - return NULL; - } - - return handle; -} - -static void __request_tidl_connect_sync(manager_tidl_info_s* mgr_tidl_info) -{ - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] tidl proxy info not allocated"); - return; - } - - if (mgr_tidl_info->connection_requesting) { - return; - } - - int ret = rpc_port_proxy_vcd_mgr_connect_sync(mgr_tidl_info->rpc_h); - SLOG(LOG_INFO, TAG_VCD, "[INFO] Request connection to stub. ret(%d)", ret); - - if (0 == ret) { - mgr_tidl_info->connection_requesting = true; - } -} - -void __send_msg(bundle* msg, vcd_client_type_e type) -{ - SLOG(LOG_INFO, TAG_VCD, "[TIDL] send msg start"); - - if (VCD_CLIENT_TYPE_MANAGER == type) { - pthread_mutex_lock(&g_mgr_tidl_info_mutex); - - SLOG(LOG_INFO, TAG_VCD, "[TIDL] message to manager"); - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] tidl proxy info not allocated"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - rpc_port_stub_vc_mgr_notify_cb_h handle = mgr_tidl_info->notify_cb; - if (NULL == handle) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] notify callback handle is null"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - if (0 != rpc_port_stub_vc_mgr_notify_cb_invoke(handle, msg)) { - SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to send msg"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - } - - SLOG(LOG_INFO, TAG_VCD, "[TIDL] send msg end"); -} - -static void __vc_mgr_create_cb(rpc_port_stub_vc_mgr_context_h context, void *user_data) -{ - char *sender = NULL; - - rpc_port_stub_vc_mgr_context_get_sender(context, &sender); - if (!sender){ - SLOG(LOG_ERROR, TAG_VCD, "Sender is NULL"); - return; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@ Manager connect. appid(%s)", sender); - - free(sender); -} - -static void __vc_mgr_terminate_cb(rpc_port_stub_vc_mgr_context_h context, void *user_data) -{ - pthread_mutex_lock(&g_mgr_tidl_info_mutex); - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get manager tidl info."); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VC MANAGER FINALIZE. pid(%u)", mgr_tidl_info->pid); - - if (0 != vcd_client_manager_unset_tidl_notify_cb()) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to unset notify callback"); - } - - if (0 != vcd_client_manager_unset_tidl_send_buffer_cb()) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to unset send buffer callback"); - } - - if (0 != vcd_client_manager_delete_tidl_info()) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to delete manager tidl info"); - } - mgr_tidl_info = NULL; - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - - - char *sender = NULL; - rpc_port_stub_vc_mgr_context_get_sender(context, &sender); - if (!sender) - return; - - SLOG(LOG_INFO, TAG_VCD, "@@@ Manager disconnect. appid(%s)", sender); - - free(sender); -} - -static void __vc_mgr_register_cb_cb(rpc_port_stub_vc_mgr_context_h context, int pid, rpc_port_stub_vc_mgr_notify_cb_h notify_callback, rpc_port_stub_vc_mgr_send_buffer_cb_h send_buffer_callback, void *user_data) -{ - pthread_mutex_lock(&g_mgr_tidl_info_mutex); - SLOG(LOG_INFO, TAG_VCD, "@@@ VC MANAGER REGISTER CALLBACK"); - - int ret = -1; - ret = vcd_client_manger_create_tidl_info(pid); - - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create manager tidl info."); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get manager tidl info. pid(%d)", pid); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - char *sender = NULL; - rpc_port_stub_vc_mgr_context_get_sender(context, &sender); - - if (!sender){ - SLOG(LOG_ERROR, TAG_VCD, "Sender is NULL"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - return; - } - - mgr_tidl_info->rpc_h = __create_rpc_port(sender, mgr_tidl_info); - - if (NULL == mgr_tidl_info->rpc_h) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to create server proxy"); - } else { - SLOG(LOG_INFO, TAG_VCD, "[TIDL] rpc_h(%p), engine_app_id(%s)", mgr_tidl_info->rpc_h, sender); - } - - free(sender); - - if (0 != vcd_client_manager_set_tidl_notify_cb(notify_callback, user_data)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set notify callback"); - } else { - SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set notify callback."); - } - - if (0 != vcd_client_manager_set_tidl_send_buffer_cb(send_buffer_callback, user_data)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to set send buffer callback"); - } else { - SLOG(LOG_INFO, TAG_VCD, "[TIDL] Succeed to set send buffer callback."); - } - - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - - __request_tidl_connect_sync(mgr_tidl_info); - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static int __vc_mgr_initialize_cb(rpc_port_stub_vc_mgr_context_h context, int pid, int audio_streaming_mode, int *service_state, int *foreground, int *daemon_pid, void *user_data) -{ - SLOG(LOG_INFO, TAG_VCD, "@@@ VCD Manager Initialize"); - - int ret = -1; - - vcd_config_set_audio_streaming_mode((vcd_audio_streaming_mode_e)audio_streaming_mode); - ret = vcd_server_mgr_initialize(pid, audio_streaming_mode); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - *service_state = vcd_server_get_service_state(); - *foreground = vcd_server_get_foreground(); - *daemon_pid = getpid(); - - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, *service_state, *foreground, *daemon_pid); - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - return ret; -} - -static int __vc_mgr_finalize_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Finalize"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_finalize(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_set_command_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set command"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_set_command(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_unset_command_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager unset command"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_unset_command(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_set_demandable_client_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Set demandable client"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_set_demandable_client(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_set_audio_type_cb(rpc_port_stub_vc_mgr_context_h context, int pid, const char *audio_type, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set audio type"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type); - - int ret = -1; - - ret = vcd_server_mgr_set_audio_type(pid, audio_type); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_get_audio_type_cb(rpc_port_stub_vc_mgr_context_h context, int pid, char **audio_type, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get audio type"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d)", pid); - - int ret = -1; - char* tmp_audio_type = NULL; - - ret = vcd_server_mgr_get_audio_type(pid, &tmp_audio_type); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - free(tmp_audio_type); - return ret; - } - - *audio_type = strdup(tmp_audio_type); - free(tmp_audio_type); - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static void __vc_mgr_set_private_data_cb(rpc_port_stub_vc_mgr_context_h context, int pid, const char *key, const char *data, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set private data"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data); - - int ret = -1; - - ret = vcd_server_mgr_set_private_data(pid, key, data); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data"); - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static int __vc_mgr_get_private_data_cb(rpc_port_stub_vc_mgr_context_h context, int pid, const char *key, char **data, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager get private data"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key); - - int ret = -1; - char *temp_data = NULL; - - ret = vcd_server_mgr_get_private_data(pid, key, &temp_data); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - if (NULL == temp_data) { - SLOG(LOG_INFO, TAG_VCD, "data parameter is NULL"); - temp_data = strdup("#NULL"); - } - - *data = strdup(temp_data); - free(temp_data); - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_set_client_info_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set client info"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_set_client_info(pid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_set_domain_cb(rpc_port_stub_vc_mgr_context_h context, int pid, const char *domain, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set domain type"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain); - - int ret = -1; - - ret = vcd_server_mgr_set_domain(pid, domain); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static void __vc_mgr_do_action_cb(rpc_port_stub_vc_mgr_context_h context, int pid, int type, const char *send_event, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager request to do action"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event); - - int ret = -1; - - ret = vcd_server_mgr_do_action(pid, type, send_event); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static int __vc_mgr_start_cb(rpc_port_stub_vc_mgr_context_h context, int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager start"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd check enabled or disabled command types. disabled cmd type(%d)", disabled_cmd_type); - - int ret = -1; - - vcd_server_mgr_set_disabled_command_type(pid, disabled_cmd_type); - - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive_command_option, start_by_client); - ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, exclusive_command_option, start_by_client); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_stop_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager stop"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_stop(); - - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static int __vc_mgr_cancel_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager cancel"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid); - - int ret = -1; - - ret = vcd_server_mgr_cancel(); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - return ret; - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); - - return ret; -} - -static void __vc_mgr_set_audio_streaming_mode_cb(rpc_port_stub_vc_mgr_context_h context, int pid, int mode, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager set audio streaming mode"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio streaming mode : pid(%d) mode(%d)", pid, mode); - - vcd_config_set_audio_streaming_mode((vcd_audio_streaming_mode_e)mode); - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static void __vc_mgr_send_specific_engine_request_cb(rpc_port_stub_vc_mgr_context_h context, int pid, const char *engine_app_id, const char *event, const char *request, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager specific engine request"); - - int ret = -1; - gsize decodingSize = 0; - gchar *gDecodedRequest = (gchar *)g_base64_decode((const gchar *)request, &decodingSize); - - if (gDecodedRequest) { - ret = vcd_server_mgr_send_specific_engine_request(pid, engine_app_id, event, gDecodedRequest); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr specific engine request : pid(%d), engine_app_id(%s), event(%s), request(%s), ret(%d)", pid, engine_app_id, event, gDecodedRequest, ret); - g_free(gDecodedRequest); - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static void __vc_mgr_send_result_selection_cb(rpc_port_stub_vc_mgr_context_h context, int pid, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager result selection"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid); - - vcd_server_mgr_result_select(); - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static void __vc_mgr_send_utterance_status_cb(rpc_port_stub_vc_mgr_context_h context, int utt_id, int utt_status, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager send utterance status"); - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr send utterance status : utt_id(%d), utt_status(%d)", utt_id, utt_status); - // TODO: send parameter to client - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -static void __vc_mgr_send_audio_streaming_cb(rpc_port_stub_vc_mgr_context_h context, int pid, int event, rpc_port_stub_array_char_h data, void *user_data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager send audio streaming"); - - char* buffer = NULL; - int len = 0; - int ret = -1; - rpc_port_stub_array_char_get(data, &buffer, &len); - - SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len); - - ret = vcd_server_mgr_send_audio_streaming(pid, event, buffer, (unsigned int)len); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); - } - - SLOG(LOG_DEBUG, TAG_VCD, "@@@"); -} - -int vcd_mgr_tidl_open_connection() -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] vcd_tidl_open_connection"); - - g_mgr_callback.create = __vc_mgr_create_cb; - g_mgr_callback.terminate = __vc_mgr_terminate_cb; - g_mgr_callback.register_cb = __vc_mgr_register_cb_cb; - g_mgr_callback.initialize = __vc_mgr_initialize_cb; - g_mgr_callback.finalize = __vc_mgr_finalize_cb; - g_mgr_callback.set_command = __vc_mgr_set_command_cb; - g_mgr_callback.unset_command = __vc_mgr_unset_command_cb; - g_mgr_callback.demandable_client = __vc_mgr_set_demandable_client_cb; - g_mgr_callback.set_audio_type = __vc_mgr_set_audio_type_cb; - g_mgr_callback.get_audio_type = __vc_mgr_get_audio_type_cb; - g_mgr_callback.set_private_data = __vc_mgr_set_private_data_cb; - g_mgr_callback.get_private_data = __vc_mgr_get_private_data_cb; - g_mgr_callback.set_client_info = __vc_mgr_set_client_info_cb; - g_mgr_callback.set_domain = __vc_mgr_set_domain_cb; - g_mgr_callback.do_action = __vc_mgr_do_action_cb; - g_mgr_callback.start = __vc_mgr_start_cb; - g_mgr_callback.stop = __vc_mgr_stop_cb; - g_mgr_callback.cancel = __vc_mgr_cancel_cb; - g_mgr_callback.set_audio_streaming_mode = __vc_mgr_set_audio_streaming_mode_cb; - g_mgr_callback.send_specific_engine_request = __vc_mgr_send_specific_engine_request_cb; - g_mgr_callback.send_result_selection = __vc_mgr_send_result_selection_cb; - g_mgr_callback.send_utterance_status = __vc_mgr_send_utterance_status_cb; - g_mgr_callback.send_audio_streaming = __vc_mgr_send_audio_streaming_cb; - - int ret = -1; - int count = 0; - while (VC_RETRY_MIN_COUNT >= count) { - ret = rpc_port_stub_vc_mgr_register(&g_mgr_callback, NULL); - if (0 == ret) { - SLOG(LOG_DEBUG, TAG_VCD, "register callback"); - return VCD_ERROR_NONE; - } - usleep(100000); - count++; - } - - SLOG(LOG_ERROR, TAG_VCD, "Fail to register callback(%d)", ret); - return VCD_ERROR_OPERATION_FAILED; -} - -int vcd_mgr_tidl_close_connection() -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Close connection"); - rpc_port_stub_vc_mgr_unregister(); - - return VCD_ERROR_NONE; -} - -// TODO: remove _tidl after all dbus removed -int vcdc_tidl_send_hello(int pid, vcd_client_type_e type) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send hello"); - - char tmp_pid[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_pid, 10, "%d", pid); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_HELLO); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_pid); - - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_set_volume(int manager_pid, float volume) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Set volume"); - - char tmp_volume[20] = {0, }; - - bundle* msg = bundle_create(); - - snprintf(tmp_volume, 20, "%.6f", volume); - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_SET_VOLUME); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_volume); - - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - if (20 == g_volume_count) { - SLOG(LOG_INFO, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manager_pid, volume); - g_volume_count = 0; - } - g_volume_count++; - - bundle_free(msg); - - return VCD_ERROR_NONE; -} -// TODO: remove tidl after all dbus migrate to tidl -int vcdc_tidl_send_result(int pid, int manager_pid, int cmd_type) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send result"); - - bundle* msg = bundle_create(); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_RESULT); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send pre result to manager"); - - char tmp_event[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_event, 10, "%d", event); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_PRE_RESULT); - bundle_add_str(msg, VC_MANAGER_BUNDLE_EVENT, tmp_event); - bundle_add_str(msg, VC_MANAGER_BUNDLE_PRE_RESULT, pre_result); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send specific engine result to manager"); - - bundle* msg = bundle_create(); - - gchar *gEncodedResult = g_base64_encode((const guchar*)result, strlen(result)); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT); - bundle_add_str(msg, VC_MANAGER_BUNDLE_ENGINE_APP_ID, engine_app_id); - bundle_add_str(msg, VC_MANAGER_BUNDLE_EVENT, event); - bundle_add_str(msg, VC_MANAGER_BUNDLE_RESULT, gEncodedResult); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - if (gEncodedResult) - g_free(gEncodedResult); - - return VCD_ERROR_NONE; -} - -int vcdc_send_result_to_manager(int manager_pid, int result_type) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send result to manager"); - - char tmp_result[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_result, 10, "%d", result_type); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_ALL_RESULT); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_result); - - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_speech_detected(int manager_pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send speech detected"); - - bundle* msg = bundle_create(); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_SPEECH_DETECTED); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_service_state(vcd_state_e state) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send service state"); - - char tmp_state[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_state, 10, "%d", (int)state); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_SET_SERVICE_STATE); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_state); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_dialog(int manager_pid, int pid, const char* disp_text, const char* utt_text, int continuous) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send dialog"); - - char tmp_pid[10] = {0, }; - char tmp_continuous[10] = {0, }; - char* tmp_disp_text = NULL; - char* tmp_utt_text = NULL; - bundle* msg = bundle_create(); - snprintf(tmp_pid, 10, "%d", pid); - snprintf(tmp_continuous, 10, "%d", continuous); - - if (NULL == disp_text) { - tmp_disp_text = strdup("#NULL"); - } else { - tmp_disp_text = strdup(disp_text); - } - - if (NULL == utt_text) { - tmp_utt_text = strdup("#NULL"); - } else { - tmp_utt_text = strdup(utt_text); - } - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_DIALOG); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_pid); - bundle_add_str(msg, VC_MANAGER_BUNDLE_DISP_TEXT, tmp_disp_text); - bundle_add_str(msg, VC_MANAGER_BUNDLE_UTT_TEXT, tmp_utt_text); - bundle_add_str(msg, VC_MANAGER_BUNDLE_CONTINUOUS, tmp_continuous); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - free(tmp_disp_text); - free(tmp_utt_text); - - return VCD_ERROR_NONE; -} - -int vcdc_tidl_send_error_to_manager(int manager_pid, int reason, char *err_msg) -{ - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] Send error signal to manager"); - - char tmp_reason[10] = {0, }; - char tmp_daemon_pid[10] = {0, }; - char *temp_msg = NULL; - - if (NULL == err_msg) { - SLOG(LOG_WARN, TAG_VCD, "[TIDL ERROR] Input parameter is NULL"); - temp_msg = strdup("#NULL"); - } else { - temp_msg = strdup(err_msg); - } - - bundle* msg = bundle_create(); - snprintf(tmp_reason, 10, "%d", reason); - snprintf(tmp_daemon_pid, 10, "%d", getpid()); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_ERROR); - bundle_add_str(msg, VC_MANAGER_BUNDLE_REASON, tmp_reason); - bundle_add_str(msg, VC_MANAGER_BUNDLE_DAEMON_PID, tmp_daemon_pid); - bundle_add_str(msg, VC_MANAGER_BUNDLE_ERROR_MESSAGE, temp_msg); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - free(temp_msg); - temp_msg = NULL; - - return VCD_ERROR_NONE; -} - -// TODO: remove _tidl after remove dbus -// TODO: make client, widget error signal -int vcdc_tidl_send_error(int reason, char *err_msg) -{ - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] Send error signal"); - - vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), reason, err_msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_request_set_private_data(int pid, const char* key, const char* data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Set private data"); - - char tmp_pid[10] = { 0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_pid, 10, "%d", pid); - - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_SET_PRIVATE_DATA); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_pid); - bundle_add_str(msg, VC_MANAGER_BUNDLE_KEY, key); - bundle_add_str(msg, VC_MANAGER_BUNDLE_PRIVATE_DATA, data); - - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_audio_channel_e channel, vce_audio_type_e audio_type) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send feedback audio format to manager"); - - char tmp_rate[10] = {0, }; - char tmp_channel[10] = {0, }; - char tmp_audio_type[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_rate, 10, "%d", rate); - snprintf(tmp_channel, 10, "%d", (int)channel); - snprintf(tmp_audio_type, 10, "%d", (int)audio_type); - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_FEEDBACK_AUDIO_FORMAT); - bundle_add_str(msg, VC_MANAGER_BUNDLE_AUDIO_RATE, tmp_rate); - bundle_add_str(msg, VC_MANAGER_BUNDLE_AUDIO_CHANNEL, tmp_channel); - bundle_add_str(msg, VC_MANAGER_BUNDLE_AUDIO_TYPE, tmp_audio_type); - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - __send_msg(msg, VCD_CLIENT_TYPE_MANAGER); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Send feedback streaming to manager"); - - char tmp_pid[10] = {0, }; - char tmp_utt_id[10] = {0, }; - char tmp_event[10] = {0, }; - - bundle* msg = bundle_create(); - snprintf(tmp_pid, 10, "%d", pid); - snprintf(tmp_utt_id, 10, "%d", utt_id); - snprintf(tmp_event, 10, "%d", (int)event); - bundle_add_str(msg, VC_MANAGER_BUNDLE_METHOD, VCD_MANAGER_METHOD_FEEDBACK_STREAMING); - bundle_add_str(msg, VC_MANAGER_BUNDLE_MESSAGE, tmp_pid); - bundle_add_str(msg, VC_MANAGER_BUNDLE_UTTID, tmp_utt_id); - bundle_add_str(msg, VC_MANAGER_BUNDLE_EVENT, tmp_event); - - rpc_port_stub_array_char_h streaming_data = NULL; - rpc_port_stub_array_char_create(&streaming_data); - if (NULL == streaming_data) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to create data handle"); - return VCD_ERROR_OUT_OF_MEMORY; - } - - if (NULL != buffer && 0 < len) { - rpc_port_stub_array_char_set(streaming_data, (char*)buffer, len); - } else { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] buffer is empty"); - } - - SLOG(LOG_DEBUG, TAG_VCD, ">>>> VCD SEND MESSAGE"); - - pthread_mutex_lock(&g_mgr_tidl_info_mutex); - SLOG(LOG_INFO, TAG_VCD, "[TIDL] message to manager"); - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Fail to get manager tidl info. pid(%d)", pid); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - rpc_port_stub_array_char_destroy(streaming_data); - bundle_free(msg); - return VCD_ERROR_OPERATION_FAILED; - } - - rpc_port_stub_vc_mgr_send_buffer_cb_h handle = mgr_tidl_info->send_buffer_cb; - if (NULL == handle) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL] notify callback handle is null"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - rpc_port_stub_array_char_destroy(streaming_data); - bundle_free(msg); - return VCD_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_stub_vc_mgr_send_buffer_cb_invoke(handle, streaming_data, msg)) { - SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to send msg"); - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - rpc_port_stub_array_char_destroy(streaming_data); - bundle_free(msg); - return VCD_ERROR_OPERATION_FAILED; - } - pthread_mutex_unlock(&g_mgr_tidl_info_mutex); - rpc_port_stub_array_char_destroy(streaming_data); - bundle_free(msg); - - return VCD_ERROR_NONE; -} - -void vcdc_send_request_set_foreground(int pid, int value) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Set foreground"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return; - } - - rpc_port_proxy_vcd_mgr_invoke_set_foreground(mgr_tidl_info->rpc_h, pid, value); - - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request set foreground"); -} - -int vcdc_send_request_get_private_data(int pid, const char* key, char** data) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Get private data"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - char *tmp = NULL; - if (0 != rpc_port_proxy_vcd_mgr_invoke_get_private_data(mgr_tidl_info->rpc_h, pid, key, &tmp)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request vcd manager get private data : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request vcd manager get private data : Success"); - - *data = tmp; - - return VC_ERROR_NONE; -} - -int vcdc_send_request_auth_enable(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] auth enable"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_enable(mgr_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth enable : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth enable : Success"); - - return VC_ERROR_NONE; -} - -int vcdc_send_request_auth_disable(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] auth disable"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_disable(mgr_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth disable : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth disable : Success"); - - return VC_ERROR_NONE; -} - -int vcdc_send_request_auth_start(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] auth start"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_start(mgr_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth start : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth start : Success"); - - return VC_ERROR_NONE; -} - -int vcdc_send_request_auth_stop(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] auth stop"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_stop(mgr_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth stop : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth stop : Success"); - - return VC_ERROR_NONE; -} - -int vcdc_send_request_auth_cancel(int pid) -{ - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] auth cancel"); - - manager_tidl_info_s* mgr_tidl_info = vcd_client_manager_get_tidl_info(); - - if (NULL == mgr_tidl_info) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get tidl info"); - return VC_ERROR_OPERATION_FAILED; - } - - if (!mgr_tidl_info->connected) { - SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Not Connected"); - return VC_ERROR_OPERATION_FAILED; - } - - if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_cancel(mgr_tidl_info->rpc_h, pid)) { - SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth cancel : Fail to invoke message"); - return VC_ERROR_OPERATION_FAILED; - } - SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth cancel : Success"); - - return VC_ERROR_NONE; -} diff --git a/server/vcd_tidl.h b/server/vcd_tidl.h deleted file mode 100644 index 6f339dc..0000000 --- a/server/vcd_tidl.h +++ /dev/null @@ -1,72 +0,0 @@ -/* -* 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 __VCD_TIDL_h__ -#define __VCD_TIDL_h__ - -#include "vcd_main.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// typedef enum { -// VCD_CLIENT_TYPE_NORMAL, -// VCD_CLIENT_TYPE_WIDGET, -// VCD_CLIENT_TYPE_MANAGER -// } vcd_client_type_e; - -int vcd_mgr_tidl_open_connection(); - -int vcd_mgr_tidl_close_connection(); - -int vcdc_tidl_send_hello(int pid, vcd_client_type_e type); - -int vcdc_send_set_volume(int manager_pid, float volume); - -int vcdc_tidl_send_result(int pid, int manager_pid, int cmd_type); - -int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result); - -int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result); - -int vcdc_send_result_to_manager(int manager_pid, int result_type); - -int vcdc_send_speech_detected(int manager_pid); - -int vcdc_tidl_send_error(int reason, char *err_msg); - -int vcdc_tidl_send_error_to_manager(int manager_pid, int reason, char *err_msg); - -int vcdc_send_service_state(vcd_state_e state); - -int vcdc_send_dialog(int manager_pid, int pid, const char* disp_text, const char* utt_text, int continuous); - -int vcdc_send_request_set_private_data(int pid, const char* key, const char* data); - -int vcdc_send_request_get_private_data(int pid, const char* key, char** data); - -/* for TTS feedback */ -int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_audio_channel_e channel, vce_audio_type_e audio_type); - -int vcdc_send_feedback_streaming_to_manager(int manager_pid, int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len); - -#ifdef __cplusplus -} -#endif - -#endif /* __VCD_TIDL_h__ */ diff --git a/server/vce.c b/server/vce.c index 5353ea0..fae0fbb 100644 --- a/server/vce.c +++ b/server/vce.c @@ -20,7 +20,6 @@ #include #include #include "vcd_dbus.h" -#include "vcd_tidl.h" #include "vcd_main.h" #include "vcd_server.h" diff --git a/tidl/vc_mgr.tidl b/tidl/vc_mgr.tidl deleted file mode 100644 index f790247..0000000 --- a/tidl/vc_mgr.tidl +++ /dev/null @@ -1,26 +0,0 @@ -interface vc_mgr { - void notify_cb(bundle msg) delegate; - void send_buffer_cb(array data_in, bundle msg) delegate; - void register_cb(int pid, notify_cb notify_callback, send_buffer_cb send_buffer_callback) async; - - int initialize(in int pid, in int audio_streaming_mode, out int service_state, out int foreground, out int daemon_pid); - int finalize(in int pid); - int set_command(in int pid); - int unset_command(in int pid); - int demandable_client(in int pid); - int set_audio_type(in int pid, string audio_type); - int get_audio_type(in int pid, out string audio_type); - void set_private_data(in int pid, string key, string data) async; - int get_private_data(in int pid, string key, out string data); - int set_client_info(in int pid); - int set_domain(in int pid, string domain); - void do_action(in int pid, int type, string send_event) async; - int start(in int pid, in int recognition_mode, bool exclusive_command_option, bool start_by_client, int disabled_cmd_type); - int stop(in int pid); - int cancel(in int pid); - void set_audio_streaming_mode(in int pid, in int mode) async; - void send_specific_engine_request(in int pid, in string engine_app_id, in string event, in string request) async; - void send_result_selection(in int pid) async; - void send_audio_streaming(in int pid, in int event, array data_in) async; - void send_utterance_status(in int utt_id, in int utt_status) async; -} \ No newline at end of file diff --git a/tidl/vcd_mgr.tidl b/tidl/vcd_mgr.tidl deleted file mode 100644 index 57557f8..0000000 --- a/tidl/vcd_mgr.tidl +++ /dev/null @@ -1,9 +0,0 @@ -interface vcd_mgr { - void set_foreground(in int pid, in int value) async; - int get_private_data(in int pid, in string key, out string data); - int auth_enable(in int pid); - int auth_disable(in int pid); - int auth_start(in int pid); - int auth_stop(in int pid); - int auth_cancel(in int pid); -} \ No newline at end of file