#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"
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");
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;
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)
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;
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;
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);
#define __VC_WIDGET_CLIENT_H_
#include "voice_control_common.h"
+#include "voice_control_internal.h"
#include "voice_control_widget.h"
#ifdef __cplusplus
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);
extern void __vc_widget_cb_result();
+extern bool __vc_widget_cb_asr_result();
+
extern int __vc_widget_cb_service_state(int state);
} /* 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;
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)
{
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);
#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"
#define __VOICE_CONTROL_INTERNAL_H__
#include <tizen.h>
-#include <voice_control.h>
#ifdef __cplusplus
#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
#include <voice_control_command.h>
#include <voice_control_command_expand.h>
#include <voice_control_common.h>
+#include <voice_control_internal.h>
/**
*/
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
}
%{_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,-)
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
typedef struct {
int pid;
bool widget_cmd;
+ bool asr_result_enabled;
} widget_info_s;
typedef enum {
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
}
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()) {
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);
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);
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
int vcd_dbus_server_widget_cancel(DBusConnection* conn, DBusMessage* msg);
+int vcd_dbus_server_widget_enable_asr_result(DBusConnection* conn, DBusMessage* msg);
#ifdef __cplusplus
}
}
}
#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 ===");
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);
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;
+}
int vcd_server_widget_cancel(int pid);
+int vcd_server_widget_enable_asr_result(int pid, bool enable);
#ifdef __cplusplus
}
projects / platform / core / uifw / voice-control.git / commitdiff