Store current service state from engine library

- Requirement:
Client library needs to get current service state when preparing is
succeeded.

- Contents:
This patch makes client library store the service state in client
structure when preparing is succeeded. If the client listen the service
state changed event, client has to maintain the current service state
even if the service is out. To do this, each client structure has to
store the current service state.
Through this patch, client structure can maintain the latest service
state at preparing success.

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

diff --git a/client/tts_client.c b/client/tts_client.c
index 551041fa01fd08759bf921b44c83e090186d2a89..2ff75a1df7e47bfe7866fcafdbbe350e301ca989 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -174,6 +174,7 @@ int tts_client_new(tts_h* tts)
        client->tts = temp;
        client->pid = getpid();
        client->uid = temp->handle;
+       client->current_service_state = TTS_SERVICE_STATE_NONE;
 
        pthread_mutex_lock(&g_client_list_mutex);
        g_client_list = g_list_append(g_client_list, client);
@@ -423,6 +424,24 @@ tts_state_e tts_client_get_current_state(tts_client_s* client)
        return client->current_state;
 }
 
+void tts_client_set_current_service_state(tts_client_s* client, tts_service_state_e service_state)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return;
+       }
+
+       client->current_service_state = service_state;
+}
+
+tts_service_state_e tts_client_get_current_service_state(tts_client_s* client)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return TTS_SERVICE_STATE_NONE;
+       }
+
+       return client->current_service_state;
+}
+
 void tts_client_set_start_listening(unsigned int uid, bool is_listening_started)
 {
        tts_client_s* client = tts_client_get_by_uid(uid);

diff --git a/client/tts_client.h b/client/tts_client.h
index 4faebc065f1ca5086ead85d151488a6de8d4b58f..c9a150cf88b91fb1f013f74571c181a088f2b281 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -63,6 +63,7 @@ typedef struct {
        tts_mode_e      mode;
        tts_state_e     before_state;
        tts_state_e     current_state;
+       tts_service_state_e current_service_state;
 
        /* semaphore */
        int             cb_ref_count;
@@ -116,6 +117,9 @@ unsigned int tts_client_get_uid(tts_client_s* client);
 void tts_client_set_current_state(tts_client_s* client, tts_state_e state);
 tts_state_e tts_client_get_current_state(tts_client_s* client);
 
+void tts_client_set_current_service_state(tts_client_s* client, tts_service_state_e service_state);
+tts_service_state_e tts_client_get_current_service_state(tts_client_s* client);
+
 void tts_client_set_start_listening(unsigned int uid, bool is_listening_started);
 bool tts_client_is_listening_started(unsigned int uid);
 

diff --git a/client/tts_core.c b/client/tts_core.c
index 7828d334bdfe9c955a081aef3e95264fa5586b7a..cc6fc0b0adb225cdbb6fc6e584e3c86859ccaec4 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -502,7 +502,7 @@ static Eina_Bool __prepare_first_cb(void *data)
        return EINA_FALSE;
 }
 
-static int __prepare_sync_cb(tts_client_s* client)
+static int __prepare_sync_cb(tts_client_s* client, tts_service_state_e* service_state)
 {
        // TODO: make function duplicated block
        bool is_launched = __is_engine_launched();
@@ -529,10 +529,10 @@ static int __prepare_sync_cb(tts_client_s* client)
        // TODO: make function duplicated block
        /* do request initialize */
        bool credential_needed = false;
-       tts_service_state_e service_state = TTS_SERVICE_STATE_READY;
+       tts_service_state_e tmp_service_state = TTS_SERVICE_STATE_NONE;
        tts_mode_e mode = tts_client_get_mode(client);
        int registered_callback_mask = tts_client_get_registered_event_mask(client);
-       int ret = tts_ipc_request_initialize(uid, mode, registered_callback_mask, &service_state, &credential_needed);
+       int ret = tts_ipc_request_initialize(uid, mode, registered_callback_mask, &tmp_service_state, &credential_needed);
        if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == 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);
@@ -548,6 +548,7 @@ static int __prepare_sync_cb(tts_client_s* client)
        }
        // TODO: make function duplicated block
 
+       *service_state = tmp_service_state;
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        return TTS_ERROR_NONE;
 }
@@ -894,6 +895,8 @@ int tts_core_notify_service_state_changed(tts_client_s* client, tts_service_stat
 
        if (NULL != callback) {
                SLOG(LOG_DEBUG, TAG_TTSC, "Notify service state changed");
+               tts_client_set_current_service_state(client, current_state);
+
                tts_client_use_callback(client);
                callback(tts_client_get_handle(client), before_state, current_state, data);
                tts_client_not_use_callback(client);
@@ -997,7 +1000,7 @@ const char* tts_core_covert_error_code(tts_error_e err)
 }
 //LCOV_EXCL_STOP
 
-int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed)
+int tts_core_receive_hello(unsigned int uid, int ret, tts_service_state_e service_state, int credential_needed)
 {
        tts_client_s* client = tts_client_get_by_uid(uid);
        RETVM_IF(NULL == client, TTS_ERROR_OPERATION_FAILED, "Fail to get TTS client or ignore this uid(%u)", uid);
@@ -1028,6 +1031,9 @@ int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed)
 
        tts_core_notify_state_changed(client, TTS_STATE_READY);
 
+       tts_service_state_e before_state = tts_client_get_current_service_state(client);
+       tts_core_notify_service_state_changed(client, before_state, service_state);
+
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        return TTS_ERROR_NONE;
 }
@@ -1061,6 +1067,7 @@ int tts_core_prepare_sync(tts_client_s* client)
        RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 
        unsigned int uid = tts_client_get_uid(client);
+       tts_service_state_e service_state = TTS_SERVICE_STATE_NONE;
        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) {
@@ -1069,7 +1076,7 @@ int tts_core_prepare_sync(tts_client_s* client)
                        return TTS_ERROR_SCREEN_READER_OFF;
                }
 
-               int ret = __prepare_sync_cb(client);
+               int ret = __prepare_sync_cb(client, &service_state);
                if (TTS_ERROR_NONE == ret) {
                        SLOG(LOG_INFO, TAG_TTSC, "[INFO] Prepare succeeds. uid(%u)", uid);
                        break;
@@ -1092,6 +1099,9 @@ int tts_core_prepare_sync(tts_client_s* client)
 
        tts_core_notify_state_changed(client, TTS_STATE_READY);
 
+       tts_service_state_e before_state = tts_client_get_current_service_state(client);
+       tts_core_notify_service_state_changed(client, before_state, service_state);
+
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        return TTS_ERROR_NONE;
 }

diff --git a/client/tts_core.h b/client/tts_core.h
index 75632e81929fcd01ef007715f59a76dcfa01dde4..1b6d25ff7ba0d3d035ac7ebcf29647e6eb2a5594 100644 (file)
--- a/client/tts_core.h
+++ b/client/tts_core.h
@@ -64,7 +64,7 @@ int tts_core_get_private_data(tts_client_s* client, const char* key, char** data
 
 int tts_core_get_service_state(tts_client_s* client, tts_service_state_e* service_state);
 
-int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed);
+int tts_core_receive_hello(unsigned int uid, int ret, tts_service_state_e service_state, int credential_needed);
 int tts_core_handle_service_reset();
 
 #ifdef __cplusplus

diff --git a/client/tts_dbus.c b/client/tts_dbus.c
index 56c1b2e82e99e58d550c023ff002d7099c5d9797..c2f29ea26491f9a9f2d19cb0c29e2b171dcc5ea7 100644 (file)
--- a/client/tts_dbus.c
+++ b/client/tts_dbus.c
@@ -134,7 +134,7 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle
                                } else {
                                        __tts_dbus_add_match(uid);
                                }
-                               tts_core_receive_hello(uid, ret, credential_needed);
+                               tts_core_receive_hello(uid, ret, (tts_service_state_e)service_state, credential_needed);
                        }
 
                        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index e3e0b362673d8e550366b15ad48a16cd1539dd3f..9110133943db344448571d0586aa1bd74c374602 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -89,7 +89,7 @@ static void __notify_cb(void *user_data, int pid, int uid, bundle *msg)
 
                if (NULL != credential_needed && NULL != ret) {
                        tts_client_set_start_listening(u_uid, true);
-                       tts_core_receive_hello(u_uid, atoi(ret), atoi(credential_needed));
+                       tts_core_receive_hello(u_uid, atoi(ret), (tts_service_state_e)atoi(service_state), atoi(credential_needed));
 
                        tts_tidl_info_s* info = __get_tidl_info_s(u_uid);
                        RETM_IF(NULL == info, "[ERROR] Fail to get tidl info");

diff --git a/include/tts.h b/include/tts.h
index 985d63870a2f370ec6ee2249c26148adfc493339..089e5146d5006cf9b25e2964046b53914381c833 100644 (file)
--- a/include/tts.h
+++ b/include/tts.h
@@ -90,9 +90,11 @@ typedef enum {
  * @since_tizen 7.0
 */
 typedef enum {
+       TTS_SERVICE_STATE_NONE = -1, /**< 'None' state */
        TTS_SERVICE_STATE_READY = 0, /**< 'Ready' state */
        TTS_SERVICE_STATE_SYNTHESIZING, /**< 'Synthesizing' state */
-       TTS_SERVICE_STATE_PLAYING /**< 'Playing' state */
+       TTS_SERVICE_STATE_PLAYING, /**< 'Playing' state */
+       TTS_SERVICE_STATE_BLOCKED /**< 'Blocked' state */
 } tts_service_state_e;