Divide __tts_cb_error() into two seperate function

__tts_cb_err() is used for two different purpose, so this function has high complexity.

This patch divides __tts_cb_error() into two functions __handle_service_reset() and
 __handle_service_error().
These two function has lower complexity and clear purpose to use.
Thus, it is expected that new developer can easily understand the purpose and behavior of each
function.

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

diff --git a/client/tts.c b/client/tts.c
index 510026d80831278acd491e4fdb62bc5c34ab7cb5..28b143f8b4e17c2ceba42b0e5d3839411f5110c8 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -940,16 +940,16 @@ int tts_get_error_message(tts_h tts, char** err_msg)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (NULL != client->err_msg) {
-               *err_msg = strdup(client->err_msg);
-               SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
+       const char* error_message = tts_client_get_error_message(client);
+       if (NULL != error_message) {
+               *err_msg = strdup(error_message);
+               SLOG(LOG_DEBUG, TAG_TTSC, "Error msg (%s)", error_message);
        } else {
                *err_msg = NULL;
-               SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
+               SLOG(LOG_DEBUG, TAG_TTSC, "Error msg (NULL)");
        }
 
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
-
        return TTS_ERROR_NONE;
 }
 

diff --git a/client/tts_client.c b/client/tts_client.c
index 9fbbabede2b824480567754a28e7edac737e43d4..46fb13e1aaaab2602af4639bbc687c917170d763 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -417,6 +417,31 @@ bool tts_client_is_listening_started(int uid)
        return client->start_listening;
 }
 
+void tts_client_set_error_message(tts_client_s* client, const char* error_message)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return;
+       }
+
+       if (NULL != client->err_msg) {
+               free(client->err_msg);
+               client->err_msg = NULL;
+       }
+
+       if (NULL != error_message) {
+               client->err_msg = strdup(error_message);
+       }
+}
+
+const char* tts_client_get_error_message(tts_client_s* client)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return NULL;
+       }
+
+       return client->err_msg;
+}
+
 void tts_client_set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
 {
        if (false == tts_client_is_valid_client(client)) {

diff --git a/client/tts_client.h b/client/tts_client.h
index e9b881c76f0ae0e3901ee06b4829a6c2c066c8a0..0212ed31225605220c6c2eeb9342f415eda6c89c 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -112,6 +112,9 @@ tts_state_e tts_client_get_current_state(tts_client_s* client);
 void tts_client_set_start_listening(int uid, bool is_listening_started);
 bool tts_client_is_listening_started(int uid);
 
+void tts_client_set_error_message(tts_client_s* client, const char* error_message);
+const char* tts_client_get_error_message(tts_client_s* client);
+
 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);

diff --git a/client/tts_dbus.c b/client/tts_dbus.c
index 01b1ff316a47ceff2c3c8eb8de2ca07843924bdb..d47a8cef415e05b9e3b53d3bf51caf5e9932e5aa 100644 (file)
--- a/client/tts_dbus.c
+++ b/client/tts_dbus.c
@@ -34,69 +34,51 @@ static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
 
 static volatile int g_connected_client = 0;
 
-static int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
+static int __handle_service_reset()
 {
-       if (-1 == uid) {
-               GList* client_list = NULL;
-               client_list = tts_client_get_client_list();
+       GList* client_list = NULL;
+       client_list = tts_client_get_client_list();
 
-               if (NULL == client_list) {
-                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client list");
-                       return TTS_ERROR_OPERATION_FAILED;
-               }
-
-               GList *iter = NULL;
-               tts_client_s *data = NULL;
-
-               if (g_list_length(client_list) > 0) {
-                       /* Get a first item */
-                       iter = g_list_first(client_list);
-
-                       while (NULL != iter) {
-                               data = iter->data;
-
-                               if (NULL != data->err_msg) {
-                                       free(data->err_msg);
-                                       data->err_msg = NULL;
-                               }
-                               if (NULL != err_msg)
-                                       data->err_msg = strdup(err_msg);
-
-                               /* call callback function */
-                               tts_core_notify_error_async(data, utt_id, reason);
+       if (NULL == client_list) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client list");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
 
-                               /* Next item */
-                               iter = g_list_next(iter);
+       if (g_list_length(client_list) > 0) {
+               GList *iter = g_list_first(client_list);
+               while (NULL != iter) {
+                       tts_client_s *client = iter->data;
+                       if (false == tts_client_is_valid_client(client)) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client is not valid");
+                       } else {
+                               tts_client_set_error_message(client, "Daemon Reset");
+                               tts_core_notify_error_async(client, -1, TTS_ERROR_SERVICE_RESET);
                        }
-               }
 
-               g_list_free(client_list);
-
-               if (TTS_ERROR_SERVICE_RESET == reason) {
-                       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
-
-                       tts_core_reprepare();
+                       iter = g_list_next(iter);
                }
+       }
 
-       } else {
-               tts_client_s* client = tts_client_get_by_uid(uid);
+       g_list_free(client_list);
 
-               if (NULL == client) {
-                       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
-                       return TTS_ERROR_INVALID_PARAMETER;
-               }
+       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
+       tts_core_reprepare();
 
-               if (NULL != client->err_msg) {
-                       free(client->err_msg);
-                       client->err_msg = NULL;
-               }
-               if (NULL != err_msg)
-                       client->err_msg = strdup(err_msg);
+       return TTS_ERROR_NONE;
+}
 
-               tts_core_notify_error_async(client, utt_id, reason);
+static int __handle_service_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
+{
+       tts_client_s* client = tts_client_get_by_uid(uid);
+       if (NULL == client) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] uid is not valid");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       return 0;
+       tts_client_set_error_message(client, err_msg);
+       tts_core_notify_error_async(client, utt_id, reason);
+
+       return TTS_ERROR_NONE;
 }
 
 static int __tts_cb_set_state(int uid, int state)
@@ -333,17 +315,14 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle
                                dbus_error_free(&err);
                        } else {
                                SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%d), error(%d), uttid(%d), err_msg(%s)", uid, reason, uttid, (NULL == err_msg) ? "NULL" : err_msg);
-                               __tts_cb_error(uid, reason, uttid, err_msg);
-
+                               __handle_service_error(uid, reason, uttid, err_msg);
                        }
                } /* TTSD_SIGNAL_ERROR */
 
                else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
                        SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Owner Changed");
-
-                       __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
+                       __handle_service_reset();
                        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
-                       SLOG(LOG_DEBUG, TAG_TTSC, " ");
                } /* NameOwnerChanged */
 
                else {

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 530f5dabea410ca569c38c4ba325017c046f08eb..6051fb326a3c64268b17db98f243da57c794064f 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -19,69 +19,51 @@
 
 #define MAXSLEEP 128
 
-static int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
+static int __handle_service_reset()
 {
-       if (-1 == uid) {
-               GList* client_list = NULL;
-               client_list = tts_client_get_client_list();
+       GList* client_list = NULL;
+       client_list = tts_client_get_client_list();
 
-               if (NULL == client_list) {
-                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client list");
-                       return TTS_ERROR_OPERATION_FAILED;
-               }
-
-               GList *iter = NULL;
-               tts_client_s *data = NULL;
-
-               if (g_list_length(client_list) > 0) {
-                       /* Get a first item */
-                       iter = g_list_first(client_list);
-
-                       while (NULL != iter) {
-                               data = iter->data;
-
-                               if (NULL != data->err_msg) {
-                                       free(data->err_msg);
-                                       data->err_msg = NULL;
-                               }
-                               if (NULL != err_msg)
-                                       data->err_msg = strdup(err_msg);
-
-                               /* call callback function */
-                               tts_core_notify_error_async(data, utt_id, reason);
+       if (NULL == client_list) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client list");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
 
-                               /* Next item */
-                               iter = g_list_next(iter);
+       if (g_list_length(client_list) > 0) {
+               GList *iter = g_list_first(client_list);
+               while (NULL != iter) {
+                       tts_client_s *client = iter->data;
+                       if (false == tts_client_is_valid_client(client)) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client is not valid");
+                       } else {
+                               tts_client_set_error_message(client, "Daemon Reset");
+                               tts_core_notify_error_async(client, -1, TTS_ERROR_SERVICE_RESET);
                        }
-               }
 
-               g_list_free(client_list);
-
-               if (TTS_ERROR_SERVICE_RESET == reason) {
-                       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
-
-                       tts_core_reprepare();
+                       iter = g_list_next(iter);
                }
+       }
 
-       } else {
-               tts_client_s* client = tts_client_get_by_uid(uid);
+       g_list_free(client_list);
 
-               if (NULL == client) {
-                       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
-                       return TTS_ERROR_INVALID_PARAMETER;
-               }
+       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
+       tts_core_reprepare();
 
-               if (NULL != client->err_msg) {
-                       free(client->err_msg);
-                       client->err_msg = NULL;
-               }
-               if (NULL != err_msg)
-                       client->err_msg = strdup(err_msg);
+       return TTS_ERROR_NONE;
+}
 
-               tts_core_notify_error_async(client, utt_id, reason);
+static int __handle_service_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
+{
+       tts_client_s* client = tts_client_get_by_uid(uid);
+       if (NULL == client) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] uid is not valid");
+               return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       return 0;
+       tts_client_set_error_message(client, err_msg);
+       tts_core_notify_error_async(client, utt_id, reason);
+
+       return TTS_ERROR_NONE;
 }
 
 static int __tts_cb_set_state(int uid, int state)
@@ -197,7 +179,7 @@ static void __notify_cb(void *user_data, int pid, int uid, bundle *msg)
                bundle_get_str(msg, TTS_BUNDLE_UTTID, &uttid);
                bundle_get_str(msg, TTS_BUNDLE_ERR_MSG, &err_msg);
                if (reason && uttid) {
-                       __tts_cb_error(uid, atoi(reason), atoi(uttid), err_msg);
+                       __handle_service_error(uid, atoi(reason), atoi(uttid), err_msg);
                }
        }
        else {
@@ -248,7 +230,7 @@ static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
 
        tts->connected = false;
        if (tts_client_is_listening_started(uid)) {
-               __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
+               __handle_service_reset();
                SLOG(LOG_DEBUG, TAG_TTSC, "Disconnected from server");
 
                ecore_main_loop_thread_safe_call_async(__reconnect, (void*)uid);
@@ -259,12 +241,11 @@ static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
 static void __on_rejected(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)
                return;
 
-       __tts_cb_error(client->uid, TTS_ERROR_PERMISSION_DENIED, client->utt_id, "Rejected");
+       __handle_service_error(uid, TTS_ERROR_PERMISSION_DENIED, client->utt_id, "Rejected");
        SLOG(LOG_DEBUG, TAG_TTSC, "Rejected from server");
 }