# for the use of ecore_wl2
ADD_DEFINITIONS("-DEFL_BETA_API_SUPPORT")
+FIND_PROGRAM(GDBUS_CODEGEN NAMES gdbus-codegen)
+EXEC_PROGRAM(${GDBUS_CODEGEN} ARGS "\\
+ --generate-c-code ${CMAKE_CURRENT_SOURCE_DIR}/common/vc_gdbus \\
+ --c-namespace GDBus\\
+ --interface-prefix org.tizen.voice. \\
+ ${CMAKE_CURRENT_SOURCE_DIR}/org.tizen.voice.voice-control.gdbus.xml \\
+ ")
+
# pkg config tool
INCLUDE(FindPkgConfig)
INCLUDE(FindPkgConfig)
IF("${_TV_PRODUCT}" STREQUAL "TRUE")
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
+ aul buxton2 capi-appfw-app-control capi-appfw-app-manager capi-base-common capi-media-audio-io capi-media-sound-manager ecore-wl2 gio-2.0 gio-unix-2.0
capi-network-bluetooth capi-network-bluetooth-tv 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 msfapi farfield-voice-api
)
ELSE()
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
+ aul buxton2 capi-appfw-app-control capi-appfw-app-manager capi-base-common capi-media-audio-io capi-media-sound-manager ecore-wl2 gio-2.0 gio-unix-2.0
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
)
ENDIF()
## config ##
INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-config.xml DESTINATION ${TZ_SYS_RO_SHARE}/voice/vc/1.0)
-INSTALL(FILES ${CMAKE_SOURCE_DIR}/org.tizen.voice.vcserver.service DESTINATION ${TZ_SYS_RO_SHARE}/dbus-1/services)
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/org.tizen.voice.vcdaemon.service DESTINATION ${TZ_SYS_RO_SHARE}/dbus-1/services)
-INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-server.conf DESTINATION /etc/dbus-1/session.d)
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-service.conf DESTINATION /etc/dbus-1/session.d)
## vc_getengine ##
IF("${ARCH}" MATCHES "^arm.*")
../common/vc_config_parser.c
../common/vc_info_parser.c
../common/vc_json_parser.c
+ ../common/vc_gdbus.c
)
SET(SETTING_SRCS
vc_setting.c
../common/vc_config_mgr.c
../common/vc_config_parser.c
+ ../common/vc_gdbus.c
)
SET(WIDGET_SRCS
../common/vc_config_parser.c
../common/vc_info_parser.c
../common/vc_json_parser.c
+ ../common/vc_gdbus.c
)
SET(MANAGER_SRCS
../common/vc_config_parser.c
../common/vc_info_parser.c
../common/vc_json_parser.c
+ ../common/vc_gdbus.c
)
#INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR})
int vc_initialize(void)
{
+ if (!ecore_main_loop_glib_integrate()) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail ecore_main_loop_glib_integrate()");
+ }
+
if (0 != __vc_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
}
}
}
-int __vc_cb_error(int reason, int daemon_pid, char* msg)
+int __vc_cb_error(int reason, int daemon_pid, const char* msg)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
#include "vc_dbus.h"
#include "vc_main.h"
-static pthread_mutex_t g_dbus_mutex = PTHREAD_MUTEX_INITIALIZER;
+#define USE_GDBUS
-static int g_waiting_time = 3000;
-static int g_waiting_short_time = 200;
-static bool g_is_connection_opened = false;
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
-static Ecore_Fd_Handler* g_fd_handler = NULL;
-
-static DBusConnection* g_conn_sender = NULL;
-static DBusConnection* g_conn_listener = NULL;
+static GDBusConnection* g_connection = NULL;
+static GDBusVcdaemon *g_daemon_proxy = NULL;
+static int g_own_name_id = 0;
+static guint g_name_owner_changed_subscription_id = 0;
-extern int __vc_cb_error(int reason, int daemon_pid, char* msg);
+extern int __vc_cb_error(int reason, int daemon_pid, const char* msg);
extern void __vc_cb_result();
extern int __vc_cb_tts_streaming(int utt_id, vc_feedback_event_e event, char* buffer, int len);
extern int __vc_cb_utterance_status(int utt_id, int utt_status);
+#else
+static pthread_mutex_t g_dbus_mutex = PTHREAD_MUTEX_INITIALIZER;
+static bool g_is_connection_opened = false;
+static int g_waiting_time = 3000;
+static int g_waiting_short_time = 200;
+static Ecore_Fd_Handler* g_fd_handler = NULL;
+static DBusConnection* g_conn_listener = NULL;
+static DBusConnection* g_conn_sender = NULL;
+
+#endif
//LCOV_EXCL_START
+#ifndef USE_GDBUS
static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
g_conn_sender = NULL;
}
}
+#endif
+
+#ifdef USE_GDBUS
+static GDBusVcmanager* get_manager_proxy() {
+ char service_name[64] = {0,};
+ char object_path[64] = {0,};
+
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
+
+ GError *error = NULL;
+ GDBusVcmanager *proxy = gdbus_vcmanager_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ service_name, object_path, NULL, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "[DBUS] Proxy : %p, service_name(%s), object_path(%s) : %s",
+ proxy, service_name, object_path, error->message);
+ g_error_free(error);
+ }
+
+ return proxy;
+}
+
+gboolean vcd_client_method_hello(GDBusVcclient *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int response = -1;
+ if (pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCC, "@@ vc get hello : pid(%d) ", pid);
+ response = 1;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "@@ vc get hello : invalid pid ");
+ }
+ gdbus_vcclient_complete_vcd_client_method_hello(service, invocation, response);
+ return TRUE;
+}
+
+gboolean vcd_client_method_result(GDBusVcclient *service, GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ __vc_cb_result();
+ gdbus_vcclient_complete_vcd_client_method_result(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_client_method_feedback_streaming(GDBusVcclient *service, GDBusMethodInvocation *invocation,
+ gint utt_id, gint event, guint size, GVariant* buffer, gpointer user_data)
+{
+ int len = 0;
+ GVariantIter *iter;
+ guchar uc;
+
+ char *data = NULL;
+ data = malloc(size);
+ if (!data) return FALSE;
+
+ g_variant_get(buffer, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", &uc)) {
+ if (len < size) {
+ data[len++] = uc;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] max size reached : %d", len);
+ }
+ }
+ g_variant_iter_free(iter);
+
+ int ret = __vc_cb_tts_streaming(utt_id, event, data, len);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to send_audio_streaming");
+ }
+
+ gdbus_vcclient_complete_vcd_client_method_feedback_streaming(service, invocation);
+
+ free(data);
+ return ret;
+}
+
+gboolean vcm_client_method_utterance_status(GDBusVcclient *service, GDBusMethodInvocation *invocation,
+ gint utt_id, gint utt_status, gpointer user_data)
+{
+ SLOG(LOG_INFO, TAG_VCC, "@@@ Get TTS utterance status streaming");
+ __vc_cb_utterance_status(utt_id, utt_status);
+ gdbus_vcclient_complete_vcm_client_method_utterance_status(service, invocation);
+ return TRUE;
+}
+
+static void
+on_name_acquired(GDBusConnection *connection,
+ const gchar *name,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCC, "Name acquired : %s", name);
+
+ GDBusVcclient *service;
+ GError *error = NULL;
+
+ service = gdbus_vcclient_skeleton_new();
+
+ /* vc daemon methods */
+ g_signal_connect(service, "handle-vcd-client-method-hello",
+ G_CALLBACK(vcd_client_method_hello), NULL);
+ g_signal_connect(service, "handle-vcd-client-method-result",
+ G_CALLBACK(vcd_client_method_result), NULL);
+ g_signal_connect(service, "handle-vcd-client-method-feedback-streaming",
+ G_CALLBACK(vcd_client_method_feedback_streaming), NULL);
+
+ /* vc manager methods */
+ g_signal_connect(service, "handle-vcm-client-method-utterance-status",
+ G_CALLBACK(vcm_client_method_utterance_status), NULL);
+
+ g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(service),
+ connection, VC_CLIENT_SERVICE_OBJECT_PATH, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCC, "Error : %s\n", error->message);
+ g_error_free(error);
+ }
+}
+
+static void vcd_signal_set_service_state(GDBusVcdaemon* proxy,
+ gint state, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCC, "@@ state changed : %d", state);
+ __vc_cb_service_state(state);
+}
+
+static void vcd_client_signal_send_error(GDBusVcdaemon* proxy,
+ gint reason, gint daemon_pid, const gchar* err_msg, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCC, "@@ vc Get Error message : reason(%d), daemon_pid(%d), msg(%s)",
+ reason, daemon_pid, err_msg);
+ __vc_cb_error(reason, daemon_pid, err_msg);
+}
+
+static void vcd_client_signal_send_manager_pid(GDBusVcdaemon* proxy,
+ gint manager_pid, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCC, "@@ manager pid is changed : %d", manager_pid);
+ __vc_cb_manager_pid(manager_pid);
+}
+
+static void _on_name_owner_changed(GDBusConnection *connection,
+ const gchar *sender_name, const gchar *object_path,
+ const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ gchar *name;
+ gchar *old_owner;
+ gchar *new_owner;
+
+ g_variant_get(parameters,
+ "(sss)",
+ &name,
+ &old_owner,
+ &new_owner);
+
+ if (g_name_owner_changed_subscription_id > 0) {
+ g_dbus_connection_signal_unsubscribe(connection, g_name_owner_changed_subscription_id);
+ g_name_owner_changed_subscription_id = 0;
+ }
+
+ SLOG(LOG_ERROR, TAG_VCC, "name_owner_changed(%s: %s -> %s) interface %s sender %s object %s",
+ name, old_owner, new_owner, interface_name, sender_name, object_path);
+ __vc_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
+
+ g_free(name);
+ g_free(old_owner);
+ g_free(new_owner);
+}
+#endif
int vc_dbus_open_connection()
{
+#ifdef USE_GDBUS
+ GError* error = NULL;
+ g_connection = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ g_own_name_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+ service_name, G_BUS_NAME_OWNER_FLAGS_REPLACE, NULL, on_name_acquired, NULL, NULL, NULL);
+ SLOG(LOG_DEBUG, TAG_VCC, "service_name : %s, %d", service_name, g_own_name_id);
+
+ g_daemon_proxy = gdbus_vcdaemon_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ VC_DAEMON_SERVICE_NAME, VC_DAEMON_SERVICE_OBJECT_PATH, NULL, &error);
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ g_error_free(error);
+ } else {
+ /* vc common signals */
+ g_signal_connect(g_daemon_proxy, "vcd-signal-set-service-state",
+ G_CALLBACK(vcd_signal_set_service_state), NULL);
+
+ /* vc daemon signals */
+ g_signal_connect(g_daemon_proxy, "vcd-client-signal-send-error",
+ G_CALLBACK(vcd_client_signal_send_error), NULL);
+ g_signal_connect(g_daemon_proxy, "vcd-client-signal-send-manager-pid",
+ G_CALLBACK(vcd_client_signal_send_manager_pid), NULL);
+ }
+#else
pthread_mutex_lock(&g_dbus_mutex);
if (NULL != g_conn_sender && NULL != g_conn_listener) {
pthread_mutex_unlock(&g_dbus_mutex);
SLOG(LOG_INFO, TAG_VCC, "[INFO] vc client dbus connection is opened");
-
+#endif
return VC_ERROR_NONE;
}
int vc_dbus_close_connection()
{
+#ifdef USE_GDBUS
+ if (g_daemon_proxy) {
+ g_object_unref(g_daemon_proxy);
+ g_daemon_proxy = NULL;
+ }
+ if (g_own_name_id) {
+ g_bus_unown_name(g_own_name_id);
+ g_own_name_id = 0;
+ }
+ if (g_connection != NULL) {
+ g_object_unref(g_connection);
+ g_connection = NULL;
+ }
+#else
pthread_mutex_lock(&g_dbus_mutex);
DBusError err;
pthread_mutex_unlock(&g_dbus_mutex);
SLOG(LOG_INFO, TAG_VCC, "[INFO] vc client dbus connection is closed");
-
+#endif
return 0;
}
int vc_dbus_reconnect()
{
+#ifdef USE_GDBUS
+ if (!g_own_name_id || !g_daemon_proxy) {
+ vc_dbus_close_connection();
+
+ if (0 != vc_dbus_open_connection()) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect"); //LCOV_EXCL_LINE
+ return -1;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect"); //LCOV_EXCL_LINE
+ return 0;
+ }
+#else
if (!g_conn_sender || !g_conn_listener) {
vc_dbus_close_connection();
SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect"); //LCOV_EXCL_LINE
}
-
+#endif
return 0;
}
static int __dbus_check()
{
+#ifdef USE_GDBUS
+ SLOG(LOG_DEBUG, TAG_VCC, "%d %p", g_own_name_id, g_daemon_proxy); //LCOV_EXCL_LINE
+ if (0 == g_own_name_id || NULL == g_daemon_proxy) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
+ return vc_dbus_reconnect();
+ }
+#else
if (NULL == g_conn_sender || NULL == g_conn_listener) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
return vc_dbus_reconnect();
}
+#endif
return 0;
}
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vc_method_hello_sync(g_daemon_proxy, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Request vc hello"); //LCOV_EXCL_LINE
DBusMessage* msg;
}
return result;
+#endif
}
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_initialize_sync(g_daemon_proxy,
+ pid, &result, mgr_pid, service_state, daemon_pid, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ if (0 == result && NULL != g_connection) {
+ g_name_owner_changed_subscription_id = g_dbus_connection_signal_subscribe(g_connection,
+ "org.freedesktop.DBus", "org.freedesktop.DBus", "NameOwnerChanged", "/org/freedesktop/DBus",
+ VC_DAEMON_SERVICE_NAME, G_DBUS_SIGNAL_FLAGS_NONE, _on_name_owner_changed, NULL, NULL);
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
int vc_dbus_request_finalize(int pid)
{
+#ifdef USE_GDBUS
+ if (0 != __dbus_check()) {
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ if (g_name_owner_changed_subscription_id > 0) {
+ g_dbus_connection_signal_unsubscribe(g_connection, g_name_owner_changed_subscription_id);
+ g_name_owner_changed_subscription_id = 0;
+ }
+
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_finalize_sync(g_daemon_proxy, pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
//LCOV_EXCL_START
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_set_exclusive_cmd_sync(g_daemon_proxy, pid, value, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
//LCOV_EXCL_STOP
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_set_command_sync(g_daemon_proxy, pid, cmd_type, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ gint result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_unset_command_sync(g_daemon_proxy, pid, cmd_type, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
int vc_dbus_set_foreground(int pid, bool value)
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcc_manager_method_set_foreground(proxy,
+ pid, value, NULL, NULL, NULL);
+ if (proxy) g_object_unref(proxy);
+
+ gdbus_vcdaemon_call_vcc_daemon_method_set_foreground(g_daemon_proxy,
+ pid, value, NULL, NULL, NULL);
+ return 0;
+#else
DBusMessage* msg = NULL;
int tmp_value = 0;
dbus_message_unref(msg);
return 0;
+#endif
}
//LCOV_EXCL_START
int vc_dbus_set_server_dialog(int pid, const char* app_id, const char* credential)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_set_server_dialog_sync(g_daemon_proxy, pid, app_id, credential, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
if (0 != vc_dbus_reconnect()) {
}
return result;
+#endif
}
//LCOV_EXCL_STOP
int vc_dbus_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
{
+#ifdef USE_GDBUS
+ int result = 0;
+ gdbus_vcdaemon_call_vcc_daemon_method_dialog(g_daemon_proxy, pid, disp_text, utt_text, continuous, NULL, NULL, NULL);
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
if (0 != vc_dbus_reconnect()) {
return result;
*/
//LCOV_EXCL_STOP
+#endif
}
int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ gboolean valid = FALSE;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_is_system_command_valid_sync(g_daemon_proxy, pid, &result, &valid, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ } else {
+ if (is_sys_cmd_valid) *is_sys_cmd_valid = valid;
+ }
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
if (0 != vc_dbus_reconnect()) {
}
return result;
+#endif
}
//LCOV_EXCL_START
/* Authority */
int vc_dbus_request_auth_enable(int pid, int mgr_pid)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_dbus_request_auth_disable(int pid, int mgr_pid)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_dbus_request_auth_start(int pid, int mgr_pid)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_dbus_request_auth_stop(int pid, int mgr_pid)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
//LCOV_EXCL_STOP
int vc_dbus_request_tts(int pid, const char* text, const char* language, bool to_vcm, int* utt_id)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_request_tts_sync(g_daemon_proxy, pid, text, language, to_vcm, &result, utt_id, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
if (0 != vc_dbus_reconnect()) {
return result;
return 0;
+#endif
}
int vc_dbus_cancel_tts(int pid, int utt_id)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_cancel_tts_sync(g_daemon_proxy, pid, utt_id, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
if (0 != vc_dbus_reconnect()) {
return result;
return 0;
+#endif
}
int vc_dbus_get_tts_audio_format(int pid, int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ gint out_channel, out_audio_type;
+ if (!gdbus_vcdaemon_call_vcc_daemon_method_get_tts_audio_format_sync(g_daemon_proxy, pid, &result, rate, &out_channel, &out_audio_type, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ } else {
+ if (channel) *channel = out_channel;
+ if (audio_type) *audio_type = out_audio_type;
+ }
+ return result;
+#else
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
if (0 != vc_dbus_reconnect()) {
return result;
return 0;
+#endif
}
static void __vc_mgr_notify_error(void *data);
static Eina_Bool __vc_mgr_notify_result(void *data);
-int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg);
+int __vc_mgr_cb_error(int reason, int daemon_pid, const char* msg);
static const char* __vc_mgr_get_error_code(vc_error_e err)
}
}
-int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg)
+int __vc_mgr_cb_error(int reason, int daemon_pid, const char* msg)
{
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
#include "vc_mgr_dbus.h"
#include "vc_command.h"
+#define USE_GDBUS
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
+
+static GDBusConnection* g_connection = NULL;
+static GDBusVcdaemon *g_daemon_proxy = NULL;
+static int g_own_name_id = 0;
+static guint g_watch_id = 0;
+static guint g_name_owner_changed_subscription_id = 0;
+static bool g_daemon_name_appeared = false;
+
+static int g_volume_count = 0;
+#else
static pthread_mutex_t g_m_dbus_mutex = PTHREAD_MUTEX_INITIALIZER;
+static Ecore_Fd_Handler* g_m_fd_handler = NULL;
-static int g_m_waiting_time = 3000;
-static int g_m_waiting_short_time = 200;
static bool g_is_connection_opened = false;
-static Ecore_Fd_Handler* g_m_fd_handler = NULL;
+static int g_m_waiting_time = 3000;
+static int g_m_waiting_short_time = 200;
static DBusConnection* g_m_conn_sender = NULL;
static DBusConnection* g_m_conn_listener = NULL;
-static int g_volume_count = 0;
-
+#endif
extern void __vc_mgr_cb_all_result(vc_result_type_e type);
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_error(int reason, int daemon_pid, const char* msg);
extern int __vc_mgr_cb_set_volume(float volume);
extern void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result);
+#ifndef USE_GDBUS
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;
}
}
+#endif
+
+#ifdef USE_GDBUS
+gboolean vcd_manager_method_hello(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int response = -1;
+ 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 ");
+ }
+ gdbus_vcmanager_complete_vcd_manager_method_hello(service, invocation, response);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_speech_detected(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get Speech detected");
+ __vc_mgr_cb_speech_detected();
+ gdbus_vcmanager_complete_vcd_manager_method_speech_detected(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_all_result(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint result_type, gpointer user_data)
+{
+ __vc_mgr_cb_all_result((vc_result_type_e)result_type);
+ gdbus_vcmanager_complete_vcd_manager_method_all_result(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_pre_result(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint event, const gchar* pre_result, gpointer user_data)
+{
+ if (NULL != pre_result) {
+ __vc_mgr_cb_pre_result((vc_pre_result_event_e)event, pre_result);
+ }
+ gdbus_vcmanager_complete_vcd_manager_method_pre_result(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_result(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ __vc_mgr_cb_system_result();
+ gdbus_vcmanager_complete_vcd_manager_method_result(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_set_volume(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint volume, gpointer user_data)
+{
+ if (10 == g_volume_count) {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set volume");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set volume : volume(%d)", volume);
+ g_volume_count = 0;
+ }
+
+ __vc_mgr_cb_set_volume(volume);
+ g_volume_count++;
+ gdbus_vcmanager_complete_vcd_manager_method_set_volume(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_dialog(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint pid, const gchar* disp_text, const gchar* utt_text, gboolean continuous, gpointer user_data)
+{
+ __vc_mgr_cb_dialog(pid, disp_text, utt_text, continuous);
+ gdbus_vcmanager_complete_vcd_manager_method_dialog(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_set_private_data(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint pid, const gchar* key, const gchar* data, gpointer user_data)
+{
+ if (pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", pid);
+ __vc_mgr_cb_private_data_set(key, data);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get request set private data : invalid pid ");
+ }
+ gdbus_vcmanager_complete_vcd_manager_method_set_private_data(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_get_private_data(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* key, gpointer user_data)
+{
+ gint ret = 0;
+ gchar* value = NULL;
+ if (pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid);
+ ret = __vc_mgr_cb_private_data_requested(key, &value);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get request get private data : invalid pid ");
+ }
+ gdbus_vcmanager_complete_vcd_manager_method_get_private_data(service, invocation, ret, value);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_specific_engine_result(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ const gchar* engine_app_id, const gchar* event, const gchar* result, gpointer user_data)
+{
+ if (NULL != result) {
+ __vc_mgr_cb_specific_engine_result(engine_app_id, event, result);
+ }
+ gdbus_vcmanager_complete_vcd_manager_method_specific_engine_result(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_feedback_audio_format(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint rate, gint channel, gint audio_type, gpointer user_data)
+{
+ __vc_mgr_cb_feedback_audio_format(rate, channel, audio_type);
+ gdbus_vcmanager_complete_vcd_manager_method_feedback_audio_format(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_manager_method_feedback_streaming(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ gint pid, gint utt_id, gint event, guint size, GVariant* buffer, gpointer user_data)
+{
+ int index = 0;
+ GVariantIter *iter;
+ guchar uc;
+
+ char *data = NULL;
+ data = malloc(size);
+ if (!data) return FALSE;
+
+ g_variant_get(buffer, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", &uc)) {
+ if (index < size) {
+ data[index++] = uc;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] max size reached : %d", index);
+ }
+ }
+ g_variant_iter_free(iter);
+
+ __vc_mgr_cb_feedback_streaming(pid, utt_id, event, data, size);
+
+ gdbus_vcmanager_complete_vcd_manager_method_feedback_streaming(service, invocation);
+
+ free(data);
+ return TRUE;
+}
+
+gboolean vcc_manager_method_set_foreground(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
+
+ __vc_mgr_cb_set_foreground(pid, value);
+ gdbus_vcmanager_complete_vcc_manager_method_set_foreground(service, invocation);
+ return TRUE;
+}
+
+gboolean vcw_manager_method_set_foreground(GDBusVcmanager *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
+
+ __vc_mgr_cb_set_foreground(pid, value);
+ gdbus_vcmanager_complete_vcw_manager_method_set_foreground(service, invocation);
+ return TRUE;
+}
+
+static void
+on_name_acquired(GDBusConnection *connection,
+ const gchar *name,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "Name acquired : %s", name);
+
+ GDBusVcmanager *service;
+ GError *error = NULL;
+
+ service = gdbus_vcmanager_skeleton_new();
+
+ /* vc client methods */
+ g_signal_connect(service, "handle-vcc-manager-method-set-foreground",
+ G_CALLBACK(vcc_manager_method_set_foreground), NULL);
+
+ /* vc daemon methods */
+ g_signal_connect(service, "handle-vcd-manager-method-hello",
+ G_CALLBACK(vcd_manager_method_hello), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-speech-detected",
+ G_CALLBACK(vcd_manager_method_speech_detected), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-all-result",
+ G_CALLBACK(vcd_manager_method_all_result), NULL);
+
+ g_signal_connect(service, "handle-vcd-manager-method-pre-result",
+ G_CALLBACK(vcd_manager_method_pre_result), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-result",
+ G_CALLBACK(vcd_manager_method_result), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-set-volume",
+ G_CALLBACK(vcd_manager_method_set_volume), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-dialog",
+ G_CALLBACK(vcd_manager_method_dialog), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-set-private-data",
+ G_CALLBACK(vcd_manager_method_set_private_data), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-get-private-data",
+ G_CALLBACK(vcd_manager_method_get_private_data), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-specific-engine-result",
+ G_CALLBACK(vcd_manager_method_specific_engine_result), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-feedback-audio-format",
+ G_CALLBACK(vcd_manager_method_feedback_audio_format), NULL);
+ g_signal_connect(service, "handle-vcd-manager-method-feedback-streaming",
+ G_CALLBACK(vcd_manager_method_feedback_streaming), NULL);
+
+ /* vc widget methods */
+ g_signal_connect(service, "handle-vcw-manager-method-set-foreground",
+ G_CALLBACK(vcw_manager_method_set_foreground), NULL);
+
+ g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(service),
+ connection, VC_MANAGER_SERVICE_OBJECT_PATH, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Error : %s\n", error->message);
+ g_error_free(error);
+ }
+}
+
+static void _on_name_owner_changed(GDBusConnection *connection,
+ const gchar *sender_name, const gchar *object_path,
+ const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ gchar *name;
+ gchar *old_owner;
+ gchar *new_owner;
+
+ g_variant_get(parameters,
+ "(sss)",
+ &name,
+ &old_owner,
+ &new_owner);
+
+ if (g_name_owner_changed_subscription_id > 0) {
+ g_dbus_connection_signal_unsubscribe(connection, g_name_owner_changed_subscription_id);
+ g_name_owner_changed_subscription_id = 0;
+ }
+
+ SLOG(LOG_ERROR, TAG_VCM, "name_owner_changed(%s: %s -> %s) interface %s sender %s object %s",
+ name, old_owner, new_owner, interface_name, sender_name, object_path);
+ __vc_mgr_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
+
+ g_free(name);
+ g_free(old_owner);
+ g_free(new_owner);
+}
+
+static void name_appeared_handler(GDBusConnection *connection,
+ const gchar *name, const gchar *name_owner, gpointer user_data)
+{
+ SLOG(LOG_INFO, TAG_VCM, "@@ Name appeared : name %s owner %s", name, name_owner);
+ g_daemon_name_appeared = true;
+}
+
+static void name_vanished_handler(GDBusConnection *connection,
+ const gchar *name, gpointer user_data)
+{
+ SLOG(LOG_INFO, TAG_VCM, "@@ Name vanished : name %s", name);
+ g_daemon_name_appeared = false;
+}
+
+#endif
+
+static void vcd_signal_set_service_state(GDBusVcdaemon* proxy,
+ gint state, gpointer user_data)
+{
+ SLOG(LOG_INFO, TAG_VCM, "@@ state changed : %d", state);
+
+ __vc_mgr_cb_service_state(state);
+}
+
+static void vcd_manager_signal_send_error(GDBusVcdaemon* proxy,
+ gint reason, gint daemon_pid, const gchar* err_msg, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "Error Signal : reason(%d), daemon_pid(%d), err_msg(%s)",
+ reason, daemon_pid, err_msg);
+}
+
int vc_mgr_dbus_open_connection()
{
+#ifdef USE_GDBUS
+ GError* error = NULL;
+ g_connection = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+ g_watch_id = g_bus_watch_name_on_connection(g_connection, VC_DAEMON_SERVICE_NAME, 0,
+ name_appeared_handler,
+ name_vanished_handler,
+ NULL, NULL);
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ g_own_name_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+ service_name, 0, NULL, on_name_acquired, NULL, NULL, NULL);
+ SLOG(LOG_DEBUG, TAG_VCM, "service_name : %s, %d", service_name, g_own_name_id);
+
+ g_daemon_proxy = gdbus_vcdaemon_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ VC_DAEMON_SERVICE_NAME, VC_DAEMON_SERVICE_OBJECT_PATH, NULL, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Error : %s", error->message);
+ g_error_free(error);
+ } else {
+ /* vc common signals */
+ g_signal_connect(g_daemon_proxy, "vcd-signal-set-service-state",
+ G_CALLBACK(vcd_signal_set_service_state), NULL);
+
+ /* vc manager signals */
+ g_signal_connect(g_daemon_proxy, "vcd-manager-signal-send-error",
+ G_CALLBACK(vcd_manager_signal_send_error), NULL);
+ }
+#else
pthread_mutex_lock(&g_m_dbus_mutex);
if (NULL != g_m_conn_sender && NULL != g_m_conn_listener) {
pthread_mutex_unlock(&g_m_dbus_mutex);
SLOG(LOG_INFO, TAG_VCM, "[INFO] manager dbus connection is opened");
-
+#endif
return VC_ERROR_NONE;
}
int vc_mgr_dbus_close_connection()
{
+#ifdef USE_GDBUS
+ if (g_daemon_proxy) {
+ g_object_unref(g_daemon_proxy);
+ g_daemon_proxy = NULL;
+ }
+ if (g_own_name_id) {
+ g_bus_unown_name(g_own_name_id);
+ g_own_name_id = 0;
+ }
+ if (g_watch_id) {
+ g_bus_unwatch_name(g_watch_id);
+ g_watch_id = 0;
+ }
+ if (g_connection != NULL) {
+ g_object_unref(g_connection);
+ g_connection = NULL;
+ }
+#else
pthread_mutex_lock(&g_m_dbus_mutex);
DBusError err;
pthread_mutex_unlock(&g_m_dbus_mutex);
SLOG(LOG_INFO, TAG_VCM, "[INFO] manager dbus connection is closed");
-
+#endif
return VC_ERROR_NONE;
}
int vc_mgr_dbus_reconnect()
{
+#ifdef USE_GDBUS
+ if (!g_own_name_id || !g_daemon_proxy) {
+ vc_mgr_dbus_close_connection();
+
+ if (0 != vc_mgr_dbus_open_connection()) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to reconnect"); //LCOV_EXCL_LINE
+ return -1;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect"); //LCOV_EXCL_LINE
+ return 0;
+ }
+#else
if (!g_m_conn_sender || !g_m_conn_listener) {
vc_mgr_dbus_close_connection();
SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
}
-
+#endif
return 0;
}
static int __dbus_check()
{
+#ifdef USE_GDBUS
+ SLOG(LOG_DEBUG, TAG_VCM, "%d %p", g_own_name_id, g_daemon_proxy); //LCOV_EXCL_LINE
+ if (0 == g_own_name_id || NULL == g_daemon_proxy) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
+ return vc_mgr_dbus_reconnect();
+ }
+#else
if (NULL == g_m_conn_sender || NULL == g_m_conn_listener) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
return vc_mgr_dbus_reconnect();
}
+#endif
return 0;
}
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vc_method_hello_sync(g_daemon_proxy, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
static int __dbus_restore_daemon()
int ret = -1;
int count = 0;
while (0 != ret) {
+ usleep(100000);
+ SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] requesting hello : %d", count);
ret = vc_mgr_dbus_request_hello();
if (0 != ret) {
- if (VC_ERROR_TIMED_OUT != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry restore daemon");
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
break;
- } else {
- SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry restore daemon");
- usleep(10000);
- count++;
- if (VC_RETRY_COUNT == count) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
- break;
- }
}
} else {
SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] restore daemon");
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ }
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_initialize_sync(g_daemon_proxy,
+ pid, audio_streaming_mode, &result, service_state, foreground, daemon_pid, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ if (0 == result && NULL != g_connection && 0 == g_name_owner_changed_subscription_id) {
+ g_name_owner_changed_subscription_id = g_dbus_connection_signal_subscribe(g_connection,
+ "org.freedesktop.DBus", "org.freedesktop.DBus", "NameOwnerChanged", "/org/freedesktop/DBus",
+ VC_DAEMON_SERVICE_NAME, G_DBUS_SIGNAL_FLAGS_NONE, _on_name_owner_changed, NULL, NULL);
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_finalize(int pid)
{
- if (0 != __dbus_check()) {
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
}
+ GError *error = NULL;
+ gint result;
+ if (g_name_owner_changed_subscription_id > 0) {
+ g_dbus_connection_signal_unsubscribe(g_connection, g_name_owner_changed_subscription_id);
+ g_name_owner_changed_subscription_id = 0;
+ }
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_finalize_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
-
+#endif
return result;
}
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_set_command_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_unset_command(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_unset_command_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_demandable_client(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_set_demandable_client_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type)
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_set_audio_type_sync(g_daemon_proxy,
+ pid, audio_type, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ gchar *temp = NULL;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_get_audio_type_sync(g_daemon_proxy,
+ pid, &result, &temp, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ if (NULL != audio_type && NULL != temp) {
+ *audio_type = strdup(temp);
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_set_private_data(int pid, const char* key, const char* data)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_call_vcm_daemon_method_set_private_data(g_daemon_proxy,
+ pid, key, data, NULL, NULL, NULL);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return VC_ERROR_NONE;
+#endif
}
int vc_mgr_dbus_request_get_private_data(int pid, const char* key, char** data)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ gint result = 0;
+ gchar *temp = NULL;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_get_private_data_sync(g_daemon_proxy,
+ pid, key, &result, &temp, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ if (NULL != data && NULL != temp) {
+ *data = strdup(temp);
+ }
+ return result;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_mgr_dbus_request_set_client_info(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_set_client_info_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
+ if (0 != __dbus_check()) {
+ return VC_ERROR_OPERATION_FAILED;
+ }
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_set_domain(int pid, const char* domain)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_set_domain_sync(g_daemon_proxy,
+ pid, domain, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_mgr_dbus_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_call_vcm_daemon_method_do_action(g_daemon_proxy,
+ pid, type, send_event, NULL, NULL, NULL);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_request_start_sync(g_daemon_proxy,
+ pid, recognition_mode, exclusive_command_option, start_by_client, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
+ if (0 != __dbus_check()) {
+ return VC_ERROR_OPERATION_FAILED;
+ }
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_stop(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_request_stop_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_cancel(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_request_cancel_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_enable_command_type(int pid, int cmd_type)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_enable_command_type_sync(g_daemon_proxy,
+ pid, cmd_type, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
int vc_mgr_dbus_request_disable_command_type(int pid, int cmd_type)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_disable_command_type_sync(g_daemon_proxy,
+ pid, cmd_type, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
+ if (0 != __dbus_check()) {
+ return VC_ERROR_OPERATION_FAILED;
+ }
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
+#ifndef USE_GDBUS
static DBusMessage* __get_message(int pid, const char* method, int type)
{
char service_name[64];
return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
}
+#endif
int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id)
{
+#ifdef USE_GDBUS
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vc_mgr_dbus_send_result_selection(int pid)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_call_vcm_daemon_method_result_selection(g_daemon_proxy,
+ pid, NULL, NULL, NULL);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
}
return 0;
+#endif
}
int vc_mgr_dbus_send_specific_engine_request(int pid, const char* engine_app_id, const char* event, const char* request)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_call_vcm_daemon_method_specific_engine_request(g_daemon_proxy,
+ pid, engine_app_id, event, request, NULL, NULL, NULL);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, int utt_status)
{
+#ifdef USE_GDBUS
+ /* To Client */
+ //gdbus_vcdaemon_call_vcm_daemon_method_utterance_status(g_daemon_proxy,
+ // utt_id, utt_status, NULL, NULL, NULL);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vc_mgr_dbus_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
{
+#ifdef USE_GDBUS
+ GVariant *variant = g_variant_new_from_data(G_VARIANT_TYPE ("ay"),
+ buffer, len, TRUE, NULL, NULL);
+
+ gdbus_vcdaemon_call_vcm_daemon_method_send_audio_streaming(g_daemon_proxy,
+ pid, event, len, variant, NULL, NULL, NULL);
+
+ return 0;
+#else
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
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;
}
+#ifdef USE_GDBUS
+ if (false == g_daemon_name_appeared) {
+ int 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;
+ }
+
+ GError *error = NULL;
+ gint result;
+ if (!gdbus_vcdaemon_call_vcm_daemon_method_change_system_volume_sync(g_daemon_proxy,
+ pid, volume_event, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCM, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
+ if (0 != __dbus_check()) {
+ return VC_ERROR_OPERATION_FAILED;
+ }
DBusError err;
dbus_error_init(&err);
}
return result;
+#endif
}
#include "vc_setting_dbus.h"
#include "vc_main.h"
+#define USE_GDBUS
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
+
+static GDBusVcdaemon *g_daemon_proxy = NULL;
+static int g_own_name_id = 0;
+
+#else
static int g_s_waiting_time = 3000;
static Ecore_Fd_Handler* g_s_fd_handler = NULL;
static DBusConnection* g_s_conn_sender = NULL;
static DBusConnection* g_s_conn_listener = NULL;
+#endif
+#ifndef USE_GDBUS
static Eina_Bool listener_setting_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
if (NULL == g_s_conn_listener) return ECORE_CALLBACK_RENEW;
g_s_conn_sender = NULL;
}
}
+#endif
+
+#ifdef USE_GDBUS
+static void
+on_name_acquired(GDBusConnection *connection,
+ const gchar *name,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCS, "Name acquired : %s", name);
+
+ GDBusVcsetting *service;
+ GError *error = NULL;
+
+ service = gdbus_vcsetting_skeleton_new();
+
+ g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(service),
+ connection, VC_SETTING_SERVICE_OBJECT_PATH, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCS, "Error : %s\n", error->message);
+ g_error_free(error);
+ }
+}
+
+#endif
int vc_setting_dbus_open_connection()
{
+#ifdef USE_GDBUS
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_SETTING_SERVICE_NAME, pid);
+ g_own_name_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+ service_name, 0, NULL, on_name_acquired, NULL, NULL, NULL);
+ SLOG(LOG_DEBUG, TAG_VCS, "service_name : %s, %d", service_name, g_own_name_id);
+
+ GError *error = NULL;
+ g_daemon_proxy = gdbus_vcdaemon_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ VC_DAEMON_SERVICE_NAME, VC_DAEMON_SERVICE_OBJECT_PATH, NULL, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCS, "Error : %s", error->message);
+ g_error_free(error);
+ }
+ return 0;
+#else
if (NULL != g_s_conn_sender && NULL != g_s_conn_listener) {
SLOG(LOG_WARN, TAG_VCS, "already existed connection ");
return 0;
}
return 0;
+#endif
}
int vc_setting_dbus_close_connection()
{
+#ifdef USE_GDBUS
+ if (g_daemon_proxy) {
+ g_object_unref(g_daemon_proxy);
+ g_daemon_proxy = NULL;
+ }
+ if (g_own_name_id) {
+ g_bus_unown_name(g_own_name_id);
+ g_own_name_id = 0;
+ }
+ return 0;
+#else
DBusError err;
dbus_error_init(&err);
__vc_setting_dbus_connection_free();
return 0;
+#endif
}
int vc_setting_dbus_reconnect()
{
+#ifdef USE_GDBUS
+ if (!g_own_name_id || !g_daemon_proxy) {
+ vc_setting_dbus_close_connection();
+
+ if (0 != vc_setting_dbus_open_connection()) {
+ SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to reconnect"); //LCOV_EXCL_LINE
+ return -1;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCS, "[DBUS] Reconnect"); //LCOV_EXCL_LINE
+ }
+ return 0;
+#else
if (!g_s_conn_sender || !g_s_conn_listener) {
vc_setting_dbus_close_connection();
}
return 0;
+#endif
}
int vc_setting_dbus_request_hello()
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vc_method_hello_sync(g_daemon_proxy, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCS, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCS, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (NULL == g_s_conn_sender) {
return VC_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vc_setting_dbus_request_set_language(int pid, const char* language)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcs_daemon_method_set_language_sync(g_daemon_proxy,
+ pid, language, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCS, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCS, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
if (NULL == g_s_conn_sender) {
SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Dbus does not open");
return VC_ERROR_OPERATION_FAILED;
}
return result;
+#endif
}
#include "vc_widget_client.h"
#include "vc_widget_dbus.h"
+#define USE_GDBUS
-static pthread_mutex_t g_w_dbus_mutex = PTHREAD_MUTEX_INITIALIZER;
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
+
+static GDBusVcdaemon *g_daemon_proxy = NULL;
+static int g_own_name_id = 0;
+#else
static pthread_mutex_t g_w_init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t g_w_dbus_mutex = PTHREAD_MUTEX_INITIALIZER;
static int g_w_waiting_time = 3000;
static int g_w_waiting_short_time = 200;
+
static bool g_is_connection_opened = false;
static Ecore_Fd_Handler* g_w_fd_handler = NULL;
-static DBusConnection* g_w_conn_sender = NULL;
static DBusConnection* g_w_conn_listener = NULL;
+static DBusConnection* g_w_conn_sender = NULL;
+#endif
extern int __vc_widget_cb_error(int reason, int daemon_pid, char* msg);
extern int __vc_widget_cb_service_state(int state);
-
+#ifndef USE_GDBUS
static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
if (NULL == g_w_conn_listener) return ECORE_CALLBACK_RENEW;
g_w_conn_sender = NULL;
}
}
+#endif
+
+#ifdef USE_GDBUS
+
+gboolean vcd_widget_method_hello(GDBusVcwidget *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int response = -1;
+
+ if (pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get hello : pid(%d) ", pid);
+ response = 1;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get hello : invalid pid ");
+ }
+
+ gdbus_vcwidget_complete_vcd_widget_method_hello(service, invocation, response);
+ return TRUE;
+}
+
+gboolean vcd_widget_method_show_tooltip(GDBusVcwidget *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean show, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget show tooltip : pid(%d), show(%d)", pid, show);
+ __vc_widget_cb_show_tooltip(pid, show);
+
+ gdbus_vcwidget_complete_vcd_widget_method_show_tooltip(service, invocation);
+ return TRUE;
+}
+
+gboolean vcd_widget_method_result(GDBusVcwidget *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean show, gpointer user_data)
+{
+ __vc_widget_cb_result();
+
+ gdbus_vcwidget_complete_vcd_widget_method_result(service, invocation);
+ return TRUE;
+}
+
+
+gboolean vcd_widget_method_asr_result(GDBusVcwidget *service, GDBusMethodInvocation *invocation,
+ int event, const gchar* asr_result, gpointer user_data)
+{
+ int ret = 0;
+
+ if (false == __vc_widget_cb_asr_result(event, asr_result))
+ ret = 0;
+ else
+ ret = 1;
+
+ SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get asr result, event(%d), asr_result(%s), consumed(%d)", event, asr_result, ret);
+ gdbus_vcwidget_complete_vcd_widget_method_asr_result(service, invocation, ret);
+ return TRUE;
+}
+
+static void
+on_name_acquired(GDBusConnection *connection,
+ const gchar *name,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCW, "Name acquired : %s", name);
+
+ GDBusVcwidget *service;
+ GError *error = NULL;
+
+ service = gdbus_vcwidget_skeleton_new();
+
+ /* vc daemon methods */
+ g_signal_connect(service, "handle-vcd-widget-method-hello",
+ G_CALLBACK(vcd_widget_method_hello), NULL);
+ g_signal_connect(service, "handle-vcd-widget-method-result",
+ G_CALLBACK(vcd_widget_method_result), NULL);
+ g_signal_connect(service, "handle-vcd-widget-method-asr-result",
+ G_CALLBACK(vcd_widget_method_asr_result), NULL);
+ g_signal_connect(service, "handle-vcd-widget-method-show-tooltip",
+ G_CALLBACK(vcd_widget_method_show_tooltip), NULL);
+
+ g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(service),
+ connection, VC_WIDGET_SERVICE_OBJECT_PATH, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCW, "Error : %s\n", error->message);
+ g_error_free(error);
+ }
+}
+#endif
int vc_widget_dbus_open_connection()
{
+#ifdef USE_GDBUS
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ g_own_name_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+ service_name, 0, NULL, on_name_acquired, NULL, NULL, NULL);
+ SLOG(LOG_DEBUG, TAG_VCW, "service_name : %s, %d", service_name, g_own_name_id);
+
+ GError *error = NULL;
+ g_daemon_proxy = gdbus_vcdaemon_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ VC_DAEMON_SERVICE_NAME, VC_DAEMON_SERVICE_OBJECT_PATH, NULL, &error);
+ if (error) {
+ SLOG(LOG_DEBUG, TAG_VCW, "Error : %s", error->message);
+ g_error_free(error);
+ }
+ return 0;
+#else
pthread_mutex_lock(&g_w_dbus_mutex);
if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
SLOG(LOG_INFO, TAG_VCW, "[INFO] widget dbus connection is opened");
- return 0;
+return 0;
+#endif
}
int vc_widget_dbus_close_connection()
{
+#ifdef USE_GDBUS
+ if (g_daemon_proxy) {
+ g_object_unref(g_daemon_proxy);
+ g_daemon_proxy = NULL;
+ }
+ if (g_own_name_id) {
+ g_bus_unown_name(g_own_name_id);
+ g_own_name_id = 0;
+ }
+ return 0;
+#else
pthread_mutex_lock(&g_w_dbus_mutex);
DBusError err;
dbus_error_init(&err);
if (NULL != g_w_fd_handler) {
- ecore_main_fd_handler_del(g_w_fd_handler);
- g_w_fd_handler = NULL;
+ ecore_main_fd_handler_del(g_w_fd_handler);
+ g_w_fd_handler = NULL;
}
if (NULL != g_w_conn_listener) {
SLOG(LOG_INFO, TAG_VCW, "[INFO] widget dbus connection is closed");
return 0;
+#endif
}
int vc_widget_dbus_reconnect()
{
+#ifdef USE_GDBUS
+ if (!g_own_name_id || !g_daemon_proxy) {
+ vc_widget_dbus_close_connection();
+
+ if (0 != vc_widget_dbus_open_connection()) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect"); //LCOV_EXCL_LINE
+ return -1;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect"); //LCOV_EXCL_LINE
+ }
+ return 0;
+#else
if (!g_w_conn_sender || !g_w_conn_listener) {
vc_widget_dbus_close_connection();
}
return 0;
+#endif
}
static int __dbus_check()
{
+#ifdef USE_GDBUS
+ SLOG(LOG_DEBUG, TAG_VCW, "%d %p", g_own_name_id, g_daemon_proxy); //LCOV_EXCL_LINE
+ if (0 == g_own_name_id || NULL == g_daemon_proxy) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NULL connection"); //LCOV_EXCL_LINE
+ return vc_widget_dbus_reconnect();
+ }
+ return 0;
+#else
if (NULL == g_w_conn_sender || NULL == g_w_conn_listener) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NULL connection");
return vc_widget_dbus_reconnect();
}
return 0;
+#endif
+}
+
+static GDBusVcmanager* get_manager_proxy() {
+ char service_name[64] = {0,};
+ char object_path[64] = {0,};
+
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
+
+ GError *error = NULL;
+ GDBusVcmanager *proxy = gdbus_vcmanager_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ service_name, object_path, NULL, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCC, "[DBUS] Proxy : %p, service_name(%s), object_path(%s) : %s",
+ proxy, service_name, object_path, error->message);
+ g_error_free(error);
+ }
+
+ return proxy;
}
int vc_widget_dbus_request_hello()
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result = 0;
+ if (!gdbus_vcdaemon_call_vc_method_hello_sync(g_daemon_proxy, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCW, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
int vc_widget_dbus_request_initialize(int pid, int* service_state, int* daemon_pid)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_initialize_sync(g_daemon_proxy,
+ pid, &result, service_state, daemon_pid, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
pthread_mutex_lock(&g_w_init_mutex);
if (0 != __dbus_check()) {
pthread_mutex_unlock(&g_w_init_mutex);
pthread_mutex_unlock(&g_w_init_mutex);
return result;
+#endif
}
int vc_widget_dbus_request_finalize(int pid)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_finalize_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
pthread_mutex_lock(&g_w_init_mutex);
if (0 != __dbus_check()) {
pthread_mutex_unlock(&g_w_init_mutex);
pthread_mutex_unlock(&g_w_init_mutex);
return result;
+#endif
}
int vc_widget_dbus_request_start_recording(int pid, bool command)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_start_recording_sync(g_daemon_proxy,
+ pid, command, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
msg = dbus_message_new_method_call(
}
return result;
+#endif
}
int vc_widget_dbus_set_foreground(int pid, bool value)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ /* To Manager */
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcw_manager_method_set_foreground(proxy,
+ pid, value, NULL, NULL, NULL);
+ if (proxy) g_object_unref(proxy);
+ return 0;
+#else
DBusMessage* msg = NULL;
int tmp_value = 0;
dbus_message_unref(msg);
return 0;
+#endif
}
int vc_widget_dbus_request_enable_asr_result(int pid, bool enable)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_start_recording_sync(g_daemon_proxy,
+ pid, enable, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
/* create a signal & check for errors */
}
return result;
+#endif
}
int vc_widget_dbus_request_start(int pid, int silence)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_start_sync(g_daemon_proxy,
+ pid, silence, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
/* create a signal & check for errors */
}
return result;
+#endif
}
int vc_widget_dbus_request_stop(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_stop_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
/* create a signal & check for errors */
}
return result;
+#endif
}
int vc_widget_dbus_request_cancel(int pid)
if (0 != __dbus_check()) {
return VC_ERROR_OPERATION_FAILED;
}
-
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ int result;
+ if (!gdbus_vcdaemon_call_vcw_daemon_method_cancel_sync(g_daemon_proxy,
+ pid, &result, NULL, &error)) {
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCW, "Error : %s", error->message);
+ result = VC_ERROR_OPERATION_FAILED;
+ g_error_free(error);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "Failed without explicit error");
+ }
+ }
+ return result;
+#else
DBusMessage* msg;
/* create a signal & check for errors */
}
return result;
+#endif
}
*******************************************************************************************/
#define VC_CLIENT_SERVICE_NAME "org.tizen.voice.vcclient"
-#define VC_CLIENT_SERVICE_OBJECT_PATH "/org/tize/voice/vcclient"
+#define VC_CLIENT_SERVICE_OBJECT_PATH "/org/tizen/voice/vcclient"
#define VC_CLIENT_SERVICE_INTERFACE "org.tizen.voice.vcclient"
#define VC_WIDGET_SERVICE_NAME "org.tizen.voice.vcwidget"
#define VC_WIDGET_SERVICE_INTERFACE "org.tizen.voice.vcwidget"
#define VC_MANAGER_SERVICE_NAME "org.tizen.voice.vcmanager"
-#define VC_MANAGER_SERVICE_OBJECT_PATH "/org/tize/voice/vcmanager"
+#define VC_MANAGER_SERVICE_OBJECT_PATH "/org/tizen/voice/vcmanager"
#define VC_MANAGER_SERVICE_INTERFACE "org.tizen.voice.vcmanager"
-#define VC_SERVER_SERVICE_NAME "org.tizen.voice.vcserver"
-#define VC_SERVER_SERVICE_OBJECT_PATH "/org/tizen/voice/vcserver"
-#define VC_SERVER_SERVICE_INTERFACE "org.tizen.voice.vcserver"
+#define VC_DAEMON_SERVICE_NAME "org.tizen.voice.vcdaemon"
+#define VC_DAEMON_SERVICE_OBJECT_PATH "/org/tizen/voice/vcdaemon"
+#define VC_DAEMON_SERVICE_INTERFACE "org.tizen.voice.vcdaemon"
#define VC_SETTING_SERVICE_NAME "org.tizen.voice.vcsetting"
-#define VC_SETTING_SERVICE_OBJECT_PATH "/org/tize/voice/vcsetting"
+#define VC_SETTING_SERVICE_OBJECT_PATH "/org/tizen/voice/vcsetting"
#define VC_SETTING_SERVICE_INTERFACE "org.tizen.voice.vcsetting"
/******************************************************************************************
[D-BUS Service]
-Name=org.tizen.voice.vcserver
+Name=org.tizen.voice.vcdaemon
#Exec=/usr/bin/vc-daemon
#Exec=/bin/sh -c "launch_app org.tizen.vc-engine-default"
Exec=/bin/sh -c "vc_getengine get system db/voice/vc/engine/default | awk '{print$5}' | xargs -t -i launch_app {}"
[D-BUS Service]
-Name=org.tizen.voice.vcserver
+Name=org.tizen.voice.vcdaemon
#Exec=/usr/bin/vc-daemon
Exec=/bin/sh -c "launch_app org.tizen.voice-client"
--- /dev/null
+<node>
+ <interface name="org.tizen.voice.vcdaemon">
+ <!-- vc common signals //-->
+ <signal name="vcd_signal_set_service_state">
+ <arg name="state" direction="in" type="i"/>
+ </signal>
+ <!-- vc common methods //-->
+ <method name="vc_method_hello">
+ </method>
+ <!-- vc client signals //-->
+ <signal name="vcd_client_signal_send_error">
+ <arg name="reason" direction="in" type="i"/>
+ <arg name="daemon_pid" direction="in" type="i"/>
+ <arg name="err_msg" direction="in" type="s"/>
+ </signal>
+ <signal name="vcd_client_signal_send_manager_pid">
+ <arg name="manager_pid" direction="in" type="i"/>
+ </signal>
+ <!-- vc client methods //-->
+ <method name="vcc_daemon_method_initialize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="mgr_pid" direction="out" type="i"/>
+ <arg name="service_state" direction="out" type="i"/>
+ <arg name="daemon_pid" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_finalize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_set_exclusive_cmd">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="value" direction="in" type="b"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_set_command">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="cmd_type" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_unset_command">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="cmd_type" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_set_foreground">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="value" direction="in" type="b"/>
+ </method>
+ <method name="vcc_daemon_method_set_server_dialog">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="app_id" direction="in" type="s"/>
+ <arg name="credential" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_dialog">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="disp_text" direction="in" type="s"/>
+ <arg name="utt_text" direction="in" type="s"/>
+ <arg name="continuous" direction="in" type="b"/>
+ </method>
+ <method name="vcc_daemon_method_is_system_command_valid">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="sys_cmd" direction="out" type="b"/>
+ </method>
+ <method name="vcc_daemon_method_request_tts">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="text" direction="in" type="s"/>
+ <arg name="language" direction="in" type="s"/>
+ <arg name="to_vcm" direction="in" type="b"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="utt_id" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_cancel_tts">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="utt_id" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcc_daemon_method_get_tts_audio_format">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="rate" direction="out" type="i"/>
+ <arg name="channel" direction="out" type="i"/>
+ <arg name="audio_type" direction="out" type="i"/>
+ </method>
+ <!-- vc widget signals //-->
+ <signal name="vcd_widget_signal_send_error">
+ <arg name="reason" direction="in" type="i"/>
+ <arg name="daemon_pid" direction="in" type="i"/>
+ <arg name="err_msg" direction="in" type="s"/>
+ </signal>
+ <!-- vc widget methods //-->
+ <method name="vcw_daemon_method_initialize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="service_state" direction="out" type="i"/>
+ <arg name="daemon_pid" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_finalize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_start_recording">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="widget_command" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_enable_asr_result">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="enabel" direction="in" type="b"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_start">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="silence" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_stop">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_cancel">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcw_daemon_method_set_foreground">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="value" direction="in" type="b"/>
+ </method>
+ <!-- vc manager signals //-->
+ <signal name="vcd_manager_signal_send_error">
+ <arg name="reason" direction="in" type="i"/>
+ <arg name="daemon_pid" direction="in" type="i"/>
+ <arg name="err_msg" direction="in" type="s"/>
+ </signal>
+ <!-- vc manager methods //-->
+ <method name="vcm_daemon_method_initialize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="audio_streaming_mode" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="service_state" direction="out" type="i"/>
+ <arg name="foreground" direction="out" type="i"/>
+ <arg name="daemon_pid" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_finalize">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_set_command">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_unset_command">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_set_demandable_client">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_set_audio_type">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="audio_type" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_get_audio_type">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="audio_type" direction="out" type="s"/>
+ </method>
+ <method name="vcm_daemon_method_set_client_info">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_set_private_data">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="key" direction="in" type="s"/>
+ <arg name="data" direction="in" type="s"/>
+ </method>
+ <method name="vcm_daemon_method_get_private_data">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="key" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="data" direction="out" type="s"/>
+ </method>
+ <method name="vcm_daemon_method_enable_command_type">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="cmd_type" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_disable_command_type">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="cmd_type" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_request_start">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="recognition_mode" direction="in" type="i"/>
+ <arg name="exclusive_command_option" direction="in" type="b"/>
+ <arg name="start_by_client" direction="in" type="b"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_request_stop">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_request_cancel">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_result_selection">
+ <arg name="pid" direction="in" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_set_domain">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="key" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcm_daemon_method_do_action">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="type" direction="in" type="i"/>
+ <arg name="send_event" direction="in" type="s"/>
+ </method>
+ <method name="vcm_daemon_method_specific_engine_request">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="engine_app_id" direction="in" type="s"/>
+ <arg name="event" direction="in" type="s"/>
+ <arg name="request" direction="in" type="s"/>
+ </method>
+ <method name="vcm_daemon_method_send_audio_streaming">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="event" direction="in" type="i"/>
+ <arg name="size" direction="in" type="u"/>
+ <arg name="buffer" direction="in" type="ay">
+ <annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
+ </arg>
+ </method>
+ <method name="vcm_daemon_method_change_system_volume">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="volume_event" direction="in" type="i"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <!-- vc setting methods //-->
+ <method name="vcs_daemon_method_set_language">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="language" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ </interface>
+ <interface name="org.tizen.voice.vcclient">
+ <!-- vc daemon methods //-->
+ <method name="vcd_client_method_hello">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="response" direction="out" type="i"/>
+ </method>
+ <method name="vcd_client_method_result">
+ </method>
+ <method name="vcd_client_method_feedback_streaming">
+ <arg name="utt_id" direction="in" type="i"/>
+ <arg name="event" direction="in" type="i"/>
+ <arg name="size" direction="in" type="u"/>
+ <arg name="buffer" direction="in" type="ay">
+ <annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
+ </arg>
+ </method>
+ <!-- vc manager methods //-->
+ <method name="vcm_client_method_utterance_status">
+ <arg name="utt_id" direction="in" type="i"/>
+ <arg name="utt_status" direction="in" type="i"/>
+ </method>
+ </interface>
+ <interface name="org.tizen.voice.vcsetting">
+ </interface>
+ <interface name="org.tizen.voice.vcmanager">
+ <!-- vc client methods //-->
+ <method name="vcc_manager_method_set_foreground">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="value" direction="in" type="b"/>
+ </method>
+ <!-- vc daemon methods //-->
+ <method name="vcd_manager_method_hello">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="response" direction="out" type="i"/>
+ </method>
+ <method name="vcd_manager_method_speech_detected">
+ </method>
+ <method name="vcd_manager_method_all_result">
+ <arg name="result_type" direction="in" type="i"/>
+ </method>
+ <method name="vcd_manager_method_pre_result">
+ <arg name="event" direction="in" type="i"/>
+ <arg name="pre_result" direction="in" type="s"/>
+ </method>
+ <method name="vcd_manager_method_result">
+ </method>
+ <method name="vcd_manager_method_set_volume">
+ <arg name="volume" direction="in" type="i"/>
+ </method>
+ <method name="vcd_manager_method_dialog">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="disp_text" direction="in" type="s"/>
+ <arg name="utt_text" direction="in" type="s"/>
+ <arg name="continuous" direction="in" type="b"/>
+ </method>
+ <method name="vcd_manager_method_set_private_data">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="key" direction="in" type="s"/>
+ <arg name="data" direction="in" type="s"/>
+ </method>
+ <method name="vcd_manager_method_get_private_data">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="key" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ <arg name="value" direction="out" type="s"/>
+ </method>
+ <method name="vcd_manager_method_specific_engine_result">
+ <arg name="engine_app_id" direction="in" type="s"/>
+ <arg name="event" direction="in" type="s"/>
+ <arg name="result" direction="in" type="s"/>
+ </method>
+ <method name="vcd_manager_method_feedback_audio_format">
+ <arg name="rate" direction="in" type="i"/>
+ <arg name="channel" direction="in" type="i"/>
+ <arg name="audio_type" direction="in" type="i"/>
+ </method>
+ <method name="vcd_manager_method_feedback_streaming">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="utt_id" direction="in" type="i"/>
+ <arg name="event" direction="in" type="i"/>
+ <arg name="size" direction="in" type="u"/>
+ <arg name="buffer" direction="in" type="ay">
+ <annotation name="org.gtk.GDBus.C.ForceGVariant" value="true"/>
+ </arg>
+ </method>
+ <!-- vc widget methods //-->
+ <method name="vcw_manager_method_set_foreground">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="value" direction="in" type="b"/>
+ </method>
+ </interface>
+ <interface name="org.tizen.voice.vcwidget">
+ <!-- vc daemon methods //-->
+ <method name="vcd_widget_method_result">
+ </method>
+ <method name="vcd_widget_method_asr_result">
+ <arg name="event" direction="in" type="i"/>
+ <arg name="asr_result" direction="in" type="s"/>
+ <arg name="result" direction="out" type="i"/>
+ </method>
+ <method name="vcd_widget_method_hello">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="response" direction="out" type="i"/>
+ </method>
+ <method name="vcd_widget_method_show_tooltip">
+ <arg name="pid" direction="in" type="i"/>
+ <arg name="show" direction="in" type="b"/>
+ </method>
+ </interface>
+</node>
BuildRequires: pkgconfig(sqlite3)
BuildRequires: pkgconfig(pkgmgr-info)
BuildRequires: pkgconfig(pkgmgr-installer)
+BuildRequires: pkgconfig(gio-2.0)
+BuildRequires: pkgconfig(gio-unix-2.0)
%if "%{tizen_profile_name}" == "tv"
BuildRequires: pkgconfig(capi-network-bluetooth)
BuildRequires: pkgconfig(capi-network-bluetooth-tv)
rm -rf %{buildroot}
%if "%{tizen_profile_name}" == "tv"
-mv -f org.tizen.voice.vcserver.tv.service org.tizen.voice.vcserver.service
+mv -f org.tizen.voice.vcdaemon.tv.service org.tizen.voice.vcdaemon.service
%endif
%make_install
%{TZ_SYS_RO_SHARE}/dbus-1/services/org.tizen.voice*
%{TZ_SYS_RO_SHARE}/parser-plugins/voice-control.info
%{TZ_SYS_RO_ETC}/package-manager/parserlib/metadata/libvc-engine-parser.so*
-/etc/dbus-1/session.d/vc-server.conf
+/etc/dbus-1/session.d/vc-service.conf
%files devel
%manifest %{name}-devel.manifest
../common/vc_config_parser.c
../common/vc_info_parser.c
../common/vc_json_parser.c
+ ../common/vc_gdbus.c
vcd_client_data.c
vcd_server_data.cpp
vcd_config.c
#include "vcd_dbus_server.h"
#include "vcd_main.h"
+#define USE_GDBUS
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
+static GDBusVcdaemon *g_daemon = NULL;
+static int g_own_name_id = 0;
+#else
+static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
static DBusConnection* g_conn_sender = NULL;
static DBusConnection* g_conn_listener = NULL;
-static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
-
static int g_waiting_time = 3000;
+#endif
+
static int g_volume_count = 0;
+#ifdef USE_GDBUS
+static GDBusVcmanager* get_manager_proxy() {
+ char service_name[64] = {0,};
+ char object_path[64] = {0,};
+
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
+
+ GError *error = NULL;
+ GDBusVcmanager *proxy = gdbus_vcmanager_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ service_name, object_path, NULL, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "[DBUS] Proxy : %p, service_name(%s), object_path(%s) : %s",
+ proxy, service_name, object_path, error->message);
+ g_error_free(error);
+ }
+
+ return proxy;
+}
+
+static GDBusVcclient* get_client_proxy(int pid) {
+ char service_name[64] = {0,};
+ char object_path[64] = {0,};
+
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
+
+ GError *error = NULL;
+ GDBusVcclient *proxy = gdbus_vcclient_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ service_name, object_path, NULL, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "[DBUS] Proxy : %p, service_name(%s), object_path(%s) : %s",
+ proxy, service_name, object_path, error->message);
+ g_error_free(error);
+ }
+
+ return proxy;
+}
+
+static GDBusVcwidget* get_widget_proxy(int pid) {
+ char service_name[64] = {0,};
+ char object_path[64] = {0,};
+
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
+
+ GError *error = NULL;
+ GDBusVcwidget *proxy = gdbus_vcwidget_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, 0,
+ service_name, object_path, NULL, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "[DBUS] Proxy : %p, service_name(%s), object_path(%s) : %s",
+ proxy, service_name, object_path, error->message);
+ g_error_free(error);
+ }
+ return proxy;
+}
+#else
static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type)
{
char service_name[64] = {0,};
return result;
}
+#endif
int vcdc_send_show_tooltip(int pid, bool show)
{
+#ifdef USE_GDBUS
+ GDBusVcwidget* proxy = get_widget_proxy(pid);
+ gdbus_vcwidget_call_vcd_widget_method_show_tooltip(proxy,
+ pid, show, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_set_volume(int manger_pid, float volume)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_set_volume(proxy,
+ volume, NULL, NULL, NULL);
+ g_object_unref(proxy);
+
+ if (10 == g_volume_count) {
+ SLOG(LOG_DEBUG, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume);
+ g_volume_count = 0;
+ }
+ g_volume_count++;
+
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_result(int pid, int manager_pid, int cmd_type)
{
+#ifdef USE_GDBUS
+ SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
+
+ switch (cmd_type) {
+ case VC_COMMAND_TYPE_FOREGROUND:
+ case VC_COMMAND_TYPE_BACKGROUND:
+ if (pid == manager_pid) {
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_result(proxy, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ } else {
+ GDBusVcclient* proxy = get_client_proxy(pid);
+ gdbus_vcclient_call_vcd_client_method_result(proxy, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ }
+ break;
+ case VC_COMMAND_TYPE_WIDGET: {
+ GDBusVcwidget* proxy = get_widget_proxy(pid);
+ gdbus_vcwidget_call_vcd_widget_method_result(proxy, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ }
+ break;
+ case VC_COMMAND_TYPE_SYSTEM:
+ case VC_COMMAND_TYPE_SYSTEM_BACKGROUND:
+ case VC_COMMAND_TYPE_EXCLUSIVE: {
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_result(proxy, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ }
+ break;
+
+ default:
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
+ return -1;
+ }
+
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_type, bool* is_consumed)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ gint result = 0;
+ GDBusVcwidget* proxy = get_widget_proxy(pid);
+ gdbus_vcwidget_call_vcd_widget_method_asr_result_sync(proxy,
+ event, asr_result, &result, NULL, &error);
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
SLOG(LOG_ERROR, TAG_VCD, "@@ Result message is NULL ");
return VCD_ERROR_OPERATION_FAILED;
}
+#endif
}
int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_pre_result(proxy,
+ event, pre_result, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
}
return 0;
+#endif
}
int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_specific_engine_result(proxy,
+ engine_app_id, event, result, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
SLOG(LOG_DEBUG, 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);
}
return 0;
+#endif
}
int vcdc_send_result_to_manager(int manger_pid, int result_type)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
+ gdbus_vcmanager_call_vcd_manager_method_all_result(proxy,
+ result_type, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_speech_detected(int manger_pid)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_speech_detected(proxy,
+ NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_service_state(vcd_state_e state)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_emit_vcd_signal_set_service_state(g_daemon, state);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_manager_pid(int manager_pid)
{
+#ifdef USE_GDBUS
+ gdbus_vcdaemon_emit_vcd_client_signal_send_manager_pid(g_daemon, manager_pid);
+#else
DBusError err;
dbus_error_init(&err);
}
dbus_message_unref(msg);
-
+#endif
return 0;
}
int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_dialog(proxy,
+ pid, disp_text, utt_text, continuous, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
}
return ret;
+#endif
}
int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
{
+#ifdef USE_GDBUS
+ int daemon_pid = getpid();
+ gdbus_vcdaemon_emit_vcd_manager_signal_send_error(g_daemon, reason, daemon_pid, err_msg);
+ return 0;
+#else
SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal to manager");
if (0 != __dbus_check()) {
}
return 0;
+#endif
}
int vcdc_send_error_signal(int reason, char *err_msg)
{
+#ifdef USE_GDBUS
+ int daemon_pid = getpid();
+ gdbus_vcdaemon_emit_vcd_client_signal_send_error(g_daemon, reason, daemon_pid, err_msg);
+ gdbus_vcdaemon_emit_vcd_manager_signal_send_error(g_daemon, reason, daemon_pid, err_msg);
+ gdbus_vcdaemon_emit_vcd_widget_signal_send_error(g_daemon, reason, daemon_pid, err_msg);
+ return 0;
+#else
SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal");
if (NULL == err_msg) {
dbus_message_unref(msg);
return 0;
+#endif
}
int vcdc_send_request_set_private_data(int pid, const char* key, const char* data)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_set_private_data(proxy,
+ pid, key, data, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(msg);
return VCD_ERROR_NONE;
+#endif
}
int vcdc_send_request_get_private_data(int pid, const char* key, char** data)
{
+#ifdef USE_GDBUS
+ GError *error = NULL;
+ gint result = 0;
+ gchar* value = NULL;
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_get_private_data_sync(proxy,
+ pid, key, &result, &value, NULL, &error);
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", error->message);
+ g_error_free(error);
+ }
+ if (NULL != data && NULL != value) {
+ *data = strdup(value);
+ }
+ g_object_unref(proxy);
+ return 0;
+#else
if (0 != __dbus_check()) {
return VCD_ERROR_OPERATION_FAILED;
}
}
return result;
+#endif
}
int vcdc_send_feedback_audio_format_to_manager(int manager_pid, int rate, vc_audio_channel_e channel, vce_audio_type_e audio_type)
{
+#ifdef USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ gdbus_vcmanager_call_vcd_manager_method_feedback_audio_format(proxy,
+ rate, channel, audio_type, NULL, NULL, NULL);
+ g_object_unref(proxy);
+ return 0;
+#else
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()) {
dbus_message_unref(msg);
return ret;
+#endif
}
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 USE_GDBUS
+ GDBusVcmanager* proxy = get_manager_proxy();
+ GVariant *variant = g_variant_new_from_data(G_VARIANT_TYPE ("ay"),
+ buffer, len, TRUE, NULL, NULL);
+
+ gdbus_vcmanager_call_vcd_manager_method_feedback_streaming(proxy,
+ pid, utt_id, event, len, variant, NULL, NULL, NULL);
+
+ g_object_unref(proxy);
+ return 0;
+#else
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()) {
dbus_message_unref(msg);
return ret;
+#endif
}
int vcdc_send_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len)
{
+#ifdef USE_GDBUS
+ GDBusVcclient* proxy = get_client_proxy(pid);
+ GVariant *variant = g_variant_new_from_data(G_VARIANT_TYPE ("ay"),
+ buffer, len, TRUE, NULL, NULL);
+
+ gdbus_vcclient_call_vcd_client_method_feedback_streaming(proxy,
+ utt_id, event, len, variant, NULL, NULL, NULL);
+
+ g_object_unref(proxy);
+ return 0;
+#else
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 (0 != __dbus_check()) {
dbus_message_unref(msg);
return ret;
+#endif
}
+#ifndef USE_GDBUS
static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
g_conn_sender = NULL;
}
}
+#endif
+
+#ifdef USE_GDBUS
+static void
+on_name_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "Name acquired : %s", name);
+
+ GError *error = NULL;
+
+ g_daemon = gdbus_vcdaemon_skeleton_new();
+
+ /* vc common methods */
+ g_signal_connect(g_daemon, "handle-vc-method-hello",
+ G_CALLBACK(vc_method_hello), NULL);
+
+ /* vc client methods */
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-initialize",
+ G_CALLBACK(vcc_daemon_method_initialize), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-finalize",
+ G_CALLBACK(vcc_daemon_method_finalize), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-set-exclusive-cmd",
+ G_CALLBACK(vcc_daemon_method_set_exclusive_cmd), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-set-command",
+ G_CALLBACK(vcc_daemon_method_set_command), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-unset-command",
+ G_CALLBACK(vcc_daemon_method_unset_command), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-set-foreground",
+ G_CALLBACK(vcc_daemon_method_set_foreground), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-set-server-dialog",
+ G_CALLBACK(vcc_daemon_method_set_server_dialog), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-dialog",
+ G_CALLBACK(vcc_daemon_method_dialog), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-is-system-command-valid",
+ G_CALLBACK(vcc_daemon_method_is_system_command_valid), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-request-tts",
+ G_CALLBACK(vcc_daemon_method_request_tts), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-cancel-tts",
+ G_CALLBACK(vcc_daemon_method_cancel_tts), NULL);
+ g_signal_connect(g_daemon, "handle-vcc-daemon-method-get-tts-audio-format",
+ G_CALLBACK(vcc_daemon_method_get_tts_audio_format), NULL);
+
+ /* vc widget methods */
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-initialize",
+ G_CALLBACK(vcw_daemon_method_initialize), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-finalize",
+ G_CALLBACK(vcw_daemon_method_finalize), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-start-recording",
+ G_CALLBACK(vcw_daemon_method_start_recording), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-enable-asr-result",
+ G_CALLBACK(vcw_daemon_method_enable_asr_result), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-start",
+ G_CALLBACK(vcw_daemon_method_start), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-stop",
+ G_CALLBACK(vcw_daemon_method_stop), NULL);
+ g_signal_connect(g_daemon, "handle-vcw-daemon-method-cancel",
+ G_CALLBACK(vcw_daemon_method_cancel), NULL);
+
+ /* vc manager methods */
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-initialize",
+ G_CALLBACK(vcm_daemon_method_initialize), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-finalize",
+ G_CALLBACK(vcm_daemon_method_finalize), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-command",
+ G_CALLBACK(vcm_daemon_method_set_command), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-unset-command",
+ G_CALLBACK(vcm_daemon_method_unset_command), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-demandable-client",
+ G_CALLBACK(vcm_daemon_method_set_demandable_client), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-audio-type",
+ G_CALLBACK(vcm_daemon_method_set_audio_type), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-get-audio-type",
+ G_CALLBACK(vcm_daemon_method_get_audio_type), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-client-info",
+ G_CALLBACK(vcm_daemon_method_set_client_info), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-private-data",
+ G_CALLBACK(vcm_daemon_method_set_private_data), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-get-private-data",
+ G_CALLBACK(vcm_daemon_method_get_private_data), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-enable-command-type",
+ G_CALLBACK(vcm_daemon_method_enable_command_type), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-disable-command-type",
+ G_CALLBACK(vcm_daemon_method_disable_command_type), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-request-start",
+ G_CALLBACK(vcm_daemon_method_request_start), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-request-stop",
+ G_CALLBACK(vcm_daemon_method_request_stop), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-request-cancel",
+ G_CALLBACK(vcm_daemon_method_request_cancel), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-result-selection",
+ G_CALLBACK(vcm_daemon_method_result_selection), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-set-domain",
+ G_CALLBACK(vcm_daemon_method_set_domain), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-do-action",
+ G_CALLBACK(vcm_daemon_method_do_action), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-specific-engine-request",
+ G_CALLBACK(vcm_daemon_method_specific_engine_request), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-send-audio-streaming",
+ G_CALLBACK(vcm_daemon_method_send_audio_streaming), NULL);
+ g_signal_connect(g_daemon, "handle-vcm-daemon-method-change-system-volume",
+ G_CALLBACK(vcm_daemon_method_change_system_volume), NULL);
+
+ /* vc setting methods */
+ g_signal_connect(g_daemon, "handle-vcs-daemon-method-set-language",
+ G_CALLBACK(vcs_daemon_method_set_language), NULL);
+
+ g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(g_daemon),
+ connection, VC_DAEMON_SERVICE_OBJECT_PATH, &error);
+
+ if (error) {
+ SLOG(LOG_ERROR, TAG_VCD, "Exporting interface error : %s", error->message);
+ g_error_free(error);
+ }
+}
+#endif
int vcd_dbus_open_connection()
{
+#ifdef USE_GDBUS
+ g_own_name_id = g_bus_own_name(G_BUS_TYPE_SESSION,
+ VC_DAEMON_SERVICE_NAME, G_BUS_NAME_OWNER_FLAGS_REPLACE, NULL, on_name_acquired, NULL, NULL, NULL);
+ SLOG(LOG_DEBUG, TAG_VCD, "g_bus_own_name returned %d", g_own_name_id);
+#else
DBusError err;
dbus_error_init(&err);
}
SLOG(LOG_INFO, TAG_VCD, "[INFO] Success to open dbus connection");
-
+#endif
return 0;
}
int vcd_dbus_close_connection()
{
+#ifdef USE_GDBUS
+ if (g_daemon) {
+ g_object_unref(g_daemon);
+ g_daemon = NULL;
+ }
+ if (g_own_name_id) {
+ g_bus_unown_name(g_own_name_id);
+ g_own_name_id = 0;
+ }
+#else
DBusError err;
dbus_error_init(&err);
}
__vcd_dbus_connection_free();
+#endif
return 0;
}
#include "vcd_server.h"
#include "vcd_config.h"
+#define USE_GDBUS
+
+#ifdef USE_GDBUS
+gboolean vc_method_hello(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[ENTER]");
+ gdbus_vcdaemon_complete_vc_method_hello(service, invocation);
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_initialize(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to initialize");
+ }
+
+ int service_state = vcd_server_get_service_state();
+ int daemon_pid = getpid();
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
+
+ int mgr_pid = vcd_client_manager_get_pid();
+
+ if (0 == ret) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
+ }
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_initialize(service, invocation,
+ ret, mgr_pid, service_state, daemon_pid);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_finalize(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to finalize");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd finalize : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_finalize(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_set_exclusive_cmd(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data)
+{
+ /*
+ int ret = vcd_server_set_exclusive_command(pid, value);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_exclusive_cmd");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set_exclusive_cmd : pid(%d), exclusive(%d)", pid, value);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_set_exclusive_cmd(service, invocation, ret);
+ */
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_set_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data)
+{
+ int ret = vcd_server_set_command(pid, (vc_cmd_type_e)cmd_type);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_command");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set_command : pid(%d), cmd_type(%d)", pid, cmd_type);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_set_command(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_unset_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data)
+{
+ int ret = vcd_server_unset_command(pid, (vc_cmd_type_e)cmd_type);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset_command");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd unset_command : pid(%d), cmd_type(%d)", pid, cmd_type);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_unset_command(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_set_foreground(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data)
+{
+ int ret = vcd_server_set_foreground(pid, value);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_foreground");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set_foreground : pid(%d), value(%d)", pid, value);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_set_foreground(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_set_server_dialog(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* app_id, const gchar* credential, gpointer user_data)
+{
+ int ret = vcd_server_set_server_dialog(pid, app_id, credential);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_server_dialog");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set_server_dialog : pid(%d), app_id(%s)", pid, app_id);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_set_server_dialog(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_dialog(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* disp_text, const gchar* utt_text, gboolean continuous, gpointer user_data)
+{
+ int ret = vcd_server_dialog(pid, disp_text, utt_text, continuous);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to dialog");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd dialog : pid(%d), disp_text(%s), utt_text(%s)", pid, disp_text, utt_text);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_dialog(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_is_system_command_valid(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int is_sys_cmd_valid;
+ int ret = vcd_server_is_system_command_valid(pid, &is_sys_cmd_valid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to is_system_command_valid");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd is_system_command_valid : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_is_system_command_valid(service, invocation,
+ ret, is_sys_cmd_valid);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_request_tts(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* text, const gchar* language, gboolean to_vcm, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd request tts : pid(%d), text(%s), language(%s), to_vcm(%d)",
+ pid, text, language, to_vcm);
+
+ int utt_id = -1;
+ int ret = vcd_server_request_tts(pid, text, language, to_vcm, &utt_id);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to request_tts");
+ }
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_request_tts(service, invocation, ret, utt_id);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_cancel_tts(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int utt_id, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd cancel tts : pid(%d), utt_id(%d)", pid, utt_id);
+
+ int ret = vcd_server_cancel_tts(pid, utt_id);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to cancel_tts");
+ }
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_cancel_tts(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcc_daemon_method_get_tts_audio_format(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd get tts audio format : pid(%d)", pid);
+
+ int rate;
+ int channel;
+ int audio_type;
+ int ret = vcd_server_get_tts_audio_format(pid, &rate, &channel, &audio_type);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get_tts_audio_format");
+ }
+
+ gdbus_vcdaemon_complete_vcc_daemon_method_get_tts_audio_format(service, invocation,
+ ret, rate, channel, audio_type);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_widget_initialize(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to widget_initialize");
+ }
+ int service_state = vcd_server_get_service_state();
+ int daemon_pid = getpid();
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_initialize(service, invocation,
+ ret, service_state, daemon_pid);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget finalize : pid(%d)", pid);
+
+ int ret = vcd_server_widget_finalize(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to widget_finalize");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_finalize(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_start_recording(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int widget_command, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start recording : pid(%d)", pid);
+
+ int ret = vcd_server_widget_start_recording(pid, widget_command);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to start_recording");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_start_recording(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_enable_asr_result(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean enable, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget enable asr result : pid(%d) enable(%d)", pid, enable);
+
+ int ret = vcd_server_widget_enable_asr_result(pid, enable);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to enable_asr_result");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_enable_asr_result(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_start(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean silence, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start : pid(%d), silence(%d)", pid, silence);
+
+ int ret = vcd_server_widget_start(pid, silence);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to start");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_start(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_stop(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget stop : pid(%d)", pid);
+
+ int ret = vcd_server_widget_stop(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to stop");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_stop(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_cancel(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget cancel : pid(%d)", pid);
+
+ int ret = vcd_server_widget_cancel(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to cancel");
+ }
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_cancel(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcw_daemon_method_set_foreground(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data)
+{
+ int ret = vcd_server_set_foreground(pid, value);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_foreground");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set_foreground : pid(%d), value(%d)", pid, value);
+
+ gdbus_vcdaemon_complete_vcw_daemon_method_set_foreground(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int streaming_mode, gpointer user_data)
+{
+ vcd_config_set_audio_streaming_mode((vcd_audio_streaming_mode_e)streaming_mode);
+ int ret = vcd_server_mgr_initialize(pid);
+ int service_state = vcd_server_get_service_state();
+ int foreground = vcd_server_get_foreground();
+ int daemon_pid = getpid();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to initialize");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_initialize(service, invocation,
+ ret, service_state, foreground, daemon_pid);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_finalize(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to finalize");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_finalize(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_set_command(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_command");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_command(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_unset_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_unset_command(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to unset_command");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_unset_command(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_demandable_client(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_set_demandable_client(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_demandable_client");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_demandable_client(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_audio_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* audio_type, gpointer user_data)
+{
+ int ret = vcd_server_mgr_set_audio_type(pid, audio_type);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_audio_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_audio_type(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_get_audio_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ char* audio_type = NULL;
+ int ret = vcd_server_mgr_get_audio_type(pid, &audio_type);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_audio_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr get audio type : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_get_audio_type(service, invocation, ret, audio_type);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_client_info(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_set_client_info(pid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_client_info");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_client_info(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_private_data(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* key, const gchar* data, gpointer user_data)
+{
+ int 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, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_private_data(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_get_private_data(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* key, gpointer user_data)
+{
+ char* data = NULL;
+ int ret = vcd_server_mgr_get_private_data(pid, key, &data);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to get_private_data");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_get_private_data(service, invocation, ret, data);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_enable_command_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data)
+{
+ int ret = vcd_server_mgr_enable_command_type(pid, cmd_type);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to enable_command_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr enable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_enable_command_type(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_disable_command_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data)
+{
+ int ret = vcd_server_mgr_disable_command_type(pid, cmd_type);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to disable_command_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr disable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_disable_command_type(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_request_start(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int recognition_mode, gboolean exclusive, gboolean start_by_client, gpointer user_data)
+{
+ int ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, exclusive, start_by_client);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to request_start");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive, start_by_client);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_request_start(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_request_stop(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_stop();
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to request_stop");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_request_stop(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_request_cancel(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ int ret = vcd_server_mgr_cancel();
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to request_cancel");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_request_cancel(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_result_selection(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data)
+{
+ vcd_server_mgr_result_select();
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_result_selection(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_set_domain(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* domain, gpointer user_data)
+{
+ int ret = vcd_server_mgr_set_domain(pid, domain);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to disable_command_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_set_domain(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_do_action(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int type, const gchar* send_event, gpointer user_data)
+{
+ int ret = vcd_server_mgr_do_action(pid, type, send_event);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to disable_command_type");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_do_action(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_specific_engine_request(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* engine_app_id, const gchar* event, const gchar* request, gpointer user_data)
+{
+ int ret = vcd_server_mgr_send_specific_engine_request(pid, engine_app_id, event, request);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to specific_engine_request");
+ }
+
+ SLOG(LOG_DEBUG, 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, request, ret);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_specific_engine_request(service, invocation);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_send_audio_streaming(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int event, GVariant *buffer, gpointer user_data)
+{
+ int len = 0;
+ GVariantIter *iter;
+ guchar uc;
+ const int MAX_STREAMING_DATA_SIZE = 4096;
+ unsigned char data[MAX_STREAMING_DATA_SIZE];
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_send_audio_streaming(service, invocation);
+
+ g_variant_get(buffer, "ay", &iter);
+ while (g_variant_iter_loop(iter, "y", &uc)) {
+ if (len < MAX_STREAMING_DATA_SIZE) {
+ data[len++] = uc;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] max size reached : %d", len);
+ }
+ }
+ g_variant_iter_free(iter);
+
+ int ret = vcd_server_mgr_send_audio_streaming(pid, event, data, len);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to send_audio_streaming");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, data, len);
+
+ return TRUE;
+}
+
+gboolean vcm_daemon_method_change_system_volume(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int volume_event, gpointer user_data)
+{
+ int ret = vcd_server_mgr_change_system_volume(pid, volume_event);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to change_system_volume");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr change system volume: pid(%d), volume_event(%d)", pid, volume_event);
+
+ gdbus_vcdaemon_complete_vcm_daemon_method_change_system_volume(service, invocation, ret);
+
+ return TRUE;
+}
+
+gboolean vcs_daemon_method_set_language(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* language, gpointer user_data)
+{
+ int ret = vcd_server_set_language(language);
+
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set_language");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd server set language : language(%s)", language);
+
+ gdbus_vcdaemon_complete_vcs_daemon_method_set_language(service, invocation, ret);
+
+ return TRUE;
+}
+#else
int __dbus_error_return(DBusConnection* conn, DBusMessage* msg, int ret)
{
DBusMessage* reply;
return 0;
}
+#endif
\ No newline at end of file
extern "C" {
#endif
+#define USE_GDBUS
+
+#ifdef USE_GDBUS
+#include "vc_gdbus.h"
+
+/*
+* Dbus Common Server functions
+*/
+gboolean vc_method_hello(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ gpointer user_data);
+
+/*
+* Dbus Server functions for client
+*/
+gboolean vcc_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcc_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcc_daemon_method_set_exclusive_cmd(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data);
+
+gboolean vcc_daemon_method_set_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data);
+
+gboolean vcc_daemon_method_unset_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data);
+
+gboolean vcc_daemon_method_set_foreground(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data);
+
+gboolean vcc_daemon_method_set_server_dialog(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* app_id, const gchar* credential, gpointer user_data);
+
+gboolean vcc_daemon_method_dialog(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* disp_text, const gchar* utt_text, gboolean continuous, gpointer user_data);
+
+gboolean vcc_daemon_method_is_system_command_valid(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcc_daemon_method_request_tts(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* text, const gchar* language, gboolean to_vcm, gpointer user_data);
+
+gboolean vcc_daemon_method_cancel_tts(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int utt_id, gpointer user_data);
+
+gboolean vcc_daemon_method_get_tts_audio_format(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+/*
+* Dbus Server functions for widget
+*/
+
+gboolean vcw_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcw_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcw_daemon_method_start_recording(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int widget_command, gpointer user_data);
+
+gboolean vcw_daemon_method_enable_asr_result(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean enable, gpointer user_data);
+
+gboolean vcw_daemon_method_start(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean silence, gpointer user_data);
+
+gboolean vcw_daemon_method_stop(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcw_daemon_method_cancel(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcw_daemon_method_set_foreground(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gboolean value, gpointer user_data);
+
+/*
+* Dbus Server functions for manager
+*/
+
+gboolean vcm_daemon_method_initialize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int streaming_mode, gpointer user_data);
+
+gboolean vcm_daemon_method_finalize(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_unset_command(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_demandable_client(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_audio_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* audio_type, gpointer user_data);
+
+gboolean vcm_daemon_method_get_audio_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_client_info(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_private_data(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* key, const gchar* data, gpointer user_data);
+
+gboolean vcm_daemon_method_get_private_data(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* key, gpointer user_data);
+
+gboolean vcm_daemon_method_enable_command_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data);
+
+gboolean vcm_daemon_method_disable_command_type(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int cmd_type, gpointer user_data);
+
+gboolean vcm_daemon_method_request_start(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int recognition_mode, gboolean exclusive, gboolean start_by_client, gpointer user_data);
+
+gboolean vcm_daemon_method_request_stop(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_request_cancel(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_result_selection(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, gpointer user_data);
+
+gboolean vcm_daemon_method_set_domain(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* domain, gpointer user_data);
+
+gboolean vcm_daemon_method_do_action(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int type, const gchar* send_event, gpointer user_data);
+
+gboolean vcm_daemon_method_specific_engine_request(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* engine_app_id, const gchar* event, const gchar* request, gpointer user_data);
+
+gboolean vcm_daemon_method_send_audio_streaming(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int event, GVariant *buffer, gpointer user_data);
+
+gboolean vcm_daemon_method_change_system_volume(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, int volume_event, gpointer user_data);
+
+/*
+* Dbus Server functions for setting
+*/
+
+gboolean vcs_daemon_method_set_language(GDBusVcdaemon *service, GDBusMethodInvocation *invocation,
+ int pid, const gchar* language, gpointer user_data);
+
+#else
int vcd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg);
/*
int vcd_dbus_server_get_tts_audio_format(DBusConnection* conn, DBusMessage* msg);
+#endif
#ifdef __cplusplus
}
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail ecore_init()");
return VCE_ERROR_OPERATION_FAILED;
}
+ if (!ecore_main_loop_glib_integrate()) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail ecore_main_loop_glib_integrate()");
+ return VCE_ERROR_OPERATION_FAILED;
+ }
// if (0 != vcd_dbus_open_connection()) {
// SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to open connection");
<allow own_prefix="org.tizen.voice.vcmanager"/>
<allow send_destination="org.tizen.voice.vcmanager"/>
- <allow own="org.tizen.voice.vcserver"/>
- <allow send_destination="org.tizen.voice.vcserver"/>
+ <allow own="org.tizen.voice.vcdaemon"/>
+ <allow send_destination="org.tizen.voice.vcdaemon"/>
</policy>
</busconfig>
projects / platform / core / uifw / voice-control.git / commitdiff