Add callback set information into prepare interface

- Requirement:
Server wants to information about whether the client set the service
state changed callback.

- Solution:
Service state is frequently changed, so IPC for notification of service
state change is invoked so many times for all client. However, most of
the client did not register the callback, so many resource can be
wasted by this unvaluable invocation. To reduce wasted resources, this
patch adds callback registration information into IPC interface.
Through this new information server can send valid  notification without
waste.

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

diff --git a/client/tts_client.c b/client/tts_client.c
index 4f963c9db23f9dcaf0be8e3a1bf1c81ff547111e..e32045c2a0c18e834b53acfec0ab9c1ad3c7f73d 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -46,42 +46,84 @@ static unsigned int __client_generate_uid(unsigned int pid)
 
 static inline void __set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_STATE_CHANGED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_STATE_CHANGED;
+       }
+
        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)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_UTTERANCE_STARTED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_UTTERANCE_STARTED;
+       }
+
        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)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_UTTERANCE_COMPLETED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_UTTERANCE_COMPLETED;
+       }
+
        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)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_ERROR;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_ERROR;
+       }
+
        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)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_DEFAULT_VOICE_CHANGED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_DEFAULT_VOICE_CHANGED;
+       }
+
        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)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_ENGINE_CHANGED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_ENGINE_CHANGED;
+       }
+
        client->engine_changed_cb = callback;
        client->engine_changed_user_data = user_data;
 }
 
 static inline void __set_screen_reader_changed_cb(tts_client_s* client, tts_screen_reader_changed_cb callback, void* user_data)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_SCREEN_READER_CHANGED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_SCREEN_READER_CHANGED;
+       }
+
        client->screen_reader_changed_cb = callback;
        client->screen_reader_changed_user_data = user_data;
 }
@@ -94,6 +136,12 @@ static inline void __set_supported_voice_cb(tts_client_s* client, tts_supported_
 
 static inline void __set_service_state_changed_cb(tts_client_s* client, tts_service_state_changed_cb callback, void* user_data)
 {
+       if (callback != NULL) {
+               client->registered_event_mask |= TTS_EVENT_MASK_SERVICE_STATE_CHANGED;
+       } else {
+               client->registered_event_mask &= ~TTS_EVENT_MASK_SERVICE_STATE_CHANGED;
+       }
+
        client->service_state_changed_cb = callback;
        client->service_state_changed_user_data = user_data;
 }
@@ -739,6 +787,14 @@ void* tts_client_get_service_state_changed_user_data(tts_client_s* client)
        return client->service_state_changed_user_data;
 }
 
+int tts_client_get_registered_event_mask(tts_client_s* client)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return 0;
+       }
+       return client->registered_event_mask;
+}
+
 void tts_client_unset_all_cb(tts_client_s* client)
 {
        if (false == tts_client_is_valid_client(client)) {

diff --git a/client/tts_client.h b/client/tts_client.h
index bcd19f287b896d4135162545a1320975bbdf3147..dcbf6b5a8b467760f055c9820ea8d68a454cd4ee 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -54,6 +54,7 @@ typedef struct {
        void*                           supported_voice_user_data;
        tts_service_state_changed_cb            service_state_changed_cb;
        void*                           service_state_changed_user_data;
+       int registered_event_mask;
 
        /* mode / state */
        tts_mode_e      mode;
@@ -169,6 +170,8 @@ void* tts_client_get_supported_voice_user_data(tts_client_s* client);
 tts_service_state_changed_cb tts_client_get_service_state_changed_cb(tts_client_s* client);
 void* tts_client_get_service_state_changed_user_data(tts_client_s* client);
 
+int tts_client_get_registered_event_mask(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 f3b9959e1c42554bf045465bb445538bc053f7a3..ae1a3d0c586360127799b3d42217c7efd805ccb8 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -417,6 +417,7 @@ static int __send_hello_msg(tts_client_s* client)
 
        unsigned int uid = tts_client_get_uid(client);
        tts_mode_e mode = tts_client_get_mode(client);
+       int registered_callback_mask = tts_client_get_registered_event_mask(client);
        SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u), mode(%d)", tts_client_get_handle(client), client, uid, (int)mode);
 
        /* check service engine status */
@@ -432,7 +433,7 @@ static int __send_hello_msg(tts_client_s* client)
                }
        }
 
-       if (0 != tts_ipc_request_hello(uid, mode)) {
+       if (0 != tts_ipc_request_hello(uid, mode, registered_callback_mask)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
        } else {
                SLOG(LOG_INFO, TAG_TTSC, "@@@ Send Hello");
@@ -519,7 +520,8 @@ static int __prepare_sync_cb(tts_client_s* client)
        /* do request initialize */
        bool credential_needed = false;
        tts_mode_e mode = tts_client_get_mode(client);
-       int ret = tts_ipc_request_initialize(uid, mode, &credential_needed);
+       int registered_callback_mask = tts_client_get_registered_event_mask(client);
+       int ret = tts_ipc_request_initialize(uid, mode, registered_callback_mask, &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);

diff --git a/client/tts_dbus.c b/client/tts_dbus.c
index e2fa6983048a1972b085cd03580de3c2a15db841..6c3cfcb0a8829e11ffc356a15f26fd84f0c0f2c1 100644 (file)
--- a/client/tts_dbus.c
+++ b/client/tts_dbus.c
@@ -438,7 +438,7 @@ DBusMessage* __tts_dbus_make_message(unsigned int uid, const char* method)
        return msg;
 }
 
-int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode)
+int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask)
 {
        DBusError err;
        dbus_error_init(&err);
@@ -457,7 +457,12 @@ int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode)
        }
 
        int pid = getpid();
-       if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID)) {
+       if (true != dbus_message_append_args(msg,
+                       DBUS_TYPE_INT32, &pid,
+                       DBUS_TYPE_UINT32, &uid,
+                       DBUS_TYPE_INT32, &mode,
+                       DBUS_TYPE_INT32, &registered_event_mask,
+                       DBUS_TYPE_INVALID)) {
                dbus_message_unref(msg);
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 
@@ -519,7 +524,7 @@ int tts_dbus_request_hello_sync(unsigned int uid)
        return result;
 }
 
-int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed)
+int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed)
 {
        DBusMessage* msg;
        DBusError err;
@@ -535,7 +540,12 @@ int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, bool* credent
        }
 
        int pid = getpid();
-       if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID)) {
+       if (true != dbus_message_append_args(msg,
+                       DBUS_TYPE_INT32, &pid,
+                       DBUS_TYPE_UINT32, &uid,
+                       DBUS_TYPE_INT32, &mode,
+                       DBUS_TYPE_INT32, &registered_event_mask,
+                       DBUS_TYPE_INVALID)) {
                dbus_message_unref(msg);
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 

diff --git a/client/tts_dbus.h b/client/tts_dbus.h
index 70ec52a5de7e31d5c4bc8aeb3e7ce326d19310de..a0eaeb70b0bd2b1050bef5e42115bfa0d947207b 100644 (file)
--- a/client/tts_dbus.h
+++ b/client/tts_dbus.h
@@ -27,11 +27,11 @@ int tts_dbus_close_connection(unsigned int uid);
 
 int tts_dbus_stop_listening(unsigned int uid);
 
-int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode);
+int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask);
 
 int tts_dbus_request_hello_sync(unsigned int uid);
 
-int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed);
+int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed);
 
 int tts_dbus_request_finalize(unsigned int uid);
 

diff --git a/client/tts_ipc.c b/client/tts_ipc.c
index 806950e84f65f552c2e176c6752c4554d695fb2d..9b4eb3662d7640d3ea0e66b78fdc9d77befa3ab4 100644 (file)
--- a/client/tts_ipc.c
+++ b/client/tts_ipc.c
@@ -109,14 +109,14 @@ int tts_ipc_stop_listening(unsigned int uid)
        return g_vtable[STOP_LISTENING](uid);
 }
 
-int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode)
+int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask)
 {
        SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_hello");
 
        RETVM_IF(false == tts_client_is_valid_uid(uid), TTS_ERROR_INVALID_PARAMETER, "Fail to get tts_client with uid(%u)", uid);
        RETVM_IF(NULL == g_vtable, TTS_ERROR_OPERATION_FAILED, "[ERROR] IPC method is not set");
 
-       return g_vtable[REQUEST_HELLO](uid, mode);
+       return g_vtable[REQUEST_HELLO](uid, mode, registered_event_mask);
 }
 
 int tts_ipc_request_hello_sync(unsigned int uid)
@@ -129,14 +129,14 @@ int tts_ipc_request_hello_sync(unsigned int uid)
        return g_vtable[REQUEST_HELLO_SYNC](uid);
 }
 
-int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed)
+int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed)
 {
        SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_initialize");
 
        RETVM_IF(false == tts_client_is_valid_uid(uid), TTS_ERROR_INVALID_PARAMETER, "Fail to get tts_client with uid(%u)", uid);
        RETVM_IF(NULL == g_vtable, TTS_ERROR_OPERATION_FAILED, "[ERROR] IPC method is not set");
 
-       return g_vtable[REQUEST_INITIALIZE](uid, mode, credential_needed);
+       return g_vtable[REQUEST_INITIALIZE](uid, mode, registered_event_mask, credential_needed);
 }
 
 int tts_ipc_request_finalize(unsigned int uid)

diff --git a/client/tts_ipc.h b/client/tts_ipc.h
index e7591c30e5f7af05901104fe89f7dcebe525e933..34bad752077e9f56c2a8908411db0f8b4bdef28d 100644 (file)
--- a/client/tts_ipc.h
+++ b/client/tts_ipc.h
@@ -30,11 +30,11 @@ int tts_ipc_close_connection(unsigned int uid);
 
 int tts_ipc_stop_listening(unsigned int uid);
 
-int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode);
+int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask);
 
 int tts_ipc_request_hello_sync(unsigned int uid);
 
-int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed);
+int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed);
 
 int tts_ipc_request_finalize(unsigned int uid);
 

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 466ae296d875ee16e9798b2dd01aeaeb322c9353..c87914a27213c4d10cfc511ffca184aab938c36f 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -315,7 +315,7 @@ static int __create_notify_callback_handle(tts_tidl_info_s* info)
        return TTS_ERROR_NONE;
 }
 
-static int __invoke_register_callback(int pid, tts_mode_e mode, tts_tidl_info_s* info)
+static int __invoke_register_callback(int pid, tts_mode_e mode, int registered_event_mask, tts_tidl_info_s* info)
 {
        if (info->register_callback_invoked) {
                SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Already register callback is invoked");
@@ -328,12 +328,12 @@ static int __invoke_register_callback(int pid, tts_mode_e mode, tts_tidl_info_s*
                return ret;
        }
 
-       rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, pid, info->uid, (int)mode, info->notify_cb_h);
+       rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, pid, info->uid, (int)mode, registered_event_mask, info->notify_cb_h);
        info->register_callback_invoked = true;
        return TTS_ERROR_NONE;
 }
 
-int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode)
+int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask)
 {
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 
@@ -372,7 +372,7 @@ int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode)
        }
 
        SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
-       if (TTS_ERROR_NONE != __invoke_register_callback(client->pid, mode, info)) {
+       if (TTS_ERROR_NONE != __invoke_register_callback(client->pid, mode, registered_event_mask, info)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to invoke register callback");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -461,7 +461,7 @@ int tts_tidl_request_hello_sync(unsigned int uid)
        return TTS_ERROR_NONE;
 }
 
-int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed)
+int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed)
 {
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize");
 
@@ -474,7 +474,7 @@ int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, bool* credent
        RETVM_IF(!info->connected, TTS_ERROR_OPERATION_FAILED, "[ERROR] Not Connected");
 
        bool temp;
-       int ret = rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, (int)mode, &temp);
+       int ret = rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, (int)mode, registered_event_mask, &temp);
        int exception = get_last_result();
        if (RPC_PORT_ERROR_NONE != exception) {
                ret = __convert_unhandled_error(exception);

diff --git a/client/tts_tidl.h b/client/tts_tidl.h
index ee3a504740a15795393ddaf4162cfbadea786e69..19af39ded717aacb4e4cdb03888a6d58c2d99855 100644 (file)
--- a/client/tts_tidl.h
+++ b/client/tts_tidl.h
@@ -26,11 +26,11 @@ int tts_tidl_close_connection(unsigned int uid);
 
 int tts_tidl_stop_listening(unsigned int uid);
 
-int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode);
+int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask);
 
 int tts_tidl_request_hello_sync(unsigned int uid);
 
-int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, bool* credential_needed);
+int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, bool* credential_needed);
 
 int tts_tidl_request_finalize(unsigned int uid);
 

diff --git a/common/tts_defs.h b/common/tts_defs.h
index 196e2e353f15c9f477680424d935b702c13bc2c6..300b6ba0b3416711fa7d7a920cfeebc269a98864 100644 (file)
--- a/common/tts_defs.h
+++ b/common/tts_defs.h
@@ -149,6 +149,21 @@ extern "C" {
 #define TAG_TTSCONFIG  "ttsconfig"
 
 
+/******************************************************************************************
+* Enumeration for registered callbacks
+*******************************************************************************************/
+typedef enum {
+       TTS_EVENT_MASK_STATE_CHANGED = (0x01 << 0), /**< State changed event */
+       TTS_EVENT_MASK_UTTERANCE_STARTED = (0x01 << 1), /**< Utterance changed event */
+       TTS_EVENT_MASK_UTTERANCE_COMPLETED = (0x01 << 2), /**< Utterance completed event */
+       TTS_EVENT_MASK_ERROR = (0x01 << 3), /**< Error event */
+       TTS_EVENT_MASK_DEFAULT_VOICE_CHANGED = (0x01 << 4), /**< Default voice changed event */
+       TTS_EVENT_MASK_ENGINE_CHANGED = (0x01 << 5), /**< Engine changed event */
+       TTS_EVENT_MASK_SCREEN_READER_CHANGED = (0x01 << 6), /**< Screen reader changed event */
+       TTS_EVENT_MASK_SERVICE_STATE_CHANGED = (0x01 << 7), /**< Service state changed event */
+} tts_event_mask_e;
+
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp
index b00ad33018637320e4ebed68351211392077f7f9..60ec5949544ad2606e21c825b209c28d3653b6b3 100644 (file)
--- a/server/ttsd_data.cpp
+++ b/server/ttsd_data.cpp
@@ -47,6 +47,7 @@ typedef struct
        tts_ipc_method_e ipc_method;
 
        char* credential;
+       int registered_event_mask;
 } app_data_s;
 
 static vector<app_data_s> g_app_list;
@@ -157,7 +158,7 @@ static app_data_s* __get_client_app_data(unsigned int uid)
        return nullptr;
 }
 
-int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_method_e method)
+int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, int registered_event_mask, tts_ipc_method_e method)
 {
        lock_guard<mutex> lock(g_app_data_mutex);
        if(nullptr != __get_client_app_data(uid) ) {
@@ -176,6 +177,7 @@ int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_me
        app.ipc_method = method;
        app.credential = nullptr;
        app.paused_data_existing = false;
+       app.registered_event_mask = registered_event_mask;
 
        g_app_list.push_back(app);
        g_activated_modes.addMode(mode);

diff --git a/server/ttsd_data.h b/server/ttsd_data.h
index a3dc88b2872e67ed6229573302babb3899af0ebc..3b9f39f82ef2e6e006dc78a1a06007eb43541463 100644 (file)
--- a/server/ttsd_data.h
+++ b/server/ttsd_data.h
@@ -70,7 +70,7 @@ ttsd_synthesis_control_e ttsd_data_get_synth_control();
 
 typedef void (* ttsd_used_voice_cb)(const char* lang, int type);
 
-int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_method_e method);
+int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, int registered_event_mask, tts_ipc_method_e method);
 
 int ttsd_data_delete_client(unsigned int uid);
 

diff --git a/server/ttsd_dbus_server.c b/server/ttsd_dbus_server.c
index d4eca700bf1f6b65858e63a64aa996f56f7c8b9e..93a44bd31a9b8256851076233fa5e0920dd34c85 100644 (file)
--- a/server/ttsd_dbus_server.c
+++ b/server/ttsd_dbus_server.c
@@ -32,7 +32,13 @@ int ttsd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
        int pid;
        unsigned int uid;
        int mode = 0;
-       dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID);
+       int registered_event_mask = 0;
+       dbus_message_get_args(msg, &err,
+               DBUS_TYPE_INT32, &pid,
+               DBUS_TYPE_UINT32, &uid,
+               DBUS_TYPE_INT32, &mode,
+               DBUS_TYPE_INT32, &registered_event_mask,
+               DBUS_TYPE_INVALID);
 
        if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : get arguments error (%s)", err.message);
@@ -46,7 +52,7 @@ int ttsd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
 
                ttsd_server_is_already_initialized(pid, uid, &is_initialized);
                if (false == is_initialized) {
-                       ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, TTS_IPC_METHOD_DBUS, &is_credential_needed);
+                       ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, registered_event_mask, TTS_IPC_METHOD_DBUS, &is_credential_needed);
                        if (0 != ret) {
                                SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : server initialize, ret(%d)", ret);
                        }
@@ -98,12 +104,14 @@ int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
        unsigned int uid;
        bool credential_needed = 0;
        int mode = 0;
+       int registered_event_mask = 0;
        int ret = 0;
 
        dbus_message_get_args(msg, &err,
                DBUS_TYPE_INT32, &pid,
                DBUS_TYPE_UINT32, &uid,
                DBUS_TYPE_INT32, &mode,
+               DBUS_TYPE_INT32, &registered_event_mask,
                DBUS_TYPE_INVALID);
 
        SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS INITIALIZE");
@@ -114,7 +122,7 @@ int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                ret = TTSD_ERROR_OPERATION_FAILED;
        } else {
                SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts initialize : pid(%d), uid(%u), mode(%d)", pid, uid, mode);
-               ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, TTS_IPC_METHOD_DBUS, &credential_needed);
+               ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, registered_event_mask, TTS_IPC_METHOD_DBUS, &credential_needed);
        }
 
        DBusMessage* reply;

diff --git a/server/ttsd_server.c b/server/ttsd_server.c
index f4e6a4070c11be6759f37176409a43db7bf81611..a665ea513052f9098e8843f67cb23536d778bd84 100644 (file)
--- a/server/ttsd_server.c
+++ b/server/ttsd_server.c
@@ -776,7 +776,7 @@ static int __check_app_agreed(int pid, unsigned int uid, bool credential_needed)
        return TTSD_ERROR_NONE;
 }
 
-int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_method_e method, bool* credential_needed)
+int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, int registered_event_mask, tts_ipc_method_e method, bool* credential_needed)
 {
        SLOG(LOG_INFO, tts_tag(), "[Server] Server initialize");
 
@@ -785,7 +785,7 @@ int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_
                return TTSD_ERROR_NONE;
        }
 
-       if (TTSD_ERROR_NONE != ttsd_data_new_client(pid, uid, mode, method)) {
+       if (TTSD_ERROR_NONE != ttsd_data_new_client(pid, uid, mode, registered_event_mask, method)) {
                SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to add client info");
                return TTSD_ERROR_OPERATION_FAILED;
        }

diff --git a/server/ttsd_server.h b/server/ttsd_server.h
index ebcb54a4207dcb7fa0a803be6b7e5ab16e148c6b..a40f9eb20a62eece4de0d2cdcc29664e76d4b5a1 100644 (file)
--- a/server/ttsd_server.h
+++ b/server/ttsd_server.h
@@ -49,7 +49,7 @@ int ttsd_set_activated_mode_changed_cb(ttse_activated_mode_changed_cb callback);
 
 int ttsd_server_is_already_initialized(int pid, unsigned int uid, bool* is_initialized);
 
-int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, tts_ipc_method_e method, bool* credential_needed);
+int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, int registered_event_mask, tts_ipc_method_e method, bool* credential_needed);
 
 int ttsd_server_finalize(unsigned int uid);
 

diff --git a/server/ttsd_tidl.c b/server/ttsd_tidl.c
index 9b50d1b08e2a7bc09fc8629078cda863a637b22f..0cb8403c00e99d33e8779bce75b489f084ffebdd 100644 (file)
--- a/server/ttsd_tidl.c
+++ b/server/ttsd_tidl.c
@@ -137,10 +137,10 @@ static void __destroy_client_cb(rpc_port_stub_tts_context_h context, void *user_
        free(sender);
 }
 
-static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, rpc_port_stub_tts_notify_cb_h callback, void *user_data)
+static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, int registered_event_mask, rpc_port_stub_tts_notify_cb_h callback, void *user_data)
 {
        unsigned int u_uid = (unsigned int)uid;
-       SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%u), mode(%d)", u_uid, mode);
+       SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%u), mode(%d), registered mask(%x)", u_uid, mode, registered_event_mask);
 
        bool is_initialized = false;
        ttsd_server_is_already_initialized(pid, u_uid, &is_initialized);
@@ -149,7 +149,7 @@ static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid,
        int credential_needed = 0;
        if (false == is_initialized) {
                bool is_credential_needed = false;
-               ret = ttsd_server_initialize(pid, u_uid, mode, TTS_IPC_METHOD_TIDL, &is_credential_needed);
+               ret = ttsd_server_initialize(pid, u_uid, mode, registered_event_mask, TTS_IPC_METHOD_TIDL, &is_credential_needed);
                if (0 != ret) {
                        SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : server initialize, ret(%d)", ret);
                }
@@ -261,12 +261,12 @@ int ttsdc_tidl_send_hello(int pid, unsigned int uid, int ret, int credential_nee
        return TTSD_ERROR_NONE;
 }
 
-static int __initialize_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, bool *credential_needed, void *user_data)
+static int __initialize_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, int registered_event_mask, bool *credential_needed, void *user_data)
 {
        unsigned int u_uid = (unsigned int)uid;
        SECURE_SLOG(LOG_ERROR, tts_tag(), "[IN] tts initialize : pid(%d), uid(%u), mode(%d)", pid, u_uid, mode);
 
-       if (0 != ttsd_server_initialize(pid, u_uid, mode, TTS_IPC_METHOD_TIDL, credential_needed)) {
+       if (0 != ttsd_server_initialize(pid, u_uid, mode, registered_event_mask, TTS_IPC_METHOD_TIDL, credential_needed)) {
                return TTSD_ERROR_OPERATION_FAILED;
        }
 

diff --git a/tidl/tts.tidl b/tidl/tts.tidl
index c6071e303f93643d21de86d574714aa9f818efb3..1d09a7be482edd03287b5cde444a4ca33a4e3b5a 100644 (file)
--- a/tidl/tts.tidl
+++ b/tidl/tts.tidl
@@ -1,9 +1,9 @@
 interface tts {
        void notify_cb(int pid, int uid, bundle msg) delegate;
-       void register_cb(int pid, int uid, int mode, notify_cb callback) async;
+       void register_cb(int pid, int uid, int mode, int registered_event_mask, notify_cb callback) async;
        int register_cb_sync(int pid, int uid, notify_cb callback);
 
-       int initialize(in int pid, in int uid, in int mode, out bool credential_needed);
+       int initialize(in int pid, in int uid, in int mode, in int registered_event_mask, out bool credential_needed);
        int finalize(in int uid);
        int add_text(int uid, string text, string lang, int vctype, int speed, int uttid, string credential);
        int stop(in int uid);