From: Kwangyoun Kim Date: Thu, 22 Dec 2016 08:10:12 +0000 (-0800) Subject: Add internal method for asr result X-Git-Tag: accepted/tizen/common/20170117.174615~8^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6558d63c58523b4d16c3b2c3e72481301c1774a5;p=platform%2Fcore%2Fuifw%2Fvoice-control.git Add internal method for asr result This reverts commit a54acbf16b441a041280630fc32295d8a4355fae. Change-Id: Ia836be7836a0f228577fea2dd66ed3ea16d342df (cherry picked from commit f1a57c169d24867fced57deeef6f33f885db658f) --- diff --git a/client/vc_widget.c b/client/vc_widget.c index ff34a07..6212288 100644 --- a/client/vc_widget.c +++ b/client/vc_widget.c @@ -25,6 +25,7 @@ #include "vc_widget_dbus.h" #include "voice_control_command.h" #include "voice_control_command_expand.h" +#include "voice_control_internal.h" #include "voice_control_widget.h" @@ -384,6 +385,53 @@ int vc_widget_unprepare() return VC_ERROR_NONE; } +int vc_widget_enable_asr_result(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)) { + 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; + } + + /* check state */ + if (state != VC_STATE_READY) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'READY'"); + SLOG(LOG_DEBUG, TAG_VCW, "====="); + SLOG(LOG_DEBUG, TAG_VCW, " "); + return VC_ERROR_INVALID_STATE; + } + + int count = 0; + int ret = -1; + + do { + ret = vc_widget_dbus_request_enable_asr_result(g_vc_w->handle, 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)); + break; + } else { + SLOG(LOG_WARN, TAG_VCW, "[WARNING] retry to enable asr result : %s", __vc_widget_get_error_code(ret)); + usleep(10000); + count++; + if (VC_RETRY_COUNT == count) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to request"); + break; + } + } + } + } while (0 != ret); + + 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) { SLOG(LOG_DEBUG, TAG_VCW, "===== [Widget] Foreach Supported Language"); @@ -1042,6 +1090,44 @@ void __vc_widget_cb_result() return; } +bool __vc_widget_cb_asr_result() +{ + 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; + } + + 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); + + 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; +} + static Eina_Bool __vc_widget_notify_state_changed(void *data) { vc_state_changed_cb changed_callback = NULL; @@ -1296,6 +1382,47 @@ int vc_widget_unset_state_changed_cb() return 0; } +int vc_widget_set_asr_result_cb(vc_asr_result_cb callback, void* user_data) +{ + if (NULL == callback) + return VC_ERROR_INVALID_PARAMETER; + + vc_state_e state; + if (0 != vc_widget_client_get_state(g_vc_w, &state)) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available"); + return VC_ERROR_INVALID_STATE; + } + + /* check state */ + if (state != VC_STATE_INITIALIZED) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'"); + return VC_ERROR_INVALID_STATE; + } + + vc_widget_client_set_asr_result_cb(g_vc_w, callback, user_data); + + return 0; +} + +int vc_widget_unset_asr_result_cb() +{ + vc_state_e state; + if (0 != vc_widget_client_get_state(g_vc_w, &state)) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] A handle is not available"); + return VC_ERROR_INVALID_STATE; + } + + /* check state */ + if (state != VC_STATE_INITIALIZED) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Invalid State: Current state is not 'Initialized'"); + return VC_ERROR_INVALID_STATE; + } + + vc_widget_client_set_asr_result_cb(g_vc_w, NULL, NULL); + + return 0; +} + int vc_widget_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data) { if (NULL == callback) diff --git a/client/vc_widget_client.c b/client/vc_widget_client.c index 2bea424..d32c23d 100644 --- a/client/vc_widget_client.c +++ b/client/vc_widget_client.c @@ -30,6 +30,8 @@ typedef struct { vc_result_cb result_cb; void* result_user_data; + vc_asr_result_cb asr_result_cb; + void* asr_result_user_data; vc_error_cb error_cb; void* error_user_data; vc_service_state_changed_cb service_state_changed_cb; @@ -119,6 +121,8 @@ int vc_widget_client_create(vc_h* vc) widget->result_cb = NULL; widget->result_user_data = NULL; + widget->asr_result_cb = NULL; + widget->asr_result_user_data = NULL; widget->service_state_changed_cb = NULL; widget->service_state_changed_user_data = NULL; widget->state_changed_cb = NULL; @@ -262,6 +266,34 @@ int vc_widget_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_ return 0; } +int vc_widget_client_set_asr_result_cb(vc_h vc, vc_asr_result_cb callback, void* user_data) +{ + vc_widget_s* widget = __widget_get(vc); + + /* check handle */ + if (NULL == widget) + return VC_ERROR_INVALID_PARAMETER; + + widget->asr_result_cb = callback; + widget->asr_result_user_data = user_data; + + return 0; +} + +int vc_widget_client_get_asr_result_cb(vc_h vc, vc_asr_result_cb* callback, void** user_data) +{ + vc_widget_s* widget = __widget_get(vc); + + /* check handle */ + if (NULL == widget) + return VC_ERROR_INVALID_PARAMETER; + + *callback = widget->asr_result_cb; + *user_data = widget->asr_result_user_data; + + 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); diff --git a/client/vc_widget_client.h b/client/vc_widget_client.h index 12a2a85..ca2dc90 100644 --- a/client/vc_widget_client.h +++ b/client/vc_widget_client.h @@ -19,6 +19,7 @@ #define __VC_WIDGET_CLIENT_H_ #include "voice_control_common.h" +#include "voice_control_internal.h" #include "voice_control_widget.h" #ifdef __cplusplus @@ -45,6 +46,10 @@ int vc_widget_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_da int vc_widget_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data); +int vc_widget_client_set_asr_result_cb(vc_h vc, vc_asr_result_cb callback, void* user_data); + +int vc_widget_client_get_asr_result_cb(vc_h vc, vc_asr_result_cb* callback, void** user_data); + int vc_widget_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data); int vc_widget_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data); diff --git a/client/vc_widget_dbus.c b/client/vc_widget_dbus.c index d491393..8ed3ff4 100644 --- a/client/vc_widget_dbus.c +++ b/client/vc_widget_dbus.c @@ -33,6 +33,8 @@ extern void __vc_widget_cb_show_tooltip(int pid, bool show); extern void __vc_widget_cb_result(); +extern bool __vc_widget_cb_asr_result(); + extern int __vc_widget_cb_service_state(int state); @@ -166,6 +168,33 @@ static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd } /* VCD_WIDGET_METHOD_RESULT */ + else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_ASR_RESULT)) { + SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget asr result"); + int ret = 0; + if (false == __vc_widget_cb_asr_result()) + ret = 0; + else + ret = 1; + + DBusMessage* reply = dbus_message_new_method_return(msg); + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID); + if (!dbus_connection_send(g_w_conn_listener, reply, NULL)) + SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get asr result : fail to send reply"); + else + SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget get asr result"); + + dbus_connection_flush(g_w_conn_listener); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget asr get result : fail to create reply message"); + } + + SLOG(LOG_DEBUG, TAG_VCW, "====="); + SLOG(LOG_DEBUG, TAG_VCW, " "); + + } /* VCD_WIDGET_METHOD_ASR_RESULT */ + else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_ERROR)) { SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget error"); int reason; @@ -696,6 +725,73 @@ int vc_widget_dbus_set_foreground(int pid, bool value) return 0; } +int vc_widget_dbus_request_enable_asr_result(int pid, bool enable) +{ + DBusMessage* msg; + + /* create a signal & check for errors */ + msg = dbus_message_new_method_call( + VC_SERVER_SERVICE_NAME, + VC_SERVER_SERVICE_OBJECT_PATH, + VC_SERVER_SERVICE_INTERFACE, + VC_WIDGET_METHOD_ENABLE_ASR_RESULT); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget enable asr result : Fail to make message "); + return VC_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget enable asr result : pid(%d), enable(%d)", pid, enable); + } + + DBusMessageIter args; + dbus_message_iter_init_append(msg, &args); + + /* Append result*/ + int temp; + if (false == enable) temp = 0; + else temp = 1; + dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid)); + dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp)); + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + int result = VC_ERROR_OPERATION_FAILED; + + result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err); + dbus_message_unref(msg); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VC_ERROR_OPERATION_FAILED; + } + dbus_message_unref(result_msg); + + if (0 == result) { + SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget enable asr result : result = %d", result); + } else { + SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget enable asr result : result = %d", result); + } + } else { + SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL"); + vc_widget_dbus_reconnect(); + result = VC_ERROR_TIMED_OUT; + } + + return result; +} int vc_widget_dbus_request_start(int pid, int silence) { diff --git a/client/vc_widget_dbus.h b/client/vc_widget_dbus.h index fe995c5..01fba7a 100644 --- a/client/vc_widget_dbus.h +++ b/client/vc_widget_dbus.h @@ -38,6 +38,7 @@ int vc_widget_dbus_request_start_recording(int pid, bool command); int vc_widget_dbus_set_foreground(int pid, bool value); +int vc_widget_dbus_request_enable_asr_result(int pid, bool enable); int vc_widget_dbus_request_start(int pid, int silence); diff --git a/common/vc_defs.h b/common/vc_defs.h index 5859338..095ba66 100644 --- a/common/vc_defs.h +++ b/common/vc_defs.h @@ -98,11 +98,14 @@ extern "C" { #define VC_WIDGET_METHOD_START_RECORDING "vc_widget_method_start_recording" +#define VC_WIDGET_METHOD_ENABLE_ASR_RESULT "vc_widget_method_enable_asr_result" + #define VC_WIDGET_METHOD_START "vc_widget_method_start" #define VC_WIDGET_METHOD_STOP "vc_widget_method_stop" #define VC_WIDGET_METHOD_CANCEL "vc_widget_method_cancel" #define VCD_WIDGET_METHOD_RESULT "vcd_widget_method_result" +#define VCD_WIDGET_METHOD_ASR_RESULT "vcd_widget_method_asr_result" #define VCD_WIDGET_METHOD_ERROR "vcd_widget_method_error" #define VCD_WIDGET_METHOD_HELLO "vcd_widget_method_hello" #define VCD_WIDGET_METHOD_SHOW_TOOLTIP "vcd_widget_method_show_tooltip" diff --git a/include/voice_control_internal.h b/include/voice_control_internal.h index 4935a91..8465e9e 100644 --- a/include/voice_control_internal.h +++ b/include/voice_control_internal.h @@ -19,7 +19,6 @@ #define __VOICE_CONTROL_INTERNAL_H__ #include -#include #ifdef __cplusplus @@ -28,6 +27,22 @@ extern "C" #endif /** +* @brief Called when client gets the asr recognition result from vc-daemon. +* +* @param[in] event The result event +* @param[in] result ASR text +* @param[in] user_data The user data passed from the callback registration function +* +* @return @c true when asr result is consumed \n @c false to propagate. +* +* @pre An application registers callback function using vc_mgr_set_pre_result_cb(). +* +* @see vc_widget_set_asr_result_cb() +* @see vc_widget_unset_asr_result_cb() +*/ +typedef bool (*vc_asr_result_cb)(vc_result_event_e event, const char* result, void *user_data); + +/** * @brief Sets command list from file. * @since_tizen 3.0 * @privlevel public diff --git a/include/voice_control_widget.h b/include/voice_control_widget.h old mode 100755 new mode 100644 index 2f8ca7a..03b6c89 --- a/include/voice_control_widget.h +++ b/include/voice_control_widget.h @@ -21,6 +21,7 @@ #include #include #include +#include /** @@ -515,6 +516,57 @@ int vc_widget_set_error_cb(vc_error_cb callback, void* user_data); */ int vc_widget_unset_error_cb(); +/** + * @brief Sets option for obtain ASR result as dictation via result callback. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/recorder + * + * @param[in] enable enable to get asr result + * + * @return 0 on success, otherwise a negative error value + * @retval #VC_ERROR_NONE Successful + * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #VC_ERROR_INVALID_STATE Invalid state + * @retval #VC_ERROR_PERMISSION_DENIED Permission denied + * @retval #VC_ERROR_NOT_SUPPORTED Not supported + * + * @pre The state should be #VC_STATE_READY. + * + */ +int vc_widget_enable_asr_result(bool enable); + +/** +* @brief Registers a callback function for an asr result. +* +* @param[in] callback Callback function to register +* @param[in] user_data The user data to be passed to the callback function +* +* @return 0 on success, otherwise a negative error value +* @retval #VC_ERROR_NONE Successful +* @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter +* @retval #VC_ERROR_INVALID_STATE Invalid state +* +* @pre The state should be #VC_STATE_INITIALIZED. +* +* @see vc_asr_result_cb() +* @see vc_widget_enable_asr_result() +* @see vc_widget_unset_asr_result_cb() +*/ +int vc_widget_set_asr_result_cb(vc_asr_result_cb callback, void* user_data); + +/** +* @brief Unregisters the callback function. +* +* @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 be #VC_STATE_INITIALIZED. +* +* @see vc_widget_set_asr_result_cb() +*/ +int vc_widget_unset_asr_result_cb(); #ifdef __cplusplus } diff --git a/packaging/voice-control.spec b/packaging/voice-control.spec index a1e54b0..be8e8a0 100644 --- a/packaging/voice-control.spec +++ b/packaging/voice-control.spec @@ -148,6 +148,7 @@ mkdir -p %{_libdir}/voice/vc %{_includedir}/voice_control_common.h %{_includedir}/voice_control_key_defines.h %{_includedir}/voice_control_command_expand.h +%{_includedir}/voice_control_internal.h %files manager-devel %defattr(-,root,root,-) diff --git a/server/vcd_client_data.c b/server/vcd_client_data.c index 70f3749..5e0253d 100644 --- a/server/vcd_client_data.c +++ b/server/vcd_client_data.c @@ -1349,3 +1349,31 @@ int vcd_client_widget_unset_command(int pid) return 0; } + +int vcd_client_widget_set_asr_result_enabled(int pid, bool enable) +{ + widget_info_s *info = NULL; + info = __widget_get_element(pid); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT valid", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + info->asr_result_enabled = enable; + + return 0; +} + +int vcd_client_widget_get_asr_result_enabled(int pid, bool* enable) +{ + widget_info_s *info = NULL; + info = __widget_get_element(pid); + if (NULL == info) { + SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT valid", pid); + return VCD_ERROR_INVALID_PARAMETER; + } + + *enable = info->asr_result_enabled; + + return 0; +} \ No newline at end of file diff --git a/server/vcd_client_data.h b/server/vcd_client_data.h index 62f3120..d84ba3b 100644 --- a/server/vcd_client_data.h +++ b/server/vcd_client_data.h @@ -62,6 +62,7 @@ typedef struct { typedef struct { int pid; bool widget_cmd; + bool asr_result_enabled; } widget_info_s; typedef enum { @@ -168,6 +169,9 @@ int vcd_client_widget_set_command(int pid); int vcd_client_widget_unset_command(int pid); +int vcd_client_widget_set_asr_result_enabled(int pid, bool enable); + +int vcd_client_widget_get_asr_result_enabled(int pid, bool* enable); #ifdef __cplusplus } diff --git a/server/vcd_dbus.c b/server/vcd_dbus.c index 0d33cb3..7d0f348 100644 --- a/server/vcd_dbus.c +++ b/server/vcd_dbus.c @@ -311,6 +311,65 @@ int vcdc_send_result(int pid, int manager_pid, int cmd_type) return 0; } +int vcdc_send_asr_result(int pid, int cmd_type, bool* is_consumed) +{ + if (0 != __dbus_check()) { + return VCD_ERROR_OPERATION_FAILED; + } + + DBusMessage* msg = NULL; + + SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type); + + switch (cmd_type) { + case VC_COMMAND_TYPE_WIDGET: + msg = __get_message(pid, VCD_WIDGET_METHOD_ASR_RESULT, VCD_CLIENT_TYPE_WIDGET); + break; + default: + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type); + return VCD_ERROR_INVALID_PARAMETER; + } + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL"); + return VCD_ERROR_OUT_OF_MEMORY; + } + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + + int result = 0; + 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)) { + SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", err.message); + dbus_error_free(&err); + } + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, + DBUS_TYPE_INT32, &result, + DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "<<<< Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = VCD_ERROR_OPERATION_FAILED; + } + + dbus_message_unref(result_msg); + SLOG(LOG_DEBUG, TAG_VCD, "<<<< vc send asr result : result = %d", result); + *is_consumed = result; + return VCD_ERROR_NONE; + } else { + SLOG(LOG_ERROR, TAG_VCD, "<<<< Result message is NULL "); + return VCD_ERROR_OPERATION_FAILED; + } +} + int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result) { if (0 != __dbus_check()) { @@ -834,6 +893,9 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL)) vcd_dbus_server_widget_cancel(g_conn_listener, msg); + else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_ENABLE_ASR_RESULT)) + vcd_dbus_server_widget_enable_asr_result(g_conn_listener, msg); + else { SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid"); dbus_message_unref(msg); diff --git a/server/vcd_dbus.h b/server/vcd_dbus.h index a075a25..5c4e357 100644 --- a/server/vcd_dbus.h +++ b/server/vcd_dbus.h @@ -44,6 +44,8 @@ int vcdc_send_set_volume(int manger_pid, float volume); int vcdc_send_result(int pid, int manager_pid, int cmd_type); +int vcdc_send_asr_result(int pid, int cmd_type, bool* is_consumed); + int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result); int vcdc_send_result_to_manager(int manger_pid, int result_type); diff --git a/server/vcd_dbus_server.c b/server/vcd_dbus_server.c index e263cdd..4a19a0b 100644 --- a/server/vcd_dbus_server.c +++ b/server/vcd_dbus_server.c @@ -1826,3 +1826,51 @@ int vcd_dbus_server_widget_cancel(DBusConnection* conn, DBusMessage* msg) return 0; } +int vcd_dbus_server_widget_enable_asr_result(DBusConnection* conn, DBusMessage* msg) +{ + DBusError err; + dbus_error_init(&err); + + int pid; + int enable; + int ret = VCD_ERROR_OPERATION_FAILED; + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &enable, DBUS_TYPE_INVALID); + + SLOG(LOG_DEBUG, TAG_VCD, ">>>>> VCD widget enable asr result"); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd widget enable asr result : get arguments error (%s)", err.message); + dbus_error_free(&err); + ret = VCD_ERROR_OPERATION_FAILED; + } else { + SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget enable asr result : pid(%d) enable(%d)", pid, enable); + ret = vcd_server_widget_enable_asr_result(pid, enable); + } + + DBusMessage* reply; + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + 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); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret); + } + + if (!dbus_connection_send(conn, reply, NULL)) { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Out Of Memory!"); + } + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Fail to create reply message!!"); + } + + SLOG(LOG_DEBUG, TAG_VCD, "<<<<<"); + SLOG(LOG_DEBUG, TAG_VCD, " "); + + return 0; +} \ No newline at end of file diff --git a/server/vcd_dbus_server.h b/server/vcd_dbus_server.h index b29fc5d..4a7fc7b 100644 --- a/server/vcd_dbus_server.h +++ b/server/vcd_dbus_server.h @@ -108,6 +108,7 @@ int vcd_dbus_server_widget_stop(DBusConnection* conn, DBusMessage* msg); int vcd_dbus_server_widget_cancel(DBusConnection* conn, DBusMessage* msg); +int vcd_dbus_server_widget_enable_asr_result(DBusConnection* conn, DBusMessage* msg); #ifdef __cplusplus } diff --git a/server/vcd_server.c b/server/vcd_server.c index 112e13b..eeed30e 100644 --- a/server/vcd_server.c +++ b/server/vcd_server.c @@ -488,6 +488,37 @@ static void __vcd_server_result_cb(vcp_result_event_e event, int* result_id, int } } #if 1 + + int pid = vcd_client_widget_get_foreground_pid(); + if (-1 != pid) { + if (NULL != all_result) { + vc_info_parser_set_result(all_result, event, msg, NULL, false); + bool enable = false; + vcd_client_widget_get_asr_result_enabled(pid, &enable); + if (true == enable) { + SLOG(LOG_DEBUG, TAG_VCD, "[Server] Send ASR result to Widget client"); + bool is_consumed = false; + if (0 != vcdc_send_asr_result(pid, VC_COMMAND_TYPE_WIDGET, &is_consumed)) { + SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to send asr result"); + } else { + SLOG(LOG_DEBUG, TAG_VCD, "[Server] ASR result is consumed(%d)", is_consumed); + if (true == is_consumed) { + vcdc_send_show_tooltip(pid, false); + if (-1 != vcd_client_manager_get_pid()) { + /* Manager client is available */ + if (0 != vcdc_send_result_to_manager(vcd_client_manager_get_pid(), VC_RESULT_TYPE_NOTIFICATION)) { + SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result"); + } + } + + vcd_client_manager_set_exclusive(false); + return; + } + } + } + } + } + /* if nlu_result is exist, Add command handle(is_action) into result list */ /* Normal result */ SLOG(LOG_DEBUG, TAG_VCD, "[Server] === Get engine result ==="); @@ -616,11 +647,6 @@ static void __vcd_server_result_cb(vcp_result_event_e event, int* result_id, int int pid = vcd_client_widget_get_foreground_pid(); if (-1 != pid) { - if (NULL != all_result) { - /* Send result text to widget */ - vcdc_send_result(pid, vcd_client_manager_get_pid(), VC_COMMAND_TYPE_WIDGET); - } - SLOG(LOG_DEBUG, TAG_VCD, "[Server] Request tooltip hide"); /* Send to hide tooltip */ vcdc_send_show_tooltip(pid, false); @@ -2228,3 +2254,13 @@ int vcd_server_widget_cancel(int pid) return VCD_ERROR_NONE; } +int vcd_server_widget_enable_asr_result(int pid, bool enable) +{ + int ret; + ret = vcd_client_widget_set_asr_result_enabled(pid, enable); + if (0 != ret) { + SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to enable asr result : %d", ret); + } + + return ret; +} diff --git a/server/vcd_server.h b/server/vcd_server.h index 5166ccb..c8b0284 100644 --- a/server/vcd_server.h +++ b/server/vcd_server.h @@ -116,6 +116,7 @@ int vcd_server_widget_stop(int pid); int vcd_server_widget_cancel(int pid); +int vcd_server_widget_enable_asr_result(int pid, bool enable); #ifdef __cplusplus }