Clean up ttse_terminate(), tts_prepare_sync() function

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

diff --git a/client/tts.c b/client/tts.c
index f818946b9e7ecff5cd7f06a9e717a7bb0c864382..bd641f044130cc5155ae494de9f7fdb7b3de7dc5 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -614,7 +614,7 @@ int tts_prepare_sync(tts_h tts)
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS synchronously");
        int ret = tts_core_prepare_sync(client);
-       if (0 != ret) {
+       if (TTS_ERROR_NONE != ret) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] tts_core_prepare_sync failed. (%s)", tts_core_covert_error_code(ret));
                return ret;
        }

diff --git a/client/tts_core.c b/client/tts_core.c
index 0fed71bc8b24abafc7dcc6dc58111dc6b627316a..300589d4eb9a57d386e111d78abf903f5182424e 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -22,6 +22,10 @@
 #include "tts_core.h"
 #include "tts_ipc.h"
 
+
+static const int TTS_ERROR_FAIL_TO_SEND_HELLO = TIZEN_ERROR_TTS | 0xFF;
+
+
 /* Static variables */
 static volatile bool g_is_thread_canceled = false;
 
@@ -511,7 +515,7 @@ static Eina_Bool __prepare_first_cb(void *data)
        return EINA_FALSE;
 }
 
-static Eina_Bool __prepare_sync_cb(tts_client_s* client)
+static int __prepare_sync_cb(tts_client_s* client)
 {
        // TODO: make function duplicated block
        bool is_launched = __is_engine_launched(tts_client_get_mode(client));
@@ -520,33 +524,33 @@ static Eina_Bool __prepare_sync_cb(tts_client_s* client)
        if (false == is_launched) {
                /* check whether engine is updating or not */
                if (g_engine_update_status) {
-                       SLOG(LOG_ERROR, TAG_TTSC, "[DEBUG] cannot prepare due to engine update");
+                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot prepare due to engine update.");
+                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client automatically tries to reprepare asynchrnously.");
                        __run_client_reprepare_thread();
-                       return EINA_FALSE;
+                       return TTS_ERROR_OPERATION_FAILED;
                }
        }
+
        // TODO: make function duplicated block
        unsigned int uid = tts_client_get_uid(client);
-       if (0 != tts_ipc_request_hello_sync(uid)) {
-               return EINA_TRUE;
+       if (TTS_ERROR_NONE != tts_ipc_request_hello_sync(uid)) {
+               return TTS_ERROR_FAIL_TO_SEND_HELLO;
        }
 
        SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 
        // TODO: make function duplicated block
        /* do request initialize */
-       int ret = -1;
        bool credential_needed = false;
-
-       ret = tts_ipc_request_initialize(uid, &credential_needed);
+       int ret = tts_ipc_request_initialize(uid, &credential_needed);
        if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == ret) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", tts_core_covert_error_code(ret));
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize. ret(%d/%s)", ret, get_error_message(ret));
                tts_core_notify_error_async(client, ret, -1, NULL);
 
-               return EINA_FALSE;
+               return ret;
        } else if (TTS_ERROR_NONE != ret) {
-               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", tts_core_covert_error_code(ret));
-               return EINA_TRUE;
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect. ret(%d/%s)", ret, get_error_message(ret));
+               return TTS_ERROR_FAIL_TO_SEND_HELLO;
        } else {
                /* success to connect tts-daemon */
                client->credential_needed = credential_needed;
@@ -554,12 +558,8 @@ static Eina_Bool __prepare_sync_cb(tts_client_s* client)
        }
        // TODO: make function duplicated block
 
-       tts_ipc_request_set_mode(uid, tts_client_get_mode(client));
-
-       tts_core_notify_state_changed(client, TTS_STATE_READY);
-
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
-       return EINA_FALSE;
+       return TTS_ERROR_NONE;
 }
 
 static void __engine_changed_cb(keynode_t* key, void* data)
@@ -1093,7 +1093,8 @@ int tts_core_prepare_sync(tts_client_s* client)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare_sync. tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, tts_client_get_uid(client));
+       unsigned int uid = tts_client_get_uid(client);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare_sync. tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
        int cnt = 0;
        while (TTS_CONNECTION_RETRY_COUNT > cnt) {
                if (false == tts_core_check_screen_reader(client)) {
@@ -1101,10 +1102,19 @@ int tts_core_prepare_sync(tts_client_s* client)
                        return TTS_ERROR_SCREEN_READER_OFF;
                }
 
-               if (EINA_FALSE == __prepare_sync_cb(client)) {
+               int ret = __prepare_sync_cb(client);
+               if (TTS_ERROR_NONE == ret) {
+                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Prepare succeeds. uid(%u)", uid);
                        break;
                }
 
+               if (TTS_ERROR_FAIL_TO_SEND_HELLO == ret) {
+                       SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Fail to send hello. Try again. uid(%u)", uid);
+               } else {
+                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare. uid(%u), ret(%d/%s)", uid, ret, get_error_message(ret));
+                       return ret;
+               }
+
                cnt++;
        }
 
@@ -1113,6 +1123,9 @@ int tts_core_prepare_sync(tts_client_s* client)
                return TTS_ERROR_OPERATION_FAILED;
        }
 
+       tts_ipc_request_set_mode(uid, tts_client_get_mode(client));
+       tts_core_notify_state_changed(client, TTS_STATE_READY);
+
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        return TTS_ERROR_NONE;
 }

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 57c0fa07a5a443cc2b933c5461fc9605041a2487..fbd408b7831f0fbd3f760caa248a56a720ef14b2 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -459,11 +459,16 @@ static int __invoke_register_callback_sync(int pid, tts_tidl_info_s* info)
        int ret = RPC_PORT_ERROR_NONE;
        ret = __create_notify_callback_handle(info);
        if (RPC_PORT_ERROR_NONE != ret) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create callback handle. ret(%d)", ret);
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create callback handle. ret(%d/%s)", ret, get_error_message(ret));
+               return TTS_ERROR_OPERATION_FAILED;
+       }
+
+       ret = rpc_port_proxy_tts_invoke_register_cb_sync(info->rpc_h, pid, info->uid, info->notify_cb_h);
+       if (RPC_PORT_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to register callback. ret(%d/%s)", ret, get_error_message(ret));
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       rpc_port_proxy_tts_invoke_register_cb_sync(info->rpc_h, pid, info->uid, info->notify_cb_h);
        info->register_callback_invoked = true;
        return TTS_ERROR_NONE;
 }

diff --git a/server/ttsd_server.c b/server/ttsd_server.c
index 04d9a70ce30c4abda2c438a05eff0dfd4198a034..ff52a0a32eb1ea1a4a74a3dd35689fecc80bbf5d 100644 (file)
--- a/server/ttsd_server.c
+++ b/server/ttsd_server.c
@@ -50,7 +50,6 @@ typedef struct {
 
 static Ecore_Timer* g_check_client_timer = NULL;
 static Ecore_Timer* g_wait_timer = NULL;
-static Ecore_Timer* g_terminate_timer = NULL;
 static Ecore_Timer* g_quit_loop_timer = NULL;
 
 static utterance_t g_utt;
@@ -414,57 +413,47 @@ bool __terminate_client(int pid, unsigned int uid, app_tts_state_e state, void*
        return true;
 }
 
-static void __terminate_server()
+static int __terminate_server()
 {
        if (g_is_terminated) {
                SLOG(LOG_INFO, tts_tag(), "[INFO] ttsd_terminate() is already invoked.");
-               return;
+               return TTSD_ERROR_NONE;
        }
 
-       g_is_terminated = true;
+       int ret = TTSD_ERROR_NONE;
+       ret = ttsd_ipc_close_connection();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_ipc_close_connection(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
 
-       ttsd_ipc_close_connection();
-       ttsd_network_finalize();
-       ttsd_finalize();
-}
+       ret = ttsd_network_finalize();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_ipc_close_connection(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
 
-static Eina_Bool __quit_ecore_loop(void *data)
-{
-       __terminate_server();
-       ecore_main_loop_quit();
+       ret = ttsd_finalize();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_ipc_close_connection(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
 
-       return EINA_FALSE;
+       g_is_terminated = true;
+       return TTSD_ERROR_NONE;
 }
 
-Eina_Bool ttsd_terminate_daemon(void *data)
+static Eina_Bool __quit_ecore_loop(void *data)
 {
-       ttsd_data_foreach_clients(__terminate_client, NULL);
-
-       if (g_quit_loop_timer) {
-               ecore_timer_del(g_quit_loop_timer);
-               g_quit_loop_timer = NULL;
-               SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore quit loop timer handle");
-       }
-
        __terminate_server();
+       ecore_main_loop_quit();
 
-       g_terminate_timer = NULL;
        return EINA_FALSE;
 }
 
 void __screen_reader_changed_cb(bool value)
 {
-/*     if (TTSD_MODE_SCREEN_READER == ttsd_get_mode() && false == value) {
-               SLOG(LOG_INFO, tts_tag(), "[Server] Screen reader is OFF. Start to terminate tts daemon");
-               if (g_terminate_timer) {
-                       ecore_timer_del(g_terminate_timer);
-                       g_terminate_timer = NULL;
-               }
-               g_terminate_timer = ecore_timer_add(1, ttsd_terminate_daemon, NULL);
-       } else {
-*/
-               SLOG(LOG_DEBUG, tts_tag(), "[Server] Screen reader is %s", value ? "ON" : "OFF");
-//     }
+       SLOG(LOG_DEBUG, tts_tag(), "[Server] Screen reader is %s", value ? "ON" : "OFF");
        return;
 }
 
@@ -556,25 +545,12 @@ int ttsd_finalize()
                }
        }
 
-       ttsd_config_finalize();
-
-       ttsd_player_release();
-
-       ttsd_engine_agent_release();
-
-
        if (g_wait_timer) {
                ecore_timer_del(g_wait_timer);
                g_wait_timer = NULL;
                SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore waiting timer handle");
        }
 
-       if (g_terminate_timer) {
-               ecore_timer_del(g_terminate_timer);
-               g_terminate_timer = NULL;
-               SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore terminating timer handle");
-       }
-
        if (g_check_client_timer) {
                ecore_timer_del(g_check_client_timer);
                g_check_client_timer = NULL;
@@ -587,16 +563,44 @@ int ttsd_finalize()
                SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore quit loop timer handle");
        }
 
+       int ret = TTSD_ERROR_NONE;
+       ret = ttsd_config_finalize();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_config_finalize(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
+
+       ret = ttsd_player_release();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_player_release(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
+
+       ret = ttsd_engine_agent_release();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_engine_agent_release(). ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
+
        return TTSD_ERROR_NONE;
 }
 
 int ttsd_terminate()
 {
        SLOG(LOG_INFO, tts_tag(), "[Server] Terminate");
+       int ret = ttsd_data_foreach_clients(__terminate_client, NULL);
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to terminate all clients. ret(%d)", ret);
+               return TTSD_ERROR_OPERATION_FAILED;
+       }
 
-       ttsd_terminate_daemon(NULL);
+       if (g_quit_loop_timer) {
+               ecore_timer_del(g_quit_loop_timer);
+               g_quit_loop_timer = NULL;
+               SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore quit loop timer handle");
+       }
 
-       return TTSD_ERROR_NONE;
+       return __terminate_server();
 }
 
 /*

diff --git a/server/ttse.c b/server/ttse.c
index 4c96c30bc306993228320085a102767672ce61c6..b0b73e15b897a8b6446902725909fa3d2d6b370a 100755 (executable)
--- a/server/ttse.c
+++ b/server/ttse.c
@@ -235,12 +235,16 @@ int ttse_terminate()
                return TTSE_ERROR_NONE;
        }
 
-       g_is_terminated = true;
-       ttsd_terminate();
+       int ret = ttsd_terminate();
+       if (TTSD_ERROR_NONE != ret) {
+               SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to ttsd_terminate(). ret(%d)", ret);
+               return TTSE_ERROR_OPERATION_FAILED;
+       }
 
        /* Unregister vconfkey callback */
        vconf_ignore_key_changed(TTS_ENGINE_DB_DEFAULT, __engine_changed_cb);
 
+       g_is_terminated = true;
        return TTSE_ERROR_NONE;
 }