}
}
- return 0;
+ return VC_ERROR_NONE;
}
static int __check_privilege_initialize()
vc_state_e state;
if (0 != vc_client_get_client_state(g_vc, &state)) {
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
/* check state */
if (state != VC_STATE_READY) {
SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] State is not READY");
if (VC_ERROR_SERVICE_RESET != reason) {
- SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
- return -1;
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet(%d)", reason);
+ return VC_ERROR_INVALID_STATE;
}
- return 0;
+ return VC_ERROR_NONE;
}
if (VC_ERROR_SERVICE_RESET == reason) {
vc_client_set_error(g_vc, reason);
ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)g_vc);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_cb_error_to_app(int pid, int reason, const char* msg)
vc_client_set_result_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_unset_result_cb(void)
vc_client_set_result_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
vc_client_get_service_state(g_vc, &before_state);
if (current_state == before_state) {
- return 0;
+ return VC_ERROR_NONE;
}
SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
}
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_cb_manager_pid(int manager_pid)
/* Save service state */
vc_client_set_mgr_pid(g_vc, manager_pid);
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_unset_service_state_changed_cb(void)
vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
vc_client_set_state_changed_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_unset_state_changed_cb(void)
vc_client_set_state_changed_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_unset_current_language_changed_cb(void)
vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_set_error_cb(vc_error_cb callback, void* user_data)
vc_client_set_error_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_unset_error_cb(void)
vc_client_set_error_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_set_invocation_name(const char* name)
vc_client_set_tts_streaming_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_tts_unset_streaming_cb(void)
vc_client_set_tts_streaming_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_cb_utterance_status(int utt_id, int utt_status)
vc_client_get_tts_utterance_status_cb(g_vc, &callback, &user_data);
if (NULL == callback) {
SLOG(LOG_WARN, TAG_VCC, "[WARNING] Utterance status callback is null");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
callback(utt_id, (vc_tts_utterance_status_e)utt_status, user_data);
vc_client_not_use_callback(g_vc);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
vc_client_set_tts_utterance_status_cb(g_vc, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_tts_unset_utterance_status_cb(void)
vc_client_set_tts_utterance_status_cb(g_vc, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
*vc = temp;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_destroy(vc_h vc)
{
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCC, "Input parameter is NULL"); //LCOV_EXCL_LINE
- return 0;
+ return VC_ERROR_NONE;
}
vc_client_s *data = NULL;
free(vc);
data = NULL;
vc = NULL;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
SLOG(LOG_ERROR, TAG_VCC, "[ERROR] client Not found");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
bool vc_client_is_valid(vc_h vc)
SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] pid(%d), handle(%d)", pid, data->vc->handle);
if (pid == data->vc->handle) {
*vc = data->vc;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
//LCOV_EXCL_STOP
client->result_cb = callback;
client->result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
*callback = client->result_cb;
*user_data = client->result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->service_state_changed_cb = callback;
client->service_state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
*callback = client->service_state_changed_cb;
*user_data = client->service_state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->state_changed_cb = callback;
client->state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
*callback = client->state_changed_cb;
*user_data = client->state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->current_lang_changed_cb = callback;
client->current_lang_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
*callback = client->current_lang_changed_cb;
*user_data = client->current_lang_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->error_cb = callback;
client->error_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
*callback = client->error_cb;
*user_data = client->error_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->service_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_service_state(vc_h vc, vc_service_state_e* state)
*state = client->service_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_set_client_state(vc_h vc, vc_state_e state)
client->before_state = client->current_state;
client->current_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_client_state(vc_h vc, vc_state_e* state)
*state = client->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_client_state_by_uid(unsigned int uid, vc_state_e* state)
if (NULL != data) {
if (uid == data->vc->handle) {
*state = data->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
int vc_client_get_before_state(vc_h vc, vc_state_e* state, vc_state_e* before_state)
*before_state = client->before_state;
*state = client->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_set_invocation_name(vc_h vc, const char* invocation_name)
if (NULL != invocation_name) {
client->invocation_name = strdup(invocation_name);
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_invocation_name(vc_h vc, char** invocation_name)
if (NULL != client->invocation_name)
*invocation_name = strdup(client->invocation_name);
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
client->xid = xid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_xid(vc_h vc, int* xid)
*xid = client->xid;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
return VC_ERROR_INVALID_PARAMETER;
client->is_foreground = value;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_is_foreground(vc_h vc, bool* value)
*value = client->is_foreground;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
client->exclusive_cmd = value;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_exclusive_cmd(vc_h vc, bool* value)
*value = client->exclusive_cmd;
- return 0;
+ return VC_ERROR_NONE;
}
#endif
//LCOV_EXCL_STOP
client->reason = reason;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_error(vc_h vc, int* reason)
*reason = client->reason;
- return 0;
+ return VC_ERROR_NONE;
}
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count++;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_not_use_callback(vc_h vc)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count--;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_START
client->auth_state_changed_cb = callback;
client->auth_state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_auth_state_changed_cb(vc_h vc, vc_auth_state_changed_cb* callback, void** user_data)
*callback = client->auth_state_changed_cb;
*user_data = client->auth_state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_unset_auth_state_changed_cb(vc_h vc)
client->auth_state_changed_cb = NULL;
client->auth_state_changed_user_data = NULL;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_set_auth_state(vc_h vc, vc_auth_state_e state)
client->auth_before_state = client->auth_current_state;
client->auth_current_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_auth_state(vc_h vc, vc_auth_state_e* state)
*state = client->auth_current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_before_auth_state(vc_h vc, vc_auth_state_e* before, vc_auth_state_e* current)
*before = client->auth_before_state;
*current = client->auth_current_state;
- return 0;
+ return VC_ERROR_NONE;
}
//LCOV_EXCL_STOP
client->mgr_pid = mgr_pid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_mgr_pid(vc_h vc, int* mgr_pid)
*mgr_pid = client->mgr_pid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_set_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb callback, void* user_data)
client->tts_streaming_cb = callback;
client->tts_streaming_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_tts_streaming_cb(vc_h vc, vc_tts_streaming_cb* callback, void** user_data)
*callback = client->tts_streaming_cb;
*user_data = client->tts_streaming_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_set_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb callback, void* user_data)
client->tts_utterance_status_cb = callback;
client->tts_utterance_status_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_client_get_tts_utterance_status_cb(vc_h vc, vc_tts_utterance_status_cb* callback, void** user_data)
*callback = client->tts_utterance_status_cb;
*user_data = client->tts_utterance_status_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
if (g_tts_data.empty()) {
SLOG(LOG_ERROR, TAG_VCC, "[DATA ERROR] There is no tts data");
pthread_mutex_unlock(&g_tts_data_mutex);
- return -1;
+ return VC_ERROR_EMPTY;
}
std::list<vc_tts_data_s*>::iterator iter;
}
}
- return 0;
+ return VC_ERROR_NONE;
}
static int __check_privilege_initialize()
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_demandable_client_rule(void)
}
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_is_command_format_supported(int format, bool* support)
SLOG(LOG_ERROR, TAG_VCM, "@@@");
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_command_list_from_file(const char* file_path, int type)
}
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
if (0 != vc_info_parser_get_client_info(&client_info_list)) {
SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No client");
- return 0;
+ return VC_ERROR_NONE;
}
if (VC_NO_FOREGROUND_PID != fg_pid) {
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
} else {
SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground app");
SLOG(LOG_ERROR, TAG_VCM, "@@@");
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
}
vc_mgr_client_set_recognition_mode(g_vc_m, mode);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
}
SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Get recognition mode = %d", *mode);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_private_data(const char* key, const char* data)
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_get_private_data(const char* key, char** data)
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_domain(const char* domain)
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* event, const char* request)
}
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_start(bool exclusive_command_option)
g_cnt = 1;
g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_set_volume_timer_cb, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_set_volume(float volume)
// called by app directly
g_volume_db = volume;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_get_recording_volume(float* volume)
*volume = g_volume_db;
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_cb_set_foreground(int pid, bool value)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
SLOG(LOG_DEBUG, TAG_VCM, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __vc_mgr_set_select_result(void *data)
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set all result callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_all_result_cb(void)
vc_mgr_client_set_all_result_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data)
vc_mgr_client_set_result_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_result_cb(void)
vc_mgr_client_set_result_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
vc_mgr_client_set_pre_result_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_pre_result_cb(void)
vc_mgr_client_set_pre_result_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_get_error_message(char** err_msg)
vc_state_e state;
if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
/* check state */
if (state != VC_STATE_INITIALIZED && state != VC_STATE_READY) {
SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet");
- return -1;
+ return VC_ERROR_INVALID_STATE;
}
vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
vc_mgr_client_get_service_state(g_vc_m, &service_state);
if (VC_SERVICE_STATE_UPDATING == service_state) {
SLOG(LOG_INFO, TAG_VCM, "[INFO] VC daemon is terminated by update manager");
- return 0;
+ return VC_ERROR_NONE;
}
vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED);
vc_mgr_client_set_error_message(g_vc_m, msg);
__vc_mgr_notify_error(g_vc_m);
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __vc_mgr_notify_state_changed(void *data)
vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data);
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set state changed callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_state_changed_cb(void)
vc_mgr_client_set_state_changed_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_cb_service_state(int state)
if (current_state == before_state) {
SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : Before(%d) Current(%d)",
before_state, current_state);
- return 0;
+ return VC_ERROR_NONE;
}
/* Save service state */
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data);
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set service state changed callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_service_state_changed_cb(void)
}
vc_mgr_client_set_service_state_changed_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data)
vc_mgr_client_set_speech_detected_cb(g_vc_m, callback, user_data);
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set speech detected callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_speech_detected_cb(void)
}
vc_mgr_client_set_speech_detected_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
vc_mgr_client_set_current_lang_changed_cb(g_vc_m, callback, user_data);
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set current language changed callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_current_language_changed_cb(void)
vc_mgr_client_set_current_lang_changed_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data)
vc_mgr_client_set_error_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_error_cb(void)
vc_mgr_client_set_error_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
}
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_cb_private_data_set(const char* key, const char* data)
vc_mgr_client_set_dialog_request_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_dialog_request_cb(void)
vc_mgr_client_set_dialog_request_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* user_data)
vc_mgr_client_set_private_data_set_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_private_data_set_cb(void)
vc_mgr_client_set_private_data_set_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callback, void* user_data)
vc_mgr_client_set_private_data_requested_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_private_data_requested_cb(void)
vc_mgr_client_set_private_data_requested_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
static bool __vc_mgr_check_demandable_client(int pid)
vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
}
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_mgr_request_auth_disable(int pid)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __request_auth_start(void* data)
/* add timer for start recording */
ecore_timer_add(0, __request_auth_start, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __request_auth_stop(void* data)
/* add timer for start recording */
ecore_timer_add(0, __request_auth_stop, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __request_auth_cancel(void* data)
/* add timer for start recording */
ecore_timer_add(0, __request_auth_cancel, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data)
vc_mgr_client_set_specific_engine_result_cb(g_vc_m, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_specific_engine_result_cb(void)
{
vc_mgr_client_set_specific_engine_result_cb(g_vc_m, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result)
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback audio format callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_feedback_audio_format_cb()
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback audio format callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data)
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_feedback_streaming_cb()
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* user_data)
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_unset_vc_tts_streaming_cb()
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
- return 0;
+ return VC_ERROR_NONE;
}
static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to player play, ret(%d)", ret);
}
#endif
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_stop_feedback(void)
if (0 != ret || NULL == feedback_data) {
/* empty queue */
SLOG(LOG_INFO, TAG_VCM, "[INFO] No feedback data to stop any more");
- return 0;
+ return VC_ERROR_NONE;
}
ret = vc_mgr_data_clear_feedback_data(&feedback_data);
if (0 != ret) {
}
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Change system volume");
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_recover_system_volume()
}
SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Recover system volume");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_change_system_volume(vc_system_volume_event_e event)
*vc = temp;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_destroy(vc_h vc)
{
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCM, "Input parameter is NULL");
- return 0;
+ return VC_ERROR_NONE;
}
vc_mgr_client_s *data = NULL;
data = NULL;
vc = NULL;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] client Not found");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
bool vc_mgr_client_is_valid(vc_h vc)
if (NULL != data) {
if (uid == data->vc->handle) {
*vc = data->vc;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
- return -1;
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to find the corresponding handle.");
+ return VC_ERROR_INVALID_PARAMETER;
}
int vc_mgr_client_get_pid(vc_h vc, int* pid)
/* check handle */
if (NULL == client) {
SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] vc is not valid");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
*pid = client->pid;
- return 0;
+ return VC_ERROR_NONE;
}
/* set/get callback function */
client->all_result_cb = callback;
client->all_result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_all_result_cb(vc_h vc, vc_mgr_all_result_cb* callback, void** user_data)
*callback = client->all_result_cb;
*user_data = client->all_result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_result_cb(vc_h vc, vc_result_cb callback, void* user_data)
client->result_cb = callback;
client->result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data)
*callback = client->result_cb;
*user_data = client->result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb callback, void* user_data)
client->pre_result_cb = callback;
client->pre_result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_pre_result_cb(vc_h vc, vc_mgr_pre_result_cb* callback, void** user_data)
*callback = client->pre_result_cb;
*user_data = client->pre_result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
client->service_state_changed_cb = callback;
client->service_state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data)
*callback = client->service_state_changed_cb;
*user_data = client->service_state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data)
client->state_changed_cb = callback;
client->state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data)
*callback = client->state_changed_cb;
*user_data = client->state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb callback, void* user_data)
client->speech_detected_cb = callback;
client->speech_detected_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_speech_detected_cb(vc_h vc, vc_mgr_begin_speech_detected_cb* callback, void** user_data)
*callback = client->speech_detected_cb;
*user_data = client->speech_detected_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data)
client->current_lang_changed_cb = callback;
client->current_lang_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data)
*callback = client->current_lang_changed_cb;
*user_data = client->current_lang_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data)
client->error_cb = callback;
client->error_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data)
*callback = client->error_cb;
*user_data = client->error_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb callback, void* user_data)
client->diaglog_requst_cb = callback;
client->dialog_request_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_dialog_request_cb(vc_h vc, vc_mgr_dialog_request_cb* callback, void** user_data)
*callback = client->diaglog_requst_cb;
*user_data = client->dialog_request_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
client->private_data_set_cb = callback;
client->private_data_set_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_private_data_set_cb(vc_h vc, vc_mgr_private_data_set_cb* callback, void** user_data)
*callback = client->private_data_set_cb;
*user_data = client->private_data_set_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb callback, void* user_data)
client->private_data_requested_cb = callback;
client->private_data_requested_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_private_data_requested_cb(vc_h vc, vc_mgr_private_data_requested_cb* callback, void** user_data)
*callback = client->private_data_requested_cb;
*user_data = client->private_data_requested_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb callback, void* user_data)
client->feedback_audio_format_cb = callback;
client->feedback_audio_format_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_feedback_audio_format_cb(vc_h vc, vc_mgr_feedback_audio_format_cb* callback, void** user_data)
*callback = client->feedback_audio_format_cb;
*user_data = client->feedback_audio_format_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb callback, void* user_data)
client->feedback_streaming_cb = callback;
client->feedback_streaming_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_feedback_streaming_cb(vc_h vc, vc_mgr_feedback_streaming_cb* callback, void** user_data)
*callback = client->feedback_streaming_cb;
*user_data = client->feedback_streaming_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb callback, void* user_data)
client->vc_tts_streaming_cb = callback;
client->vc_tts_streaming_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb* callback, void** user_data)
*callback = client->vc_tts_streaming_cb;
*user_data = client->vc_tts_streaming_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
/* set/get option */
client->service_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_service_state(vc_h vc, vc_service_state_e* state)
*state = client->service_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_internal_state(vc_h vc, vc_internal_state_e state)
client->internal_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_internal_state(vc_h vc, vc_internal_state_e* state)
*state = client->internal_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_client_state(vc_h vc, vc_state_e state)
client->before_state = client->current_state;
client->current_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_client_state(vc_h vc, vc_state_e* state)
*state = client->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_client_state_by_uid(unsigned int uid, vc_state_e* state)
if (NULL != data) {
if (uid == data->vc->handle) {
*state = data->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
}
}
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
int vc_mgr_client_get_before_state(vc_h vc, vc_state_e* state, vc_state_e* before_state)
*before_state = client->before_state;
*state = client->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_error(vc_h vc, int reason)
client->reason = reason;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_error(vc_h vc, int* reason)
*reason = client->reason;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_error_message(vc_h vc, const char* err_msg)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_error_message(vc_h vc, char** err_msg)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_enable_command_type(vc_h vc, vc_cmd_type_e cmd_type)
client->disabled_cmd_type &= ~(1 << cmd_type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_disable_command_type(vc_h vc, vc_cmd_type_e cmd_type)
client->disabled_cmd_type |= (1 << cmd_type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_disabled_command_type(vc_h vc, int* disabled_cmd_type)
*disabled_cmd_type = client->disabled_cmd_type;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_exclusive_command(vc_h vc, bool value)
client->exclusive_cmd_option = value;
- return 0;
+ return VC_ERROR_NONE;
}
bool vc_mgr_client_get_exclusive_command(vc_h vc)
client->all_result_text = strdup(result_text);
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_all_result(vc_h vc, int* event, char** result_text)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_unset_all_result(vc_h vc)
client->all_result_text = NULL;
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_audio_type(vc_h vc, const char* audio_id)
client->audio_id = strdup(audio_id);
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_audio_type(vc_h vc, char** audio_id)
{
if (NULL == audio_id) {
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
vc_mgr_client_s* client = __mgr_client_get(vc);
else
*audio_id = NULL;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_recognition_mode(vc_h vc, vc_recognition_mode_e mode)
client->recognition_mode = mode;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_recognition_mode(vc_h vc, vc_recognition_mode_e* mode)
{
if (NULL == mode) {
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
vc_mgr_client_s* client = __mgr_client_get(vc);
return VC_ERROR_INVALID_PARAMETER;
*mode = client->recognition_mode;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_foreground(vc_h vc, int pid, bool value)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_foreground(vc_h vc, int* pid)
return VC_ERROR_INVALID_PARAMETER;
*pid = client->foreground_pid;
- return 0;
+ return VC_ERROR_NONE;
}
/* utils */
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count++;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_not_use_callback(vc_h vc)
return VC_ERROR_INVALID_PARAMETER;
client->cb_ref_count--;
- return 0;
+ return VC_ERROR_NONE;
}
/* Authority */
SLOG(LOG_DEBUG, TAG_VCM, "Add authorized client - %d", pid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_remove_authorized_client(vc_h vc, int pid)
data = NULL;
SLOG(LOG_DEBUG, TAG_VCM, "Remove authorized client - %d", pid);
- return 0;
+ return VC_ERROR_NONE;
}
}
}
client->valid_authorized_pid = pid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_valid_authorized_client(vc_h vc, int* pid)
*pid = client->valid_authorized_pid;
- return 0;
+ return VC_ERROR_NONE;
}
bool vc_mgr_client_is_valid_authorized_client(vc_h vc, int pid)
client->start_by_client = option;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_start_by_client(vc_h vc, bool* option)
*option = client->start_by_client;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb callback, void* user_data)
client->specific_engine_result_cb = callback;
client->specific_engine_result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_specific_engine_result_cb(vc_h vc, vc_mgr_specific_engine_result_cb* callback, void** user_data)
*callback = client->specific_engine_result_cb;
*user_data = client->specific_engine_result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_set_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e streaming_mode)
client->streaming_mode = streaming_mode;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_client_get_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e* streaming_mode)
*streaming_mode = client->streaming_mode;
- return 0;
+ return VC_ERROR_NONE;
}
*data = NULL;
pthread_mutex_unlock(&g_feedback_data_mutex);
- return -1;
+ return VC_ERROR_EMPTY;
}
std::list<vc_feedback_data_s*>::iterator iter;
if (AUDIO_IO_ERROR_NONE != ret) {
g_audio_state = AUDIO_STATE_NONE;
g_audio_h = NULL;
- SLOG(LOG_ERROR, TAG_VCM, "[Player ERROR] Fail to create audio");
+ SLOG(LOG_ERROR, TAG_VCM, "[Player ERROR] Fail to create audio. ret(%d)", ret);
return -1;
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[Player DEBUG] Create audio");
int ret = -1;
ret = audio_out_destroy(g_audio_h);
if (AUDIO_IO_ERROR_NONE != ret) {
- SLOG(LOG_ERROR, TAG_VCM, "[Player ERROR] Fail to destroy audio");
+ SLOG(LOG_ERROR, TAG_VCM, "[Player ERROR] Fail to destroy audio. ret(%d)", ret);
return -1;
} else {
SLOG(LOG_DEBUG, TAG_VCM, "[Player DEBUG] Destroy audio");
ret = __create_audio_out(rate, channel, audio_type);
if (0 != ret) {
- return -1;
+ return VC_ERROR_OPERATION_FAILED;
}
g_player_init = true;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_player_release()
ret = __destroy_audio_out();
if (0 != ret) {
- return -1;
+ return VC_ERROR_OPERATION_FAILED;
}
g_player_init = false;
- return 0;
+ return VC_ERROR_NONE;
}
static void __play_feedback_thread(void* data, Ecore_Thread* thread)
ecore_thread_run(__play_feedback_thread, __end_play_feedback_thread, NULL, NULL);
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_mgr_player_stop()
thread_count = ecore_thread_active_get();
}
- return 0;
+ return VC_ERROR_NONE;
}
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_set_enabled(bool value)
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_unset_enabled_changed_cb()
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_set_current_language_changed_cb(vc_setting_current_language_changed_cb callback, void* user_data)
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_unset_current_language_changed_cb()
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_set_engine_changed_cb(vc_setting_engine_changed_cb callback, void *user_data)
g_engine_changed_user_data = user_data;
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_setting_unset_engine_changed_cb()
g_engine_changed_user_data = NULL;
SLOG(LOG_DEBUG, TAG_VCS, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
} /* VCD_METHOD_SEND_MANAGER_PID */
else if (0 == strncmp(VCD_METHOD_ERROR, method, strlen(VCD_METHOD_ERROR))) {
/* signal!!! */
- char* reason;
- char* daemon_pid;
+ char* reason = NULL;
+ char* daemon_pid = NULL;
char* err_msg = NULL;
bundle_get_str(msg, VC_BUNDLE_REASON, &reason);
} /* VCD_METHOD_ERROR_TO_APP */
else if (0 == strncmp(VC_MANAGER_METHOD_UTTERANCE_STATUS, method, strlen(VC_MANAGER_METHOD_UTTERANCE_STATUS))) {
/* signal!!! */
- char* pid;
- char* utt_id;
+ char* pid = NULL;
+ char* utt_id = NULL;
char* utt_status = NULL;
bundle_get_str(msg, VC_BUNDLE_PID, &pid);
static int __create_notify_callback_handle(vc_tidl_info_s* info)
{
+ if (NULL == info) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
if (NULL != info->notify_cb_h) {
rpc_port_proxy_vc_proxy_vc_notify_cb_dispose(info->rpc_h, info->notify_cb_h);
info->notify_cb_h = NULL;
static int __create_feedback_callback_handle(vc_tidl_info_s* info)
{
- if (NULL != info) {
+ if (NULL == info) {
+ SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ if (NULL != info->feedback_cb_h) {
rpc_port_proxy_vc_proxy_vc_feedback_cb_dispose(info->rpc_h, info->feedback_cb_h);
info->feedback_cb_h = NULL;
}
}
}
- return 0;
+ return VC_ERROR_NONE;
}
const char* vc_tag()
count++;
}
SLOG(LOG_WARN, TAG_VCW, "[Widget] prepare_thread is terminated");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_deinitialize(vc_h vc_w)
}
} while (0 != ret);
- return 0;
+ return VC_ERROR_NONE;
}
#endif
SLOG(LOG_DEBUG, TAG_VCW, "@@@");
// TODO: check return value correct or not
- return 0;
+ return VC_ERROR_NONE;
}
static void __vc_widget_notify_error(void *data)
if (0 != vc_widget_client_get_state(vc_w, &state)) {
SLOG(LOG_ERROR, TAG_VCW, "[WARNING] Invalid client");
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
/* check state */
if (state != VC_STATE_READY) {
SLOG(LOG_ERROR, TAG_VCW, "[WARNING] not connected client yet");
- return -1;
+ return VC_ERROR_INVALID_STATE;
}
if (VC_ERROR_SERVICE_RESET == reason) {
}
}
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __vc_widget_start_recording(void *data)
vc_widget_client_set_result_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_result_cb(vc_h vc_w)
vc_widget_client_set_result_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_show_tooltip_cb(vc_h vc_w, vc_widget_show_tooltip_cb callback, void* user_data)
vc_widget_client_set_show_tooltip_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_show_tooltip_cb(vc_h vc_w)
vc_widget_client_set_show_tooltip_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_send_current_command_list_cb(vc_h vc_w, vc_widget_send_current_command_list_cb callback, void* user_data)
vc_widget_client_set_send_command_list_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_send_current_command_list_cb(vc_h vc_w)
vc_widget_client_set_send_command_list_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_widget_cb_service_state(int state)
}
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_service_state_changed_cb(vc_h vc_w, vc_service_state_changed_cb callback, void* user_data)
vc_widget_client_set_service_state_changed_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_service_state_changed_cb(vc_h vc_w)
vc_widget_client_set_service_state_changed_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_state_changed_cb(vc_h vc_w, vc_state_changed_cb callback, void* user_data)
vc_widget_client_set_state_changed_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_state_changed_cb(vc_h vc_w)
vc_widget_client_set_state_changed_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_asr_result_cb(vc_h vc_w, vc_asr_result_cb callback, void* user_data)
vc_widget_client_set_asr_result_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_asr_result_cb(vc_h vc_w)
vc_widget_client_set_asr_result_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_current_language_changed_cb(vc_h vc_w, vc_current_language_changed_cb callback, void* user_data)
vc_widget_client_set_current_lang_changed_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_current_language_changed_cb(vc_h vc_w)
vc_widget_client_set_current_lang_changed_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_set_error_cb(vc_h vc_w, vc_error_cb callback, void* user_data)
vc_widget_client_set_error_cb(vc_w, callback, user_data);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_unset_error_cb(vc_h vc_w)
vc_widget_client_set_error_cb(vc_w, NULL, NULL);
- return 0;
+ return VC_ERROR_NONE;
}
*vc = temp;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_destroy(vc_h vc)
{
if (vc == NULL) {
SLOG(LOG_ERROR, TAG_VCW, "Input parameter is NULL");
- return 0;
+ return VC_ERROR_NONE;
}
vc_widget_s *data = NULL;
vc = NULL;
pthread_mutex_unlock(&g_widget_list_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
}
}
SLOG(LOG_ERROR, TAG_VCW, "[ERROR] widget Not found");
pthread_mutex_unlock(&g_widget_list_mutex);
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
GSList* vc_widget_client_get_client_list()
if (uid == data->vc->handle) {
*vc = data->vc;
pthread_mutex_unlock(&g_widget_list_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
}
}
pthread_mutex_unlock(&g_widget_list_mutex);
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
/* set/get callback function */
widget->result_cb = callback;
widget->result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_result_cb(vc_h vc, vc_result_cb* callback, void** user_data)
*callback = widget->result_cb;
*user_data = widget->result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_asr_result_enabled(vc_h vc, bool enabled)
widget->asr_result_enabled = enabled;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_asr_result_enabled(vc_h vc, bool* enabled)
*enabled = widget->asr_result_enabled;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_asr_result_cb(vc_h vc, vc_asr_result_cb callback, void* user_data)
widget->asr_result_cb = callback;
widget->asr_result_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_asr_result_cb(vc_h vc, vc_asr_result_cb* callback, void** user_data)
*callback = widget->asr_result_cb;
*user_data = widget->asr_result_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb callback, void* user_data)
widget->service_state_changed_cb = callback;
widget->service_state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_service_state_changed_cb(vc_h vc, vc_service_state_changed_cb* callback, void** user_data)
*callback = widget->service_state_changed_cb;
*user_data = widget->service_state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_state_changed_cb(vc_h vc, vc_state_changed_cb callback, void* user_data)
widget->state_changed_cb = callback;
widget->state_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_state_changed_cb(vc_h vc, vc_state_changed_cb* callback, void** user_data)
*callback = widget->state_changed_cb;
*user_data = widget->state_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_show_tooltip_cb(vc_h vc, vc_widget_show_tooltip_cb callback, void* user_data)
widget->show_tooltip_cb = callback;
widget->show_tooltip_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_show_tooltip_cb(vc_h vc, vc_widget_show_tooltip_cb* callback, void** user_data)
*callback = widget->show_tooltip_cb;
*user_data = widget->show_tooltip_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb callback, void* user_data)
widget->current_lang_changed_cb = callback;
widget->current_lang_changed_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_current_lang_changed_cb(vc_h vc, vc_current_language_changed_cb* callback, void** user_data)
*callback = widget->current_lang_changed_cb;
*user_data = widget->current_lang_changed_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_error_cb(vc_h vc, vc_error_cb callback, void* user_data)
widget->error_cb = callback;
widget->error_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_error_cb(vc_h vc, vc_error_cb* callback, void** user_data)
*callback = widget->error_cb;
*user_data = widget->error_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_send_command_list_cb(vc_h vc, vc_widget_send_current_command_list_cb callback, void* user_data)
widget->send_command_list_cb = callback;
widget->send_command_list_user_data = user_data;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_send_command_list_cb(vc_h vc, vc_widget_send_current_command_list_cb* callback, void** user_data)
*callback = widget->send_command_list_cb;
*user_data = widget->send_command_list_user_data;
- return 0;
+ return VC_ERROR_NONE;
}
widget->service_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_service_state(vc_h vc, vc_service_state_e* state)
*state = widget->service_state;
- return 0;
+ return VC_ERROR_NONE;
}
widget->before_state = widget->current_state;
widget->current_state = state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_state(vc_h vc, vc_state_e* state)
*state = widget->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_state_by_uid(unsigned int uid, vc_state_e* state)
if (uid == data->vc->handle) {
*state = data->current_state;
pthread_mutex_unlock(&g_widget_list_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
}
}
pthread_mutex_unlock(&g_widget_list_mutex);
- return -1;
+ return VC_ERROR_INVALID_PARAMETER;
}
int vc_widget_client_get_before_state(vc_h vc, vc_state_e* state, vc_state_e* before_state)
*before_state = widget->before_state;
*state = widget->current_state;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_xid(vc_h vc, int xid)
widget->xid = xid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_cilent_get_xid(vc_h vc, int* xid)
*xid = widget->xid;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_error(vc_h vc, int reason)
widget->reason = reason;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_error(vc_h vc, int* reason)
*reason = widget->reason;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_set_show_tooltip(vc_h vc, bool show)
widget->show_tooltip = show;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_show_tooltip(vc_h vc, bool* show)
*show = widget->show_tooltip;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_get_count()
return VC_ERROR_INVALID_PARAMETER;
widget->cb_ref_count++;
- return 0;
+ return VC_ERROR_NONE;
}
int vc_widget_client_not_use_callback(vc_h vc)
return VC_ERROR_INVALID_PARAMETER;
widget->cb_ref_count--;
- return 0;
+ return VC_ERROR_NONE;
}
vc_db_finalize();
vc_db_initialize();
}
- return 0;
+ return VC_DB_ERROR_NONE;
}
static int __vc_db_transaction(sqlite3* db_handle, const char* transaction)
g_ref_cnt++;
SLOG(LOG_INFO, vc_db_tag(), "[SUCCESS] DB initialization after restore for daemon");
- return 0;
+ return VC_DB_ERROR_NONE;
}
is_connect = __vc_db_connect_db_for_daemon(&g_backup_path, &g_db_backup_handle);
}
if (!g_db_handle)
- return 0;
+ return VC_DB_ERROR_NONE;
db_util_close(g_db_handle);
g_db_handle = NULL;
if (!g_db_backup_handle)
- return 0;
+ return VC_DB_ERROR_NONE;
db_util_close(g_db_backup_handle);
g_db_backup_handle = NULL;
}
}
- return 0;
+ return VC_ERROR_NONE;
}
static int __check_privilege_initialize()
cmd->id = id;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
*id = cmd->id;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
cmd->appid = strdup(appid);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
cmd->parameter = strdup(command);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
cmd->fixed = strdup(fixed);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
cmd->invocation_name = strdup(invocation_name);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
*invocation_name = NULL;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_type(vc_cmd_h vc_command, int type)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_format(vc_cmd_h vc_command, int format)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
- return 0;
+ return VC_ERROR_NONE;
}
/**
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
/**
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
return VC_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VC_ERROR_NONE;
}
static void __vc_cmd_regex_deinit(int num_regex)
if (!strcmp(engine_id, engine_info->uuid)) {
SLOG(LOG_DEBUG, vc_config_tag(), "Default engine is valid : %s", engine_id);
- return 0;
+ return VC_ERROR_NONE;
}
iter = g_slist_next(iter);
return -1;
}
- return 0;
+ return VC_ERROR_NONE;
}
bool __vc_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
return -1;
}
- return 0;
+ return VC_ERROR_NONE;
}
static Eina_Bool __vc_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
g_ino_list = g_list_append(g_ino_list, ino);
pthread_mutex_unlock(&vc_config_engine_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
static int __vc_config_mgr_unregister_engine_config_updated_event()
}
}
pthread_mutex_unlock(&vc_config_engine_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
Eina_Bool vc_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
SLOG(LOG_DEBUG, vc_config_tag(), "[Config] VC language(%s) is same with display language", g_config_info->language);
- return 0;
+ return VC_ERROR_NONE;
}
if (true == __vc_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
if (NULL != before_lang) free(before_lang);
}
- return 0;
+ return VC_ERROR_NONE;
}
void __vc_config_language_changed_cb(keynode_t *key, void *data)
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
- return 0;
+ return VC_ERROR_NONE;
}
iter = g_slist_next(iter);
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
- return 0;
+ return VC_ERROR_NONE;
}
/* Get file name from default engine directory */
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_finalize(unsigned int uid)
pthread_mutex_unlock(&vc_config_mgr_mutex);
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
- return 0;
+ return VC_ERROR_NONE;
}
__vc_config_release_engine();
SLOG(LOG_DEBUG, vc_config_tag(), "[WARNING] Leave critical section");
SLOG(LOG_DEBUG, vc_config_tag(), "[Success] Finalize config");
- return 0;
+ return VC_ERROR_NONE;
}
}
g_lang_ref_count++;
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_config_mgr_unregister_config_event()
vconf_ignore_key_changed(VCONFKEY_LANGSET, __vc_config_language_changed_cb);
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_set_engine_cb(unsigned int uid, vc_config_engine_changed_cb engine_cb)
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_unset_engine_cb(unsigned int uid)
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
- return 0;
+ return VC_ERROR_NONE;
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_unset_lang_cb(unsigned int uid)
pthread_mutex_unlock(&vc_config_mgr_mutex);
ecore_thread_main_loop_end();
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_set_enabled_cb(unsigned int uid, vc_config_enabled_cb enabled_cb)
if (uid == temp_client->uid) {
temp_client->enabled_cb = NULL;
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
}
iter = g_slist_next(iter);
*value = g_config_info->auto_lang;
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_set_auto_language(bool value)
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_get_engine_list(vc_config_supported_engine_cb callback, void* user_data)
/* Check current engine id with new engine id */
if (0 == strncmp(g_config_info->engine_id, engine, strlen(g_config_info->engine_id))) {
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
SLOG(LOG_DEBUG, vc_config_tag(), "New engine id : %s", engine);
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_get_default_language(char** language)
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
static int __vc_config_mgr_set_default_language(const char* language)
return -1;
}
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_set_default_language(const char* language)
*value = g_config_info->enabled;
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_set_enabled(bool value)
g_config_info->enabled = value;
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_config_mgr_get_nonfixed_support(bool* value)
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return 0;
+ return VC_ERROR_NONE;
}
bool vc_config_check_default_engine_is_valid(const char* engine)
SLOG(LOG_DEBUG, vc_config_tag(), "@ engine list @");
SLOG(LOG_DEBUG, vc_config_tag(), " No Engine in engine directory");
SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
- return 0;
+ return VC_ERROR_NONE;
}
/* Get a first item */
}
SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int __vc_config_mgr_print_client_info()
SLOG(LOG_DEBUG, vc_config_tag(), "@ Client list @");
SLOG(LOG_DEBUG, vc_config_tag(), " No Client");
SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
- return 0;
+ return VC_ERROR_NONE;
}
/* Get a first item */
}
SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int ret = app_manager_get_app_id(pid, &appid);
if (0 != ret || NULL == appid) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] fail to get app id, ret(%d), pid(%d)", ret, pid);
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
if (-1 != g_manager.pid && NULL != g_manager.appid && 0 == strncmp(g_manager.appid, appid, strlen(g_manager.appid))) {
SLOG(LOG_WARN, TAG_VCD, "Same manager has already registered. It doesn't need to set manager again.");
if (appid)
free(appid);
- return 0;
+ return VCD_ERROR_NONE;
}
g_manager.pid = pid;
free(appid);
appid = NULL;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_manager_unset()
g_manager.manager_cmd = false;
g_manager.exclusive_cmd_option = false;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_manager_unset_appid()
free(g_manager.appid);
g_manager.appid = NULL;
}
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_client_manager_is_valid(int pid)
{
if (pid != g_manager.pid) {
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT valid", pid);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
g_manager.manager_cmd = true;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_manager_unset_command(int pid)
{
if (pid != g_manager.pid) {
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT valid", pid);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
g_manager.manager_cmd = false;
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_client_manager_is_system_command_valid(int pid)
g_demandable_client = client_list;
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_client_manager_check_demandable_client(int pid)
int vcd_client_manager_set_exclusive(bool value)
{
g_manager.exclusive_cmd_option = value;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_manager_get_pid()
if (NULL != g_manager.appid)
*appid = strdup(g_manager.appid);
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_manager_set_result_text(const char* result)
g_result_text = strdup(result);
}
- return 0;
+ return VCD_ERROR_NONE;
}
char* vcd_client_manager_get_result_text()
free(g_mgr_tidl_info);
g_mgr_tidl_info = NULL;
- return 0;
+ return VCD_ERROR_NONE;
}
manager_tidl_info_s* vcd_client_manager_get_tidl_info()
__vcd_client_release_each_commands(&(g_cur_cmd_list.foreground_cmds));
__vcd_client_release_each_commands(&(g_cur_cmd_list.background_cmds));
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_command_collect_command()
SLOG(LOG_INFO, TAG_VCD, "[Client Data] No exclusive system commands");
}
- return 0;
+ return VCD_ERROR_NONE;
}
/* 3. Set system command */
g_cur_cmd_list.background_cmds = bg_cmd_list;
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_get_length()
} else {
SLOG(LOG_INFO, TAG_VCD, "[Client Data] No background commands");
}
- return 0;
+ return VCD_ERROR_NONE;
}
static vc_cmd_s* __command_copy(vc_cmd_s* src_cmd)
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
/*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
/*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
/*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
/*SLOG(LOG_DEBUG, TAG_VCD, "[Client Data] Find result pid(%d) type(%d)", *pid, *cmd_type); */
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
if (result_id == temp_cmd->id) {
*result = __command_copy(temp_cmd);
- return 0;
+ return VCD_ERROR_NONE;
}
iter = g_slist_next(iter);
}
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] Not find matched result");
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
int vcd_client_set_slience_detection(bool value)
{
g_silence_detection = value;
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_client_get_slience_detection()
int vcd_client_set_recognition_mode(vcd_recognition_mode_e mode)
{
g_recognition_mode = mode;
- return 0;
+ return VCD_ERROR_NONE;
}
vcd_recognition_mode_e vcd_client_get_recognition_mode()
client_info->server_dialog = is_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;
+ return VCD_ERROR_NONE;
}
int vcd_client_get_server_dialog(int pid, bool* is_server_dialog)
*is_server_dialog = client_info->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 VCD_ERROR_NONE;
}
int vcd_client_append_cmd_from_type(int type, vc_cmd_list_h list)
item = item->next;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int __show_client_list()
SLOG(LOG_DEBUG, TAG_VCD, "@@@");
- return 0;
+ return VCD_ERROR_NONE;
}
int __show_command_list(GSList* cmd_group)
SLOG(LOG_DEBUG, TAG_VCD, "@@@");
- return 0;
+ return VCD_ERROR_NONE;
}
GSList* __client_get_item(const int pid)
free(info);
info = NULL;
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
} else {
SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new client");
}
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
#endif
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_delete(int pid)
__show_client_list();
#endif
- return 0;
+ return VCD_ERROR_NONE;
}
GSList* __get_client_tidl_info_item(const int pid)
free(info);
info = NULL;
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
} else {
SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new client tidl info. pid(%d)", pid);
}
/*Delete handle from list*/
g_client_tidl_info_list = g_slist_delete_link(g_client_tidl_info_list, tmp);
- return 0;
+ return VCD_ERROR_NONE;
}
client_tidl_info_s* vcd_client_get_tidl_info(int pid)
int vcd_client_get_tidl_list(int** pids, int* pid_count)
{
if (NULL == pids || NULL == pid_count)
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
int count = g_slist_length(g_client_tidl_info_list);
if (0 == count)
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
int *tmp;
tmp = (int*)calloc(count, sizeof(int));
*pids = tmp;
*pid_count = count;
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_client_is_available(int pid)
int vcd_client_get_list(int** pids, int* pid_count)
{
if (NULL == pids || NULL == pid_count)
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
int count = g_slist_length(g_client_list);
if (0 == count)
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
int *tmp;
tmp = (int*)calloc(count, sizeof(int));
*pids = tmp;
*pid_count = count;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_set_command_type(int pid, int type)
break;
default:
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] not supported command type(%d)", type);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_unset_command_type(int pid, int type)
break;
default:
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] not supported command type(%d)", type);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_set_exclusive_command(int pid)
client_info->exclusive_cmd = true;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_unset_exclusive_command(int pid)
client_info->exclusive_cmd = false;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_save_client_info()
{
if (0 != vc_info_parser_set_client_info(g_client_list)) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to save client info");
- return -1;
+ return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
/*
int vcd_client_widget_get_list(int** pids, int* pid_count)
{
if (NULL == pids || NULL == pid_count)
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
int count = g_slist_length(g_widget_list);
if (0 == count)
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
int *tmp;
tmp = (int*)calloc(count, sizeof(int));
*pids = tmp;
*pid_count = count;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_add(int pid)
free(info);
info = NULL;
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
} else {
SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new widget");
}
#ifdef CLIENT_DATA_DEBUG
__show_client_list();
#endif
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_delete(int pid)
__show_client_list();
#endif
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_get_foreground_pid()
widget = __widget_get_element(fg_pid);
if (NULL == widget) {
SLOG(LOG_WARN, TAG_VCD, "[Client Data] Not found foreground pid of widget");
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
return widget->pid;
info->widget_cmd = true;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_unset_command(int pid)
info->widget_cmd = false;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_set_asr_result_enabled(int pid, bool enable)
info->asr_result_enabled = enable;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_get_asr_result_enabled(int pid, bool* enable)
*enable = info->asr_result_enabled;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_set_waiting_for_recording(int pid, bool waiting)
if (TRUE == waiting && pid != vcd_client_widget_get_foreground_pid()) {
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT foreground pid", pid);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
g_is_waiting_recording = waiting;
g_waiting_recording_pid = pid;
SLOG(LOG_ERROR, TAG_VCD, "[INFO] Success to set waiting for recording, pid(%d), waiting(%d)", pid, waiting);
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_client_widget_get_waiting_for_recording(int pid, bool* waiting)
{
if (pid != g_waiting_recording_pid) {
SLOG(LOG_ERROR, TAG_VCD, "[Client Data ERROR] pid(%d) is NOT waiting pid", pid);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
*waiting = g_is_waiting_recording;
SLOG(LOG_ERROR, TAG_VCD, "[INFO] Success to get waiting for recording, waiting(%d)", *waiting);
- return 0;
+ return VCD_ERROR_NONE;
}
GSList* __get_widget_tidl_info_item(const int pid)
free(info);
info = NULL;
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
} else {
SLOG(LOG_INFO, TAG_VCD, "[Client Data SUCCESS] Add new widget tidl info. pid(%d)", pid);
}
/*Delete handle from list*/
g_widget_tidl_info_list = g_slist_delete_link(g_widget_tidl_info_list, tmp);
- return 0;
+ return VCD_ERROR_NONE;
}
widget_tidl_info_s* vcd_client_widget_get_tidl_info(int pid)
free(info);
info = NULL;
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
} else {
SLOG(LOG_INFO, TAG_VCD, "[Setting Data SUCCESS] Add new setting client tidl info. pid(%d)", pid);
}
/*Delete handle from list*/
g_setting_tidl_info_list = g_slist_delete_link(g_setting_tidl_info_list, tmp);
- return 0;
+ return VCD_ERROR_NONE;
}
setting_tidl_info_s* vcd_client_setting_get_tidl_info(int pid)
int vcd_client_setting_get_tidl_list(int** pids, int* pid_count)
{
if (NULL == pids || NULL == pid_count)
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
int count = g_slist_length(g_setting_tidl_info_list);
if (0 == count)
- return -1;
+ return VCD_ERROR_OUT_OF_MEMORY;
int *tmp;
tmp = (int*)calloc(count, sizeof(int));
*pids = tmp;
*pid_count = count;
- return 0;
+ return VCD_ERROR_NONE;
}
g_foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_finalize()
vc_config_mgr_unset_lang_cb(getpid());
vc_config_mgr_finalize(getpid());
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_get_default_language(char** language)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_set_default_language(const char* language)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_set_service_state(vcd_state_e state)
SLOG(LOG_INFO, TAG_VCD, "[Config] Config is changed : %d", g_state);
- return 0;
+ return VCD_ERROR_NONE;
}
vcd_state_e vcd_config_get_service_state()
int vcd_config_get_foreground(int* pid)
{
*pid = g_foreground_pid;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_set_foreground(int pid, bool value)
g_foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_set_disabled_command_type(int disabled_cmd_type)
g_disabled_command_type = disabled_cmd_type;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_get_command_type_enabled(int cmd_type)
{
if (cmd_type <= 0 || cmd_type >= COMMAND_TYPE_MAX) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid command type");
- return 0;
+ return VCD_ERROR_NONE;
}
if (~(g_disabled_command_type) & (1 << cmd_type))
return 1;
else
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_get_audio_streaming_mode(vcd_audio_streaming_mode_e* streaming_mode)
{
*streaming_mode = g_audio_streaming_mode;
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_config_set_audio_streaming_mode(vcd_audio_streaming_mode_e streaming_mode)
{
if (streaming_mode < VCD_AUDIO_STREAMING_MODE_VC_SERVICE || streaming_mode > VCD_AUDIO_STREAMING_MODE_OUTSIDE) {
SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Invalid streaming mode(%d)", streaming_mode);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
g_audio_streaming_mode = streaming_mode;
- return 0;
+ return VCD_ERROR_NONE;
}
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent Initialize");
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_agent_release()
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent release");
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_engine_is_available_engine()
SLOG(LOG_INFO, TAG_VCD, "Engine setting : %s", g_dynamic_engine.engine_setting_path);
SLOG(LOG_INFO, TAG_VCD, "@@@");
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_agent_load_current_engine(vce_request_callback_s* callback)
if (true == g_dynamic_engine.is_loaded) {
SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent] Engine has already been loaded");
- return 0;
+ return VCD_ERROR_NONE;
}
/* Get current engine info */
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] load current engine FINISH");
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_agent_unload_current_engine()
/* reset current engine data */
g_dynamic_engine.is_loaded = false;
- return 0;
+ return VCD_ERROR_NONE;
}
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Dynamic engine is not available");
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_recognize_start(bool silence)
}
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent SUCCESS] Engine start");
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_recognize_audio(const void* data, unsigned int length, vce_speech_detect_e* speech_detected)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_recognize_stop()
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_recognize_cancel()
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_set_audio_type(const char* audio)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_set_server_dialog(const char* app_id, const char* credential)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_set_domain(int pid, const char* domain)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_get_nlu_base_info(int pid, const char* key, char** value)
return VCD_ERROR_NONE;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_set_private_data(int pid, const char* key, const char* data)
return VCD_ERROR_NONE;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_get_private_data(int pid, const char* key, char** data)
return VCD_ERROR_NONE;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_send_specific_engine_request(const char* engine_app_id, const char* event, const char* request)
return VCD_ERROR_NONE;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_process_text(int pid, const char* text)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_process_list_event(int pid, const char* event)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_process_haptic_event(int pid, const char* event)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_request_tts(int pid, int utt_id, const char* text, const char* language)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_cancel_tts(int pid, int utt_id)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_get_tts_audio_format(int* rate, int* channel, int* audio_type)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
return ret;
}
- return 0;
+ return VCD_ERROR_NONE;
}
static bool __supported_language_cb(const char* language, void* user_data)
return ret;
}
- return 0;
+ return VCD_ERROR_NONE;
}
/* get default language */
*lang = g_strdup(g_default_lang);
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_set_current_language(const char* language)
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Dynamic engine is not available (Cannot start)");
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_agent_get_foreach_command(vce_cmd_h vce_command, vce_command_cb callback, void* user_data)
SLOG(LOG_INFO, TAG_VCD, "[Engine Agent] Request command length from engine");
*count = vcd_client_get_length();
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_engine_agent_get_audio_type(char** audio_type)
if (VCD_STATE_READY == state) {
SLOG(LOG_DEBUG, TAG_VCD, "[Server] Ready state, but recording");
} else if (VCD_STATE_PROCESSING == state) {
- return 0;
+ return VCD_ERROR_NONE;
}
vce_speech_detect_e speech_detected = VCE_SPEECH_DETECT_NONE;
} else {
vcdc_tidl_send_error_to_manager(vcd_client_manager_get_pid(), ret, "voice_framework.error.engine.set_recording_fail");
}
- return 0;
+ return VCD_ERROR_NONE;
}
if (VCE_SPEECH_DETECT_BEGIN == speech_detected) {
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
void __server_recorder_interrupt_callback()
SLOG(LOG_ERROR, TAG_VCD, "[Server SUCCESS] initialize");
- return 0;
+ return VCD_ERROR_NONE;
}
bool vcd_finalize()
}
// Reset flag to wait for recording from widget client
vcd_client_widget_set_waiting_for_recording(-1, false);
- return 0;
+ return VCD_ERROR_NONE;
}
#if 0
// Set flag to wait for recording from widget client
vcd_client_widget_set_waiting_for_recording(pid, true);
- return 0;
+ return VCD_ERROR_NONE;
}
static int __start_internal_recognition()
SLOG(LOG_ERROR, TAG_VCD, "[Server Success] Start recognition(%d)", stop_by_silence);
- return 0;
+ return VCD_ERROR_NONE;
}
static Eina_Bool __vcd_request_show_tooltip(void *data)
ecore_timer_add(0, __vcd_request_show_tooltip, (void*)true);
__set_waiting_for_widget_recording(pid);
- return 0;
+ return VCD_ERROR_NONE;
}
}
} else {
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_unset_command(int pid, vc_cmd_type_e cmd_type)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_set_foreground(int pid, bool value)
return VCD_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VCD_ERROR_NONE;
}
static int __vcd_server_launch_manager_app()
SLOG(LOG_INFO, TAG_VCD, "[Server] Set to false for server dialog, app_id(%s)", app_id);
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_dialog(int pid, const char* disp_text, const char* utt_text, int continuous)
return ret;
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_is_system_command_valid(int pid, int* is_sys_cmd_valid)
else
*is_sys_cmd_valid = false;
- return 0;
+ return VCD_ERROR_NONE;
}
static void __start_tts_request_thread(void* data, Ecore_Thread* thread)
g_tts_thread = ecore_thread_run(__start_tts_request_thread, __end_tts_request_thread, NULL, NULL);
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_cancel_tts(int pid, int utt_id)
}
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_request_start(int pid, bool stop_by_silence)
return VCD_ERROR_INVALID_PARAMETER;
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_request_stop(int pid)
if (0 == vcd_client_get_ref_count()) {
SLOG(LOG_ERROR, TAG_VCD, "[Server] connected client list is empty, vc-service will be terminated");
ecore_timer_add(0, __finalize_quit_ecore_loop, NULL);
- return 0;
+ return VCD_ERROR_NONE;
}
return VCD_ERROR_INVALID_PARAMETER;
}
if (0 == vcd_client_get_ref_count()) {
SLOG(LOG_ERROR, TAG_VCD, "[Server] connected client list is empty, vc-service will be terminated");
ecore_timer_add(0, __finalize_quit_ecore_loop, NULL);
- return 0;
+ return VCD_ERROR_NONE;
}
bool is_waiting = false;
bool waiting;
if (0 != vcd_client_widget_get_waiting_for_recording(pid, &waiting) || false == waiting) {
SLOG(LOG_ERROR, TAG_VCD, "[Server] Server is not waiting for recording, pid(%d), waiting(%d)", pid, waiting);
- return 0;
+ return VCD_ERROR_NONE;
}
if (true == widget_command) {
ecore_timer_add(0, __vcd_request_show_tooltip, (void*)false);
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_widget_start(int pid, bool stop_by_silence)
/* Notify show tooltip */
ecore_timer_add(0, __vcd_request_show_tooltip, (void*)true);
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_server_widget_stop(int pid)
SLOG(LOG_ERROR, TAG_VCD, "[Server ERROR] Update event : Fail - msg(%s)", msg);
}
- return 0;
+ return VCD_ERROR_NONE;
}
int vcd_set_private_data_set_cb(vce_private_data_set_cb callback_func)
SLOG(LOG_ERROR, TAG_VCD, "[DATA ERROR] There is no tts_text data");
*data = NULL;
pthread_mutex_unlock(&g_tts_text_data_mutex);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
std::list<vc_tts_text_data_s *>::iterator iter;
SLOG(LOG_ERROR, TAG_VCD, "[DATA ERROR] There is no tts_text data");
*data = NULL;
pthread_mutex_unlock(&g_tts_text_data_mutex);
- return -1;
+ return VCD_ERROR_INVALID_PARAMETER;
}
std::list<vc_tts_text_data_s*>::iterator iter;
}
}
- return 0;
+ return VCE_ERROR_NONE;
}
static int __check_privilege_initialize()
SLOG(LOG_DEBUG, TAG_VCD, " ");
SLOG(LOG_DEBUG, TAG_VCD, " ");
- return 0;
+ return VCE_ERROR_NONE;
}
int vce_send_result(vce_result_event_e event, int* result_id, int count, const char* all_result, const char* non_fixed_result, const char* nlu_result, const char* msg, int* user_info, void *user_data)
projects / platform / core / uifw / voice-control.git / commitdiff