INCLUDE(FindPkgConfig)
pkg_check_modules(pkgs REQUIRED
aul capi-base-common capi-media-audio-io capi-media-sound-manager capi-network-bluetooth capi-system-info
- dbus-1 dlog ecore glib-2.0 libxml-2.0 vconf
+ dbus-1 dlog ecore glib-2.0 libtzplatform-config libxml-2.0 vconf
)
## API ##
ADD_SUBDIRECTORY(server)
## config ##
-INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-config.xml DESTINATION /usr/share/voice/vc/)
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/vc-config.xml DESTINATION ${LIBDIR}/voice/vc/1.0)
INSTALL(FILES ${CMAKE_SOURCE_DIR}/org.tizen.voice.vcserver.service DESTINATION /usr/share/dbus-1/services)
* 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>)
+ * Update file IPC for foreground app to dbus IPC (Dongyeol Lee <dy3.lee@samsung.com>)
voice-control (0.2.8) -- Thu, 18 Jun 2015
}
g_feature_enabled = 1;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
}
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
}
}
return EINA_FALSE;
}
+static int __vc_app_state_changed_cb(int app_state, void *data)
+{
+ int ret = -1;
+ SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] app state changed");
+
+ /* Set current pid */
+ if (STATUS_VISIBLE == app_state) {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
+ ret = vc_dbus_set_foreground(getpid(), true);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
+ }
+
+ ret = vc_client_set_is_foreground(g_vc, true);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
+ }
+
+ /* set authority valid */
+ vc_auth_state_e state = VC_AUTH_STATE_NONE;
+ if (0 != vc_client_get_auth_state(g_vc, &state)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
+ }
+ if (VC_AUTH_STATE_INVALID == state) {
+ vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
+
+ /* notify auth changed cb */
+ ecore_timer_add(0, __notify_auth_changed_cb, NULL);
+ }
+ } else if (STATUS_BG == app_state) {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== Set background");
+ ret = vc_dbus_set_foreground(getpid(), false);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
+ }
+
+ ret = vc_client_set_is_foreground(g_vc, false);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
+ }
+
+ /* set authority valid */
+ vc_auth_state_e state = VC_AUTH_STATE_NONE;
+ if (0 != vc_client_get_auth_state(g_vc, &state)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
+ }
+ if (VC_AUTH_STATE_VALID == state) {
+ vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
+
+ /* notify authority changed cb */
+ ecore_timer_add(0, __notify_auth_changed_cb, NULL);
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCC, "===== App state is NOT valid");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
+
+ return 0;
+}
int vc_initialize(void)
{
#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);
+#else
+ ret = aul_add_status_local_cb(__vc_app_state_changed_cb, NULL);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set app stae changed callback");
+ }
#endif
-
vc_client_set_client_state(g_vc, VC_STATE_READY);
ecore_timer_add(0, __vc_notify_state_changed, g_vc);
return VC_ERROR_INVALID_STATE;
}
+ if (VC_STATE_READY != temp) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
/* get service state */
vc_service_state_e service_state;
if (0 != vc_client_get_service_state(g_vc, &service_state)) {
return EINA_FALSE;
}
-void __vc_cb_result(int pid)
+void __vc_cb_result(void)
{
- if (0 != vc_client_get_handle(pid, &g_vc)) {
- SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
- return;
- }
-
ecore_timer_add(0, __vc_notify_result, NULL);
return;
}
/* set authority into handle */
- int fg_pid = -1;
- if (0 != vc_config_mgr_get_foreground(&fg_pid)) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get foreground");
+ bool is_foreground = false;
+ if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
return VC_ERROR_OPERATION_FAILED;
}
- if (g_vc->handle == fg_pid) {
+ if (is_foreground) {
auth_state = VC_AUTH_STATE_VALID;
} else {
auth_state = VC_AUTH_STATE_INVALID;
void* auth_state_changed_user_data;
int mgr_pid;
+
+ /* is foreground */
+ bool is_foreground;
} vc_client_s;
/* client list */
client->exclusive_cmd = false;
#endif
- client->service_state = -1;
+ client->service_state = VC_RUNTIME_INFO_NO_FOREGROUND;
client->before_state = VC_STATE_INITIALIZED;
client->current_state = VC_STATE_INITIALIZED;
client->auth_state_changed_cb = NULL;
client->auth_state_changed_user_data = NULL;
+ client->is_foreground = false;
+
g_client_list = g_slist_append(g_client_list, client);
*vc = temp;
return 0;
}
+int vc_client_set_is_foreground(vc_h vc, bool value)
+{
+ vc_client_s* client = __client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->is_foreground = value;
+ return 0;
+}
+
+int vc_client_get_is_foreground(vc_h vc, bool* value)
+{
+ vc_client_s* client = __client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *value = client->is_foreground;
+
+ return 0;
+}
+
#if 0
int vc_client_set_exclusive_cmd(vc_h vc, bool value)
{
int vc_client_get_xid(vc_h vc, int* xid);
+int vc_client_set_is_foreground(vc_h vc, bool value);
+
+int vc_client_get_is_foreground(vc_h vc, bool* value);
+
#if 0
int vc_client_set_exclusive_cmd(vc_h vc, bool value);
extern int __vc_cb_error(int pid, int reason);
-extern void __vc_cb_result(int pid);
+extern void __vc_cb_result();
extern int __vc_cb_service_state(int state);
} /* VCD_METHOD_SET_SERVICE_STATE */
- else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_RESULT)) {
+ else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
- int pid = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
-
- __vc_cb_result(pid);
+ __vc_cb_result();
SLOG(LOG_DEBUG, TAG_VCC, "=====");
SLOG(LOG_DEBUG, TAG_VCC, " ");
} /* VCD_METHOD_RESULT */
- else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_ERROR)) {
+ else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_ERROR)) {
SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
int pid;
int reason;
}
DBusError err;
+ int ret;
/* initialise the error value */
dbus_error_init(&err);
/* connect to the DBUS system bus, and check for errors */
- g_conn_sender = dbus_bus_get(DBUS_BUS_SESSION, &err);
+ g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
return VC_ERROR_OPERATION_FAILED;
}
- g_conn_listener = dbus_bus_get(DBUS_BUS_SESSION, &err);
+ g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
return VC_ERROR_OPERATION_FAILED;
}
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+
+ SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
+
+ /* register our name on the bus, and check for errors */
+ ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
+ SLOG(LOG_ERROR, TAG_VCC, "fail dbus_bus_request_name()");
+ return -2;
+ }
+
if (NULL != g_fd_handler) {
SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
return 0;
g_fd_handler = NULL;
}
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+
+ dbus_bus_release_name(g_conn_listener, service_name, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ dbus_connection_close(g_conn_sender);
+ dbus_connection_close(g_conn_listener);
g_conn_sender = NULL;
g_conn_listener = NULL;
return result;
}
+int vc_dbus_set_foreground(int pid, bool value)
+{
+ DBusMessage* msg = NULL;
+ int tmp_value = 0;
+
+ tmp_value = (int)value;
+
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCC_MANAGER_METHOD_SET_FOREGROUND);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to manager : Fail to make message");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &tmp_value,
+ DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ dbus_message_unref(msg);
+
+ msg = NULL;
+ msg = dbus_message_new_method_call(
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_SET_FOREGROUND);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to daemon : Fail to make message");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &tmp_value,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ dbus_connection_flush(g_conn_sender);
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
+
#if 0
int vc_dbus_request_start(int pid, int silence)
{
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
char object_path[64] = {0,};
char target_if_name[128] = {0,};
- snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type);
+int vc_dbus_set_foreground(int pid, bool value);
+
#if 0
int vc_dbus_request_start(int pid, int silence);
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);
-
- /* get authorized valid app */
- int pid;
- if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &pid)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
- return;
- }
-
- /* compare & set valid */
- if (current != pid) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", pid);
-
- /* set authorized valid */
- if (true == vc_mgr_client_is_authorized_client(g_vc_m, current)) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", current);
- vc_mgr_client_set_valid_authorized_client(g_vc_m, current);
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
- vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
- }
- }
-}
-
int vc_mgr_initialize()
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Initialize");
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);
-
SLOG(LOG_DEBUG, TAG_VCM, "[Success] pid(%d)", g_vc_m->handle);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
/* request initialization */
int ret = -1;
int service_state = 0;
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state);
+ int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
+ ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
/* Set service state */
vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)service_state);
+ /* Set foreground */
+ vc_mgr_client_set_foreground(g_vc_m, foreground, true);
+
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
vc_mgr_client_set_client_state(g_vc_m, VC_STATE_READY);
int ret = -1;
/* Get foreground pid */
- if (0 != vc_config_mgr_get_foreground(&fg_pid)) {
+ if (0 != vc_mgr_client_get_foreground(g_vc_m, &fg_pid)) {
/* There is no foreground app for voice control */
SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
} else {
return 0;
}
-int vc_mgr_start(bool stop_by_silence, bool exclusive_command_option)
+int vc_mgr_start(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);
+ vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
+ if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
+ }
/* Request */
ret = -1;
return 0;
}
+int __vc_mgr_cb_set_foreground(int pid, bool value)
+{
+ vc_mgr_client_set_foreground(g_vc_m, pid, value);
+
+ /* get authorized valid app */
+ int tmp_pid;
+ if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &tmp_pid)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ if (true == value) {
+ /* compare & set valid */
+ if (tmp_pid != pid) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
+
+ /* set authorized valid */
+ if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid);
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
+ }
+ }
+ } else {
+ if (tmp_pid == pid) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
+ }
+ }
+
+ return 0;
+}
+
int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Select result");
/* foreground check */
int fore_pid = 0;
- if (0 != vc_config_mgr_get_foreground(&fore_pid)) {
+ if (0 != vc_mgr_client_get_foreground(g_vc_m, &fore_pid)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground");
return VC_ERROR_OPERATION_FAILED;
}
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
}
- if (0 != vc_mgr_start(true, false)) {
+ if (0 != vc_mgr_start(false)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed");
/* TODO - Error handling? */
}
GSList* authorized_client_list;
int valid_authorized_pid;
bool start_by_client;
+
+ /* foreground pid */
+ int foreground_pid;
} vc_mgr_client_s;
typedef struct {
client->valid_authorized_pid = -1;
client->start_by_client = false;
+ client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
+
g_mgr_client_list = g_slist_append(g_mgr_client_list, client);
*vc = temp;
int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode)
{
- if (NULL == mode) {
+ if (NULL == mode) {
return -1;
}
return 0;
}
+int vc_mgr_client_set_foreground(vc_h vc, int pid, bool value)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ if (true == value) {
+ client->foreground_pid = pid;
+ } else {
+ if (pid == client->foreground_pid) {
+ client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
+ }
+ }
+
+ return 0;
+}
+
+int vc_mgr_client_get_foreground(vc_h vc, int* pid)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *pid = client->foreground_pid;
+ return 0;
+}
+
/* utils */
int vc_mgr_client_get_count()
{
int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode);
+int vc_mgr_client_set_foreground(vc_h vc, int pid, bool value);
+
+int vc_mgr_client_get_foreground(vc_h vc, int* pid);
/* utils */
int vc_mgr_client_get_count();
static DBusConnection* g_m_conn_sender = NULL;
static DBusConnection* g_m_conn_listener = NULL;
+static int g_volume_count = 0;
+
extern void __vc_mgr_cb_all_result(vc_result_type_e type);
extern int __vc_mgr_cb_service_state(int state);
+extern int __vc_mgr_cb_set_foreground(int pid, bool value);
+
/* Authority */
extern int __vc_mgr_request_auth_enable(int pid);
break;
}
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Message is arrived");
+ /* SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Message is arrived"); */
DBusError err;
dbus_error_init(&err);
- char if_name[64];
+ char if_name[64] = {0, };
snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE);
if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
} /* VCD_METHOD_HELLO */
else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_VOLUME)) {
- /* SLOG(LOG_DEBUG, TAG_VCM, "===== Set volume"); */
float volume = 0;
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
dbus_error_free(&err);
}
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set volume : volume(%f)", volume);
+ if (10 == g_volume_count) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Set volume");
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set volume : volume(%f)", volume);
+ g_volume_count = 0;
+ }
+
__vc_mgr_cb_set_volume(volume);
+ g_volume_count++;
- /* SLOG(LOG_DEBUG, TAG_VCM, "====="); */
- /* SLOG(LOG_DEBUG, TAG_VCM, " "); */
} /* VCD_MANAGER_METHOD_SET_VOLUME */
else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_SERVICE_STATE)) {
} /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
- else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
SLOG(LOG_DEBUG, TAG_VCM, "===== Get Speech detected");
__vc_mgr_cb_speech_detected();
} /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
- else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
+ 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;
} /* VCD_MANAGER_METHOD_ALL_RESULT */
- else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
SLOG(LOG_DEBUG, TAG_VCM, "===== Get System Result");
__vc_mgr_cb_system_result();
} /* VCD_MANAGER_METHOD_RESULT */
- else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
+ else if (dbus_message_is_signal(msg, if_name, VCC_MANAGER_METHOD_SET_FOREGROUND)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Set foreground");
+ int pid = 0;
+ int value = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &value,
+ DBUS_TYPE_INVALID);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
+
+ __vc_mgr_cb_set_foreground(pid, (bool)value);
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ } /* VCC_MANAGER_METHOD_SET_FOREGROUND */
+
+ 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;
g_m_fd_handler = NULL;
}
- dbus_bus_release_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, &err);
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
+
+ dbus_bus_release_name(g_m_conn_listener, service_name, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
dbus_error_free(&err);
}
+ dbus_connection_close(g_m_conn_sender);
+ dbus_connection_close(g_m_conn_listener);
+
g_m_conn_sender = NULL;
g_m_conn_listener = NULL;
return result;
}
-
-int vc_mgr_dbus_request_initialize(int pid, int* service_state)
+int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground)
{
DBusMessage* msg;
}
if (NULL != result_msg) {
+ int tmp_service_state = 0;
+ int tmp_foreground = 0;
dbus_message_get_args(result_msg, &err,
DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INT32, service_state,
+ DBUS_TYPE_INT32, &tmp_service_state,
+ DBUS_TYPE_INT32, &tmp_foreground,
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, service state = %d", result, *service_state);
+ *service_state = tmp_service_state;
+ *foreground = tmp_foreground;
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d, foreground = %d",
+ result, *service_state, *foreground);
} else {
SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
}
memset(target_if_name, '\0', 128);
if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
- snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_NAME);
-
+ snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
} else if (VC_COMMAND_TYPE_WIDGET == type) {
- snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
- snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
+ snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
} else {
return NULL;
}
int vc_mgr_dbus_request_hello();
-int vc_mgr_dbus_request_initialize(int pid, int* service_state);
+int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground);
int vc_mgr_dbus_request_finalize(int pid);
static vc_setting_state_e g_state = VC_SETTING_STATE_NONE;
-static vc_setting_enabled_changed_cb g_callback;
+static vc_setting_enabled_changed_cb g_callback = NULL;
-static void* g_user_data;
+static void* g_user_data = NULL;
+static vc_setting_current_language_changed_cb g_lang_callback = NULL;
+
+static void* g_lang_user_data = NULL;
const char* vc_tag()
{
void __config_lang_changed_cb(const char* before_lang, const char* current_lang)
{
SLOG(LOG_DEBUG, TAG_VCS, "Lang changed : before(%s) current(%s)", before_lang, current_lang);
+
+ if (NULL != g_lang_callback) {
+ g_lang_callback(before_lang, current_lang, g_lang_user_data);
+ }
}
void __vc_setting_state_changed_cb(int before_state, int current_state, void* user_data)
SLOG(LOG_DEBUG, TAG_VCS, " ");
return 0;
-}
\ No newline at end of file
+}
+
+int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCS, "===== Set current language changed callback");
+
+ if (VC_SETTING_STATE_NONE == g_state) {
+ SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
+ SLOG(LOG_DEBUG, TAG_VCS, "=====");
+ SLOG(LOG_DEBUG, TAG_VCS, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ if (NULL == callback) {
+ SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Param is NULL");
+ SLOG(LOG_DEBUG, TAG_VCS, "=====");
+ SLOG(LOG_DEBUG, TAG_VCS, " ");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ g_lang_callback = callback;
+ g_lang_user_data = user_data;
+
+ SLOG(LOG_DEBUG, TAG_VCS, "=====");
+ SLOG(LOG_DEBUG, TAG_VCS, " ");
+
+ return 0;
+}
+
+int vc_setting_unset_current_language_changed_cb()
+{
+ SLOG(LOG_DEBUG, TAG_VCS, "===== Unset current language changed callback");
+
+ if (VC_SETTING_STATE_NONE == g_state) {
+ SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Not initialized");
+ SLOG(LOG_DEBUG, TAG_VCS, "=====");
+ SLOG(LOG_DEBUG, TAG_VCS, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ g_lang_callback = NULL;
+ g_lang_user_data = NULL;
+
+ SLOG(LOG_DEBUG, TAG_VCS, "=====");
+ SLOG(LOG_DEBUG, TAG_VCS, " ");
+
+ return 0;
+}
+
}
SLOG(LOG_DEBUG, TAG_VCW, "Set foreground : pid(%d) value(%s)", getpid(), value ? "true" : "false");
- int ret = vc_config_mgr_set_foreground(getpid(), value);
+ int ret = vc_widget_dbus_set_foreground(getpid(), value);
if (0 != ret) {
ret = vc_config_convert_error_code((vc_config_error_e)ret);
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set foreground : %s", __vc_widget_get_error_code(ret));
return EINA_FALSE;
}
-void __vc_widget_cb_result(int pid)
+void __vc_widget_cb_result()
{
- if (0 != vc_widget_client_get_handle(pid, &g_vc_w)) {
- SLOG(LOG_ERROR, TAG_VCW, "Handle is not valid : pid(%d)", pid);
- return;
- }
-
ecore_timer_add(0, __vc_widget_notify_result, NULL);
return;
extern void __vc_widget_cb_show_tooltip(int pid, bool show);
-extern void __vc_widget_cb_result(int pid);
+extern void __vc_widget_cb_result();
extern int __vc_widget_cb_service_state(int state);
} /* VCD_WIDGET_METHOD_SET_SERVICE_STATE */
- else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_SHOW_TOOLTIP)) {
+ 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;
SLOG(LOG_DEBUG, TAG_VCW, " ");
} /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
- else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
+ else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget result");
- int pid = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
-
- __vc_widget_cb_result(pid);
+ __vc_widget_cb_result();
/*
reply = dbus_message_new_method_return(msg);
} /* VCD_WIDGET_METHOD_RESULT */
- else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
+ 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;
}
DBusError err;
+ int ret;
/* initialise the error value */
dbus_error_init(&err);
/* connect to the DBUS system bus, and check for errors */
- g_w_conn_sender = dbus_bus_get(DBUS_BUS_SESSION, &err);
+ g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
return VC_ERROR_OPERATION_FAILED;
}
- g_w_conn_listener = dbus_bus_get(DBUS_BUS_SESSION, &err);
+ g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
return VC_ERROR_OPERATION_FAILED;
}
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+
+ SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
+
+ /* register our name on the bus, and check for errors */
+ ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
+ SLOG(LOG_ERROR, TAG_VCW, "fail dbus_bus_request_name()");
+ return -2;
+ }
+
if (NULL != g_w_fd_handler) {
SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
return 0;
g_w_fd_handler = NULL;
}
+ int pid = getpid();
+
+ char service_name[64];
+ memset(service_name, '\0', 64);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+
+ dbus_bus_release_name(g_w_conn_listener, service_name, &err);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ dbus_connection_close(g_w_conn_sender);
+ dbus_connection_close(g_w_conn_listener);
+
g_w_conn_sender = NULL;
g_w_conn_listener = NULL;
return result;
}
+int vc_widget_dbus_set_foreground(int pid, bool value)
+{
+ DBusMessage* msg = NULL;
+ int tmp_value = 0;
+
+ tmp_value = (int)value;
+
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCC_MANAGER_METHOD_SET_FOREGROUND);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to manager : Fail to make message");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &tmp_value,
+ DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ dbus_message_unref(msg);
+
+ msg = NULL;
+ msg = dbus_message_new_method_call(
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_SET_FOREGROUND);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to daemon : Fail to make message");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &tmp_value,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ dbus_connection_flush(g_w_conn_sender);
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
+
+
int vc_widget_dbus_request_start(int pid, int silence)
{
DBusMessage* msg;
int vc_widget_dbus_request_start_recording(int pid, bool command);
+int vc_widget_dbus_set_foreground(int pid, bool value);
+
int vc_widget_dbus_request_start(int pid, int silence);
}
g_feature_enabled = 1;
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
}
+ } else {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
+ return VC_ERROR_NOT_SUPPORTED;
}
}
typedef struct {
int uid;
vc_config_lang_changed_cb lang_cb;
- vc_config_foreground_changed_cb foreground_cb;
vc_config_enabled_cb enabled_cb;
} vc_config_client_s;
static int g_fd_lang;
static int g_wd_lang;
-static int g_fore_ref_count;
-static Ecore_Fd_Handler* g_fd_handler_fore = NULL;
-static int g_fd_fore;
-static int g_wd_fore;
-
int __vc_config_mgr_print_engine_info();
SLOG(LOG_WARN, vc_config_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
__vc_config_mgr_print_client_info();
-
return 0;
}
- if (0 != access(VC_CONFIG_BASE, F_OK)) {
- if (0 != mkdir(VC_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_CONFIG_BASE);
- return -1;
- } else {
- SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_CONFIG_BASE);
- }
- }
-
- if (0 != access(VC_RUNTIME_INFO_ROOT, F_OK)) {
- if (0 != mkdir(VC_RUNTIME_INFO_ROOT, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_RUNTIME_INFO_ROOT);
- return -1;
- } else {
- SLOG(LOG_DEBUG, vc_config_tag(), "Success to make directory : %s", VC_RUNTIME_INFO_ROOT);
- }
- }
-
/* Get file name from default engine directory */
DIR *dp = NULL;
int ret = -1;
SLOG(LOG_DEBUG, vc_config_tag(), "Current foreground pid : %d", g_foreground_pid);
g_lang_ref_count = 0;
- g_fore_ref_count = 0;
/* Register to detect display language change */
vconf_notify_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb, NULL);
return 0;
}
-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");
-
- int length;
- struct inotify_event event;
- memset(&event, '\0', sizeof(struct inotify_event));
-
- length = read(g_fd_fore, &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 foreground_pid = -1;
- if (0 != vc_parser_get_foreground(&foreground_pid)) {
- SLOG(LOG_ERROR, vc_config_tag(), "Fail to get state");
- return ECORE_CALLBACK_PASS_ON;
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "foreground pid (%d)", foreground_pid);
-
- /* If foreground pid is changed */
- if (g_foreground_pid != foreground_pid) {
- int previous_pid = g_foreground_pid;
- g_foreground_pid = foreground_pid;
-
- 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->foreground_cb) {
- temp_client->foreground_cb(previous_pid, g_foreground_pid);
- }
- }
-
- 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_foreground_event()
-{
- if (0 == g_fore_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_fore = fd;
-
- wd = inotify_add_watch(g_fd_fore, VC_RUNTIME_INFO_FOREGROUND, IN_CLOSE_WRITE);
- g_wd_fore = wd;
-
- g_fd_handler_fore = ecore_main_fd_handler_add(g_fd_fore, ECORE_FD_READ, (Ecore_Fd_Cb)vc_config_mgr_inotify_foreground_cb,
- NULL, NULL, NULL);
- if (NULL == g_fd_handler_fore) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get handler for foreground");
- return -1;
- }
- }
- g_fore_ref_count++;
-
- return 0;
-}
-
-int __vc_config_mgr_unregister_foreground_event()
-{
- if (0 == g_fore_ref_count) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Foreground ref count is 0");
- return VC_CONFIG_ERROR_INVALID_STATE;
- }
-
- g_fore_ref_count--;
-
- if (0 == g_fore_ref_count) {
- /* delete inotify variable */
- ecore_main_fd_handler_del(g_fd_handler_fore);
- inotify_rm_watch(g_fd_fore, g_wd_fore);
- close(g_fd_fore);
- }
-
- return 0;
-}
-
-int vc_config_mgr_set_foreground_cb(int uid, vc_config_foreground_changed_cb foreground_cb)
-{
- if (NULL == foreground_cb) {
- SLOG(LOG_ERROR, vc_config_tag(), "Foreground 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->foreground_cb = foreground_cb;
- __vc_config_mgr_register_foreground_event();
- return VC_CONFIG_ERROR_NONE;
- }
- }
- iter = g_slist_next(iter);
- }
-
- return VC_CONFIG_ERROR_INVALID_PARAMETER;
-}
-
-int vc_config_mgr_unset_foreground_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->foreground_cb = NULL;
- __vc_config_mgr_unregister_foreground_event();
- return 0;
- }
- }
- iter = g_slist_next(iter);
- }
-
- return VC_CONFIG_ERROR_INVALID_PARAMETER;
-}
-
int vc_config_mgr_set_enabled_cb(int uid, vc_config_enabled_cb enabled_cb)
{
if (NULL == enabled_cb) {
typedef void (*vc_config_lang_changed_cb)(const char* before_lang, const char* current_lang);
-typedef void (*vc_config_foreground_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_foreground_cb(int uid, vc_config_foreground_changed_cb foreground_cb);
-
-int vc_config_mgr_unset_foreground_cb(int uid);
int vc_config_mgr_set_enabled_cb(int uid, vc_config_enabled_cb enabled_cb);
int vc_config_convert_error_code(vc_config_error_e code);
-int vc_config_mgr_set_foreground(int pid, bool value);
-
-int vc_config_mgr_get_foreground(int* pid);
-
-
#ifdef __cplusplus
}
#endif
if (0 > chmod(filename, 0666)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to change file mode");
- /* return -1; */
+ return -1;
}
+#if 0 /*Does not need to change owner on Tizen 3.0*/
+ if (0 > chown(filename, 5000, 5000)) {
+ SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to change file owner");
+ return -1;
+ }
+#endif
return 0;
}
#define VC_METHOD_SET_EXCLUSIVE_CMD "vc_method_set_exclusive_cmd"
#define VC_METHOD_SET_COMMAND "vc_method_set_command"
#define VC_METHOD_UNSET_COMMAND "vc_method_unset_command"
+#define VC_METHOD_SET_FOREGROUND "vc_method_set_foreground"
#define VCD_METHOD_RESULT "vcd_method_result"
#define VCD_METHOD_ERROR "vcd_method_error"
#define VCD_MANAGER_METHOD_ERROR "vcd_manager_method_error"
+#define VCC_MANAGER_METHOD_SET_FOREGROUND "vcd_manager_method_set_foreground"
+
/******************************************************************************************
* Defines for configuration
#define VC_DAEMON_PATH "/usr/bin/vc-daemon"
-#define VC_CONFIG_DEFAULT "/usr/share/voice/vc/vc-config.xml"
+#define VC_CONFIG_DEFAULT VOICE_LIBDIR"/voice/vc/1.0/vc-config.xml"
#define VC_CONFIG_BASE tzplatform_mkpath(TZ_USER_HOME, "share/.voice")
#define VC_CONFIG tzplatform_mkpath(TZ_USER_HOME, "share/.voice/vc-config.xml")
#define VC_RUNTIME_INFO_CLIENT tzplatform_mkpath(TZ_USER_HOME, "share/.voice/vc/vc-client-info.xml")
+#define VC_RUNTIME_INFO_NO_FOREGROUND -1
+
#define VC_FEATURE_PATH "tizen.org/feature/speech.control"
#define VC_MIC_FEATURE_PATH "tizen.org/feature/microphone"
if (0 > chmod(filename, 0666)) {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to change file mode");
- /*return -1;*/
+ return -1;
+ }
+
+#if 0 /*Does not need to change owner on Tizen 3.0*/
+ if (0 > chown(filename, 5000, 5000)) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to change file owner");
+ return -1;
}
+#endif
return 0;
}
if (0 < selected_count) {
int ret = xmlSaveFormatFile(filepath, doc, 1);
if (0 >= ret) {
- SLOG(LOG_DEBUG, vc_info_tag(), "[ERROR] Fail to save command file : %d", ret);
+ SLOG(LOG_DEBUG, vc_info_tag(), "[ERROR] Fail to save command file : %d, filepath(%s)", ret, filepath);
free(filepath);
return -1;
}
#define VC_AUDIO_TYPE_BLUETOOTH "VC_AUDIO_ID_BLUETOOTH" /**< Bluetooth audio type */
/**
+* @brief Definitions for foreground command type.
+* @since_tizen 2.4
+*/
+#define VC_COMMAND_TYPE_FOREGROUND 1
+
+/**
+* @brief Definitions for background command type.
+* @since_tizen 2.4
+*/
+#define VC_COMMAND_TYPE_BACKGROUND 2
+
+/**
+* @brief Definitions for widget command type.
+* @since_tizen 2.4
+*/
+#define VC_COMMAND_TYPE_WIDGET 3
+
+/**
* @brief Definitions for system command type.
* @since_tizen 2.4
*/
* @retval #VC_ERROR_NONE Successful
* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
*
-* @pre The state should NOT be #VC_SERVICE_STATE_NONE.
+* @pre The state should be #VC_STATE_READY.
*
* @see vc_mgr_start()
* @see vc_mgr_stop()
/**
* @brief Sets recognition mode.
*
-* @param[in] mode recognition mode (e.g. #VC_RECOGNITION_MODE_SILENCE_DETECTION_ONE_TURN is default value)
+* @param[in] mode recognition mode (e.g. #VC_RECOGNITION_MODE_STOP_BY_SILENCE is default value)
*
* @return 0 on success, otherwise a negative error value
* @retval #VC_ERROR_NONE Successful
/**
* @brief Starts recognition.
*
-* @param[in] stop_by_silence Silence detection option
+* @remarks The default recognition mode is #VC_RECOGNITION_MODE_STOP_BY_SILENCE. \n
+* If you want to use other mode, you can set mode with vc_mgr_set_recognition_mode().
+*
* @param[in] exclusive_command_option Exclusive command option
*
* @return 0 on success, otherwise a negative error value
* @see vc_mgr_stop()
* @see vc_mgr_cancel()
* @see vc_service_state_changed_cb()
+* @see vc_mgr_set_recognition_mode()
+* @see vc_mgr_get_recognition_mode()
*/
-int vc_mgr_start(bool stop_by_silence, bool exclusive_command_option);
+int vc_mgr_start(bool exclusive_command_option);
/**
* @brief Stop recognition.
*/
typedef bool(*vc_setting_supported_language_cb)(const char* language, void* user_data);
+/**
+* @brief Called when default language is changed.
+* @since_tizen 2.4
+*
+* @param[in] previous Previous language
+* @param[in] current Current language
+* @param[in] user_data The user data passed from the callback registration function
+*
+* @pre An application registers this callback to detect changing mode.
+*
+* @see vc_setting_set_current_language_changed_cb()
+*/
+typedef void (*vc_setting_current_language_changed_cb)(const char* previous, const char* current, void* user_data);
/**
* @brief Initialize voice control setting
* @brief Unsets the callback function.
*
* @return 0 on success, otherwise a negative error value
-* @retval #VC_ELM_ERROR_NONE Successful
-* @retval #VC_ELM_ERROR_INVALID_STATE Invalid state
-* @retval #VC_ELM_ERROR_PERMISSION_DENIED Permission denied
-* @retval #VC_ELM_ERROR_NOT_SUPPORTED Not supported
+* @retval #VC_ERROR_NONE Success.
+* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
+* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @pre vc_setting_initialize() should be successful.
*
*/
int vc_setting_unset_enabled_changed_cb();
+/**
+* @brief Registers a callback function to be called when current language is changed.
+*
+* @param[in] callback Callback function to register
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #VC_ERROR_NONE Success.
+* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
+*
+* @pre vc_setting_initialize() should be successful.
+*
+* @see vc_setting_unset_current_language_changed_cb()
+*/
+int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data);
+
+/**
+* @brief Unregisters the callback function.
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #VC_ERROR_NONE Success.
+* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
+*
+* @pre vc_setting_initialize() should be successful.
+*
+* @see vc_setting_set_current_language_changed_cb()
+*/
+int vc_setting_unset_current_language_changed_cb();
+
#ifdef __cplusplus
}
%post
/sbin/ldconfig
-mkdir -p /usr/share/voice/vc
+mkdir -p %{_libdir}/voice/vc
%postun -p /sbin/ldconfig
%{_libdir}/libvc_widget.so
%{_libdir}/libvc_manager.so
%{_bindir}/vc-daemon
+%{_libdir}/voice/vc/1.0/vc-config.xml
/usr/share/dbus-1/services/org.tizen.voice*
/etc/dbus-1/session.d/vc-server.conf
-/usr/share/voice/vc/vc-config.xml
/usr/share/license/%{name}
%files devel
static vcd_config_lang_changed_cb g_lang_cb;
-static vcd_config_foreground_changed_cb g_fore_cb;
-
static void* g_user_data;
static vcd_state_e g_state;
+static int g_foreground_pid;
+
void __vcd_config_lang_changed_cb(const char* before_lang, const char* current_lang)
{
SLOG(LOG_ERROR, TAG_VCD, "Language changed callback is NULL");
}
-void __vcd_config_foreground_changed_cb(int previous, int current)
-{
- if (NULL != g_fore_cb)
- g_fore_cb(previous, current, g_user_data);
- else
- SLOG(LOG_ERROR, TAG_VCD, "Foreground changed callback is NULL");
-}
int vcd_config_initialize(vcd_config_lang_changed_cb lang_cb, vcd_config_foreground_changed_cb fore_cb, void* user_data)
{
return VCD_ERROR_OPERATION_FAILED;
}
- ret = vc_config_mgr_set_foreground_cb(getpid(), __vcd_config_foreground_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set foreground changed callback : %d", ret);
- return VCD_ERROR_OPERATION_FAILED;
- }
-
g_lang_cb = lang_cb;
- g_fore_cb = fore_cb;
g_user_data = user_data;
+ g_foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
+
return 0;
}
int vcd_config_finalize()
{
- vc_config_mgr_unset_foreground_cb(getpid());
vc_config_mgr_unset_lang_cb(getpid());
vc_config_mgr_finalize(getpid());
return 0;
int vcd_config_get_foreground(int* pid)
{
- return vc_config_mgr_get_foreground(pid);
+ *pid = g_foreground_pid;
+ return 0;
+}
+
+int vcd_config_set_foreground(int pid, bool value)
+{
+ if (true == value) {
+ g_foreground_pid = pid;
+ } else {
+ if (pid == g_foreground_pid) {
+ g_foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
+ }
+ }
+ return 0;
}
int vcd_config_get_foreground(int* pid);
+int vcd_config_set_foreground(int pid, bool value);
+
#ifdef __cplusplus
}
static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
+static int g_waiting_time = 3000;
+
+static int g_volume_count = 0;
+
static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type)
{
char target_if_name[128] = {0,};
if (VCD_CLIENT_TYPE_NORMAL == type) {
- snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_INTERFACE);
-
} else if (VCD_CLIENT_TYPE_WIDGET == type) {
- snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
-
} else if (VCD_CLIENT_TYPE_MANAGER == type) {
snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
return NULL;
}
- return dbus_message_new_signal(object_path, target_if_name, method);
+ return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
}
int vcdc_send_hello(int pid, vcd_client_type_e type)
{
-#if 0
DBusMessage* msg = NULL;
if (VCD_CLIENT_TYPE_NORMAL == type) {
} else if (VCD_CLIENT_TYPE_WIDGET == type) {
msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET);
} else if (VCD_CLIENT_TYPE_MANAGER == type) {
- msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
+ msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
return -1;
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
+ if (NULL != err.name) {
+ if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
+ dbus_error_free(&err);
+ return 0;
+ }
+ }
dbus_error_free(&err);
}
dbus_message_unref(result_msg);
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
- result = 0;
}
return result;
-#endif
- return 1;
}
int vcdc_send_show_tooltip(int pid, bool show)
return -1;
}
+ char service_name[64] = {0, };
+ memset(service_name, 0, 64);
+ snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
+
+ char target_if_name[128] = {0, };
+ snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
+
DBusMessage* msg;
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
- msg = dbus_message_new_signal(
- VC_WIDGET_SERVICE_OBJECT_PATH,
- VC_WIDGET_SERVICE_INTERFACE,
- VCD_WIDGET_METHOD_SHOW_TOOLTIP);
+ msg = dbus_message_new_method_call(
+ service_name,
+ VC_WIDGET_SERVICE_OBJECT_PATH,
+ target_if_name,
+ VCD_WIDGET_METHOD_SHOW_TOOLTIP);
if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &pid);
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
+ dbus_message_set_no_reply(msg, TRUE);
+
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
dbus_message_unref(msg);
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send set volume : pid(%d), volume(%f)", manger_pid, volume);
+ if (10 == g_volume_count) {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send set volume : pid(%d), volume(%f)", manger_pid, volume);
+ g_volume_count = 0;
+ }
+
dbus_connection_flush(g_conn_sender);
+
+ g_volume_count++;
}
dbus_message_unref(msg);
return VCD_ERROR_OUT_OF_MEMORY;
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
+ dbus_message_set_no_reply(msg, TRUE);
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
+ dbus_message_set_no_reply(msg, TRUE);
+
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
return VCD_ERROR_OUT_OF_MEMORY;
}
+ dbus_message_set_no_reply(msg, TRUE);
+
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
return VCD_ERROR_INVALID_PARAMETER;
}
+ char service_name[64] = {0, };
+ snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+
DBusMessage* msg;
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send error signal : reason(%d), Error Msg(%s)", reason, err_msg);
- msg = dbus_message_new_signal(
- VC_CLIENT_SERVICE_OBJECT_PATH,
- VC_CLIENT_SERVICE_INTERFACE,
- VCD_METHOD_ERROR);
+ msg = dbus_message_new_method_call(
+ service_name,
+ VC_CLIENT_SERVICE_OBJECT_PATH,
+ VC_CLIENT_SERVICE_INTERFACE,
+ VCD_METHOD_ERROR);
if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
DBUS_TYPE_STRING, &err_msg,
DBUS_TYPE_INVALID);
+ dbus_message_set_no_reply(msg, TRUE);
+
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
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;
+ }
- /* Common event */
- if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
- vcd_dbus_server_hello(g_conn_listener, msg);
+ /* Common event */
+ if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
+ vcd_dbus_server_hello(g_conn_listener, msg);
- /* manager event */
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
- vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
+ /* manager event */
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
+ vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
- vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
+ vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
- vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
+ vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
- vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
+ vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
- vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
+ vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
- vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
+ vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
- vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
+ vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
- vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
+ vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
- vcd_dbus_server_mgr_start(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
+ vcd_dbus_server_mgr_start(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
- vcd_dbus_server_mgr_stop(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
+ vcd_dbus_server_mgr_stop(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
- vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
+ vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
- vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
+ vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
- /* client event */
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
- vcd_dbus_server_initialize(g_conn_listener, msg);
+ /* client event */
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
+ vcd_dbus_server_initialize(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
- vcd_dbus_server_finalize(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
+ vcd_dbus_server_finalize(g_conn_listener, msg);
#if 0
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
- vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
+ vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
#endif
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
- vcd_dbus_server_set_command(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
+ vcd_dbus_server_set_command(g_conn_listener, msg);
+
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
+ vcd_dbus_server_unset_command(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
- vcd_dbus_server_unset_command(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
+ vcd_dbus_server_set_foreground(g_conn_listener, msg);
#if 0
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
- vcd_dbus_server_start_request(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
+ vcd_dbus_server_start_request(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
- vcd_dbus_server_stop_request(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
+ vcd_dbus_server_stop_request(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
- vcd_dbus_server_cancel_request(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
+ vcd_dbus_server_cancel_request(g_conn_listener, msg);
#endif
- /* widget event */
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
- vcd_dbus_server_widget_initialize(g_conn_listener, msg);
+ /* widget event */
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
+ vcd_dbus_server_widget_initialize(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
- vcd_dbus_server_widget_finalize(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
+ vcd_dbus_server_widget_finalize(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
- vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
+ vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
- vcd_dbus_server_widget_start(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
+ vcd_dbus_server_widget_start(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
- vcd_dbus_server_widget_stop(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
+ vcd_dbus_server_widget_stop(g_conn_listener, msg);
- else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
- vcd_dbus_server_widget_cancel(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
+ vcd_dbus_server_widget_cancel(g_conn_listener, msg);
- else
- return ECORE_CALLBACK_RENEW;
+ else {
+ SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
+ dbus_message_unref(msg);
+ break;
+ }
- /* free the message */
- dbus_message_unref(msg);
+ /* free the message */
+ dbus_message_unref(msg);
+ }
return ECORE_CALLBACK_RENEW;
}
dbus_error_free(&err);
}
+ dbus_connection_close(g_conn_listener);
+ dbus_connection_close(g_conn_sender);
+
g_conn_listener = NULL;
g_conn_sender = NULL;
int pid;
int service_state;
+ int foreground;
int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} 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();
+ foreground = vcd_server_get_foreground();
+
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d)", pid, service_state, foreground);
}
DBusMessage* reply;
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &service_state,
+ DBUS_TYPE_INT32, &foreground,
DBUS_TYPE_INVALID);
if (0 == ret) {
return 0;
}
+int vcd_dbus_server_set_foreground(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ int pid;
+ int value;
+
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD set foreground");
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd set foreground : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ } else {
+ bool tmp_value;
+ tmp_value = (bool)value;
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set foreground : pid(%d), value(%s)", pid, value ? "true" : "false");
+ vcd_server_set_foreground(pid, tmp_value);
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<<<");
+ SLOG(LOG_DEBUG, TAG_VCD, " ");
+
+ return 0;
+}
+
#if 0
int vcd_dbus_server_start_request(DBusConnection* conn, DBusMessage* msg)
{
int vcd_dbus_server_unset_command(DBusConnection* conn, DBusMessage* msg);
+int vcd_dbus_server_set_foreground(DBusConnection* conn, DBusMessage* msg);
+
#if 0
int vcd_dbus_server_start_request(DBusConnection* conn, DBusMessage* msg);
return EXIT_FAILURE;
}
- g_check_client_timer = ecore_timer_add(CLIENT_CLEAN_UP_TIME, vcd_cleanup_client, NULL);
+ g_check_client_timer = ecore_timer_add(CLIENT_CLEAN_UP_TIME, vcd_cleanup_client_all, NULL);
if (NULL == g_check_client_timer) {
SLOG(LOG_WARN, TAG_VCD, "[Main Warning] Fail to create timer of client check");
}
#include <audio_io.h>
-#include <bluetooth.h>
#include <math.h>
#include <sound_manager.h>
*/
static bool g_is_engine;
+static GList *g_proc_list = NULL;
+
/*
* VC Server Internal Functions
*/
void vcd_finalize()
{
+ GList *iter = NULL;
+ if (0 < g_list_length(g_proc_list)) {
+ iter = g_list_first(g_proc_list);
+ while (NULL != iter) {
+ g_proc_list = g_list_remove_link(g_proc_list, iter);
+ iter = g_list_first(g_proc_list);
+ }
+ }
+
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_READY != state) {
if (VCD_STATE_RECORDING == state) {
return EINA_FALSE;
}
-Eina_Bool vcd_cleanup_client(void *data)
+static void __read_proc()
+{
+ DIR *dp = NULL;
+ struct dirent entry;
+ struct dirent *dirp = NULL;
+ int ret = -1;
+ int tmp;
+
+ GList *iter = NULL;
+ if (0 < g_list_length(g_proc_list)) {
+ iter = g_list_first(g_proc_list);
+ while (NULL != iter) {
+ g_proc_list = g_list_remove_link(g_proc_list, iter);
+ iter = g_list_first(g_proc_list);
+ }
+ }
+
+ dp = opendir("/proc");
+ if (NULL == dp) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to open proc");
+ } else {
+ do {
+ ret = readdir_r(dp, &entry, &dirp);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to readdir");
+ break;
+ }
+
+ if (NULL != dirp) {
+ tmp = atoi(dirp->d_name);
+ if (0 >= tmp) continue;
+ g_proc_list = g_list_append(g_proc_list, GINT_TO_POINTER(tmp));
+ }
+ } while (NULL != dirp);
+ closedir(dp);
+ }
+ return;
+}
+
+static void __vcd_cleanup_client(vcd_client_type_e type)
{
-#if 0
int* client_list = NULL;
int client_count = 0;
- int result;
int i = 0;
+ int j = 0;
+ bool exist = false;
+ int mgr_pid = -1;
+ int ret = -1;
+
+ if (VCD_CLIENT_TYPE_NORMAL == type) {
+ ret = vcd_client_get_list(&client_list, &client_count);
+ }
+ else if (VCD_CLIENT_TYPE_WIDGET == type) {
+ ret = vcd_client_widget_get_list(&client_list, &client_count);
+ }
+ else if (VCD_CLIENT_TYPE_MANAGER == type) {
+ mgr_pid = vcd_client_manager_get_pid();
+ client_list = &mgr_pid;
+ client_count = 1;
+ }
+
+ if (0 == ret || mgr_pid > 0) {
+ SLOG(LOG_DEBUG, TAG_VCD, "===== Clean up %s client ", type ? (type == 1) ? "Widget" : "Manager" : "Normal");
+ if (NULL != client_list && client_count > 0) {
+ for (i = 0; i < client_count; i++) {
+ exist = false;
+ GList *iter = NULL;
+ for (j = 0; j < g_list_length(g_proc_list); j++) {
+ iter = g_list_nth(g_proc_list, j);
+ if (NULL != iter) {
+ if (client_list[i] == GPOINTER_TO_INT(iter->data)) {
+ SLOG(LOG_DEBUG, TAG_VCD, "%s pid(%d) is running", type ? (type == 1) ? "Widget" : "Manager" : "Normal", client_list[i]);
+ exist = true;
+ break;
+ }
+ }
+ }
+
+ if (false == exist) {
+ SLOG(LOG_ERROR, TAG_VCD, "%s pid(%d) should be removed", type ? (type == 1) ? "Widget" : "Manager" : "Normal", client_list[i]);
+ if (VCD_CLIENT_TYPE_NORMAL == type)
+ vcd_server_finalize(client_list[i]);
+ else if (VCD_CLIENT_TYPE_WIDGET == type)
+ vcd_server_widget_finalize(client_list[i]);
+ else
+ vcd_server_mgr_finalize(mgr_pid);
+ }
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_VCD, "=====");
+ SLOG(LOG_DEBUG, TAG_VCD, " ");
+ }
+ if (NULL != client_list && -1 == mgr_pid) {
+ free(client_list);
+ client_list = NULL;
+ }
+ return;
+}
+
+Eina_Bool vcd_cleanup_client_all(void *data)
+{
+ __read_proc();
+
+ __vcd_cleanup_client(VCD_CLIENT_TYPE_NORMAL);
+ __vcd_cleanup_client(VCD_CLIENT_TYPE_WIDGET);
+ __vcd_cleanup_client(VCD_CLIENT_TYPE_MANAGER);
+#if 0
if (0 == vcd_client_get_list(&client_list, &client_count)) {
SLOG(LOG_DEBUG, TAG_VCD, "===== Clean up client ");
if (NULL != client_list && client_count > 0) {
for (i = 0; i < client_count; i++) {
+ exist = false;
+ GList *iter = NULL;
+ for (j = 0; j < g_list_length(g_proc_list); j++) {
+ iter = g_list_nth(g_proc_list, j);
+ if (NULL != iter) {
+ if (client_list[i] == GPOINTER_TO_INT(iter->data)) {
+ SLOG(LOG_DEBUG, TAG_VCD, "pid(%d) is running", client_list[i]);
+ exist = true;
+ break;
+ }
+ }
+ }
+
+ if (false == exist) {
+ SLOG(LOG_ERROR, TAG_VCD, "pid(%d) should be removed", client_list[i]);
+ vcd_server_finalize(client_list[i]);
+ }
+#if 0
result = vcdc_send_hello(client_list[i], VCD_CLIENT_TYPE_NORMAL);
if (0 == result) {
} else if (-1 == result) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Hello result has error");
}
+#endif
}
}
SLOG(LOG_DEBUG, TAG_VCD, "=====");
free(client_list);
client_list = NULL;
}
-#endif
-#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) {
for (i = 0; i < client_count; i++) {
+ exist = false;
+ GList *iter = NULL;
+ for (j = 0; j < g_list_length(g_proc_list); j++) {
+ iter = g_list_nth(g_proc_list, j);
+ if (NULL != iter) {
+ if (client_list[i] == GPOINTER_TO_INT(iter->data)) {
+ SLOG(LOG_DEBUG, TAG_VCD, "widget pid(%d) is running", client_list[i]);
+ exist = true;
+ break;
+ }
+ }
+ }
+
+ if (false == exist) {
+ SLOG(LOG_ERROR, TAG_VCD, "widget pid(%d) should be removed", client_list[i]);
+ vcd_server_widget_finalize(client_list[i]);
+ }
+#if 0
result = vcdc_send_hello(client_list[i], VCD_CLIENT_TYPE_WIDGET);
if (0 == result) {
} else if (-1 == result) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Hello result has error");
}
+#endif
}
}
SLOG(LOG_DEBUG, TAG_VCD, "=====");
free(client_list);
client_list = NULL;
}
-#endif
/* manager */
+ exist = false;
+ GList *iter = NULL;
+ int mgr_pid = vcd_client_manager_get_pid();
+ if (0 < mgr_pid) {
+ for (j = 0; j < g_list_length(g_proc_list); j++) {
+ iter = g_list_nth(g_proc_list, j);
+ if (NULL != iter) {
+ if (mgr_pid == GPOINTER_TO_INT(iter->data)) {
+ SLOG(LOG_DEBUG, TAG_VCD, "manager pid(%d) is running", mgr_pid);
+ exist = true;
+ break;
+ }
+ }
+ }
+ if (false == exist) {
+ SLOG(LOG_ERROR, TAG_VCD, "manager pid (%d) should be removed", mgr_pid);
+ vcd_server_mgr_finalize(mgr_pid);
+ }
+ }
+#endif
return EINA_TRUE;
}
return vcd_config_get_service_state();
}
+int vcd_server_get_foreground()
+{
+ int pid;
+ vcd_config_get_foreground(&pid);
+ return pid;
+}
+
+
/*
* API for manager
*/
return VCD_ERROR_INVALID_PARAMETER;
}
+ /* Cancel recognition */
+ vcd_server_mgr_cancel();
+
/* Remove manager information */
if (0 != vcd_client_manager_unset()) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to delete client");
SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Set command");
+ bool stop_by_silence = true;
+ if (VCD_RECOGNITION_MODE_MANUAL == vcd_client_get_recognition_mode()) {
+ stop_by_silence = false;
+ }
+
/* 4. start recognition */
- ret = vcd_engine_recognize_start(true);
+ ret = vcd_engine_recognize_start(stop_by_silence);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
return VCD_ERROR_OPERATION_FAILED;
vcd_config_set_service_state(VCD_STATE_RECORDING);
vcdc_send_service_state(VCD_STATE_RECORDING);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Start recognition");
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Start recognition(%d)", stop_by_silence);
return 0;
}
return 0;
}
+int vcd_server_set_foreground(int pid, bool value)
+{
+ /* check if pid is valid */
+ if (false == vcd_client_is_available(pid) && false == vcd_client_widget_is_available(pid)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] pid is NOT valid ");
+ return VCD_ERROR_INVALID_PARAMETER;
+ }
+
+ if (0 != vcd_config_set_foreground(pid, value)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set foreground : pid(%d), value(%d)", pid, value);
+ return VCD_ERROR_OPERATION_FAILED;
+ }
+
+ return 0;
+}
+
#if 0
int vcd_server_set_exclusive_command(int pid, bool value)
{
SLOG(LOG_DEBUG, TAG_VCD, "[Server] widget command is available");
} else {
vcd_client_widget_unset_command(pid);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] widget command is NOT available");
+ SLOG(LOG_WARN, TAG_VCD, "[Server] widget command is NOT available");
}
int ret = __start_internal_recognition();
void vcd_finalize();
-Eina_Bool vcd_cleanup_client(void *data);
+Eina_Bool vcd_cleanup_client_all(void *data);
int vcd_server_get_service_state();
+int vcd_server_get_foreground();
+
/*
* For manager
int vcd_server_unset_command(int pid, vc_cmd_type_e cmd_type);
-int vcd_server_set_exclusive_command(int pid, bool value);
+int vcd_server_set_foreground(int pid, bool value);
#if 0
+int vcd_server_set_exclusive_command(int pid, bool value);
+
int vcd_server_request_start(int pid, bool stop_by_silence);
int vcd_server_request_stop(int pid);
projects / platform / core / uifw / voice-control.git / commitdiff