SET(PREFIX ${CMAKE_INSTALL_PREFIX})
SET(EXEC_PREFIX "${PREFIX}")
-SET(VERSION 0.2.8)
+SET(VERSION 0.2.9)
# pkg config tool
INCLUDE(FindPkgConfig)
+voice-control (0.2.9) -- Mon, 6 Jul 2015
+
+ * Update daemon start by dbus activation (Dongyeol Lee <dy3.lee@samsung.com>)
+ * Add audio header and Fix volume data (Kwangyoun Kim <ky85.kim@samsung.com>)
+ * Update file IPC for service state to dbus IPC (Dongyeol Lee <dy3.lee@samsung.com>)
+
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>)
- * Change config directory for multi-client (Kwnagyoun Kim <ky85.kim@samsung.com>)
+ * Add to check app state using APP FW api (Dongyeol Lee <dy3.lee@samsung.com>)
+ * Add recognition mode (Dongyeol Lee <dy3.lee@samsung.com>)
+ * Clean up code by coding rule (Dongyeol Lee <dy3.lee@samsung.com>)
vc (0.2.7) -- Wed, 21 Jan 2015
* limitations under the License.
*/
+#include <aul.h>
#include "vc_client.h"
#include "vc_command.h"
return;
}
-static void __vc_service_state_changed_cb(int before_state, int current_state)
+static Eina_Bool __notify_auth_changed_cb(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
+ vc_auth_state_changed_cb callback = NULL;
+ void* user_data;
- /* Save service state */
- vc_client_set_service_state(g_vc, (vc_service_state_e)current_state);
+ vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
- vc_service_state_changed_cb service_callback = NULL;
- void* service_user_data;
- vc_client_get_service_state_changed_cb(g_vc, &service_callback, &service_user_data);
+ vc_auth_state_e before = -1;
+ vc_auth_state_e current = -1;
+
+ vc_client_get_before_auth_state(g_vc, &before, ¤t);
- if (NULL != service_callback) {
+ if (NULL != callback) {
vc_client_use_callback(g_vc);
- service_callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ callback(before, current, user_data);
vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
+ SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
} else {
- SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is NULL");
+ SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
}
- return;
+ return EINA_FALSE;
}
return __vc_convert_config_error_code(ret);
}
- ret = vc_config_mgr_set_service_state_cb(g_vc->handle, __vc_service_state_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set service change callback : %d", ret);
- vc_config_mgr_unset_lang_cb(g_vc->handle);
- vc_config_mgr_finalize(g_vc->handle);
- vc_client_destroy(g_vc);
- return __vc_convert_config_error_code(ret);
- }
-
- int service_state = -1;
- if (0 != vc_config_mgr_get_service_state(&service_state)) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
- vc_config_mgr_finalize(g_vc->handle);
- vc_client_destroy(g_vc);
- return __vc_convert_config_error_code(ret);
- }
-
- vc_client_set_service_state(g_vc, service_state);
-
SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
ecore_timer_del(g_connect_timer);
}
- vc_config_mgr_unset_service_state_cb(g_vc->handle);
vc_config_mgr_unset_lang_cb(g_vc->handle);
vc_config_mgr_finalize(g_vc->handle);
return VC_ERROR_NONE;
}
-static Eina_Bool __notify_auth_changed_cb(void *data)
-{
- vc_auth_state_changed_cb callback = NULL;
- void* user_data;
-
- vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
-
- vc_auth_state_e before = -1;
- vc_auth_state_e current = -1;
-
- vc_client_get_before_auth_state(g_vc, &before, ¤t);
-
- if (NULL != callback) {
- vc_client_use_callback(g_vc);
- callback(before, current, user_data);
- vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
- }
-
- return EINA_FALSE;
-
-
-}
-
#if 0
static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
{
/* request initialization */
int ret = -1;
int mgr_pid = -1;
- ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid);
+ int service_state = 0;
+ ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
/* Success to connect */
}
- g_connect_timer = NULL;
+ /* Set service state */
+ vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
+ g_connect_timer = NULL;
#if 0
g_focus_in_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, __vc_x_event_window_focus_in, NULL);
g_focus_out_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, __vc_x_event_window_focus_out, NULL);
return 0;
}
+int __vc_cb_service_state(int state)
+{
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_client_get_service_state(g_vc, &before_state);
+
+ if (current_state == before_state) {
+ return 0;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
+
+ /* Save service state */
+ vc_client_set_service_state(g_vc, current_state);
+
+ vc_service_state_changed_cb callback = NULL;
+ void* service_user_data;
+ vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_client_use_callback(g_vc);
+ callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ vc_client_not_use_callback(g_vc);
+ SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
+ }
+
+ return 0;
+}
+
int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
{
if (NULL == callback)
extern void __vc_cb_result();
+extern int __vc_cb_service_state(int state);
+
static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
dbus_connection_read_write_dispatch(g_conn_listener, 50);
- DBusMessage* msg = NULL;
- msg = dbus_connection_pop_message(g_conn_listener);
+ while (1) {
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_conn_listener);
- /* loop again if we haven't read a message */
- if (NULL == msg) {
- return ECORE_CALLBACK_RENEW;
- }
+ /* loop again if we haven't read a message */
+ if (NULL == msg) {
+ break;
+ }
- DBusError err;
- dbus_error_init(&err);
+ DBusError err;
+ dbus_error_init(&err);
- char if_name[64];
- snprintf(if_name, 64, "%s", VC_CLIENT_SERVICE_INTERFACE);
+ char if_name[64] = {0, };
+ 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");
- int pid = 0;
- int response = -1;
+ if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_HELLO)) {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== Get Hello");
+ int pid = 0;
+ int response = -1;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
- }
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- if (pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc get hello : pid(%d) ", pid);
- 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 ");
+ }
- } else {
- SLOG(LOG_ERROR, TAG_VCC, "<<<< vc get hello : invalid pid ");
- }
+ DBusMessage* reply = NULL;
+ reply = dbus_message_new_method_return(msg);
- 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 (NULL != reply) {
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- 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);
+ 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(g_conn_listener);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
- }
-
- SLOG(LOG_DEBUG, TAG_VCC, "=====");
- SLOG(LOG_DEBUG, TAG_VCC, " ");
- } /* VCD_METHOD_HELLO */
+ dbus_connection_flush(g_conn_listener);
+ dbus_message_unref(reply);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
+ }
- else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
+ } /* VCD_METHOD_HELLO */
- __vc_cb_result();
+ else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_SET_SERVICE_STATE)) {
+ int state = 0;
- /*
- reply = dbus_message_new_method_return(msg);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- if (NULL != reply) {
- 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");
+ SLOG(LOG_DEBUG, TAG_VCC, "<<<< state changed : %d", state);
- dbus_connection_flush(g_conn_listener);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get result : fail to create reply message");
- }
- */
+ __vc_cb_service_state(state);
- SLOG(LOG_DEBUG, TAG_VCC, "=====");
- SLOG(LOG_DEBUG, TAG_VCC, " ");
+ } /* VCD_METHOD_SET_SERVICE_STATE */
- }/* VCD_METHOD_RESULT */
+ else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
- else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_ERROR)) {
- SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
- int pid;
- int reason;
- char* err_msg;
+ __vc_cb_result();
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &reason,
- DBUS_TYPE_STRING, &err_msg,
- DBUS_TYPE_INVALID);
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCC, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- } else {
- SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
- __vc_cb_error(pid, reason);
- }
+ } /* VCD_METHOD_RESULT */
- /*
- reply = dbus_message_new_method_return(msg);
+ else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_ERROR)) {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
+ int pid;
+ int reason;
+ char* err_msg;
- if (NULL != reply) {
- 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_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &reason,
+ DBUS_TYPE_STRING, &err_msg,
+ DBUS_TYPE_INVALID);
- dbus_connection_flush(g_conn_listener);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc Error message : fail to create reply message");
- }
- */
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+ else {
+ SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
+ __vc_cb_error(pid, reason);
+ }
- SLOG(LOG_DEBUG, TAG_VCC, "=====");
- SLOG(LOG_DEBUG, TAG_VCC, " ");
- }/* VCD_METHOD_ERROR */
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
+ } /* VCD_METHOD_ERROR */
+
+ else {
+ SLOG(LOG_DEBUG, TAG_VCC, "Message is NOT valid");
+ dbus_message_unref(msg);
+ break;
+ }
- /* free the message */
- dbus_message_unref(msg);
+ /* free the message */
+ dbus_message_unref(msg);
+ } /* while(1) */
return ECORE_CALLBACK_PASS_ON;
}
return VC_ERROR_OPERATION_FAILED;
}
- int pid = getpid();
-
char service_name[64];
memset(service_name, '\0', 64);
snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
}
-int vc_dbus_request_initialize(int pid, int* mgr_pid)
+int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state)
{
DBusMessage* msg;
if (NULL != result_msg) {
int tmp = -1;
- dbus_message_get_args(result_msg, &err,
+ int tmp_service_state = 0;
+ dbus_message_get_args(result_msg, &err,
DBUS_TYPE_INT32, &result,
DBUS_TYPE_INT32, &tmp,
+ DBUS_TYPE_INT32, &tmp_service_state,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
if (0 == result) {
*mgr_pid = tmp;
- SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d", result, *mgr_pid);
+ *service_state = tmp_service_state;
+ SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d service = %d", result, *mgr_pid, *service_state);
} else {
SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
}
int vc_dbus_request_hello();
-int vc_dbus_request_initialize(int pid, int* mgr_pid);
+int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state);
int vc_dbus_request_finalize(int pid);
static GSList* g_demandable_client_list = NULL;
+static float g_volume_db = 0;
+
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);
return;
}
-static void __vc_mgr_service_state_changed_cb(int before_state, int current_state)
-{
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
-
- /* Save service state */
- vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)current_state);
-
- vc_service_state_changed_cb callback = NULL;
- void* service_user_data;
- vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
-
- if (NULL != callback) {
- vc_mgr_client_use_callback(g_vc_m);
- callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
- vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
- }
-
- return;
-}
-
static void __vc_mgr_foreground_changed_cb(int previous, int current)
{
SLOG(LOG_DEBUG, TAG_VCM, "Foreground changed : Before(%d) Current(%d)", previous, current);
vc_mgr_client_destroy(g_vc_m);
return VC_ERROR_OPERATION_FAILED;
}
-
- ret = vc_config_mgr_set_service_state_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_service_state_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set service change callback : %d", ret);
- vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
- vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
- vc_mgr_client_destroy(g_vc_m);
- return VC_ERROR_OPERATION_FAILED;
- }
ret = vc_config_mgr_set_foreground_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_foreground_changed_cb);
- int service_state = -1;
- if (0 != vc_config_mgr_get_service_state(&service_state)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state");
- vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
- vc_mgr_client_destroy(g_vc_m);
- return VC_ERROR_OPERATION_FAILED;
- }
-
- vc_mgr_client_set_service_state(g_vc_m, service_state);
-
SLOG(LOG_DEBUG, TAG_VCM, "[Success] pid(%d)", g_vc_m->handle);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
ecore_timer_del(g_m_connect_timer);
}
- vc_config_mgr_unset_service_state_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
/* request initialization */
int ret = -1;
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle);
+ int service_state = 0;
+ ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
/* Success to connect */
}
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
+ /* Set service state */
+ vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)service_state);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
vc_mgr_client_set_client_state(g_vc_m, VC_STATE_READY);
return 0;
}
+int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set recognition mode = %d", mode);
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_recognition_mode(g_vc_m, mode);
+ return 0;
+}
+
+int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
+{
+ int ret = -1;
+
+ ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
+ return ret;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
+ return 0;
+}
+
int vc_mgr_start(bool stop_by_silence, bool exclusive_command_option)
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
int ret;
int count = 0;
+ vc_recognition_mode_e recognition_mode;
+
+ if (0 == stop_by_silence)
+ recognition_mode = VC_RECOGNITION_MODE_MANUAL;
+ else
+ vc_mgr_get_recognition_mode(&recognition_mode);
/* Request */
ret = -1;
count = 0;
while (0 != ret) {
- ret = vc_mgr_dbus_request_start(g_vc_m->handle, stop_by_silence, exclusive_command_option, start_by_client);
+ ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client);
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
- vc_mgr_client_set_service_state(g_vc_m, VC_SERVICE_STATE_RECORDING);
}
}
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Stop recognition");
- vc_mgr_client_set_service_state(g_vc_m, VC_SERVICE_STATE_PROCESSING);
}
}
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Cancel recognition");
- vc_mgr_client_set_service_state(g_vc_m, VC_SERVICE_STATE_READY);
}
}
return ret;
}
+int __vc_mgr_cb_set_volume(float volume)
+{
+ g_volume_db = volume;
+ SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)", g_volume_db);
+
+ return 0;
+}
+
int vc_mgr_get_recording_volume(float* volume)
{
if (NULL == volume) {
return VC_ERROR_INVALID_STATE;
}
- FILE* fp = fopen(VC_RUNTIME_INFO_AUDIO_VOLUME, "rb");
- if (!fp) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open Volume File");
- return VC_ERROR_OPERATION_FAILED;
- }
-
- int readlen = fread((void*)volume, sizeof(*volume), 1, fp);
- fclose(fp);
-
- if (0 == readlen)
- *volume = 0.0f;
+ *volume = g_volume_db;
return 0;
}
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Select result");
+ /* Do not check state for 'restart continusly' mode */
+
vc_service_state_e service_state = -1;
vc_mgr_client_get_service_state(g_vc_m, &service_state);
if (service_state != VC_SERVICE_STATE_PROCESSING) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING'");
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- return VC_ERROR_INVALID_STATE;
+ vc_recognition_mode_e recognition_mode;
+ vc_mgr_get_recognition_mode(&recognition_mode);
+
+ if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continously'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
}
if (NULL != vc_cmd_list) {
return EINA_FALSE;
}
-static Eina_Bool __vc_mgr_notify_all_result(void *data)
+static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
{
char* temp_text = NULL;
int event;
vc_mgr_client_get_all_result_cb(g_vc_m, &all_callback, &all_user_data);
if (NULL == all_callback) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] All result callback is NULL");
- return EINA_FALSE;
+ return;
}
if (0 != vc_cmd_list_create(&vc_cmd_list)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
- return EINA_FALSE;
+ return;
}
vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command(g_vc_m));
- SLOG(LOG_DEBUG, TAG_VCM, "Result info : result text(%s) event(%d) result_message(%s)", temp_text, event, temp_message);
+ SLOG(LOG_DEBUG, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
+ result_type, temp_text, event, temp_message);
vc_cmd_print_list(vc_cmd_list);
vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
if (NULL == callback) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
- return EINA_FALSE;
+ return;
}
vc_mgr_client_use_callback(g_vc_m);
vc_mgr_client_set_exclusive_command(g_vc_m, false);
- return EINA_FALSE;
+ return;
}
int count = 0;
if (0 < count) {
if (true == cb_ret) {
SLOG(LOG_DEBUG, TAG_VCM, "Callback result is true");
- ecore_idler_add(__vc_mgr_set_select_result, NULL);
+ if (VC_RESULT_TYPE_NOTIFICATION != result_type)
+ ecore_idler_add(__vc_mgr_set_select_result, NULL);
} else {
SLOG(LOG_DEBUG, TAG_VCM, "Callback result is false");
/* need to select conflicted result */
vc_mgr_client_set_all_result(g_vc_m, event, temp_text);
}
} else {
- ecore_idler_add(__vc_mgr_set_select_result, NULL);
+ if (VC_RESULT_TYPE_NOTIFICATION != result_type)
+ ecore_idler_add(__vc_mgr_set_select_result, NULL);
+
vc_mgr_client_set_exclusive_command(g_vc_m, false);
vc_mgr_client_unset_all_result(g_vc_m);
}
/* Release list */
vc_cmd_list_destroy(vc_cmd_list, true);
- return EINA_FALSE;
+ return;
}
static Eina_Bool __vc_mgr_notify_result(void *data)
return EINA_FALSE;
}
-void __vc_mgr_cb_all_result()
+void __vc_mgr_cb_all_result(vc_result_type_e type)
{
if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) {
- __vc_mgr_notify_all_result(NULL);
+ __vc_mgr_notify_all_result(type);
} else {
__vc_mgr_notify_result(0);
}
return 0;
}
+int __vc_mgr_cb_service_state(int state)
+{
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_mgr_client_get_service_state(g_vc_m, &before_state);
+
+ if (current_state == before_state) {
+ SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : Before(%d) Current(%d)",
+ before_state, current_state);
+ return 0;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
+
+ /* Save service state */
+ vc_mgr_client_set_service_state(g_vc_m, current_state);
+
+ vc_service_state_changed_cb callback = NULL;
+ void* service_user_data = NULL;
+ vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_mgr_client_use_callback(g_vc_m);
+ callback(before_state, current_state, service_user_data);
+ vc_mgr_client_not_use_callback(g_vc_m);
+ SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
+ }
+
+ return 0;
+}
+
int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
{
if (callback == NULL)
/* audio type */
char* audio_id;
+ /* recognition mode */
+ vc_recognition_mode_e recognition_mode;
+
/* mutex */
int cb_ref_count;
client->result_event = -1;
client->result_text = NULL;
- client->service_state = -1;
+ client->service_state = 0;
client->before_state = VC_STATE_INITIALIZED;
client->current_state = VC_STATE_INITIALIZED;
client->current_language = NULL;
client->audio_id = NULL;
+ client->recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
client->cb_ref_count = 0;
return 0;
}
+int vc_mgr_client_set_recognition_mode(vc_h vc, vc_recognition_mode_e mode)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->recognition_mode = mode;
+
+ return 0;
+}
+
+int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode)
+{
+ if (NULL == mode) {
+ return -1;
+ }
+
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *mode = client->recognition_mode;
+ return 0;
+}
+
/* utils */
int vc_mgr_client_get_count()
{
int vc_mgr_client_get_audio_type(vc_h vc, char** audio_id);
+int vc_mgr_client_set_recognition_mode(vc_h vc, vc_recognition_mode_e mode);
+
+int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode);
+
/* utils */
int vc_mgr_client_get_count();
static DBusConnection* g_m_conn_listener = NULL;
-extern void __vc_mgr_cb_all_result();
+extern void __vc_mgr_cb_all_result(vc_result_type_e type);
extern void __vc_mgr_cb_system_result();
extern int __vc_mgr_cb_error(int pid, int reason);
+extern int __vc_mgr_cb_set_volume(float volume);
+
+extern int __vc_mgr_cb_service_state(int state);
+
/* Authority */
extern int __vc_mgr_request_auth_enable(int pid);
dbus_connection_read_write_dispatch(g_m_conn_listener, 50);
- DBusMessage* msg = NULL;
- msg = dbus_connection_pop_message(g_m_conn_listener);
+ while (1) {
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_m_conn_listener);
- /* loop again if we haven't read a message */
- if (NULL == msg) {
- return ECORE_CALLBACK_RENEW;
- }
+ /* loop again if we haven't read a message */
+ if (NULL == msg) {
+ break;
+ }
- DBusError err;
- dbus_error_init(&err);
+ SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Message is arrived");
- char if_name[64];
- snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ DBusError err;
+ dbus_error_init(&err);
- if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get Hello");
- int pid = 0;
- int response = -1;
+ char if_name[64];
+ snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE);
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
- }
+ if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get Hello");
+ int pid = 0;
+ 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 ");
- }
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- 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 (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 ");
+ }
- 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);
+ DBusMessage *reply = NULL;
+ reply = dbus_message_new_method_return(msg);
- dbus_connection_flush(g_m_conn_listener);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get hello : fail to create reply message");
- }
-
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- } /* VCD_METHOD_HELLO */
+ if (NULL != reply) {
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get Speech detected");
+ 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);
- __vc_mgr_cb_speech_detected();
+ dbus_connection_flush(g_m_conn_listener);
+ dbus_message_unref(reply);
+ }
+ else {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get hello : fail to create reply message");
+ }
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VCD_METHOD_HELLO */
- }/* VCD_MANAGER_METHOD_SPEECH_DETECTED */
+ else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_VOLUME)) {
+ /* SLOG(LOG_DEBUG, TAG_VCM, "===== Set volume"); */
+ float volume = 0;
- else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get All Result");
-
- __vc_mgr_cb_all_result();
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- }/* VCD_MANAGER_METHOD_ALL_RESULT */
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set volume : volume(%f)", volume);
+ __vc_mgr_cb_set_volume(volume);
- else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get System Result");
+ /* SLOG(LOG_DEBUG, TAG_VCM, "====="); */
+ /* SLOG(LOG_DEBUG, TAG_VCM, " "); */
+ } /* VCD_MANAGER_METHOD_SET_VOLUME */
- __vc_mgr_cb_system_result();
+ else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_SERVICE_STATE)) {
+ int state = 0;
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- }/* VCD_MANAGER_METHOD_RESULT */
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< state changed : %d", state);
- else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get Error");
- int pid;
- int reason;
- char* err_msg;
+ __vc_mgr_cb_service_state(state);
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &reason,
- DBUS_TYPE_STRING, &err_msg,
- DBUS_TYPE_INVALID);
+ } /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- } else {
- 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);
- }
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get Speech detected");
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VCD_MANAGER_METHOD_ERROR */
+ __vc_mgr_cb_speech_detected();
- /* Authority */
- else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth enable");
- int pid;
- int ret = 0;
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
- if (dbus_error_is_set(&err)) {
- 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 mgr request auth enable : pid(%d)", pid);
- ret = __vc_mgr_request_auth_enable(pid);
- }
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get All Result");
+ int result_type = 0;
- 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(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 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 mgr request auth enable : fail to create reply message");
- }
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VC_METHOD_AUTH_ENABLE */
+ __vc_mgr_cb_all_result((vc_result_type_e)result_type);
- else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_DISABLE)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth disable");
- int pid;
- int ret = 0;
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ } /* VCD_MANAGER_METHOD_ALL_RESULT */
- if (dbus_error_is_set(&err)) {
- 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 mgr request auth disable : pid(%d)", pid);
- ret = __vc_mgr_request_auth_disable(pid);
- }
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get System Result");
- DBusMessage *reply = NULL;
- reply = dbus_message_new_method_return(msg);
+ __vc_mgr_cb_system_result();
- if (NULL != reply) {
- dbus_message_append_args(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 disable : fail to send reply");
- else
- 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 mgr request auth disable : fail to create reply message");
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VC_METHOD_AUTH_DISABLE */
+ } /* VCD_MANAGER_METHOD_RESULT */
- else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_START)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth start");
- int pid;
- int ret = 0;
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get Error");
+ int pid;
+ int reason;
+ char* err_msg;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &reason,
+ DBUS_TYPE_STRING, &err_msg,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
- 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 mgr request auth start : pid(%d)", pid);
- ret = __vc_mgr_request_auth_start(pid);
- }
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+ else {
+ 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);
+ }
- DBusMessage *reply = NULL;
- reply = dbus_message_new_method_return(msg);
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VCD_MANAGER_METHOD_ERROR */
- if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ /* Authority */
+ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth enable");
+ int pid;
+ int ret = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- 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 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 mgr request auth start : fail to create reply message");
- }
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VC_METHOD_AUTH_START */
+ if (dbus_error_is_set(&err)) {
+ 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 mgr request auth enable : pid(%d)", pid);
+ ret = __vc_mgr_request_auth_enable(pid);
+ }
- else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_STOP)) {
- SLOG(LOG_DEBUG,TAG_VCM, "===== Get request auth stop");
- int pid;
- int ret = 0;
+ 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(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 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 mgr request auth enable : fail to create reply message");
+ }
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VC_METHOD_AUTH_ENABLE */
- if (dbus_error_is_set(&err)) {
- 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 mgr request auth stop : pid(%d)", pid);
- ret = __vc_mgr_request_auth_stop(pid);
- }
+ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_DISABLE)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth disable");
+ int pid;
+ int ret = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ 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 mgr request auth disable : pid(%d)", pid);
+ ret = __vc_mgr_request_auth_disable(pid);
+ }
- DBusMessage *reply = NULL;
- reply = dbus_message_new_method_return(msg);
+ 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(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 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 mgr request auth disable : fail to create reply message");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VC_METHOD_AUTH_DISABLE */
+
+ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_START)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth start");
+ int pid;
+ int ret = 0;
- if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- 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 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 mgr request auth stop : fail to create reply message");
- }
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VC_METHOD_AUTH_STOP */
+ if (dbus_error_is_set(&err)) {
+ 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 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(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 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 mgr request auth start : fail to create reply message");
+ }
- else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_CANCEL)) {
- SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth cancel");
- int pid;
- int ret = 0;
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VC_METHOD_AUTH_START */
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_STOP)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth stop");
+ int pid;
+ int ret = 0;
- if (dbus_error_is_set(&err)) {
- 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 mgr request auth cancel : pid(%d)", pid);
- ret = __vc_mgr_request_auth_cancel(pid);
- }
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ 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 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(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 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 mgr request auth stop : fail to create reply message");
+ }
- DBusMessage *reply = NULL;
- reply = dbus_message_new_method_return(msg);
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VC_METHOD_AUTH_STOP */
- if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_CANCEL)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth cancel");
+ int pid;
+ int ret = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- 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(g_m_conn_listener);
- dbus_message_unref(reply);
- } else {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth cancel : fail to create reply message");
- }
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- }/* VC_METHOD_AUTH_CANCEL */
+ if (dbus_error_is_set(&err)) {
+ 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 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(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(g_m_conn_listener);
+ dbus_message_unref(reply);
+ }
+ else {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth cancel : fail to create reply message");
+ }
- /* free the message */
- dbus_message_unref(msg);
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VC_METHOD_AUTH_CANCEL */
+
+ else {
+ SLOG(LOG_DEBUG, TAG_VCM, "Message is NOT valid");
+ dbus_message_unref(msg);
+ break;
+ }
+
+ /* free the message */
+ dbus_message_unref(msg);
+ } /* while(1) */
return ECORE_CALLBACK_PASS_ON;
}
return VC_ERROR_OPERATION_FAILED;
}
- int pid = getpid();
-
- char service_name[64];
- memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
-
- SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", service_name);
+ SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", VC_MANAGER_SERVICE_NAME);
/* register our name on the bus, and check for errors */
- ret = dbus_bus_request_name(g_m_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
+ ret = dbus_bus_request_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
g_m_fd_handler = NULL;
}
- int pid = getpid();
-
- char service_name[64];
- memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
-
- dbus_bus_release_name(g_m_conn_listener, service_name, &err);
+ dbus_bus_release_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
}
-int vc_mgr_dbus_request_initialize(int pid)
+int vc_mgr_dbus_request_initialize(int pid, int* service_state)
{
DBusMessage* msg;
}
if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
+ dbus_message_get_args(result_msg, &err,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INT32, service_state,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d", result, *service_state);
} else {
SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
}
return result;
}
-int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option, bool start_by_client)
+int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
{
DBusMessage* 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) start by client(%d)",
- pid, silence, exclusive_command_option, start_by_client);
+ SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
+ pid, recognition_mode, exclusive_command_option, start_by_client);
}
int exclusive = exclusive_command_option;
int by = start_by_client;
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &(silence),
- DBUS_TYPE_INT32, &(exclusive),
- DBUS_TYPE_INT32, &(by),
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &(recognition_mode),
+ DBUS_TYPE_INT32, &(exclusive),
+ DBUS_TYPE_INT32, &(by),
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
int vc_mgr_dbus_request_hello();
-int vc_mgr_dbus_request_initialize(int pid);
+int vc_mgr_dbus_request_initialize(int pid, int* service_state);
int vc_mgr_dbus_request_finalize(int pid);
int vc_mgr_dbus_request_set_client_info(int pid);
-int vc_mgr_dbus_request_start(int pid, int silence, bool exclusive_command_option, bool start_by_client);
+int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client);
int vc_mgr_dbus_request_stop(int pid);
return;
}
-static void __vc_widget_service_state_changed_cb(int before_state, int current_state)
-{
- SECURE_SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
-
- /* Save service state */
- vc_widget_client_set_service_state(g_vc_w, (vc_service_state_e)current_state);
-
- vc_service_state_changed_cb service_callback = NULL;
- void* service_user_data;
- vc_widget_client_get_service_state_changed_cb(g_vc_w, &service_callback, &service_user_data);
-
- if (NULL != service_callback) {
- vc_widget_client_use_callback(g_vc_w);
- service_callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
- vc_widget_client_not_use_callback(g_vc_w);
- SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCW, "[WARNING] State changed callback is null");
- }
-
- return;
-}
-
int vc_widget_initialize()
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Initialize");
return __vc_widget_convert_config_error_code(ret);
}
- ret = vc_config_mgr_set_service_state_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE, __vc_widget_service_state_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set service state callback : %d", ret);
- vc_config_mgr_unset_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_widget_client_destroy(g_vc_w);
- return __vc_widget_convert_config_error_code(ret);
- }
-
- int service_state = -1;
- if (0 != vc_config_mgr_get_service_state(&service_state)) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get service state");
- vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_widget_client_destroy(g_vc_w);
- return __vc_widget_convert_config_error_code(ret);
- }
-
- vc_widget_client_set_service_state(g_vc_w, service_state);
-
SLOG(LOG_DEBUG, TAG_VCW, "[Success] pid(%d)", g_vc_w->handle);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
ecore_timer_del(g_w_connect_timer);
}
- vc_config_mgr_unset_service_state_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
vc_config_mgr_unset_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
/* request initialization */
int ret = -1;
- ret = vc_widget_dbus_request_initialize(g_vc_w->handle);
+ int service_state = 0;
+ ret = vc_widget_dbus_request_initialize(g_vc_w->handle, &service_state);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
return EINA_FALSE;
}
+ vc_widget_client_set_service_state(g_vc_w, (vc_service_state_e)service_state);
+
vc_widget_client_set_state(g_vc_w, VC_STATE_READY);
ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
}
#endif
-#if 0
int vc_widget_cancel()
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Cancel Recognition");
return VC_ERROR_INVALID_STATE;
}
- int ret = vc_widget_client_set_command_group(g_vc_w, NULL);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set command to client : %d", ret);
- return ret;
- }
-
- ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
- if (0 != ret) {
- ret = vc_config_convert_error_code((vc_config_error_e)ret);
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete command group : %s", __vc_widget_get_error_code(ret));
- }
-
int count = 0;
+ int ret = -1;
+
do {
ret = vc_widget_dbus_request_cancel(g_vc_w->handle);
if (0 != ret) {
return 0;
}
-#endif
static Eina_Bool __vc_widget_notify_error(void *data)
{
return 0;
}
+int __vc_widget_cb_service_state(int state)
+{
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_widget_client_get_service_state(g_vc_w, &before_state);
+
+ if (current_state == before_state) {
+ return 0;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
+
+ /* Save service state */
+ vc_widget_client_set_service_state(g_vc_w, current_state);
+
+ vc_service_state_changed_cb callback = NULL;
+ void* service_user_data = NULL;
+ vc_widget_client_get_service_state_changed_cb(g_vc_w, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_widget_client_use_callback(g_vc_w);
+ callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ vc_widget_client_not_use_callback(g_vc_w);
+ SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
+ }
+ else {
+ SLOG(LOG_WARN, TAG_VCW, "[WARNING] Service state changed callback is null");
+ }
+
+ return 0;
+}
+
int vc_widget_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
{
vc_state_e state;
free(data);
free(vc);
+ data = NULL;
+ vc = NULL;
+
return 0;
}
}
extern void __vc_widget_cb_result();
+extern int __vc_widget_cb_service_state(int state);
+
static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
{
dbus_connection_read_write_dispatch(g_w_conn_listener, 50);
- DBusMessage* msg = NULL;
- msg = dbus_connection_pop_message(g_w_conn_listener);
-
- /* loop again if we haven't read a message */
- if (NULL == msg) {
- return ECORE_CALLBACK_RENEW;
- }
-
- DBusError err;
- dbus_error_init(&err);
-
- char if_name[64];
- 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");
- int pid = 0;
- int response = -1;
+ while (1) {
+ DBusMessage* msg = NULL;
+ msg = dbus_connection_pop_message(g_w_conn_listener);
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
-
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
+ /* loop again if we haven't read a message */
+ if (NULL == msg) {
+ break;
}
- 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 ");
- }
+ SLOG(LOG_DEBUG, TAG_VCW, "[DEBUG] Message is arrived");
- 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);
+ DBusError err;
+ dbus_error_init(&err);
- 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);
+ char if_name[64] = {0, };
+ snprintf(if_name, 64, "%s", VC_WIDGET_SERVICE_INTERFACE);
- 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_DEBUG, TAG_VCW, "=====");
- SLOG(LOG_DEBUG, TAG_VCW, " ");
- } /* VCD_WIDGET_METHOD_HELLO */
-
- else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_SHOW_TOOLTIP)) {
- SLOG(LOG_DEBUG, TAG_VCW, "===== Show / Hide tooltip");
- int pid = 0;
- int show = 0;
-
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &show,
- DBUS_TYPE_INVALID);
+ if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_HELLO)) {
+ SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget hello");
+ int pid = 0;
+ int response = -1;
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
- dbus_error_free(&err);
- }
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
- if (pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget show tooltip : pid(%d), show(%d)", pid, show);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- __vc_widget_cb_show_tooltip(pid, (bool)show);
- } else {
- SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget show tooltip : invalid pid");
- }
-
- SLOG(LOG_DEBUG, TAG_VCW, "=====");
- SLOG(LOG_DEBUG, TAG_VCW, " ");
- } /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
+ 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 ");
+ }
- else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget result");
+ DBusMessage* reply = NULL;
+ reply = dbus_message_new_method_return(msg);
- __vc_widget_cb_result();
+ if (NULL != reply) {
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCW, "=====");
- SLOG(LOG_DEBUG, TAG_VCW, " ");
+ 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);
- } /* VCD_WIDGET_METHOD_RESULT */
+ 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");
+ }
- else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
- SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget error");
- int pid;
- int reason;
- char* err_msg;
+ SLOG(LOG_DEBUG, TAG_VCW, "=====");
+ SLOG(LOG_DEBUG, TAG_VCW, " ");
+ } /* VCD_WIDGET_METHOD_HELLO */
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &reason,
- DBUS_TYPE_STRING, &err_msg,
- DBUS_TYPE_INVALID);
+ else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_SET_SERVICE_STATE)) {
+ int state = 0;
+
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get error message : Get arguments error (%s)", err.message);
- dbus_error_free(&err);
- } else {
- SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget get error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
- __vc_widget_cb_error(pid, reason);
+ SLOG(LOG_DEBUG, TAG_VCW, "<<<< service state changed : %d", state);
+
+ __vc_widget_cb_service_state(state);
+
+ } /* VCD_WIDGET_METHOD_SET_SERVICE_STATE */
+
+ else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_SHOW_TOOLTIP)) {
+ SLOG(LOG_DEBUG, TAG_VCW, "===== Show / Hide tooltip");
+ int pid = 0;
+ int show = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &show,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget show tooltip : pid(%d), show(%d)", pid, show);
+
+ __vc_widget_cb_show_tooltip(pid, (bool)show);
+ } else {
+ SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget show tooltip : invalid pid");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCW, "=====");
+ SLOG(LOG_DEBUG, TAG_VCW, " ");
+ } /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
+
+ else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
+ SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget result");
+
+ __vc_widget_cb_result();
+
+ /*
+ reply = dbus_message_new_method_return(msg);
+
+ if (NULL != reply) {
+ if (!dbus_connection_send(g_w_conn_listener, 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(g_w_conn_listener);
+ 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, " ");
+
+ } /* VCD_WIDGET_METHOD_RESULT */
+
+ else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
+ SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget error");
+ int pid;
+ int reason;
+ char* err_msg;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &reason,
+ DBUS_TYPE_STRING, &err_msg,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get error message : Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget get error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
+ __vc_widget_cb_error(pid, reason);
+ }
+
+ /*
+ reply = dbus_message_new_method_return(msg);
+
+ if (NULL != reply) {
+ if (!dbus_connection_send(g_w_conn_listener, 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(g_w_conn_listener);
+ 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 */
+
+ else {
+ SLOG(LOG_ERROR, TAG_VCW, "Message is NOT valid");
+ dbus_message_unref(msg);
+ break;
}
- SLOG(LOG_DEBUG, TAG_VCW, "=====");
- SLOG(LOG_DEBUG, TAG_VCW, " ");
- } /* VCD_WIDGET_METHOD_ERROR */
-
- /* free the message */
- dbus_message_unref(msg);
+ /* free the message */
+ dbus_message_unref(msg);
+ } /* while(1) */
return ECORE_CALLBACK_PASS_ON;
}
return VC_ERROR_OPERATION_FAILED;
}
- int pid = getpid();
-
- char service_name[64];
- memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
-
- SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
+ SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", VC_WIDGET_SERVICE_NAME);
/* register our name on the bus, and check for errors */
- ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+ ret = dbus_bus_request_name(g_w_conn_listener, VC_WIDGET_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
g_w_fd_handler = NULL;
}
- int pid = getpid();
-
- char service_name[64];
- memset(service_name, '\0', 64);
- snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
-
- dbus_bus_release_name(g_w_conn_listener, service_name, &err);
+ dbus_bus_release_name(g_w_conn_listener, VC_WIDGET_SERVICE_NAME, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
}
-int vc_widget_dbus_request_initialize(int pid)
+int vc_widget_dbus_request_initialize(int pid, int* service_state)
{
DBusMessage* msg;
}
if (NULL != result_msg) {
+ int tmp_service_state = 0;
dbus_message_get_args(result_msg, &err,
DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INT32, &tmp_service_state,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
+ *service_state = tmp_service_state;
+ SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget initialize : result = %d service = %d", result, *service_state);
} else {
SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
}
int vc_widget_dbus_request_hello();
-int vc_widget_dbus_request_initialize(int pid);
+int vc_widget_dbus_request_initialize(int pid, int* service_state);
int vc_widget_dbus_request_finalize(int pid);
int uid;
vc_config_lang_changed_cb lang_cb;
vc_config_foreground_changed_cb foreground_cb;
- vc_config_state_changed_cb state_cb;
vc_config_enabled_cb enabled_cb;
} vc_config_client_s;
static vc_config_s* g_config_info;
-static int g_service_state;
-
static int g_foreground_pid;
static int g_lang_ref_count;
static int g_fd_lang;
static int g_wd_lang;
-static int g_state_ref_count;
-static Ecore_Fd_Handler* g_fd_handler_state = NULL;
-static int g_fd_state;
-static int g_wd_state;
-
static int g_fore_ref_count;
static Ecore_Fd_Handler* g_fd_handler_fore = NULL;
static int g_fd_fore;
SLOG(LOG_DEBUG, vc_config_tag(), " language : %s", g_config_info->language);
SLOG(LOG_DEBUG, vc_config_tag(), "===================");
- /* Get service state */
- if (0 != vc_parser_get_service_state(&g_service_state)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get state");
- return VC_CONFIG_ERROR_OPERATION_FAILED;
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "Current service state : %d", g_service_state);
-
if (0 != vc_parser_get_foreground(&g_foreground_pid)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get foreground pid");
return VC_CONFIG_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, vc_config_tag(), "Current foreground pid : %d", g_foreground_pid);
g_lang_ref_count = 0;
- g_state_ref_count = 0;
g_fore_ref_count = 0;
/* Register to detect display language change */
return 0;
}
-Eina_Bool vc_config_mgr_inotify_state_cb(void* data, Ecore_Fd_Handler *fd_handler)
-{
- SLOG(LOG_DEBUG, vc_config_tag(), "===== State changed callback event");
-
- int length;
- struct inotify_event event;
- memset(&event, '\0', sizeof(struct inotify_event));
-
- length = read(g_fd_state, &event, sizeof(struct inotify_event));
- if (0 > length) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Empty Inotify event");
- SLOG(LOG_DEBUG, vc_config_tag(), "=====");
- SLOG(LOG_DEBUG, vc_config_tag(), " ");
- return ECORE_CALLBACK_PASS_ON;
- }
-
- if (IN_CLOSE_WRITE == event.mask) {
- int state = -1;
- if (0 != vc_parser_get_service_state(&state)) {
- SLOG(LOG_ERROR, vc_config_tag(), "Fail to get state");
- return ECORE_CALLBACK_PASS_ON;
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "Previous state(%d) Current state(%d)", g_service_state, state);
-
- /* If state is not changed */
- if (g_service_state != state) {
- int previous_state = g_service_state;
- g_service_state = state;
-
- GSList *iter = NULL;
- vc_config_client_s* temp_client = NULL;
-
- /* Call all callbacks of client*/
- iter = g_slist_nth(g_config_client_list, 0);
-
- while (NULL != iter) {
- temp_client = iter->data;
-
- if (NULL != temp_client) {
- if (NULL != temp_client->state_cb) {
- temp_client->state_cb(previous_state, g_service_state);
- }
- }
-
- iter = g_slist_next(iter);
- }
- }
- } else {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Undefined event");
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "=====");
- SLOG(LOG_DEBUG, vc_config_tag(), " ");
-
- return ECORE_CALLBACK_PASS_ON;
-}
-
-int __vc_config_mgr_register_state_event()
-{
- if (0 == g_state_ref_count) {
- /* get file notification handler */
- int fd;
- int wd;
-
- fd = inotify_init();
- if (fd < 0) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail get inotify fd");
- return -1;
- }
- g_fd_state = fd;
-
- wd = inotify_add_watch(fd, VC_RUNTIME_INFO_SERVICE_STATE, IN_CLOSE_WRITE);
- g_wd_state = wd;
-
- g_fd_handler_state = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)vc_config_mgr_inotify_state_cb, NULL, NULL, NULL);
- if (NULL == g_fd_handler_state) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get handler for state");
- return -1;
- }
- }
- g_state_ref_count++;
-
- return 0;
-}
-
-int __vc_config_mgr_unregister_state_event()
-{
- if (0 == g_state_ref_count) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] State ref count is 0");
- return VC_CONFIG_ERROR_INVALID_STATE;
- }
-
- g_state_ref_count--;
- if (0 == g_state_ref_count) {
- /* delete inotify variable */
- ecore_main_fd_handler_del(g_fd_handler_state);
- inotify_rm_watch(g_fd_state, g_wd_state);
- close(g_fd_state);
- }
- return 0;
-}
-
-int vc_config_mgr_set_service_state_cb(int uid, vc_config_state_changed_cb state_cb)
-{
- if (NULL == state_cb) {
- SLOG(LOG_ERROR, vc_config_tag(), "State changed cb is NULL : uid(%d) ", uid);
- return VC_CONFIG_ERROR_INVALID_PARAMETER;
- }
-
- GSList *iter = NULL;
- vc_config_client_s* temp_client = NULL;
-
- /* Call all callbacks of client*/
- iter = g_slist_nth(g_config_client_list, 0);
-
- while (NULL != iter) {
- temp_client = iter->data;
-
- if (NULL != temp_client) {
- if (uid == temp_client->uid) {
- temp_client->state_cb = state_cb;
- __vc_config_mgr_register_state_event();
- return VC_CONFIG_ERROR_NONE;
- }
- }
- iter = g_slist_next(iter);
- }
-
- return VC_CONFIG_ERROR_INVALID_PARAMETER;
-}
-
-int vc_config_mgr_unset_service_state_cb(int uid)
-{
- GSList *iter = NULL;
- vc_config_client_s* temp_client = NULL;
-
- /* Call all callbacks of client*/
- iter = g_slist_nth(g_config_client_list, 0);
-
- while (NULL != iter) {
- temp_client = iter->data;
-
- if (NULL != temp_client) {
- if (uid == temp_client->uid) {
- temp_client->state_cb = NULL;
- __vc_config_mgr_unregister_state_event();
- return 0;
- }
- }
- iter = g_slist_next(iter);
- }
-
- return VC_CONFIG_ERROR_INVALID_PARAMETER;
-}
-
Eina_Bool vc_config_mgr_inotify_foreground_cb(void* data, Ecore_Fd_Handler *fd_handler)
{
SLOG(LOG_DEBUG, vc_config_tag(), "===== Foreground changed callback event");
return false;
}
-int vc_config_mgr_set_service_state(int state)
-{
- if (0 >= g_slist_length(g_config_client_list)) {
- SLOG(LOG_ERROR, vc_config_tag(), "Not initialized");
- return -1;
- }
-
- return vc_parser_set_service_state(state);
-}
-
-int vc_config_mgr_get_service_state(int* state)
-{
- if (0 >= g_slist_length(g_config_client_list)) {
- SLOG(LOG_ERROR, vc_config_tag(), "Not initialized");
- return -1;
- }
-
- return vc_parser_get_service_state(state);
-}
-
int vc_config_mgr_set_foreground(int pid, bool value)
{
if (0 >= g_slist_length(g_config_client_list)) {
typedef void (*vc_config_foreground_changed_cb)(int previous, int current);
-typedef void (*vc_config_state_changed_cb)(int previous, int current);
-
typedef void (*vc_config_enabled_cb)(bool enable);
int vc_config_mgr_unset_lang_cb(int uid);
-int vc_config_mgr_set_service_state_cb(int uid, vc_config_state_changed_cb state_cb);
-
-int vc_config_mgr_unset_service_state_cb(int uid);
-
int vc_config_mgr_set_foreground_cb(int uid, vc_config_foreground_changed_cb foreground_cb);
int vc_config_mgr_unset_foreground_cb(int uid);
int vc_config_convert_error_code(vc_config_error_e code);
-int vc_config_mgr_set_service_state(int state);
-
-int vc_config_mgr_get_service_state(int* state);
-
-
int vc_config_mgr_set_foreground(int pid, bool value);
int vc_config_mgr_get_foreground(int* pid);
#define VC_TAG_CONFIG_ENABLED "enabled"
#define VC_TAG_INFO_BASE_TAG "vc_info_option"
-#define VC_TAG_INFO_SERVICE_STATE "service_state"
#define VC_TAG_INFO_FOREGROUND "foreground_pid"
xmlChar *key;
bool is_default_open = false;
- if (0 != access(VC_RUNTIME_INFO_ROOT, F_OK)) {
- SLOG(LOG_DEBUG, vc_config_tag(), "No info root directory");
- if (0 != access(VC_CONFIG_ROOT, F_OK)) {
- SLOG(LOG_DEBUG, vc_config_tag(), "No root directory");
- if (0 != mkdir(VC_CONFIG_ROOT, 0755)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory");
- }
- }
- if (0 != mkdir(VC_RUNTIME_INFO_ROOT, 0755)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory");
- }
- }
-
if (0 != access(VC_CONFIG, F_OK)) {
doc = xmlParseFile(VC_CONFIG_DEFAULT);
if (doc == NULL) {
return 0;
}
-int vc_parser_init_service_state()
-{
- if (0 != access(VC_RUNTIME_INFO_SERVICE_STATE, R_OK | W_OK)) {
- /* make file */
- xmlDocPtr doc;
- xmlNodePtr root_node;
- xmlNodePtr info_node;
-
- doc = xmlNewDoc((const xmlChar*)"1.0");
- doc->encoding = (const xmlChar*)"utf-8";
- doc->charset = 1;
-
- root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_BASE_TAG);
- xmlDocSetRootElement(doc,root_node);
-
- /* Make new command node */
- info_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_SERVICE_STATE);
- xmlNodeSetContent(info_node, (const xmlChar *)"0");
- xmlAddChild(root_node, info_node);
-
- int ret = xmlSaveFormatFile(VC_RUNTIME_INFO_SERVICE_STATE, doc, 1);
- SLOG(LOG_DEBUG, vc_config_tag(), "Save service state info file : %d", ret);
-
- if (0 != __vc_config_parser_set_file_mode(VC_RUNTIME_INFO_SERVICE_STATE))
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to set file mode - %s", VC_RUNTIME_INFO_SERVICE_STATE);
- }
-
- return 0;
-}
-
-int vc_parser_set_service_state(int state)
-{
- /* Set service state */
- xmlDocPtr doc = NULL;
- xmlNodePtr cur = NULL;
-
- int retry_count = 0;
-
- while (NULL == doc) {
- doc = xmlParseFile(VC_RUNTIME_INFO_SERVICE_STATE);
- if (NULL != doc) {
- break;
- }
- retry_count++;
- usleep(10000);
-
- if (VC_RETRY_COUNT == retry_count) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to parse file error : %s", VC_RUNTIME_INFO_SERVICE_STATE);
- return -1;
- }
- }
-
- cur = xmlDocGetRootElement(doc);
- if (cur == NULL) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Empty document");
- return -1;
- }
-
- if (xmlStrcmp(cur->name, (const xmlChar *) VC_TAG_INFO_BASE_TAG)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] The wrong type, root node is NOT %s", VC_TAG_INFO_BASE_TAG);
- return -1;
- }
-
- cur = cur->xmlChildrenNode;
- if (cur == NULL) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Empty document");
- return -1;
- }
-
- while (cur != NULL) {
- if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_INFO_SERVICE_STATE)) {
- char temp[16];
- memset(temp, 0, 16);
- snprintf(temp, 16, "%d", state);
-
- xmlNodeSetContent(cur, (const xmlChar *)temp);
- break;
- }
-
- cur = cur->next;
- }
-
- int ret = xmlSaveFile(VC_RUNTIME_INFO_SERVICE_STATE, doc);
- if (0 >= ret) {
- SLOG(LOG_DEBUG, vc_config_tag(), "[ERROR] Fail to save service state info file : %d", ret);
- return -1;
- }
- SLOG(LOG_DEBUG, vc_config_tag(), "[Success] Save service state info file : state(%d)", state);
-
- return 0;
-}
-
-int vc_parser_get_service_state(int* state)
-{
- if (NULL == state) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Input parameter is NULL");
- return -1;
- }
-
- if (0 != access(VC_RUNTIME_INFO_SERVICE_STATE, F_OK)) {
- /* make file */
- xmlDocPtr doc;
- xmlNodePtr root_node;
- xmlNodePtr info_node;
-
- doc = xmlNewDoc((const xmlChar*)"1.0");
- doc->encoding = (const xmlChar*)"utf-8";
- doc->charset = 1;
-
- root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_BASE_TAG);
- xmlDocSetRootElement(doc, root_node);
-
- /* Make new command node */
- info_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_SERVICE_STATE);
- xmlNodeSetContent(info_node, (const xmlChar *)"0");
- xmlAddChild(root_node, info_node);
-
- int ret = xmlSaveFormatFile(VC_RUNTIME_INFO_SERVICE_STATE, doc, 1);
- SLOG(LOG_DEBUG, vc_config_tag(), "Save runtime info file : %d", ret);
-
- if (0 != __vc_config_parser_set_file_mode(VC_RUNTIME_INFO_SERVICE_STATE))
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to set file mode - %s", VC_RUNTIME_INFO_SERVICE_STATE);
-
- *state = 0;
- return 0;
- }
-
- /* Check file */
- xmlDocPtr doc = NULL;
- xmlNodePtr cur = NULL;
- xmlChar *key;
- int retry_count = 0;
-
- while (NULL == doc) {
- doc = xmlParseFile(VC_RUNTIME_INFO_SERVICE_STATE);
- if (NULL != doc) {
- break;
- }
- retry_count++;
- usleep(10000);
-
- if (VC_RETRY_COUNT == retry_count) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to parse file error : %s", VC_RUNTIME_INFO_SERVICE_STATE);
- return -1;
- }
- }
-
- cur = xmlDocGetRootElement(doc);
- if (cur == NULL) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Empty document");
- xmlFreeDoc(doc);
- return -1;
- }
-
- if (xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_INFO_BASE_TAG)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] The wrong type, root node is NOT '%s'", VC_TAG_INFO_BASE_TAG);
- xmlFreeDoc(doc);
- return -1;
- }
-
- cur = cur->xmlChildrenNode;
- if (cur == NULL) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Empty document");
- xmlFreeDoc(doc);
- return -1;
- }
-
- while (cur != NULL) {
- if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_INFO_SERVICE_STATE)) {
- key = xmlNodeGetContent(cur);
- if (NULL != key) {
- SLOG(LOG_DEBUG, vc_config_tag(), "Service state : %s", (char *)key);
- *state = atoi((char*)key);
- xmlFree(key);
- } else {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] enable is NULL");
- }
- }
- cur = cur->next;
- }
-
- xmlFreeDoc(doc);
-
- return 0;
-}
-
int vc_parser_set_foreground(int pid, bool value)
{
int cur_pid = 0;
int vc_parser_find_config_changed(int* auto_lang, char** language, int* enabled);
-/* Set / Get service state */
-int vc_parser_init_service_state();
-
-int vc_parser_set_service_state(int state);
-
-int vc_parser_get_service_state(int* state);
-
-
/* Set / Get foreground info */
int vc_parser_set_foreground(int pid, bool value);
* Definition for Dbus
*******************************************************************************************/
-#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_CLIENT_SERVICE_NAME "org.tizen.voice.vcclient"
+#define VC_CLIENT_SERVICE_OBJECT_PATH "/org/tize/voice/vcclient"
+#define VC_CLIENT_SERVICE_INTERFACE "org.tizen.voice.vcclient"
-#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_WIDGET_SERVICE_NAME "org.tizen.voice.vcwidget"
+#define VC_WIDGET_SERVICE_OBJECT_PATH "/org/tize/voice/vcwidget"
+#define VC_WIDGET_SERVICE_INTERFACE "org.tizen.voice.vcwidget"
-#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_MANAGER_SERVICE_NAME "org.tizen.voice.vcmanager"
+#define VC_MANAGER_SERVICE_OBJECT_PATH "/org/tize/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 VCD_METHOD_RESULT "vcd_method_result"
#define VCD_METHOD_ERROR "vcd_method_error"
#define VCD_METHOD_HELLO "vcd_method_hello"
+#define VCD_METHOD_SET_SERVICE_STATE "vcd_method_set_service_state"
/* Authority */
#if 0
#define VCD_WIDGET_METHOD_ERROR "vcd_widget_method_error"
#define VCD_WIDGET_METHOD_HELLO "vcd_widget_method_hello"
#define VCD_WIDGET_METHOD_SHOW_TOOLTIP "vcd_widget_method_show_tooltip"
+#define VCD_WIDGET_METHOD_SET_SERVICE_STATE "vcd_widget_method_set_service_state"
/******************************************************************************************
#define VCD_MANAGER_METHOD_SPEECH_DETECTED "vcd_manager_method_speech_detected"
#define VCD_MANAGER_METHOD_ALL_RESULT "vcd_manager_method_all_result"
#define VCD_MANAGER_METHOD_RESULT "vcd_manager_method_result"
+#define VCD_MANAGER_METHOD_SET_VOLUME "vcd_manager_method_set_volume"
+#define VCD_MANAGER_METHOD_SET_SERVICE_STATE "vcd_manager_method_set_service_state"
#define VCD_MANAGER_METHOD_ERROR "vcd_manager_method_error"
#define VC_RUNTIME_INFO_CLIENT tzplatform_mkpath(TZ_USER_HOME, ".voice/vc/vc-client-info.xml")
+/******************************************************************************************
+* Defines for common enum
+*******************************************************************************************/
+
+typedef enum {
+ VC_RESULT_TYPE_NORMAL,
+ VC_RESULT_TYPE_NOTIFICATION
+} vc_result_type_e;
+
#ifdef __cplusplus
}
#define VC_RESULT_MESSAGE_ERROR_TOO_LOUD "vc.result.message.error.too.loud"
/**
+* @brief Enumerations of recognition mode.
+*/
+typedef enum {
+ VC_RECOGNITION_MODE_STOP_BY_SILENCE, /**< Default mode */
+ VC_RECOGNITION_MODE_RESTART_AFTER_REJECT, /**< Restart recognition after rejected result */
+ VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY, /**< Continuously restart recognition - not support yet*/
+ VC_RECOGNITION_MODE_MANUAL /**< Start and stop manually without silence */
+} vc_recognition_mode_e;
+
+/**
* @brief Called when client gets the all recognition results from vc-daemon.
*
* @remark temp_command is valid in callback function.
int vc_mgr_get_audio_type(char** audio_id);
/**
+* @brief Sets recognition mode.
+*
+* @param[in] mode recognition mode (e.g. #VC_RECOGNITION_MODE_SILENCE_DETECTION_ONE_TURN is default value)
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #VC_ERROR_NONE Successful
+* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #VC_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #VC_STATE_READY and the service state should be #VC_SERVICE_STATE_READY.
+*
+* @see vc_mgr_set_recognition_mode()
+*/
+int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode);
+
+/**
+* @brief Gets recognition mode.
+*
+* @param[out] mode recognition mode
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #VC_ERROR_NONE Successful
+* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #VC_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #VC_STATE_READY.
+*
+* @see vc_mgr_get_recognition_mode()
+*/
+int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode);
+
+/**
* @brief Starts recognition.
*
* @param[in] stop_by_silence Silence detection option
Name: voice-control
Summary: Voice control client library and daemon
-Version: 0.2.8
+Version: 0.2.9
Release: 1
Group: Graphics & UI Framework/Voice Framework
License: Apache-2.0
/* Runtime info */
static bool g_silence_detection;
+static vcd_recognition_mode_e g_recognition_mode;
/* Function definitions */
return g_silence_detection;
}
+int vcd_client_set_recognition_mode(vcd_recognition_mode_e mode)
+{
+ g_recognition_mode = mode;
+ return 0;
+}
+
+vcd_recognition_mode_e vcd_client_get_recognition_mode()
+{
+ return g_recognition_mode;
+}
+
int __show_client_list()
{
GSList *iter = NULL;
bool widget_cmd;
} widget_info_s;
+typedef enum {
+ VCD_RECOGNITION_MODE_STOP_BY_SILENCE, /**< Default mode */
+ VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT, /**< Restart recognition after rejected result */
+ VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY, /**< Continuously restart recognition - not support yet*/
+ VCD_RECOGNITION_MODE_MANUAL /**< Start and stop manually without silence */
+} vcd_recognition_mode_e;
+
/*
* Command API
bool vcd_client_get_slience_detection();
+int vcd_client_set_recognition_mode(vcd_recognition_mode_e mode);
+
+vcd_recognition_mode_e vcd_client_get_recognition_mode();
+
/*
* Manager API
*/
{
g_state = state;
- if (0 != vc_config_mgr_set_service_state((int)state)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Config ERROR] Fail to set service state");
- return VCD_ERROR_OPERATION_FAILED;
- }
-
SLOG(LOG_DEBUG, TAG_VCD, "[Config] Config is changed : %d", g_state);
return 0;
dbus_connection_flush(g_conn_sender);
}
+ dbus_message_unref(msg);
+
return 0;
}
+int vcdc_send_set_volume(int manger_pid, float volume)
+{
+ DBusMessage* msg = NULL;
+
+ /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */
+
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCD_MANAGER_METHOD_SET_VOLUME);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return -1;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send set volume : pid(%d), volume(%f)", manger_pid, volume);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
int vcdc_send_result(int pid, int cmd_type)
{
dbus_connection_flush(g_conn_sender);
}
+ dbus_message_unref(msg);
+
return 0;
}
-int vcdc_send_result_to_manager(int manger_pid)
+int vcdc_send_result_to_manager(int manger_pid, int result_type)
{
DBusError err;
dbus_error_init(&err);
return VCD_ERROR_OUT_OF_MEMORY;
}
+ SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
+
dbus_message_set_no_reply(msg, TRUE);
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
dbus_connection_flush(g_conn_sender);
}
+ dbus_message_unref(msg);
+
return 0;
}
DBusError err;
dbus_error_init(&err);
+ /* Send to manager */
DBusMessage* msg = NULL;
msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
dbus_connection_flush(g_conn_sender);
}
+ dbus_message_unref(msg);
+
+ return 0;
+}
+
+int vcdc_send_service_state(vcd_state_e state)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ DBusMessage* msg = NULL;
+
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCD_MANAGER_METHOD_SET_SERVICE_STATE);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to manager : state(%d)", state);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ /* Send to client */
+ msg = NULL;
+
+ msg = dbus_message_new_signal(
+ VC_CLIENT_SERVICE_OBJECT_PATH,
+ VC_CLIENT_SERVICE_INTERFACE,
+ VCD_METHOD_SET_SERVICE_STATE);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to client : state(%d)", state);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ msg = NULL;
+
+ /* Send to widget client */
+ msg = dbus_message_new_signal(
+ VC_WIDGET_SERVICE_OBJECT_PATH,
+ VC_WIDGET_SERVICE_INTERFACE,
+ VCD_WIDGET_METHOD_SET_SERVICE_STATE);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to widget client : state(%d)", state);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
return 0;
}
memset(service_name, 0, 64);
snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
- char target_if_name[128];
- 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);
dbus_connection_flush(g_conn_sender);
}
+ dbus_message_unref(msg);
+
return 0;
}
int vcdc_send_show_tooltip(int pid, bool show);
+int vcdc_send_set_volume(int manger_pid, float volume);
+
int vcdc_send_result(int pid, int cmd_type);
-int vcdc_send_result_to_manager(int manger_pid);
+int vcdc_send_result_to_manager(int manger_pid, int result_type);
int vcdc_send_speech_detected(int manger_pid);
int vcdc_send_error_signal(int pid, int reason, char *err_msg);
+int vcdc_send_service_state(vcd_state_e state);
+
#ifdef __cplusplus
}
dbus_error_init(&err);
int pid;
+ int service_state;
int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d)", pid);
ret = vcd_server_mgr_initialize(pid);
+ service_state = vcd_server_get_service_state();
}
DBusMessage* reply;
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &service_state,
DBUS_TYPE_INVALID);
if (0 == ret) {
dbus_error_init(&err);
int pid = 0;
- int silence = 0;
+ int recognition_mode = 0;
int exclusive = 0;
int start_by_client = 0;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager start");
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &silence,
- DBUS_TYPE_INT32, &exclusive,
- DBUS_TYPE_INT32, &start_by_client,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &recognition_mode,
+ DBUS_TYPE_INT32, &exclusive,
+ DBUS_TYPE_INT32, &start_by_client,
+ DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr start : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr start : pid(%d), silence(%d), exclusive(%d), start by client(%d)", pid, silence, exclusive, start_by_client);
- ret = vcd_server_mgr_start((bool)silence, (bool)exclusive, (bool)start_by_client);
+ 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);
+ ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, (bool)exclusive, (bool)start_by_client);
}
DBusMessage* reply;
dbus_error_init(&err);
int pid;
+ int service_state = 0;
int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Initialize");
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd initialize : pid(%d)", pid);
ret = vcd_server_initialize(pid);
+ service_state = vcd_server_get_service_state();
}
int mgr_pid = vcd_client_manager_get_pid();
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &mgr_pid,
+ DBUS_TYPE_INT32, &service_state,
DBUS_TYPE_INVALID);
if (0 == ret) {
dbus_error_init(&err);
int pid;
-
+ int service_state = 0;
int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget initialize : pid(%d)", pid);
ret = vcd_server_widget_initialize(pid);
+ service_state = vcd_server_get_service_state();
}
DBusMessage* reply;
if (NULL != reply) {
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &service_state,
DBUS_TYPE_INVALID);
if (0 == ret) {
int (*get_engine_info)(vcpe_engine_info_cb callback, void* user_data);
get_engine_info = (int (*)(vcpe_engine_info_cb, void*))dlsym(handle, "vcp_get_engine_info");
- if ((error = dlerror()) != NULL) {
+ if (NULL != (error = dlerror()) || NULL == get_engine_info) {
SLOG(LOG_WARN, TAG_VCD, "[Engine Agent WARNING] Invalid engine. Fail to open vcp_get_engine_info : %s", filepath);
dlclose(handle);
return -1;
return VCD_ERROR_OPERATION_FAILED;
}
- engine->vcp_load_engine = (int (*)(vcpd_funcs_s*, vcpe_funcs_s*) )dlsym(engine->handle, "vcp_load_engine");
- if ((error = dlerror()) != NULL) {
+ engine->vcp_load_engine = (int (*)(vcpd_funcs_s*, vcpe_funcs_s*))dlsym(engine->handle, "vcp_load_engine");
+ if (NULL != (error = dlerror()) || NULL == engine->vcp_load_engine) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to link daemon to vcp_load_engine()");
dlclose(engine->handle);
return VCD_ERROR_OPERATION_FAILED;
#include <math.h>
#include <sound_manager.h>
+#include "vcd_client_data.h"
+#include "vcd_dbus.h"
#include "vcd_recorder.h"
#include "vcd_main.h"
#include "voice_control_plugin_engine.h"
static vcp_audio_type_e g_audio_type;
-static int g_audio_rate;
+static unsigned int g_audio_rate;
static int g_audio_channel;
-static FILE* g_pFile_vol;
-
static char g_normal_buffer[BUFFER_LENGTH + 10];
static bool g_is_valid_audio_in = false;
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail to read audio");
vcd_recorder_stop();
}
+ }
- float vol_db = get_volume_decibel((char*)voice_data->audio_buf, (int)voice_data->length);
-
- rewind(g_pFile_vol);
-
- fwrite((void*)(&vol_db), sizeof(vol_db), 1, g_pFile_vol);
+ /* Set volume */
+ if (0 == g_buffer_count % 30) {
+ float vol_db = get_volume_decibel((char*)voice_data->audio_buf, (unsigned int)voice_data->length);
+ if (0 != vcdc_send_set_volume(vcd_client_manager_get_pid(), vol_db)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder] Fail to send recording volume(%f)", vol_db);
+ }
}
if (0 == g_buffer_count || 0 == g_buffer_count % 50) {
SLOG(LOG_WARN, TAG_VCD, "[Recorder][%d] Recording... : read_size(%d)", g_buffer_count, voice_data->length);
-
+
if (0 == g_bt_extend_count % 5) {
const unsigned char input_data[2] = {SMART_CONTROL_EXTEND_CMD, 0x00 };
if (BT_ERROR_NONE != bt_hid_send_rc_command(NULL, input_data, sizeof(input_data))) {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail bt_hid_send_rc_command(NULL, %s, %d)", input_data, sizeof(input_data));
- }
- else {
+ } else {
SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Extend bt audio recorder");
}
}
}
*/
} else {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Rate(%d) Channel(%d) Type(%d)", g_audio_rate, audio_ch, audio_type);
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail to create audio handle : %d", ret);
g_is_valid_audio_in = false;
}
#ifdef TV_BT_MODE
bt_hid_unset_audio_data_receive_cb();
- bt_hid_host_deinitialize ();
+ bt_hid_host_deinitialize();
bt_deinitialize();
#endif
g_audio_cb = NULL;
- if (0 == access(VC_RUNTIME_INFO_AUDIO_VOLUME, R_OK)) {
- if (0 != remove(VC_RUNTIME_INFO_AUDIO_VOLUME)) {
- SLOG(LOG_WARN, TAG_VCD, "[Recorder WARN] Fail to remove volume file");
- }
- }
-
if (NULL != g_current_audio_type) {
free(g_current_audio_type);
g_current_audio_type = NULL;
static float get_volume_decibel(char* data, int size)
{
- #define MAX_AMPLITUDE_MEAN_16 32768
+#define MAX_AMPLITUDE_MEAN_16 32768
int i, depthByte;
int count = 0;
float db = 0.0;
float rms = 0.0;
unsigned long long square_sum = 0;
+ short pcm16 = 0;
depthByte = 2;
- for (i = 0;i < size;i += (depthByte<<1)) {
- short pcm16 = 0;
+ for (i = 0; i < size; i += (depthByte<<1)) {
+ pcm16 = 0;
memcpy(&pcm16, data + i, sizeof(short));
square_sum += pcm16 * pcm16;
count++;
}
}
+ /* Set volume */
+ if (0 == g_buffer_count % 30) {
+ float vol_db = get_volume_decibel(g_normal_buffer, BUFFER_LENGTH);
+ if (0 != vcdc_send_set_volume(vcd_client_manager_get_pid(), vol_db)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder] Fail to send recording volume(%f)", vol_db);
+ }
+ }
+
if (0 == g_buffer_count || 0 == g_buffer_count % 50) {
SLOG(LOG_WARN, TAG_VCD, "[Recorder][%d] Recording... : read_size(%d)", g_buffer_count, ret);
g_buffer_count++;
- float vol_db = get_volume_decibel(g_normal_buffer, BUFFER_LENGTH);
-
- rewind(g_pFile_vol);
-
- fwrite((void*)(&vol_db), sizeof(vol_db), 1, g_pFile_vol);
-
#ifdef BUF_SAVE_MODE
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] read normal buffer : size(%d)", ret);
-
/* write pcm buffer */
fwrite(g_normal_buffer, 1, BUFFER_LENGTH, g_normal_file);
#endif
SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Start audio in recorder");
}
- g_pFile_vol = fopen(VC_RUNTIME_INFO_AUDIO_VOLUME, "wb+");
- if (!g_pFile_vol) {
- SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail to create Volume File");
- }
-
g_recorder_state = VCD_RECORDER_STATE_RECORDING;
#ifdef BUF_SAVE_MODE
g_recorder_state = VCD_RECORDER_STATE_READY;
- fclose(g_pFile_vol);
-
#ifdef BUF_SAVE_MODE
fclose(g_normal_file);
#endif
return EINA_FALSE;
}
+static Eina_Bool __restart_engine(void *data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "===== Restart by no result");
+
+ /* Restart recognition */
+ int ret = vcd_engine_recognize_start(true);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to restart recognition : result(%d)", ret);
+ return EINA_FALSE;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Start engine");
+
+ if (VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT == vcd_client_get_recognition_mode()) {
+ vcd_config_set_service_state(VCD_STATE_RECORDING);
+ vcdc_send_service_state(VCD_STATE_RECORDING);
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Restart recognition");
+
+ SLOG(LOG_DEBUG, TAG_VCD, "=====");
+ SLOG(LOG_DEBUG, TAG_VCD, " ");
+ return EINA_FALSE;
+}
+
static int __server_recorder_callback(const void* data, const unsigned int length)
{
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_RECORDING != state) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Skip by engine processing");
return 0;
}
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send speech detected");
}
}
- } else if (VCP_SPEECH_DETECT_END == speech_detected && vcd_client_get_slience_detection()) {
- /* silence detected */
- ecore_timer_add(0, __stop_by_silence, NULL);
+ } else if (VCP_SPEECH_DETECT_END == speech_detected) {
+ if (VCD_RECOGNITION_MODE_STOP_BY_SILENCE == vcd_client_get_recognition_mode()) {
+ /* silence detected */
+ ecore_timer_add(0, __stop_by_silence, NULL);
+ } else if (VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT == vcd_client_get_recognition_mode()) {
+ /* Stop engine recognition */
+ int ret = vcd_engine_recognize_stop();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to stop recognition : %d", ret);
+ }
+ vcd_config_set_service_state(VCD_STATE_PROCESSING);
+ vcdc_send_service_state(VCD_STATE_PROCESSING);
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop engine only by silence");
+ } else if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == vcd_client_get_recognition_mode()) {
+ /* Stop engine recognition */
+ int ret = vcd_engine_recognize_stop();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to stop recognition : %d", ret);
+ }
+ }
}
return 0;
}
}
- vcd_config_set_service_state(VCD_STATE_READY);
+ if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY != vcd_client_get_recognition_mode()) {
+ vcd_config_set_service_state(VCD_STATE_READY);
+ vcdc_send_service_state(VCD_STATE_READY);
+ }
return EINA_FALSE;
}
-static void __vcd_server_result_cb(vcp_result_event_e event, int* result_id, int count,
- const char* all_result, const char* non_fixed_result, const char* msg, void *user_data)
+static void __vcd_server_result_cb(vcp_result_event_e event, int* result_id, int count, const char* all_result,
+ const char* non_fixed_result, const char* msg, void *user_data)
{
if (VCD_STATE_PROCESSING != vcd_config_get_service_state()) {
- SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Current state is not 'Processing'");
- return;
+ if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY != vcd_client_get_recognition_mode()) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Current state is not 'Processing' and mode is not 'Restart continuously'");
+ return;
+ }
}
vc_info_parser_unset_result(vcd_client_manager_get_exclusive());
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Event(%d), Text(%s) Nonfixed(%s) Msg(%s) Result count(%d)", event, all_result, non_fixed_result, msg, count);
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Event(%d), Text(%s) Nonfixed(%s) Msg(%s) Result count(%d)",
+ event, all_result, non_fixed_result, msg, count);
+
+ if (VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT == vcd_client_get_recognition_mode()) {
+ if (VCP_RESULT_EVENT_REJECTED == event) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Restart by no or rejected result");
+ /* If no result and restart option is ON */
+ /* Send reject message */
+ bool temp = vcd_client_manager_get_exclusive();
+ vc_info_parser_set_result(all_result, event, msg, NULL, temp);
+ if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NOTIFICATION)) {
+ SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
+ }
+
+ ecore_timer_add(0, __restart_engine, NULL);
+ return;
+ }
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop recorder due to success");
+ vcd_recorder_stop();
+ } else if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == vcd_client_get_recognition_mode()) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Restart continuously");
+ /* Restart option is ON */
+ ecore_timer_add(0, __restart_engine, NULL);
+ if (VCP_RESULT_EVENT_REJECTED == event) {
+ bool temp = vcd_client_manager_get_exclusive();
+ vc_info_parser_set_result(all_result, event, msg, NULL, temp);
+ if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NOTIFICATION)) {
+ SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
+ }
+ return;
+ }
+ }
/* No result */
if (NULL == result_id) {
if (-1 != vcd_client_manager_get_pid()) {
/* Manager client is available */
- if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid())) {
+ if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NORMAL)) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
}
}
SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to create command list");
vcd_client_manager_set_exclusive(false);
vcd_config_set_service_state(VCD_STATE_READY);
+ vcdc_send_service_state(VCD_STATE_READY);
return;
}
if (-1 != vcd_client_manager_get_pid()) {
/* Manager client is available */
- if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid())) {
+ if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NORMAL)) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
}
} else {
if (-1 != vcd_client_manager_get_pid()) {
/* Manager client is available */
- if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid())) {
+ if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NORMAL)) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
}
} else {
vcd_client_manager_unset();
vcd_config_set_service_state(VCD_STATE_READY);
+ vcdc_send_service_state(VCD_STATE_READY);
SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] initialize");
}
vcd_config_set_service_state(VCD_STATE_NONE);
+ vcdc_send_service_state(VCD_STATE_NONE);
SLOG(LOG_DEBUG, TAG_VCD, "[Server] mode finalize");
client_list = NULL;
}
+#if 0
+ /* If app is in background state, app cannot response message. */
if (0 == vcd_client_widget_get_list(&client_list, &client_count)) {
SLOG(LOG_DEBUG, TAG_VCD, "===== Clean up widget");
if (NULL != client_list && client_count > 0) {
free(client_list);
client_list = NULL;
}
+#endif
/* manager */
return EINA_TRUE;
}
+int vcd_server_get_service_state()
+{
+ return vcd_config_get_service_state();
+}
+
/*
* API for manager
*/
}
vcd_config_set_service_state(VCD_STATE_RECORDING);
+ vcdc_send_service_state(VCD_STATE_RECORDING);
SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Start recognition");
return EINA_FALSE;
}
-int vcd_server_mgr_start(bool stop_by_silence, bool exclusive_cmd, bool start_by_client)
+int vcd_server_mgr_start(vcd_recognition_mode_e recognition_mode, bool exclusive_cmd, bool start_by_client)
{
/* 1. check current state */
vcd_state_e state = vcd_config_get_service_state();
return VCD_ERROR_INVALID_STATE;
}
- vcd_client_set_slience_detection(stop_by_silence);
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] set recognition mode = %d", recognition_mode);
+ vcd_client_set_recognition_mode(recognition_mode);
if (false == exclusive_cmd) {
/* Notify show tooltip */
/* 4. Set original mode */
vcd_config_set_service_state(VCD_STATE_PROCESSING);
+ vcdc_send_service_state(VCD_STATE_PROCESSING);
return VCD_ERROR_NONE;
}
/* 4. Set state */
vcd_config_set_service_state(VCD_STATE_READY);
+ vcdc_send_service_state(VCD_STATE_READY);
return VCD_ERROR_NONE;
}
int vcd_server_mgr_result_select()
{
- ecore_timer_add(0.01, __vcd_send_selected_result, NULL);
+ __vcd_send_selected_result(NULL);
return VCD_ERROR_NONE;
}
ret = vcd_server_mgr_cancel();
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to start recognition");
- return VCD_ERROR_OPERATION_FAILED;
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to cancel recognition : %d", ret);
+ return ret;
}
return VCD_ERROR_NONE;
Eina_Bool vcd_cleanup_client(void *data);
+int vcd_server_get_service_state();
+
/*
* For manager
int vcd_server_mgr_set_client_info(int pid);
-int vcd_server_mgr_start(bool stop_by_silence, bool exclusive_cmd, bool start_by_client);
+int vcd_server_mgr_start(vcd_recognition_mode_e recognition_mode, bool exclusive_cmd, bool start_by_client);
int vcd_server_mgr_stop();
<!-- 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"/>
+ <allow own_prefix="org.tizen.voice.vcclient"/>
+ <allow send_destination="org.tizen.voice.vcclient"/>
+ <allow receive_sender="org.tizen.voice.vcclient"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcclient"/>
+ <allow send_destination="org.tizen.voice.vcclient"/>
+ <allow receive_sender="org.tizen.voice.vcclient"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcclient"/>
+ <allow send_destination="org.tizen.voice.vcclient"/>
+ <allow receive_sender="org.tizen.voice.vcclient"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcwidget"/>
+ <allow send_destination="org.tizen.voice.vcwidget"/>
+ <allow receive_sender="org.tizen.voice.vcwidget"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcwidget"/>
+ <allow send_destination="org.tizen.voice.vcwidget"/>
+ <allow receive_sender="org.tizen.voice.vcwidget"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcwidget"/>
+ <allow send_destination="org.tizen.voice.vcwidget"/>
+ <allow receive_sender="org.tizen.voice.vcwidget"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcmanager"/>
+ <allow send_destination="org.tizen.voice.vcmanager"/>
+ <allow receive_sender="org.tizen.voice.vcmanager"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcmanager"/>
+ <allow send_destination="org.tizen.voice.vcmanager"/>
+ <allow receive_sender="org.tizen.voice.vcmanager"/>
</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"/>
+ <allow own_prefix="org.tizen.voice.vcmanager"/>
+ <allow send_destination="org.tizen.voice.vcmanager"/>
+ <allow receive_sender="org.tizen.voice.vcmanager"/>
</policy>
projects / platform / core / uifw / voice-control.git / commitdiff