static void __vc_mgr_lang_changed_cb(const char* before_lang, const char* current_lang)
{
- SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
+ SLOG(LOG_INFO, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
before_lang, current_lang);
vc_current_language_changed_cb callback = NULL;
vc_mgr_client_use_callback(g_vc_m);
callback(before_lang, current_lang, lang_user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Language changed callback is called");
+ SLOG(LOG_INFO, TAG_VCM, "Language changed callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Language changed callback is null");
}
pid_t pid = getpid();
char *session = cynara_session_from_pid(pid);
int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
- SLOG(LOG_DEBUG, TAG_VCM, "[Client]cynara_check returned %d(%s), p_cynara(%p), label(%s), session(%s), uid(%s), priv(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied", p_cynara, smack_label, session, uid, privilege);
+ SLOG(LOG_INFO, TAG_VCM, "[Client]cynara_check returned %d(%s), p_cynara(%p), label(%s), session(%s), uid(%s), priv(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied", p_cynara, smack_label, session, uid, privilege);
if (session)
free(session);
if (0 != __vc_mgr_get_feature_enabled()) {
- SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] not supported");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
return VC_ERROR_NOT_SUPPORTED;
}
SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
if (NULL == g_m_connect_idler) {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Create a new idler for preparation");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new idler for preparation");
g_m_connect_idler = ecore_idler_add(__vc_mgr_connect_daemon, NULL);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[INFO] idler handle is already created");
+ SLOG(LOG_INFO, TAG_VCM, "[INFO] idler handle is already created");
}
g_m_connect_timer = NULL;
SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Prepare");
if (0 != __vc_mgr_get_feature_enabled()) {
- SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] not supported");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
return VC_ERROR_NOT_SUPPORTED;
}
if (NULL == g_m_connect_timer) {
g_retry_connect_count = 0;
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Create a new timer for preparation");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new timer for preparation");
ecore_thread_main_loop_begin();
g_m_connect_timer = ecore_timer_add(0.02, __vc_mgr_prepare_daemon, NULL);
ecore_thread_main_loop_end();
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[INFO] timer handle is already created");
+ SLOG(LOG_INFO, TAG_VCM, "[INFO] timer handle is already created");
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
int vc_mgr_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Foreach Supported Language");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Foreach Supported Language");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
*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;
+ case VC_STATE_NONE: SLOG(LOG_INFO, TAG_VCM, "Current state is 'None'"); break;
+ case VC_STATE_INITIALIZED: SLOG(LOG_INFO, TAG_VCM, "Current state is 'Created'"); break;
+ case VC_STATE_READY: SLOG(LOG_INFO, TAG_VCM, "Current state is 'Ready'"); break;
default: SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
}
int vc_mgr_set_demandable_client_rule(const char* rule)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set Demandable client rule");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s)", rule);
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
int vc_mgr_unset_demandable_client_rule(void)
{
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Unset Demandable client");
+
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
return VC_ERROR_NOT_SUPPORTED;
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);
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Save file, type(%d)", i);
success_save = true;
}
}
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter!!");
return VC_ERROR_INVALID_PARAMETER;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ File path: %s", file_path);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
}
/* check type */
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter!! file_path is NULL ptr");
return VC_ERROR_INVALID_PARAMETER;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ File path: %s", file_path);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
}
vc_state_e state;
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio type");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set audio type");
/* Save */
vc_mgr_client_set_audio_type(g_vc_m, audio_id);
}
/* 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);
+ SLOG(LOG_INFO, 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");
+ SLOG(LOG_ERROR, 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);
+ SLOG(LOG_INFO, 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");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] No system commands");
}
/* Request */
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set client info");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set client info");
}
}
bool is_fgpid = false;
if (0 != vc_info_parser_get_client_info(&client_info_list)) {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No client");
return 0;
}
/* Get foreground commands and widget */
if (true == is_fgpid) {
/* Get handle */
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
/* Get foreground command */
if (true == client_info->fg_cmd) {
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_INFO, 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");
+ SLOG(LOG_INFO, 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");
+ SLOG(LOG_INFO, 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);
return 0;
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground app");
}
/* Get background commands */
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);
+ SLOG(LOG_INFO, 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) {
}
} else {
/* NO client */
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No background commands");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] No background commands");
}
SLOG(LOG_ERROR, TAG_VCM, "@@@");
int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set recognition mode = %d", mode);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set recognition mode = %d", mode);
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
return ret;
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get recognition mode = %d", *mode);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Get recognition mode = %d", *mode);
return 0;
}
int vc_mgr_set_private_data(const char* key, const char* data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set private data");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set private data");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
int ret = -1;
ret = vc_mgr_dbus_request_set_private_data(g_vc_m->handle, key, data);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret));
return ret;
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set private data");
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));
+ SLOG(LOG_ERROR, 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));
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
}
}
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));
+ SLOG(LOG_ERROR, 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));
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set domain");
}
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] do action");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] do action");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
int ret = -1;
ret = vc_mgr_dbus_request_do_action(g_vc_m->handle, type, send_event);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
return ret;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] do action");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] do action");
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* event, const char* request)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send specific engine request");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send specific engine request");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
return VC_ERROR_PERMISSION_DENIED;
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] specific engine request. engine app id(%s), event(%s), request(%s)", engine_app_id, event, request);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] specific engine request. engine app id(%s), event(%s), request(%s)", engine_app_id, event, request);
if (NULL == engine_app_id || NULL == event) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
int ret = -1;
ret = vc_mgr_dbus_send_specific_engine_request(g_vc_m->handle, engine_app_id, event, request);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret));
return ret;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] specific engine request");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] specific engine request");
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] start recognition");
}
}
ret = vc_mgr_dbus_request_stop(g_vc_m->handle);
if (0 != ret) {
if (VC_ERROR_TIMED_OUT != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
break;
} else {
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Stop recognition");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Stop recognition");
}
}
int vc_mgr_cancel(void)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request cancel");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request cancel");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Cancel recognition");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel recognition");
}
}
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);
+ SLOG(LOG_INFO, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
if (0 == g_cnt % 5) {
return EINA_FALSE;
if (true == value) {
/* compare & set valid */
if (tmp_pid != pid) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
+ SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
/* set authorized valid */
if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
}
} else {
if (tmp_pid == pid) {
- SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
+ SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
}
}
int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Select result");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Select result");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret));
return ret;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] result selection");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] result selection");
}
vc_mgr_client_unset_all_result(g_vc_m);
vc_cmd_list_get_count(vc_cmd_list, &count);
if (0 < count) {
if (true == cb_ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "Callback result is true");
+ SLOG(LOG_INFO, TAG_VCM, "Callback result is true");
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");
+ SLOG(LOG_INFO, TAG_VCM, "Callback result is false");
/* need to select conflicted result */
}
} else {
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");
+ SLOG(LOG_INFO, TAG_VCM, "Pre result callback is called");
return;
}
vc_mgr_client_use_callback(g_vc_m);
callback(user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Speech detected callback called");
+ SLOG(LOG_INFO, TAG_VCM, "Speech detected callback called");
return EINA_FALSE;
}
vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set all result callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set all result callback");
return 0;
}
int vc_mgr_unset_all_result_cb(void)
{
if (0 != __vc_mgr_get_feature_enabled()) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] not supported");
return VC_ERROR_NOT_SUPPORTED;
}
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");
+ SLOG(LOG_INFO, TAG_VCM, "Error callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
}
vc_mgr_client_use_callback(g_vc_m);
changed_callback(before_state, current_state, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "State changed callback is called");
+ SLOG(LOG_INFO, TAG_VCM, "State changed callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
}
vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set state changed callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set state changed callback");
return 0;
}
vc_service_state_e before_state;
vc_mgr_client_get_service_state(g_vc_m, &before_state);
- SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
+ SLOG(LOG_INFO, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
before_state, current_state);
vc_internal_state_e internal_state = -1;
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");
+ SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE");
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
}
if (VC_SERVICE_STATE_UPDATING == current_state) {
- SLOG(LOG_DEBUG, TAG_VCM, "Internal state is changed to NONE by updating");
+ SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE by updating");
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
}
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");
+ SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
}
vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set service state changed callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set service 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");
+ SLOG(LOG_INFO, 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");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set current language changed callback");
return 0;
}
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, disp_text(%s), utt)text(%s), continuous(%d)", disp_text, utt_text, continuous);
+ SLOG(LOG_INFO, TAG_VCM, "Dialog callback is called, disp_text(%s), utt)text(%s), continuous(%d)", disp_text, utt_text, continuous);
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
}
vc_mgr_client_use_callback(g_vc_m);
ret = callback(key, data, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Private data set callback is called");
+ SLOG(LOG_INFO, TAG_VCM, "Private data set callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data set callback is null");
}
vc_mgr_client_use_callback(g_vc_m);
ret = callback(key, data, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Private data requested callback is called");
+ SLOG(LOG_INFO, TAG_VCM, "Private data requested callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data requested callback is null");
}
vc_mgr_client_use_callback(g_vc_m);
callback(rate, channel, audio_type, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "TTS feedback audio format callback is called");
+ SLOG(LOG_INFO, TAG_VCM, "TTS feedback audio format callback is called");
} else {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback audio format callback is null");
}
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get callee appid by pid");
return false;
}
- SLOG(LOG_DEBUG, TAG_VCM, "[CHECK] Appid - %s", appid);
+ SLOG(LOG_INFO, TAG_VCM, "[CHECK] Appid - %s", appid);
GSList *iter = NULL;
vc_demandable_client_s* temp_client;
static Eina_Bool __request_auth_start(void* data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "Request Start");
+ SLOG(LOG_INFO, TAG_VCM, "Request Start");
if (0 != vc_mgr_client_set_start_by_client(g_vc_m, true)) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
static Eina_Bool __request_auth_stop(void* data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "Request Stop");
+ SLOG(LOG_INFO, TAG_VCM, "Request Stop");
if (0 != vc_mgr_stop()) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed");
static Eina_Bool __request_auth_cancel(void* data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "Request Cancel");
+ SLOG(LOG_INFO, TAG_VCM, "Request Cancel");
if (0 != vc_mgr_cancel()) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed");
vc_mgr_client_use_callback(g_vc_m);
callback(engine_app_id, event, result, user_data);
vc_mgr_client_not_use_callback(g_vc_m);
- SLOG(LOG_DEBUG, TAG_VCM, "Specific engine result callback is called, engine app id(%s), event(%s), result(%s)", engine_app_id, event, result);
+ SLOG(LOG_INFO, TAG_VCM, "Specific engine result callback is called, engine app id(%s), event(%s), result(%s)", engine_app_id, event, result);
return;
}
/* for TTS feedback */
int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] set feedback audio format");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback audio format");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
vc_mgr_client_set_feedback_audio_format_cb(g_vc_m, callback, user_data);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set feedback audio format callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback audio format callback");
return 0;
}
int vc_mgr_unset_feedback_audio_format_cb()
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] unset feedback audio format");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback audio format");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
vc_mgr_client_set_feedback_audio_format_cb(g_vc_m, NULL, NULL);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Unset feedback audio format callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback audio format callback");
return 0;
}
int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] set feedback streaming");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback streaming");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
return 0;
}
int vc_mgr_unset_feedback_streaming_cb()
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] unset feedback streaming");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback streaming");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
return 0;
}
pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
return 0;
}
pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
return 0;
}
static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Start thread");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Start thread");
vc_feedback_data_s* feedback_data = NULL;
ret = vc_mgr_data_get_feedback_data(&feedback_data);
if (0 != ret || NULL == feedback_data) {
/* empty queue */
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No feedback data. Waiting mode");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No feedback data. Waiting mode");
/* waiting */
while (1) {
static void __end_tts_feedback_thread(void* data, Ecore_Thread* thread)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] End thread");
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] End thread");
g_feedback_thread = NULL;
}
int vc_mgr_start_feedback(void)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] start feedback");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] start feedback");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
return VC_ERROR_PERMISSION_DENIED;
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request start TTS feedback");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request start TTS feedback");
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
int vc_mgr_stop_feedback(void)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] stop feedback");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] stop feedback");
if (0 != __vc_mgr_get_feature_enabled()) {
return VC_ERROR_NOT_SUPPORTED;
return VC_ERROR_PERMISSION_DENIED;
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request stop TTS feedback");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request stop TTS feedback");
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
int vc_mgr_send_utterance_status(int pid, int utt_id, int utt_status)
{
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send utterance status, pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
+ SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send utterance status, pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
return VC_ERROR_INVALID_STATE;
}
- int ret = -1;
- ret = vc_mgr_dbus_send_utterance_status(pid, utt_id, utt_status);
- if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to send utterance status : %s", __vc_mgr_get_error_code(ret));
+ int ret = vc_mgr_dbus_send_utterance_status(pid, utt_id, utt_status);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send utterance status : %s", __vc_mgr_get_error_code(ret));
return ret;
- } else {
- SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Send utterance status");
- }
+ } else {
+ SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Send utterance status");
+ }
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
return 0;
int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Send audio streaming to the engine service");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] Send audio streaming to the engine service");
if (NULL == buffer) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
if (0 != ret) {
SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data");
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to send");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to send");
}
return ret;
int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e streaming_mode)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set multi assistant mode");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] Set multi assistant mode");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
ret = sound_manager_create_stream_information_internal(stream_type, NULL, NULL, &g_stream_for_volume_h);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to create stream information, ret(%d)", ret);
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create stream information, ret(%d)", ret);
return VC_ERROR_OPERATION_FAILED;
}
int vc_mgr_change_system_volume(vc_system_volume_event_e volume_event)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Change system volume, volume_event(%d)", volume_event);
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] Change system volume, volume_event(%d)", volume_event);
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to change volume");
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to change volume");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to change volume");
}
return ret;
}
int vc_mgr_recover_system_volume()
{
- SLOG(LOG_DEBUG, TAG_VCM, "[Manager] recover system volume");
+ SLOG(LOG_INFO, TAG_VCM, "[Manager] recover system volume");
if (0 != __vc_mgr_get_feature_enabled()) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to recover volume");
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to recover volume");
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to recover volume");
}
return ret;
}
SLOG(LOG_ERROR, TAG_VCM, "[DATA ERROR] feedback data is NULL");
return VC_ERROR_INVALID_PARAMETER;
}
- SLOG(LOG_DEBUG, TAG_VCM, "[DATA] feedback_data : %p", data);
+ SLOG(LOG_INFO, TAG_VCM, "[DATA] feedback_data : %p", data);
pthread_mutex_lock(&g_feedback_data_mutex);
int vc_mgr_data_get_feedback_data(vc_feedback_data_s** data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[DATA] feedback_data : %p", *data);
+ SLOG(LOG_INFO, TAG_VCM, "[DATA] feedback_data : %p", *data);
pthread_mutex_lock(&g_feedback_data_mutex);
if (0 == g_feedback_data.size()) {
- SLOG(LOG_DEBUG, TAG_VCM, "[DATA] There is no feedback data");
+ SLOG(LOG_INFO, TAG_VCM, "[DATA] There is no feedback data");
*data = NULL;
pthread_mutex_unlock(&g_feedback_data_mutex);
int vc_mgr_data_clear_feedback_data(vc_feedback_data_s** data)
{
- SLOG(LOG_DEBUG, TAG_VCM, "[DATA] clear feedback data, empty(%d)", g_feedback_data.empty());
+ SLOG(LOG_INFO, TAG_VCM, "[DATA] clear feedback data, empty(%d)", g_feedback_data.empty());
pthread_mutex_lock(&g_feedback_data_mutex);
if (!g_feedback_data.empty()) {
if (NULL != *data) {
- SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] pid(%d), utt_id(%d), data(%p) size(%d) rate(%d)", (*data)->pid, (*data)->utt_id, (*data)->data, (*data)->data_size, (*data)->rate);
+ SLOG(LOG_INFO, TAG_VCM, "[DEBUG] pid(%d), utt_id(%d), data(%p) size(%d) rate(%d)", (*data)->pid, (*data)->utt_id, (*data)->data, (*data)->data_size, (*data)->rate);
if (NULL != (*data)->data) {
free((*data)->data);
} /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get Speech detected");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get Speech detected");
__vc_mgr_cb_speech_detected();
} /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get All Result");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get All Result");
int result_type = 0;
dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
} /* VCD_MANAGER_METHOD_ALL_RESULT */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_PRE_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get Pre Result");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get Pre Result");
int event;
char* pre_result = NULL;
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
} /* VCD_MANAGER_METHOD_PRE_RESULT */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get specific engine result");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get specific engine result");
char* engine_app_id = NULL;
char* event = NULL;
char* result = NULL;
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
} /* VCD_MANAGER_METHOD_SPECIFIC_ENGINE_RESULT */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get System Result");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get System Result");
__vc_mgr_cb_system_result();
} /* VCD_MANAGER_METHOD_RESULT */
else if (dbus_message_is_signal(msg, if_name, VCC_MANAGER_METHOD_SET_FOREGROUND)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Set foreground");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Set foreground");
int pid = 0;
int value = 0;
dbus_error_free(&err);
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
+ SLOG(LOG_INFO, TAG_VCM, "@@ foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
__vc_mgr_cb_set_foreground(pid, (bool)value);
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
} /* VCC_MANAGER_METHOD_SET_FOREGROUND */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_DIALOG)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Request Dialog");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Request Dialog");
int pid = -1;
char* disp_text = NULL;
char* utt_text = NULL;
} /* VCD_MANAGER_METHOD_ERROR */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SET_PRIVATE_DATA)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request set private data");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request set private data");
int pid = 0;
char* key = NULL;
char* private_data = NULL;
}
if (pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request set private data : pid(%d) ", pid);
__vc_mgr_cb_private_data_set(key, private_data);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get request set private data : invalid pid ");
} /* VCD_MANAGER_METHOD_SET_PRIVATE_DATA */
else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_GET_PRIVATE_DATA)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request get private data");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request get private data");
int pid = 0;
int ret = -1;
char* key = NULL;
}
if (pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get request get private data : pid(%d) ", pid);
ret = __vc_mgr_cb_private_data_requested(key, &temp);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get request get private data : invalid pid ");
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc get request get private data : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc get request get private data : result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc get request get private data : result(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
/* Authority */
else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request auth enable");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth enable");
int pid;
int ret = 0;
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth enable : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth enable : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth enable : pid(%d)", pid);
ret = __vc_mgr_request_auth_enable(pid);
}
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth enable : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth enable : ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth enable : ret(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
} /* VC_METHOD_AUTH_ENABLE */
else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_DISABLE)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request auth disable");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth disable");
int pid;
int ret = 0;
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth disable : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth disable : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth disable : pid(%d)", pid);
ret = __vc_mgr_request_auth_disable(pid);
}
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth disable : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth disable : ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth disable : ret(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
} /* VC_METHOD_AUTH_DISABLE */
else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_START)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request auth start");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth start");
int pid;
int ret = 0;
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth start : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth start : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth start : pid(%d)", pid);
ret = __vc_mgr_request_auth_start(pid);
}
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth start : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth start : ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth start : ret(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
} /* VC_METHOD_AUTH_START */
else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_STOP)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request auth stop");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth stop");
int pid;
int ret = 0;
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth stop : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth stop : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth stop : pid(%d)", pid);
ret = __vc_mgr_request_auth_stop(pid);
}
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth stop : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth stop : ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth stop : ret(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
} /* VC_METHOD_AUTH_STOP */
else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_CANCEL)) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Get request auth cancel");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Get request auth cancel");
int pid;
int ret = 0;
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr request auth cancel : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr request auth cancel : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr request auth cancel : pid(%d)", pid);
ret = __vc_mgr_request_auth_cancel(pid);
}
if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
SLOG(LOG_ERROR, TAG_VCM, "@@ vc request auth cancel : fail to send reply");
else
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc request auth cancel : ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc request auth cancel : ret(%d)", ret);
dbus_connection_flush(g_m_conn_listener);
dbus_message_unref(reply);
} else {
} /* VC_METHOD_AUTH_CANCEL */
else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@@ Owner Changed");
+ SLOG(LOG_INFO, TAG_VCM, "@@@ Owner Changed");
/* remove a rule for daemon error */
DBusError err;
/* initialize the error value */
return -1;
}
- SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
+ SLOG(LOG_INFO, TAG_VCM, "[DBUS] Reconnect");
}
return 0;
result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_short_time, &err);
if (dbus_error_is_set(&err)) {
- SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
dbus_error_free(&err);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr finalize : pid(%d)", pid);
}
dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr finalize : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr finalize : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : result = %d", result);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set command : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set command : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set command : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set command : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : result = %d", result);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr unset command : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr unset command : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr unset command : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr unset command : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : result = %d", result);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set demandable client : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set demandable client : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set audio type : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set audio type : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get audio type : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get audio type : pid(%d)", pid);
}
dbus_message_append_args(msg,
if (NULL != audio_type && NULL != temp) {
*audio_type = strdup(temp);
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get audio type : result = %d audio type = %s", result, temp);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get audio type : result = %d audio type = %s", result, temp);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc set private data : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set private data : pid(%d), data(%s)", pid, data);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc set private data : pid(%d), data(%s)", pid, data);
}
dbus_message_append_args(msg,
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get private data : pid(%d), key(%s)", pid, key);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get private data : pid(%d), key(%s)", pid, key);
}
dbus_message_append_args(msg,
} else {
*data = strdup(temp);
}
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get private data : result = %d private data = %s", result, *data);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr get private data : result = %d private data = %s", result, *data);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_INFO, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set client info : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set client info : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set client info : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr set client info : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : pid(%d), domain(%s)", pid, domain);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : pid(%d), domain(%s)", pid, domain);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : pid(%d), type(%d), send_event(%s)", pid, type, send_event);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc set domain : pid(%d), type(%d), send_event(%s)", pid, type, send_event);
}
dbus_message_append_args(msg,
dbus_message_unref(msg);
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_m_conn_sender);
}
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
pid, recognition_mode, exclusive_command_option, start_by_client);
}
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr start : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr start : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr stop : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr stop : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr stop : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc mgr stop : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc cancel : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc cancel : pid(%d)", pid);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc cancel : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc cancel : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc enable command type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc enable command type : pid(%d) type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc enable command type : pid(%d) type(%d)", pid, cmd_type);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc enable command type : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc enable command type : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc enable command type : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc disable command type : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc disable command type : pid(%d) type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc disable command type : pid(%d) type(%d)", pid, cmd_type);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc disable command type : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc disable command type : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc disable command type : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
return NULL;
}
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name);
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name);
return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
}
if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Success to send result");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] Success to send result");
dbus_connection_flush(g_m_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc result selection : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc result selection : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc result selection : pid(%d)", pid);
}
dbus_message_append_args(msg,
SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_m_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc send specific engine : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc send specific engine : pid(%d), engine_app_id(%s), event(%s), request(%s)", pid, engine_app_id, event, request);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc send specific engine : pid(%d), engine_app_id(%s), event(%s), request(%s)", pid, engine_app_id, event, request);
}
dbus_message_append_args(msg,
dbus_message_unref(msg);
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_m_conn_sender);
}
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_VCM, "@@ vc send utterance status : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc send utterance status : pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc send utterance status : pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
}
dbus_message_append_args(msg,
dbus_message_unref(msg);
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_m_conn_sender);
}
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_VCM, "@@ vc send audio streaming : Fail to make message");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
}
dbus_message_append_args(msg,
if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send audio streaming");
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "[Dbus DEBUG] Success to send audio streaming");
+ SLOG(LOG_INFO, TAG_VCM, "[Dbus DEBUG] Success to send audio streaming");
dbus_connection_flush(g_m_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCM, "@@ vc change system volume : Fail to make message ");
return VC_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc change system volume : pid(%d) volume_event(%d)", pid, temp_event);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc change system volume : pid(%d) volume_event(%d)", pid, temp_event);
}
dbus_message_append_args(msg,
dbus_message_unref(result_msg);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ vc change system volume : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCM, "@@ vc change system volume : result = %d", result);
} else {
SLOG(LOG_ERROR, TAG_VCM, "@@ vc change system volume : result = %d", result);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
+ SLOG(LOG_ERROR, TAG_VCM, "@@ Result Message is NULL");
vc_mgr_dbus_reconnect();
result = VC_ERROR_TIMED_OUT;
}
bool vcd_client_manager_check_demandable_client(int pid)
{
if (0 == g_slist_length(g_demandable_client)) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] All client is available to request start");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] All client is available to request start");
return true;
}
/* Check demandable appid */
char appid[1024] = {0, };
if (0 == aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] %s(%d) requests start", appid, pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] %s(%d) requests start", appid, pid);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] daemon(%d) requests start", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] daemon(%d) requests start", pid);
}
/* Compare appid */
if (NULL != temp_client->appid) {
if (0 == strcmp(temp_client->appid, appid)) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] pid(%d) is available", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] pid(%d) is available", pid);
return true;
}
} else {
if (0 == strlen(appid)) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] pid(%d) is available", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] pid(%d) is available", pid);
return true;
}
}
/* There is no foreground app for voice control */
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Foreground pid(%d)", fg_pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Foreground pid(%d)", fg_pid);
/* 2. Clean up command list */
__vcd_client_release_commands();
/* Check exclusive system command */
if (true == g_manager.exclusive_cmd_option && 1 == vcd_config_get_command_type_enabled(VC_COMMAND_TYPE_EXCLUSIVE)) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Exclusive option of manager is ON");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Exclusive option of manager is ON");
GSList* ex_sys_cmd_list = NULL;
if (true == g_manager.manager_cmd) {
g_cur_cmd_list.exclusive_system_cmds = ex_sys_cmd_list;
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No exclusive system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No exclusive system commands");
}
return 0;
g_cur_cmd_list.system_cmds = sys_cmd_list;
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system commands");
}
GSList* sys_back_cmd_list = NULL;
g_cur_cmd_list.system_background_cmds = sys_back_cmd_list;
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system background commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system background commands");
}
/* 4. Set foreground commands and widget */
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No widget commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No widget commands");
}
/* 4-2. Set foreground command of foreground app */
}
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No foreground app");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No foreground app");
}
if (true == g_manager.manager_cmd && 1 == vcd_config_get_command_type_enabled(VC_COMMAND_TYPE_FOREGROUND)) {
/* 4-3. Set foreground command by manager */
ret = vc_cmd_parser_get_commands(g_manager.pid, VC_COMMAND_TYPE_FOREGROUND, &fg_cmd_list);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No foreground commands of manager app");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No foreground commands of manager app");
} else {
g_cur_cmd_list.foreground_cmds = fg_cmd_list;
}
g_cur_cmd_list.total_cmd_count = command_count;
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Command count : %d ", g_cur_cmd_list.total_cmd_count);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Command count : %d ", g_cur_cmd_list.total_cmd_count);
return command_count;
}
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No widget commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No widget commands");
}
if (0 < g_slist_length(g_cur_cmd_list.foreground_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No foreground commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No foreground commands");
}
if (0 < g_slist_length(g_cur_cmd_list.system_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system commands");
}
if (0 < g_slist_length(g_cur_cmd_list.system_background_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system background commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system background commands");
}
if (0 < g_slist_length(g_cur_cmd_list.exclusive_system_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No exclusive system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No exclusive system commands");
}
if (0 < g_slist_length(g_cur_cmd_list.background_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No background commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No background commands");
}
return 0;
}
GSList *iter = NULL;
vc_cmd_s* temp_cmd;
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Result id(%d)", result_id);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Result id(%d)", result_id);
if (0 < g_slist_length(g_cur_cmd_list.widget_cmds)) {
iter = g_slist_nth(g_cur_cmd_list.widget_cmds, 0);
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No widget commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No widget commands");
}
if (0 < g_slist_length(g_cur_cmd_list.foreground_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No foreground commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No foreground commands");
}
if (0 < g_slist_length(g_cur_cmd_list.system_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system commands");
}
if (0 < g_slist_length(g_cur_cmd_list.system_background_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No system background commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No system background commands");
}
if (0 < g_slist_length(g_cur_cmd_list.exclusive_system_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No exclusive system commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No exclusive system commands");
}
if (0 < g_slist_length(g_cur_cmd_list.background_cmds)) {
iter = g_slist_next(iter);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] No background commands");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] No background commands");
}
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Not find matched result");
client_info->server_dialog = is_server_dialog;
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Set server dialog, client pid(%d), server_dialog(%d)", pid, client_info->server_dialog);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Set server dialog, client pid(%d), server_dialog(%d)", pid, client_info->server_dialog);
return 0;
}
*is_server_dialog = client_info->server_dialog;
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Get server dialog, client pid(%d), server_dialog(%d)", pid, *is_server_dialog);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] Get server dialog, client pid(%d), server_dialog(%d)", pid, *is_server_dialog);
return 0;
}
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data SUCCESS] Add new client");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new client");
}
#ifdef CLIENT_DATA_DEBUG
count++;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] client count : %d", count);
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data] client count : %d", count);
return count;
}
return -1;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Client Data SUCCESS] Add new widget");
+ SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new widget");
}
#ifdef CLIENT_DATA_DEBUG
int i;
if (0 == count) {
- SLOG(LOG_DEBUG, TAG_VCD, "No Client");
+ SLOG(LOG_INFO, TAG_VCD, "No Client");
} else {
iter = g_slist_nth(g_client_list, 0);
for (i = 0; i < count; i++) {
data = iter->data;
if (NULL != data) {
- SLOG(LOG_DEBUG, TAG_VCD, "[%dth] pid(%d)", i, data->pid);
+ SLOG(LOG_INFO, TAG_VCD, "[%dth] pid(%d)", i, data->pid);
if (pid == data->pid) {
SLOG(LOG_INFO, TAG_VCD, "[INFO] foreground pid (%d)", data->pid);
vcd_config_set_foreground(data->pid, true);
count = g_slist_length(g_widget_list);
if (0 == count) {
- SLOG(LOG_DEBUG, TAG_VCD, "No widget");
+ SLOG(LOG_INFO, TAG_VCD, "No widget");
} else {
iter = g_slist_nth(g_widget_list, 0);
for (i = 0; i < count; i++) {
widget_data = iter->data;
if (NULL != widget_data) {
- SLOG(LOG_DEBUG, TAG_VCD, "[%dth] pid(%d)", i, widget_data->pid);
+ SLOG(LOG_INFO, TAG_VCD, "[%dth] pid(%d)", i, widget_data->pid);
if (pid == widget_data->pid) {
SLOG(LOG_INFO, TAG_VCD, "[INFO] foreground pid (%d)", widget_data->pid);
vcd_config_set_foreground(widget_data->pid, true);
{
g_state = state;
- SLOG(LOG_DEBUG, TAG_VCD, "[Config] Config is changed : %d", g_state);
+ SLOG(LOG_INFO, TAG_VCD, "[Config] Config is changed : %d", g_state);
return 0;
}
return -1;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[DBUS] Reconnect");
+ SLOG(LOG_INFO, TAG_VCD, "[DBUS] Reconnect");
}
return 0;
dbus_message_unref(result_msg);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
+ SLOG(LOG_WARN, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
}
return result;
DBusMessage* msg;
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
msg = dbus_message_new_method_call(
service_name,
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
dbus_message_unref(msg);
return -1;
} else {
- if (10 == g_volume_count) {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume);
+ if (20 == g_volume_count) {
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume);
g_volume_count = 0;
}
DBusMessage* msg = NULL;
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
switch (cmd_type) {
case VC_COMMAND_TYPE_FOREGROUND:
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
DBusMessage* msg = NULL;
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
switch (cmd_type) {
case VC_COMMAND_TYPE_WIDGET:
}
dbus_message_unref(result_msg);
- SLOG(LOG_DEBUG, TAG_VCD, "@@ vc send asr result : result = %d", result);
+ SLOG(LOG_INFO, TAG_VCD, "@@ vc send asr result : result = %d", result);
*is_consumed = result;
return VCD_ERROR_NONE;
} else {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
int vcdc_send_specific_engine_result_to_manager(int manager_pid, const char* engine_app_id, const char* event, const char* result)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[VCDC] send specific engine result to manager, mgr pid(%d), engine app id(%s), event(%s), result(%s),",
+ SLOG(LOG_INFO, TAG_VCD, "[VCDC] send specific engine result to manager, mgr pid(%d), engine app id(%s), event(%s), result(%s),",
manager_pid, engine_app_id, event, result);
if (0 != __dbus_check()) {
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
return VCD_ERROR_OUT_OF_MEMORY;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to manager : state(%d)", state);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to manager : state(%d)", state);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to client : state(%d)", state);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to client : state(%d)", state);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to widget client : state(%d)", state);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send service state message to widget client : state(%d)", state);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send manager pid to client : pid(%d)", manager_pid);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send manager pid to client : pid(%d)", manager_pid);
dbus_connection_flush(g_conn_sender);
}
return VCD_ERROR_OUT_OF_MEMORY;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
char* disp_null = NULL;
char* utt_null = NULL;
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send");
dbus_connection_flush(g_conn_sender);
}
}
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager : reason(%d), Error Msg(%s)", reason, temp_msg);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal to manager : reason(%d), Error Msg(%s)", reason, temp_msg);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
dbus_connection_flush(g_conn_sender);
}
SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
+ SLOG(LOG_INFO, TAG_VCD, "@@ Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
dbus_connection_flush(g_conn_sender);
}
dbus_message_unref(msg);
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send request set private data");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] SUCCESS Send request set private data");
dbus_connection_flush(g_conn_sender);
}
dbus_message_unref(result_msg);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
}
if (NULL != data && NULL != temp) {
/* Flush messages which are received before fd event handler registration */
while (DBUS_DISPATCH_COMPLETE != dbus_connection_get_dispatch_status(g_conn_listener)) {
- SLOG(LOG_DEBUG, TAG_VCD, "Dbus data is remained, g_conn_listener(%p)", g_conn_listener);
+ SLOG(LOG_INFO, TAG_VCD, "Dbus data is remained, g_conn_listener(%p)", g_conn_listener);
listener_event_callback(NULL, NULL);
}
__vcd_dbus_connection_free();
return VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "Get fd from dbus : %d", fd);
+ SLOG(LOG_INFO, TAG_VCD, "Get fd from dbus : %d", fd);
}
g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
foreground = vcd_server_get_foreground();
daemon_pid = getpid();
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr initialize : pid(%d) service state(%d) foreground(%d) daemon_pid(%d)", pid, service_state, foreground, daemon_pid);
}
DBusMessage* reply;
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr finalize : pid(%d)", pid);
ret = vcd_server_mgr_finalize(pid);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set command : pid(%d)", pid);
ret = vcd_server_mgr_set_command(pid);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr unset command : pid(%d)", pid);
ret = vcd_server_mgr_unset_command(pid);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set demandable client : pid(%d)", pid);
ret = vcd_server_mgr_set_demandable_client(pid);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
ret = vcd_server_mgr_set_audio_type(pid, audio_type);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set audio type : pid(%d)", pid);
ret = vcd_server_mgr_get_audio_type(pid, &audio_type);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), audio type(%s)", ret, audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), audio type(%s)", ret, audio_type);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set client info : pid(%d)", pid);
ret = vcd_server_mgr_set_client_info(pid);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), key(%s), data(%s)", pid, key, data);
ret = vcd_server_mgr_set_private_data(pid, key, data);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to set private data");
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr get private data : pid(%d), key(%s)", pid, key);
ret = vcd_server_mgr_get_private_data(pid, key, &data);
}
char *temp_data = NULL;
if (NULL == data) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Dbus INFO] data parameter is NULL");
+ SLOG(LOG_INFO, TAG_VCD, "[Dbus INFO] data parameter is NULL");
temp_data = strdup("#NULL");
} else {
temp_data = strdup(data);
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), private data(%s)", ret, temp_data);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), private data(%s)", ret, temp_data);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
ret = VCD_ERROR_OPERATION_FAILED;
} else {
ret = vcd_server_mgr_send_specific_engine_request(pid, engine_app_id, event, request);
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr specific engine request : pid(%d), engine_app_id(%s), event(%s), request(%s), ret(%d)", pid, engine_app_id, event, request, ret);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr specific engine request : pid(%d), engine_app_id(%s), event(%s), request(%s), ret(%d)", pid, engine_app_id, event, request, ret);
}
return 0;
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr set domain : pid(%d), domain(%s)", pid, domain);
ret = vcd_server_mgr_set_domain(pid, domain);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr request to do action : pid(%d), type(%d) send_event(%s)", pid, type, send_event);
ret = vcd_server_mgr_do_action(pid, type, send_event);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to do action");
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr enable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr enable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
ret = vcd_server_mgr_enable_command_type(pid, cmd_type);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr disable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr disable command type : pid(%d), cmd_type(%d)", pid, cmd_type);
ret = vcd_server_mgr_disable_command_type(pid, cmd_type);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive, start_by_client);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr start : pid(%d) recognition_mode(%d) exclusive(%d) start by client(%d)", pid, recognition_mode, exclusive, start_by_client);
ret = vcd_server_mgr_start((vcd_recognition_mode_e)recognition_mode, (bool)exclusive, (bool)start_by_client);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr stop : pid(%d)", pid);
ret = vcd_server_mgr_stop();
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr cancel : pid(%d)", pid);
ret = vcd_server_mgr_cancel();
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr result selection : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr result selection : pid(%d)", pid);
vcd_server_mgr_result_select();
}
return 0;
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] vcd mgr start TTS feedback : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] vcd mgr start TTS feedback : pid(%d)", pid);
ret = vcd_server_mgr_start_feedback();
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] vcd mgr stop TTS feedback : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] vcd mgr stop TTS feedback : pid(%d)", pid);
ret = vcd_server_mgr_stop_feedback();
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
ret = vcd_server_mgr_send_audio_streaming(pid, event, buffer, len);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr change system volume: pid(%d), volume_event(%d)", pid, volume_event);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd mgr change system volume: pid(%d), volume_event(%d)", pid, volume_event);
ret = vcd_server_mgr_change_system_volume(pid, volume_event);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
ret = vcd_server_initialize(pid);
service_state = vcd_server_get_service_state();
daemon_pid = getpid();
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
}
int mgr_pid = vcd_client_manager_get_pid();
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd finalize : pid(%d)", pid);
ret = vcd_server_finalize(pid);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set command : pid(%d), cmd_type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set command : pid(%d), cmd_type(%d)", pid, cmd_type);
ret = vcd_server_set_command(pid, (vc_cmd_type_e)cmd_type);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd unset command : pid(%d), cmd_type(%d)", pid, cmd_type);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd unset command : pid(%d), cmd_type(%d)", pid, cmd_type);
ret = vcd_server_unset_command(pid, (vc_cmd_type_e)cmd_type);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
} else {
bool tmp_value;
tmp_value = (bool)value;
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set foreground : pid(%d), value(%s)", pid, value ? "true" : "false");
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set foreground : pid(%d), value(%s)", pid, value ? "true" : "false");
vcd_server_set_foreground(pid, tmp_value);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd set server dialog : pid(%d), app_id(%s)", pid, app_id);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd set server dialog : pid(%d), app_id(%s)", pid, app_id);
ret = vcd_server_set_server_dialog(pid, app_id, credential);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd request dialog : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", pid, disp_text, utt_text, continuous);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd dialog : pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", pid, disp_text, utt_text, continuous);
ret = vcd_server_dialog(pid, disp_text, utt_text, continuous);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to dialog");
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd request to check system command is valid : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd dialog : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd dialog : pid(%d)", pid);
ret = vcd_server_is_system_command_valid(pid, &is_sys_cmd_valid);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), is_sys_cmd_valid (%d)", ret, is_sys_cmd_valid);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), is_sys_cmd_valid (%d)", ret, is_sys_cmd_valid);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
ret = vcd_server_widget_initialize(pid);
service_state = vcd_server_get_service_state();
daemon_pid = getpid();
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget initialize : pid(%d) daemon_pid(%d)", pid, daemon_pid);
}
DBusMessage* reply;
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget finalize : pid(%d)", pid);
ret = vcd_server_widget_finalize(pid);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start recording : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget start recording : pid(%d)", pid);
ret = vcd_server_widget_start_recording(pid, widget_command);
}
/* Append result and language */
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget start : pid(%d), silence(%d)", pid, silence);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget start : pid(%d), silence(%d)", pid, silence);
ret = vcd_server_widget_start(pid, (bool)silence);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget stop : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget stop : pid(%d)", pid);
ret = vcd_server_widget_stop(pid);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget cancel : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget cancel : pid(%d)", pid);
ret = vcd_server_widget_cancel(pid);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd widget enable asr result : pid(%d) enable(%d)", pid, enable);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd widget enable asr result : pid(%d) enable(%d)", pid, enable);
ret = vcd_server_widget_enable_asr_result(pid, enable);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd server set language : language(%s)", language);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd server set language : language(%s)", language);
ret = vcd_server_set_language(language);
}
dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd request tts : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd request tts : pid(%d), text(%s), language(%s), to_vcm(%d)", pid, text, language, to_vcm);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd request tts : pid(%d), text(%s), language(%s), to_vcm(%d)", pid, text, language, to_vcm);
ret = vcd_server_request_tts(pid, text, language, to_vcm, &utt_id);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d), utt_id(%d)", ret, utt_id);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d), utt_id(%d)", ret, utt_id);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd cancel tts : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd cancel tts : pid(%d), utt_id(%d)", pid, utt_id);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd cancel tts : pid(%d), utt_id(%d)", pid, utt_id);
ret = vcd_server_cancel_tts(pid, utt_id);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd get tts audio format : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd get tts audio format : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[IN] vcd get tts audio format : pid(%d)", pid);
ret = vcd_server_get_tts_audio_format(pid, &rate, &channel, &audio_type);
}
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[OUT SUCCESS] Result(%d)", ret);
} else {
SLOG(LOG_ERROR, TAG_VCD, "[OUT ERROR] Result(%d)", ret);
}
int vcd_engine_agent_init()
{
if (true == g_agent_init) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Already initialized");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Already initialized");
return VCD_ERROR_NONE;
}
}
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent Initialize");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent Initialize");
return 0;
}
g_agent_init = false;
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent release");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent release");
return 0;
}
static int __internal_get_engine_info(vce_request_callback_s* callback)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] inside __internal_get_engine_info");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] inside __internal_get_engine_info");
if (NULL == callback) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid engine");
g_dynamic_engine.internal_callbacks->get_tts_audio_format = NULL;
g_dynamic_engine.internal_callbacks->get_tts_audio_format_user_data = NULL;
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Valid Engine");
- SLOG(LOG_DEBUG, TAG_VCD, "Engine uuid : %s", g_dynamic_engine.engine_uuid);
- SLOG(LOG_DEBUG, TAG_VCD, "Engine name : %s", g_dynamic_engine.engine_name);
- SLOG(LOG_DEBUG, TAG_VCD, "Engine setting : %s", g_dynamic_engine.engine_setting_path);
- SLOG(LOG_DEBUG, TAG_VCD, "@@@");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Valid Engine");
+ SLOG(LOG_INFO, TAG_VCD, "Engine uuid : %s", g_dynamic_engine.engine_uuid);
+ SLOG(LOG_INFO, TAG_VCD, "Engine name : %s", g_dynamic_engine.engine_name);
+ SLOG(LOG_INFO, TAG_VCD, "Engine setting : %s", g_dynamic_engine.engine_setting_path);
+ SLOG(LOG_INFO, TAG_VCD, "@@@");
return 0;
}
int vcd_engine_agent_load_current_engine(vce_request_callback_s* callback)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] load current engine START");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] load current engine START");
if (false == g_agent_init) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
return ret;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] The %s has been loaded!!!", g_dynamic_engine.engine_name);
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] The %s has been loaded!!!", g_dynamic_engine.engine_name);
g_dynamic_engine.is_loaded = true;
} else {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent WARNING] This engine do not support default language : lang(%s)", g_default_lang);
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] load current engine FINISH");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] load current engine FINISH");
return 0;
}
}
if (false == g_dynamic_engine.is_loaded) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Engine has already been unloaded");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Engine has already been unloaded");
return VCD_ERROR_NONE;
}
g_dynamic_engine.is_command_ready = true;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] set command");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] set command");
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Dynamic engine is not available");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Dynamic engine is not available");
}
return 0;
}
int ret = -1;
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] silence is %s", silence ? "true" : "false");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] silence is %s", silence ? "true" : "false");
if (true == g_dynamic_engine.is_loaded && true == g_dynamic_engine.is_command_ready) {
ret = g_dynamic_engine.callbacks->start(silence);
return VCD_ERROR_OPERATION_FAILED;
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Engine is not available (Cannot start)");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Engine is not available (Cannot start)");
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine start");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine start");
return 0;
}
return false;
}
- SLOG(LOG_DEBUG, TAG_VCD, "-- Language(%s)", language);
+ SLOG(LOG_INFO, TAG_VCD, "-- Language(%s)", language);
char* temp_lang = g_strdup(language);
SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Fail to set language of dynamic engine error(%d, %s)", ret, language);
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Dynamic engine is not available (Cannot start)");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Dynamic engine is not available (Cannot start)");
}
return 0;
int vcd_engine_agent_get_foreach_command(vce_cmd_h vce_command, vce_command_cb callback, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request foreach command from engine");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request foreach command from engine");
return vcd_client_foreach_command((client_foreach_command_cb)callback, user_data);
}
int vcd_engine_agent_get_command_count(vce_cmd_h vce_command, int* count)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request command length from engine");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request command length from engine");
*count = vcd_client_get_length();
return 0;
int vcd_engine_agent_get_audio_type(char** audio_type)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request audio type");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request audio type");
return vcd_recorder_get(audio_type);
}
int vcd_engine_agent_set_private_data(const char* key, const char* data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request set private data, key(%s), data(%s)", key, data);
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request set private data, key(%s), data(%s)", key, data);
vcdc_send_request_set_private_data(vcd_client_manager_get_pid(), key, data);
return VCD_ERROR_NONE;
int vcd_engine_agent_get_private_data(const char* key, char** data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request get private data, key(%s)", key);
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request get private data, key(%s)", key);
vcdc_send_request_get_private_data(vcd_client_manager_get_pid(), key, data);
return VCD_ERROR_NONE;
int vcd_engine_agent_start_recording()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request start recording");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request start recording");
int ret = vcd_recorder_start();
if (0 != ret) {
int vcd_engine_agent_stop_recording()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request stop recording");
+ SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request stop recording");
return vcd_recorder_stop();
}
if (BT_ERROR_NONE != bt_hid_send_rc_command(NULL, input_data, sizeof(input_data))) {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail bt_hid_send_rc_command");
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Extend bt audio recorder");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Extend bt audio recorder");
}
}
g_bt_extend_count++;
static void __recorder_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
sound_stream_focus_change_reason_e reason, int sound_behavior, const char *extra_info, void *user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Focus state changed cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Focus state changed cb");
if (stream_info != g_stream_info_h) {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Invalid stream info handle");
if (0 != ret) {
SLOG(LOG_WARN, TAG_VCD, "[Recorder] No device");
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Apply device for stream routing");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Apply device for stream routing");
}
return ret;
}
if (type == SOUND_DEVICE_USB_AUDIO) {
bool is_recording_state = false;
if (VCD_RECORDER_STATE_RECORDING == g_recorder_state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Stop recorder");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Stop recorder");
vcd_recorder_stop();
is_recording_state = true;
}
return;
}
if (true == is_recording_state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Start recorder");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Start recorder");
vcd_recorder_start();
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Apply device for stream routing");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Apply device for stream routing");
}
}
return;
audio_channel_e audio_ch;
audio_sample_type_e audio_type;
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Audio type(%d) rate(%d) channel(%d)", g_audio_type, g_audio_rate, g_audio_channel);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Audio type(%d) rate(%d) channel(%d)", g_audio_type, g_audio_rate, g_audio_channel);
switch (g_audio_channel) {
case 1: audio_ch = AUDIO_CHANNEL_MONO; break;
}
if (false == is_bt_failed) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Bluetooth is available");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Bluetooth is available");
g_is_valid_bt_in = true;
}
#endif
}
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Audio type : %s", g_current_audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Audio type : %s", g_current_audio_type);
return 0;
}
int vcd_recorder_set(const char* audio_type, vce_audio_type_e type, int rate, int channel)
{
if (NULL == audio_type) {
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Audio type is NULL");
return VCD_ERROR_INVALID_PARAMETER;
}
if (NULL != g_current_audio_type) {
if (0 == strncmp(g_current_audio_type, audio_type, strlen(g_current_audio_type))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio type is already set : %s", audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio type is already set : %s", audio_type);
return 0;
}
} else {
return VCD_ERROR_INVALID_STATE;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] set audio type (%s)", audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] set audio type (%s)", audio_type);
vcd_engine_set_audio_type(audio_type);
if (VCD_RECORDER_STATE_READY != g_recorder_state) {
strncmp(g_current_audio_type, VCE_AUDIO_ID_WIFI, strlen(g_current_audio_type)) &&
strncmp(g_current_audio_type, VCE_AUDIO_ID_NONE, strlen(g_current_audio_type)) &&
!strncmp(audio_type, VCE_AUDIO_ID_NONE, strlen(audio_type)))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Skip stop recording while Recorder is NOT ready");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Skip stop recording while Recorder is NOT ready");
} else {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Recorder is NOT ready");
vcd_recorder_stop();
}
if (g_audio_type != type || g_audio_rate != rate || g_audio_channel != channel) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] New audio type(%d) rate(%d) channel(%d)", type, rate, channel);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] New audio type(%d) rate(%d) channel(%d)", type, rate, channel);
audio_in_destroy(g_audio_h);
audio_channel_e audio_ch;
#endif
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio type is changed : %s", g_current_audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio type is changed : %s", g_current_audio_type);
return 0;
}
int ret = -1;
if (VCD_RECORDER_STATE_RECORDING != g_recorder_state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Exit audio reading normal func");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Exit audio reading normal func");
return EINA_FALSE;
}
}
if (g_audio_type != type || g_audio_rate != rate || g_audio_channel != channel) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] New audio type(%d) rate(%d) channel(%d)", type, rate, channel);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] New audio type(%d) rate(%d) channel(%d)", type, rate, channel);
audio_in_destroy(g_audio_h);
audio_channel_e audio_ch;
g_audio_rate = rate;
g_audio_channel = channel;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] audio type(%d) rate(%d) channel(%d)", g_audio_type, g_audio_rate, g_audio_channel);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] audio type(%d) rate(%d) channel(%d)", g_audio_type, g_audio_rate, g_audio_channel);
}
}
int vcd_recorder_start_streaming()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] start streaming");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] start streaming");
vcd_audio_streaming_mode_e streaming_mode;
vcd_config_get_audio_streaming_mode(&streaming_mode);
if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
return VCD_ERROR_NONE;
}
vcd_audio_streaming_mode_e streaming_mode;
vcd_config_get_audio_streaming_mode(&streaming_mode);
if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
return VCD_ERROR_NONE;
}
int vcd_recorder_stop_streaming()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] stop streaming");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] stop streaming");
vcd_audio_streaming_mode_e streaming_mode;
vcd_config_get_audio_streaming_mode(&streaming_mode);
if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
return VCD_ERROR_NONE;
}
if (!g_stream_for_volume_h) {
ret = sound_manager_create_stream_information_internal(SOUND_STREAM_TYPE_VOICE_RECOGNITION_SERVICE, NULL, NULL, &g_stream_for_volume_h);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Fail to create stream information, ret(%d)", ret);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Fail to create stream information, ret(%d)", ret);
return VCD_ERROR_OPERATION_FAILED;
}
}
vcd_audio_streaming_mode_e streaming_mode;
vcd_config_get_audio_streaming_mode(&streaming_mode);
if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
return VCD_ERROR_NONE;
}
g_buffer_count = 0;
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Enter, recorder state(%d)", g_recorder_state);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Enter, recorder state(%d)", g_recorder_state);
if (VCD_RECORDER_STATE_RECORDING == g_recorder_state) return 0;
bool started = false;
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] audio type : %s", g_current_audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] audio type : %s", g_current_audio_type);
if (NULL != g_current_audio_type) {
if (0 == strncmp(VCE_AUDIO_ID_BLUETOOTH, g_current_audio_type, strlen(VCE_AUDIO_ID_BLUETOOTH))) {
if (BT_ERROR_NONE != bt_hid_set_audio_data_receive_cb(_bt_hid_audio_data_receive_cb, NULL)) {
SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail bt_hid_set_audio_data_receive_cb()");
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Start bt audio");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Start bt audio");
g_bt_extend_count = 0;
started = true;
#endif
} else if (0 == strncmp(VCE_AUDIO_ID_FFV, g_current_audio_type, strlen(VCE_AUDIO_ID_FFV))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] call farfield_voice_register_audio_cb() function");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] call farfield_voice_register_audio_cb() function");
#ifdef TV_FFV_MODE
if (g_farfieldvoice_h) {
SLOG(LOG_INFO, TAG_VCD, "[Recorder INFO] Register farfield voice audio callback");
#endif
started = true;
} else if (0 == strncmp(VCE_AUDIO_ID_WIFI, g_current_audio_type, strlen(VCE_AUDIO_ID_WIFI))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] call RegisterMSFAudioCallback() function");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] call RegisterMSFAudioCallback() function");
#ifdef TV_MSF_WIFI_MODE
ret = RegisterMSFAudioCallback(__msf_wifi_audio_data_receive_cb, NULL);
}
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] started = %d", started);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] started = %d", started);
if (false == started) {
/* check audio format */
__check_audio_format();
/* Add ecore timer to read audio data */
ecore_main_loop_thread_safe_call_async(__timer_read_normal_func, NULL);
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Start audio in recorder");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Start audio in recorder");
}
g_recorder_state = VCD_RECORDER_STATE_RECORDING;
vcd_audio_streaming_mode_e streaming_mode;
vcd_config_get_audio_streaming_mode(&streaming_mode);
if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
return VCD_ERROR_NONE;
}
while (5 > bt_retry) {
ret = bt_hid_rc_stop_sending_voice(NULL);
if (BT_ERROR_NONE == ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Stop bt audio recorder");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] Stop bt audio recorder");
stoped = true;
break;
} else if (BT_ERROR_NOW_IN_PROGRESS == ret) {
(!strncmp(g_current_audio_type, VCE_AUDIO_ID_BLUETOOTH, sizeof(VCE_AUDIO_ID_BLUETOOTH)) ||
!strncmp(g_current_audio_type, VCE_AUDIO_ID_FFV, sizeof(VCE_AUDIO_ID_FFV)) ||
!strncmp(g_current_audio_type, VCE_AUDIO_ID_WIFI, sizeof(VCE_AUDIO_ID_WIFI)))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] Recorder reset to NONE");
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] Recorder reset to NONE");
vcd_recorder_set(VCE_AUDIO_ID_NONE, g_audio_type, g_audio_rate, g_audio_channel);
}
}
#endif
} else if (0 == strncmp(VCE_AUDIO_ID_FFV, g_current_audio_type, strlen(VCE_AUDIO_ID_FFV))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] FFV");
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] FFV");
#ifdef TV_FFV_MODE
// Unregister callback for far field audio
if (g_farfieldvoice_h)
(!strncmp(g_current_audio_type, VCE_AUDIO_ID_BLUETOOTH, sizeof(VCE_AUDIO_ID_BLUETOOTH)) ||
!strncmp(g_current_audio_type, VCE_AUDIO_ID_FFV, sizeof(VCE_AUDIO_ID_FFV)) ||
!strncmp(g_current_audio_type, VCE_AUDIO_ID_WIFI, sizeof(VCE_AUDIO_ID_WIFI)))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] Recorder reset to NONE");
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] Recorder reset to NONE");
vcd_recorder_set(VCE_AUDIO_ID_NONE, g_audio_type, g_audio_rate, g_audio_channel);
}
stoped = true;
if (NULL != g_current_audio_type &&
(!strncmp(g_current_audio_type, VCE_AUDIO_ID_BLUETOOTH, sizeof(VCE_AUDIO_ID_BLUETOOTH)) ||
!strncmp(g_current_audio_type, VCE_AUDIO_ID_WIFI, sizeof(VCE_AUDIO_ID_WIFI)))) {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] Recorder reset to NONE");
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] Recorder reset to NONE");
vcd_recorder_set(VCE_AUDIO_ID_NONE, g_audio_type, g_audio_rate, g_audio_channel);
}
stoped = true;
#endif
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] current audio type is NONE");
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] current audio type is NONE");
}
}
int vcd_recorder_set_pcm_path(const char *path)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] set pcm path : %s", path);
+ SLOG(LOG_INFO, TAG_VCD, "[Recorder] set pcm path : %s", path);
if (path == NULL)
return 0;
*/
static Eina_Bool __stop_by_silence(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Silence Detected ");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Silence Detected ");
vcd_server_mgr_stop();
static Eina_Bool __cancel_by_interrupt(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Cancel by interrupt");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Cancel by interrupt");
vcd_server_mgr_cancel();
static void __cancel_by_error(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Cancel by error");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Cancel by error");
vcd_server_mgr_cancel();
static Eina_Bool __restart_engine(void *data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Restart by no result");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Restart by no result");
g_restart_timer = NULL;
return EINA_FALSE;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Start engine");
+ SLOG(LOG_INFO, TAG_VCD, "[Server Success] Start engine");
vcd_recognition_mode_e mode = vcd_client_get_recognition_mode();
if (VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT == mode || VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == mode) {
vcdc_send_service_state(VCD_STATE_RECORDING);
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Restart recognition");
+ SLOG(LOG_INFO, TAG_VCD, "[Server Success] Restart recognition");
SLOG(LOG_DEBUG, TAG_VCD, "@@@");
return EINA_FALSE;
vcd_config_set_service_state(VCD_STATE_PROCESSING);
vcdc_send_service_state(VCD_STATE_PROCESSING);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop engine only by silence");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Stop engine only by silence");
} else if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == vcd_client_get_recognition_mode()) {
/* Stop engine recognition */
int ret = vcd_engine_recognize_stop();
void __server_recorder_interrupt_callback()
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Cancel by sound interrupt");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Cancel by sound interrupt");
ecore_timer_add(0, __cancel_by_interrupt, NULL);
static void __config_lang_changed_cb(const char* current_lang, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Change language ");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Change language ");
/* Current state is recording */
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_RECORDING == state || VCD_STATE_PROCESSING == state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Current state is 'Recording'. Cancel recognition");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Current state is 'Recording'. Cancel recognition");
vcd_server_mgr_cancel();
}
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set language of engine : %d", ret);
}
- SLOG(LOG_DEBUG, TAG_VCD, "@@@");
+ SLOG(LOG_INFO, TAG_VCD, "@@@");
return;
}
{
SLOG(LOG_DEBUG, TAG_VCD, "@@@ Change foreground");
- SLOG(LOG_DEBUG, TAG_VCD, "Foreground pid(%d)", current);
+ SLOG(LOG_INFO, TAG_VCD, "Foreground pid(%d)", current);
if (VC_NO_FOREGROUND_PID != current) {
/* Foreground app is changed */
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_RECORDING == state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Foreground pid(%d) is changed. Cancel recognition", current);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Foreground pid(%d) is changed. Cancel recognition", current);
ecore_timer_add(0, __cancel_by_interrupt, NULL);
}
}
}
if (NULL != asr_result) {
- SECURE_SLOG(LOG_DEBUG, TAG_VCD, "[Server] ASR result - Event(%d), Text(%s)", event, asr_result);
+ SECURE_SLOG(LOG_INFO, TAG_VCD, "[Server] ASR result - Event(%d), Text(%s)", event, asr_result);
ret = vcdc_send_pre_result_to_manager(vcd_client_manager_get_pid(), event, asr_result);
if (0 != ret) {
SECURE_SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to send ASR result : mgr_pid(%d), asr_result(%s)", vcd_client_manager_get_pid(), asr_result);
int vcd_send_specific_engine_result(const char* engine_app_id, const char* event, const char* result, void *user_info)
{
if (NULL != result) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] specific engine result - Event(%s), Text(%s)", event, result);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] specific engine result - Event(%s), Text(%s)", event, result);
vcdc_send_specific_engine_result_to_manager(vcd_client_manager_get_pid(), engine_app_id, event, result);
}
#if 1
/* if nlu_result is exist, Add command handle(is_action) into result list */
/* Normal result */
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] @ Get engine result @");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] @ Get engine result @");
vc_cmd_s* temp_cmd = NULL;
vc_cmd_list_h vc_cmd_list = NULL;
bool enable = false;
vcd_client_widget_get_asr_result_enabled(pid, &enable);
if (true == enable) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Send ASR result to Widget client");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Send ASR result to Widget client");
bool is_consumed = false;
if (NULL != user_info) {
*user_info = 0x00;
if (0 != vcdc_send_asr_result(pid, event, all_result, VC_COMMAND_TYPE_WIDGET, &is_consumed)) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to send asr result");
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] ASR result is consumed(%d)", is_consumed);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] ASR result is consumed(%d)", is_consumed);
if (true == is_consumed) {
if (NULL != user_info) {
*user_info = 0x01;
temp_cmd->id = i;
if (0 != vc_cmd_list_add(vc_cmd_list, (vc_cmd_h)temp_cmd)) {
- SLOG(LOG_DEBUG, TAG_VCD, "Fail to add command to list");
+ SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to add command to list");
vc_cmd_destroy((vc_cmd_h)temp_cmd);
temp_cmd = NULL;
}
vc_cmd_print_list(vc_cmd_list);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] @@@@");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] @@@@");
int result_count = 0;
vc_cmd_list_get_count(vc_cmd_list, &result_count);
vc_cmd_list_h widget_cmd_list = NULL;
vc_cmd_list_h foreground_cmd_list = NULL;
if (NULL != all_result) {
- SECURE_SLOG(LOG_DEBUG, TAG_VCD, "[Server] Engine result is no command : %s", all_result);
+ SECURE_SLOG(LOG_INFO, TAG_VCD, "[Server] Engine result is no command : %s", all_result);
int cnt = 0;
if (0 != vc_cmd_list_create(&widget_cmd_list)) {
vc_cmd_list_destroy(widget_cmd_list, true);
widget_cmd_list = NULL;
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Engine result is NULL");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Engine all result is NULL");
}
vc_cmd_list_get_count(vc_cmd_list, &result_count);
// After running partial matching algorithm, if there is no result.
if (0 == result_count) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] No commands even after partial matching");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] No commands even after partial matching");
bool temp = vcd_client_manager_get_exclusive();
vc_info_parser_set_result(all_result, event, msg, NULL, temp);
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Request tooltip hide");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Request tooltip hide");
/* Send to hide tooltip */
vcdc_send_show_tooltip(pid, false);
}
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Request tooltip hide");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Request tooltip hide");
vcdc_send_show_tooltip(pid, false);
}
SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] Fail to send result");
}
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Manager is NOT available. Send result to client directly");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Manager is NOT available. Send result to client directly");
ecore_timer_add(0, __vcd_send_selected_result, NULL);
}
} else {
if (VCD_RECOGNITION_MODE_RESTART_AFTER_REJECT == recognition_mode) {
if (VCE_RESULT_EVENT_REJECTED == event) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Restart by no or rejected result");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Restart by no or rejected result");
/* If no result and restart option is ON */
/* Send reject message */
bool temp = vcd_client_manager_get_exclusive();
g_restart_timer = ecore_timer_add(0, __restart_engine, NULL);
return ret;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop recorder due to success");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Stop recorder due to success");
//vcd_recorder_stop();
ecore_main_loop_thread_safe_call_sync(__recorder_stop, NULL);
} else if (VCD_RECOGNITION_MODE_RESTART_CONTINUOUSLY == recognition_mode) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Restart continuously");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Restart continuously");
/* Restart option is ON */
g_restart_timer = ecore_timer_add(0, __restart_engine, NULL);
if (VCE_RESULT_EVENT_REJECTED == event) {
*/
static void __vcd_file_clean_up()
{
- SLOG(LOG_DEBUG, TAG_VCD, "== Old file clean up == ");
+ SLOG(LOG_INFO, TAG_VCD, "== Old file clean up == ");
DIR *dp = NULL;
struct dirent *dirp = NULL;
if (0 != remove(remove_path)) {
SLOG(LOG_WARN, TAG_VCD, "[File message WARN] Fail to remove file : %s", remove_path);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[File message] Remove file : %s", remove_path);
+ SLOG(LOG_INFO, TAG_VCD, "[File message] Remove file : %s", remove_path);
}
}
}
}
if (0 == ret || mgr_pid > 0) {
- SLOG(LOG_DEBUG, TAG_VCD, "@@@ Clean up %s client ", type ? (type == 1) ? "Widget" : "Manager" : "Normal");
+ SLOG(LOG_INFO, TAG_VCD, "@@@ Clean up %s client ", type ? (type == 1) ? "Widget" : "Manager" : "Normal");
if (NULL != client_list && client_count > 0) {
for (i = 0; i < client_count; i++) {
exist = false;
iter = g_list_nth(g_proc_list, j);
if (NULL != iter) {
if (*(client_list + i) == GPOINTER_TO_INT(iter->data)) {
- SLOG(LOG_DEBUG, TAG_VCD, "%s pid(%d) is running", type ? (type == 1) ? "Widget" : "Manager" : "Normal", *(client_list + i));
+ SLOG(LOG_INFO, TAG_VCD, "%s pid(%d) is running", type ? (type == 1) ? "Widget" : "Manager" : "Normal", *(client_list + i));
exist = true;
break;
}
}
}
}
- SLOG(LOG_DEBUG, TAG_VCD, "@@@");
+ SLOG(LOG_INFO, TAG_VCD, "@@@");
}
if (NULL != client_list && -1 == mgr_pid) {
free(client_list);
__vcd_cleanup_client(VCD_CLIENT_TYPE_MANAGER);
if (0 == vcd_client_get_ref_count()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Connected client list is empty");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Connected client list is empty");
ecore_timer_add(0, __finalize_quit_ecore_loop, NULL);
}
#if 0
}
if (0 == vcd_client_get_ref_count()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Connected client list is empty");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Connected client list is empty");
ecore_timer_add(0, __finalize_quit_ecore_loop, NULL);
}
return VCD_ERROR_INVALID_STATE;
}
if (-1 == vcd_client_manager_get_pid()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Manager is NOT available.");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Manager is NOT available.");
return VCD_ERROR_OPERATION_FAILED;
}
SLOG(LOG_ERROR, TAG_VCD, "[Server] stop internal recognition");
int vcd_server_mgr_cancel()
{
if (-1 == vcd_client_manager_get_pid()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Manager is NOT available.");
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Manager is NOT available.");
return VCD_ERROR_OPERATION_FAILED;
}
/* 1. Check current state */
vcd_state_e state = vcd_config_get_service_state();
if (VCD_STATE_READY == state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Current state is READY");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Current state is READY");
vcd_recorder_stop();
if (false == vcd_client_manager_get_exclusive()) {
if (1 == vcd_config_get_command_type_enabled(VC_COMMAND_TYPE_WIDGET)) {
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Request tooltip hide");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Request tooltip hide");
ecore_timer_add(0, __vcd_request_show_tooltip, (void*)false);
}
}
if (1 == vcd_config_get_command_type_enabled(VC_COMMAND_TYPE_WIDGET)) {
int pid = vcd_client_widget_get_foreground_pid();
if (-1 != pid) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Request tooltip hide");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Request tooltip hide");
ecore_timer_add(0, __vcd_request_show_tooltip, (void*)false);
}
}
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set domain : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] Set domain");
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] Set domain");
}
return ret;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set private data : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] Set private data");
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] Set private data");
}
return ret;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to get private data : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] Set private data");
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] Set private data");
}
return ret;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set specific engine request : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] Set specific engine request ");
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] Set specific engine request ");
}
return ret;
} else {
vcd_config_set_service_state(VCD_STATE_PROCESSING);
vcdc_send_service_state(VCD_STATE_PROCESSING);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] Process do action");
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] Process do action");
}
return ret;
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] start TTS feedback");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] start TTS feedback");
/* check there is TTS buffer to be spoken */
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] stop TTS feedback");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] stop TTS feedback");
return VCD_ERROR_NONE;
}
int vcd_server_mgr_send_audio_streaming(int pid, int event, unsigned char* buffer, unsigned int len)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] Send Audio Streaming from Multi-assistant. event(%d), buffer(%p), len(%d)", event, &buffer, len);
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] Send Audio Streaming from Multi-assistant. event(%d), buffer(%p), len(%d)", event, &buffer, len);
int ret = 0;
if (VCD_AUDIO_STREAMING_EVENT_START == event) {
int vcd_server_mgr_change_system_volume(int pid, vcd_system_volume_event_e system_volume_event)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] change system volume, system volume event(%d)", system_volume_event);
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] change system volume, system volume event(%d)", system_volume_event);
int ret = 0;
if (VCD_SYSTEM_VOLUME_EVENT_CHANGE == system_volume_event) {
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Client Initialize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Server Success] Client Initialize : pid(%d)", pid);
return VCD_ERROR_NONE;
}
}
if (0 == vcd_client_get_ref_count()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Connected client list is empty");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Connected client list is empty");
ecore_timer_add(0, __finalize_quit_ecore_loop, NULL);
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Client Finalize : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Server Success] Client Finalize : pid(%d)", pid);
return VCD_ERROR_NONE;
}
if (0 != strncmp(credential, "#NULL", strlen(credential))) {
ret = vcd_client_set_server_dialog(pid, true);
if (0 != ret)
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set to true for server dialog, app_id(%s)", app_id);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set to true for server dialog, app_id(%s)", app_id);
} else {
ret = vcd_client_set_server_dialog(pid, false);
if (0 != ret)
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set to false for server dialog, app_id(%s)", app_id);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set to false for server dialog, app_id(%s)", app_id);
}
return 0;
static void __start_tts_request_thread(void* data, Ecore_Thread* thread)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[SUCCESS] Start tts request thread");
+ SLOG(LOG_INFO, TAG_VCD, "[SUCCESS] Start tts request thread");
vc_tts_text_data_s* tts_text_data = NULL;
while (1) {
if (0 != ret || NULL == tts_text_data) {
/* empty queue */
if (0 >= vcd_data_get_tts_text_data_size()) {
- SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] No tts text data");
+ SLOG(LOG_INFO, TAG_VCD, "[DEBUG] No tts text data");
return;
}
SLOG(LOG_INFO, TAG_VCD, "[INFO] tts text data is just incoming");
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to request tts : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] request tts, uid(%d) pid(%d), text(%s), language(%s), utt_id(%d)",
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] request tts, uid(%d) pid(%d), text(%s), language(%s), utt_id(%d)",
tts_text_data->uid, tts_text_data->pid, tts_text_data->text, tts_text_data->language, tts_text_data->utt_id);
}
/* clear tts text data after use */
static void __end_tts_request_thread(void* data, Ecore_Thread* thread)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[SUCCESS] End tts request thread");
+ SLOG(LOG_INFO, TAG_VCD, "[SUCCESS] End tts request thread");
g_tts_thread = NULL;
}
if (0 != ret) {
SLOG(LOG_WARN, TAG_VCD, "[Server WARN] No data in vcd tts text queue");
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Clear tts text data, pid(%d), utt_id(%d), text(%s)", pid, utt_id, tts_text_data->text);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Clear tts text data, pid(%d), utt_id(%d), text(%s)", pid, utt_id, tts_text_data->text);
vcd_data_clear_tts_text_data(&tts_text_data);
}
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to cancel tts : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] request tts, pid(%d), utt_id(%d)", pid, utt_id);
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] request tts, pid(%d), utt_id(%d)", pid, utt_id);
}
return 0;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to get tts audio format : %d", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server SUCCESS] get tts audio format, pid(%d), rate(%d), channel(%d), audio_type(%d)", pid, *rate, *channel, *audio_type);
+ SLOG(LOG_INFO, TAG_VCD, "[Server SUCCESS] get tts audio format, pid(%d), rate(%d), channel(%d), audio_type(%d)", pid, *rate, *channel, *audio_type);
}
return ret;
return VCD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Server Success] Initialize widget : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Server Success] Initialize widget : pid(%d)", pid);
return VCD_ERROR_NONE;
}
if (true == widget_command) {
vcd_client_widget_set_command(pid);
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] widget command is available");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] widget command is available");
} else {
vcd_client_widget_unset_command(pid);
SLOG(LOG_WARN, TAG_VCD, "[Server] widget command is NOT available");
/* Service state should be ready */
if (VCD_STATE_READY != state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Current state is not Ready : pid(%d)", pid);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Current state is not Ready : pid(%d)", pid);
return VCD_ERROR_INVALID_STATE;
}
/* Service state should be recording */
if (VCD_STATE_RECORDING != state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Current service state is not Recording : pid(%d)", pid);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Current service state is not Recording : pid(%d)", pid);
return VCD_ERROR_INVALID_STATE;
}
ret = vcd_server_mgr_stop();
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to start recognition");
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Fail to start recognition");
return VCD_ERROR_OPERATION_FAILED;
}
/* Service state should be recording or processing */
if (VCD_STATE_RECORDING != state && VCD_STATE_PROCESSING != state) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Current state is not Recording or Processing : pid(%d)", pid);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Current state is not Recording or Processing : pid(%d)", pid);
return VCD_ERROR_INVALID_STATE;
}
ret = vcd_server_mgr_cancel();
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to cancel recognition : %d", ret);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Fail to cancel recognition : %d", ret);
return ret;
}
int ret;
ret = vcd_client_widget_set_asr_result_enabled(pid, enable);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to enable asr result : %d", ret);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Fail to enable asr result : %d", ret);
}
return ret;
ret = vcd_config_set_default_language(language);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to set language : %d", ret);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Fail to set language : %d", ret);
return ret;
}
ret = vcd_engine_set_current_language(language);
if (0 != ret) {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Fail to set language : %d", ret);
+ SLOG(LOG_ERROR, TAG_VCD, "[Server] Fail to set language : %d", ret);
return ret;
}
*/
int vcd_get_foreach_command(vce_cmd_h vce_command, vce_command_cb callback, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Get foreach command");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Get foreach command");
if (NULL == callback) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] input parameter is NULL");
int vcd_get_command_count(vce_cmd_h vce_command, int* count)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Get command count");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Get command count");
int ret = 0;
ret = vcd_engine_agent_get_command_count(vce_command, count);
int vcd_get_audio_type(char** audio_type)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Get audio type");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Get audio type");
int ret = 0;
ret = vcd_engine_agent_get_audio_type(audio_type);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to set private data to the manager client : ret(%d)", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set private data to the manager client, key(%s), data(%s)", key, data);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set private data to the manager client, key(%s), data(%s)", key, data);
}
return ret;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Fail to get private data from the manager client : ret(%d)", ret);
} else {
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Get private data from the manager client, key(%s), data(%s)", key, *data);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Get private data from the manager client, key(%s), data(%s)", key, *data);
}
return ret;
int vcd_start_recording()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Start recording");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Start recording");
int ret = 0;
ret = vcd_engine_agent_start_recording();
int vcd_stop_recording()
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Stop recording");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Stop recording");
int ret = 0;
ret = vcd_engine_agent_stop_recording();
int vcd_send_update_status(vce_update_event_e update_event, const char* msg)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] update status, update event(%d), msg(%s)", update_event, msg);
+ SLOG(LOG_INFO, TAG_VCD, "[Server] update status, update event(%d), msg(%s)", update_event, msg);
int ret = 0;
if (VCE_UPDATE_EVENT_START == update_event) {
int vcd_set_private_data_set_cb(vce_private_data_set_cb callback_func)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set private data set cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set private data set cb");
int ret = 0;
ret = vcd_engine_agent_set_private_data_set_cb(callback_func);
int vcd_set_private_data_requested_cb(vce_private_data_requested_cb callback_func)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set private data requested cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set private data requested cb");
int ret = 0;
ret = vcd_engine_agent_set_private_data_requested_cb(callback_func);
int vcd_set_nlu_base_info_requested_cb(vce_nlu_base_info_requested_cb callback_func)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set nlu base info requested cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set nlu base info requested cb");
int ret = 0;
ret = vcd_engine_agent_set_nlu_base_info_requested_cb(callback_func);
int vcd_set_specific_engine_request_cb(vce_specific_engine_request_cb callback_func)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set specific engine request cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set specific engine request cb");
int ret = 0;
ret = vcd_engine_agent_set_specific_engine_request_cb(callback_func);
if (0 != ret) {
int vcd_set_request_tts_cb(vce_request_tts_cb callback_func, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set request tts cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set request tts cb");
int ret = 0;
ret = vcd_engine_agent_set_request_tts_cb(callback_func, user_data);
if (0 != ret) {
int vcd_set_cancel_tts_cb(vce_cancel_tts_cb callback_func, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set cancel tts cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set cancel tts cb");
int ret = 0;
ret = vcd_engine_agent_set_cancel_tts_cb(callback_func, user_data);
if (0 != ret) {
int vcd_set_tts_audio_format_request_cb(vce_tts_audio_format_request_cb callback_func, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[Server] Set tts audio format request cb");
+ SLOG(LOG_INFO, TAG_VCD, "[Server] Set tts audio format request cb");
int ret = 0;
ret = vcd_engine_agent_set_get_tts_audio_format_cb(callback_func, user_data);
if (0 != ret) {
int vcd_data_get_tts_text_data(int uid, vc_tts_text_data_s** data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[DATA] Get tts text data : uid(%d)", uid);
+ SLOG(LOG_INFO, TAG_VCD, "[DATA] Get tts text data : uid(%d)", uid);
/* mutex is locked */
pthread_mutex_lock(&g_tts_text_data_mutex);
int vcd_data_get_first_tts_text_data(vc_tts_text_data_s** data)
{
- SLOG(LOG_DEBUG, TAG_VCD, "[DATA] Get first tts text data");
+ SLOG(LOG_INFO, TAG_VCD, "[DATA] Get first tts text data");
#ifdef DATA_DEBUG
__data_show_text_list();
pthread_mutex_lock(&g_tts_text_data_mutex);
int size = g_tts_text_data.size();
- SLOG(LOG_DEBUG, TAG_VCD, "[DATA] get feedback data size(%d)", size);
+ SLOG(LOG_INFO, TAG_VCD, "[DATA] get feedback data size(%d)", size);
/* mutex is unlocked */
pthread_mutex_unlock(&g_tts_text_data_mutex);
pid_t pid = getpid();
char *session = cynara_session_from_pid(pid);
int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
- SLOG(LOG_DEBUG, TAG_VCD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
+ SLOG(LOG_INFO, TAG_VCD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
if (session)
free(session);
SLOG(LOG_DEBUG, TAG_VCD, " ");
SLOG(LOG_DEBUG, TAG_VCD, " ");
- SLOG(LOG_DEBUG, TAG_VCD, "===== VC Engine Service Initialize");
+ SLOG(LOG_INFO, TAG_VCD, "===== VC Engine Service Initialize");
int ret = VCE_ERROR_NONE;
return ret;
}
- SLOG(LOG_DEBUG, TAG_VCD, "[Main] VC Engine Service start...");
+ SLOG(LOG_INFO, TAG_VCD, "[Main] VC Engine Service start...");
SLOG(LOG_DEBUG, TAG_VCD, "=====");
SLOG(LOG_DEBUG, TAG_VCD, " ");
projects / platform / core / uifw / voice-control.git / commitdiff