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 4f963c9..e32045c 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 bcd19f2..dcbf6b5 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 f3b9959..ae1a3d0 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 e2fa698..6c3cfcb 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 70ec52a..a0eaeb7 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 806950e..9b4eb36 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 e7591c3..34bad75 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 466ae29..c87914a 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 ee3a504..19af39d 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 196e2e3..300b6ba 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 b00ad33..60ec594 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 a3dc88b..3b9f39f 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 d4eca70..93a44bd 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 f4e6a40..a665ea5 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 ebcb54a..a40f9eb 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 9b50d1b..0cb8403 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 c6071e3..1d09a7b 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);