## Dependent packages ##
INCLUDE(FindPkgConfig)
-pkg_check_modules(pkgs REQUIRED
+pkg_check_modules(pkgs REQUIRED
aul capi-base-common capi-media-audio-io capi-media-sound-manager capi-network-bluetooth
dbus-1 dlog ecore glib-2.0 libprivilege-control libxml-2.0 vconf
)
static const char* __vc_get_error_code(vc_error_e err)
{
- switch(err) {
+ switch (err) {
case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
- before_lang, current_lang);
+ SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
+ before_lang, current_lang);
vc_current_language_changed_cb callback;
void* lang_user_data;
return;
}
-int vc_initialize()
+
+int vc_initialize(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
int ret = vc_config_mgr_initialize(g_vc->handle);
if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
- __vc_get_error_code(__vc_convert_config_error_code(ret)));
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
+ __vc_get_error_code(__vc_convert_config_error_code(ret)));
vc_client_destroy(g_vc);
return __vc_convert_config_error_code(ret);
}
return VC_ERROR_NONE;
}
-static void __vc_internal_unprepare()
+static void __vc_internal_unprepare(void)
{
/* return authority */
vc_auth_state_e state = VC_AUTH_STATE_NONE;
return;
}
-int vc_deinitialize()
+int vc_deinitialize(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
}
#if 0
-static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
-{
+static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
+{
Ecore_X_Event_Window_Focus_In *e;
e = event;
}
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);
}
}
return ECORE_CALLBACK_PASS_ON;
-}
+}
-static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
-{
+static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
+{
Ecore_X_Event_Window_Focus_In *e;
e = event;
return EINA_FALSE;
}
-int vc_prepare()
+int vc_prepare(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
return VC_ERROR_INVALID_STATE;
}
-
g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return VC_ERROR_NONE;
}
-int vc_unprepare()
+int vc_unprepare(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
*state = temp;
- switch(*state) {
+ switch (*state) {
case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'"); break;
case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'"); break;
case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'"); break;
*state = service_state;
- switch(*state) {
- case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
- case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
- case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
- case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
- default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
+ switch (*state) {
+ case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'"); break;
+ case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'"); break;
+ case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'"); break;
+ case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'"); break;
+ default: SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state"); break;
}
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return VC_ERROR_NONE;
}
-#if 0
+#if 0
int vc_set_window_id(int wid)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Window id");
*
* @pre The state should be #VC_STATE_READY.
*/
-#if 0
+#if 0
int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
#endif
int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
-{
+{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
if (NULL == vc_cmd_list) {
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
}
SLOG(LOG_DEBUG, TAG_VCC, "=====");
return ret;
}
-int vc_request_stop()
+int vc_request_stop(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
return ret;
}
-int vc_request_cancel()
+int vc_request_cancel(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
} else {
SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
- }
+ }
return EINA_FALSE;
}
callback(event, vc_cmd_list, temp_text, user_data);
vc_client_not_use_callback(g_vc);
- SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
+ SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
vc_cmd_list_destroy(vc_cmd_list, true);
return EINA_FALSE;
}
-void __vc_cb_result()
+void __vc_cb_result(void)
{
ecore_timer_add(0, __vc_notify_result, NULL);
}
vc_client_set_result_cb(g_vc, callback, user_data);
-
+
return 0;
}
-int vc_unset_result_cb()
+int vc_unset_result_cb(void)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
}
vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
-
+
return 0;
}
-int vc_unset_service_state_changed_cb()
+int vc_unset_service_state_changed_cb(void)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
return 0;
}
-int vc_unset_state_changed_cb()
+int vc_unset_state_changed_cb(void)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
return 0;
}
-int vc_unset_current_language_changed_cb()
+int vc_unset_current_language_changed_cb(void)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
return 0;
}
-int vc_unset_error_cb()
+int vc_unset_error_cb(void)
{
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
}
/* Authority */
-int vc_auth_enable()
+int vc_auth_enable(void)
{
/* check state */
vc_state_e state;
ecore_timer_add(0, __notify_auth_changed_cb, NULL);
SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
-
+
return VC_ERROR_NONE;
}
-int vc_auth_disable()
+int vc_auth_disable(void)
{
/* check state */
vc_state_e state;
*state = temp;
SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
-
+
return VC_ERROR_NONE;
}
return VC_ERROR_NONE;
}
-int vc_auth_unset_state_changed_cb()
+int vc_auth_unset_state_changed_cb(void)
{
/* check auth */
vc_auth_state_e auth_state;
return VC_ERROR_NONE;
}
-int vc_auth_start()
+int vc_auth_start(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
return ret;
}
-int vc_auth_stop()
+int vc_auth_stop(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
return ret;
}
-int vc_auth_cancel()
+int vc_auth_cancel(void)
{
SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
void* state_changed_user_data;
vc_current_language_changed_cb current_lang_changed_cb;
void* current_lang_changed_user_data;
-
+
#if 0
/* exclusive option */
bool exclusive_cmd;
void* auth_state_changed_user_data;
int mgr_pid;
-}vc_client_s;
+} vc_client_s;
/* client list */
static GSList *g_client_list = NULL;
vc_client_s *data = NULL;
int count = g_slist_length(g_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_client_list, i);
if (NULL != data) {
return VC_ERROR_OUT_OF_MEMORY;
}
- temp->handle = getpid();
+ temp->handle = getpid();
/* initialize client data */
client->vc = temp;
- client->pid = getpid();
+ client->pid = getpid();
client->uid = temp->handle;
client->xid = -1;
client->service_state = -1;
- client->before_state = VC_STATE_INITIALIZED;
- client->current_state = VC_STATE_INITIALIZED;
+ client->before_state = VC_STATE_INITIALIZED;
+ client->current_state = VC_STATE_INITIALIZED;
client->cb_ref_count = 0;
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCC, "Input parameter is NULL");
return 0;
- }
+ }
vc_client_s *data = NULL;
int count = g_slist_length(g_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_client_list, i);
if (NULL != data) {
if (vc->handle == data->vc->handle) {
g_client_list = g_slist_remove(g_client_list, data);
- while (0 != data->cb_ref_count)
- {
+ while (0 != data->cb_ref_count) {
/* wait for release callback function */
}
free(data);
vc_client_s *data = NULL;
int count = g_slist_length(g_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_client_list, i);
if (NULL != data) {
- if (uid == data->vc->handle)
+ if (uid == data->vc->handle)
return true;
}
}
int vc_client_get_handle(int uid, vc_h* vc)
{
vc_client_s *data = NULL;
-
+
int count = g_slist_length(g_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_client_list, i);
if (NULL != data) {
}
}
}
-
+
return -1;
}
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->result_cb = callback;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->result_cb;
*user_data = client->result_user_data;
- return 0;
+ return 0;
}
int vc_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->service_state_changed_cb = callback;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->service_state_changed_cb;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->state_changed_cb = callback;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->state_changed_cb;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->current_lang_changed_cb = callback;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->current_lang_changed_cb;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->error_cb = callback;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->error_cb;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->service_state = state;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*state = client->service_state;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->before_state = client->current_state;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*state = client->current_state;
vc_client_s *data = NULL;
int count = g_slist_length(g_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_client_list, i);
if (NULL != data) {
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*before_state = client->before_state;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->xid = xid;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*xid = client->xid;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->exclusive_cmd = value;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*value = client->exclusive_cmd;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->reason = reason;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*reason = client->reason;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count++;
vc_client_s* client = __client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count--;
extern "C" {
#endif
-/*
-* Common function
+/*
+* Common function
*/
int vc_client_create(vc_h* vc);
int vc_client_get_handle(int uid, vc_h* vc);
-/*
-* set/get callback function
+/*
+* set/get callback function
*/
int vc_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data);
int vc_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data);
-/*
-* set/get option
+/*
+* set/get option
*/
int vc_client_set_service_state(vc_h vc, vc_service_state_e state);
/* connect to the DBUS system bus, and check for errors */
g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
}
if (NULL == g_conn_sender) {
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);
+ SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
+ dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
return -2;
}
- if( NULL != g_fd_handler ) {
+ if (NULL != g_fd_handler) {
SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
return 0;
}
- char rule[128];
+ char rule[128] = {0, };
snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
dbus_bus_add_match(g_conn_listener, rule, &err);
dbus_connection_flush(g_conn_listener);
- if (dbus_error_is_set(&err))
- {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
dbus_error_free(&err);
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
}
int fd = 0;
SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
}
+
return 0;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_HELLO);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_HELLO);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
- }
+ }
DBusError err;
dbus_error_init(&err);
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_INITIALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_INITIALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
DBUS_TYPE_INT32, &tmp,
DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_FINALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_FINALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
}
if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(result_msg, &err,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_SET_EXCLUSIVE_CMD);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_SET_EXCLUSIVE_CMD);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
int temp = value;
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &temp,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &temp,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_SET_COMMAND);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_SET_COMMAND);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &cmd_type,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &cmd_type,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
result = VC_ERROR_TIMED_OUT;
}
- return result;
+ return result;
}
int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_UNSET_COMMAND);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_UNSET_COMMAND);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &cmd_type,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &cmd_type,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_REQUEST_START);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_REQUEST_START);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_REQUEST_STOP);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_REQUEST_STOP);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
- VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
- VC_METHOD_REQUEST_CANCEL); /* name of the signal */
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
+ VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
+ VC_METHOD_REQUEST_CANCEL); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- service_name,
- object_path, /* object name of the signal */
- target_if_name, /* interface name of the signal */
- VC_METHOD_AUTH_ENABLE); /* name of the signal */
+ service_name,
+ object_path, /* object name of the signal */
+ target_if_name, /* interface name of the signal */
+ VC_METHOD_AUTH_ENABLE); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- service_name,
- object_path, /* object name of the signal */
- target_if_name, /* interface name of the signal */
- VC_METHOD_AUTH_DISABLE); /* name of the signal */
+ service_name,
+ object_path, /* object name of the signal */
+ target_if_name, /* interface name of the signal */
+ VC_METHOD_AUTH_DISABLE); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- service_name,
- object_path,
- target_if_name,
- VC_METHOD_AUTH_START);
+ service_name,
+ object_path,
+ target_if_name,
+ VC_METHOD_AUTH_START);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
/* Append result*/
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
-
+
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- service_name,
- object_path,
- target_if_name,
- VC_METHOD_AUTH_STOP);
+ service_name,
+ object_path,
+ target_if_name,
+ VC_METHOD_AUTH_STOP);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- service_name,
- object_path, /* object name of the signal */
- target_if_name, /* interface name of the signal */
- VC_METHOD_AUTH_CANCEL); /* name of the signal */
+ service_name,
+ object_path, /* object name of the signal */
+ target_if_name, /* interface name of the signal */
+ VC_METHOD_AUTH_CANCEL); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
* limitations under the License.
*/
-
+
#ifndef __VC_DBUS_H_
#define __VC_DBUS_H_
static const char* __vc_mgr_get_error_code(vc_error_e err)
{
- switch(err) {
+ switch (err) {
case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
static void __vc_mgr_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
- before_lang, current_lang);
+ SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
+ before_lang, current_lang);
vc_current_language_changed_cb callback = NULL;
void* lang_user_data;
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
}
-
vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
return VC_ERROR_INVALID_STATE;
}
-
g_m_connect_timer = ecore_timer_add(0, __vc_mgr_connect_daemon, NULL);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
*state = temp;
- switch(*state) {
+ switch (*state) {
case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'None'"); break;
case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Created'"); break;
case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Ready'"); break;
*state = service_state;
- switch(*state) {
+ switch (*state) {
case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'"); break;
case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'"); break;
case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'"); break;
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
-
+
return 0;
/*
}
int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
-{
+{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list");
vc_state_e state;
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
return 0;
}
-
+
if (VC_NO_FOREGROUND_PID != fg_pid) {
iter = g_slist_nth(client_info_list, 0);
while (NULL != iter) {
ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
- }
+ }
}
free(client_info);
}
char* result_text = NULL;
vc_mgr_client_get_all_result(g_vc_m, &event, &result_text);
-
+
vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false);
if (NULL != result_text) {
result_text = NULL;
}
}
-
+
int ret;
int count = 0;
vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data);
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set all result callback");
-
+
return 0;
}
}
vc_mgr_client_set_result_cb(g_vc_m, callback, user_data);
-
+
return 0;
}
SLOG(LOG_DEBUG, TAG_VCM, "Error callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
- }
+ }
return EINA_FALSE;
}
if (pid == fore_pid) {
vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
}
-
+
return 0;
}
/* add timer for start recording */
ecore_timer_add(0, __request_auth_start, NULL);
-
+
return 0;
}
void* speech_detected_user_data;
vc_current_language_changed_cb current_lang_changed_cb;
void* current_lang_changed_user_data;
-
+
/* All result */
vc_result_event_e all_result_event;
char* all_result_text;
GSList* authorized_client_list;
int valid_authorized_pid;
bool start_by_client;
-}vc_mgr_client_s;
+} vc_mgr_client_s;
typedef struct {
int pid;
-}vc_authorized_client_s;
+} vc_authorized_client_s;
static GSList *g_mgr_client_list = NULL;
vc_mgr_client_s *data = NULL;
int count = g_slist_length(g_mgr_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_mgr_client_list, i);
if (NULL != data) {
return VC_ERROR_OUT_OF_MEMORY;
}
- temp->handle = getpid();
+ temp->handle = getpid();
/* initialize client data */
client->vc = temp;
- client->pid = getpid();
+ client->pid = getpid();
client->uid = temp->handle;
client->all_result_cb = NULL;
client->service_state = -1;
client->before_state = VC_STATE_INITIALIZED;
- client->current_state = VC_STATE_INITIALIZED;
+ client->current_state = VC_STATE_INITIALIZED;
client->before_language = NULL;
client->current_language = NULL;
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCM, "Input parameter is NULL");
return 0;
- }
+ }
vc_mgr_client_s *data = NULL;
int count = g_slist_length(g_mgr_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_mgr_client_list, i);
if (NULL != data) {
if (vc->handle == data->vc->handle) {
g_mgr_client_list = g_slist_remove(g_mgr_client_list, data);
- while (0 != data->cb_ref_count)
- {
+ while (0 != data->cb_ref_count) {
/* wait for release callback function */
}
free(data->all_result_text);
}
- free(data); data = NULL;
- free(vc); vc = NULL;
+ free(data);
+ free(vc);
+
+ data = NULL;
+ vc = NULL;
return 0;
}
vc_mgr_client_s *data = NULL;
int count = g_slist_length(g_mgr_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_mgr_client_list, i);
if (NULL != data) {
- if (uid == data->vc->handle)
+ if (uid == data->vc->handle)
return true;
}
}
int vc_mgr_client_get_handle(int uid, vc_h* vc)
{
vc_mgr_client_s *data = NULL;
-
+
int count = g_slist_length(g_mgr_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_mgr_client_list, i);
if (NULL != data) {
}
}
}
-
+
return -1;
}
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->all_result_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->all_result_cb;
*user_data = client->all_result_user_data;
- return 0;
+ return 0;
}
int vc_mgr_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data)
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->result_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->result_cb;
*user_data = client->result_user_data;
- return 0;
+ return 0;
}
int vc_mgr_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->service_state_changed_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->service_state_changed_cb;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->state_changed_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->state_changed_cb;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->current_lang_changed_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->current_lang_changed_cb;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->error_cb = callback;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*callback = client->error_cb;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->service_state = state;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*state = client->service_state;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->before_state = client->current_state;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*state = client->current_state;
vc_mgr_client_s *data = NULL;
int count = g_slist_length(g_mgr_client_list);
- int i;
+ int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_mgr_client_list, i);
if (NULL != data) {
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*before_state = client->before_state;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->reason = reason;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*reason = client->reason;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->exclusive_cmd_option = value;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
return client->exclusive_cmd_option;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->all_result_event = event;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
*event = client->all_result_event;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->all_result_event = -1;
free(client->all_result_text);
client->all_result_text = NULL;
}
-
+
return 0;
}
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
if (NULL != audio_id) {
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
if (NULL != client->audio_id)
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count++;
vc_mgr_client_s* client = __mgr_client_get(vc);
/* check handle */
- if (NULL == client)
+ if (NULL == client)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count--;
extern "C" {
#endif
-/*
-* Common function
+/*
+* Common function
*/
int vc_mgr_client_create(vc_h* vc);
int vc_mgr_client_get_pid(vc_h vc, int* pid);
-/*
-* set/get callback function
+/*
+* set/get callback function
*/
int vc_mgr_client_set_all_result_cb(vc_h vc, vc_mgr_all_result_cb callback, void* user_data);
int vc_mgr_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data);
-/*
-* set/get option
+/*
+* set/get option
*/
int vc_mgr_client_set_service_state(vc_h vc, vc_service_state_e state);
/* connect to the DBUS system bus, and check for errors */
g_m_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
- if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
- dbus_error_free(&err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
+ dbus_error_free(&err);
}
if (NULL == g_m_conn_listener) {
SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
}
int pid = getpid();
ret = dbus_bus_request_name(g_m_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
- dbus_error_free(&err);
+ SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
+ dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
return 0;
}
- char rule[128];
+ char rule[128] = {0, };
snprintf(rule, 128, "type='signal',interface='%s'", VC_MANAGER_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
dbus_bus_add_match(g_m_conn_listener, rule, &err);
dbus_connection_flush(g_m_conn_listener);
- if (dbus_error_is_set(&err))
- {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
dbus_error_free(&err);
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
}
int fd = 0;
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_HELLO);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_HELLO);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> Request vc hello : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> Request vc hello : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
- }
+ }
DBusError err;
dbus_error_init(&err);
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_INITIALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_INITIALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr initialize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr initialize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr initialize : pid(%d)", pid);
}
- dbus_message_append_args( msg,
+ dbus_message_append_args(msg,
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
DBUS_TYPE_INT32, &result,
DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_FINALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_FINALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr finalize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr finalize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr finalize : pid(%d)", pid);
}
if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(result_msg, &err,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_SET_COMMAND);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_SET_COMMAND);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set command : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set command : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
result = VC_ERROR_TIMED_OUT;
}
- return result;
+ return result;
}
int vc_mgr_dbus_request_unset_command(int pid)
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_UNSET_COMMAND);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_UNSET_COMMAND);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr unset command : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr unset command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr unset command : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_SET_DEMANDABLE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_SET_DEMANDABLE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set demandable client : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set demandable client : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set demandable client : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_SET_AUDIO_TYPE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_SET_AUDIO_TYPE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set audio type : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set audio type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &(audio_type),
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_STRING, &(audio_type),
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_GET_AUDIO_TYPE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_GET_AUDIO_TYPE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get audio type : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get audio type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get audio type : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_STRING, &temp,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_STRING, &temp,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_SET_CLIENT_INFO);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_SET_CLIENT_INFO);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set client info : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set client info : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set client info : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_START);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_START);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr start : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr start : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr start : pid(%d), silence(%d) exclusive(%d) start by client(%d)",
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_MANAGER_METHOD_STOP);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_STOP);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr stop : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr stop : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr stop : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
- VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
- VC_MANAGER_METHOD_CANCEL); /* name of the signal */
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
+ VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
+ VC_MANAGER_METHOD_CANCEL); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc cancel : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc cancel : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc cancel : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
memset(service_name, '\0', 64);
memset(object_path, '\0', 64);
memset(target_if_name, '\0', 128);
-
+
if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
switch (cmd_type) {
case VC_COMMAND_TYPE_FOREGROUND:
- case VC_COMMAND_TYPE_BACKGROUND:
+ case VC_COMMAND_TYPE_BACKGROUND:
msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type);
break;
case VC_COMMAND_TYPE_WIDGET:
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
- VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
- VC_MANAGER_METHOD_RESULT_SELECTION); /* name of the signal */
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
+ VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
+ VC_MANAGER_METHOD_RESULT_SELECTION); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCM, ">>>> vc result selection : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, ">>>> vc result selection : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc result selection : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
dbus_message_set_no_reply(msg, TRUE);
* limitations under the License.
*/
-
+
#ifndef __VC_DBUS_H_
#define __VC_DBUS_H_
#include "voice_control_common.h"
#include "voice_control_setting.h"
-/**
+/**
* @brief Enumerations of mode.
*/
typedef enum {
VC_SETTING_STATE_NONE = 0,
VC_SETTING_STATE_READY
-}vc_setting_state_e;
+} vc_setting_state_e;
#define VC_SETTING_CONFIG_HANDLE 300000
void __vc_setting_state_changed_cb(int before_state, int current_state, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCS, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
+ SLOG(LOG_DEBUG, TAG_VCS, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
return;
}
SLOG(LOG_DEBUG, TAG_VCS, " ");
return VC_ERROR_OPERATION_FAILED;
}
-
+
ret = vc_config_mgr_set_lang_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __config_lang_changed_cb);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Fail to initialize config manager");
}
ret = vc_config_mgr_set_enabled_cb(getpid() + VC_SETTING_CONFIG_HANDLE, __vc_setting_enabled_changed_cb);
-
+
g_state = VC_SETTING_STATE_READY;
SLOG(LOG_DEBUG, TAG_VCS, "=====");
vc_config_mgr_finalize(getpid() + VC_SETTING_CONFIG_HANDLE);
g_state = VC_SETTING_STATE_NONE;
-
+
SLOG(LOG_DEBUG, TAG_VCS, "=====");
SLOG(LOG_DEBUG, TAG_VCS, " ");
SLOG(LOG_DEBUG, TAG_VCS, "=====");
SLOG(LOG_DEBUG, TAG_VCS, " ");
-
+
return ret;
}
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCS, "[ERROR] Result : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get auto language (%s)", *value ? "true":"false");
+ SLOG(LOG_DEBUG, TAG_VCS, "[SUCCESS] Get auto language (%s)", *value ? "true" : "false");
}
SLOG(LOG_DEBUG, TAG_VCS, "=====");
static const char* __vc_widget_get_error_code(vc_error_e err)
{
- switch(err) {
+ switch (err) {
case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
static void __vc_widget_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCW, "Lang changed : Before lang(%s) Current lang(%s)",
- before_lang, current_lang);
+ SLOG(LOG_DEBUG, TAG_VCW, "Lang changed : Before lang(%s) Current lang(%s)",
+ before_lang, current_lang);
vc_current_language_changed_cb callback;
void* lang_user_data;
int ret = vc_config_mgr_initialize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to init config manager : %s",
- __vc_widget_get_error_code(__vc_widget_convert_config_error_code(ret)));
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to init config manager : %s",
+ __vc_widget_get_error_code(__vc_widget_convert_config_error_code(ret)));
vc_widget_client_destroy(g_vc_w);
return __vc_widget_convert_config_error_code(ret);
}
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return EINA_FALSE;
- }
+ }
vc_widget_client_set_state(g_vc_w, VC_STATE_READY);
ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
ret = vc_config_convert_error_code((vc_config_error_e)ret);
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get languages : %s", __vc_widget_get_error_code(ret));
}
-
+
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
*state = temp;
- switch(*state) {
+ switch (*state) {
case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'None'"); break;
case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Created'"); break;
case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCW, "Current state is 'Ready'"); break;
*state = service_state;
- switch(*state) {
- case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'None'"); break;
- case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Ready'"); break;
- case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Recording'"); break;
- case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Processing'"); break;
- default: SLOG(LOG_ERROR, TAG_VCW, "Invalid service state"); break;
+ switch (*state) {
+ case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'None'"); break;
+ case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Ready'"); break;
+ case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Recording'"); break;
+ case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCW, "Current service state is 'Processing'"); break;
+ default: SLOG(LOG_ERROR, TAG_VCW, "Invalid service state"); break;
}
SLOG(LOG_DEBUG, TAG_VCW, "=====");
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
}
SLOG(LOG_DEBUG, TAG_VCW, "=====");
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
return 0;
}
}
}
}
- } while(0 != ret);
+ } while (0 != ret);
+
+ SLOG(LOG_DEBUG, TAG_VCW, "=====");
return 0;
}
SLOG(LOG_DEBUG, TAG_VCW, "[Error] callback is called");
} else {
SLOG(LOG_WARN, TAG_VCW, "[WARNING] Error callback is null");
- }
+ }
return EINA_FALSE;
}
}
vc_widget_client_set_result_cb(g_vc_w, callback, user_data);
-
+
return 0;
}
/* error data */
int reason;
-}vc_widget_s;
+} vc_widget_s;
/* widget list */
int count = g_slist_length(g_widget_list);
int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_widget_list, i);
if (NULL != data) {
return VC_ERROR_OUT_OF_MEMORY;
}
- temp->handle = getpid();
+ temp->handle = getpid();
/* initialize widget data */
widget->vc = temp;
- widget->pid = getpid();
+ widget->pid = getpid();
widget->uid = temp->handle;
widget->xid = -1;
widget->error_cb = NULL;
widget->error_user_data = NULL;
- widget->before_state = VC_STATE_INITIALIZED;
- widget->current_state = VC_STATE_INITIALIZED;
+ widget->before_state = VC_STATE_INITIALIZED;
+ widget->current_state = VC_STATE_INITIALIZED;
widget->cb_ref_count = 0;
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCW, "Input parameter is NULL");
return 0;
- }
+ }
vc_widget_s *data = NULL;
int count = g_slist_length(g_widget_list);
int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_widget_list, i);
if (NULL != data) {
if (vc->handle == data->vc->handle) {
g_widget_list = g_slist_remove(g_widget_list, data);
- while (0 != data->cb_ref_count)
- {
+ while (0 != data->cb_ref_count) {
/* wait for release callback function */
}
free(data);
int count = g_slist_length(g_widget_list);
int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_widget_list, i);
if (NULL != data) {
- if (uid == data->vc->handle)
+ if (uid == data->vc->handle)
return true;
}
}
int count = g_slist_length(g_widget_list);
int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_widget_list, i);
if (NULL != data) {
}
}
}
-
+
return -1;
}
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->result_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->result_cb;
*user_data = widget->result_user_data;
- return 0;
+ return 0;
}
int vc_widget_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->service_state_changed_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->service_state_changed_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->state_changed_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->state_changed_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->show_tooltip_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->show_tooltip_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->current_lang_changed_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->current_lang_changed_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->error_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->error_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->send_command_list_cb = callback;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*callback = widget->send_command_list_cb;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->service_state = state;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*state = widget->service_state;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->before_state = widget->current_state;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*state = widget->current_state;
int count = g_slist_length(g_widget_list);
int i;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = g_slist_nth_data(g_widget_list, i);
if (NULL != data) {
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*before_state = widget->before_state;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->xid = xid;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*xid = widget->xid;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->reason = reason;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*reason = widget->reason;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->show_tooltip = show;
-
+
return 0;
}
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
*show = widget->show_tooltip;
-
+
return 0;
}
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->cb_ref_count++;
vc_widget_s* widget = __widget_get(vc);
/* check handle */
- if (NULL == widget)
+ if (NULL == widget)
return VC_ERROR_INVALID_PARAMETER;
widget->cb_ref_count--;
extern "C" {
#endif
-/*
-* Common function
+/*
+* Common function
*/
int vc_widget_client_create(vc_h* vc);
int vc_widget_client_get_handle(int uid, vc_h* vc);
-/*
-* set/get callback function
+/*
+* set/get callback function
*/
int vc_widget_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data);
-/*
-* set/get option
+/*
+* set/get option
*/
int vc_widget_client_set_service_state(vc_h vc, vc_service_state_e state);
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);
+ SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
+ dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
return -2;
}
- if( NULL != g_w_fd_handler ) {
+ if (NULL != g_w_fd_handler) {
SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
return 0;
}
- char rule[128];
+ char rule[128] = {0, };
snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
/* add a rule for which messages we want to see */
dbus_bus_add_match(g_w_conn_listener, rule, &err);
dbus_connection_flush(g_w_conn_listener);
- if (dbus_error_is_set(&err))
- {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
dbus_error_free(&err);
- return VC_ERROR_OPERATION_FAILED;
+ return VC_ERROR_OPERATION_FAILED;
}
int fd = 0;
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_METHOD_HELLO);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_METHOD_HELLO);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> Request vc hello : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> Request vc hello : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
- }
+ }
DBusError err;
dbus_error_init(&err);
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_WIDGET_METHOD_INITIALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_WIDGET_METHOD_INITIALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget initialize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget initialize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget initialize : pid(%d)", pid);
}
- dbus_message_append_args( msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
}
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_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_WIDGET_METHOD_FINALIZE);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_WIDGET_METHOD_FINALIZE);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget finalize : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget finalize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget finalize : pid(%d)", pid);
}
if (NULL != result_msg) {
- dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(result_msg, &err,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
DBusMessage* msg;
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_WIDGET_METHOD_START_RECORDING);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_WIDGET_METHOD_START_RECORDING);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start recording : Fail to make message");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start recording : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start recording : pid(%d)", pid);
int temp = (int)command;
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &temp,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &temp,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_WIDGET_METHOD_START);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_WIDGET_METHOD_START);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start : pid(%d), silence(%d)", pid, silence);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH,
- VC_SERVER_SERVICE_INTERFACE,
- VC_WIDGET_METHOD_STOP);
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_WIDGET_METHOD_STOP);
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget stop : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget stop : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget stop : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
/* create a signal & check for errors */
msg = dbus_message_new_method_call(
- VC_SERVER_SERVICE_NAME,
- VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
- VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
- VC_WIDGET_METHOD_CANCEL); /* name of the signal */
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
+ VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
+ VC_WIDGET_METHOD_CANCEL); /* name of the signal */
- if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget cancel : Fail to make message ");
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget cancel : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget cancel : pid(%d)", pid);
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err,
- DBUS_TYPE_INT32, &result,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
- dbus_error_free(&err);
+ dbus_error_free(&err);
result = VC_ERROR_OPERATION_FAILED;
}
dbus_message_unref(result_msg);
* limitations under the License.
*/
-
+
#ifndef __VC_WIDGET_DBUS_H_
#define __VC_WIDGET_DBUS_H_
list = (vc_cmd_list_s*)vc_cmd_list;
SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
- , list, release_command ? "true" : "false");
+ , list, release_command ? "true" : "false");
int count = g_slist_length(list->list);
int i ;
vc_cmd_s *temp_cmd;
- for (i = 0;i < count ;i++) {
+ for (i = 0; i < count ; i++) {
temp_cmd = g_slist_nth_data(list->list, 0);
if (NULL != temp_cmd) {
free(temp_cmd);
temp_cmd = NULL;
}
- }
+ }
}
list->index = -1;
iter = g_slist_nth(list->list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
temp_cmd = iter->data;
if (NULL != temp_cmd) {
break;
}
- }
+ }
iter = g_slist_next(iter);
}
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
}
- return 0;
+ return 0;
}
int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
int i;
vc_cmd_s *temp_cmd = NULL;
- for (i = 0;i < count ;i++) {
+ for (i = 0; i < count ; i++) {
temp_cmd = g_slist_nth_data(list->list, i);
if (NULL != temp_cmd) {
- SLOG(LOG_DEBUG, TAG_VCCMD, " [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
- i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
- }
+ SLOG(LOG_DEBUG, TAG_VCCMD, " [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
+ i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
+ }
}
SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
extern "C" {
#endif
-typedef struct _command_s{
+typedef struct _command_s {
int pid;
int id;
int index;
/* not used */
int key;
int modifier;
-}vc_cmd_s;
+} vc_cmd_s;
typedef struct {
int index;
GSList* list;
-}vc_cmd_list_s;
+} vc_cmd_list_s;
/**
* @brief Enumerations of command type.
VC_COMMAND_TYPE_WIDGET = 3, /**< Widget command by widget client */
VC_COMMAND_TYPE_SYSTEM = 4, /**< System command by manager client */
VC_COMMAND_TYPE_EXCLUSIVE = 5 /**< exclusive command by manager client */
-}vc_cmd_type_e;
+} vc_cmd_type_e;
int vc_cmd_set_id(vc_cmd_h vc_command, int id);
vc_config_foreground_changed_cb foreground_cb;
vc_config_state_changed_cb state_cb;
vc_config_enabled_cb enabled_cb;
-}vc_config_client_s;
+} vc_config_client_s;
const char* vc_config_tag()
free(g_config_info->engine_id);
g_config_info->engine_id = strdup(engine_info->uuid);
-
+
SLOG(LOG_DEBUG, vc_config_tag(), "Default engine is changed : %s", g_config_info->engine_id);
if (0 != vc_parser_set_engine(g_config_info->engine_id)) {
SLOG(LOG_ERROR, vc_config_tag(), " Fail to save config");
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
- int i = 1;
+ int i = 1;
while (NULL != iter_lang) {
/*Get handle data from list*/
engine_lang = iter_lang->data;
iter = g_slist_next(iter);
continue;
}
-
+
GSList *iter_lang = NULL;
char* engine_lang = NULL;
if (g_slist_length(engine_info->languages) > 0) {
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
-
+
while (NULL != iter_lang) {
engine_lang = iter_lang->data;
if (NULL != engine_lang) {
free(g_config_info->language);
g_config_info->language = strdup(candidate_lang);
- SLOG(LOG_DEBUG, vc_config_tag(), "[Config] Default language change : before(%s) current(%s)",
- before_lang, g_config_info->language);
+ SLOG(LOG_DEBUG, vc_config_tag(), "[Config] Default language change : before(%s) current(%s)",
+ before_lang, g_config_info->language);
/* Call all callbacks of client*/
GSList *iter = NULL;
}
free(tmp_language);
- SLOG(LOG_DEBUG, vc_config_tag(), "[Config] Default language change : before(%s) current(%s)",
- before_lang, g_config_info->language);
+ SLOG(LOG_DEBUG, vc_config_tag(), "[Config] Default language change : before(%s) current(%s)",
+ before_lang, g_config_info->language);
/* Call all callbacks of client*/
GSList *iter = NULL;
}
temp_client->uid = uid;
-
+
/* Add uid */
g_config_client_list = g_slist_append(g_config_client_list, temp_client);
}
temp_client->uid = uid;
-
+
SLOG(LOG_DEBUG, vc_config_tag(), "uid(%d) temp_uid(%d)", uid, temp_client->uid);
/* Add uid */
}
int vc_config_mgr_unset_lang_cb(int uid)
-{
+{
GSList *iter = NULL;
vc_config_client_s* temp_client = NULL;
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);
+ 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;
}
SLOG(LOG_ERROR, vc_config_tag(), "Not initialized");
return -1;
}
-
+
if (0 >= g_slist_length(g_engine_list)) {
SLOG(LOG_ERROR, vc_config_tag(), "There is no engine");
return -1;
GSList *iter_lang = NULL;
char* lang;
-
+
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
if (false == callback(lang, user_data))
break;
}
-
+
/*Get next item*/
iter_lang = g_slist_next(iter_lang);
}
return false;
}
- if (0 >= g_slist_length(g_engine_list))
+ if (0 >= g_slist_length(g_engine_list))
return false;
GSList *iter = NULL;
return false;
}
- if (0 >= g_slist_length(g_engine_list))
+ if (0 >= g_slist_length(g_engine_list))
return false;
GSList *iter = NULL;
iter = g_slist_next(iter);
continue;
}
-
+
if (0 == strcmp(g_config_info->engine_id, engine_info->uuid)) {
iter = g_slist_next(iter);
continue;
while (NULL != iter_lang) {
lang = iter_lang->data;
-
+
if (0 == strcmp(language, lang))
return true;
SLOG(LOG_DEBUG, vc_config_tag(), "--------------- engine list -----------------");
- int i = 1;
+ int i = 1;
while (NULL != iter) {
engine_info = iter->data;
SLOG(LOG_DEBUG, vc_config_tag(), "[%dth]", i);
SLOG(LOG_DEBUG, vc_config_tag(), " name : %s", engine_info->name);
SLOG(LOG_DEBUG, vc_config_tag(), " id : %s", engine_info->uuid);
-
+
SLOG(LOG_DEBUG, vc_config_tag(), " languages");
GSList *iter_lang = NULL;
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
- int j = 1;
+ int j = 1;
while (NULL != iter_lang) {
/*Get handle data from list*/
lang = iter_lang->data;
SLOG(LOG_DEBUG, vc_config_tag(), "--------------- Client list -----------------");
- int i = 1;
+ int i = 1;
while (NULL != iter) {
temp_client = iter->data;
SLOG(LOG_DEBUG, vc_config_tag(), "[%dth] uid(%d)", i, temp_client->uid);
-
+
iter = g_slist_next(iter);
i++;
}
* limitations under the License.
*/
-
+
#ifndef __VC_CONFIG_MANAGER_H_
#define __VC_CONFIG_MANAGER_H_
VC_CONFIG_ERROR_INVALID_LANGUAGE = TIZEN_ERROR_VOICE_CONTROL | 0x012, /**< Invalid voice */
VC_CONFIG_ERROR_ENGINE_NOT_FOUND = TIZEN_ERROR_VOICE_CONTROL | 0x013, /**< No available VC-engine */
VC_CONFIG_ERROR_OPERATION_FAILED = TIZEN_ERROR_VOICE_CONTROL | 0x014 /**< Operation failed */
-}vc_config_error_e;
+} vc_config_error_e;
typedef void (*vc_config_lang_changed_cb)(const char* before_lang, const char* current_lang);
if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_ENGINE_NAME)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- // SLOG(LOG_DEBUG, vc_config_tag(), "Engine name : %s", (char *)key);
+ /* SLOG(LOG_DEBUG, vc_config_tag(), "Engine name : %s", (char *)key); */
if (NULL != temp->name) free(temp->name);
temp->name = strdup((char*)key);
xmlFree(key);
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_ENGINE_ID)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- // SLOG(LOG_DEBUG, vc_config_tag(), "Engine uuid : %s", (char *)key);
+ /* SLOG(LOG_DEBUG, vc_config_tag(), "Engine uuid : %s", (char *)key); */
if (NULL != temp->uuid) free(temp->uuid);
temp->uuid = strdup((char*)key);
xmlFree(key);
lang_node = cur->xmlChildrenNode;
while (lang_node != NULL) {
- if (0 == xmlStrcmp(lang_node->name, (const xmlChar *)VC_TAG_ENGINE_LANGUAGE)){
+ if (0 == xmlStrcmp(lang_node->name, (const xmlChar *)VC_TAG_ENGINE_LANGUAGE)) {
key = xmlNodeGetContent(lang_node);
if (NULL != key) {
- // SLOG(LOG_DEBUG, vc_config_tag(), "language : %s", (char *)key);
+ /* SLOG(LOG_DEBUG, vc_config_tag(), "language : %s", (char *)key); */
temp_lang = strdup((char*)key);
temp->languages = g_slist_append(temp->languages, temp_lang);
xmlFree(key);
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_ENGINE_NON_FIXED_SUPPORT)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- // SLOG(LOG_DEBUG, vc_config_tag(), "Engine uuid : %s", (char *)key);
+ /* SLOG(LOG_DEBUG, vc_config_tag(), "Engine uuid : %s", (char *)key); */
if (0 == xmlStrcmp(key, (const xmlChar *)"true")) {
temp->non_fixed_support = true;
int i ;
char *temp_lang;
- for (i = 0;i < count ;i++) {
+ for (i = 0; i < count ; i++) {
temp_lang = g_slist_nth_data(engine_info->languages, 0);
if (NULL != temp_lang) {
if (NULL != temp_lang)
free(temp_lang);
- }
+ }
}
if (NULL != engine_info) free(engine_info);
- return 0;
+ return 0;
}
int vc_parser_print_engine_info(vc_engine_info_s* engine_info)
SLOG(LOG_DEBUG, vc_config_tag(), "== engine info ==");
SLOG(LOG_DEBUG, vc_config_tag(), " id : %s", engine_info->uuid);
-
+
SLOG(LOG_DEBUG, vc_config_tag(), " languages");
GSList *iter = NULL;
char* lang;
/* Get a first item */
iter = g_slist_nth(engine_info->languages, 0);
- int i = 1;
+ int i = 1;
while (NULL != iter) {
/*Get handle data from list*/
lang = iter->data;
if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_CONFIG_ENGINE_ID)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_config_tag(), "Engine id : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_config_tag(), "Engine id : %s", (char *)key); */
if (NULL != temp->engine_id) free(temp->engine_id);
temp->engine_id = strdup((char*)key);
xmlFree(key);
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_CONFIG_LANGUAGE)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_config_tag(), "language : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_config_tag(), "language : %s", (char *)key); */
if (NULL != temp->language) free(temp->language);
temp->language = strdup((char*)key);
xmlFree(key);
} else if (0 == xmlStrcmp(cur->name, (const xmlChar*)VC_TAG_CONFIG_ENABLED)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_config_tag(), "Enabled service : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_config_tag(), "Enabled service : %s", (char *)key); */
if (0 == xmlStrcmp(key, (const xmlChar *)"on")) {
temp->enabled = true;
- }
- else if (0 == xmlStrcmp(key, (const xmlChar *)"off")) {
+ } else if (0 == xmlStrcmp(key, (const xmlChar *)"off")) {
temp->enabled = false;
- }
- else {
+ } else {
SLOG(LOG_ERROR, vc_config_tag(), "Enabled service is wrong");
temp->enabled = false;
}
while (cur != NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_CONFIG_LANGUAGE)) {
xmlNodeSetContent(cur, (const xmlChar *)language);
- }
+ }
cur = cur->next;
}
*language = NULL;
while (cur_new != NULL && cur_old != NULL) {
- // SLOG(LOG_DEBUG, vc_config_tag(), "cur_new->name(%s), cur_old->name(%s)", (char*)cur_new->name, (char*)cur_old->name);
+ /* SLOG(LOG_DEBUG, vc_config_tag(), "cur_new->name(%s), cur_old->name(%s)", (char*)cur_new->name, (char*)cur_old->name); */
if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)VC_TAG_CONFIG_AUTO_LANGUAGE)) {
if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)VC_TAG_CONFIG_AUTO_LANGUAGE)) {
cur_new = cur_new->next;
cur_old = cur_old->next;
}
-
+
xmlFreeDoc(g_config_doc);
g_config_doc = doc;
}
while (cur != NULL) {
- if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_INFO_FOREGROUND)) {
+ if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_INFO_FOREGROUND)) {
char temp[16];
memset(temp, 0, 16);
if (true == value) {
xmlNodeSetContent(cur, (const xmlChar *)temp);
break;
- }
+ }
cur = cur->next;
}
doc->charset = 1;
root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_BASE_TAG);
- xmlDocSetRootElement(doc,root_node);
+ xmlDocSetRootElement(doc, root_node);
/* Make new command node */
info_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_INFO_FOREGROUND);
* limitations under the License.
*/
-
+
#ifndef __VC_CONFIG_PARSER_H_
#define __VC_CONFIG_PARSER_H_
char* uuid;
GSList* languages;
bool non_fixed_support;
-}vc_engine_info_s;
+} vc_engine_info_s;
typedef struct {
char* engine_id;
bool auto_lang;
char* language;
bool enabled;
-}vc_config_s;
+} vc_config_s;
/* Get engine information */
extern "C" {
#endif
+
/******************************************************************************************
* Definition for Dbus
*******************************************************************************************/
/******************************************************************************************
-* Message Definition for all
+* Message Definition for all
*******************************************************************************************/
#define VC_METHOD_HELLO "vc_method_hello"
#define VC_BASE_LANGUAGE "en_US"
-#define VC_RETRY_COUNT 5
+#define VC_RETRY_COUNT 5
+
#define VC_CONFIG_ROOT tzplatform_mkpath(TZ_USER_HOME, ".voice")
doc->encoding = (const xmlChar*)"utf-8";
doc->charset = 1;
- root_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_BASE_TAG);
- xmlDocSetRootElement(doc,root_node);
+ root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_BASE_TAG);
+ xmlDocSetRootElement(doc, root_node);
GSList *iter = NULL;
vc_cmd_s *temp_cmd;
iter = g_slist_nth(cmd_list, 0);
SLOG(LOG_DEBUG, vc_info_tag(), "list count : %d", count);
- char temp[16];
+ char temp[16] = {0, };
int selected_count = 0;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
temp_cmd = iter->data;
if (NULL == temp_cmd) {
}
if (type == temp_cmd->type) {
- SLOG(LOG_DEBUG, vc_info_tag(), "[%dth] type(%d) format(%d) domain(%d) cmd(%s) param(%s)",
- i, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
+ SLOG(LOG_DEBUG, vc_info_tag(), "[%dth] type(%d) format(%d) domain(%d) cmd(%s) param(%s)",
+ i, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
/* Make new command node */
- cmd_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_COMMAND);
+ cmd_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_COMMAND);
/* ID */
memset(temp, 0, 16);
snprintf(temp, 16, "%d", i);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_ID);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_ID);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
/* PID */
memset(temp, 0, 16);
snprintf(temp, 16, "%d", getpid());
-
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_PID);
+
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_PID);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
-
+
/* TYPE */
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->type);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_TYPE);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_TYPE);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->format);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_FORMAT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_FORMAT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->domain);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_DOMAIN);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_DOMAIN);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
/* COMMAND */
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_COMMAND_TEXT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_COMMAND_TEXT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp_cmd->command);
xmlAddChild(cmd_node, tmp_node);
/* PARAMETER */
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_PARAMETER_TEXT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_PARAMETER_TEXT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp_cmd->parameter);
xmlAddChild(cmd_node, tmp_node);
free(filepath);
} else {
free(filepath);
-
+
SLOG(LOG_DEBUG, vc_info_tag(), "No command");
return -1;
}
vc_cmd_s* temp_cmd;
temp_cmd = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
-
+
if (NULL == temp_cmd) {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
return -1;
command_node = command_node->next;
command_node = command_node->next;
-
+
/* PID */
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_PID)) {
key = xmlNodeGetContent(command_node);
break;
}
}
-
+
command_node = command_node->next;
command_node = command_node->next;
xmlFreeDoc(doc);
*cmd_list = temp_cmd_list;
-
+
__vc_cmd_parser_print_commands(temp_cmd_list);
return 0;
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_ID)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "ID : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "ID : %s", (char *)key); */
vc_cmd_set_id(temp_command, atoi((char*)key));
xmlFree(key);
} else {
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_PID)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "PID : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "PID : %s", (char *)key); */
vc_cmd_set_pid(temp_command, atoi((char*)key));
xmlFree(key);
} else {
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_TYPE)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "Type : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "Type : %s", (char *)key); */
vc_cmd_set_type(temp_command, atoi((char*)key));
xmlFree(key);
} else {
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_FORMAT)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "Format : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "Format : %s", (char *)key); */
vc_cmd_set_format(temp_command, atoi((char*)key));
xmlFree(key);
} else {
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_DOMAIN)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "Domain : %s", (char *)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "Domain : %s", (char *)key); */
vc_cmd_set_domain(temp_command, atoi((char*)key));
xmlFree(key);
} else {
break;
}
}
-
+
command_node = command_node->next;
command_node = command_node->next;
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_COMMAND_TEXT)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "Command : %s, size : %d", (char *)key, strlen(key));
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "Command : %s, size : %d", (char *)key, strlen(key)); */
vc_cmd_set_command(temp_command, (char*)key);
-
+
xmlFree(key);
} else {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] <%s> has no content", VC_TAG_CMD_COMMAND_TEXT);
if (0 == xmlStrcmp(command_node->name, (const xmlChar *)VC_TAG_CMD_PARAMETER_TEXT)) {
key = xmlNodeGetContent(command_node);
if (NULL != key) {
- //SLOG(LOG_DEBUG, vc_info_tag(), "Parameter : %s , size : %d", (char *)key, strlen(key));
- //vc_cmd_set_parameter(temp_command, (char*)key);
+ /*SLOG(LOG_DEBUG, vc_info_tag(), "Parameter : %s , size : %d", (char *)key, strlen(key)); */
+ /*vc_cmd_set_parameter(temp_command, (char*)key); */
vc_cmd_set_unfixed_command(temp_command, (char*)key);
xmlFree(key);
} else {
vc_demandable_client_s* temp_client;
temp_client = (vc_demandable_client_s*)calloc(1, sizeof(vc_demandable_client_s));
-
+
if (NULL == temp_client) {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
return -1;
xmlFreeDoc(doc);
- *client_list = temp_client_list;
+ *client_list = temp_client_list;
remove(VC_RUNTIME_INFO_DEMANDABLE_LIST);
} else {
snprintf(filepath, 256, "%s", VC_RUNTIME_INFO_EX_RESULT);
}
-
+
SLOG(LOG_DEBUG, vc_info_tag(), "Result file path : %s", filepath);
/* Check file */
doc->encoding = (const xmlChar*)"utf-8";
doc->charset = 1;
- root_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_RESULT_BASE_TAG);
- xmlDocSetRootElement(doc,root_node);
+ root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_RESULT_BASE_TAG);
+ xmlDocSetRootElement(doc, root_node);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_RESULT_TEXT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_RESULT_TEXT);
xmlNodeSetContent(tmp_node, (const xmlChar *)result_text);
xmlAddChild(root_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", event);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_RESULT_EVENT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_RESULT_EVENT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(root_node, tmp_node);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_RESULT_MESSAGE);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_RESULT_MESSAGE);
xmlNodeSetContent(tmp_node, (const xmlChar *)msg);
- xmlAddChild(root_node, tmp_node);
+ xmlAddChild(root_node, tmp_node);
/* Make client list node */
vc_cmd_h vc_command = NULL;
/* Make new command node */
cmd_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_COMMAND);
-
- SLOG(LOG_DEBUG, vc_info_tag(), "[Result info] ID(%d) PID(%d) type(%d) format(%d) domain(%d) cmd(%s) param(%s)",
- temp_cmd->id, temp_cmd->pid, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
+
+ SLOG(LOG_DEBUG, vc_info_tag(), "[Result info] ID(%d) PID(%d) type(%d) format(%d) domain(%d) cmd(%s) param(%s)",
+ temp_cmd->id, temp_cmd->pid, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
/* ID */
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->id);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_ID);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_ID);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->pid);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_PID);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_PID);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->type);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_TYPE);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_TYPE);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->format);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_FORMAT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_FORMAT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", temp_cmd->domain);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_DOMAIN);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_DOMAIN);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(cmd_node, tmp_node);
/* COMMAND */
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_COMMAND_TEXT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_COMMAND_TEXT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp_cmd->command);
xmlAddChild(cmd_node, tmp_node);
/* PARAMETER */
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CMD_PARAMETER_TEXT);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CMD_PARAMETER_TEXT);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp_cmd->parameter);
xmlAddChild(cmd_node, tmp_node);
} else {
snprintf(filepath, 256, "%s", VC_RUNTIME_INFO_EX_RESULT);
}
-
+
SLOG(LOG_DEBUG, vc_info_tag(), "Result file path : %s", filepath);
xmlDocPtr doc = NULL;
xmlFreeDoc(doc);
return -1;
}
-
+
/* Result text */
if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_RESULT_TEXT)) {
key = xmlNodeGetContent(cur);
xmlFreeDoc(doc);
return -1;
}
-
+
/* Result Message */
if (result_message != NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)VC_TAG_RESULT_MESSAGE)) {
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)"text")) {
continue;
}
-
+
SLOG(LOG_ERROR, vc_info_tag(), "111 : %s", cur->name);
/* Check Command tag */
vc_cmd_s* temp_cmd = NULL;
temp_cmd = (vc_cmd_s*)vc_command;
-
+
if (NULL == temp_cmd) {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
return -1;
return -1;
}
}
-
+
command_node = command_node->next;
command_node = command_node->next;
cur = cur->next;
if (NULL == cur) {
break;
- }
- else if (0 == xmlStrcmp(cur->name, (const xmlChar *)"text")) {
+ } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)"text")) {
continue;
}
SLOG(LOG_DEBUG, vc_info_tag(), "PID : %s", (char *)key);
temp_cmd->pid = atoi((char*)key);
xmlFree(key);
- }
- else {
+ } else {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] <%s> has no content", VC_TAG_CMD_PID);
free(temp_cmd);
break;
SLOG(LOG_DEBUG, vc_info_tag(), "Type : %s", (char *)key);
temp_cmd->type = atoi((char*)key);
xmlFree(key);
- }
- else {
+ } else {
SECURE_SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] <%s> has no content", VC_TAG_CMD_TYPE);
free(temp_cmd);
return -1;
doc->encoding = (const xmlChar*)"utf-8";
doc->charset = 1;
- root_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_BASE_TAG);
+ root_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_BASE_TAG);
xmlDocSetRootElement(doc, root_node);
GSList *iter = NULL;
SLOG(LOG_DEBUG, vc_info_tag(), "client count : %d", count);
char temp[16] = {0, };
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
client = iter->data;
if (NULL != client) {
- SLOG(LOG_DEBUG, vc_info_tag(), "[%dth] pid(%d) fgcmd(%d) bgcmd(%d) excmd(%d)",
- i, client->pid, client->fg_cmd, client->bg_cmd, client->exclusive_cmd);
+ SLOG(LOG_DEBUG, vc_info_tag(), "[%dth] pid(%d) fgcmd(%d) bgcmd(%d) excmd(%d)",
+ i, client->pid, client->fg_cmd, client->bg_cmd, client->exclusive_cmd);
/* Make new client node */
- client_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_CLIENT);
+ client_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_CLIENT);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", client->pid);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_PID);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_PID);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(client_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", client->fg_cmd);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_FGCMD);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_FGCMD);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(client_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", client->bg_cmd);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_BGCMD);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_BGCMD);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(client_node, tmp_node);
memset(temp, 0, 16);
snprintf(temp, 16, "%d", client->exclusive_cmd);
- tmp_node = xmlNewNode(NULL,(const xmlChar*)VC_TAG_CLIENT_EXCMD);
+ tmp_node = xmlNewNode(NULL, (const xmlChar*)VC_TAG_CLIENT_EXCMD);
xmlNodeSetContent(tmp_node, (const xmlChar *)temp);
xmlAddChild(client_node, tmp_node);
xmlAddChild(root_node, client_node);
- }
+ }
iter = g_slist_next(iter);
}
int ret = xmlSaveFormatFile(VC_RUNTIME_INFO_CLIENT, doc, 1);
- //xmlFreeDoc(doc);
+ /*xmlFreeDoc(doc); */
if (0 >= ret) {
SLOG(LOG_DEBUG, vc_info_tag(), "[ERROR] Fail to save client file : %d", ret);
return -1;
vc_client_info_s *client = NULL;
client = (vc_client_info_s*)calloc(1, sizeof(vc_client_info_s));
-
+
if (NULL == client) {
SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
return -1;
break;
}
}
-
+
client_node = client_node->next;
client_node = client_node->next;
iter = g_slist_nth(cmd_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
temp_cmd = iter->data;
if (NULL == temp_cmd) {
}
SLOG(LOG_DEBUG, vc_info_tag(), " [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
- i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain,
- temp_cmd->command, temp_cmd->parameter);
+ i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain,
+ temp_cmd->command, temp_cmd->parameter);
iter = g_slist_next(iter);
* limitations under the License.
*/
-
+
#ifndef __VC_CMD_PARSER_H_
#define __VC_CMD_PARSER_H_
#endif
-typedef struct _demandable_client_s{
+typedef struct _demandable_client_s {
char* appid;
-}vc_demandable_client_s;
+} vc_demandable_client_s;
-typedef struct _client_s{
+typedef struct _client_s {
int pid;
bool fg_cmd;
bool bg_cmd;
bool exclusive_cmd;
-}vc_client_info_s;
+} vc_client_info_s;
int vc_cmd_parser_save_file(int pid, vc_cmd_type_e type, GSList* cmd_list);
* limitations under the License.
*/
-
+
#ifndef __VC_MAIN_H_
#define __VC_MAIN_H_
#define TAG_VCCONFIG "vcinfo" /* config lib log tag */
#define TAG_VCCMD "vccmd" /* Command log tag */
-/**
+/**
* @brief A structure of handle for identification
*/
struct vc_s {
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
*
* @see vc_deinitialize()
*/
-int vc_initialize();
+int vc_initialize(void);
/**
* @brief Deinitializes voice control.
*
* @see vc_deinitialize()
*/
-int vc_deinitialize();
+int vc_deinitialize(void);
/**
* @brief Connects the voice control service.
*
* @see vc_unprepare()
*/
-int vc_prepare();
+int vc_prepare(void);
/**
* @brief Disconnects the voice control service.
*
* @see vc_prepare()
*/
-int vc_unprepare();
+int vc_unprepare(void);
/**
* @brief Retrieves all supported languages using callback function.
* @retval #VC_ERROR_PERMISSION_DENIED Permission denied
* @retval #VC_ERROR_NOT_SUPPORTED Not supported
*
-* @see vc_state_changed_cb()
+* @see vc_state_changed_cb()
* @see vc_set_state_changed_cb()
*/
int vc_get_state(vc_state_e* state);
* @see vc_request_start()
* @see vc_request_stop()
* @see vc_request_cancel()
-* @see vc_set_service_state_changed_cb()
+* @see vc_set_service_state_changed_cb()
* @see vc_unset_service_state_changed_cb()
*/
int vc_get_service_state(vc_service_state_e* state);
*
* @pre The state should be #VC_STATE_READY.
*
-* @see vc_unset_command_list()
+* @see vc_unset_command_list()
*/
int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type);
*
* @pre The state should be #VC_STATE_READY.
*
-* @see vc_set_command_list()
+* @see vc_set_command_list()
*/
int vc_unset_command_list(int type);
*
* @see vc_set_result_cb()
*/
-int vc_unset_result_cb();
+int vc_unset_result_cb(void);
/**
* @brief Registers a callback function to be called when state is changed.
*
* @see vc_set_service_state_changed_cb()
*/
-int vc_unset_service_state_changed_cb();
+int vc_unset_service_state_changed_cb(void);
/**
* @brief Registers a callback function to be called when state is changed.
*
* @see vc_set_state_changed_cb()
*/
-int vc_unset_state_changed_cb();
+int vc_unset_state_changed_cb(void);
/**
* @brief Registers a callback function to be called when current language is changed.
*
* @see vc_set_current_language_changed_cb()
*/
-int vc_unset_current_language_changed_cb();
+int vc_unset_current_language_changed_cb(void);
/**
* @brief Registers a callback function to be called when an error occurred.
*
* @see vc_set_error_cb()
*/
-int vc_unset_error_cb();
+int vc_unset_error_cb(void);
#ifdef __cplusplus
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
VC_AUTH_STATE_NONE = 0,
VC_AUTH_STATE_VALID = 1,
VC_AUTH_STATE_INVALID = 2
-}vc_auth_state_e;
+} vc_auth_state_e;
/**
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
* @since_tizen 2.4
*
* @param[in] vc_cmd_list The command list handle
-* @param[in] free_command The command free option @c true = release each commands in list,
+* @param[in] free_command The command free option @c true = release each commands in list,
* @c false = remove command from list
*
* @return 0 on success, otherwise a negative error value
* @brief Creates a handle for command.
* @since_tizen 2.4
*
-* @remarks If the function succeeds, @a The command handle must be released
+* @remarks If the function succeeds, @a The command handle must be released
* with vc_cmd_destroy() or vc_cmd_list_destroy().
* You should set command and type if command is valid
*
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
VC_CMD_FORMAT_FIXED_AND_EXTRA, /**< Fixed + extra unfixed command */
VC_CMD_FORMAT_EXTRA_AND_FIXED, /**< Extra unfixed + fixed command */
VC_CMD_FORMAT_UNFIXED_ONLY /**< Unfixed command */
-}vc_cmd_format_e;
+} vc_cmd_format_e;
/**
* @since_tizen 2.4
*
* @remark If the function succeeds, @a The command must be released with free() by you if they are not NULL.
-* If you get the result command list in result callback and the command type of commands has non-fixed format,
+* If you get the result command list in result callback and the command type of commands has non-fixed format,
* you should check non-fixed result using this function.
*
* @param[in] vc_command The command handle
VC_ERROR_OPERATION_REJECTED = TIZEN_ERROR_VOICE_CONTROL | 0x015, /**< Operation rejected */
VC_ERROR_ITERATION_END = TIZEN_ERROR_VOICE_CONTROL | 0x016, /**< List reached end */
VC_ERROR_EMPTY = TIZEN_ERROR_VOICE_CONTROL | 0x017 /**< List empty */
-}vc_error_e;
+} vc_error_e;
/**
* @brief Enumerations of result event.
typedef enum {
VC_RESULT_EVENT_RESULT_SUCCESS = 0, /**< Normal result */
VC_RESULT_EVENT_REJECTED = 1 /**< Rejected result */
-}vc_result_event_e;
+} vc_result_event_e;
/**
* @brief Enumerations of service state.
VC_SERVICE_STATE_READY = 1, /**< 'Ready' state */
VC_SERVICE_STATE_RECORDING = 2, /**< 'Recording' state */
VC_SERVICE_STATE_PROCESSING = 3 /**< 'Processing' state */
-}vc_service_state_e;
+} vc_service_state_e;
/**
* @brief Enumerations of client state.
VC_STATE_NONE = 0, /**< 'None' state */
VC_STATE_INITIALIZED = 1, /**< 'Initialized' state */
VC_STATE_READY = 2 /**< 'Ready' state */
-}vc_state_e;
+} vc_state_e;
/**
* @since_tizen 2.4
*
* @remarks If the duplicated commands are recognized, the event(e.g. #VC_RESULT_EVENT_REJECTED) of command may be rejected \n
-* for selecting command as priority. If you set similar or same commands or the recognized results are multi-results,
-* vc_cmd_list has the multi commands.
+* for selecting command as priority. If you set similar or same commands or the recognized results are multi-results,
+* vc_cmd_list has the multi commands.
*
* @param[in] event The result event (e.g. #VC_RESULT_EVENT_RESULT_SUCCESS, #VC_RESULT_EVENT_REJECTED)
* @param[in] vc_cmd_list The recognized command list
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
-/**
+/**
* @brief Defines of audio-in type.
*/
#define VC_AUDIO_TYPE_BLUETOOTH "VC_AUDIO_ID_BLUETOOTH" /**< Bluetooth audio type */
* @see vc_mgr_set_all_result_cb()
* @see vc_mgr_unset_all_result_cb()
*/
-typedef bool (*vc_mgr_all_result_cb)(vc_result_event_e event, vc_cmd_list_h vc_cmd_list,
- const char* result, const char* msg, void *user_data);
+typedef bool (*vc_mgr_all_result_cb)(vc_result_event_e event, vc_cmd_list_h vc_cmd_list,
+ const char* result, const char* msg, void *user_data);
/**
* @brief Called when user speaking is detected.
int vc_mgr_deinitialize();
/**
-* @brief Connects the vc-daemon.
+* @brief Connects the voice control service.
*
* @return 0 on success, otherwise a negative error value
* @retval #VC_ERROR_NONE Successful
* @retval #VC_ERROR_INVALID_STATE Invalid state
*
* @pre The state should NOT be #VC_SERVICE_STATE_NONE.
-* @post This function invokes vc_supported_language_cb() repeatedly for getting languages.
+* @post This function invokes vc_supported_language_cb() repeatedly for getting languages.
*
* @see vc_supported_language_cb()
* @see vc_mgr_get_current_language()
*
* @pre The state should NOT be #VC_SERVICE_STATE_NONE.
*
-* @see vc_state_changed_cb()
+* @see vc_state_changed_cb()
* @see vc_set_state_changed_cb()
*/
int vc_mgr_get_state(vc_state_e* state);
* @see vc_mgr_start()
* @see vc_mgr_stop()
* @see vc_mgr_cancel()
-* @see vc_set_service_state_changed_cb()
+* @see vc_set_service_state_changed_cb()
* @see vc_unset_service_state_changed_cb()
*/
int vc_mgr_get_service_state(vc_service_state_e* state);
*
* @pre The state should be #VC_STATE_READY.
*
-* @see vc_mgr_get_demandable_client_rule()
+* @see vc_mgr_get_demandable_client_rule()
*/
int vc_mgr_set_demandable_client_rule(const char* rule);
*
* @pre The state should be #VC_STATE_READY.
*
-* @see vc_mgr_set_demandable_client_rule()
+* @see vc_mgr_set_demandable_client_rule()
*/
int vc_mgr_unset_demandable_client_rule();
*
* @pre The state should be #VC_STATE_READY.
*
-* @see vc_mgr_unset_command_list()
+* @see vc_mgr_unset_command_list()
*/
int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list);
*
* @pre The state should be #VC_STATE_READY and the service state should be #VC_SERVICE_STATE_READY.
*
-* @see vc_mgr_get_audio_type()
+* @see vc_mgr_get_audio_type()
*/
int vc_mgr_set_audio_type(const char* audio_id);
/**
* @brief Gets the microphone volume during recording.
-*
+*
* @param[out] volume Recording volume
*
* @return 0 on success, otherwise a negative error value
* @retval #VC_ERROR_OPERATION_FAILED Operation failure
*
* @pre The service state should be #VC_SERVICE_STATE_RECORDING.
-*
+*
* @see vc_mgr_start()
*/
int vc_mgr_get_recording_volume(float* volume);
/**
* @brief Select valid result from all results.
-*
+*
* @param[in] vc_cmd_list The valid result list
*
* @return 0 on success, otherwise a negative error value
* @retval #VC_ERROR_OPERATION_FAILED Operation failure
*
* @pre vc_mgr_all_result_cb() should be called
-*
+*
* @see vc_mgr_all_result_cb()
*/
int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list);
extern "C" {
#endif
-/**
+/**
* @brief Enumerations of error codes.
*/
typedef enum {
VCP_ERROR_INVALID_LANGUAGE = -0x0100032, /**< Invalid language */
VCP_ERROR_OPERATION_FAILED = -0x0100034, /**< Operation failed */
VCP_ERROR_NOT_SUPPORTED_FEATURE = -0x0100035 /**< Not supported feature */
-}vcp_error_e;
+} vcp_error_e;
/**
* @brief Enumerations of audio type.
typedef enum {
VCP_AUDIO_TYPE_PCM_S16_LE = 0, /**< Signed 16bit audio type, Little endian */
VCP_AUDIO_TYPE_PCM_U8 /**< Unsigned 8bit audio type */
-}vcp_audio_type_e;
+} vcp_audio_type_e;
/**
* @brief Enumerations of callback event.
VCP_RESULT_EVENT_SUCCESS = 0, /**< Event when the recognition full result is ready */
VCP_RESULT_EVENT_REJECTED, /**< Event when the recognition result is rejected */
VCP_RESULT_EVENT_ERROR /**< Event when the recognition has failed */
-}vcp_result_event_e;
+} vcp_result_event_e;
/**
* @brief Enumerations of command type.
VCP_COMMAND_TYPE_FIXED = 0, /**< Fixed command */
VCP_COMMAND_TYPE_FIXED_AND_NON_FIXED, /**< Fixed command + Non-fixed command */
VCP_COMMAND_TYPE_NON_FIXED_AND_FIXED /**< Non-fixed command + Fixed command */
-}vcp_command_type_e;
+} vcp_command_type_e;
/**
* @brief Enumerations of speech detect.
VCP_SPEECH_DETECT_NONE = 0, /**< No event */
VCP_SPEECH_DETECT_BEGIN, /**< Begin of speech detected */
VCP_SPEECH_DETECT_END, /**< End of speech detected */
-}vcp_speech_detect_e;
+} vcp_speech_detect_e;
-/**
+/**
* @brief A structure of handle for VC command
*/
typedef int vcp_cmd_h;
-/**
+/**
* @brief Defines of bluetooth audio id.
*/
#define VCP_AUDIO_ID_BLUETOOTH "VC_AUDIO_ID_BLUETOOTH" /**< Bluetooth audio id */
#define VC_RESULT_MESSAGE_ERROR_TOO_LOUD "vc.result.message.error.too.loud"
-/**
+/**
* @brief Called when the daemon gets synthesized result.
-*
+*
* @param[in] event A result event
* @param[in] result_id Result ids
* @param[in] count Result count
*
* @see vcpe_stop()
*/
-typedef void (*vcpe_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);
+typedef void (*vcpe_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);
/**
-* @brief Called to retrieve the supported languages.
+* @brief Called to retrieve the supported languages.
*
* @param[in] language A language is specified as an ISO 3166 alpha-2 two letter country-code
* followed by ISO 639-1 for the two-letter language code \n
*
* @return @c true to continue with the next iteration of the loop \n @c false to break out of the loop
*
-* @pre vcpe_foreach_supported_languages() will invoke this callback.
+* @pre vcpe_foreach_supported_languages() will invoke this callback.
*
* @see vcpe_foreach_supported_languages()
*/
* @retval #VCP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #VCP_ERROR_INVALID_STATE Already initialized
* @retval #VCP_ERROR_OPERATION_FAILED Operation failed
-*
+*
* @see vcpe_deinitialize()
*/
typedef int (* vcpe_initialize)(void);
* @return 0 on success, otherwise a negative error value
* @retval #VCP_ERROR_NONE Successful
* @retval #VCP_ERROR_INVALID_STATE Not initialized
-*
+*
* @see vcpe_initialize()
*/
typedef void (* vcpe_deinitialize)(void);
* @retval #VCP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #VCP_ERROR_INVALID_STATE Not initialized
*
-* @post This function invokes vcpe_supported_language_cb() repeatedly for getting supported languages.
+* @post This function invokes vcpe_supported_language_cb() repeatedly for getting supported languages.
*
* @see vcpe_supported_language_cb()
*/
typedef bool (* vcpe_is_language_supported)(const char* language);
/**
-* @brief Sets language.
+* @brief Sets language.
*
* @param[in] language language.
*
*
* @remark This function should set commands via vcpd_foreach_command().
*
-* @param[in] vcp_command command handle.
+* @param[in] vcp_command command handle.
*
* @return 0 on success, otherwise a negative error value
* @retval #VCP_ERROR_NONE Successful
typedef int (* vcpe_start)(bool stop_by_silence);
/**
-* @brief Sets recording data for speech recognition from recorder.
+* @brief Sets recording data for speech recognition from recorder.
+*
+* @remark This function should be returned immediately after recording data copy.
*
-* @remark This function should be returned immediately after recording data copy.
-*
* @param[in] data A recording data
* @param[in] length A length of recording data
* @param[out] silence_detected @c true Silence detected \n @c false No silence detected
*/
/**
-* @brief Called to retrieve the commands.
+* @brief Called to retrieve the commands.
*
* @param[in] id command id
* @param[in] type command type
* @param[in] user_data The user data passed from the foreach function
*
* @return @c true to continue with the next iteration of the loop, \n @c false to break out of the loop.
-* @pre vcpd_foreach_command() will invoke this callback.
+* @pre vcpd_foreach_command() will invoke this callback.
*
* @see vcpd_foreach_command()
*/
* @retval #VCP_ERROR_OPERATION_FAILED Operation failure
* @retval #VCP_ERROR_INVALID_STATE Invalid state
*
-* @post This function invokes vcpd_foreach_command_cb() repeatedly for getting commands.
+* @post This function invokes vcpd_foreach_command_cb() repeatedly for getting commands.
*
* @see vcpd_foreach_command_cb()
* @see vcpe_set_commands()
} vcpd_funcs_s;
/**
-* @brief Loads the engine.
+* @brief Loads the engine.
*
* @param[in] pdfuncs The daemon functions
* @param[out] pefuncs The engine functions
int vcp_load_engine(vcpd_funcs_s* pdfuncs, vcpe_funcs_s* pefuncs);
/**
-* @brief Unloads this engine by the daemon.
+* @brief Unloads this engine by the daemon.
*
* @pre The vcp_load_engine() should be successful.
*
* @param[in] use_network @c true to need network @c false not to need network.
* @param[in] user_data The User data passed from vcp_get_engine_info()
*
-* @pre vcp_get_engine_info() will invoke this callback.
+* @pre vcp_get_engine_info() will invoke this callback.
*
* @see vcp_get_engine_info()
*/
-typedef void (*vcpe_engine_info_cb)(const char* engine_uuid, const char* engine_name, const char* engine_setting,
- bool use_network, void* user_data);
+typedef void (*vcpe_engine_info_cb)(const char* engine_uuid, const char* engine_name, const char* engine_setting,
+ bool use_network, void* user_data);
/**
-* @brief Gets the engine base information before the engine is loaded by the daemon.
+* @brief Gets the engine base information before the engine is loaded by the daemon.
*
* @param[in] callback Callback function
* @param[in] user_data User data to be passed to the callback function
/**
-* @brief Initialize voice control setting
+* @brief Initialize voice control setting
*
* @remarks If the function succeeds, @a vc mgr must be released with vc_setting_finalize().
*
* @return 0 on success, otherwise a negative error value.
* @retval #VC_ERROR_NONE Success.
-* @retval #VC_ERROR_INVALID_STATE VC setting has Already been initialized.
+* @retval #VC_ERROR_INVALID_STATE VC setting has Already been initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_finalize()
*
* @return 0 on success, otherwise a negative error value.
* @retval #VC_ERROR_NONE Success.
-* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_initialize()
* @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.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
-* @post This function invokes vc_setting_supported_language_cb() repeatedly for getting supported languages.
+* @post This function invokes vc_setting_supported_language_cb() repeatedly for getting supported languages.
*
* @see vc_setting_supported_language_cb()
*/
* @retval #VC_ERROR_NONE Success.
* @retval #VC_ERROR_OUT_OF_MEMORY Out of memory.
* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter.
-* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_set_language()
* @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.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_get_language()
* @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.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_get_auto_language()
* @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.
+* @retval #VC_ERROR_INVALID_STATE VC Not initialized.
* @retval #VC_ERROR_OPERATION_FAILED Operation failure.
*
* @see vc_setting_set_auto_language()
*/
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
/**
-* @brief Initialize voice control for widget.
+* @brief Initialize voice control for widget.
*
* @param[in] vc_widget The voice control handle
*
* @retval #VC_ERROR_INVALID_STATE Invalid state
*
* @pre The state should be #VC_STATE_READY.
-* @post This function invokes vc_supported_language_cb() repeatedly for getting languages.
+* @post This function invokes vc_supported_language_cb() repeatedly for getting languages.
*
* @see vc_supported_language_cb()
* @see vc_widget_get_current_language()
* @see vc_widget_deinitialize()
* @see vc_widget_prepare()
* @see vc_widget_unprepare()
-* @see vc_widget_set_state_changed_cb()
+* @see vc_widget_set_state_changed_cb()
* @see vc_widget_unset_state_changed_cb()
*/
int vc_widget_get_state(vc_state_e* state);
GSList *iter = NULL;
vc_demandable_client_s* temp_client;
iter = g_slist_nth(g_demandable_client, 0);
-
+
while (NULL != iter) {
temp_client = iter->data;
/* Check demandable appid */
char appid[128] = {0, };
aul_app_get_appid_bypid(pid, appid, sizeof(appid));
-
+
if (0 < strlen(appid)) {
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] %s(%d) requests start", appid, pid);
} else {
GSList *iter = NULL;
vc_demandable_client_s* temp_client;
iter = g_slist_nth(g_demandable_client, 0);
-
+
while (NULL != iter) {
temp_client = iter->data;
g_cur_cmd_list.background_cmds = g_slist_append(g_cur_cmd_list.background_cmds, bg_cmd);
}
}
-
return 0;
}
} else {
id_count++;
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Widget : id(%d) index(%d) format(%d) command(%s) param(%s) domain(%d)"
- , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
+ , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
callback(temp_cmd->id, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain, user_data);
id_count++;
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Foreground : id(%d) index(%d) format(%d) command(%s) param(%s) domain(%d)"
- , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
+ , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
callback(temp_cmd->id, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain, user_data);
id_count++;
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] System : id(%d) index(%d) format(%d) domain(%d) command(%s) param(%s)"
- , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
+ , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
callback(temp_cmd->id, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain, user_data);
id_count++;
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Exclusive system : id(%d) index(%d) format(%d) command(%s) param(%s) domain(%d)"
- , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
+ , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
callback(temp_cmd->id, temp_cmd->type, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain, user_data);
id_count++;
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Background : id(%d) index(%d) format(%d) command(%s) param(%s) domain(%d)"
- , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
+ , temp_cmd->id, temp_cmd->index, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain);
callback(temp_cmd->id, temp_cmd->format, temp_cmd->command, temp_cmd->parameter, temp_cmd->domain, user_data);
if (NULL != src_cmd->parameter) {
temp_cmd->parameter = strdup(src_cmd->parameter);
}
-
+
temp_cmd->key = src_cmd->key;
temp_cmd->modifier = src_cmd->modifier;
return temp_cmd;
}
-//int vcd_client_get_cmd_info_from_result_id(int result_id, int* pid, int* cmd_type, vc_cmd_s** result)
int vcd_client_get_cmd_from_result_id(int result_id, vc_cmd_s** result)
{
GSList *iter = NULL;
temp_cmd = iter->data;
if (result_id == temp_cmd->id) {
- //*pid = g_cur_cmd_list.foreground;
- //*cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_UI_CONTROL;
- //SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type);
+ /**pid = g_cur_cmd_list.foreground; */
+ /**cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_UI_CONTROL; */
+ /*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] command id (%d)", temp_cmd->id);
if (result_id == temp_cmd->id) {
- //*pid = g_cur_cmd_list.foreground;
- //*cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_FOREGROUND;
- //SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type);
+ /**pid = g_cur_cmd_list.foreground; */
+ /**cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_FOREGROUND; */
+ /*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
return 0;
temp_cmd = iter->data;
if (result_id == temp_cmd->id) {
- //*pid = g_manager.pid;
- //*cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_SYSTEM;
- //SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type);
+ /**pid = g_manager.pid; */
+ /**cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_SYSTEM; */
+ /*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
return 0;
temp_cmd = iter->data;
if (result_id == temp_cmd->id) {
- //*pid = g_manager.pid;
- //*cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_SYSTEM_EXCLUSIVE;
- //SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type);
+ /**pid = g_manager.pid; */
+ /**cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_SYSTEM_EXCLUSIVE; */
+ /*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
return 0;
temp_cmd = back_iter->data;
if (result_id == temp_cmd->id) {
- //*pid = back_cmd_info->pid;
- //*cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_BACKGROUND;
+ /**pid = back_cmd_info->pid; */
+ /**cmd_type = VCD_CLIENT_COMMAND_GROUP_TYPE_BACKGROUND; */
*result = __command_copy(temp_cmd);
return 0;
SLOG(LOG_DEBUG, TAG_VCD, "No Client");
} else {
iter = g_slist_nth(g_client_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
SLOG(LOG_DEBUG, TAG_VCD, "[%dth] pid(%d)", i, data->pid);
SLOG(LOG_DEBUG, TAG_VCD, "No widget");
} else {
iter = g_slist_nth(g_widget_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
widget_data = iter->data;
SLOG(LOG_DEBUG, TAG_VCD, "[%dth] pid(%d)", i, widget_data->pid);
SLOG(LOG_DEBUG, TAG_VCD, "No command");
} else {
iter = g_slist_nth(cmd_group, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
if (NULL != data->parameter) {
if (0 < count) {
iter = g_slist_nth(g_client_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
- if (pid == data->pid)
+ if (pid == data->pid)
return iter;
iter = g_slist_next(iter);
{
GSList *iter = NULL;
vc_client_info_s *data = NULL;
-
+
int count = g_slist_length(g_client_list);
int i;
if (0 < count) {
iter = g_slist_nth(g_client_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
- if (pid == data->pid)
+ if (pid == data->pid)
return data;
iter = g_slist_next(iter);
/*Check pid is duplicated*/
GSList *tmp = NULL;
tmp = __client_get_item(pid);
-
+
if (NULL != tmp) {
SLOG(LOG_WARN, TAG_VCD, "[Client Data] Client pid is already registered");
return VCD_ERROR_INVALID_PARAMETER;
/* Add item to global list */
g_client_list = g_slist_append(g_client_list, info);
-
+
if (NULL == g_client_list) {
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Fail to add new client");
return -1;
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
-#endif
+#endif
return 0;
}
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
-#endif
+#endif
return 0;
}
int vcd_client_get_ref_count()
{
int count = 0;
-
+
count = g_slist_length(g_client_list) + g_slist_length(g_widget_list);
if (0 < g_manager.pid) {
count++;
{
if (NULL == pids || NULL == pid_count)
return -1;
-
+
int count = g_slist_length(g_client_list);
if (0 == count)
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to allocate memory");
return VCD_ERROR_OUT_OF_MEMORY;
}
-
+
GSList *iter = NULL;
vc_client_info_s *data = NULL;
int i = 0;
if (0 < count) {
iter = g_slist_nth(g_widget_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
- if (pid == data->pid)
+ if (pid == data->pid)
return iter;
iter = g_slist_next(iter);
{
GSList *iter = NULL;
widget_info_s *data = NULL;
-
+
int count = g_slist_length(g_widget_list);
int i;
if (0 < count) {
iter = g_slist_nth(g_widget_list, 0);
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
data = iter->data;
if (NULL != data) {
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
-#endif
+#endif
return 0;
}
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
-#endif
+#endif
return 0;
}
}
info->widget_cmd = true;
-
+
return 0;
}
}
info->widget_cmd = false;
-
+
return 0;
}
\ No newline at end of file
typedef struct {
int pid;
int cmd_count;
-
+
GSList* cmds;
-}background_command_s;
+} background_command_s;
typedef struct {
int total_cmd_count;
/* Other applications */
int bg_cmd_count;
GSList* background_cmds;
-}current_commands_list_s;
+} current_commands_list_s;
typedef struct {
int pid;
bool manager_cmd;
bool exclusive_cmd_option;
-}manager_info_s;
+} manager_info_s;
typedef struct {
int pid;
bool widget_cmd;
-}widget_info_s;
+} widget_info_s;
/*
int vcd_config_get_foreground(int* pid)
{
return vc_config_mgr_get_foreground(pid);
-}
\ No newline at end of file
+}
return -1;
}
- if (NULL == msg) {
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
return VCD_ERROR_OUT_OF_MEMORY;
}
result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
dbus_message_unref(msg);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
dbus_error_free(&err);
}
if (NULL != result_msg) {
dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
dbus_error_free(&err);
result = VCD_ERROR_OPERATION_FAILED;
int vcdc_send_show_tooltip(int pid, bool show)
{
if (0 > pid) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid" );
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid");
return -1;
}
- char service_name[64];
+ char service_name[64] = {0, };
memset(service_name, 0, 64);
snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
- char target_if_name[128];
+ 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_method_call(
- service_name,
- VC_WIDGET_SERVICE_OBJECT_PATH,
- target_if_name,
- VCD_WIDGET_METHOD_SHOW_TOOLTIP);
+ service_name,
+ VC_WIDGET_SERVICE_OBJECT_PATH,
+ target_if_name,
+ VCD_WIDGET_METHOD_SHOW_TOOLTIP);
- if (NULL == msg) {
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
return VCD_ERROR_OUT_OF_MEMORY;
}
SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send error signal : reason(%d), Error Msg(%s)", reason, err_msg);
msg = dbus_message_new_method_call(
- service_name,
- VC_CLIENT_SERVICE_OBJECT_PATH,
- target_if_name,
- VCD_METHOD_ERROR);
+ service_name,
+ VC_CLIENT_SERVICE_OBJECT_PATH,
+ VC_CLIENT_SERVICE_INTERFACE,
+ VCD_METHOD_ERROR);
- if (NULL == msg) {
+ if (NULL == msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
return VCD_ERROR_OUT_OF_MEMORY;
}
- dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &reason,
- DBUS_TYPE_STRING, &err_msg,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &reason,
+ DBUS_TYPE_STRING, &err_msg,
+ DBUS_TYPE_INVALID);
dbus_message_set_no_reply(msg, TRUE);
msg = dbus_connection_pop_message(g_conn_listener);
/* loop again if we haven't read a message */
- if (NULL == msg) {
+ if (NULL == msg) {
return ECORE_CALLBACK_RENEW;
}
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
+ else
return ECORE_CALLBACK_RENEW;
/* free the message */
/* connect to the bus and check for errors */
g_conn_listener = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
dbus_error_free(&err);
}
return VCD_ERROR_OPERATION_FAILED;
}
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
dbus_error_free(&err);
return VCD_ERROR_OPERATION_FAILED;
dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
dbus_connection_flush(g_conn_listener);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
dbus_error_free(&err);
return VCD_ERROR_OPERATION_FAILED;
VCD_CLIENT_TYPE_NORMAL,
VCD_CLIENT_TYPE_WIDGET,
VCD_CLIENT_TYPE_MANAGER
-}vcd_client_type_e;
+} vcd_client_type_e;
int vcd_dbus_open_connection();
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)");
dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
-
+
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager Initialize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr initialize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
if (0 == ret) {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager Finalize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr finalize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
}
DBusMessage* reply;
-
+
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager Set command");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set command : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
if (NULL != reply) {
if (0 == ret) {
/* Append result and language */
- dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD manager unset command");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr unset command : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager Set demandable client");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set demandable client : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
int pid = 0;
char* audio_type = NULL;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager set audio type");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &audio_type,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_STRING, &audio_type,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
int pid = 0;
char* audio_type = NULL;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager get audio type");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set audio type : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_STRING, &audio_type,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_STRING, &audio_type,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), audio type(%s)", ret, audio_type);
dbus_error_init(&err);
int pid = 0;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager set client info");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr set client info : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
- DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INVALID);
if (0 == ret) {
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
int silence = 0;
int exclusive = 0;
int start_by_client = 0;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Manager start");
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
+ dbus_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);
- if (dbus_error_is_set(&err)) {
+ 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;
dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
-
+
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Initialize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd initialize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &mgr_pid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Finalize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd finalize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
}
DBusMessage* reply;
-
+
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD set exclusive command");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd unset command : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
if (NULL != reply) {
if (0 == ret) {
/* Append result and language */
- dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD set command");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd set command : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
if (NULL != reply) {
if (0 == ret) {
/* Append result and language */
- dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD unset command");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd unset command : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
if (NULL != reply) {
if (0 == ret) {
/* Append result and language */
- dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
int pid;
int silence;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Request Start");
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &silence, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd start : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Request Stop");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd stop : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Request Cancel");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd cancel : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
/*
* Dbus Widget-Daemon Server
-*/
+*/
int vcd_dbus_server_widget_initialize(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Widget Initialize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget initialize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
reply = dbus_message_new_method_return(msg);
if (NULL != reply) {
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
if (0 == ret) {
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD Widget Finalize");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget finalize : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
int ret = VCD_ERROR_OPERATION_FAILED;
int widget_command;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &widget_command,
- DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &widget_command,
+ DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD widget start recording");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget start recording : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
if (NULL != reply) {
if (0 == ret) {
/* Append result and language */
- dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
+ dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
int pid;
int silence;
-
+
int ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD widget start");
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &silence, DBUS_TYPE_INVALID);
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd start : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD widget stop");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget stop : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD widget cancel");
- if (dbus_error_is_set(&err)) {
+ if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget cancel : get arguments error (%s)", err.message);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
/*
* Dbus Server functions for widget
-*/
+*/
int vcd_dbus_server_widget_initialize(DBusConnection* conn, DBusMessage* msg);
int vcd_dbus_server_widget_finalize(DBusConnection* conn, DBusMessage* msg);
/* engine load info */
bool is_set;
- bool is_loaded;
+ bool is_loaded;
bool is_command_ready;
void *handle;
static bool g_agent_init;
/** vc engine list */
-static GList *g_engine_list;
+static GList *g_engine_list;
/** current engine information */
static vcengine_s g_dynamic_engine;
/*
-* Internal Interfaces
+* Internal Interfaces
*/
/** check engine id */
}
g_list_free(iter);
-
+
/* release current engine data */
if (NULL != g_dynamic_engine.pefuncs) free(g_dynamic_engine.pefuncs);
if (NULL != g_dynamic_engine.pdfuncs) free(g_dynamic_engine.pdfuncs);
bool vcd_engine_is_available_engine()
{
- if (true == g_dynamic_engine.is_loaded)
+ if (true == g_dynamic_engine.is_loaded)
return true;
-
+
return false;
}
int vcd_engine_agent_initialize_current_engine()
{
/* check agent init */
- if (false == g_agent_init ) {
+ if (false == g_agent_init) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
return VCD_ERROR_OPERATION_FAILED;
}
SLOG(LOG_DEBUG, TAG_VCD, " Dynamic engine name : %s", g_dynamic_engine.engine_name);
SLOG(LOG_DEBUG, TAG_VCD, " Dynamic engine path : %s", g_dynamic_engine.engine_path);
SLOG(LOG_DEBUG, TAG_VCD, "-----");
-
+
}
return 0;
while (NULL != iter) {
data = iter->data;
-
+
if (0 == strncmp(engine_uuid, data->engine_uuid, strlen(data->engine_uuid))) {
return 0;
}
if (NULL != data->engine_uuid) free(data->engine_uuid);
if (NULL != data->engine_path) free(data->engine_path);
if (NULL != data->engine_name) free(data->engine_name);
-
+
free(data);
}
} else {
SLOG(LOG_WARN, TAG_VCD, "[Engine Agent WARNING] Fail to open default directory");
}
-
+
if (0 >= g_list_length(g_engine_list)) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] No Engine");
- return VCD_ERROR_ENGINE_NOT_FOUND;
+ return VCD_ERROR_ENGINE_NOT_FOUND;
}
__log_enginelist();
-
+
return 0;
}
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] engine info : version(%d), size(%d)",engine->pefuncs->version, engine->pefuncs->size);
+ SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] engine info : version(%d), size(%d)", engine->pefuncs->version, engine->pefuncs->size);
/* engine error check */
if (engine->pefuncs->size != sizeof(vcpe_funcs_s)) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to initialize vc-engine");
return VCD_ERROR_OPERATION_FAILED;
}
-
+
if (0 != engine->pefuncs->set_result_cb(__result_cb, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set result callback of vc-engine");
return VCD_ERROR_OPERATION_FAILED;
SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Load dynamic engine");
}
}
-
+
return 0;
}
int ret = -1;
SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] silence is %s", silence ? "true" : "false");
-
+
if (true == g_dynamic_engine.is_loaded && true == g_dynamic_engine.is_command_ready) {
ret = g_dynamic_engine.pefuncs->start(silence);
if (0 != ret) {
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to cancel dynamic engine error(%d)", ret);
}
- }
+ }
return 0;
}
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] get language list error(%d)", ret);
return VCD_ERROR_OPERATION_FAILED;
}
-
+
return 0;
}
ret = g_dynamic_engine.pefuncs->set_language(language);
if (0 != ret) {
SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Fail to set language of dynamic engine error(%d, %s)", ret, language);
- }
+ }
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Dynamic engine is not available (Cannot start)");
}
if (NULL != data)
free(data);
-
+
lang_list = g_list_remove_link(lang_list, iter);
iter = g_list_first(lang_list);
SLOG(LOG_DEBUG, TAG_VCD, "--------------- engine list -------------------");
- int i = 1;
+ int i = 1;
while (NULL != iter) {
/* Get handle data from list */
data = iter->data;
#endif
/*
-* Constants & Structures
+* Constants & Structures
*/
#define ENGINE_PATH_SIZE 256
-typedef void (*result_callback)(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);
+typedef void (*result_callback)(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);
typedef void (*silence_dectection_callback)(void *user_data);
perm_app_set_privilege("voice-control", NULL, NULL);
}
- if (0 != vcd_dbus_open_connection()) {
+ if (0 != vcd_dbus_open_connection()) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to open connection");
return EXIT_FAILURE;
}
#define ENGINE_DIRECTORY_DOWNLOAD_SETTING "/opt/usr/voice/vc/setting"
/* for debug message */
-// #define RECORDER_DEBUG
+/* #define RECORDER_DEBUG */
#define CLIENT_DATA_DEBUG
-// #define COMMAND_DATA_DEBUG
+/* #define COMMAND_DATA_DEBUG */
typedef enum {
VCD_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
VCD_ERROR_ENGINE_NOT_FOUND = TIZEN_ERROR_VOICE_CONTROL | 0x013, /**< No available engine */
VCD_ERROR_OPERATION_FAILED = TIZEN_ERROR_VOICE_CONTROL | 0x014, /**< Operation failed */
VCD_ERROR_OPERATION_REJECTED = TIZEN_ERROR_VOICE_CONTROL | 0x015 /**< Operation rejected */
-}vcd_error_e;
+} vcd_error_e;
typedef enum {
VCD_STATE_NONE = 0,
VCD_STATE_READY = 1,
VCD_STATE_RECORDING = 2,
VCD_STATE_PROCESSING = 3
-}vcd_state_e;
+} vcd_state_e;
#ifdef __cplusplus
#include "voice_control_plugin_engine.h"
/* Multi session enable */
-//#define AUDIO_MULTI_SESSION
+/*#define AUDIO_MULTI_SESSION */
/* TV BT enable */
-//#define TV_BT_MODE
+/*#define TV_BT_MODE */
#define FRAME_LENGTH 160
#define BUFFER_LENGTH FRAME_LENGTH * 2
g_audio_type = VCP_AUDIO_TYPE_PCM_S16_LE;
g_audio_rate = 16000;
g_audio_channel = 1;
-
+
audio_channel_e audio_ch;
audio_sample_type_e audio_type;
int i, depthByte;
int count = 0;
-
+
float db = 0.0;
float rms = 0.0;
unsigned long long square_sum = 0;
rms = sqrt(square_sum/count);
db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16);
-
return db;
}
SLOG(LOG_WARN, TAG_VCD, "[Recorder WARNING] Fail to read audio : %d", ret);
g_recorder_state = VCD_RECORDER_STATE_READY;
return EINA_FALSE;
- }
+ }
if (NULL != g_audio_cb) {
if (0 != g_audio_cb(g_normal_buffer, BUFFER_LENGTH)) {
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);
-
+
if (100000 == g_buffer_count) {
g_buffer_count = 0;
}
g_normal_file = fopen(normal_file_name, "wb+");
if (!g_normal_file) {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] File not found!");
- }
+ }
#endif
return 0;
}
int vcd_recorder_get_state()
{
return g_recorder_state;
-}
\ No newline at end of file
+}
typedef enum {
VCD_RECORDER_STATE_READY, /**< Recorder is ready to start */
VCD_RECORDER_STATE_RECORDING, /**< In the middle of recording */
-}vcd_recorder_state_e;
+} vcd_recorder_state_e;
typedef int (*vcd_recoder_audio_cb)(const void* data, const unsigned int length);
SLOG(LOG_DEBUG, TAG_VCD, "===== Change foreground");
SLOG(LOG_DEBUG, TAG_VCD, "Foreground pid(%d)", current);
-
+
if (VC_NO_FOREGROUND_PID != current) {
/* Foreground app is changed */
vcd_state_e state = vcd_config_get_service_state();
GSList* pid_list = NULL;
if (0 != vc_info_parser_get_result_pid_list(&pid_list)) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to get pid list. No result");
- }
- else {
- if (0 < g_slist_length(pid_list)){
+ } else {
+ if (0 < g_slist_length(pid_list)) {
GSList* iter = NULL;
vc_cmd_s* temp_cmd = NULL;
int ret = 0;
}
int i = 0;
- for (i = 0;i < count;i++) {
+ for (i = 0; i < count; i++) {
SLOG(LOG_DEBUG, TAG_VCD, "[Server] [%d] Result ID(%d)", i, result_id[i]);
if (result_id[i] < 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++) {
+ for (i = 0; i < client_count; i++) {
result = vcdc_send_hello(client_list[i], VCD_CLIENT_TYPE_NORMAL);
if (0 == result) {
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++) {
+ for (i = 0; i < client_count; i++) {
result = vcdc_send_hello(client_list[i], VCD_CLIENT_TYPE_WIDGET);
if (0 == result) {
SLOG(LOG_DEBUG, TAG_VCD, "=====");
SLOG(LOG_DEBUG, TAG_VCD, " ");
}
+
if (NULL != client_list) {
free(client_list);
client_list = NULL;
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] The manager pid(%d) is NOT valid", pid);
return VCD_ERROR_INVALID_PARAMETER;
}
-
+
int ret = 0;
vcp_audio_type_e type = VCP_AUDIO_TYPE_PCM_S16_LE;
int rate = 16000;
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] The manager pid(%d) is NOT valid", pid);
return VCD_ERROR_INVALID_PARAMETER;
}
-
+
int ret = vcd_recorder_get(audio_type);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to get audio in type : %d", ret);
{
/* 1. check current state */
vcd_state_e state = vcd_config_get_service_state();
-
+
if (VCD_STATE_READY != state) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Current state is not ready");
return VCD_ERROR_INVALID_STATE;
if (0 != vcd_config_get_foreground(&fg_pid)) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to get foreground");
}
-
+
/* Set client exclusive option */
if (0 != vcd_client_set_exclusive_command(fg_pid)) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set exclusive command");
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to unset command type : pid(%d), cmd_type(%d)", pid, cmd_type);
return VCD_ERROR_OPERATION_FAILED;
}
-
+
return 0;
}
return VCD_ERROR_OPERATION_FAILED;
}
}
-
+
return 0;
}
projects / platform / core / uifw / voice-control.git / commitdiff