SET(PREFIX ${CMAKE_INSTALL_PREFIX})
SET(EXEC_PREFIX "${PREFIX}")
-SET(VERSION 0.2.7)
+SET(VERSION 0.2.8)
# pkg config tool
INCLUDE(FindPkgConfig)
## config ##
INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-config.xml DESTINATION /usr/lib/voice/vc/1.0)
+
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-server.conf DESTINATION /etc/dbus-1/system.d)
+
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/org.tizen.voice.vcserver.service DESTINATION /usr/share/dbus-1/system-services)
+voice-control (0.2.8) -- Thu, 18 Jun 2015
+
+ * Update IPC and remove volume file (Dongyeol Lee <dy3.lee@samsung.com>)
+ * Add daemon activation by dbus (Kwangyoun Kim <ky85.kim@samsung.com>)
+
vc (0.2.7) -- Wed, 21 Jan 2015
* Add result message from engine (Wonnam Jang <wn.jang@samsung.com>)
* Change sequence for engine and recorder stop (Kwangyoun Kim <ky85.kim@samsung.com>)
* Add authority feature (Kwangyoun Kim <ky85.kim@samsung.com>)
+ * Remove unused smack label (Kwangyoun Kim <ky85.kim@samsung.com>)
vc (0.2.6) -- Mon, 08 Dec 2014
#include "voice_control_command_expand.h"
-static bool g_is_daemon_started = false;
static Ecore_Timer* g_connect_timer = NULL;
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
}
- g_is_daemon_started = false;
#if 0
ecore_event_handler_del(g_focus_in_hander);
}
#endif
-static void __vc_fork_vc_daemon()
-{
- int pid, i;
- pid = fork();
-
- switch(pid) {
- case -1:
- SLOG(LOG_ERROR, TAG_VCC, "Fail to create daemon");
- break;
- case 0:
- setsid();
- for (i = 0;i < _NSIG;i++)
- signal(i, SIG_DFL);
-
- execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
- break;
- default:
- break;
- }
- return;
-}
-
static Eina_Bool __vc_connect_daemon(void *data)
{
/* Send hello */
if (0 != vc_dbus_request_hello()) {
- if (false == g_is_daemon_started) {
- g_is_daemon_started = true;
- __vc_fork_vc_daemon();
- }
return EINA_TRUE;
}
return VC_ERROR_INVALID_STATE;
}
- g_is_daemon_started = false;
g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
SLOG(LOG_DEBUG, TAG_VCC, " ");
- return VC_ERROR_INVALID_STATE;
+ return VC_ERROR_INVALID_PARAMETER;
}
vc_cmd_list_s* list = NULL;
static Ecore_Fd_Handler* g_fd_handler = NULL;
-static DBusConnection* g_conn = NULL;
-
+static DBusConnection* g_conn_sender = NULL;
+static DBusConnection* g_conn_listener = NULL;
extern int __vc_cb_error(int pid, int reason);
static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
- DBusConnection* conn = (DBusConnection*)data;
- DBusMessage* msg = NULL;
- DBusMessage *reply = NULL;
-
- if (NULL == conn)
- return ECORE_CALLBACK_RENEW;
+ if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
- dbus_connection_read_write_dispatch(conn, 50);
+ dbus_connection_read_write_dispatch(g_conn_listener, 50);
- msg = dbus_connection_pop_message(conn);
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_conn_listener);
/* loop again if we haven't read a message */
if (NULL == msg) {
dbus_error_init(&err);
char if_name[64];
- snprintf(if_name, 64, "%s%d", VC_CLIENT_SERVICE_INTERFACE, getpid());
+ snprintf(if_name, 64, "%s", VC_CLIENT_SERVICE_INTERFACE);
if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_HELLO)) {
SLOG(LOG_DEBUG, TAG_VCC, "===== Get Hello");
SLOG(LOG_ERROR, TAG_VCC, "<<<< vc get hello : invalid pid ");
}
+ DBusMessage* reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get hello : result(%d)", response);
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ dbus_connection_flush(g_conn_listener);
+ dbus_message_unref(reply);
} else {
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
}
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get result : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get result");
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ dbus_connection_flush(g_conn_listener);
+ dbus_message_unref(reply);
} else {
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get result : fail to create reply message");
}
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc Error message : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc Error message");
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ dbus_connection_flush(g_conn_listener);
+ dbus_message_unref(reply);
} else {
SLOG(LOG_ERROR, TAG_VCC, ">>>> vc Error message : fail to create reply message");
}
int vc_dbus_open_connection()
{
- if (NULL != g_conn) {
+ if (NULL != g_conn_sender && NULL != g_conn_listener) {
SLOG(LOG_WARN, TAG_VCC, "already existed connection ");
return 0;
}
dbus_error_init(&err);
/* connect to the DBUS system bus, and check for errors */
- g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+ g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
dbus_error_free(&err);
}
- if (NULL == g_conn) {
+ if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (NULL == g_conn_listener) {
+ SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
+ return VC_ERROR_OPERATION_FAILED;
}
int pid = getpid();
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
/* register our name on the bus, and check for errors */
- ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+ ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
}
char rule[128];
- snprintf(rule, 128, "type='signal',interface='%s%d'", VC_CLIENT_SERVICE_INTERFACE, pid);
+ snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
- dbus_bus_add_match(g_conn, rule, &err);
- dbus_connection_flush(g_conn);
+ dbus_bus_add_match(g_conn_listener, rule, &err);
+ dbus_connection_flush(g_conn_listener);
if (dbus_error_is_set(&err))
{
}
int fd = 0;
- if (1 != dbus_connection_get_unix_fd(g_conn, &fd)) {
+ if (1 != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
SLOG(LOG_ERROR, TAG_VCC, "fail to get fd from dbus ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, "Get fd from dbus : %d", fd);
}
- g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
-
+ g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
if (NULL == g_fd_handler) {
SLOG(LOG_ERROR, TAG_VCC, "fail to get fd handler from ecore ");
return VC_ERROR_OPERATION_FAILED;
DBusError err;
dbus_error_init(&err);
+ if (NULL != g_fd_handler) {
+ ecore_main_fd_handler_del(g_fd_handler);
+ g_fd_handler = NULL;
+ }
+
int pid = getpid();
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
- dbus_bus_release_name (g_conn, service_name, &err);
+ dbus_bus_release_name(g_conn_listener, service_name, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
dbus_error_free(&err);
}
- dbus_connection_close(g_conn);
-
- g_fd_handler = NULL;
- g_conn = NULL;
+ g_conn_sender = NULL;
+ g_conn_listener = NULL;
return 0;
}
int vc_dbus_reconnect()
{
- bool connected = dbus_connection_get_is_connected(g_conn);
- SECURE_SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] %s", connected ? "Connected" : "Not connected");
+ bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
+ bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
+ SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Sender(%s) Listener(%s)",
+ sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
- if (false == connected) {
+ if (false == sender_connected || false == listener_connected) {
vc_dbus_close_connection();
if (0 != vc_dbus_open_connection()) {
DBusMessage* result_msg = NULL;
int result = 0;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err);
-
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
+
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
}
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
#define VC_MANAGER_CONFIG_HANDLE 100000
-static bool g_m_is_daemon_started = false;
-
static Ecore_Timer* g_m_connect_timer = NULL;
static vc_h g_vc_m = NULL;
static GSList* g_demandable_client_list = NULL;
-
static Eina_Bool __vc_mgr_notify_state_changed(void *data);
static Eina_Bool __vc_mgr_notify_error(void *data);
static Eina_Bool __vc_mgr_notify_result(void *data);
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
}
- g_m_is_daemon_started = false;
vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
return VC_ERROR_NONE;
}
-static void* __fork_vc_daemon()
-{
- int pid, i;
- pid = fork();
-
- switch(pid) {
- case -1:
- SLOG(LOG_ERROR, TAG_VCM, "Fail to create daemon");
- break;
- case 0:
- setsid();
- for (i = 0;i < _NSIG;i++)
- signal(i, SIG_DFL);
-
- execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
- break;
- default:
- break;
- }
-
- return (void*) 1;
-}
-
static Eina_Bool __vc_mgr_connect_daemon(void *data)
{
/* Send hello */
if (0 != vc_mgr_dbus_request_hello()) {
- if (false == g_m_is_daemon_started) {
- g_m_is_daemon_started = true;
-
- pthread_t thread;
- int thread_id;
- thread_id = pthread_create(&thread, NULL, __fork_vc_daemon, NULL);
- if (thread_id < 0) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to make thread");
- g_m_connect_timer = NULL;
- return EINA_FALSE;
- }
-
- pthread_detach(thread);
- }
return EINA_TRUE;
}
return VC_ERROR_INVALID_STATE;
}
- g_m_is_daemon_started = false;
g_m_connect_timer = ecore_timer_add(0, __vc_mgr_connect_daemon, NULL);
static Ecore_Fd_Handler* g_m_fd_handler = NULL;
-static DBusConnection* g_m_conn = NULL;
+static DBusConnection* g_m_conn_sender = NULL;
+static DBusConnection* g_m_conn_listener = NULL;
extern void __vc_mgr_cb_all_result();
static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
- DBusConnection* conn = (DBusConnection*)data;
- DBusMessage* msg = NULL;
- DBusMessage *reply = NULL;
-
- if (NULL == conn)
- return ECORE_CALLBACK_RENEW;
+ if (NULL == g_m_conn_listener) return ECORE_CALLBACK_RENEW;
- dbus_connection_read_write_dispatch(conn, 50);
+ dbus_connection_read_write_dispatch(g_m_conn_listener, 50);
- msg = dbus_connection_pop_message(conn);
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_m_conn_listener);
/* loop again if we haven't read a message */
if (NULL == msg) {
dbus_error_init(&err);
char if_name[64];
- snprintf(if_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, getpid());
+ snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
SLOG(LOG_DEBUG, TAG_VCM, "===== Get Hello");
}
if (pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc get hello : pid(%d) ", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get hello : pid(%d) ", pid);
response = 1;
} else {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc get hello : invalid pid ");
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get hello : invalid pid ");
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, ">>>> vc get hello : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc get hello : result(%d)", response);
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ dbus_connection_flush(g_m_conn_listener);
+ dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc get hello : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get hello : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
__vc_mgr_cb_speech_detected();
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get speech detected : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get speech detected");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get speech detected : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
__vc_mgr_cb_all_result();
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get all result : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get all result");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get all result : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
__vc_mgr_cb_system_result();
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get system result : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get system result");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get system result : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
__vc_mgr_cb_error(pid, reason);
}
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc Error message : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc Error message");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc Error message : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
}/* VCD_MANAGER_METHOD_ERROR */
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc request auth enable : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth enable : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc request auth enable : pid(%d)", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth enable : pid(%d)", pid);
ret = __vc_mgr_request_auth_enable(pid);
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply ,NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth enable : fail to send reply");
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth enable : ret(%d)", ret);
- dbus_connection_flush(conn);
+ SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth enable : ret(%d)", ret);
+ dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth enable : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc request auth disable : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth disable : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc request auth disable : pid(%d)", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth disable : pid(%d)", pid);
ret = __vc_mgr_request_auth_disable(pid);
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth disable : fail to send reply");
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth disable : ret(%d)", ret);
- dbus_connection_flush(conn);
+ SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth disable : ret(%d)", ret);
+ dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth disable : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc request auth start : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth start : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc request auth start : pid(%d)", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth start : pid(%d)", pid);
ret = __vc_mgr_request_auth_start(pid);
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth start : fail to send reply");
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth start : ret(%d)", ret);
- dbus_connection_flush(conn);
+ SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth start : ret(%d)", ret);
+ dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth start : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc request auth stop : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth stop : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc request auth stop : pid(%d)", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth stop : pid(%d)", pid);
ret = __vc_mgr_request_auth_stop(pid);
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth stop : fail to send reply");
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth stop : ret(%d)", ret);
- dbus_connection_flush(conn);
+ SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth stop : ret(%d)", ret);
+ dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth stop : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc request auth cancel : Get arguments error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth cancel : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc request auth cancel : pid(%d)", pid);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth cancel : pid(%d)", pid);
ret = __vc_mgr_request_auth_cancel(pid);
}
+ DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth cancel : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth cancel : ret(%d)", ret);
- dbus_connection_flush(conn);
+ dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth cancel : fail to create reply message");
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth cancel : fail to create reply message");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
int vc_mgr_dbus_open_connection()
{
- if (NULL != g_m_conn) {
+ if (NULL != g_m_conn_sender && NULL != g_m_conn_listener) {
SLOG(LOG_WARN, TAG_VCM, "already existed connection ");
return 0;
}
dbus_error_init(&err);
/* connect to the DBUS system bus, and check for errors */
- g_m_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+ g_m_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (NULL == g_m_conn_sender) {
+ SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ /* connect to the DBUS system bus, and check for errors */
+ g_m_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
dbus_error_free(&err);
}
- if (NULL == g_m_conn) {
+ if (NULL == g_m_conn_listener) {
SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
return VC_ERROR_OPERATION_FAILED;
}
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", service_name);
/* register our name on the bus, and check for errors */
- ret = dbus_bus_request_name(g_m_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+ ret = dbus_bus_request_name(g_m_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
}
char rule[128];
- snprintf(rule, 128, "type='signal',interface='%s%d'", VC_MANAGER_SERVICE_INTERFACE, pid);
+ snprintf(rule, 128, "type='signal',interface='%s'", VC_MANAGER_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
- dbus_bus_add_match(g_m_conn, rule, &err);
- dbus_connection_flush(g_m_conn);
+ dbus_bus_add_match(g_m_conn_listener, rule, &err);
+ dbus_connection_flush(g_m_conn_listener);
if (dbus_error_is_set(&err))
{
}
int fd = 0;
- if (1 != dbus_connection_get_unix_fd(g_m_conn, &fd)) {
+ if (1 != dbus_connection_get_unix_fd(g_m_conn_listener, &fd)) {
SLOG(LOG_ERROR, TAG_VCM, "fail to get fd from dbus ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, "Get fd from dbus : %d", fd);
}
- g_m_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)vc_mgr_listener_event_callback, g_m_conn, NULL, NULL);
+ g_m_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)vc_mgr_listener_event_callback, g_m_conn_listener, NULL, NULL);
if (NULL == g_m_fd_handler) {
SLOG(LOG_ERROR, TAG_VCM, "fail to get fd handler from ecore ");
DBusError err;
dbus_error_init(&err);
+ if (NULL != g_m_fd_handler) {
+ ecore_main_fd_handler_del(g_m_fd_handler);
+ g_m_fd_handler = NULL;
+ }
+
int pid = getpid();
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
- dbus_bus_release_name (g_m_conn, service_name, &err);
+ dbus_bus_release_name(g_m_conn_listener, service_name, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
dbus_error_free(&err);
}
- dbus_connection_close(g_m_conn);
-
- g_m_fd_handler = NULL;
- g_m_conn = NULL;
+ g_m_conn_sender = NULL;
+ g_m_conn_listener = NULL;
return 0;
}
int vc_mgr_dbus_reconnect()
{
- bool connected = dbus_connection_get_is_connected(g_m_conn);
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] %s", connected ? "Connected" : "Not connected");
+ bool sender_connected = dbus_connection_get_is_connected(g_m_conn_sender);
+ bool listener_connected = dbus_connection_get_is_connected(g_m_conn_listener);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Sender(%s) Listener(%s)",
+ sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
- if (false == connected) {
+ if (false == sender_connected || false == listener_connected) {
vc_mgr_dbus_close_connection();
if (0 != vc_mgr_dbus_open_connection()) {
SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
}
+
return 0;
}
DBusMessage* result_msg = NULL;
int result = 0;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, 500, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, 500, &err);
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
int result = VC_ERROR_OPERATION_FAILED;
char* temp = NULL;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
return result;
}
-#if 0
-int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option)
-{
- DBusMessage* msg;
-
- /* create a signal & check for errors */
- msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_START);
-
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr start : Fail to make message ");
- return VC_ERROR_OPERATION_FAILED;
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr start : pid(%d), silence(%d) exclusive(%d)",
- pid, silence, exclusive_command_option);
- }
-
- int temp = exclusive_command_option;
-
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &(silence),
- DBUS_TYPE_INT32, &(temp),
- DBUS_TYPE_INVALID);
-
- DBusError err;
- dbus_error_init(&err);
-
- DBusMessage* result_msg;
- int result = VC_ERROR_OPERATION_FAILED;
-
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
- }
-
- if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- result = VC_ERROR_OPERATION_FAILED;
- }
- dbus_message_unref(result_msg);
-
- if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr start : result = %d", result);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr start : result = %d", result);
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
- vc_mgr_dbus_reconnect();
- result = VC_ERROR_TIMED_OUT;
- }
-
- return result;
-}
-#endif
-
int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option, bool start_by_client)
{
DBusMessage* msg;
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
memset(target_if_name, '\0', 128);
if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_NAME);
+
} else if (VC_COMMAND_TYPE_WIDGET == type) {
- snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
+ snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
} else {
return NULL;
}
dbus_message_set_no_reply(msg, TRUE);
/* send the message and flush the connection */
- if (!dbus_connection_send(g_m_conn, msg, NULL)) {
- SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
+ if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Success to send result");
- dbus_connection_flush(g_m_conn);
+ dbus_connection_flush(g_m_conn_sender);
}
dbus_message_unref(msg);
DBUS_TYPE_INVALID);
dbus_message_set_no_reply(msg, TRUE);
-
- if (1 != dbus_connection_send(g_m_conn, msg, NULL)) {
+
+ if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
return -1;
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_m_conn);
- return 0;
- }
-
- /*
- DBusError err;
- dbus_error_init(&err);
-
- DBusMessage* result_msg;
- int result = VC_ERROR_OPERATION_FAILED;
-
- result_msg = dbus_connection_send_with_reply_and_block(g_m_conn, msg, g_m_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_connection_flush(g_m_conn_sender);
}
- if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- result = VC_ERROR_OPERATION_FAILED;
- }
- dbus_message_unref(result_msg);
-
- if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc result selection : result = %d", result);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc result selection : result = %d", result);
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
- vc_mgr_dbus_reconnect();
- result = VC_ERROR_TIMED_OUT;
- }
-
- return result;
- */
+ return 0;
}
int vc_mgr_dbus_request_set_client_info(int pid);
-#if 0
-int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option);
-#endif
-
int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option, bool start_by_client);
int vc_mgr_dbus_request_stop(int pid);
return VC_ERROR_NONE;
}
-//int vc_setting_finalize()
-//{
-// SLOG(LOG_DEBUG, TAG_VCS, "===== Finalize VC Setting");
-//
-// vc_config_mgr_unset_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE);
-// vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
-//
-// g_state = VC_SETTING_STATE_NONE;
-//
-// SLOG(LOG_DEBUG, TAG_VCS, "=====");
-// SLOG(LOG_DEBUG, TAG_VCS, " ");
-//
-// return VC_ERROR_NONE;
-//}
-
int vc_setting_deinitialize()
{
SLOG(LOG_DEBUG, TAG_VCS, "===== Deinitialize VC Setting");
#define VC_WIDGET_CONFIG_HANDLE 200000
-static bool g_w_is_daemon_started = false;
-
static Ecore_Timer* g_w_connect_timer = NULL;
static Ecore_Timer* g_w_start_timer = NULL;
SLOG(LOG_WARN, TAG_VCW, "[ERROR] Fail to request finalize : %s", __vc_widget_get_error_code(ret));
}
- g_w_is_daemon_started = false;
-
vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
return;
return VC_ERROR_NONE;
}
-static void __vc_widget_fork_vc_daemon()
-{
- int pid, i;
- pid = fork();
-
- switch(pid) {
- case -1:
- SLOG(LOG_ERROR, TAG_VCW, "Fail to create daemon");
- break;
- case 0:
- setsid();
- for (i = 0;i < _NSIG;i++)
- signal(i, SIG_DFL);
-
- execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
- break;
- default:
- break;
- }
- return;
-}
-
static Eina_Bool __vc_widget_connect_daemon(void *data)
{
/* Send hello */
if (0 != vc_widget_dbus_request_hello()) {
- if (false == g_w_is_daemon_started) {
- g_w_is_daemon_started = true;
- __vc_widget_fork_vc_daemon();
- }
return EINA_TRUE;
}
return VC_ERROR_INVALID_STATE;
}
- g_w_is_daemon_started = false;
-
g_w_connect_timer = ecore_timer_add(0, __vc_widget_connect_daemon, NULL);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
static Ecore_Fd_Handler* g_w_fd_handler = NULL;
-static DBusConnection* g_w_conn = NULL;
-
+static DBusConnection* g_w_conn_sender = NULL;
+static DBusConnection* g_w_conn_listener = NULL;
extern int __vc_widget_cb_error(int pid, int reason);
static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
- DBusConnection* conn = (DBusConnection*)data;
- DBusMessage* msg = NULL;
- DBusMessage *reply = NULL;
-
- if (NULL == conn)
- return ECORE_CALLBACK_RENEW;
+ if (NULL == g_w_conn_listener) return ECORE_CALLBACK_RENEW;
- dbus_connection_read_write_dispatch(conn, 50);
+ dbus_connection_read_write_dispatch(g_w_conn_listener, 50);
- msg = dbus_connection_pop_message(conn);
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_w_conn_listener);
/* loop again if we haven't read a message */
if (NULL == msg) {
dbus_error_init(&err);
char if_name[64];
- snprintf(if_name, 64, "%s%d", VC_WIDGET_SERVICE_INTERFACE, getpid());
+ snprintf(if_name, 64, "%s", VC_WIDGET_SERVICE_INTERFACE);
if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_HELLO)) {
SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget hello");
SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get hello : invalid pid ");
}
+ DBusMessage* reply = NULL;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- if (!dbus_connection_send(conn, reply, NULL))
+ if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get hello : fail to send reply");
else
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget get hello : result(%d)", response);
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
+ dbus_connection_flush(g_w_conn_listener);
+ dbus_message_unref(reply);
} else {
SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get hello : fail to create reply message");
}
SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget show tooltip : invalid pid");
}
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget show tooltip : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget show tooltip");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget show tooltip : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
} /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
__vc_widget_cb_result();
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get result : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget get result");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get result : fail to create reply message");
-
- */
-
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
__vc_widget_cb_error(pid, reason);
}
- /*
- reply = dbus_message_new_method_return(msg);
-
- if (NULL != reply) {
- if (!dbus_connection_send(conn, reply, NULL))
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget error message : fail to send reply");
- else
- SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget error message");
-
- dbus_connection_flush(conn);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget error message : fail to create reply message");
- }
- */
-
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
} /* VCD_WIDGET_METHOD_ERROR */
int vc_widget_dbus_open_connection()
{
- if (NULL != g_w_conn) {
+ if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
SLOG(LOG_WARN, TAG_VCW, "Already existed connection ");
return 0;
}
dbus_error_init(&err);
/* connect to the DBUS system bus, and check for errors */
- g_w_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+ g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
}
- if (NULL == g_w_conn) {
+ if (NULL == g_w_conn_sender) {
SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (NULL == g_w_conn_listener) {
+ SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
+ return VC_ERROR_OPERATION_FAILED;
}
int pid = getpid();
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
/* register our name on the bus, and check for errors */
- ret = dbus_bus_request_name(g_w_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+ ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
}
char rule[128];
- snprintf(rule, 128, "type='signal',interface='%s%d'", VC_WIDGET_SERVICE_INTERFACE, pid);
+ snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
- dbus_bus_add_match(g_w_conn, rule, &err);
- dbus_connection_flush(g_w_conn);
+ dbus_bus_add_match(g_w_conn_listener, rule, &err);
+ dbus_connection_flush(g_w_conn_listener);
if (dbus_error_is_set(&err))
{
}
int fd = 0;
- if (1 != dbus_connection_get_unix_fd(g_w_conn, &fd)) {
+ if (1 != dbus_connection_get_unix_fd(g_w_conn_listener, &fd)) {
SLOG(LOG_ERROR, TAG_VCW, "fail to get fd from dbus ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, "Get fd from dbus : %d", fd);
}
- g_w_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)widget_listener_event_callback, g_w_conn, NULL, NULL);
+ g_w_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)widget_listener_event_callback, g_w_conn_listener, NULL, NULL);
if (NULL == g_w_fd_handler) {
SLOG(LOG_ERROR, TAG_VCW, "fail to get fd handler from ecore ");
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;
+ }
+
int pid = getpid();
char service_name[64];
memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
- dbus_bus_release_name (g_w_conn, service_name, &err);
+ dbus_bus_release_name(g_w_conn_listener, service_name, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
dbus_error_free(&err);
}
- dbus_connection_close(g_w_conn);
-
- g_w_fd_handler = NULL;
- g_w_conn = NULL;
+ g_w_conn_sender = NULL;
+ g_w_conn_listener = NULL;
return 0;
}
int vc_widget_dbus_reconnect()
{
- bool connected = dbus_connection_get_is_connected(g_w_conn);
- SECURE_SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] %s", connected ? "Connected" : "Not connected");
+ bool sender_connected = dbus_connection_get_is_connected(g_w_conn_sender);
+ bool listener_connected = dbus_connection_get_is_connected(g_w_conn_listener);
+ SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Sender(%s) Listener(%s)",
+ sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
- if (false == connected) {
+ if (false == sender_connected || false == listener_connected) {
vc_widget_dbus_close_connection();
if (0 != vc_widget_dbus_open_connection()) {
SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
}
+
return 0;
}
DBusMessage* result_msg = NULL;
int result = 0;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, 500, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, 500, &err);
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
- result_msg = dbus_connection_send_with_reply_and_block(g_w_conn, msg, g_w_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
return 0;
}
-//int vc_cmd_set_type(vc_cmd_h vc_command, vc_cmd_type_e type)
int vc_cmd_set_type(vc_cmd_h vc_command, int type)
{
if (NULL == vc_command) {
* @see vc_cmd_add_result_key()
*/
int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
-//int vc_command_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
{
SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
* Definition for Dbus
*******************************************************************************************/
-#define VC_CLIENT_SERVICE_NAME "org.tizen.voice.vcclient"
-#define VC_CLIENT_SERVICE_OBJECT_PATH "/org/tizen/voice/vcclient"
-#define VC_CLIENT_SERVICE_INTERFACE "org.tizen.voice.vcclient"
+#define VC_CLIENT_SERVICE_NAME "org.tizen.vc.client"
+#define VC_CLIENT_SERVICE_OBJECT_PATH "/org/tizen/vc/client"
+#define VC_CLIENT_SERVICE_INTERFACE "org.tizen.vc.client"
-#define VC_WIDGET_SERVICE_NAME "org.tizen.voice.vcwidget"
-#define VC_WIDGET_SERVICE_OBJECT_PATH "/org/tizen/voice/vcwidget"
-#define VC_WIDGET_SERVICE_INTERFACE "org.tizen.voice.vcwidget"
+#define VC_WIDGET_SERVICE_NAME "org.tizen.vc.widget"
+#define VC_WIDGET_SERVICE_OBJECT_PATH "/org/tizen/vc/widget"
+#define VC_WIDGET_SERVICE_INTERFACE "org.tizen.vc.widget"
-#define VC_MANAGER_SERVICE_NAME "org.tizen.voice.vcmanager"
-#define VC_MANAGER_SERVICE_OBJECT_PATH "/org/tizen/voice/vcmanager"
-#define VC_MANAGER_SERVICE_INTERFACE "org.tizen.voice.vcmanager"
+#define VC_MANAGER_SERVICE_NAME "org.tizen.vc.manager"
+#define VC_MANAGER_SERVICE_OBJECT_PATH "/org/tizen/vc/manager"
+#define VC_MANAGER_SERVICE_INTERFACE "org.tizen.vc.manager"
-#define VC_SERVER_SERVICE_NAME "service.connect.vcserver"
+#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"
* <td></td>
* </tr>
* <tr>
- * <td>vc_set_app_state()</td>
- * <td>Ready</td>
- * <td></td>
- * </tr>
- * <tr>
- * <td>vc_get_app_state()</td>
- * <td>Ready</td>
- * <td></td>
- * </tr>
- * <tr>
* <td>vc_set_command_list()</td>
* <td>Ready</td>
* <td></td>
Name: lib@PROJECT_NAME@_manager
Description: Voice control manager client library
+Requires: glib-2.0 dbus-1 capi-base-common
Version: @VERSION@
Libs: -L${libdir} -l@PROJECT_NAME@_manager
Cflags: -I${includedir}
Name: lib@PROJECT_NAME@_setting
Description: Voice control setting library
+Requires: glib-2.0 capi-base-common
Version: @VERSION@
Libs: -L${libdir} -l@PROJECT_NAME@_setting
Cflags: -I${includedir}
Name: lib@PROJECT_NAME@_widget
Description: Voice control library for widget
+Requires: glib-2.0 dbus-1 capi-base-common
Version: @VERSION@
Libs: -L${libdir} -l@PROJECT_NAME@_widget
Cflags: -I${includedir}
Name: lib@PROJECT_NAME@
Description: Voice control client library
+Requires: glib-2.0 dbus-1 capi-base-common
Version: @VERSION@
Libs: -L${libdir} -l@PROJECT_NAME@
Cflags: -I${includedir}
/**
-* @addtogroup Voice_control_command
+* @defgroup CAPI_UIX_VOICE_CONTROL_COMMAND_MODULE Voice control command
+* @ingroup CAPI_UIX_VOICE_CONTROL_MODULE
+*
+* @brief The @ref CAPI_UIX_VOICE_CONTROL_COMMAND_MODULE API provides functions for creating/destroying command list and add/remove/retrieve commands of list.
* @{
*/
#include <voice_control_command.h>
/**
-* @addtogroup Voice_control_common
+* @addtogroup CAPI_UIX_VOICE_CONTROL_MODULE
* @{
*/
--- /dev/null
+[D-BUS Service]
+Name=org.tizen.voice.vcserver
+Exec=/usr/bin/vc-daemon
+User=system
+Group=system
Name: voice-control
Summary: Voice control client library and daemon
-Version: 0.2.7
+Version: 0.2.8
Release: 1
Group: Graphics & UI Framework/Voice Framework
License: Apache-2.0
/sbin/ldconfig
mkdir -p /usr/share/voice/vc
-chsmack -a '_' /usr/share/voice/vc
mkdir -p /opt/home/app/.voice/vc
chown 5000:5000 /opt/home/app/.voice/vc
%{_libdir}/libvc_widget.so
%{_libdir}/libvc_manager.so
%{_bindir}/vc-daemon
+/usr/share/dbus-1/system-services/org.tizen.voice*
+/etc/dbus-1/system.d/vc-server.conf
/usr/lib/voice/vc/1.0/vc-config.xml
/usr/share/license/%{name}
%files setting-devel
%defattr(-,root,root,-)
%{_libdir}/pkgconfig/voice-control-setting.pc
-%{_includedir}/voice_control_command.h
-%{_includedir}/voice_control_common.h
%{_includedir}/voice_control_setting.h
%files engine-devel
return 0;
}
-//int vcd_client_set_command_type(int pid, vcd_client_command_group_type_e type)
int vcd_client_set_command_type(int pid, int type)
{
vc_client_info_s* client_info = NULL;
return 0;
}
-//int vcd_client_unset_command_type(int pid, vcd_client_command_group_type_e type)
int vcd_client_unset_command_type(int pid, int type)
{
vc_client_info_s* client_info = NULL;
int vcd_client_foreach_command(client_foreach_command_cb callback, void* user_data);
-//int vcd_client_get_client_info_from_result_id(int* result_id, int** pid, int** cmd_type);
int vcd_client_get_cmd_from_result_id(int result_id, vc_cmd_s** result);
int vcd_client_get_cmd_info_from_result_id(int result_id, int* pid, int* cmd_type, vc_cmd_s** result);
* limitations under the License.
*/
-
-
#include <dbus/dbus.h>
#include "vcd_client_data.h"
#include "vcd_dbus.h"
#include "vcd_main.h"
-static DBusConnection* g_conn;
+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;
char target_if_name[128] = {0,};
if (VCD_CLIENT_TYPE_NORMAL == type) {
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_NAME);
+
} else if (VCD_CLIENT_TYPE_WIDGET == type) {
- snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
+ snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
+
} else if (VCD_CLIENT_TYPE_MANAGER == type) {
- snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, pid);
+ snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
} else {
return NULL;
}
if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
}
dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
DBusMessage* result_msg;
int result = -1;
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
+ result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
if (dbus_error_is_set(&err)) {
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
dbus_error_free(&err);
- result = -1;
+ result = VCD_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
char service_name[64];
memset(service_name, 0, 64);
- snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
char target_if_name[128];
- snprintf(target_if_name, sizeof(target_if_name), "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
+ snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
DBusMessage* msg;
if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
}
int temp = (int)show;
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
dbus_message_set_no_reply(msg, TRUE);
-
- if (1 != dbus_connection_send(g_conn, msg, NULL)) {
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_conn);
- return 0;
- }
-
- /*
- DBusError err;
- dbus_error_init(&err);
-
- DBusMessage* result_msg;
-
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (NULL != result_msg) {
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)\n", err.message);
- dbus_error_free(&err);
- return -1;
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result response");
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Widget is not available");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
- dbus_error_free(&err);
- }
- return -1;
+ dbus_connection_flush(g_conn_sender);
}
return 0;
- */
}
+
+
int vcdc_send_result(int pid, int cmd_type)
{
DBusMessage* msg = NULL;
return -1;
}
- if (NULL == msg)
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
-
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
dbus_message_set_no_reply(msg, TRUE);
- if (1 != dbus_connection_send(g_conn, msg, NULL)) {
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_conn);
- return 0;
- }
-
- /*
- DBusError err;
- dbus_error_init(&err);
-
- DBusMessage* result_msg;
-
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (NULL != result_msg) {
- dbus_message_unref(result_msg);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)\n", err.message);
- dbus_error_free(&err);
- return VCD_ERROR_TIMED_OUT;
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result response");
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL.");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
- dbus_error_free(&err);
- }
- return VCD_ERROR_TIMED_OUT;
+ dbus_connection_flush(g_conn_sender);
}
return 0;
- */
}
int vcdc_send_result_to_manager(int manger_pid)
{
-// int count = 0;
-
-// DBusMessage* result_msg = NULL;
-
DBusError err;
dbus_error_init(&err);
msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
- if (NULL == msg)
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
dbus_message_set_no_reply(msg, TRUE);
-
- if (1 != dbus_connection_send(g_conn, msg, NULL)) {
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_conn);
- return 0;
- }
-
- /*
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (NULL != result_msg) {
- dbus_message_unref(result_msg);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)\n", err.message);
- dbus_error_free(&err);
- return -1;
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result response");
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL.");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
- dbus_error_free(&err);
- }
- return -1;
+ dbus_connection_flush(g_conn_sender);
}
- count++;
-
return 0;
- */
}
int vcdc_send_speech_detected(int manger_pid)
{
-// DBusMessage* result_msg = NULL;
-
DBusError err;
dbus_error_init(&err);
msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
- if (NULL == msg)
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
dbus_message_set_no_reply(msg, TRUE);
- if (1 != dbus_connection_send(g_conn, msg, NULL)) {
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_conn);
- return 0;
- }
-
- /*
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (NULL != result_msg) {
- dbus_message_unref(result_msg);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)\n", err.message);
- dbus_error_free(&err);
- return -1;
- }
- else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result response");
- }
- }
- else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL.");
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
- dbus_error_free(&err);
- }
- return -1;
+ dbus_connection_flush(g_conn_sender);
}
return 0;
- */
}
int vcdc_send_error_signal(int pid, int reason, char *err_msg)
char service_name[64];
memset(service_name, 0, 64);
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
char target_if_name[128];
- snprintf(target_if_name, sizeof(target_if_name), "%s%d", VC_CLIENT_SERVICE_INTERFACE, pid);
+ snprintf(target_if_name, sizeof(target_if_name), "%s", VC_CLIENT_SERVICE_INTERFACE);
DBusMessage* msg;
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send error signal : reason(%d), Error Msg(%s)", reason, err_msg);
if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
}
dbus_message_append_args(msg,
DBUS_TYPE_INVALID);
dbus_message_set_no_reply(msg, TRUE);
-
- if (1 != dbus_connection_send(g_conn, msg, NULL)) {
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
- dbus_connection_flush(g_conn);
- return 0;
- }
-
- /*
- DBusError err;
- dbus_error_init(&err);
-
- DBusMessage* result_msg;
-
- result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
- dbus_message_unref(msg);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
- dbus_error_free(&err);
- }
-
- if (NULL != result_msg) {
- dbus_message_unref(result_msg);
- } else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL.");
+ dbus_connection_flush(g_conn_sender);
}
return 0;
- */
}
static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
- DBusConnection* conn = (DBusConnection*)data;
- DBusMessage* msg = NULL;
-
- if (NULL == conn)
- return ECORE_CALLBACK_RENEW;
+ if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
- dbus_connection_read_write_dispatch(conn, 50);
+ dbus_connection_read_write_dispatch(g_conn_listener, 50);
- msg = dbus_connection_pop_message(conn);
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_conn_listener);
/* loop again if we haven't read a message */
if (NULL == msg) {
/* Common event */
if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
- vcd_dbus_server_hello(conn, msg);
+ vcd_dbus_server_hello(g_conn_listener, msg);
/* manager event */
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
- vcd_dbus_server_mgr_initialize(conn, msg);
+ vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
- vcd_dbus_server_mgr_finalize(conn, msg);
+ vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
- vcd_dbus_server_mgr_set_command(conn, msg);
+ vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
- vcd_dbus_server_mgr_unset_command(conn, msg);
+ vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
- vcd_dbus_server_mgr_set_demandable_client(conn, msg);
+ vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
- vcd_dbus_server_mgr_set_audio_type(conn, msg);
+ vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
- vcd_dbus_server_mgr_get_audio_type(conn, msg);
+ vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
- vcd_dbus_server_mgr_set_client_info(conn, msg);
+ vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
- vcd_dbus_server_mgr_start(conn, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
+ vcd_dbus_server_mgr_start(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
- vcd_dbus_server_mgr_stop(conn, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
+ vcd_dbus_server_mgr_stop(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
- vcd_dbus_server_mgr_cancel(conn, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
+ vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
- vcd_dbus_server_mgr_result_selection(conn, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
+ vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
/* client event */
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
- vcd_dbus_server_initialize(conn, msg);
+ vcd_dbus_server_initialize(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
- vcd_dbus_server_finalize(conn, msg);
+ vcd_dbus_server_finalize(g_conn_listener, msg);
#if 0
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
- vcd_dbus_server_set_exclusive_command(conn, msg);
+ vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
#endif
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
- vcd_dbus_server_set_command(conn, msg);
+ vcd_dbus_server_set_command(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
- vcd_dbus_server_unset_command(conn, msg);
+ vcd_dbus_server_unset_command(g_conn_listener, msg);
#if 0
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
- vcd_dbus_server_start_request(conn, msg);
+ vcd_dbus_server_start_request(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
- vcd_dbus_server_stop_request(conn, msg);
+ vcd_dbus_server_stop_request(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
- vcd_dbus_server_cancel_request(conn, msg);
+ vcd_dbus_server_cancel_request(g_conn_listener, msg);
#endif
/* widget event */
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
- vcd_dbus_server_widget_initialize(conn, msg);
+ vcd_dbus_server_widget_initialize(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
- vcd_dbus_server_widget_finalize(conn, msg);
+ vcd_dbus_server_widget_finalize(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
- vcd_dbus_server_widget_start_recording(conn, msg);
+ vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
- vcd_dbus_server_widget_start(conn, msg);
+ vcd_dbus_server_widget_start(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
- vcd_dbus_server_widget_stop(conn, msg);
+ vcd_dbus_server_widget_stop(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
- vcd_dbus_server_widget_cancel(conn, msg);
+ vcd_dbus_server_widget_cancel(g_conn_listener, msg);
else
return ECORE_CALLBACK_RENEW;
int ret;
+ /* Create connection for sender */
+ g_conn_sender = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (NULL == g_conn_sender) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
+ return VCD_ERROR_OPERATION_FAILED;
+ }
+
/* connect to the bus and check for errors */
- g_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
+ g_conn_listener = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
dbus_error_free(&err);
}
- if (NULL == g_conn) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection" );
- return -1;
+ if (NULL == g_conn_listener) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
+ return VCD_ERROR_OPERATION_FAILED;
}
/* request our name on the bus and check for errors */
- ret = dbus_bus_request_name(g_conn, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+ ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
printf("Fail to be primary owner in dbus request.");
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
dbus_error_free(&err);
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
/* add a rule for getting signal */
snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
- dbus_bus_add_match(g_conn, rule, &err);/* see signals from the given interface */
- dbus_connection_flush(g_conn);
+ dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
+ dbus_connection_flush(g_conn_listener);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
dbus_error_free(&err);
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
int fd = 0;
- dbus_connection_get_unix_fd(g_conn, &fd);
+ dbus_connection_get_unix_fd(g_conn_listener, &fd);
- if (!ecore_init()) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] ecore_init()");
- return -1;
- }
+ g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
- Ecore_Fd_Handler* fd_handler;
- fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ , (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
-
- if (NULL == fd_handler) {
+ if (NULL == g_dbus_fd_handler) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
return 0;
DBusError err;
dbus_error_init(&err);
- dbus_bus_release_name (g_conn, VC_SERVER_SERVICE_NAME, &err);
+ if (NULL != g_dbus_fd_handler) {
+ ecore_main_fd_handler_del(g_dbus_fd_handler);
+ g_dbus_fd_handler = NULL;
+ }
+
+ dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
dbus_error_free(&err);
- return -1;
}
+ g_conn_listener = NULL;
+ g_conn_sender = NULL;
+
return 0;
}
\ No newline at end of file
dbus_error_init(&err);
int pid;
- //int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager result selection");
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr result selection : get arguments error (%s)", err.message);
dbus_error_free(&err);
- // ret = VCD_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid);
- //ret = vcd_server_mgr_result_select();
vcd_server_mgr_result_select();
}
return 0;
--- /dev/null
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+
+<!-- root can own the service -->
+ <policy user="default">
+ <allow own_prefix="org.tizen.vc.client"/>
+ <allow send_destination="org.tizen.vc.client"/>
+ <allow receive_sender="org.tizen.vc.client"/>
+ </policy>
+
+ <policy user="root">
+ <allow own_prefix="org.tizen.vc.client"/>
+ <allow send_destination="org.tizen.vc.client"/>
+ <allow receive_sender="org.tizen.vc.client"/>
+ </policy>
+
+ <policy context="default">
+ <allow own_prefix="org.tizen.vc.client"/>
+ <allow send_destination="org.tizen.vc.client"/>
+ <allow receive_sender="org.tizen.vc.client"/>
+ </policy>
+
+
+ <policy user="default">
+ <allow own_prefix="org.tizen.vc.widget"/>
+ <allow send_destination="org.tizen.vc.widget"/>
+ <allow receive_sender="org.tizen.vc.widget"/>
+ </policy>
+
+ <policy user="root">
+ <allow own_prefix="org.tizen.vc.widget"/>
+ <allow send_destination="org.tizen.vc.widget"/>
+ <allow receive_sender="org.tizen.vc.widget"/>
+ </policy>
+
+ <policy context="default">
+ <allow own_prefix="org.tizen.vc.widget"/>
+ <allow send_destination="org.tizen.vc.widget"/>
+ <allow receive_sender="org.tizen.vc.widget"/>
+ </policy>
+
+
+ <policy user="default">
+ <allow own_prefix="org.tizen.vc.manager"/>
+ <allow send_destination="org.tizen.vc.manager"/>
+ <allow receive_sender="org.tizen.vc.manager"/>
+ </policy>
+
+ <policy user="root">
+ <allow own_prefix="org.tizen.vc.manager"/>
+ <allow send_destination="org.tizen.vc.manager"/>
+ <allow receive_sender="org.tizen.vc.manager"/>
+ </policy>
+
+ <policy context="default">
+ <allow own_prefix="org.tizen.vc.manager"/>
+ <allow send_destination="org.tizen.vc.manager"/>
+ <allow receive_sender="org.tizen.vc.manager"/>
+ </policy>
+
+
+ <policy user="default">
+ <allow own="org.tizen.voice.vcserver"/>
+ <allow send_destination="org.tizen.voice.vcserver"/>
+ <allow receive_sender="org.tizen.voice.vcserver"/>
+ </policy>
+
+ <policy user="root">
+ <allow own="org.tizen.voice.vcserver"/>
+ <allow send_destination="org.tizen.voice.vcserver"/>
+ <allow receive_sender="org.tizen.voice.vcserver"/>
+ </policy>
+
+ <policy user="system">
+ <allow own="org.tizen.voice.vcserver"/>
+ <allow send_destination="org.tizen.voice.vcserver"/>
+ <allow receive_sender="org.tizen.voice.vcserver"/>
+ </policy>
+
+
+ <!--
+ <policy context="default">
+ <check send_destination="org.tizen.voice.vcserver"
+ send_interface="org.tizen.voice.vcserver"
+ privilege="(n/a)" />
+ </policy>
+ -->
+
+ <!--
+ <policy context="default">
+ <check send_destination="org.tizen.voice.vcserver"
+ send_interface="org.tizen.voice.vcserver"
+ privilege="http://tizen.org/privilege/recorder" />
+ </policy>
+ -->
+</busconfig>
projects / platform / core / uifw / voice-control.git / commitdiff