dbus_connection_close(g_conn_sender);
dbus_connection_close(g_conn_listener);
+ dbus_connection_unref(g_conn_sender);
+ dbus_connection_unref(g_conn_listener);
+
g_conn_sender = NULL;
g_conn_listener = NULL;
*/
#include <aul.h>
+#include <system_info.h>
#include "vc_info_parser.h"
#include "vc_config_mgr.h"
static float g_volume_db = 0;
+static int g_daemon_pid = 0;
+
+static int g_feature_enabled = -1;
+
static Eina_Bool __vc_mgr_notify_state_changed(void *data);
static Eina_Bool __vc_mgr_notify_error(void *data);
static Eina_Bool __vc_mgr_notify_result(void *data);
return;
}
+static int __vc_mgr_get_feature_enabled()
+{
+ if (0 == g_feature_enabled) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ } else if (-1 == g_feature_enabled) {
+ bool vc_supported = false;
+ bool mic_supported = false;
+ if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
+ if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
+ if (false == vc_supported || false == mic_supported) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
+ g_feature_enabled = 0;
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
+ g_feature_enabled = 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
int vc_mgr_initialize()
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Initialize");
+
+ if (0 != __vc_mgr_get_feature_enabled()) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] not supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
/* check handle */
if (true == vc_mgr_client_is_valid(g_vc_m)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already initialized");
static Eina_Bool __vc_mgr_connect_daemon(void *data)
{
+ /* request initialization */
+ int ret = -1;
+ int service_state = 0;
+ int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
+
+ g_m_connect_timer = NULL;
+
+ ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground, &g_daemon_pid);
+
+ if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
+
+ vc_mgr_client_set_error(g_vc_m, VC_ERROR_ENGINE_NOT_FOUND);
+ ecore_timer_add(0, __vc_mgr_notify_error, g_vc_m);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return EINA_FALSE;
+
+ } else if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Fail to connection. Retry to connect : %s", __vc_mgr_get_error_code(ret));
+ return EINA_TRUE;
+ } else {
+ /* Success to connect */
+ }
+
+ /* Set service state */
+ vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)service_state);
+
+ /* Set foreground */
+ vc_mgr_client_set_foreground(g_vc_m, foreground, true);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
+
+ vc_mgr_client_set_client_state(g_vc_m, VC_STATE_READY);
+
+ vc_state_changed_cb changed_callback = NULL;
+ void* user_data = NULL;
+
+ vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data);
+
+ vc_state_e current_state;
+ vc_state_e before_state;
+
+ vc_mgr_client_get_before_state(g_vc_m, ¤t_state, &before_state);
+
+ if (NULL != changed_callback) {
+ vc_mgr_client_use_callback(g_vc_m);
+ changed_callback(before_state, current_state, user_data);
+ vc_mgr_client_not_use_callback(g_vc_m);
+ SLOG(LOG_DEBUG, TAG_VCM, "State changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return EINA_FALSE;
+}
+
+static Eina_Bool __vc_mgr_prepare_daemon(void *data)
+{
/* Send hello */
if (0 != vc_mgr_dbus_request_hello()) {
return EINA_TRUE;
g_m_connect_timer = NULL;
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
+ g_m_connect_timer = ecore_idler_add(__vc_mgr_connect_daemon, data);
+
+#if 0
/* request initialization */
int ret = -1;
int service_state = 0;
int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground);
+ ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground, &g_daemon_pid);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
-
+#endif
return EINA_FALSE;
}
return VC_ERROR_INVALID_STATE;
}
- g_m_connect_timer = ecore_timer_add(0, __vc_mgr_connect_daemon, NULL);
+ g_m_connect_timer = ecore_timer_add(0, __vc_mgr_prepare_daemon, NULL);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
vc_mgr_client_get_audio_type(g_vc_m, &temp);
+ if (NULL != temp) {
+ free(temp);
+ temp = NULL;
+ }
+
if (NULL == temp) {
/* Not initiallized */
int ret = -1;
return EINA_FALSE;
}
+int vc_mgr_set_nlp_info(const char* info)
+{
+ return 0;
+}
+
+int vc_mgr_get_nlp_info(char** info)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get nlp info");
+
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_PROCESSING) {
+ vc_recognition_mode_e recognition_mode;
+ vc_mgr_get_recognition_mode(&recognition_mode);
+
+ if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continously'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+ }
+
+ int ret = -1;
+ ret = vc_info_parser_get_nlp_info(info);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get nlp_info");
+ }
+
+ if (0 == strncmp(*info, "null", strlen("null"))) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Get nlp info (NULL)");
+ *info = NULL;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+}
+
+int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
+{
+ if (NULL == callback){
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : callback is NULL");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_INITIALIZED) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : Current state is not 'Initialized'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_pre_result_cb(g_vc_m, callback, user_data);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set pre result callback");
+ return 0;
+}
+
+int vc_mgr_unset_pre_result_cb()
+{
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_INITIALIZED) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : Current state is not 'Initialized'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_pre_result_cb(g_vc_m, NULL, NULL);
+
+ return 0;
+}
+
static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
{
char* temp_text = NULL;
return EINA_FALSE;
}
+static Eina_Bool __vc_mgr_notify_pre_result(void *data)
+{
+ vc_mgr_pre_result_cb callback = NULL;
+ void* user_data = NULL;
+ int event = -1;
+ char* pre_result = NULL;
+
+ vc_mgr_client_get_pre_resut_cb(g_vc_m, &callback, &user_data);
+ if (NULL == callback) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client speech detected callback is NULL");
+ return EINA_FALSE;
+ }
+
+ vc_mgr_client_get_pre_result(g_vc_m, &event, &pre_result);
+
+ vc_mgr_client_use_callback(g_vc_m);
+ callback(event, pre_result, user_data);
+ vc_mgr_client_not_use_callback(g_vc_m);
+ SLOG(LOG_DEBUG, TAG_VCM, "Speech detected callback called");
+
+ if (NULL != pre_result) {
+ free(pre_result);
+ }
+
+ vc_mgr_client_unset_pre_result(g_vc_m);
+
+ return EINA_FALSE;
+}
+
+void __vc_mgr_cb_pre_result(int event, const char* pre_result)
+{
+ if (0 != vc_mgr_client_set_pre_result(g_vc_m, event, pre_result)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client speech detected callback is NULL");
+ }
+
+ ecore_timer_add(0, __vc_mgr_notify_pre_result, NULL);
+
+ return;
+}
+
void __vc_mgr_cb_all_result(vc_result_type_e type)
{
if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) {
return EINA_FALSE;
}
-int __vc_mgr_cb_error(int pid, int reason)
+int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg)
{
- if (0 != vc_mgr_client_get_handle(pid, &g_vc_m)) {
- SLOG(LOG_ERROR, TAG_VCM, "Handle is not valid");
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client");
+ return -1;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet");
return -1;
}
+ if ((daemon_pid == g_daemon_pid) && (VC_ERROR_SERVICE_RESET == reason)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[WARNING] This is first initializing, not daemon reset");
+ return -1;
+ }
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
+
+ if (VC_ERROR_SERVICE_RESET == reason) {
+ vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED);
+ __vc_mgr_notify_state_changed(NULL);
+ }
+
vc_mgr_client_set_error(g_vc_m, reason);
__vc_mgr_notify_error(g_vc_m);
vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data);
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set state changed callback");
return 0;
}
vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data);
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set sevice state changed callback");
return 0;
}
vc_mgr_client_set_speech_detected_cb(g_vc_m, callback, user_data);
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set speech detected callback");
return 0;
}
vc_mgr_client_set_current_lang_changed_cb(g_vc_m, callback, user_data);
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set current language changed callback");
return 0;
}
void* speech_detected_user_data;
vc_current_language_changed_cb current_lang_changed_cb;
void* current_lang_changed_user_data;
+ vc_mgr_pre_result_cb pre_result_cb;
+ void* pre_result_user_data;
/* All result */
vc_result_event_e all_result_event;
char* all_result_text;
+ /* Pre result */
+ vc_pre_result_event_e pre_result_event;
+ char* pre_result_text;
+
/* exclusive command flag */
bool exclusive_cmd_option;
client->speech_detected_user_data = NULL;
client->current_lang_changed_cb = NULL;
client->current_lang_changed_user_data = NULL;
+ client->pre_result_cb = NULL;
+ client->pre_result_user_data = NULL;
client->exclusive_cmd_option = false;
client->all_result_event = 0;
client->all_result_text = NULL;
+ client->pre_result_event = 0;
+ client->pre_result_text = NULL;
client->result_event = -1;
client->result_text = NULL;
client->audio_id = NULL;
client->recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
+ client->reason = 0;
+
client->cb_ref_count = 0;
/* Authoriry */
return 0;
}
+int vc_mgr_client_set_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb callback, void* user_data)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->pre_result_cb = callback;
+ client->pre_result_user_data = user_data;
+
+ return 0;
+}
+
+int vc_mgr_client_get_pre_resut_cb(vc_h vc, vc_mgr_pre_result_cb* callback, void** user_data)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *callback = client->pre_result_cb;
+ *user_data = client->pre_result_user_data;
+
+ return 0;
+}
/* set/get option */
int vc_mgr_client_set_service_state(vc_h vc, vc_service_state_e state)
return 0;
}
+int vc_mgr_client_set_pre_result(vc_h vc, int event, const char* pre_result)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->pre_result_event = event;
+
+ if (NULL != client->pre_result_text) {
+ free(client->pre_result_text);
+ }
+ client->pre_result_text = strdup(pre_result);
+
+ return 0;
+}
+
+int vc_mgr_client_get_pre_result(vc_h vc, int* event, char** pre_result)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *event = client->pre_result_event;
+
+ if (NULL != pre_result) {
+ if (NULL != client->pre_result_text) {
+ *pre_result = strdup(client->pre_result_text);
+ } else {
+ *pre_result = NULL;
+ }
+ }
+
+ return 0;
+}
+
+int vc_mgr_client_unset_pre_result(vc_h vc)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->pre_result_event = -1;
+
+ if (NULL != client->pre_result_text) {
+ free(client->pre_result_text);
+ client->pre_result_text = NULL;
+ }
+
+ return 0;
+}
+
int vc_mgr_client_set_audio_type(vc_h vc, const char* audio_id)
{
vc_mgr_client_s* client = __mgr_client_get(vc);
int vc_mgr_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data);
+int vc_mgr_client_set_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb callback, void* user_data);
+
+int vc_mgr_client_get_pre_resut_cb(vc_h vc, vc_mgr_pre_result_cb* callback, void** user_data);
/*
* set/get option
int vc_mgr_client_unset_all_result(vc_h vc);
+int vc_mgr_client_set_pre_result(vc_h vc, int event, const char* pre_result);
+
+int vc_mgr_client_get_pre_result(vc_h vc, int* event, char** pre_result);
+
+int vc_mgr_client_unset_pre_result(vc_h vc);
+
int vc_mgr_client_set_audio_type(vc_h vc, const char* audio_id);
int vc_mgr_client_get_audio_type(vc_h vc, char** audio_id);
static int g_volume_count = 0;
+extern void __vc_mgr_cb_pre_result(int event, const char* pre_result);
extern void __vc_mgr_cb_all_result(vc_result_type_e type);
extern void __vc_mgr_cb_speech_detected();
-extern int __vc_mgr_cb_error(int pid, int reason);
+extern int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg);
extern int __vc_mgr_cb_set_volume(float volume);
} /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
+ else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_PRE_RESULT)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== Get Pre Result");
+ int event;
+ char* pre_result = NULL;
+
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
+
+ if (NULL != pre_result) {
+ __vc_mgr_cb_pre_result(event, pre_result);
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ } /* VCD_MANAGER_METHOD_PRE_RESULT */
+
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
SLOG(LOG_DEBUG, TAG_VCM, "===== Get All Result");
int result_type = 0;
SLOG(LOG_DEBUG, TAG_VCM, " ");
} /* VCC_MANAGER_METHOD_SET_FOREGROUND */
- else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
+ else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
SLOG(LOG_DEBUG, TAG_VCM, "===== Get Error");
- int pid;
int reason;
+ int daemon_pid;
char* err_msg;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INT32, &reason,
+ DBUS_TYPE_INT32, &daemon_pid,
DBUS_TYPE_STRING, &err_msg,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
dbus_error_free(&err);
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
- __vc_mgr_cb_error(pid, reason);
+ }
+ else {
+ SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
+ __vc_mgr_cb_error(reason, daemon_pid, err_msg);
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
dbus_connection_close(g_m_conn_sender);
dbus_connection_close(g_m_conn_listener);
+ dbus_connection_unref(g_m_conn_sender);
+ dbus_connection_unref(g_m_conn_listener);
+
g_m_conn_sender = NULL;
g_m_conn_listener = NULL;
return result;
}
-int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground)
+static int __dbus_restore_daemon()
{
+ int ret = -1;
+ int count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_hello();
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry restore daemon");
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ } else {
+ SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] restore daemon");
+ }
+ }
+ return ret;
+}
+
+int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
msg = dbus_message_new_method_call(
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
if (NULL != result_msg) {
int tmp_service_state = 0;
int tmp_foreground = 0;
+ int tmp_daemon_pid = 0;
dbus_message_get_args(result_msg, &err,
DBUS_TYPE_INT32, &result,
DBUS_TYPE_INT32, &tmp_service_state,
DBUS_TYPE_INT32, &tmp_foreground,
+ DBUS_TYPE_INT32, &tmp_daemon_pid,
DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
if (0 == result) {
*service_state = tmp_service_state;
*foreground = tmp_foreground;
- SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d, foreground = %d",
- result, *service_state, *foreground);
+ *daemon_pid = tmp_daemon_pid;
+ SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d, foreground = %d, daemon_pid = %d",
+ result, *service_state, *foreground, *daemon_pid);
} else {
SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
}
int vc_mgr_dbus_request_finalize(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
msg = dbus_message_new_method_call(
dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_set_command(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
msg = dbus_message_new_method_call(
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_unset_command(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
msg = dbus_message_new_method_call(
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_demandable_client(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
msg = dbus_message_new_method_call(
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_STRING, &(audio_type),
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_set_client_info(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_INT32, &(by),
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_stop(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_cancel(int pid)
{
+ DBusError err;
+ dbus_error_init(&err);
+
+ bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ dbus_error_free(&err);
+ }
+
+ int ret;
+ if (false == exist) {
+ ret = __dbus_restore_daemon();
+ if (VC_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
+ return VC_ERROR_TIMED_OUT;
+ }
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
DBusMessage* msg;
/* create a signal & check for errors */
DBUS_TYPE_INT32, &pid,
DBUS_TYPE_INVALID);
- DBusError err;
- dbus_error_init(&err);
-
DBusMessage* result_msg;
int result = VC_ERROR_OPERATION_FAILED;
int vc_mgr_dbus_request_hello();
-int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground);
+int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid);
int vc_mgr_dbus_request_finalize(int pid);
dbus_connection_close(g_w_conn_sender);
dbus_connection_close(g_w_conn_listener);
+
+ dbus_connection_unref(g_w_conn_sender);
+ dbus_connection_unref(g_w_conn_listener);
g_w_conn_sender = NULL;
g_w_conn_listener = NULL;
}
if (true == __vc_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
- /* stt default language change */
+ /* vc default language change */
char* before_lang = NULL;
if (0 != vc_parser_set_language(candidate_lang)) {
SLOG(LOG_ERROR, vc_config_tag(), "Fail to save default language");
#define VCD_MANAGER_METHOD_HELLO "vcd_manager_method_hello"
#define VCD_MANAGER_METHOD_SPEECH_DETECTED "vcd_manager_method_speech_detected"
#define VCD_MANAGER_METHOD_ALL_RESULT "vcd_manager_method_all_result"
+#define VCD_MANAGER_METHOD_PRE_RESULT "vcd_manager_method_pre_result"
#define VCD_MANAGER_METHOD_RESULT "vcd_manager_method_result"
#define VCD_MANAGER_METHOD_SET_VOLUME "vcd_manager_method_set_volume"
#define VCD_MANAGER_METHOD_SET_SERVICE_STATE "vcd_manager_method_set_service_state"
#define VC_RUNTIME_INFO_CLIENT tzplatform_mkpath(TZ_USER_HOME, "share/.voice/vc/vc-client-info.xml")
+#define VC_RUNTIME_INFO_NLP_INFO tzplatform_mkpath(TZ_USER_HOME, "share/.voice/vc/vc-nlp-info.xml")
+
#define VC_NO_FOREGROUND_PID 0
#define VC_BASE_LANGUAGE "en_US"
#define VC_RETRY_COUNT 5
return 0;
}
+int vc_info_parser_set_nlp_info(const char* nlp_info)
+{
+ if (NULL == nlp_info) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] nlp info is NULL");
+ return -1;
+ }
+
+ remove(VC_RUNTIME_INFO_NLP_INFO);
+
+ FILE* fp = NULL;
+ int write_size = -1;
+
+ fp = fopen(VC_RUNTIME_INFO_NLP_INFO, "w+");
+ if (NULL == fp) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to open file %s", VC_RUNTIME_INFO_NLP_INFO);
+ return -1;
+ }
+
+ /* Write size */
+ fprintf(fp, "size(%d)\n", strlen(nlp_info));
+
+ write_size = fwrite(nlp_info, 1, strlen(nlp_info), fp);
+ fclose(fp);
+
+ if (0 >= write_size) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to write file");
+ return -1;
+ }
+
+ if (0 != __vc_info_parser_set_file_mode(VC_RUNTIME_INFO_NLP_INFO)) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to set file mode - %s", VC_RUNTIME_INFO_NLP_INFO);
+ }
+
+ SLOG(LOG_DEBUG, vc_info_tag(), "[SUCCESS] Write file (%s) size (%d)", VC_RUNTIME_INFO_NLP_INFO, strlen(nlp_info));
+
+ return 0;
+}
+
+int vc_info_parser_get_nlp_info(char** nlp_info)
+{
+ if (NULL == nlp_info) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] nlp info is NULL");
+ return -1;
+ }
+
+ FILE* fp = NULL;
+ int readn = 0;
+
+ fp = fopen(VC_RUNTIME_INFO_NLP_INFO, "r");
+ if (NULL == fp) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Fail to open file %s", VC_RUNTIME_INFO_NLP_INFO);
+ return -1;
+ }
+
+ int ret;
+ ret = fscanf(fp, "size(%d)\n", &readn);
+ if (ret <= 0) {
+ SLOG(LOG_DEBUG, vc_info_tag(), "[ERROR] Fail to get buffer size");
+ fclose(fp);
+ return -1;
+ }
+
+ SLOG(LOG_DEBUG, vc_info_tag(), "[DEBUG] buffer size (%d)", readn);
+ if (10000000 < readn || 0 > readn) {
+ SLOG(LOG_DEBUG, vc_info_tag(), "[ERROR] Invalid buffer size");
+ fclose(fp);
+ return -1;
+ }
+ int tmp_readn = readn + 10;
+
+ *nlp_info = (char*)calloc(tmp_readn, sizeof(char));
+ if (NULL == *nlp_info) {
+ SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Out of memory");
+ fclose(fp);
+ return -1;
+ }
+
+ readn = fread(*nlp_info, 1, readn, fp);
+ fclose(fp);
+
+ SLOG(LOG_DEBUG, vc_info_tag(), "[DEBUG] Read buffer (%d)", readn);
+
+ /* remove(VC_RUNTIME_INFO_NLP_INFO); */
+
+ return 0;
+}
+
+
int vc_info_parser_unset_result(bool exclusive)
{
if (false == exclusive) {
int vc_info_parser_get_result(char** result_text, int* event, char** result_message, int pid, vc_cmd_list_h vc_cmd_list, bool exclusive);
+int vc_info_parser_set_nlp_info(const char* nlp_info);
+
+int vc_info_parser_get_nlp_info(char** nlp_info);
+
int vc_info_parser_unset_result(bool exclusive);
int vc_info_parser_get_result_pid_list(GSList** pid_list);
VC_ERROR_OPERATION_FAILED = TIZEN_ERROR_VOICE_CONTROL | 0x014, /**< Operation failed */
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_EMPTY = TIZEN_ERROR_VOICE_CONTROL | 0x017, /**< List empty */
+ VC_ERROR_SERVICE_RESET = TIZEN_ERROR_VOICE_CONTROL | 0x018 /**< Service Damon reset */
} vc_error_e;
/**
#define VC_AUDIO_TYPE_BLUETOOTH "VC_AUDIO_ID_BLUETOOTH" /**< Bluetooth audio type */
/**
+ * @brief Defines of audio-in type.
+*/
+#define VC_AUDIO_TYPE_MSF "VC_AUDIO_ID_MSF" /**< MSF (wifi) audio type */
+
+/**
* @brief Definitions for foreground command type.
* @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
*/
* @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);
+ const char* result, const char* msg, void *user_data);
+
+typedef enum {
+ VC_PRE_RESULT_EVENT_FINAL_RESULT = 0,
+ VC_PRE_RESULT_EVENT_PARTIAL_RESULT,
+ VC_PRE_RESULT_EVENT_ERROR
+}vc_pre_result_event_e;
+
+// support pre-result
+typedef bool(*vc_mgr_pre_result_cb)(vc_pre_result_event_e event, const char* result, void *user_data);
/**
* @brief Called when user speaking is detected.
int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list);
+int vc_mgr_set_nlp_info(const char* info);
+
+int vc_mgr_get_nlp_info(char** info);
+
+int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data);
+
+int vc_mgr_unset_pre_result_cb();
+
/**
* @brief Registers a callback function for getting recognition result.
*
*
* @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);
+
+typedef enum {
+ VCP_PRE_RESULT_EVENT_FINAL_RESULT = 0,
+ VCP_PRE_RESULT_EVENT_PARTIAL_RESULT,
+ VCP_PRE_RESULT_EVENT_ERROR
+}vcp_pre_result_event_e;
+
+// Add new
+typedef void (*vcpe_pre_result_cb)(vcp_pre_result_event_e event, const char* pre_result, void *user_data);
/**
* @brief Called to retrieve the supported languages.
typedef int (*vcpe_set_result_cb)(vcpe_result_cb callback, void* user_data);
/**
+* @brief Registers a callback function for getting partial recognition 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
+*
+* @see vcpe_pre_result_cb()
+*/
+typedef int (*vcpe_set_pre_result_cb)(vcpe_pre_result_cb callback, void* user_data);
+
+
+/**
* @brief Gets recording format of the engine.
*
* @param[in] audio_id The audio device id.
*/
typedef int (*vcpe_unset_commands)();
+// Add new
+typedef int (*vcpe_set_nlp_info)(const char* info);
+
+typedef int (*vcpe_get_nlp_info)(char** info);
+
/**
* @brief Start recognition.
*
vcpe_is_language_supported is_lang_supported; /**< Check language */
/* Set info */
+ vcpe_set_pre_result_cb set_pre_result_cb; /**< Set pre result callback */
vcpe_set_result_cb set_result_cb; /**< Set result callback */
vcpe_set_language set_language; /**< Set language */
vcpe_set_commands set_commands; /**< Request to set current commands */
vcpe_unset_commands unset_commands; /**< Request to unset current commands */
+ vcpe_set_nlp_info set_nlp_info; /**< Set nlp info */
+ vcpe_get_nlp_info get_nlp_info; /**< Get nlp info */
/* Control recognition */
vcpe_start start; /**< Start recognition */
return 0;
}
+int vcdc_send_pre_result_to_manager(int manger_pid, int event, const char* pre_result)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ DBusMessage* msg = NULL;
+
+ msg = __get_message(manger_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ return 0;
+}
+
int vcdc_send_result_to_manager(int manger_pid, int result_type)
{
DBusError err;
return 0;
}
-int vcdc_send_error_signal(int pid, int reason, char *err_msg)
+int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
{
+ SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal to manager");
+
if (NULL == err_msg) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
return VCD_ERROR_INVALID_PARAMETER;
}
- char service_name[64] = {0, };
- snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
+ int daemon_pid;
+ DBusError err;
+ dbus_error_init(&err);
- DBusMessage* msg;
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send error signal : reason(%d), Error Msg(%s)", reason, err_msg);
+ DBusMessage* msg = NULL;
- msg = dbus_message_new_method_call(
- service_name,
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCD_MANAGER_METHOD_ERROR);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ daemon_pid = getpid();
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager : reason(%d), Error Msg(%s)", reason, err_msg);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
+
+int vcdc_send_error_signal(int reason, char *err_msg)
+{
+ SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal");
+
+ if (NULL == err_msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
+ return VCD_ERROR_INVALID_PARAMETER;
+ }
+
+ int daemon_pid;
+ DBusError err;
+ dbus_error_init(&err);
+
+ DBusMessage* msg = NULL;
+
+ msg = dbus_message_new_signal(
+ VC_MANAGER_SERVICE_OBJECT_PATH,
+ VC_MANAGER_SERVICE_INTERFACE,
+ VCD_MANAGER_METHOD_ERROR);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ daemon_pid = getpid();
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
+
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ msg = NULL;
+ msg = dbus_message_new_signal(
VC_CLIENT_SERVICE_OBJECT_PATH,
VC_CLIENT_SERVICE_INTERFACE,
VCD_METHOD_ERROR);
if (NULL == msg) {
- SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
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, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
- dbus_message_set_no_reply(msg, TRUE);
+ if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
+ return VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
+ dbus_connection_flush(g_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ msg = NULL;
+ msg = dbus_message_new_signal(
+ VC_WIDGET_SERVICE_OBJECT_PATH,
+ VC_WIDGET_SERVICE_INTERFACE,
+ VCD_WIDGET_METHOD_ERROR);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
+ return VCD_ERROR_OUT_OF_MEMORY;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
dbus_connection_flush(g_conn_sender);
}
dbus_connection_close(g_conn_listener);
dbus_connection_close(g_conn_sender);
+ dbus_connection_unref(g_conn_listener);
+ dbus_connection_unref(g_conn_sender);
+
g_conn_listener = NULL;
g_conn_sender = NULL;
int vcdc_send_result(int pid, int cmd_type);
+int vcdc_send_pre_result_to_manager(int manger_pid, int event, const char* pre_result);
+
int vcdc_send_result_to_manager(int manger_pid, int result_type);
int vcdc_send_speech_detected(int manger_pid);
-int vcdc_send_error_signal(int pid, int reason, char *err_msg);
+int vcdc_send_error_signal(int reason, char *err_msg);
+
+int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg);
int vcdc_send_service_state(vcd_state_e state);
int pid;
int service_state;
int foreground;
+ int daemon_pid;
int ret = VCD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
ret = vcd_server_mgr_initialize(pid);
service_state = vcd_server_get_service_state();
foreground = vcd_server_get_foreground();
+ daemon_pid = getpid();
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d)", pid, service_state, foreground);
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid);
}
DBusMessage* reply;
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &service_state,
DBUS_TYPE_INT32, &foreground,
+ DBUS_TYPE_INT32, &daemon_pid,
DBUS_TYPE_INVALID);
if (0 == ret) {
static char* g_default_lang;
/** callback functions */
+static pre_result_callback g_pre_result_cb;
static result_callback g_result_cb;
bool __supported_language_cb(const char* language, void* user_data);
/*
* VCS Engine Agent Interfaces
*/
-int vcd_engine_agent_init(result_callback result_cb)
+int vcd_engine_agent_init(pre_result_callback pre_cb, result_callback result_cb)
{
- if (NULL == result_cb) {
+ if (NULL == pre_cb || NULL == result_cb) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Input parameter is NULL");
return VCD_ERROR_OPERATION_FAILED;
}
g_agent_init = true;
+ g_pre_result_cb = pre_cb;
g_result_cb = result_cb;
if (0 != vcd_config_get_default_language(&g_default_lang)) {
return vcd_recorder_get(audio_type);
}
+void __pre_result_cb(vcp_pre_result_event_e event, const char* pre_result, void* user_data)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[Engine agent] Pre result(%s)", pre_result);
+
+ if (NULL != g_pre_result_cb) {
+ g_pre_result_cb(event, pre_result, user_data);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent ERROR] Result callback function is NOT valid");
+ }
+
+ return;
+}
+
void __result_cb(vcp_result_event_e event, int* result_id, int count, const char* all_result, const char* non_fixed, const char* msg, void *user_data)
{
SLOG(LOG_DEBUG, TAG_VCD, "[Engine agent] Event(%d), Count(%d) Text(%s) Nonfixed(%s) Msg(%s)", event, count, all_result, non_fixed, msg);
+ // Need to nlp info handle or true false value
+ int ret = 0;
+ char* temp_nlp = NULL;
+
+ if (true == g_dynamic_engine.is_loaded) {
+ if (NULL != g_dynamic_engine.pefuncs->get_nlp_info) {
+ ret = g_dynamic_engine.pefuncs->get_nlp_info(&temp_nlp);
+ if (0 != ret) {
+ SLOG(LOG_WARN, TAG_VCD, "[Engine Agent ERROR] Fail to get nlp info : error(%d)", ret);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Get nlp info : %s", temp_nlp);
+ }
+ } else {
+ SLOG(LOG_WARN, TAG_VCD, "[Engine Agent ERROR] Not support to get nlp info");
+ }
+ }
+
+ if (NULL == temp_nlp)
+ temp_nlp = "null";
+
if (NULL != g_result_cb) {
- g_result_cb(event, result_id, count, all_result, non_fixed, msg, user_data);
+ g_result_cb(event, result_id, count, all_result, non_fixed, msg, temp_nlp, user_data);
} else {
SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent ERROR] Result callback function is NOT valid");
}
return VCD_ERROR_OPERATION_FAILED;
}
+ // temp
+ if (0 != engine->pefuncs->set_pre_result_cb(__pre_result_cb, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set pre result callback of vc-engine");
+ return VCD_ERROR_OPERATION_FAILED;
+ }
+
/* load engine */
if (true == engine->pefuncs->is_lang_supported(g_default_lang)) {
if (0 != engine->pefuncs->set_language(g_default_lang)) {
ret = g_dynamic_engine.pefuncs->set_recording(data, length, speech_detected);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set recording dynamic engine error(%d)", ret);
+ if (VCP_ERROR_OUT_OF_NETWORK == ret) {
+ return VCD_ERROR_TIMED_OUT;
+ }
return VCD_ERROR_OPERATION_FAILED;
}
}
#define ENGINE_PATH_SIZE 256
+typedef void (*pre_result_callback)(vcp_pre_result_event_e event, const char* pre_result, 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);
+ const char* non_fixed_result, const char* msg, const char* nlp_info, void *user_data);
typedef void (*silence_dectection_callback)(void *user_data);
/** Init engine agent */
-int vcd_engine_agent_init(result_callback result_cb);
+int vcd_engine_agent_init(pre_result_callback pre_cb, result_callback result_cb);
/** Release engine agent */
int vcd_engine_agent_release();
ecore_timer_del(g_check_client_timer);
}
- vcd_dbus_close_connection();
-
vcd_finalize();
+ vcd_dbus_close_connection();
+
ecore_shutdown();
SLOG(LOG_DEBUG, TAG_VCD, "=====");
VCD_ERROR_INVALID_LANGUAGE = TIZEN_ERROR_VOICE_CONTROL | 0x012, /**< Invalid language */
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_OPERATION_REJECTED = TIZEN_ERROR_VOICE_CONTROL | 0x015, /**< Operation rejected */
+ VCD_ERROR_SERVICE_RESET = TIZEN_ERROR_VOICE_CONTROL | 0x018 /**< Daemon Service reset */
} vcd_error_e;
typedef enum {
static GList *g_proc_list = NULL;
+static Ecore_Timer *g_restart_timer = NULL;
+
/*
* VC Server Internal Functions
*/
{
SLOG(LOG_DEBUG, TAG_VCD, "===== Restart by no result");
+ g_restart_timer = NULL;
+
/* Restart recognition */
int ret = vcd_engine_recognize_start(true);
if (0 != ret) {
{
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_RECORDING != state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Skip by engine processing");
- return 0;
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] Not recording state, but recording");
+// return 0;
}
vcp_speech_detect_e speech_detected = VCP_SPEECH_DETECT_NONE;
/* Error */
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set recording data to engine(%d)", ret);
ecore_timer_add(0, __cancel_by_interrupt, NULL);
+ /* Send error cb to manager */
+ if (VCP_ERROR_OUT_OF_NETWORK == ret) {
+ vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_TIMED_OUT, "Engine connection failed");
+ } else {
+ vcdc_send_error_signal_to_manager(vcd_client_manager_get_pid(), VCD_ERROR_OPERATION_FAILED, "Engine recognition failed");
+ }
return 0;
}
}
}
+static void __vcd_server_pre_result_cb(vcp_pre_result_event_e event, const char* pre_result, void* user_data)
+{
+ if (NULL != pre_result) {
+ vcdc_send_pre_result_to_manager(vcd_client_manager_get_pid(), event, pre_result);
+ }
+
+ return;
+}
+
static void __vcd_server_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)
+ const char* non_fixed_result, const char* msg, const char* nlp_info, void *user_data)
{
if (VCD_STATE_PROCESSING != vcd_config_get_service_state()) {
if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY != vcd_client_get_recognition_mode()) {
}
}
+ // temp
+ if (NULL != nlp_info) {
+ if (0 != vc_info_parser_set_nlp_info(nlp_info)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to save nlp info");
+ }
+ }
+
vc_info_parser_unset_result(vcd_client_manager_get_exclusive());
SLOG(LOG_DEBUG, TAG_VCD, "[Server] Event(%d), Text(%s) Nonfixed(%s) Msg(%s) Result count(%d)",
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
}
- ecore_timer_add(0, __restart_engine, NULL);
+ g_restart_timer = ecore_timer_add(0, __restart_engine, NULL);
return;
}
SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop recorder due to success");
} else if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == vcd_client_get_recognition_mode()) {
SLOG(LOG_DEBUG, TAG_VCD, "[Server] Restart continuously");
/* Restart option is ON */
- ecore_timer_add(0, __restart_engine, NULL);
+ g_restart_timer = ecore_timer_add(0, __restart_engine, NULL);
if (VCP_RESULT_EVENT_REJECTED == event) {
bool temp = vcd_client_manager_get_exclusive();
vc_info_parser_set_result(all_result, event, msg, NULL, temp);
/* Remove old file */
__vcd_file_clean_up();
+ /* Send error signal for notifying that daemon is reset*/
+ vcdc_send_error_signal(VCD_ERROR_SERVICE_RESET, "Daemon reset");
/* initialize modules */
ret = vcd_config_initialize(__config_lang_changed_cb, __config_foreground_changed_cb, NULL);
vcd_config_set_service_state(VCD_STATE_NONE);
- ret = vcd_engine_agent_init(__vcd_server_result_cb);
+ ret = vcd_engine_agent_init(__vcd_server_pre_result_cb, __vcd_server_result_cb);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
return ret;
}
}
+ if (g_restart_timer != NULL) {
+ ecore_timer_del(g_restart_timer);
+ g_restart_timer = NULL;
+ }
+
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_READY != state) {
if (VCD_STATE_RECORDING == state) {
/* check if pid is valid */
if (false == vcd_client_manager_is_valid(pid)) {
- SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] The pid(%d) is already exist", pid);
- return VCD_ERROR_INVALID_PARAMETER;
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] old manager pid(%d) be removed", vcd_client_manager_get_pid());
+ vcd_server_mgr_cancel();
+ vcd_client_manager_unset();
}
/* Add client information to client manager */
return VCD_ERROR_INVALID_STATE;
}
+ if (g_restart_timer != NULL) {
+ SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Delete restart engine timer");
+ ecore_timer_del(g_restart_timer);
+ g_restart_timer = NULL;
+ }
+
/* 2. Stop recorder */
vcd_recorder_stop();
/* 3. Cancel engine */
SLOG(LOG_DEBUG, TAG_VCD, "[Server] widget command is available");
} else {
vcd_client_widget_unset_command(pid);
- SLOG(LOG_WARN, TAG_VCD, "[Server] widget command is NOT available");
+ SLOG(LOG_DEBUG, TAG_VCD, "[Server] widget command is NOT available");
}
int ret = __start_internal_recognition();
projects / platform / core / uifw / voice-control.git / commitdiff