#define VC_WIDGET_CONFIG_HANDLE 200000
-static Ecore_Timer* g_w_connect_timer = NULL;
-
static Ecore_Event_Handler* g_focus_in_handler = NULL;
static Ecore_Event_Handler* g_focus_out_handler = NULL;
static Ecore_Timer* g_w_start_timer = NULL;
-static Ecore_Timer* g_w_tooltip_timer = NULL;
-
-static vc_h g_vc_w = NULL;
static int g_daemon_pid = 0;
vc_current_language_changed_cb callback;
void* lang_user_data;
- vc_widget_client_get_current_lang_changed_cb(g_vc_w, &callback, &lang_user_data);
- if (NULL != callback) {
- vc_widget_client_use_callback(g_vc_w);
- callback(before_lang, current_lang, lang_user_data);
- vc_widget_client_not_use_callback(g_vc_w);
- SLOG(LOG_DEBUG, TAG_VCW, "Language changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCW, "[WARNING] Language changed callback is null");
- }
+ GSList* client_list = vc_widget_client_get_client_list();
+ vc_widget_s *widget_data = NULL;
+ vc_h vc_w = NULL;
+
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ widget_data = g_slist_nth_data(client_list, i);
+ if (NULL != widget_data) {
+ vc_w = widget_data->vc;
+
+ vc_widget_client_get_current_lang_changed_cb(vc_w, &callback, &lang_user_data);
+
+ if (NULL != callback) {
+ vc_widget_client_use_callback(vc_w);
+ callback(before_lang, current_lang, lang_user_data);
+ vc_widget_client_not_use_callback(vc_w);
+ SLOG(LOG_DEBUG, TAG_VCW, "Language changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCW, "[WARNING] Language changed callback is null");
+ }
+ }
+ }
return;
}
-int vc_widget_initialize()
+int vc_widget_initialize(vc_h* vc_w)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Initialize");
- /* check handle */
- if (true == vc_widget_client_is_valid(g_vc_w)) {
- SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Already initialized");
- return VC_ERROR_NONE;
+ if (NULL == vc_w) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Input parameter is NULL");
+ return VC_ERROR_INVALID_PARAMETER;
}
if (0 == vc_widget_client_get_count()) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to open connection");
return VC_ERROR_OPERATION_FAILED;
}
- } else {
- SLOG(LOG_WARN, TAG_VCW, "[WARN] Already initialized");
- return VC_ERROR_NONE;
}
- if (0 != vc_widget_client_create(&g_vc_w)) {
+ if (0 != vc_widget_client_create(vc_w)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create client!!!!!");
return VC_ERROR_OUT_OF_MEMORY;
}
- int ret = vc_config_mgr_initialize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
+ /* TODO - each handle? */
+ int ret = vc_config_mgr_initialize((*vc_w)->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)));
- vc_widget_client_destroy(g_vc_w);
+ vc_widget_client_destroy((*vc_w));
return __vc_widget_convert_config_error_code(ret);
}
- ret = vc_config_mgr_set_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE, __vc_widget_lang_changed_cb);
+ ret = vc_config_mgr_set_lang_cb((*vc_w)->handle, __vc_widget_lang_changed_cb);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to set config changed : %d", ret);
- vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_widget_client_destroy(g_vc_w);
+ vc_config_mgr_finalize((*vc_w)->handle);
+ vc_widget_client_destroy((*vc_w));
return __vc_widget_convert_config_error_code(ret);
}
- ret = vc_db_initialize();
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize DB : %d", ret);
- vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_widget_client_destroy(g_vc_w);
- return ret;
+ if (1 == vc_widget_client_get_count()) {
+ ret = vc_db_initialize();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize DB : %d", ret);
+ vc_config_mgr_finalize((*vc_w)->handle);
+ vc_widget_client_destroy((*vc_w));
+ return ret;
+ }
}
- SLOG(LOG_DEBUG, TAG_VCW, "[Success] pid(%d)", g_vc_w->handle);
+ SLOG(LOG_DEBUG, TAG_VCW, "[Success] uid(%d)", (*vc_w)->handle);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-static void __vc_widget_internal_unprepare()
+static void __vc_widget_internal_unprepare(vc_h vc_w)
{
- int ret = vc_widget_dbus_request_finalize(g_vc_w->handle);
+ int ret = vc_widget_dbus_request_finalize(getpid());
if (0 != ret) {
SLOG(LOG_WARN, TAG_VCW, "[ERROR] Fail to request finalize : %s", __vc_widget_get_error_code(ret));
}
return;
}
-int vc_widget_deinitialize()
+int vc_widget_deinitialize(vc_h vc_w)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Deinitialize");
- if (false == vc_widget_client_is_valid(g_vc_w)) {
+ if (false == vc_widget_client_is_valid(vc_w)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NOT initialized");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
}
vc_state_e state;
- vc_widget_client_get_state(g_vc_w, &state);
+ vc_widget_client_get_state(vc_w, &state);
+ vc_widget_s* widget = widget_get(vc_w);
/* check state */
switch (state) {
case VC_STATE_READY:
- __vc_widget_internal_unprepare();
+ if (1 == vc_widget_client_get_count()) {
+ __vc_widget_internal_unprepare(vc_w);
+ }
/* no break. need to next step*/
case VC_STATE_INITIALIZED:
- if (NULL != g_w_connect_timer) {
+ if (NULL != widget->conn_timer) {
SLOG(LOG_DEBUG, TAG_VCW, "Connect Timer is deleted");
- ecore_timer_del(g_w_connect_timer);
- g_w_connect_timer = NULL;
+ ecore_timer_del(widget->conn_timer);
+ widget->conn_timer = NULL;
}
- vc_config_mgr_unset_lang_cb(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
- vc_config_mgr_finalize(g_vc_w->handle + VC_WIDGET_CONFIG_HANDLE);
+ vc_config_mgr_unset_lang_cb(vc_w->handle);
+ vc_config_mgr_finalize(vc_w->handle);
/* Free resources */
- vc_widget_client_destroy(g_vc_w);
- g_vc_w = NULL;
+ vc_widget_client_destroy(vc_w);
+ vc_w = NULL;
break;
case VC_STATE_NONE:
break;
SLOG(LOG_DEBUG, TAG_VCW, "Success: destroy");
- int ret = vc_db_finalize();
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to finalize DB, ret(%d)", ret);
- }
+ if (0 == vc_widget_client_get_count()) {
+ int ret = vc_db_finalize();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to finalize DB, ret(%d)", ret);
+ }
- if (0 != vc_widget_dbus_close_connection()) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to close connection");
+ if (0 != vc_widget_dbus_close_connection()) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to close connection");
+ }
}
SLOG(LOG_DEBUG, TAG_VCW, "=====");
static Eina_Bool __vc_widget_connect_daemon(void *data)
{
+ vc_h vc_w = (vc_h)data;
+
/* Send hello */
if (0 != vc_widget_dbus_request_hello()) {
return EINA_TRUE;
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Connect daemon");
- g_w_connect_timer = NULL;
+ vc_widget_s* widget = widget_get(vc_w);
+ widget->conn_timer = NULL;
/* request initialization */
int ret = -1;
int service_state = 0;
- ret = vc_widget_dbus_request_initialize(g_vc_w->handle, &service_state, &g_daemon_pid);
+ ret = vc_widget_dbus_request_initialize(getpid(), &service_state, &g_daemon_pid);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
- vc_widget_client_set_error(g_vc_w, VC_ERROR_ENGINE_NOT_FOUND);
- ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
+ vc_widget_client_set_error(vc_w, VC_ERROR_ENGINE_NOT_FOUND);
+ ecore_timer_add(0, __vc_widget_notify_error, vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return EINA_FALSE;
+ } else if (VC_ERROR_INVALID_PARAMETER == ret) {
+ SLOG(LOG_WARN, TAG_VCW, "[WARNING] Invalid Parameter");
} else if (VC_ERROR_NONE != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to initialize : %s", __vc_widget_get_error_code(ret));
- vc_widget_client_set_error(g_vc_w, VC_ERROR_TIMED_OUT);
- ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
+ vc_widget_client_set_error(vc_w, VC_ERROR_TIMED_OUT);
+ ecore_timer_add(0, __vc_widget_notify_error, vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return EINA_FALSE;
}
- vc_widget_client_set_service_state(g_vc_w, (vc_service_state_e)service_state);
+ vc_widget_client_set_service_state(vc_w, (vc_service_state_e)service_state);
- g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
- g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
+ if (NULL == g_focus_in_handler)
+ g_focus_in_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN, __focus_changed_cb, NULL);
+ if (NULL == g_focus_out_handler)
+ g_focus_out_handler = ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT, __focus_changed_cb, NULL);
char appid[255] = {'\0',};
aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
}
}
- vc_widget_client_set_state(g_vc_w, VC_STATE_READY);
- ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
+ vc_widget_client_set_state(vc_w, VC_STATE_READY);
+ ecore_timer_add(0, __vc_widget_notify_state_changed, vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return EINA_FALSE;
}
-int vc_widget_prepare()
+int vc_widget_prepare(vc_h vc_w)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Prepare");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_INVALID_STATE;
}
- g_w_connect_timer = ecore_timer_add(0, __vc_widget_connect_daemon, NULL);
+ vc_widget_s* widget = widget_get(vc_w);
+ widget->conn_timer = ecore_timer_add(0, __vc_widget_connect_daemon, (void*)vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-int vc_widget_unprepare()
+int vc_widget_unprepare(vc_h vc_w)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Unprepare");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_INVALID_STATE;
}
- __vc_widget_internal_unprepare();
+ __vc_widget_internal_unprepare(vc_w);
- vc_widget_client_set_state(g_vc_w, VC_STATE_INITIALIZED);
- ecore_timer_add(0, __vc_widget_notify_state_changed, g_vc_w);
+ vc_widget_client_set_state(vc_w, VC_STATE_INITIALIZED);
+ ecore_timer_add(0, __vc_widget_notify_state_changed, vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-int vc_widget_enable_asr_result(bool enable)
+int vc_widget_enable_asr_result(vc_h vc_w, bool enable)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Enable asr result");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
int ret = -1;
do {
- ret = vc_widget_dbus_request_enable_asr_result(g_vc_w->handle, enable);
+ ret = vc_widget_dbus_request_enable_asr_result(getpid(), enable);
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to enable asr result : %s", __vc_widget_get_error_code(ret));
}
} while (0 != ret);
+ vc_widget_client_set_asr_result_enabled(vc_w, enable);
+
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return ret;
}
-int vc_widget_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
+int vc_widget_foreach_supported_languages(vc_h vc_w, vc_supported_language_cb callback, void* user_data)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Foreach Supported Language");
}
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-int vc_widget_get_current_language(char** language)
+int vc_widget_get_current_language(vc_h vc_w, char** language)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get Current Language");
}
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return ret;
}
-int vc_widget_get_state(vc_state_e* state)
+int vc_widget_get_state(vc_h vc_w, vc_state_e* state)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get State");
}
vc_state_e temp;
- if (0 != vc_widget_client_get_state(g_vc_w, &temp)) {
+ if (0 != vc_widget_client_get_state(vc_w, &temp)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-int vc_widget_get_service_state(vc_service_state_e* state)
+int vc_widget_get_service_state(vc_h vc_w, vc_service_state_e* state)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Get Service State");
}
vc_state_e temp;
- if (0 != vc_widget_client_get_state(g_vc_w, &temp)) {
+ if (0 != vc_widget_client_get_state(vc_w, &temp)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
/* get service state */
vc_service_state_e service_state;
- if (0 != vc_widget_client_get_service_state(g_vc_w, &service_state)) {
+ if (0 != vc_widget_client_get_service_state(vc_w, &service_state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to get service state");
return VC_ERROR_OPERATION_FAILED;
}
return VC_ERROR_NONE;
}
-int vc_widget_set_foreground(bool value)
+int vc_widget_set_foreground(vc_h vc_w, bool value)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Set foreground state");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
return VC_ERROR_NONE;
}
-int vc_widget_is_format_supported(vc_cmd_format_e format, bool* support)
+int vc_widget_is_format_supported(vc_h vc_w, vc_cmd_format_e format, bool* support)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Is command type supported");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not valid");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
} else {
int count = 0;
do {
- ret = vc_widget_dbus_request_start(g_vc_w->handle, stop_by_silence);
+ ret = vc_widget_dbus_request_start(getpid(), stop_by_silence);
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start : %s", __vc_widget_get_error_code(ret));
int count = 0;
do {
- ret = vc_widget_dbus_request_stop(g_vc_w->handle);
+ ret = vc_widget_dbus_request_stop(getpid());
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request stop : %s", __vc_widget_get_error_code(ret));
}
#endif
-int vc_widget_cancel()
+int vc_widget_cancel(vc_h vc_w)
{
SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Cancel Recognition");
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
SLOG(LOG_DEBUG, TAG_VCW, " ");
/* Check service state */
vc_service_state_e service_state = -1;
- vc_widget_client_get_service_state(g_vc_w, &service_state);
+ vc_widget_client_get_service_state(vc_w, &service_state);
if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
SLOG(LOG_DEBUG, TAG_VCW, "=====");
int ret = -1;
do {
- ret = vc_widget_dbus_request_cancel(g_vc_w->handle);
+ ret = vc_widget_dbus_request_cancel(getpid());
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request cancel : %s", __vc_widget_get_error_code(ret));
static Eina_Bool __vc_widget_notify_error(void *data)
{
+ vc_h vc_w = (vc_h)data;
vc_error_cb callback = NULL;
void* user_data;
int reason;
- vc_widget_client_get_error_cb(g_vc_w, &callback, &user_data);
- vc_widget_client_get_error(g_vc_w, &reason);
+ vc_widget_client_get_error_cb(vc_w, &callback, &user_data);
+ vc_widget_client_get_error(vc_w, &reason);
if (NULL != callback) {
- vc_widget_client_use_callback(g_vc_w);
+ vc_widget_client_use_callback(vc_w);
callback(reason, user_data);
- vc_widget_client_not_use_callback(g_vc_w);
+ vc_widget_client_not_use_callback(vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "[Error] callback is called");
} else {
SLOG(LOG_WARN, TAG_VCW, "[WARNING] Error callback is null");
int __vc_widget_cb_error(int reason, int daemon_pid, char* msg)
{
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
- SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Invalid client");
- return -1;
- }
- /* check state */
- if (state != VC_STATE_READY) {
- SLOG(LOG_ERROR, TAG_VCW, "[WARNING] not connected client yet");
- return -1;
- }
+ GSList* client_list = vc_widget_client_get_client_list();
- if (VC_ERROR_SERVICE_RESET == reason) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] VC daemon reset");
+ vc_widget_s *data = NULL;
+ vc_h vc_w = NULL;
- vc_widget_client_set_state(g_vc_w, VC_STATE_INITIALIZED);
- __vc_widget_notify_state_changed(g_vc_w);
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ data = g_slist_nth_data(client_list, i);
+ if (NULL != data) {
+ vc_w = data->vc;
- if (0 != vc_widget_prepare()) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to prepare");
- }
- }
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Invalid client");
+ return -1;
+ }
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCW, "[WARNING] not connected client yet");
+ return -1;
+ }
- vc_widget_client_set_error(g_vc_w, reason);
- ecore_timer_add(0, __vc_widget_notify_error, g_vc_w);
+ if (VC_ERROR_SERVICE_RESET == reason) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] VC daemon reset");
+
+ vc_widget_client_set_state(vc_w, VC_STATE_INITIALIZED);
+ __vc_widget_notify_state_changed(vc_w);
+
+ if (0 != vc_widget_prepare(vc_w)) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to prepare");
+ }
+ }
+
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
+
+ vc_widget_client_set_error(vc_w, reason);
+ ecore_timer_add(0, __vc_widget_notify_error, vc_w);
+ }
+ }
return 0;
}
g_w_start_timer = NULL;
}
+ int ret;
+ ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_WIDGET, ret);
+
vc_widget_send_current_command_list_cb send_command_list_cb = NULL;
void* send_command_user_data = NULL;
vc_cmd_list_h vc_cmd_list = NULL;
- int ret = vc_widget_client_get_send_command_list_cb(g_vc_w, &send_command_list_cb, &send_command_user_data);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Invalid client");
- return -1;
- }
-
- if (NULL != send_command_list_cb) {
- vc_widget_client_use_callback(g_vc_w);
- send_command_list_cb(&vc_cmd_list, send_command_user_data);
- vc_widget_client_not_use_callback(g_vc_w);
- SLOG(LOG_DEBUG, TAG_VCW, "client result callback called");
-
- } else {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] User show tooltip callback is NULL");
- }
+ GSList* client_list = vc_widget_client_get_client_list();
+ vc_widget_s *widget_data = NULL;
+ vc_h vc_w = NULL;
bool widget_command = false;
- if (NULL != vc_cmd_list) {
- vc_cmd_list_s* list = NULL;
- list = (vc_cmd_list_s*)vc_cmd_list;
-
- ret = vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_WIDGET);
- if (0 != ret)
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to delete file, type(%d), ret(%d)", VC_COMMAND_TYPE_WIDGET, ret);
-
- ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_WIDGET, list->list, NULL);
- if (0 == ret) {
- /* widget command is valid */
- widget_command = true;
- SLOG(LOG_DEBUG, TAG_VCW, "Widget command is valid");
- } else {
- ret = VC_ERROR_OPERATION_FAILED;
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ widget_data = g_slist_nth_data(client_list, i);
+ if (NULL != widget_data) {
+ vc_w = widget_data->vc;
+
+ vc_widget_client_get_send_command_list_cb(vc_w, &send_command_list_cb, &send_command_user_data);
+
+ if (NULL != send_command_list_cb) {
+ vc_widget_client_use_callback(vc_w);
+ send_command_list_cb(&vc_cmd_list, send_command_user_data);
+ vc_widget_client_not_use_callback(vc_w);
+ SLOG(LOG_DEBUG, TAG_VCW, "client command list callback called");
+ if (NULL != vc_cmd_list) {
+ vc_cmd_list_s* list = NULL;
+ list = (vc_cmd_list_s*)vc_cmd_list;
+ ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_WIDGET, list->list, NULL);
+ if (0 == ret) {
+ /* widget command is valid */
+ widget_command = true;
+ SLOG(LOG_DEBUG, TAG_VCW, "Widget command is valid");
+ } else {
+ ret = VC_ERROR_OPERATION_FAILED;
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to save command group : %s", __vc_widget_get_error_code(ret));
+ }
+ }
+ } else {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] User show tooltip callback is NULL");
+ }
}
}
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] command list (%d)", g_slist_length(((vc_cmd_list_s*)vc_cmd_list)->list));
+
ret = -1;
- int count = 0;
+ count = 0;
while (0 != ret) {
- ret = vc_widget_dbus_request_start_recording(g_vc_w->handle, widget_command);
+ ret = vc_widget_dbus_request_start_recording(getpid(), widget_command);
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request start recording to daemon : %s", __vc_widget_get_error_code(ret));
static Eina_Bool __vc_widget_notify_tooltip(void *data)
{
- if (NULL != g_w_tooltip_timer) {
- ecore_timer_del(g_w_tooltip_timer);
- g_w_tooltip_timer = NULL;
- }
+ bool show = (bool)data;
vc_widget_show_tooltip_cb callback;
void* user_data;
- bool show;
- vc_widget_client_get_show_tooltip_cb(g_vc_w, &callback, &user_data);
- vc_widget_client_get_show_tooltip(g_vc_w, &show);
+ GSList* client_list = vc_widget_client_get_client_list();
- if (NULL != callback) {
- vc_widget_client_use_callback(g_vc_w);
- callback(show, user_data);
- vc_widget_client_not_use_callback(g_vc_w);
- SLOG(LOG_DEBUG, TAG_VCW, "client result callback called");
- } else {
- SLOG(LOG_WARN, TAG_VCW, "[WARNING] Show tooltip callback is NULL");
+ vc_widget_s *widget_data = NULL;
+ vc_h vc_w = NULL;
+
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ widget_data = g_slist_nth_data(client_list, i);
+ if (NULL != widget_data) {
+ vc_w = widget_data->vc;
+
+ vc_widget_client_set_show_tooltip(vc_w, show);
+ vc_widget_client_get_show_tooltip_cb(vc_w, &callback, &user_data);
+ vc_widget_client_get_show_tooltip(vc_w, &show);
+
+ if (NULL != callback) {
+ vc_widget_client_use_callback(vc_w);
+ callback(show, user_data);
+ vc_widget_client_not_use_callback(vc_w);
+ SLOG(LOG_DEBUG, TAG_VCW, "client show tooltip callback called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCW, "[WARNING] Show tooltip callback is NULL");
+ }
+ }
}
if (true == show) {
void __vc_widget_cb_show_tooltip(int pid, bool show)
{
- if (0 != vc_widget_client_get_handle(pid, &g_vc_w)) {
- SLOG(LOG_ERROR, TAG_VCW, "Handle is not valid : pid(%d)", pid);
- return;
- }
-
- vc_widget_client_set_show_tooltip(g_vc_w, show);
- g_w_tooltip_timer = ecore_timer_add(0, __vc_widget_notify_tooltip, NULL);
-
- return;
+ ecore_timer_add(0, __vc_widget_notify_tooltip, (void*)show);
}
static Eina_Bool __vc_widget_notify_result(void *data)
char* temp_text;
int event;
vc_cmd_list_h vc_cmd_list = NULL;
-
- vc_result_cb callback = NULL;
- void* user_data = NULL;
-
- vc_widget_client_get_result_cb(g_vc_w, &callback, &user_data);
- if (NULL == callback) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
- return EINA_FALSE;
- }
-
if (0 != vc_cmd_list_create(&vc_cmd_list)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create command list");
return EINA_FALSE;
vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
- SLOG(LOG_INFO, TAG_VCW, "Result info : result text(%s) event(%d)", temp_text, event);
+ SLOG(LOG_DEBUG, TAG_VCW, "Result info : result text(%s) event(%d)", temp_text, event);
+
+ vc_result_cb callback = NULL;
+ void* user_data = NULL;
+
+ GSList* client_list = vc_widget_client_get_client_list();
+
+ vc_widget_s *widget_data = NULL;
+ vc_h vc_w = NULL;
+
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ widget_data = g_slist_nth_data(client_list, i);
+ if (NULL != widget_data) {
+ vc_w = widget_data->vc;
+ vc_widget_client_get_result_cb(vc_w, &callback, &user_data);
+ if (NULL == callback) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
+ return EINA_FALSE;
+ }
- vc_cmd_print_list(vc_cmd_list);
+ vc_cmd_print_list(vc_cmd_list);
- vc_widget_client_use_callback(g_vc_w);
- callback(event, vc_cmd_list, temp_text, user_data);
- vc_widget_client_not_use_callback(g_vc_w);
+ vc_widget_client_use_callback(vc_w);
+ callback(event, vc_cmd_list, temp_text, user_data);
+ vc_widget_client_not_use_callback(vc_w);
- SLOG(LOG_INFO, TAG_VCW, "Widget result callback called");
+ SLOG(LOG_DEBUG, TAG_VCW, "Widget result callback called");
+ }
+ }
/* Release result */
if (NULL != temp_text) free(temp_text);
char* temp_text;
int event;
vc_cmd_list_h vc_cmd_list = NULL;
-
- vc_asr_result_cb callback = NULL;
- void* user_data = NULL;
-
- vc_widget_client_get_asr_result_cb(g_vc_w, &callback, &user_data);
- if (NULL == callback) {
- SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
- return EINA_FALSE;
- }
-
if (0 != vc_cmd_list_create(&vc_cmd_list)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to create command list");
- return EINA_FALSE;
+ return false;
}
vc_info_parser_get_result(&temp_text, &event, NULL, -1, vc_cmd_list, false);
-
SLOG(LOG_DEBUG, TAG_VCW, "Result info : result text(%s) event(%d)", temp_text, event);
- vc_widget_client_use_callback(g_vc_w);
- bool ret = callback(event, temp_text, user_data);
- vc_widget_client_not_use_callback(g_vc_w);
+ vc_asr_result_cb callback = NULL;
+ void* user_data = NULL;
+
+ GSList* client_list = vc_widget_client_get_client_list();
+
+ vc_widget_s *data = NULL;
+ vc_h vc_w = NULL;
+
+ bool consumed = false;
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ data = g_slist_nth_data(client_list, i);
+ if (NULL != data) {
+ vc_w = data->vc;
+ bool enabled = false;
+ vc_widget_client_get_asr_result_enabled(vc_w, &enabled);
+ if (false == enabled)
+ continue;
+
+ vc_widget_client_get_asr_result_cb(vc_w, &callback, &user_data);
+ if (NULL == callback) {
+ SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Client result callback is NULL");
+ continue;
+ }
+
+ vc_widget_client_use_callback(vc_w);
+ consumed = callback(event, temp_text, user_data);
+ vc_widget_client_not_use_callback(vc_w);
+ if (true == consumed)
+ break;
- SLOG(LOG_DEBUG, TAG_VCW, "Widget asr result callback called");
+ SLOG(LOG_DEBUG, TAG_VCW, "Widget asr result callback called");
+ }
+ }
/* Release result */
if (NULL != temp_text) free(temp_text);
vc_cmd_list_destroy(vc_cmd_list, true);
- return ret;
+ return consumed;
}
static Eina_Bool __vc_widget_notify_state_changed(void *data)
{
+ vc_h vc_w = (vc_h)data;
+
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
+
vc_state_changed_cb changed_callback = NULL;
void* user_data;
- vc_widget_client_get_state_changed_cb(g_vc_w, &changed_callback, &user_data);
+ vc_widget_client_get_state_changed_cb(vc_w, &changed_callback, &user_data);
vc_state_e current_state;
vc_state_e before_state;
- vc_widget_client_get_before_state(g_vc_w, ¤t_state, &before_state);
+ vc_widget_client_get_before_state(vc_w, ¤t_state, &before_state);
if (NULL != changed_callback) {
- vc_widget_client_use_callback(g_vc_w);
+ vc_widget_client_use_callback(vc_w);
changed_callback(before_state, current_state, user_data);
- vc_widget_client_not_use_callback(g_vc_w);
+ vc_widget_client_not_use_callback(vc_w);
SLOG(LOG_DEBUG, TAG_VCW, "State changed callback is called");
} else {
SLOG(LOG_WARN, TAG_VCW, "[WARNING] State changed callback is null");
return EINA_FALSE;
}
-int vc_widget_set_result_cb(vc_result_cb callback, void* user_data)
+int vc_widget_set_result_cb(vc_h vc_w, vc_result_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_result_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_result_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_result_cb()
+int vc_widget_unset_result_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_result_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_result_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_show_tooltip_cb(vc_widget_show_tooltip_cb callback, void* user_data)
+int vc_widget_set_show_tooltip_cb(vc_h vc_w, vc_widget_show_tooltip_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_show_tooltip_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_show_tooltip_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_show_tooltip_cb()
+int vc_widget_unset_show_tooltip_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_show_tooltip_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_show_tooltip_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_send_current_command_list_cb(vc_widget_send_current_command_list_cb callback, void* user_data)
+int vc_widget_set_send_current_command_list_cb(vc_h vc_w, vc_widget_send_current_command_list_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_send_command_list_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_send_command_list_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_send_current_command_list_cb()
+int vc_widget_unset_send_current_command_list_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_send_command_list_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_send_command_list_cb(vc_w, NULL, NULL);
return 0;
}
int __vc_widget_cb_service_state(int state)
{
- vc_service_state_e current_state = (vc_service_state_e)state;
- vc_service_state_e before_state;
- vc_widget_client_get_service_state(g_vc_w, &before_state);
+ GSList* client_list = vc_widget_client_get_client_list();
- if (current_state == before_state) {
- return 0;
- }
+ vc_widget_s *data = NULL;
+ vc_h vc_w = NULL;
- SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
+ int count = g_slist_length(client_list);
+ int i;
+ for (i = 0; i < count; i++) {
+ data = g_slist_nth_data(client_list, i);
+ if (NULL != data) {
+ vc_w = data->vc;
- /* Save service state */
- vc_widget_client_set_service_state(g_vc_w, current_state);
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_widget_client_get_service_state(vc_w, &before_state);
- vc_service_state_changed_cb callback = NULL;
- void* service_user_data = NULL;
- vc_widget_client_get_service_state_changed_cb(g_vc_w, &callback, &service_user_data);
+ if (current_state == before_state) {
+ continue;
+ }
- if (NULL != callback) {
- vc_widget_client_use_callback(g_vc_w);
- callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
- vc_widget_client_not_use_callback(g_vc_w);
- SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCW, "[WARNING] Service state changed callback is null");
+ SLOG(LOG_DEBUG, TAG_VCW, "Service State changed : Before(%d) Current(%d)",
+ before_state, current_state);
+
+ /* Save service state */
+ vc_widget_client_set_service_state(vc_w, current_state);
+
+ vc_service_state_changed_cb callback = NULL;
+ void* service_user_data = NULL;
+ vc_widget_client_get_service_state_changed_cb(vc_w, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_widget_client_use_callback(vc_w);
+ callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
+ vc_widget_client_not_use_callback(vc_w);
+ SLOG(LOG_DEBUG, TAG_VCW, "Service state changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCW, "[WARNING] Service state changed callback is null");
+ }
+ }
}
return 0;
}
-int vc_widget_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
+int vc_widget_set_service_state_changed_cb(vc_h vc_w, vc_service_state_changed_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_service_state_changed_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_service_state_changed_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_service_state_changed_cb()
+int vc_widget_unset_service_state_changed_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_service_state_changed_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_service_state_changed_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
+int vc_widget_set_state_changed_cb(vc_h vc_w, vc_state_changed_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_state_changed_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_state_changed_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_state_changed_cb()
+int vc_widget_unset_state_changed_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_state_changed_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_state_changed_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_asr_result_cb(vc_asr_result_cb callback, void* user_data)
+int vc_widget_set_asr_result_cb(vc_h vc_w, vc_asr_result_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_asr_result_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_asr_result_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_asr_result_cb()
+int vc_widget_unset_asr_result_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_asr_result_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_asr_result_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
+int vc_widget_set_current_language_changed_cb(vc_h vc_w, vc_current_language_changed_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_current_lang_changed_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_current_lang_changed_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_current_language_changed_cb()
+int vc_widget_unset_current_language_changed_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_current_lang_changed_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_current_lang_changed_cb(vc_w, NULL, NULL);
return 0;
}
-int vc_widget_set_error_cb(vc_error_cb callback, void* user_data)
+int vc_widget_set_error_cb(vc_h vc_w, vc_error_cb callback, void* user_data)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
if (NULL == callback)
return VC_ERROR_INVALID_PARAMETER;
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_error_cb(g_vc_w, callback, user_data);
+ vc_widget_client_set_error_cb(vc_w, callback, user_data);
return 0;
}
-int vc_widget_unset_error_cb()
+int vc_widget_unset_error_cb(vc_h vc_w)
{
+ SLOG(LOG_DEBUG, TAG_VCW, "[CHECK] uid (%d)", vc_w->handle);
vc_state_e state;
- if (0 != vc_widget_client_get_state(g_vc_w, &state)) {
+ if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available");
return VC_ERROR_INVALID_STATE;
}
return VC_ERROR_INVALID_STATE;
}
- vc_widget_client_set_error_cb(g_vc_w, NULL, NULL);
+ vc_widget_client_set_error_cb(vc_w, NULL, NULL);
return 0;
}
projects / platform / core / uifw / voice-control.git / commitdiff