* limitations under the License.
*/
+#include <app.h>
#include <aul.h>
+#include <system_info.h>
-#include "vc_info_parser.h"
+#include "vc_cmd_db.h"
#include "vc_config_mgr.h"
#include "vc_command.h"
+#include "vc_info_parser.h"
+#include "vc_json_parser.h"
#include "vc_main.h"
#include "vc_mgr_client.h"
#include "vc_mgr_dbus.h"
static Ecore_Timer* g_m_connect_timer = NULL;
+static Ecore_Timer* g_m_set_volume_timer = NULL;
+
static vc_h g_vc_m = NULL;
static GSList* g_demandable_client_list = NULL;
static float g_volume_db = 0;
+static float g_prev_volume_db = 0;
+
+static float g_cur_volume_db = 0;
+
+static int g_daemon_pid = 0;
+
+static int g_feature_enabled = -1;
+
+static bool g_err_callback_status = false;
+
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);
static const char* __vc_mgr_get_error_code(vc_error_e err)
{
switch (err) {
- case VC_ERROR_NONE: return "VC_ERROR_NONE"; break;
- case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY"; break;
- case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR"; break;
- case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER"; break;
- case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT"; break;
- case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY"; break;
- case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE"; break;
- case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE"; break;
- case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND"; break;
- case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED"; break;
- default: return "Invalid error code"; break;
+ case VC_ERROR_NONE: return "VC_ERROR_NONE";
+ case VC_ERROR_OUT_OF_MEMORY: return "VC_ERROR_OUT_OF_MEMORY";
+ case VC_ERROR_IO_ERROR: return "VC_ERROR_IO_ERROR";
+ case VC_ERROR_INVALID_PARAMETER: return "VC_ERROR_INVALID_PARAMETER";
+ case VC_ERROR_TIMED_OUT: return "VC_ERROR_TIMED_OUT";
+ case VC_ERROR_RECORDER_BUSY: return "VC_ERROR_RECORDER_BUSY";
+ case VC_ERROR_INVALID_STATE: return "VC_ERROR_INVALID_STATE";
+ case VC_ERROR_INVALID_LANGUAGE: return "VC_ERROR_INVALID_LANGUAGE";
+ case VC_ERROR_ENGINE_NOT_FOUND: return "VC_ERROR_ENGINE_NOT_FOUND";
+ case VC_ERROR_OPERATION_FAILED: return "VC_ERROR_OPERATION_FAILED";
+ default: return "Invalid error code";
}
return NULL;
}
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");
return VC_ERROR_OPERATION_FAILED;
}
+ ret = vc_db_initialize();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize DB : %d", ret);
+ vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
+ vc_mgr_client_destroy(g_vc_m);
+ return ret;
+ }
+
SLOG(LOG_DEBUG, TAG_VCM, "[Success] pid(%d)", g_vc_m->handle);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
}
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
-
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
return;
}
if (NULL != g_m_connect_timer) {
SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
ecore_timer_del(g_m_connect_timer);
+ g_m_connect_timer = NULL;
}
vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
break;
case VC_STATE_NONE:
break;
- default:
- break;
}
SLOG(LOG_DEBUG, TAG_VCM, "Success: destroy");
+ int cnt = VC_COMMAND_TYPE_FOREGROUND;
+ do {
+ int ret = vc_cmd_parser_delete_file(getpid(), cnt);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", cnt, ret);
+ } while (VC_COMMAND_TYPE_EXCLUSIVE >= ++cnt);
+
+ int ret = vc_db_finalize();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to finalize DB, ret(%d)", ret);
+ }
+
if (0 != vc_mgr_dbus_close_connection()) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection");
}
static Eina_Bool __vc_mgr_connect_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");
-
/* 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);
+
+ 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));
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);
+
+ return EINA_FALSE;
+}
+
int vc_mgr_prepare()
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Prepare");
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, " ");
*state = temp;
switch (*state) {
- case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'None'"); break;
- case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Created'"); break;
- case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Ready'"); break;
- default: SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state"); break;
+ case VC_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'None'"); break;
+ case VC_STATE_INITIALIZED: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Created'"); break;
+ case VC_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Ready'"); break;
+ default: SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
*state = service_state;
switch (*state) {
- case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'"); break;
- case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'"); break;
- case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'"); break;
- case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Processing'"); break;
- default: SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state"); break;
+ case VC_SERVICE_STATE_NONE: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'"); break;
+ case VC_SERVICE_STATE_READY: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'"); break;
+ case VC_SERVICE_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'"); break;
+ case VC_SERVICE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Processing'"); break;
+ default: SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
}
switch (format) {
- case VC_CMD_FORMAT_FIXED: *support = true; break;
- case VC_CMD_FORMAT_FIXED_AND_EXTRA: *support = non_fixed_support; break;
- case VC_CMD_FORMAT_EXTRA_AND_FIXED: *support = non_fixed_support; break;
- default: *support = false; break;
+ case VC_CMD_FORMAT_FIXED: *support = true; break;
+ case VC_CMD_FORMAT_FIXED_AND_VFIXED: *support = true; break;
+ case VC_CMD_FORMAT_VFIXED_AND_FIXED: *support = true; break;
+ case VC_CMD_FORMAT_FIXED_AND_NONFIXED: *support = non_fixed_support; break;
+ case VC_CMD_FORMAT_NONFIXED_AND_FIXED: *support = non_fixed_support; break;
+ default: *support = false; break;
}
SLOG(LOG_ERROR, TAG_VCM, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
return VC_ERROR_NONE;
}
+int vc_mgr_enable_command_type(int cmd_type)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Enable Command Type");
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret;
+ int count = 0;
+ do {
+ ret = vc_mgr_dbus_request_enable_command_type(g_vc_m->handle, cmd_type);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request enable command type : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request enable command type : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ }
+ } while (0 != ret);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return ret;
+}
+
+int vc_mgr_disable_command_type(int cmd_type)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Disable Command Type");
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret;
+ int count = 0;
+ do {
+ ret = vc_mgr_dbus_request_disable_command_type(g_vc_m->handle, cmd_type);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request disable command type : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request disable command type : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ }
+ } while (0 != ret);
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return ret;
+}
+
int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list");
return VC_ERROR_INVALID_STATE;
}
+ if (NULL == vc_cmd_list) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
vc_cmd_list_s* list = NULL;
list = (vc_cmd_list_s*)vc_cmd_list;
+ SLOG(LOG_INFO, TAG_VCM, "[List] (%p) (%p)", list, list->list);
+
+ if (NULL == list->list) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid command list");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
- int system_ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_SYSTEM, list->list);
- int exclsive_ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE, list->list);
- int ret = 0;
+ int i;
+ int ret;
+ bool success_save = false;
+ for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
+ ret = vc_cmd_parser_delete_file(getpid(), i);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
+
+ ret = vc_cmd_parser_save_file(getpid(), i, list->list, NULL);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save file, type(%d), ret(%d)", i, ret);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Save file, type(%d)", i);
+ success_save = true;
+ }
+ }
- if (0 != system_ret && 0 != exclsive_ret) {
+ if (true != success_save) {
ret = VC_ERROR_INVALID_PARAMETER;
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret));
} else {
}
}
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
+ int i;
+ for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
+ ret = vc_cmd_parser_delete_file(getpid(), i);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
+ }
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
return 0;
}
+int vc_mgr_set_command_list_from_file(const char* file_path, int type)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list from file");
+
+ if (NULL == file_path) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter!!");
+ return VC_ERROR_INVALID_PARAMETER;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== File path: %s", file_path);
+ }
+
+ /* check type */
+ if (VC_COMMAND_TYPE_FOREGROUND > type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
+ SLOG(LOG_DEBUG, TAG_VCC, "=====");
+ SLOG(LOG_DEBUG, TAG_VCC, " ");
+ 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] A handle is not available");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret = vc_cmd_parser_delete_file(getpid(), type);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(4), ret(%d)", ret);
+
+ if (0 != vc_json_set_commands_from_file(file_path, type, NULL)) {
+ ret = VC_ERROR_INVALID_PARAMETER;
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command list (%d)", ret);
+ } else {
+ int count = 0;
+ do {
+ ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request set command : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ }
+ } while (0 != ret);
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return ret;
+}
+
+int vc_mgr_set_preloaded_commands_from_file(const char* file_path)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set preloaded command list");
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Only support to set background commands for preloaded application */
+ int ret = vc_json_set_commands_from_file(file_path, VC_COMMAND_TYPE_BACKGROUND, NULL);
+ if (0 != ret)
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to insert preloaded commands into db");
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return ret;
+}
+
int vc_mgr_set_audio_type(const char* audio_id)
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set audio type");
iter = g_slist_nth(client_info_list, 0);
}
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
+ }
+
+ /* Get background commands */
+ if (0 < g_slist_length(client_info_list)) {
+ iter = g_slist_nth(client_info_list, 0);
+
+ while (NULL != iter) {
+ client_info = iter->data;
+
+ if (NULL != client_info) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
+ if (true == client_info->bg_cmd) {
+ ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
+ }
+ }
+ free(client_info);
+ }
+ client_info_list = g_slist_remove_link(client_info_list, iter);
+
+ iter = g_slist_nth(client_info_list, 0);
+ }
+ } else {
+ /* NO client */
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No background commands");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+}
+
+int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set recognition mode = %d", mode);
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_recognition_mode(g_vc_m, mode);
+ return 0;
+}
+
+int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
+{
+ int ret = -1;
+
+ ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
+ return ret;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
+ return 0;
+}
+
+int vc_mgr_set_private_data(const char* key, const char* data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set private data");
+
+ if (NULL == key) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ 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] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret = -1;
+ int count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_set_private_data(g_vc_m->handle, key, data);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to set private data request : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry set private data request : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+}
+
+int vc_mgr_get_private_data(const char* key, char** data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get private data");
+
+ if (NULL == key || NULL == data) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ 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] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret = -1;
+ int count = 0;
+ char* temp = NULL;
+
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_get_private_data(g_vc_m->handle, key, &temp);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry get private data request : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
+ }
+ }
+
+ if (NULL != temp) {
+ *data = strdup(temp);
+ free(temp);
+ temp = NULL;
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+}
+
+int vc_mgr_set_domain(const char* domain)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set domain");
- return 0;
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
+ if (NULL == domain) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
}
- /* Get background commands */
- if (0 < g_slist_length(client_info_list)) {
- iter = g_slist_nth(client_info_list, 0);
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
- while (NULL != iter) {
- client_info = iter->data;
+ /* check state */
+ if (state != VC_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
- if (NULL != client_info) {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
- if (true == client_info->bg_cmd) {
- ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
- }
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (service_state != VC_SERVICE_STATE_READY) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret = -1;
+ int count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_set_domain(g_vc_m->handle, domain);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry set domain request : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
}
- free(client_info);
}
- client_info_list = g_slist_remove_link(client_info_list, iter);
-
- iter = g_slist_nth(client_info_list, 0);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
}
- } else {
- /* NO client */
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No background commands");
}
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
return 0;
}
-int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
+int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set recognition mode = %d", mode);
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] do action");
+
+ if (NULL == send_event) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
return VC_ERROR_INVALID_STATE;
}
- vc_mgr_client_set_recognition_mode(g_vc_m, mode);
- return 0;
-}
-
-int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
-{
int ret = -1;
-
- ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
- return ret;
+ int count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_do_action(g_vc_m->handle, type, send_event);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry do action request : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ break;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] do action");
+ }
}
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
return 0;
}
return VC_ERROR_INVALID_STATE;
}
+ /* Check internal state for async */
+ vc_internal_state_e internal_state = -1;
+ vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
+ if (internal_state != VC_INTERNAL_STATE_NONE) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invaid State : Internal state is NOT none : %d", internal_state);
+ return VC_ERROR_IN_PROGRESS_TO_RECORDING;
+ }
+
vc_mgr_client_set_exclusive_command(g_vc_m, exclusive_command_option);
bool start_by_client = false;
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STARTING);
}
}
+ g_volume_db = 0;
+ g_prev_volume_db = 0;
+ g_cur_volume_db = 0;
+
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
return VC_ERROR_INVALID_STATE;
}
+ /* Check internal state for async */
+ vc_internal_state_e internal_state = -1;
+ vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
+ if (VC_INTERNAL_STATE_STARTING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
+ return VC_ERROR_IN_PROGRESS_TO_RECORDING;
+ } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
+ return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
+ } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
+ return VC_ERROR_IN_PROGRESS_TO_READY;
+ }
+
int ret = -1;
int count = 0;
/* do request */
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Stop recognition");
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STOPPING);
}
}
return VC_ERROR_INVALID_STATE;
}
+ vc_internal_state_e internal_state = -1;
+ vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
+ if (VC_INTERNAL_STATE_STARTING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
+ return VC_ERROR_IN_PROGRESS_TO_RECORDING;
+ } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
+ return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
+ } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
+ return VC_ERROR_IN_PROGRESS_TO_READY;
+ }
+
int ret = -1;
int count = 0;
while (0 != ret) {
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Cancel recognition");
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_CANCELING);
}
}
return ret;
}
+static int g_cnt = 0;
+static Eina_Bool __vc_mgr_set_volume(void* data)
+{
+ g_cnt++;
+ g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5 * g_cnt;
+
+ SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
+
+ if (0 == g_cnt % 5) {
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
int __vc_mgr_cb_set_volume(float volume)
{
- g_volume_db = volume;
- SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)", g_volume_db);
+ g_prev_volume_db = g_volume_db;
+ g_cur_volume_db = volume;
+
+ g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5;
+
+ SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
+
+ if (NULL != g_m_set_volume_timer) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
+ ecore_timer_del(g_m_set_volume_timer);
+ }
+
+ g_cnt = 1;
+ g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_set_volume, NULL);
return 0;
}
vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command(g_vc_m));
- SLOG(LOG_DEBUG, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
+ SLOG(LOG_INFO, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
result_type, temp_text, event, temp_message);
vc_cmd_print_list(vc_cmd_list);
int count = 0;
vc_cmd_list_get_count(vc_cmd_list, &count);
if (0 < count) {
+ vc_mgr_client_set_all_result(g_vc_m, event, temp_text);
if (true == cb_ret) {
SLOG(LOG_DEBUG, TAG_VCM, "Callback result is true");
if (VC_RESULT_TYPE_NOTIFICATION != result_type)
} else {
SLOG(LOG_DEBUG, TAG_VCM, "Callback result is false");
/* need to select conflicted result */
-
- vc_mgr_client_set_all_result(g_vc_m, event, temp_text);
}
} else {
if (VC_RESULT_TYPE_NOTIFICATION != result_type)
}
/* Release result */
- if (NULL != temp_text) free(temp_text);
+ if (NULL != temp_text) {
+ free(temp_text);
+ temp_text = NULL;
+ }
/* Release list */
vc_cmd_list_destroy(vc_cmd_list, true);
static Eina_Bool __vc_mgr_notify_result(void *data)
{
- char* temp_text;
+ char* temp_text = NULL;
int event;
vc_cmd_list_h vc_cmd_list = NULL;
vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
- SLOG(LOG_DEBUG, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event);
+ SLOG(LOG_INFO, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event);
vc_cmd_print_list(vc_cmd_list);
vc_mgr_client_use_callback(g_vc_m);
callback(event, vc_cmd_list, temp_text, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Result callback called");
+ SLOG(LOG_INFO, TAG_VCM, "Result callback called");
vc_cmd_list_destroy(vc_cmd_list, true);
return;
}
+void __vc_mgr_cb_pre_result(vc_pre_result_event_e event, const char* pre_result)
+{
+ vc_mgr_pre_result_cb callback = NULL;
+ void* user_data = NULL;
+
+ vc_mgr_client_get_pre_result_cb(g_vc_m, &callback, &user_data);
+ if (NULL == callback) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client pre result callback is NULL");
+ return;
+ }
+
+ 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, "Pre result callback is called");
+
+ return;
+}
+
void __vc_mgr_cb_system_result()
{
__vc_mgr_notify_result(NULL);
return 0;
}
+int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
+{
+ if (NULL == callback)
+ 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 pre result 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 pre result callback : Current state is not 'Initialized'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_pre_result_cb(g_vc_m, callback, user_data);
+
+ 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 pre result 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 pre result callback : Current state is not 'Initialize'");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ vc_mgr_client_set_pre_result_cb(g_vc_m, NULL, NULL);
+
+ return 0;
+}
+
+int vc_mgr_get_error_message(char** err_msg)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get error message");
+
+ if (NULL == err_msg) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ if (false == g_err_callback_status) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in error callback");
+ return VC_ERROR_OPERATION_FAILED;
+ }
+
+ int ret;
+ ret = vc_mgr_client_get_error_message(g_vc_m, err_msg);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message");
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return ret;
+}
+
static Eina_Bool __vc_mgr_notify_error(void *data)
{
vc_h vc_m = (vc_h)data;
if (NULL != callback) {
vc_mgr_client_use_callback(vc_m);
+ g_err_callback_status = true;
callback(reason, user_data);
+ g_err_callback_status = false;
vc_mgr_client_not_use_callback(vc_m);
SLOG(LOG_DEBUG, TAG_VCM, "Error callback is called");
} else {
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;
}
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
+
+ if (VC_ERROR_SERVICE_RESET == reason) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] VC daemon reset");
+
+ vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED);
+ __vc_mgr_notify_state_changed(g_vc_m);
+
+ if (0 != vc_mgr_prepare()) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to prepare");
+ }
+ }
+
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
+
vc_mgr_client_set_error(g_vc_m, reason);
+ vc_mgr_client_set_error_message(g_vc_m, msg);
__vc_mgr_notify_error(g_vc_m);
return 0;
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;
}
SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
before_state, current_state);
+ vc_internal_state_e internal_state = -1;
+ vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
+ if ((VC_INTERNAL_STATE_STARTING == internal_state && VC_SERVICE_STATE_RECORDING == current_state) ||
+ (VC_INTERNAL_STATE_STOPPING == internal_state && VC_SERVICE_STATE_PROCESSING == current_state) ||
+ (VC_INTERNAL_STATE_CANCELING == internal_state && VC_SERVICE_STATE_READY == current_state)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Internal state is changed to NONE");
+ vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
+ }
+
/* Save service state */
vc_mgr_client_set_service_state(g_vc_m, current_state);
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;
}
return 0;
}
+int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
+{
+ vc_mgr_dialog_request_cb callback = NULL;
+ void* user_data = NULL;
+
+ vc_mgr_client_get_dialog_request_cb(g_vc_m, &callback, &user_data);
+
+ if (NULL != callback) {
+ vc_mgr_client_use_callback(g_vc_m);
+ callback(pid, disp_text, utt_text, continuous, user_data);
+ vc_mgr_client_not_use_callback(g_vc_m);
+ SLOG(LOG_DEBUG, TAG_VCM, "Dialog callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
+ }
+
+ return 0;
+}
+
+int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data)
+{
+ if (NULL == callback)
+ 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_dialog_request_cb(g_vc_m, callback, user_data);
+
+ return 0;
+}
+
+int vc_mgr_unset_dialog_request_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_dialog_request_cb(g_vc_m, NULL, NULL);
+
+ return 0;
+}
+
static bool __vc_mgr_check_demandable_client(int pid)
{
if (0 == g_slist_length(g_demandable_client_list)) {
ecore_timer_add(0, __request_auth_cancel, NULL);
return 0;
-}
\ No newline at end of file
+}
projects / platform / core / uifw / voice-control.git / blobdiff