* 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);
{
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;
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);
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");
}
}
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;
+ 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");
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 0;
}
-int vc_mgr_start(bool exclusive_command_option)
+int vc_mgr_set_private_data(const char* key, const char* data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
+ 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)) {
return VC_ERROR_INVALID_STATE;
}
- vc_mgr_client_set_exclusive_command(g_vc_m, exclusive_command_option);
-
- bool start_by_client = false;
- if (0 != vc_mgr_client_get_start_by_client(g_vc_m, &start_by_client)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
- }
-
- int ret;
+ int ret = -1;
int count = 0;
- vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
- if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
- }
-
- /* Request */
- ret = -1;
- count = 0;
while (0 != ret) {
- ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client);
+ 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_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(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 start request start : %s", __vc_mgr_get_error_code(ret));
+ 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");
- vc_mgr_client_set_exclusive_command(g_vc_m, false);
break;
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
}
}
-
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
- return ret;
+ return 0;
}
-int vc_mgr_stop()
+int vc_mgr_get_private_data(const char* key, char** data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request stop");
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get private data");
- vc_state_e state;
- if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ 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");
+
+ if (NULL == domain) {
+ 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_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;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return 0;
+}
+
+int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
+{
+ 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)) {
+ 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_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, " ");
+
+ return 0;
+}
+
+int vc_mgr_start(bool exclusive_command_option)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
+
+ 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;
+ }
+
+ /* 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;
+ if (0 != vc_mgr_client_get_start_by_client(g_vc_m, &start_by_client)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
+ }
+
+ int ret;
+ int count = 0;
+ vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
+ if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
+ }
+
+ /* Request */
+ ret = -1;
+ count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry start request start : %s", __vc_mgr_get_error_code(ret));
+ usleep(10000);
+ count++;
+ if (VC_RETRY_COUNT == count) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
+ vc_mgr_client_set_exclusive_command(g_vc_m, false);
+ break;
+ }
+ }
+ } 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 ret;
+}
+
+int vc_mgr_stop()
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request stop");
+
+ 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 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;
}
return EINA_FALSE;
}
-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;
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 EINA_FALSE;
}
-static Eina_Bool __vc_mgr_notify_pre_result(void *data)
+void __vc_mgr_cb_all_result(vc_result_type_e type)
+{
+ if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) {
+ __vc_mgr_notify_all_result(type);
+ } else {
+ __vc_mgr_notify_result(0);
+ }
+
+ 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;
- int event = -1;
- char* pre_result = NULL;
- vc_mgr_client_get_pre_resut_cb(g_vc_m, &callback, &user_data);
+ vc_mgr_client_get_pre_result_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;
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client pre result callback is NULL");
+ return;
}
- 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)) {
- __vc_mgr_notify_all_result(type);
- } else {
- __vc_mgr_notify_result(0);
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "Pre result callback is called");
return;
}
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 -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);
+ 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(NULL);
+ __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;
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);
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)) {
projects / platform / core / uifw / voice-control.git / blobdiff