Make functions to access callbacks and handle of the client

To access safely to member of tts_client_s, this patch define new functions.
Theses functions provides the access of the member of tts_client_s.

And if there is requirement of thread safety, we will easily implement it, only
fixing these functions.

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

diff --git a/client/tts.c b/client/tts.c
index 5126607..95429d7 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -310,7 +310,7 @@ int tts_create(tts_h* tts)
                return __tts_convert_config_error_code(ret);
        }
 
-       ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL, client->tts);
+       ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, NULL, tts);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
                tts_client_destroy(*tts);
@@ -416,7 +416,7 @@ int tts_destroy(tts_h tts)
                        }
                }
 
-               if (client->tts->connected) {
+               if (tts->connected) {
                        if (1 == tts_client_get_size()) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[INFO] all clients are destroied");
                                if (0 != tts_ipc_close_connection(client->uid)) {

diff --git a/client/tts_client.c b/client/tts_client.c
index 8b1d16e..9900a79 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -297,6 +297,15 @@ bool tts_client_is_valid(int uid)
        return true;
 }
 
+tts_h tts_client_get_handle(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+
+       return client->tts;
+}
+
 int tts_client_get_size()
 {
        pthread_mutex_lock(&g_client_list_mutex);
@@ -455,6 +464,118 @@ void tts_client_set_supported_voice_cb(tts_client_s* client, tts_supported_voice
        __set_supported_voice_cb(client, callback, user_data);
 }
 
+tts_state_changed_cb tts_client_get_state_changed_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->state_changed_cb;
+}
+
+void* tts_client_get_state_changed_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->state_changed_user_data;
+}
+
+tts_utterance_started_cb tts_client_get_utterance_started_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->utt_started_cb;
+}
+
+void* tts_client_get_utterance_started_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->utt_started_user_data;
+}
+
+tts_utterance_completed_cb tts_client_get_utterance_completed_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->utt_completed_cb;
+}
+
+void* tts_client_get_utterance_completed_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->utt_completed_user_data;
+}
+
+tts_error_cb tts_client_get_error_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->error_cb;
+}
+
+void* tts_client_get_error_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->error_user_data;
+}
+
+tts_default_voice_changed_cb tts_client_get_default_voice_changed_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->default_voice_changed_cb;
+}
+
+void* tts_client_get_default_voice_changed_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->default_voice_changed_user_data;
+}
+
+tts_engine_changed_cb tts_client_get_engine_changed_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->engine_changed_cb;
+}
+
+void* tts_client_get_engine_changed_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->engine_changed_user_data;
+}
+
+tts_supported_voice_cb tts_client_get_supported_voice_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->supported_voice_cb;
+}
+
+void* tts_client_get_supported_voice_user_data(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->uid)) {
+               return NULL;
+       }
+       return client->supported_voice_user_data;
+}
+
 void tts_client_unset_all_cb(tts_client_s* client)
 {
        if (NULL == client || false == tts_client_is_valid(client->uid)) {

diff --git a/client/tts_client.h b/client/tts_client.h
index bd3e8e5..f4920b3 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -80,19 +80,17 @@ typedef struct {
 } tts_client_s;
 
 int tts_client_new(tts_h* tts);
-
 int tts_client_destroy(tts_h tts);
 
 tts_client_s* tts_client_get(tts_h tts);
-
 tts_client_s* tts_client_get_by_uid(const int uid);
+tts_h tts_client_get_handle(tts_client_s* client);
 
 bool tts_client_is_valid(int uid);
 
 int tts_client_get_size();
 
 int tts_client_use_callback(tts_client_s* client);
-
 int tts_client_not_use_callback(tts_client_s* client);
 
 int tts_client_get_use_callback(tts_client_s* client);
@@ -111,6 +109,27 @@ void tts_client_set_default_voice_changed_cb(tts_client_s* client, tts_default_v
 void tts_client_set_engine_changed_cb(tts_client_s* client, tts_engine_changed_cb callback, void* user_data);
 void tts_client_set_supported_voice_cb(tts_client_s* client, tts_supported_voice_cb callback, void* user_data);
 
+tts_state_changed_cb tts_client_get_state_changed_cb(tts_client_s* client);
+void* tts_client_get_state_changed_user_data(tts_client_s* client);
+
+tts_utterance_started_cb tts_client_get_utterance_started_cb(tts_client_s* client);
+void* tts_client_get_utterance_started_user_data(tts_client_s* client);
+
+tts_utterance_completed_cb tts_client_get_utterance_completed_cb(tts_client_s* client);
+void* tts_client_get_utterance_completed_user_data(tts_client_s* client);
+
+tts_error_cb tts_client_get_error_cb(tts_client_s* client);
+void* tts_client_get_error_user_data(tts_client_s* client);
+
+tts_default_voice_changed_cb tts_client_get_default_voice_changed_cb(tts_client_s* client);
+void* tts_client_get_default_voice_changed_user_data(tts_client_s* client);
+
+tts_engine_changed_cb tts_client_get_engine_changed_cb(tts_client_s* client);
+void* tts_client_get_engine_changed_user_data(tts_client_s* client);
+
+tts_supported_voice_cb tts_client_get_supported_voice_cb(tts_client_s* client);
+void* tts_client_get_supported_voice_user_data(tts_client_s* client);
+
 void tts_client_unset_all_cb(tts_client_s* client);
 
 #ifdef __cplusplus

diff --git a/client/tts_core.c b/client/tts_core.c
index 3f6a1e2..27c17ce 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -102,10 +102,13 @@ static int __update_engine_name()
 
 static inline void __client_error_cb(tts_client_s* client, int utt_id, tts_error_e reason)
 {
-       if (NULL != client->error_cb) {
+       tts_error_cb callback = tts_client_get_error_cb(client);
+       void* data = tts_client_get_error_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify error");
                tts_client_use_callback(client);
-               client->error_cb(client->tts, utt_id, reason, client->error_user_data);
+               callback(tts_client_get_handle(client), utt_id, reason, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(error)");
@@ -114,10 +117,13 @@ static inline void __client_error_cb(tts_client_s* client, int utt_id, tts_error
 
 static inline void __client_state_changed_cb(tts_client_s* client, tts_state_e before_state, tts_state_e current_state)
 {
-       if (NULL != client->state_changed_cb) {
+       tts_state_changed_cb callback = tts_client_get_state_changed_cb(client);
+       void* data = tts_client_get_state_changed_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify state changed");
                tts_client_use_callback(client);
-               client->state_changed_cb(client->tts, before_state, current_state, client->state_changed_user_data);
+               callback(tts_client_get_handle(client), before_state, current_state, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(state_changed)");
@@ -130,7 +136,7 @@ static Eina_Bool __notify_error_timer_cb(void *data)
        tts_client_s* client = tts_client_get_by_uid(uid);
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid.");
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%d)", uid);
        } else {
                __client_error_cb(client, client->utt_id, client->reason);
                client->notify_error_timer = NULL;
@@ -145,7 +151,7 @@ static Eina_Bool __notify_state_timer_cb(void *data)
        tts_client_s* client = tts_client_get_by_uid(uid);
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid.");
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%d)", uid);
        } else {
                __client_state_changed_cb(client, client->before_state, client->current_state);
                client->notify_state_timer = NULL;
@@ -418,7 +424,7 @@ static int __send_hello_msg(tts_client_s* client)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", client->tts, client, client->uid);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, client->uid);
 
        /* check service engine status */
        bool is_launched = __is_engine_launched(client->mode);
@@ -638,15 +644,11 @@ int tts_core_notify_state_changed_async(tts_client_s* client, tts_state_e before
        client->before_state = before_state;
        client->current_state = current_state;
 
-       if (NULL != client->state_changed_cb) {
-               SLOG(LOG_DEBUG, TAG_TTSC, "Notify state changed asynchronously");
-               if (NULL != client->notify_state_timer) {
-                       ecore_timer_del(client->notify_state_timer);
-               }
-               client->notify_state_timer = ecore_timer_add(0, __notify_state_timer_cb, (void*)client->uid);
-       } else {
-               SLOG(LOG_WARN, TAG_TTSC, "No registered callback(state changed)");
+       SLOG(LOG_DEBUG, TAG_TTSC, "Notify state changed asynchronously");
+       if (NULL != client->notify_state_timer) {
+               ecore_timer_del(client->notify_state_timer);
        }
+       client->notify_state_timer = ecore_timer_add(0, __notify_state_timer_cb, (void*)client->uid);
 
        return TTS_ERROR_NONE;
 }
@@ -661,10 +663,13 @@ int tts_core_notify_utt_started(tts_client_s* client, int utt_id)
 
        SLOG(LOG_DEBUG, TAG_TTSC, "Utterance started data : utt_id(%d)", client->utt_id);
 
-       if (NULL != client->utt_started_cb) {
+       tts_utterance_started_cb callback = tts_client_get_utterance_started_cb(client);
+       void* data = tts_client_get_utterance_started_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
                tts_client_use_callback(client);
-               client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
+               callback(tts_client_get_handle(client), client->utt_id, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_started)");
@@ -683,10 +688,13 @@ int tts_core_notify_utt_completeted(tts_client_s* client, int utt_id)
 
        SLOG(LOG_DEBUG, TAG_TTSC, "Utterance completed data : utt_id(%d)", utt_id);
 
-       if (NULL != client->utt_completed_cb) {
+       tts_utterance_completed_cb callback = tts_client_get_utterance_completed_cb(client);
+       void* data = tts_client_get_utterance_completed_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
                tts_client_use_callback(client);
-               client->utt_completed_cb(client->tts, utt_id, client->utt_completed_user_data);
+               callback(tts_client_get_handle(client), utt_id, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_completed)");
@@ -721,15 +729,11 @@ int tts_core_notify_error_async(tts_client_s* client, int utt_id, tts_error_e re
        client->utt_id = utt_id;
        client->reason = reason;
 
-       if (NULL != client->error_cb) {
-               SLOG(LOG_DEBUG, TAG_TTSC, "Notify error asynchronously");
-               if (NULL != client->notify_error_timer) {
-                       ecore_timer_del(client->notify_error_timer);
-               }
-               client->notify_error_timer = ecore_timer_add(0, __notify_error_timer_cb, (void*)client->uid);
-       } else {
-               SLOG(LOG_WARN, TAG_TTSC, "No registered callback(error)");
+       SLOG(LOG_DEBUG, TAG_TTSC, "Notify error asynchronously");
+       if (NULL != client->notify_error_timer) {
+               ecore_timer_del(client->notify_error_timer);
        }
+       client->notify_error_timer = ecore_timer_add(0, __notify_error_timer_cb, (void*)client->uid);
 
        return TTS_ERROR_NONE;
 }
@@ -750,10 +754,13 @@ int tts_core_notify_default_voice_changed(tts_client_s* client, const char* befo
        SLOG(LOG_DEBUG, TAG_TTSC, "Default voice changed data : before_lang(%s), before_voice_type(%d), language(%s), voice_type(%d)",
                        before_lang, before_voice_type, language, voice_type);
 
-       if (NULL != client->default_voice_changed_cb) {
+       tts_default_voice_changed_cb callback = tts_client_get_default_voice_changed_cb(client);
+       void* data = tts_client_get_default_voice_changed_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify default voice changed");
                tts_client_use_callback(client);
-               client->default_voice_changed_cb(client->tts, before_lang, before_voice_type, language, voice_type, client->default_voice_changed_user_data);
+               callback(tts_client_get_handle(client), before_lang, before_voice_type, language, voice_type, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(default_voice_changed)");
@@ -778,10 +785,13 @@ int tts_core_notify_engine_changed(tts_client_s* client, const char* engine_id,
        SLOG(LOG_DEBUG, TAG_TTSC, "Engine changed data : engine_id(%s) language(%s), voicd_type(%d), need_credential(%d)",
                        engine_id, language, voice_type, need_credential);
 
-       if (NULL != client->engine_changed_cb) {
+       tts_engine_changed_cb callback = tts_client_get_engine_changed_cb(client);
+       void* data = tts_client_get_engine_changed_user_data(client);
+
+       if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify engine changed");
                tts_client_use_callback(client);
-               client->engine_changed_cb(client->tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
+               callback(tts_client_get_handle(client), engine_id, language, voice_type, need_credential, data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(engine_changed)");
@@ -808,7 +818,7 @@ int tts_core_notify_supported_voice(tts_client_s* client, const char* language,
        if (NULL != client->supported_voice_cb) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify supported voice");
                tts_client_use_callback(client);
-               client->supported_voice_cb(client->tts, language, voice_type, client->supported_voice_user_data);
+               client->supported_voice_cb(tts_client_get_handle(client), language, voice_type, client->supported_voice_user_data);
                tts_client_not_use_callback(client);
        } else {
                SLOG(LOG_WARN, TAG_TTSC, "No registered callback(supported_voice)");
@@ -870,7 +880,7 @@ int tts_core_prepare(tts_client_s* client)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", client->tts, client, client->uid);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, client->uid);
        if (NULL == client->hello_timer) {
                SLOG(LOG_ERROR, TAG_TTSC, "Register timer for __prepare_first_cb");
 
@@ -892,7 +902,7 @@ int tts_core_prepare_sync(tts_client_s* client)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", client->tts, client, client->uid);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, client->uid);
        int cnt = 0;
        while (EINA_TRUE == __prepare_sync_cb(client) && TTS_CONNECTION_RETRY_COUNT > cnt) {
                cnt++;
@@ -916,7 +926,7 @@ int tts_core_unprepare(tts_client_s* client, bool is_screen_reader_on)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", client->tts, client, client->uid);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, client->uid);
        if (client->hello_timer) {
                ecore_timer_del(client->hello_timer);
                client->hello_timer = NULL;
@@ -967,9 +977,11 @@ int tts_core_unprepare(tts_client_s* client, bool is_screen_reader_on)
                } while (0 != ret);
        }
 
+       // TODO: make function like tts_core_set_state()
        client->before_state = client->current_state;
        client->current_state = TTS_STATE_CREATED;
        __client_state_changed_cb(client, client->before_state, client->current_state);
+       // TODO: make function like tts_core_set_state()
 
        return TTS_ERROR_NONE;
 }

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 73e4e1b..8b855e2 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -208,13 +208,20 @@ static void __on_connected(rpc_port_proxy_tts_h h, void *user_data)
 {
        int uid = (int)user_data;
 
-       tts_client_s *client = tts_client_get_by_uid(uid);
-       if (!client)
+       tts_client_s* client = tts_client_get_by_uid(uid);
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
                return;
+       }
 
-       client->tts->connected = TRUE;
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return;
+       }
 
-       if (0 != rpc_port_proxy_tts_invoke_set_mode(client->tts->rpc_h, client->mode)) {
+       tts->connected = TRUE;
+       if (0 != rpc_port_proxy_tts_invoke_set_mode(tts->rpc_h, client->mode)) {
                SLOG(LOG_ERROR, TAG_TTSC, "Failed to set mode");
                return;
        }
@@ -226,11 +233,19 @@ static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
 {
        int uid = (int)user_data;
 
-       tts_client_s *client = tts_client_get_by_uid(uid);
-       if (!client)
+       tts_client_s* client = tts_client_get_by_uid(uid);
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
                return;
+       }
 
-       client->tts->connected = FALSE;
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return;
+       }
+
+       tts->connected = FALSE;
        __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
        SLOG(LOG_DEBUG, TAG_TTSC, "Disconnected from server");
 
@@ -264,9 +279,15 @@ int tts_tidl_open_connection(int uid)
        };
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
@@ -292,20 +313,20 @@ int tts_tidl_open_connection(int uid)
        }
 
 
-       if (0 != rpc_port_proxy_tts_create(engine_mode, &rpc_callback, (void*)uid, &client->tts->rpc_h)) {
+       if (0 != rpc_port_proxy_tts_create(engine_mode, &rpc_callback, (void*)uid, &tts->rpc_h)) {
                free(engine_name);
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create proxy");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_connect(client->tts->rpc_h)) {
-               rpc_port_proxy_tts_destroy(client->tts->rpc_h);
-               client->tts->rpc_h = NULL;
+       if (0 != rpc_port_proxy_tts_connect(tts->rpc_h)) {
+               rpc_port_proxy_tts_destroy(tts->rpc_h);
+               tts->rpc_h = NULL;
                free(engine_name);
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect the service");
                return TTS_ERROR_OPERATION_FAILED;
        }
-       SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p) rpc_h(%p) engine(%s)", client->tts, client->tts->rpc_h, engine_mode);
+       SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p) rpc_h(%p) engine(%s)", tts, tts->rpc_h, engine_mode);
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        free(engine_name);
 
@@ -317,16 +338,23 @@ int tts_tidl_close_connection(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_close_connection");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (0 != rpc_port_proxy_tts_destroy(client->tts->rpc_h)) {
+       if (0 != rpc_port_proxy_tts_destroy(tts->rpc_h)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to disconnect");
                return TTS_ERROR_OPERATION_FAILED;
        }
-       client->tts->rpc_h = NULL;
+
+       tts->rpc_h = NULL;
        return TTS_ERROR_NONE;
 }
 
@@ -335,14 +363,20 @@ int tts_tidl_request_hello(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        rpc_port_tts_notify_cb_h cb;
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -350,13 +384,13 @@ int tts_tidl_request_hello(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
        /* register callback - needed to create new client before adding callback */
        cb = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
-       if (0 != rpc_port_proxy_tts_invoke_register_cb(client->tts->rpc_h, client->pid, client->uid, cb)) {
+       if (0 != rpc_port_proxy_tts_invoke_register_cb(tts->rpc_h, client->pid, client->uid, cb)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Failed to invoke register");
                return TTS_ERROR_OPERATION_FAILED;
        }
        SLOG(LOG_DEBUG, TAG_TTSC, "TTS Register callback");
 
-       if (0 != rpc_port_proxy_tts_invoke_request_hello(client->tts->rpc_h, client->pid, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_request_hello(tts->rpc_h, client->pid, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>> Request tts hello : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -376,19 +410,25 @@ int tts_tidl_request_initialize(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 (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        bool temp;
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_initialize(client->tts->rpc_h, client->uid, client->pid, &temp)) {
+       if (0 != rpc_port_proxy_tts_invoke_initialize(tts->rpc_h, client->uid, client->pid, &temp)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -405,17 +445,23 @@ int tts_tidl_request_finalize(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_finalize");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_finalize(client->tts->rpc_h, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_finalize(tts->rpc_h, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -428,9 +474,15 @@ int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int v
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_text");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        if (NULL == text || NULL == lang) {
@@ -438,12 +490,12 @@ int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int v
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_add_text(client->tts->rpc_h, client->uid, text, lang, vctype, speed, uttid, credential)) {
+       if (0 != rpc_port_proxy_tts_invoke_add_text(tts->rpc_h, client->uid, text, lang, vctype, speed, uttid, credential)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request add text : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -456,9 +508,15 @@ int tts_tidl_request_set_private_data(int uid, const char* key, const char* data
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_private_data");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        if (NULL == key || NULL == data) {
@@ -466,12 +524,12 @@ int tts_tidl_request_set_private_data(int uid, const char* key, const char* data
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_set_private(client->tts->rpc_h, client->uid, key, data)) {
+       if (0 != rpc_port_proxy_tts_invoke_set_private(tts->rpc_h, client->uid, key, data)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request set private data : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -484,9 +542,15 @@ int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_get_private_data");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
        char *tmp = NULL;
@@ -496,12 +560,12 @@ int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_get_private(client->tts->rpc_h, client->uid, key, &tmp)) {
+       if (0 != rpc_port_proxy_tts_invoke_get_private(tts->rpc_h, client->uid, key, &tmp)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request get private data : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -517,17 +581,23 @@ int tts_tidl_request_play(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 (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_play(client->tts->rpc_h, client->uid, credential)) {
+       if (0 != rpc_port_proxy_tts_invoke_play(tts->rpc_h, client->uid, credential)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -542,17 +612,23 @@ int tts_tidl_request_stop(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_stop(client->tts->rpc_h, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_stop(tts->rpc_h, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request stop : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -566,17 +642,23 @@ int tts_tidl_request_pause(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_pause");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_pause(client->tts->rpc_h, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_pause(tts->rpc_h, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -592,17 +674,23 @@ int tts_tidl_request_play_pcm(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_play_pcm(client->tts->rpc_h, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_play_pcm(tts->rpc_h, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -617,17 +705,23 @@ int tts_tidl_request_stop_pcm(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_stop_pcm(client->tts->rpc_h, client->uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_stop_pcm(tts->rpc_h, client->uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -642,17 +736,23 @@ int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_pcm");
 
        tts_client_s* client = tts_client_get_by_uid(uid);
-       if (!client) {
-               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get tts_client with uid");
-               return TTS_ERROR_OPERATION_FAILED;
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_h tts = tts_client_get_handle(client);
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!client->tts->connected) {
+       if (!tts->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_add_pcm(client->tts->rpc_h, client->uid, event, data, data_size, audio_type, rate)) {
+       if (0 != rpc_port_proxy_tts_invoke_add_pcm(tts->rpc_h, client->uid, event, data, data_size, audio_type, rate)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }