* 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"
#define VC_MANAGER_CONFIG_HANDLE 100000
-static bool g_m_is_daemon_started = false;
-
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 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;
+ switch (err) {
+ 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;
}
static void __vc_mgr_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
- before_lang, current_lang);
+ SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
+ before_lang, current_lang);
vc_current_language_changed_cb callback = NULL;
void* lang_user_data;
return;
}
-static void __vc_mgr_service_state_changed_cb(int before_state, int current_state)
+static int __vc_mgr_get_feature_enabled()
{
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
- before_state, current_state);
-
- /* Save service state */
- vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)current_state);
-
- vc_service_state_changed_cb callback = NULL;
- void* service_user_data;
- vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
+ 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;
+ }
- if (NULL != callback) {
- vc_mgr_client_use_callback(g_vc_m);
- callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
- vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
- } else {
- SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
+ g_feature_enabled = 1;
+ }
+ }
}
- return;
+ return 0;
}
-static void __vc_mgr_foreground_changed_cb(int previous, int current)
+int vc_mgr_initialize()
{
- SLOG(LOG_DEBUG, TAG_VCM, "Foreground changed : Before(%d) Current(%d)", previous, current);
-
- /* get authorized valid app */
- int pid;
- if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &pid)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
- return;
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Initialize");
- /* compare & set valid */
- if (current != pid) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", pid);
- /* set authorized valid */
- if (true == vc_mgr_client_is_authorized_client(g_vc_m, current)) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", current);
- vc_mgr_client_set_valid_authorized_client(g_vc_m, current);
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
- vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
- }
+ if (0 != __vc_mgr_get_feature_enabled()) {
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] not supported");
+ return VC_ERROR_NOT_SUPPORTED;
}
-}
-
-int vc_mgr_initialize()
-{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Initialize");
/* check handle */
if (true == vc_mgr_client_is_valid(g_vc_m)) {
vc_mgr_client_destroy(g_vc_m);
return VC_ERROR_OPERATION_FAILED;
}
-
- ret = vc_config_mgr_set_service_state_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_service_state_changed_cb);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set service change callback : %d", ret);
- vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
- vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
- vc_mgr_client_destroy(g_vc_m);
- return VC_ERROR_OPERATION_FAILED;
- }
-
- ret = vc_config_mgr_set_foreground_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_foreground_changed_cb);
- int service_state = -1;
- if (0 != vc_config_mgr_get_service_state(&service_state)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state");
+ 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 VC_ERROR_OPERATION_FAILED;
+ return ret;
}
- vc_mgr_client_set_service_state(g_vc_m, service_state);
-
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));
}
- g_m_is_daemon_started = false;
-
- 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_service_state_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
vc_config_mgr_finalize(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");
}
return VC_ERROR_NONE;
}
-static void* __fork_vc_daemon()
-{
- int pid, i;
- pid = fork();
-
- switch(pid) {
- case -1:
- SLOG(LOG_ERROR, TAG_VCM, "Fail to create daemon");
- break;
- case 0:
- setsid();
- for (i = 0;i < _NSIG;i++)
- signal(i, SIG_DFL);
-
- execl(VC_DAEMON_PATH, VC_DAEMON_PATH, NULL);
- break;
- default:
- break;
- }
-
- return (void*) 1;
-}
-
static Eina_Bool __vc_mgr_connect_daemon(void *data)
{
- /* Send hello */
- if (0 != vc_mgr_dbus_request_hello()) {
- if (false == g_m_is_daemon_started) {
- g_m_is_daemon_started = true;
-
- pthread_t thread;
- int thread_id;
- thread_id = pthread_create(&thread, NULL, __fork_vc_daemon, NULL);
- if (thread_id < 0) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to make thread");
- g_m_connect_timer = NULL;
- return EINA_FALSE;
- }
-
- pthread_detach(thread);
- }
- return EINA_TRUE;
- }
+ /* request initialization */
+ int ret = -1;
+ int service_state = 0;
+ int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
g_m_connect_timer = NULL;
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
- /* request initialization */
- int ret = -1;
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle);
+ 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));
/* Success to connect */
}
- SECURE_SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
+ /* 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);
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_is_daemon_started = false;
-
- 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;
+ 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");
}
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;
+ 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");
}
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
-
+
return 0;
/*
}
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_set_command_list(vc_cmd_list_h vc_cmd_list)
-{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list");
+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)) {
return VC_ERROR_INVALID_STATE;
}
- vc_cmd_list_s* list = NULL;
- list = (vc_cmd_list_s*)vc_cmd_list;
-
- 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;
-
- if (0 != system_ret && 0 != exclsive_ret) {
- ret = VC_ERROR_INVALID_PARAMETER;
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(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_unset_command_list()
-{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Unset 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] Current state is not 'READY'");
- return VC_ERROR_INVALID_STATE;
- }
-
+ int ret;
int count = 0;
- int ret = -1;
- while (0 != ret) {
- ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle);
+ 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 unset command to daemon : %s", __vc_mgr_get_error_code(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 unset command : %s", __vc_mgr_get_error_code(ret));
+ 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) {
}
}
}
- }
-
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
- vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
+ } while (0 != ret);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
- return 0;
+ return ret;
}
-int vc_mgr_set_audio_type(const char* audio_id)
+int vc_mgr_disable_command_type(int cmd_type)
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set audio type");
-
- if (NULL == audio_id) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
- return VC_ERROR_INVALID_PARAMETER;
- }
+ 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)) {
int ret;
int count = 0;
-
- /* Request */
- ret = -1;
- count = 0;
- while (0 != ret) {
- ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id);
+ 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 set audio type : %s", __vc_mgr_get_error_code(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 to set audio type : %s", __vc_mgr_get_error_code(ret));
+ 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) {
break;
}
}
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio type");
- /* Save */
- vc_mgr_client_set_audio_type(g_vc_m, audio_id);
}
- }
+ } while (0 != ret);
SLOG(LOG_DEBUG, TAG_VCM, "=====");
SLOG(LOG_DEBUG, TAG_VCM, " ");
return ret;
}
-int vc_mgr_get_audio_type(char** audio_id)
+int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get audio type");
-
- if (NULL == audio_id) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
- return VC_ERROR_INVALID_PARAMETER;
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list");
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
return VC_ERROR_INVALID_STATE;
}
- char* temp = NULL;
+ if (NULL == vc_cmd_list) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
- vc_mgr_client_get_audio_type(g_vc_m, &temp);
+ 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 == temp) {
- /* Not initiallized */
- int ret = -1;
+ if (NULL == list->list) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid command list");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ 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 (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 {
int count = 0;
- while (0 != ret) {
- ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp);
+ 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 get audio type : %s", __vc_mgr_get_error_code(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 to get audio type : %s", __vc_mgr_get_error_code(ret));
+ 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) {
break;
}
}
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
- /* Save */
- vc_mgr_client_set_audio_type(g_vc_m, temp);
}
- }
+ } while (0 != ret);
}
- if (NULL != temp) {
- *audio_id = strdup(temp);
- free(temp);
- temp = NULL;
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- return 0;
+ return ret;
}
-int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
+int vc_mgr_unset_command_list()
{
- SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Foreach current commands");
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Unset 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");
- 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, " ");
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Current state is not 'READY'");
return VC_ERROR_INVALID_STATE;
}
- if (NULL == vc_cmd_list) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid Parameter");
+ int count = 0;
+ int ret = -1;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request unset 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;
+ }
+ }
+ }
+ }
+
+ 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");
+
+ if (NULL == audio_id) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter 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] 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;
+
+ /* Request */
+ ret = -1;
+ count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set audio 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;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio type");
+ /* Save */
+ vc_mgr_client_set_audio_type(g_vc_m, audio_id);
+ }
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+
+ return ret;
+}
+
+int vc_mgr_get_audio_type(char** audio_id)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get audio type");
+
+ if (NULL == audio_id) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter 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] 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;
+ }
+
+ char* temp = NULL;
+
+ vc_mgr_client_get_audio_type(g_vc_m, &temp);
+
+ if (NULL == temp) {
+ /* Not initiallized */
+ int ret = -1;
+ int count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to get audio 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;
+ }
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
+ /* Save */
+ vc_mgr_client_set_audio_type(g_vc_m, temp);
+ }
+ }
+ }
+
+ if (NULL != temp) {
+ *audio_id = strdup(temp);
+ free(temp);
+ temp = NULL;
+ }
+
+ return 0;
+}
+
+int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Foreach current commands");
+
+ 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;
+ }
+
+ if (NULL == vc_cmd_list) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid Parameter");
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ vc_cmd_list_h temp_list = NULL;
+ if (0 != vc_cmd_list_create(&temp_list)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ *vc_cmd_list = temp_list;
+
+ int fg_pid = 0;
+ int mgr_pid = 0;
+ int count = 0;
+ int ret = -1;
+
+ /* Get foreground pid */
+ if (0 != vc_mgr_client_get_foreground(g_vc_m, &fg_pid)) {
+ /* There is no foreground app for voice control */
+ SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
+ }
+
+ if (0 != vc_mgr_client_get_pid(g_vc_m, &mgr_pid)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Fail to get manager pid");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
+ }
+
+ /* Get system command */
+ ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
+ if (0 != ret) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No system commands");
+ }
+
+ /* Request */
+ ret = -1;
+ count = 0;
+ while (0 != ret) {
+ ret = vc_mgr_dbus_request_set_client_info(g_vc_m->handle);
+ if (0 != ret) {
+ if (VC_ERROR_TIMED_OUT != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret));
+ break;
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set client info : %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 client info");
+ }
+ }
+
+ GSList *iter = NULL;
+ GSList* client_info_list = NULL;
+ vc_client_info_s *client_info = NULL;
+ bool is_fgpid = false;
+
+ if (0 != vc_info_parser_get_client_info(&client_info_list)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
+ return 0;
+ }
+
+ if (VC_NO_FOREGROUND_PID != fg_pid) {
+ iter = g_slist_nth(client_info_list, 0);
+ while (NULL != iter) {
+ client_info = iter->data;
+ if (NULL != client_info) {
+ if (fg_pid == client_info->pid) {
+ is_fgpid = true;
+ break;
+ }
+ }
+ iter = g_slist_next(iter);
+ }
+ }
+
+ /* Get foreground commands and widget */
+ if (true == is_fgpid) {
+ /* Get handle */
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
+
+ /* Get foreground command */
+ if (true == client_info->fg_cmd) {
+ ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
+ }
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground commands");
+ }
+
+ /* Check exclusive option */
+ if (true == client_info->exclusive_cmd) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Exclusive command is ON");
+
+ /* Set background command for exclusive option */
+ if (true == client_info->bg_cmd) {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set background command");
+ 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);
+ }
+ }
+
+ /* need to release client info */
+ iter = g_slist_nth(client_info_list, 0);
+
+ while (NULL != iter) {
+ client_info = iter->data;
+ if (NULL != client_info) {
+ free(client_info);
+ }
+ client_info_list = g_slist_remove_link(client_info_list, iter);
+ iter = g_slist_nth(client_info_list, 0);
+ }
+
+ 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_PARAMETER;
+ return VC_ERROR_INVALID_STATE;
}
- vc_cmd_list_h temp_list = NULL;
- if (0 != vc_cmd_list_create(&temp_list)) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
- return VC_ERROR_INVALID_PARAMETER;
+ 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;
}
- *vc_cmd_list = temp_list;
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
+ return 0;
+}
- int fg_pid = 0;
- int mgr_pid = 0;
- int count = 0;
- int ret = -1;
+int vc_mgr_set_private_data(const char* key, const char* data)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set private data");
- /* Get foreground pid */
- if (0 != vc_config_mgr_get_foreground(&fg_pid)) {
- /* There is no foreground app for voice control */
- SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
+ if (NULL == key) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
}
- if (0 != vc_mgr_client_get_pid(g_vc_m, &mgr_pid)) {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Fail to get manager pid");
- return VC_ERROR_OPERATION_FAILED;
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
+ 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;
}
- /* Get system command */
- ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
- if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No system commands");
+ /* 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;
}
- /* Request */
- ret = -1;
- count = 0;
+ /* 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_client_info(g_vc_m->handle);
+ 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 set client info : %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 to set client info : %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) {
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set client info");
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
}
}
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- GSList *iter = NULL;
- GSList* client_info_list = NULL;
- vc_client_info_s *client_info = NULL;
- bool is_fgpid = false;
+ return 0;
+}
- if (0 != vc_info_parser_get_client_info(&client_info_list)) {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
- 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;
}
-
- if (VC_NO_FOREGROUND_PID != fg_pid) {
- iter = g_slist_nth(client_info_list, 0);
- while (NULL != iter) {
- client_info = iter->data;
- if (NULL != client_info) {
- if (fg_pid == client_info->pid) {
- is_fgpid = true;
+
+ 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;
}
}
- iter = g_slist_next(iter);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
}
}
- /* Get foreground commands and widget */
- if (true == is_fgpid) {
- /* Get handle */
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
+ if (NULL != temp) {
+ *data = strdup(temp);
+ free(temp);
+ temp = NULL;
+ }
- /* Get foreground command */
- if (true == client_info->fg_cmd) {
- ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground commands");
- }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- /* Check exclusive option */
- if (true == client_info->exclusive_cmd) {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Exclusive command is ON");
+ return 0;
+}
- /* Set background command for exclusive option */
- if (true == client_info->bg_cmd) {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set background command");
- 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);
- }
- }
+int vc_mgr_set_domain(const char* domain)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set domain");
- /* need to release client info */
- iter = g_slist_nth(client_info_list, 0);
+ if (NULL == domain) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
- while (NULL != iter) {
- client_info = iter->data;
- if (NULL != client_info) {
- free(client_info);
+ 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;
}
- 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");
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_VCM, "=====");
+ SLOG(LOG_DEBUG, TAG_VCM, " ");
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
+ return 0;
+}
- return 0;
- }
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
+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;
}
- /* 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;
+ }
+
+ /* 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;
+ }
- 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);
- }
+ 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;
}
- 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] do action");
}
- } 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_start(bool stop_by_silence, bool exclusive_command_option)
+int vc_mgr_start(bool exclusive_command_option)
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
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;
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, stop_by_silence, exclusive_command_option, start_by_client);
+ 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));
}
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
- vc_mgr_client_set_service_state(g_vc_m, VC_SERVICE_STATE_RECORDING);
+ 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_service_state(g_vc_m, VC_SERVICE_STATE_PROCESSING);
+ 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_service_state(g_vc_m, VC_SERVICE_STATE_READY);
+ 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_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;
+}
+
int vc_mgr_get_recording_volume(float* volume)
{
if (NULL == volume) {
return VC_ERROR_INVALID_STATE;
}
- FILE* fp = fopen(VC_RUNTIME_INFO_AUDIO_VOLUME, "rb");
- if (!fp) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open Volume File");
- return VC_ERROR_OPERATION_FAILED;
+ *volume = g_volume_db;
+
+ return 0;
+}
+
+int __vc_mgr_cb_set_foreground(int pid, bool value)
+{
+ vc_mgr_client_set_foreground(g_vc_m, pid, value);
+
+ /* get authorized valid app */
+ int tmp_pid;
+ if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &tmp_pid)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
+ return VC_ERROR_INVALID_PARAMETER;
}
- int readlen = fread((void*)volume, sizeof(*volume), 1, fp);
- fclose(fp);
+ if (true == value) {
+ /* compare & set valid */
+ if (tmp_pid != pid) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
- if (0 == readlen)
- *volume = 0.0f;
+ /* set authorized valid */
+ if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid);
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
+ }
+ }
+ } else {
+ if (tmp_pid == pid) {
+ SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
+ vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
+ }
+ }
return 0;
}
{
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Select result");
+ /* Do not check state for 'restart continusly' mode */
+
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) {
- SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING'");
- SLOG(LOG_DEBUG, TAG_VCM, "=====");
- SLOG(LOG_DEBUG, TAG_VCM, " ");
- return VC_ERROR_INVALID_STATE;
+ 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;
+ }
}
if (NULL != vc_cmd_list) {
char* result_text = NULL;
vc_mgr_client_get_all_result(g_vc_m, &event, &result_text);
-
+
vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false);
if (NULL != result_text) {
result_text = NULL;
}
}
-
+
int ret;
int count = 0;
return EINA_FALSE;
}
-static Eina_Bool __vc_mgr_notify_all_result(void *data)
+static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
{
char* temp_text = NULL;
int event;
vc_mgr_client_get_all_result_cb(g_vc_m, &all_callback, &all_user_data);
if (NULL == all_callback) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] All result callback is NULL");
- return EINA_FALSE;
+ return;
}
if (0 != vc_cmd_list_create(&vc_cmd_list)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
- return EINA_FALSE;
+ return;
}
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 text(%s) event(%d) result_message(%s)", temp_text, event, temp_message);
+ 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);
vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
if (NULL == callback) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
- return EINA_FALSE;
+ return;
}
vc_mgr_client_use_callback(g_vc_m);
vc_mgr_client_set_exclusive_command(g_vc_m, false);
- return EINA_FALSE;
+ return;
}
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");
- ecore_idler_add(__vc_mgr_set_select_result, NULL);
+ if (VC_RESULT_TYPE_NOTIFICATION != result_type)
+ ecore_idler_add(__vc_mgr_set_select_result, NULL);
} 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 {
- ecore_idler_add(__vc_mgr_set_select_result, NULL);
+ if (VC_RESULT_TYPE_NOTIFICATION != result_type)
+ ecore_idler_add(__vc_mgr_set_select_result, NULL);
+
vc_mgr_client_set_exclusive_command(g_vc_m, false);
vc_mgr_client_unset_all_result(g_vc_m);
}
/* 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);
- return EINA_FALSE;
+ return;
}
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;
}
-void __vc_mgr_cb_all_result()
+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(NULL);
+ __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;
+
+ 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);
vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data);
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set all result callback");
-
+
return 0;
}
}
vc_mgr_client_set_result_cb(g_vc_m, callback, user_data);
-
+
return 0;
}
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 {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
- }
+ }
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;
}
return 0;
}
+int __vc_mgr_cb_service_state(int state)
+{
+ vc_service_state_e current_state = (vc_service_state_e)state;
+ vc_service_state_e before_state;
+ vc_mgr_client_get_service_state(g_vc_m, &before_state);
+
+ if (current_state == before_state) {
+ SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : Before(%d) Current(%d)",
+ before_state, current_state);
+ 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_service_state_changed_cb callback = NULL;
+ void* service_user_data = NULL;
+ vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
+
+ if (NULL != callback) {
+ vc_mgr_client_use_callback(g_vc_m);
+ callback(before_state, current_state, service_user_data);
+ vc_mgr_client_not_use_callback(g_vc_m);
+ SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
+ } else {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
+ }
+
+ return 0;
+}
+
int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
{
if (callback == NULL)
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)) {
/* foreground check */
int fore_pid = 0;
- if (0 != vc_config_mgr_get_foreground(&fore_pid)) {
+ if (0 != vc_mgr_client_get_foreground(g_vc_m, &fore_pid)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground");
return VC_ERROR_OPERATION_FAILED;
}
if (pid == fore_pid) {
vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
}
-
+
return 0;
}
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
}
- if (0 != vc_mgr_start(true, false)) {
+ if (0 != vc_mgr_start(false)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed");
/* TODO - Error handling? */
}
/* add timer for start recording */
ecore_timer_add(0, __request_auth_start, NULL);
-
+
return 0;
}
ecore_timer_add(0, __request_auth_cancel, NULL);
return 0;
-}
\ No newline at end of file
+}
projects / platform / core / uifw / voice-control.git / blobdiff