Simplify the precondition checking code

- Issue:
Each functions of TTS framework have many precondition checking codes and
these codes are duplicated.

- Solution:
This patch creates macro for simplifying the precondition checking
codes. According to this patch, each checking codes are becoming shorter
and simpler than before. There are still duplicated code, but these
codes are shorter than before, so these can effectively reduce the line of
duplicated code.

Change-Id: Ibf705a819217d892ff4d2bdcb2d74d3539640b65
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/client/tts.c b/client/tts.c
index 2cc9f770725203697ea4110a44d5fb44e22dfaff..9ce0353e5cc7d9e31cf35fa2259aa047da5ffba6 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -29,6 +29,7 @@
 #include "tts_main.h"
 #include "tts_core.h"
 #include "tts_ipc.h"
+#include "tts_dlog.h"
 
 #include "tts_internal.h"
 
@@ -149,10 +150,7 @@ static void __tts_config_engine_changed_cb(const char* engine_id, const char* se
        tts_h tts = (tts_h)user_data;
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        if (NULL != engine_id)  SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
        if (NULL != setting)    SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
@@ -192,10 +190,7 @@ static void __tts_config_screen_reader_changed_cb(bool value, void* user_data)
        tts_h tts = (tts_h)user_data;
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "Screen reader is changed. current status (%d)", value);
 
@@ -213,10 +208,7 @@ int tts_create(tts_h* tts)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == tts, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input handle is null");
 
        bool is_first_client = false;
        if (0 == tts_client_get_size()) {
@@ -310,10 +302,7 @@ int tts_destroy(tts_h tts)
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        unsigned int uid = tts_client_get_uid(client);
        SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts, client, uid);
@@ -392,22 +381,13 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
 
-       if (TTS_MODE_DEFAULT > mode || TTS_MODE_INTERRUPT < mode) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(TTS_MODE_DEFAULT > mode || TTS_MODE_INTERRUPT < mode, TTS_ERROR_INVALID_PARAMETER, "[ERROR] mode is not valid : %d", mode);
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_mode(client, mode);
 
@@ -423,22 +403,13 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
 
-       if (NULL == mode) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == mode, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter(mode) is NULL");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        *mode = tts_client_get_mode(client);
 
@@ -452,22 +423,13 @@ int tts_set_credential(tts_h tts, const char* credential)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == credential) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == credential, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state && TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state && TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_credential_key(client, credential);
 
@@ -483,17 +445,11 @@ int tts_set_server_tts(tts_h tts, const char* credential)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        // TODO: fix state check, because set_private_data runs only ready state
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state && TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state && TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        // TODO: fix name more clear and move into tts_client
        client->internal = true;
@@ -545,16 +501,10 @@ int tts_prepare(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
        int ret = tts_core_prepare(client);
@@ -574,16 +524,10 @@ int tts_prepare_sync(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS synchronously");
        int ret = tts_core_prepare_sync(client);
@@ -603,16 +547,10 @@ int tts_unprepare(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
        int ret = tts_core_unprepare(client);
@@ -635,16 +573,10 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Foreach supported voices");
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        int ret = 0;
        char* current_engine = NULL;
@@ -674,16 +606,10 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 
-       if (NULL == lang || NULL == vctype) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == lang || NULL == vctype, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        /* Request call remote method */
        int ret = 0;
@@ -704,22 +630,13 @@ int tts_get_max_text_size(tts_h tts, unsigned int* size)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == size) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == size, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Get max text count : Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        if (0 != tts_config_mgr_get_max_text_size(size)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
@@ -737,16 +654,10 @@ int tts_get_state(tts_h tts, tts_state_e* state)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == state, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Get state : Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
        switch (current_state) {
@@ -769,16 +680,10 @@ int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == min || NULL == normal || NULL == max) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == min || NULL == normal || NULL == max, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        *min = TTS_SPEED_MIN;
        *normal = TTS_SPEED_NORMAL;
@@ -793,16 +698,10 @@ int tts_get_error_message(tts_h tts, char** err_msg)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == err_msg) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == err_msg, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        const char* error_message = tts_client_get_error_message(client);
        if (NULL != error_message) {
@@ -823,16 +722,10 @@ int tts_check_screen_reader_on(tts_h tts, bool* is_on)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == is_on) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == is_on, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        if (false == tts_core_check_screen_reader(client)) {
                SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is not available");
@@ -853,47 +746,19 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 
        SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
 
-       if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
-       if (voice_type < 0) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == utt_id) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == text || false == tts_core_is_valid_text(text)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text is invalid");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed, TTS_ERROR_INVALID_PARAMETER, "[ERROR] speed value(%d) is invalid.", speed);
+       RETVM_IF(voice_type < 0, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Voice type should not be negative(%d)", voice_type);
+       RETVM_IF(NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null");
+       RETVM_IF(false == tts_core_is_valid_text(text), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input text is invalid");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
-
-       if (true == client->credential_needed && NULL == client->credential) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
-               return TTS_ERROR_PERMISSION_DENIED;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
+       RETVM_IF(false == tts_core_check_credential(client), TTS_ERROR_PERMISSION_DENIED, "[ERROR] Do not have app credential for this engine");
 
        int ret = tts_core_add_text(client, text, language, voice_type, speed, utt_id);
        if (TTS_ERROR_NONE != ret) {
@@ -911,10 +776,7 @@ static void __tts_play_async(void *data)
        tts_h tts = (tts_h)data;
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        int ret = tts_core_play(client);
        if (0 != ret) {
@@ -933,29 +795,16 @@ int tts_play_async(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play asynchronously tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
-               return TTS_ERROR_INVALID_STATE;
-       }
-
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (true == client->credential_needed && NULL == client->credential) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
-               return TTS_ERROR_PERMISSION_DENIED;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
+       RETVM_IF(false == tts_core_check_credential(client), TTS_ERROR_PERMISSION_DENIED, "[ERROR] Do not have app credential for this engine");
 
        ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
 
@@ -972,28 +821,14 @@ int tts_play(tts_h tts)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
 
-       // Check handle
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
-
-       if (true == client->credential_needed && NULL == client->credential) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
-               return TTS_ERROR_PERMISSION_DENIED;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
+       RETVM_IF(false == tts_core_check_credential(client), TTS_ERROR_PERMISSION_DENIED, "[ERROR] Do not have app credential for this engine");
 
        int ret = tts_core_play(client);
        if (TTS_ERROR_NONE != ret) {
@@ -1011,10 +846,7 @@ static void __tts_stop_async(void *data)
        tts_h tts = (tts_h)data;
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        int ret = tts_core_stop(client);
        if (0 != ret) {
@@ -1033,24 +865,15 @@ int tts_stop_aync(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop asynchronously tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
 
@@ -1068,21 +891,12 @@ int tts_stop(tts_h tts)
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        int ret = tts_core_stop(client);
        if (TTS_ERROR_NONE != ret) {
@@ -1100,10 +914,7 @@ static void __tts_pause_async(void *data)
        tts_h tts = (tts_h)data;
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        int ret = tts_core_pause(client);
        if (0 != ret) {
@@ -1122,24 +933,15 @@ int tts_pause_async(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause asynchronously tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_PLAYING != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_PLAYING != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
 
@@ -1156,21 +958,12 @@ int tts_pause(tts_h tts)
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_PLAYING != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_PLAYING != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        int ret = tts_core_pause(client);
        if (TTS_ERROR_NONE != ret) {
@@ -1190,22 +983,13 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
 
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == key || NULL == data, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Invalid parameter");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
@@ -1230,22 +1014,13 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
 
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == key || NULL == data, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Invalid parameter");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        int ret = tts_core_get_private_data(client, key, data);
        if (TTS_ERROR_NONE != ret) {
@@ -1264,21 +1039,12 @@ int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* use
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set state changed cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_state_changed_cb(client, callback, user_data);
 
@@ -1293,16 +1059,10 @@ int tts_unset_state_changed_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_state_changed_cb(client, NULL, NULL);
 
@@ -1317,21 +1077,12 @@ int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, v
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set utt started cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_utterance_started_cb(client, callback, user_data);
 
@@ -1347,16 +1098,10 @@ int tts_unset_utterance_started_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_utterance_started_cb(client, NULL, NULL);
 
@@ -1372,21 +1117,12 @@ int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callbac
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set utt completed cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_utterance_completed_cb(client, callback, user_data);
 
@@ -1402,16 +1138,10 @@ int tts_unset_utterance_completed_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_utterance_completed_cb(client, NULL, NULL);
 
@@ -1426,21 +1156,12 @@ int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set error cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_error_cb(client, callback, user_data);
 
@@ -1456,16 +1177,10 @@ int tts_unset_error_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_error_cb(client, NULL, NULL);
 
@@ -1481,21 +1196,12 @@ int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb cal
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set default voice changed cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_default_voice_changed_cb(client, callback, user_data);
 
@@ -1511,16 +1217,10 @@ int tts_unset_default_voice_changed_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_default_voice_changed_cb(client, NULL, NULL);
 
@@ -1536,21 +1236,12 @@ int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* u
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set engine changed cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_engine_changed_cb(client, callback, user_data);
 
@@ -1566,16 +1257,10 @@ int tts_unset_engine_changed_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_engine_changed_cb(client, NULL, NULL);
 
@@ -1591,21 +1276,12 @@ int tts_set_screen_reader_changed_cb(tts_h tts, tts_screen_reader_changed_cb cal
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
-       if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set screen reader changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Set screen reader changed cb : Input parameter is null");
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set screen reader changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_screen_reader_changed_cb(client, callback, user_data);
 
@@ -1621,16 +1297,10 @@ int tts_unset_screen_reader_changed_cb(tts_h tts)
        }
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset screen reader changed cb : Current state is not 'Created'.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
        tts_client_set_screen_reader_changed_cb(client, NULL, NULL);
 
@@ -1650,21 +1320,12 @@ int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size,
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        int ret = tts_core_add_pcm(client, event, data, data_size, audio_type, rate);
        if (TTS_ERROR_NONE != ret) {
@@ -1685,21 +1346,12 @@ int tts_play_pcm(tts_h tts)
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_PLAYING == current_state || TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        int ret = tts_core_play_pcm(client);
        if (TTS_ERROR_NONE != ret) {
@@ -1720,21 +1372,12 @@ int tts_stop_pcm(tts_h tts)
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_CREATED == current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_CREATED == current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        int ret = tts_core_stop_pcm(client);
        if (TTS_ERROR_NONE != ret) {
@@ -1755,27 +1398,15 @@ int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
 
-       if (NULL == text_repeat || NULL == utt_id) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == text_repeat || NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Input parameter is null.");
 
        tts_client_s* client = tts_client_get(tts);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid. tts(%p)", tts);
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
 
        tts_state_e current_state = tts_client_get_current_state(client);
-       if (TTS_STATE_READY != current_state) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", current_state);
-               return TTS_ERROR_INVALID_STATE;
-       }
+       RETVM_IF(TTS_STATE_READY != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
 
-       if (false == tts_core_check_screen_reader(client)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
-               return TTS_ERROR_SCREEN_READER_OFF;
-       }
+       RETVM_IF(false == tts_core_check_screen_reader(client), TTS_ERROR_SCREEN_READER_OFF, "[ERROR] Screen reader option is not available");
 
        if (true == client->credential_needed && NULL == client->credential) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");

diff --git a/client/tts_core.c b/client/tts_core.c
index d7864f6de9584423601abfb170e7f25f66fbbc91..019212eed2f059cee55f11703cb3c1c237fe475a 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -942,6 +942,21 @@ bool tts_core_check_screen_reader(tts_client_s* client)
        return true;
 }
 
+bool tts_core_check_credential(tts_client_s* client)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] client is not valid");
+               return false;
+       }
+
+       if (true == client->credential_needed && NULL == tts_client_get_credential_key(client)) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
+               return false;
+       }
+
+       return true;
+}
+
 const char* tts_core_covert_error_code(tts_error_e err)
 {
        switch (err) {

diff --git a/client/tts_core.h b/client/tts_core.h
index c2e6beb1163deebf2c91c5c5544758bf7b4cae30..41a7616ae59650d1e5bb0d596c092a6eea3dabc4 100644 (file)
--- a/client/tts_core.h
+++ b/client/tts_core.h
@@ -32,6 +32,7 @@ int tts_core_notify_screen_reader_changed(tts_client_s* client, bool value);
 
 bool tts_core_is_valid_text(const char* text);
 bool tts_core_check_screen_reader(tts_client_s* client);
+bool tts_core_check_credential(tts_client_s* client);
 
 const char* tts_core_covert_error_code(tts_error_e err);
 

diff --git a/client/tts_dlog.h b/client/tts_dlog.h
new file mode 100644 (file)
index 0000000..d17818e
--- /dev/null
+++ b/client/tts_dlog.h
@@ -0,0 +1,69 @@
+/*
+*  Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
+*  Licensed under the Apache License, Version 2.0 (the "License");
+*  you may not use this file except in compliance with the License.
+*  You may obtain a copy of the License at
+*  http://www.apache.org/licenses/LICENSE-2.0
+*  Unless required by applicable law or agreed to in writing, software
+*  distributed under the License is distributed on an "AS IS" BASIS,
+*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*  See the License for the specific language governing permissions and
+*  limitations under the License.
+*/
+
+#ifndef __TTS_DLOG_H__
+#define __TTS_DLOG_H__
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "ttsc"
+
+#define COLOR_RED       "\033[0;31m"
+#define COLOR_GREEN     "\033[0;32m"
+#define COLOR_BROWN     "\033[0;33m"
+#define COLOR_BLUE      "\033[0;34m"
+#define COLOR_PURPLE    "\033[0;35m"
+#define COLOR_CYAN      "\033[0;36m"
+#define COLOR_LIGHTBLUE "\033[0;37m"
+#define COLOR_END       "\033[0;m"
+
+#define PLOG(fmt, args...) LOGD(fmt, ##args)
+#define PINFO(fmt, args...) LOGI(COLOR_PURPLE fmt COLOR_END, ##args)
+#define PWARNING(fmt, args...) LOGW(COLOR_BLUE fmt COLOR_END, ##args)
+#define PERR(fmt, args...) LOGE(COLOR_RED fmt COLOR_END, ##args)
+#define PENTER() LOGD(COLOR_GREEN "BEGIN >>>>" COLOR_END)
+#define PLEAVE() LOGD(COLOR_GREEN "END <<<<" COLOR_END)
+
+#define RET_IF(expr) \
+do { \
+       if (expr) \
+               return; \
+} while (0)
+
+#define RETV_IF(expr, val) \
+do { \
+       if (expr) \
+               return (val); \
+} while (0)
+
+#define RETM_IF(expr, fmt, arg...) \
+do { \
+       if (expr) { \
+               PERR(fmt, ##arg); \
+               return; \
+       } \
+} while (0)
+
+#define RETVM_IF(expr, val, fmt, arg...) \
+do { \
+       if (expr) { \
+               PERR(fmt, ##arg); \
+               return (val); \
+       } \
+} while (0)
+
+#endif /* __TTS_DLOG_H__ */

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 409eb52ac4602a1997302edea397f3e7f5ab4eb6..40247cbafb977725e83e6893a37bc762378005d3 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -17,6 +17,7 @@
 #include "tts_internal.h"
 #include "tts_client.h"
 #include "tts_core.h"
+#include "tts_dlog.h"
 
 #define MAXSLEEP 128
 #define MAX_CONNECT_CHECK 100
@@ -63,8 +64,7 @@ static void __notify_cb(void *user_data, int pid, int uid, bundle *msg)
        char *method = NULL;
        char *val = NULL;
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client)
-               return;
+       RETM_IF(NULL == client, "[ERROR] Fail to get client");
 
        unsigned int u_uid = (unsigned int)uid;
        SLOG(LOG_DEBUG, TAG_TTSC, "__notify_cb is invoked pid(%d) uid(%u)", pid, u_uid);
@@ -82,10 +82,7 @@ static void __notify_cb(void *user_data, int pid, int uid, bundle *msg)
                        tts_core_receive_hello(u_uid, atoi(ret), atoi(credential_needed));
 
                        tts_tidl_info_s* info = __get_tidl_info_s(u_uid);
-                       if (NULL == info) {
-                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-                               return;
-                       }
+                       RETM_IF(NULL == info, "[ERROR] Fail to get tidl info");
                        info->register_callback_invoked = false;
                } else {
                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get message(TTSD_METHOD_HELLO). pid(%d) uid(%u)", pid, u_uid);
@@ -126,16 +123,10 @@ static void __on_connected(rpc_port_proxy_tts_h h, void *user_data)
        unsigned int uid = (uintptr_t)user_data;
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return;
-       }
+       RETM_IF(NULL == info, "[ERROR] Fail to get tidl info");
 
        info->connected = true;
        info->connection_requesting = false;
@@ -149,16 +140,10 @@ static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
        unsigned int uid = (uintptr_t)user_data;
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return;
-       }
+       RETM_IF(NULL == info, "[ERROR] Fail to get tidl info");
 
        info->connected = false;
        info->connection_requesting = false;
@@ -175,16 +160,10 @@ static void __on_rejected(rpc_port_proxy_tts_h h, void *user_data)
 {
        unsigned int uid = (uintptr_t)user_data;
        tts_client_s *client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return;
-       }
+       RETM_IF(NULL == client, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return;
-       }
+       RETM_IF(NULL == info, "[ERROR] Fail to get tidl info");
        info->connection_requesting = false;
        info->register_callback_invoked = false;
 
@@ -193,10 +172,7 @@ static void __on_rejected(rpc_port_proxy_tts_h h, void *user_data)
 
 static void __get_engine_app_id(int size, char* app_id)
 {
-       if (NULL == app_id) {
-               SLOG(LOG_ERROR, TAG_TTSC, "app_id is NULL");
-               return;
-       }
+       RETM_IF(NULL == app_id, "app_id is NULL");
 
        char* engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
        if (NULL == engine_name) {
@@ -233,10 +209,7 @@ int tts_tidl_open_connection(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_open_connection");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[TIDL ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = (tts_tidl_info_s*)calloc(1, sizeof(tts_tidl_info_s));
        if (NULL == info) {
@@ -267,16 +240,10 @@ int tts_tidl_close_connection(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_close_connection");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
        if (0 != rpc_port_proxy_tts_destroy(info->rpc_h)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to disconnect");
@@ -297,10 +264,7 @@ int tts_tidl_close_connection(unsigned int uid)
 
 int tts_tidl_stop_listening(unsigned int uid)
 {
-       if (false == tts_client_is_valid_uid(uid)) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not valid");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(false == tts_client_is_valid_uid(uid), TTS_ERROR_INVALID_PARAMETER, "[ERROR] uid is not valid");
 
        tts_client_set_start_listening(uid, false);
 
@@ -364,16 +328,10 @@ int tts_tidl_request_hello(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
        char engine_app_id[TTS_ENGINE_APPID_LEN] = {0, };
        __get_engine_app_id(TTS_ENGINE_APPID_LEN, engine_app_id);
@@ -453,16 +411,10 @@ int tts_tidl_request_hello_sync(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
        if (!info->connected) {
                SLOG(LOG_WARN, TAG_TTSC, "[WARNNING] Stub is not Connected. Try to connect..");
@@ -499,24 +451,14 @@ int tts_tidl_request_initialize(unsigned int uid, bool* credential_needed)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
-       bool temp;
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
+       bool temp;
        int ret = rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, &temp);
        if (RPC_PORT_ERROR_NONE != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
@@ -535,21 +477,13 @@ int tts_tidl_request_finalize(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_finalize");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+               RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
+
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
 
        int ret = rpc_port_proxy_tts_invoke_finalize(info->rpc_h, uid);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -566,26 +500,15 @@ int tts_tidl_request_add_text(unsigned int uid, const char* text, const char* la
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_text");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (NULL == text || NULL == lang) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == text || NULL == lang, TTS_ERROR_INVALID_PARAMETER, "Input parameter is NULL");
+
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
 
        const char *not_null_credential = NULL == credential ? "NULL" : credential;
        int ret = rpc_port_proxy_tts_invoke_add_text(info->rpc_h, uid, text, lang, vctype, speed, uttid, not_null_credential);
@@ -602,26 +525,15 @@ int tts_tidl_request_set_private_data(unsigned int uid, const char* key, const c
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_private_data");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == key || NULL == data, TTS_ERROR_INVALID_PARAMETER, "Input parameter is NULL");
+
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
 
        int ret = rpc_port_proxy_tts_invoke_set_private(info->rpc_h, uid, key, data);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -637,29 +549,17 @@ int tts_tidl_request_get_private_data(unsigned int uid, const char* key, char**
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_get_private_data");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       char *tmp = NULL;
+       RETVM_IF(NULL == key || NULL == data, TTS_ERROR_INVALID_PARAMETER, "Input parameter is NULL");
 
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
 
+       char *tmp = NULL;
        int ret = rpc_port_proxy_tts_invoke_get_private(info->rpc_h, uid, key, &tmp);
        if (RPC_PORT_ERROR_NONE != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request get private data : Fail to invoke message");
@@ -678,21 +578,12 @@ int tts_tidl_request_play(unsigned int uid, const char* credential)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        const char *not_null_credential = NULL == credential ? "NULL" : credential;
        int ret = rpc_port_proxy_tts_invoke_play(info->rpc_h, uid, not_null_credential);
@@ -711,21 +602,12 @@ int tts_tidl_request_stop(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        int ret = rpc_port_proxy_tts_invoke_stop(info->rpc_h, uid);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -742,21 +624,12 @@ int tts_tidl_request_pause(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_pause");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        int ret = rpc_port_proxy_tts_invoke_pause(info->rpc_h, uid);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -775,21 +648,12 @@ int tts_tidl_request_play_pcm(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        int ret = rpc_port_proxy_tts_invoke_play_pcm(info->rpc_h, uid);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -807,21 +671,12 @@ int tts_tidl_request_stop_pcm(unsigned int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        int ret = rpc_port_proxy_tts_invoke_stop_pcm(info->rpc_h, uid);
        if (RPC_PORT_ERROR_NONE != ret) {
@@ -839,21 +694,12 @@ int tts_tidl_request_add_pcm(unsigned int uid, int event, const char* data, int
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        rpc_port_proxy_array_char_h pcm_data = NULL;
        rpc_port_proxy_array_char_create(&pcm_data);
@@ -886,21 +732,12 @@ int tts_tidl_request_set_mode(unsigned int uid, tts_mode_e mode)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_mode");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
 
        tts_tidl_info_s* info = __get_tidl_info_s(uid);
-       if (NULL == info) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == info, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get tidl info");
 
-       if (!info->connected) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
-               return TTS_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        int ret = rpc_port_proxy_tts_invoke_set_mode(info->rpc_h, uid, mode);
        if (RPC_PORT_ERROR_NONE != ret) {