Refactor set/unset client callback logic

To avoid direct access of tts_client_s on tts.c, this patch creates the new function on tts_client.c.

These new functions provides safer access of tts_client_s.

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

diff --git a/client/tts.c b/client/tts.c
index 4515d16..5126607 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -243,20 +243,6 @@ void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, c
 }
 //LCOV_EXCL_STOP
 
-void __tts_unset_all_callbacks(tts_h tts)
-{
-       SLOG(LOG_INFO, TAG_TTSC, "@@@ unset all callbacks");
-
-       tts_unset_state_changed_cb(tts);
-       tts_unset_utterance_started_cb(tts);
-       tts_unset_utterance_completed_cb(tts);
-       tts_unset_error_cb(tts);
-       tts_unset_default_voice_changed_cb(tts);
-       tts_unset_engine_changed_cb(tts);
-
-       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
-}
-
 int tts_create(tts_h* tts)
 {
        if (0 != __tts_get_feature_enabled()) {
@@ -375,6 +361,7 @@ int tts_destroy(tts_h tts)
 
        tts_config_mgr_finalize(client->uid);
 
+       // TODO: move into tts_client
        if (client->hello_timer) {
                ecore_timer_del(client->hello_timer);
                client->hello_timer = NULL;
@@ -388,6 +375,7 @@ int tts_destroy(tts_h tts)
        case TTS_STATE_PAUSED:
        case TTS_STATE_PLAYING:
        case TTS_STATE_READY:
+               // TODO: fix to core_unprepare
                ret = __tts_recheck_screen_reader();
                if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get screen reader(%d)", ret);
@@ -443,7 +431,7 @@ int tts_destroy(tts_h tts)
 
        case TTS_STATE_CREATED:
                /* Unset registered callbacks */
-               __tts_unset_all_callbacks(tts);
+               tts_client_unset_all_cb(client);
 
                int thread_count = ecore_thread_active_get();
                SLOG(LOG_INFO, TAG_TTSC, "[INFO] Active thread count: %d", thread_count);
@@ -458,17 +446,6 @@ int tts_destroy(tts_h tts)
                        thread_count = ecore_thread_active_get();
                }
 
-               /* Delete state timer before destroying handle */
-               if (NULL != client->notify_state_timer) {
-                       ecore_timer_del(client->notify_state_timer);
-                       client->notify_state_timer = NULL;
-               }
-               /* Delete error timer before destroying handle */
-               if (NULL != client->notify_error_timer) {
-                       ecore_timer_del(client->notify_error_timer);
-                       client->notify_error_timer = NULL;
-               }
-
                /* Free resources */
                tts_client_destroy(tts);
 
@@ -866,18 +843,15 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
                return __tts_convert_config_error_code(ret);
        }
 
-       client->supported_voice_cb = callback;
-       client->supported_voice_user_data = user_data;
+       tts_client_set_supported_voice_cb(client, callback, user_data);
        ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client);
+       tts_client_set_supported_voice_cb(client, NULL, NULL);
 
        if (NULL != current_engine) {
                free(current_engine);
                current_engine = NULL;
        }
 
-       client->supported_voice_cb = NULL;
-       client->supported_voice_user_data = NULL;
-
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
                ret = TTS_ERROR_OPERATION_FAILED;
@@ -1944,28 +1918,26 @@ int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* use
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->state_changed_cb = callback;
-       client->state_changed_user_data = user_data;
+       tts_client_set_state_changed_cb(client, callback, user_data);
 
        SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
-
        return 0;
 }
 
@@ -1975,13 +1947,8 @@ int tts_unset_state_changed_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -1992,16 +1959,9 @@ int tts_unset_state_changed_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->state_changed_cb = NULL;
-       client->state_changed_user_data = NULL;
-
-       if (NULL != client->notify_state_timer) {
-               ecore_timer_del(client->notify_state_timer);
-               client->notify_state_timer = NULL;
-       }
+       tts_client_set_state_changed_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
-
        return 0;
 }
 
@@ -2011,25 +1971,24 @@ int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, v
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->utt_started_cb = callback;
-       client->utt_started_user_data = user_data;
+       tts_client_set_utterance_started_cb(client, callback, user_data);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
 
@@ -2042,13 +2001,8 @@ int tts_unset_utterance_started_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -2059,8 +2013,7 @@ int tts_unset_utterance_started_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->utt_started_cb = NULL;
-       client->utt_started_user_data = NULL;
+       tts_client_set_utterance_started_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
 
@@ -2073,25 +2026,24 @@ int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callbac
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->utt_completed_cb = callback;
-       client->utt_completed_user_data = user_data;
+       tts_client_set_utterance_completed_cb(client, callback, user_data);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
 
@@ -2104,13 +2056,8 @@ int tts_unset_utterance_completed_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -2121,8 +2068,7 @@ int tts_unset_utterance_completed_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->utt_completed_cb = NULL;
-       client->utt_completed_user_data = NULL;
+       tts_client_set_utterance_completed_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
        return 0;
@@ -2134,25 +2080,24 @@ int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->error_cb = callback;
-       client->error_user_data = user_data;
+       tts_client_set_error_cb(client, callback, user_data);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
 
@@ -2165,13 +2110,8 @@ int tts_unset_error_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -2182,13 +2122,7 @@ int tts_unset_error_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->error_cb = NULL;
-       client->error_user_data = NULL;
-
-       if (NULL != client->notify_error_timer) {
-               ecore_timer_del(client->notify_error_timer);
-               client->notify_error_timer = NULL;
-       }
+       tts_client_set_error_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
 
@@ -2201,25 +2135,24 @@ int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb cal
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->default_voice_changed_cb = callback;
-       client->default_voice_changed_user_data = user_data;
+       tts_client_set_default_voice_changed_cb(client, callback, user_data);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
 
@@ -2232,13 +2165,8 @@ int tts_unset_default_voice_changed_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -2249,8 +2177,7 @@ int tts_unset_default_voice_changed_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->default_voice_changed_cb = NULL;
-       client->default_voice_changed_user_data = NULL;
+       tts_client_set_default_voice_changed_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
 
@@ -2263,25 +2190,24 @@ int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* u
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts || NULL == callback) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
+       if (NULL == callback) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
        if (TTS_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->engine_changed_cb = callback;
-       client->engine_changed_user_data = user_data;
+       tts_client_set_engine_changed_cb(client, callback, user_data);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
 
@@ -2294,13 +2220,8 @@ int tts_unset_engine_changed_cb(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
-               return TTS_ERROR_INVALID_PARAMETER;
-       }
-
+       /* check handle */
        tts_client_s* client = tts_client_get(tts);
-
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -2311,8 +2232,7 @@ int tts_unset_engine_changed_cb(tts_h tts)
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->engine_changed_cb = NULL;
-       client->engine_changed_user_data = NULL;
+       tts_client_set_engine_changed_cb(client, NULL, NULL);
 
        SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
 

diff --git a/client/tts_client.c b/client/tts_client.c
index d83c6b5..caec6fc 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -44,6 +44,48 @@ static int __client_generate_uid(int pid)
        return uid;
 }
 
+static inline void __set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
+{
+       client->state_changed_cb = callback;
+       client->state_changed_user_data = user_data;
+}
+
+static inline void __set_utterance_started_cb(tts_client_s* client, tts_utterance_started_cb callback, void* user_data)
+{
+       client->utt_started_cb = callback;
+       client->utt_started_user_data = user_data;
+}
+
+static inline void __set_utterance_completed_cb(tts_client_s* client, tts_utterance_completed_cb callback, void* user_data)
+{
+       client->utt_completed_cb = callback;
+       client->utt_completed_user_data = user_data;
+}
+
+static inline void __set_error_cb(tts_client_s* client, tts_error_cb callback, void* user_data)
+{
+       client->error_cb = callback;
+       client->error_user_data = user_data;
+}
+
+static inline void __set_default_voice_changed_cb(tts_client_s* client, tts_default_voice_changed_cb callback, void* user_data)
+{
+       client->default_voice_changed_cb = callback;
+       client->default_voice_changed_user_data = user_data;
+}
+
+static inline void __set_engine_changed_cb(tts_client_s* client, tts_engine_changed_cb callback, void* user_data)
+{
+       client->engine_changed_cb = callback;
+       client->engine_changed_user_data = user_data;
+}
+
+static inline void __set_supported_voice_cb(tts_client_s* client, tts_supported_voice_cb callback, void* user_data)
+{
+       client->supported_voice_cb = callback;
+       client->supported_voice_user_data = user_data;
+}
+
 int tts_client_new(tts_h* tts)
 {
        tts_client_s* client = NULL;
@@ -342,3 +384,98 @@ GList* tts_client_get_client_list()
        return copy_list;
 }
 //LCOV_EXCL_STOP
+
+void tts_client_set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+
+       if (NULL == callback) {
+               if (NULL != client->notify_state_timer) {
+                       ecore_timer_del(client->notify_state_timer);
+                       client->notify_state_timer = NULL;
+               }
+       }
+       __set_state_changed_cb(client, callback, user_data);
+}
+
+void tts_client_set_utterance_started_cb(tts_client_s* client, tts_utterance_started_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+       __set_utterance_started_cb(client, callback, user_data);
+}
+
+void tts_client_set_utterance_completed_cb(tts_client_s* client, tts_utterance_completed_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+       __set_utterance_completed_cb(client, callback, user_data);
+}
+
+void tts_client_set_error_cb(tts_client_s* client, tts_error_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+
+       if (NULL == callback) {
+               if (NULL != client->notify_error_timer) {
+                       ecore_timer_del(client->notify_error_timer);
+                       client->notify_error_timer = NULL;
+               }
+       }
+       __set_error_cb(client, callback, user_data);
+}
+
+void tts_client_set_default_voice_changed_cb(tts_client_s* client, tts_default_voice_changed_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+       __set_default_voice_changed_cb(client, callback, user_data);
+}
+
+void tts_client_set_engine_changed_cb(tts_client_s* client, tts_engine_changed_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+       __set_engine_changed_cb(client, callback, user_data);
+}
+
+void tts_client_set_supported_voice_cb(tts_client_s* client, tts_supported_voice_cb callback, void* user_data)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+       __set_supported_voice_cb(client, callback, user_data);
+}
+
+void tts_client_unset_all_cb(tts_client_s* client)
+{
+       if (NULL == client || false == tts_client_is_valid(client->tts)) {
+               return;
+       }
+
+       if (NULL != client->notify_state_timer) {
+               ecore_timer_del(client->notify_state_timer);
+               client->notify_state_timer = NULL;
+       }
+
+       if (NULL != client->notify_error_timer) {
+               ecore_timer_del(client->notify_error_timer);
+               client->notify_error_timer = NULL;
+       }
+
+       __set_state_changed_cb(client, NULL, NULL);
+       __set_utterance_started_cb(client, NULL, NULL);
+       __set_utterance_completed_cb(client, NULL, NULL);
+       __set_error_cb(client, NULL, NULL);
+       __set_default_voice_changed_cb(client, NULL, NULL);
+       __set_engine_changed_cb(client, NULL, NULL);
+       __set_supported_voice_cb(client, NULL, NULL);
+}
\ No newline at end of file

diff --git a/client/tts_client.h b/client/tts_client.h
index 88a541e..4bb82ed 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -103,6 +103,16 @@ int tts_client_get_mode_client_count(tts_mode_e mode);
 
 GList* tts_client_get_client_list();
 
+void tts_client_set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data);
+void tts_client_set_utterance_started_cb(tts_client_s* client, tts_utterance_started_cb callback, void* user_data);
+void tts_client_set_utterance_completed_cb(tts_client_s* client, tts_utterance_completed_cb callback, void* user_data);
+void tts_client_set_error_cb(tts_client_s* client, tts_error_cb callback, void* user_data);
+void tts_client_set_default_voice_changed_cb(tts_client_s* client, tts_default_voice_changed_cb callback, void* user_data);
+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);
+
+void tts_client_unset_all_cb(tts_client_s* client);
+
 #ifdef __cplusplus
 }
 #endif