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
+ 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
)
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
#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"
static Ecore_Timer* g_send_hello_timer = NULL;
static Ecore_Timer* g_request_init_timer = NULL;
-static int g_send_hello_count = 0;
+static int g_dbus_send_hello_count = 0;
+static int g_tidl_send_hello_count = 0;
static Ecore_Timer* g_m_set_volume_timer = NULL;
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 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");
return VC_ERROR_OPERATION_FAILED;
}
static void __vc_mgr_internal_unprepare()
{
- int ret = vc_mgr_dbus_request_finalize(g_vc_m->handle);
+ int ret = vc_mgr_tidl_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;
}
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;
vc_audio_streaming_mode_e streaming_mode;
vc_mgr_client_get_audio_streaming_mode(g_vc_m, &streaming_mode);
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid);
+ ret = vc_mgr_tidl_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));
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_send_hello_count == 20) {
- g_send_hello_count = 0;
+ 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;
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_send_hello_count++;
+ g_tidl_send_hello_count++;
return EINA_TRUE;
}
}
}
if (NULL == g_send_hello_timer) {
- g_send_hello_count = 0;
+ g_dbus_send_hello_count = 0;
+ g_tidl_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);
int count = 0;
int ret = -1;
while (0 != ret) {
- ret = vc_mgr_dbus_request_demandable_client(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
} else {
int count = 0;
do {
- ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
int count = 0;
int ret = -1;
while (0 != ret) {
- ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
} else {
int count = 0;
do {
- ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
/* Request */
while (0 != ret) {
- ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id);
+ ret = vc_mgr_tidl_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));
int ret = -1;
int count = 0;
while (0 != ret) {
- ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp);
+ ret = vc_mgr_tidl_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));
ret = -1;
count = 0;
while (0 != ret) {
- ret = vc_mgr_dbus_request_set_client_info(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
}
int ret = -1;
- ret = vc_mgr_dbus_request_set_private_data(g_vc_m->handle, key, data);
+ ret = vc_mgr_tidl_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;
char* temp = NULL;
while (0 != ret) {
- ret = vc_mgr_dbus_request_get_private_data(g_vc_m->handle, key, &temp);
+ ret = vc_mgr_tidl_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));
int ret = -1;
int count = 0;
while (0 != ret) {
- ret = vc_mgr_dbus_request_set_domain(g_vc_m->handle, domain);
+ ret = vc_mgr_tidl_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));
}
int ret = -1;
- ret = vc_mgr_dbus_request_do_action(g_vc_m->handle, type, send_event);
+ ret = vc_mgr_tidl_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;
}
int ret = -1;
- ret = vc_mgr_dbus_send_specific_engine_request(g_vc_m->handle, engine_app_id, event, request);
+ ret = vc_mgr_tidl_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;
count = 0;
while (0 != ret) {
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STARTING);
- ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type);
+ ret = vc_mgr_tidl_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));
/* do request */
while (0 != ret) {
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STOPPING);
- ret = vc_mgr_dbus_request_stop(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
int count = 0;
while (0 != ret) {
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_CANCELING);
- ret = vc_mgr_dbus_request_cancel(g_vc_m->handle);
+ ret = vc_mgr_tidl_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));
int __vc_mgr_cb_set_volume(float volume)
{
- // called in vc_mgr_dbus
+ // called in vc_mgr_tidl
g_prev_volume_db = g_volume_db;
g_cur_volume_db = volume;
/* Request */
int ret = -1;
- ret = vc_mgr_dbus_send_result_selection(g_vc_m->handle);
+ ret = vc_mgr_tidl_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;
float volume = __get_volume_decibel((char*)buffer, len);
__vc_mgr_set_volume(volume);
- ret = vc_mgr_dbus_send_audio_streaming(g_vc_m->handle, event, buffer, len);
+ ret = vc_mgr_tidl_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
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client");
}
- ret = vc_mgr_dbus_request_set_audio_streaming_mode(g_vc_m->handle, mode);
+ ret = vc_mgr_tidl_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 dbus");
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr tidl");
}
} else {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'INITIALIZED', state(%d)", state);
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;
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 */
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);
-
+// TODO: remove listener event callback
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;
char if_name[64] = {0, };
snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE);
- 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)) {
+ 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;
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;
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");
int vc_mgr_dbus_request_hello()
{
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ Request vc hello start");
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
result = VC_ERROR_TIMED_OUT;
}
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ Request vc hello end");
return result;
}
return ret;
}
-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)
{
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
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_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);
+ /* 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);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
dbus_error_free(&err);
+ return VC_ERROR_OPERATION_FAILED;
}
- 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);
-
- 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);
+ return VC_ERROR_NONE;
+}
- if (0 == result) {
- *service_state = tmp_service_state;
- *foreground = tmp_foreground;
- *daemon_pid = tmp_daemon_pid;
+static DBusMessage* __get_message(int pid, const char* method, int type)
+{
+ char service_name[64];
+ char object_path[64];
+ char target_if_name[128];
- /* 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);
+ memset(service_name, '\0', 64);
+ memset(object_path, '\0', 64);
+ memset(target_if_name, '\0', 128);
- 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);
- }
+ 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 {
- SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL ");
- vc_mgr_dbus_reconnect();
- result = VC_ERROR_TIMED_OUT;
+ return NULL;
}
- return result;
+ 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_request_finalize(int pid)
+// 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)
{
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;
- }
-
- /* 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 = __get_message(pid, VC_MANAGER_METHOD_UTTERANCE_STATUS, VC_COMMAND_TYPE_FOREGROUND);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
- dbus_error_free(&err);
+ 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);
}
- DBusMessage* msg;
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &utt_id,
+ DBUS_TYPE_INT32, &utt_status,
+ DBUS_TYPE_INVALID);
- msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_FINALIZE);
+ dbus_message_set_no_reply(msg, TRUE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : Fail to make message ");
+ /* 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, "@@ vc mgr finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send");
+ dbus_connection_flush(g_m_conn_sender);
}
- 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 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;
-}
+}
\ No newline at end of file
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
--- /dev/null
+/*
+* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <pthread.h>
+
+#include <rpc-port.h>
+
+#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;
+}
--- /dev/null
+/*
+* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+#ifndef __VC_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_ */
#define __VC_DEFS_H__
#include <tzplatform_config.h>
+#include <vconf.h>
#ifdef __cplusplus
extern "C" {
/******************************************************************************************
-* Definitions for Dbus
+* Definitions for IPC
*******************************************************************************************/
#define VC_CLIENT_SERVICE_NAME "org.tizen.voice.vcclient"
#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
*******************************************************************************************/
#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"
#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
BuildRequires: pkgconfig(vconf)
BuildRequires: cmake
BuildRequires: pkgconfig(gmock)
+BuildRequires: tidl
+BuildRequires: pkgconfig(rpc-port)
+BuildRequires: pkgconfig(bundle)
%if 0%{?gcov:1}
BuildRequires: lcov
%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}
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
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;
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;
#include <glib.h>
#include "vc_command.h"
#include "vc_info_parser.h"
+#include "vcd_mgr_stub.h"
+#include "vcd_mgr_proxy.h"
#ifdef __cplusplus
extern "C" {
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 */
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
*/
#include "vcd_client_data.h"
#include "vcd_dbus.h"
#include "vcd_dbus_server.h"
+#include "vcd_tidl.h"
#include "vcd_main.h"
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)
} 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) {
- msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
+ vcdc_tidl_send_hello(pid, type);
+ return VCD_ERROR_NONE;
} else {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
return -1;
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()) {
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);
+ // msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
+ vcdc_tidl_send_result(pid, manager_pid, cmd_type);
+ return 0;
} else {
msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL);
}
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;
+ // msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
+ // break;
+ vcdc_tidl_send_result(pid, manager_pid, cmd_type);
+ return 0;
default:
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
}
}
-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;
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");
DBusMessage* msg = NULL;
- msg = dbus_message_new_signal(
- VC_MANAGER_SERVICE_OBJECT_PATH,
- VC_MANAGER_SERVICE_INTERFACE,
- VCD_MANAGER_METHOD_ERROR);
+ // 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;
- }
+ // if (NULL == msg) {
+ // SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ // return VCD_ERROR_OUT_OF_MEMORY;
+ // }
- 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);
+ // 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 (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);
- }
+ // 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);
+ // }
- dbus_message_unref(msg);
+ // dbus_message_unref(msg);
- msg = NULL;
+ // msg = NULL;
+
+ vcdc_tidl_send_error(reason, err_msg);
msg = dbus_message_new_signal(
VC_CLIENT_SERVICE_OBJECT_PATH,
VC_CLIENT_SERVICE_INTERFACE,
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);
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);
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();
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_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);
+// 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
}
#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"
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)
{
/*
* 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);
#include "vcd_main.h"
#include "vcd_recorder.h"
#include "vcd_dbus.h"
+#include "vcd_tidl.h"
#include "vce_internal.h"
/*
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
vcd_engine_recognize_cancel();
/* Send error cb to manager */
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail");
return ret;
}
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
}
#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"
#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"
ecore_timer_add(0, __cancel_by_interrupt, NULL);
/* Send error cb to manager */
if (VCE_ERROR_OUT_OF_NETWORK == ret) {
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_TIMED_OUT, "voice_framework.error.engine.set_recording_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_TIMED_OUT, "voice_framework.error.engine.set_recording_fail");
} else {
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.set_recording_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.set_recording_fail");
}
return 0;
}
int pid = __get_tts_played_pid();
ret = vcdc_send_error_signal_to_app(pid, error, error_msg);
} else {
- ret = vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), error, error_msg);
+ ret = vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), error, error_msg);
ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
}
}
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);
vcdc_send_service_state(VCD_STATE_NONE);
}
- /* Open dbus connection */
+ /* Close 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;
/* Send error cb to manager */
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid)
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.collect_command_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.collect_command_fail");
return VCD_ERROR_OPERATION_FAILED;
}
/* Send error cb to manager */
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid)
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.engine.set_commands_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.engine.set_commands_fail");
return VCD_ERROR_OPERATION_FAILED;
}
/* Send error cb to manager */
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid)
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.start_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.start_fail");
return ret;
}
/* Send error cb to manager */
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid)
- vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail");
+ vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "voice_framework.error.vcfw.send_rc_fail");
return ret;
}
#endif
return VCD_ERROR_NONE;
}
-int vcd_server_mgr_send_audio_streaming(int pid, int event, char* buffer, unsigned int len)
+int vcd_server_mgr_send_audio_streaming(int pid, int event, const 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);
int vcd_server_mgr_stop_feedback(void);
/* for Multi-assistant */
-int vcd_server_mgr_send_audio_streaming(int pid, int event, char* buffer, unsigned int len);
+int vcd_server_mgr_send_audio_streaming(int pid, int event, const char* buffer, unsigned int len);
/*
--- /dev/null
+/*
+* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "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;
+}
--- /dev/null
+/*
+* Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+#ifndef __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__ */
#include <cynara-session.h>
#include <system_info.h>
#include "vcd_dbus.h"
+#include "vcd_tidl.h"
#include "vcd_main.h"
#include "vcd_server.h"
--- /dev/null
+interface vc_mgr {
+ void notify_cb(bundle msg) delegate;
+ void send_buffer_cb(array<char> 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<char> data_in) async;
+ void send_utterance_status(in int utt_id, in int utt_status) async;
+}
\ No newline at end of file
--- /dev/null
+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
projects / platform / core / uifw / voice-control.git / commitdiff