Fix ipc sync function's return value

Change-Id: Ideac4cd335daf2de50153f96443af85bde0a0f49

diff --git a/client/vc_mgr_tidl.c b/client/vc_mgr_tidl.c
index 27154fc..a351965 100755 (executable)
--- a/client/vc_mgr_tidl.c
+++ b/client/vc_mgr_tidl.c
@@ -767,9 +767,10 @@ int vc_mgr_tidl_request_initialize(int pid, int audio_streaming_mode, int* servi
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, audio_streaming_mode, &tmp_service_state, &tmp_forground, &tmp_daemon_pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, audio_streaming_mode, &tmp_service_state, &tmp_forground, &tmp_daemon_pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager initialize : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        *service_state = tmp_service_state;
@@ -795,9 +796,10 @@ int vc_mgr_tidl_request_finalize(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_finalize(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager finalize : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -817,9 +819,10 @@ int vc_mgr_tidl_request_set_command(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_set_command(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set command : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -839,9 +842,10 @@ int vc_mgr_tidl_request_unset_command(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_unset_command(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager unset command : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -861,9 +865,10 @@ int vc_mgr_tidl_request_demandable_client(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_demandable_client(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager demandable client : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -883,9 +888,10 @@ int vc_mgr_tidl_request_set_audio_type(int pid, const char* audio_type)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_set_audio_type(g_proxy_tidl_info->rpc_h, pid, audio_type);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set audio type : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -906,9 +912,10 @@ int vc_mgr_tidl_request_get_audio_type(int pid, char** audio_type)
        }
 
        char *tmp = NULL;
-       if (0 != rpc_port_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_get_audio_type(g_proxy_tidl_info->rpc_h, pid, &tmp);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get audio type : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get audio type : Success");
 
@@ -951,9 +958,10 @@ int vc_mgr_tidl_request_get_private_data(int pid, const char* key, char** data)
        }
 
        char *tmp = NULL;
-       if (0 != rpc_port_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_get_private_data(g_proxy_tidl_info->rpc_h, pid, key, &tmp);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager get private data : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCM, "[TIDL] Request vc manager get private data : Success");
 
@@ -976,9 +984,10 @@ int vc_mgr_tidl_request_set_client_info(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_set_client_info(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set client info : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -998,9 +1007,10 @@ int vc_mgr_tidl_request_set_domain(int pid, const char* domain)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_set_domain(g_proxy_tidl_info->rpc_h, pid, domain);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager set domain : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -1039,9 +1049,10 @@ int vc_mgr_tidl_request_start(int pid, int recognition_mode, bool exclusive_comm
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_start(g_proxy_tidl_info->rpc_h, pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_start(g_proxy_tidl_info->rpc_h, pid, recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager start : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -1061,9 +1072,10 @@ int vc_mgr_tidl_request_stop(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_stop(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager stop : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -1083,9 +1095,10 @@ int vc_mgr_tidl_request_cancel(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_mgr_invoke_cancel(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCM, "[TIDL ERROR] Request vc manager cancel : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;

diff --git a/client/vc_widget_tidl.c b/client/vc_widget_tidl.c
index 3002bf5..da50b61 100644 (file)
--- a/client/vc_widget_tidl.c
+++ b/client/vc_widget_tidl.c
@@ -449,10 +449,11 @@ int vc_widget_tidl_request_initialize(int pid, int* service_state, int* daemon_p
 
        int temp_service_state = 0;
        int temp_daemon_pid = 0;
-       if (0 != rpc_port_proxy_vc_widget_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, &temp_service_state, &temp_daemon_pid)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget initialize : Fail to invoke message");
+       int ret = rpc_port_proxy_vc_widget_invoke_initialize(g_proxy_tidl_info->rpc_h, pid, &temp_service_state, &temp_daemon_pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget initialize : Fail to invoke message, error(%d)", ret);
                pthread_mutex_unlock(&g_w_init_mutex);
-               return VC_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        *service_state = temp_service_state;
@@ -481,10 +482,11 @@ int vc_widget_tidl_request_finalize(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_finalize(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget finalize : Fail to invoke message");
+       int ret = rpc_port_proxy_vc_widget_invoke_finalize(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget finalize : Fail to invoke message, error(%d)", ret);
                pthread_mutex_unlock(&g_w_init_mutex);
-               return VC_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        pthread_mutex_unlock(&g_w_init_mutex);
@@ -505,9 +507,10 @@ int vc_widget_tidl_request_start_recording(int pid, bool command)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_start_recording(g_proxy_tidl_info->rpc_h, pid, (int)command)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start recording : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_widget_invoke_start_recording(g_proxy_tidl_info->rpc_h, pid, (int)command);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start recording : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -527,6 +530,7 @@ int vc_widget_tidl_set_foreground(int pid, bool value)
                return VC_ERROR_OPERATION_FAILED;
        }
 
+       // TODO: Error tolerance cannot be applied because this function is asynchronous.
        rpc_port_proxy_vc_widget_invoke_set_foreground(g_proxy_tidl_info->rpc_h, pid, (int)value);
 
        return VC_ERROR_NONE;
@@ -546,9 +550,10 @@ int vc_widget_tidl_request_enable_asr_result(int pid, bool enable)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_enable_asr_result(g_proxy_tidl_info->rpc_h, pid, (int)enable)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget enable asr result : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_widget_invoke_enable_asr_result(g_proxy_tidl_info->rpc_h, pid, (int)enable);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget enable asr result : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -568,9 +573,10 @@ int vc_widget_tidl_request_start(int pid, int silence)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_start(g_proxy_tidl_info->rpc_h, pid, silence)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_widget_invoke_start(g_proxy_tidl_info->rpc_h, pid, silence);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget start : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -590,9 +596,10 @@ int vc_widget_tidl_request_stop(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_stop(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget stop : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_widget_invoke_stop(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget stop : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;
@@ -612,9 +619,10 @@ int vc_widget_tidl_request_cancel(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vc_widget_invoke_cancel(g_proxy_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget cancel : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vc_widget_invoke_cancel(g_proxy_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCW, "[TIDL ERROR] Request vc widget cancel : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
 
        return VC_ERROR_NONE;

diff --git a/server/vcd_tidl.c b/server/vcd_tidl.c
index 1d87f70..784f9c0 100644 (file)
--- a/server/vcd_tidl.c
+++ b/server/vcd_tidl.c
@@ -844,9 +844,10 @@ int vcdc_send_request_get_private_data(int pid, const char* key, char** data)
        }
 
        char *tmp = NULL;
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_get_private_data(mgr_tidl_info->rpc_h, pid, key, &tmp)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request vcd manager get private data : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_get_private_data(mgr_tidl_info->rpc_h, pid, key, &tmp);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request vcd manager get private data : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request vcd manager get private data : Success");
 
@@ -871,9 +872,10 @@ int vcdc_send_request_auth_enable(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_enable(mgr_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth enable : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_auth_enable(mgr_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth enable : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth enable : Success");
 
@@ -896,9 +898,10 @@ int vcdc_send_request_auth_disable(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_disable(mgr_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth disable : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_auth_disable(mgr_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth disable : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth disable : Success");
 
@@ -921,9 +924,10 @@ int vcdc_send_request_auth_start(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_start(mgr_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth start : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_auth_start(mgr_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth start : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth start : Success");
 
@@ -946,9 +950,10 @@ int vcdc_send_request_auth_stop(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_stop(mgr_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth stop : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_auth_stop(mgr_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth stop : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth stop : Success");
 
@@ -971,9 +976,10 @@ int vcdc_send_request_auth_cancel(int pid)
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_vcd_mgr_invoke_auth_cancel(mgr_tidl_info->rpc_h, pid)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth cancel : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_mgr_invoke_auth_cancel(mgr_tidl_info->rpc_h, pid);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request auth cancel : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request auth cancel : Success");
 
@@ -997,9 +1003,10 @@ int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_typ
        }
 
        bool temp;
-       if (0 != rpc_port_proxy_vcd_widget_invoke_send_asr_result(widget_tidl_info->rpc_h, pid, event, asr_result, &temp)) {
-               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request vcd widget send asr result : Fail to invoke message");
-               return VC_ERROR_OPERATION_FAILED;
+       int ret = rpc_port_proxy_vcd_widget_invoke_send_asr_result(widget_tidl_info->rpc_h, pid, event, asr_result, &temp);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_VCD, "[TIDL ERROR] Request vcd widget send asr result : Fail to invoke message, error(%d)", ret);
+               return ret;
        }
        SLOG(LOG_DEBUG, TAG_VCD, "[TIDL] Request vcd widget send asr result : Success");