Add to set playing mode to decide where the synthesized pcm data will be played

Needs: The application wants to play the synthesized pcm data on client side.

Solution: Provides the Api to set playing mode to decide where it will be played.

This commit is related to following commit.
https://review.tizen.org/gerrit/#/c/platform/core/uifw/tts/+/284933/

Change-Id: If9e73f05409feab8e9ff371aee1570b38d6e2407

diff --git a/client/tts.c b/client/tts.c
index a7b67f3a72afa50e039dc85e03383ad21d8c78e5..46de738ad221f8ce10f61f79742e9d95e3ddf1c7 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -430,6 +430,26 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
        return TTS_ERROR_NONE;
 }
 
+int tts_set_playing_mode(tts_h tts, tts_playing_mode_e mode)
+{
+       RETV_IF(TTS_ERROR_NONE != __tts_get_feature_enabled(), TTS_ERROR_NOT_SUPPORTED);
+
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS playing mode(%d)", mode);
+
+       RETVM_IF(TTS_PLAYING_MODE_BY_CLIENT > mode || TTS_PLAYING_MODE_BY_SERVICE < mode, TTS_ERROR_INVALID_PARAMETER, "[ERROR] mode is not valid : %d", mode);
+
+       tts_client_s* client = tts_client_get(tts);
+       RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not valid. tts(%p)", tts);
+
+       tts_state_e current_state = tts_client_get_current_state(client);
+       RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_INVALID_STATE, "[ERROR] The current state(%d) is invalid", current_state);
+
+       tts_client_set_playing_mode(client, mode);
+
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+       return TTS_ERROR_NONE;
+}
+
 int tts_set_credential(tts_h tts, const char* credential)
 {
        RETV_IF(TTS_ERROR_NONE != __tts_get_feature_enabled(), TTS_ERROR_NOT_SUPPORTED);

diff --git a/client/tts_client.c b/client/tts_client.c
index 8cfc81b3213f1cd5742c99054f6453a26414e3f7..ba8789a65b664f6665d76794834caab65c9ca63f 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -516,6 +516,24 @@ tts_mode_e tts_client_get_mode(tts_client_s* client)
        return client->mode;
 }
 
+void tts_client_set_playing_mode(tts_client_s* client, tts_playing_mode_e mode)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return;
+       }
+
+       client->playing_mode = mode;
+}
+
+tts_playing_mode_e tts_client_get_playing_mode(tts_client_s* client)
+{
+       if (false == tts_client_is_valid_client(client)) {
+               return INVALID_HANDLE;
+       }
+
+       return client->playing_mode;
+}
+
 void tts_client_set_repeat_text(tts_client_s* client, const char* text)
 {
        if (NULL == client || false == tts_client_is_valid_client(client)) {

diff --git a/client/tts_client.h b/client/tts_client.h
index 44267751ff01b2f8dc7225b864b81ee3942fb961..b4e5bc1c60326aba1506e644a39cf43ba3d168c4 100644 (file)
--- a/client/tts_client.h
+++ b/client/tts_client.h
@@ -61,6 +61,7 @@ typedef struct {
 
        /* mode / state */
        tts_mode_e      mode;
+       tts_playing_mode_e playing_mode;
        tts_state_e     before_state;
        tts_state_e     current_state;
        tts_service_state_e current_service_state;
@@ -133,6 +134,9 @@ bool tts_client_is_service_out(tts_client_s* client);
 void tts_client_set_mode(tts_client_s* client, tts_mode_e mode);
 tts_mode_e tts_client_get_mode(tts_client_s* client);
 
+void tts_client_set_playing_mode(tts_client_s* client, tts_playing_mode_e mode);
+tts_playing_mode_e tts_client_get_playing_mode(tts_client_s* client);
+
 void tts_client_set_repeat_text(tts_client_s* client, const char* text);
 char* tts_client_get_repeat_text(tts_client_s* client);
 

diff --git a/client/tts_core.c b/client/tts_core.c
index fd4b4d6c0449bbecbaaea1a20461f596f35fa0e2..28d5daa9586532d0a58e9060dcac38d95c2b0b66 100644 (file)
--- a/client/tts_core.c
+++ b/client/tts_core.c
@@ -428,8 +428,9 @@ 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);
+       tts_playing_mode_e playing_mode = tts_client_get_playing_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);
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u), mode(%d), playing_mode(%d)", tts_client_get_handle(client), client, uid, (int)mode, (int)playing_mode);
 
        /* check service engine status */
        bool is_launched = __is_engine_launched();
@@ -444,7 +445,7 @@ static int __send_hello_msg(tts_client_s* client)
                }
        }
 
-       if (0 != tts_ipc_request_hello(uid, mode, registered_callback_mask)) {
+       if (0 != tts_ipc_request_hello(uid, mode, playing_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");
@@ -532,8 +533,9 @@ static int __prepare_sync_cb(tts_client_s* client, tts_service_state_e* service_
        bool credential_needed = false;
        tts_service_state_e tmp_service_state = TTS_SERVICE_STATE_NONE;
        tts_mode_e mode = tts_client_get_mode(client);
+       tts_playing_mode_e playing_mode = tts_client_get_playing_mode(client);
        int registered_callback_mask = tts_client_get_registered_event_mask(client);
-       int ret = tts_ipc_request_initialize(uid, mode, registered_callback_mask, &tmp_service_state, &credential_needed);
+       int ret = tts_ipc_request_initialize(uid, mode, playing_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);

diff --git a/client/tts_dbus.c b/client/tts_dbus.c
index c2f29ea26491f9a9f2d19cb0c29e2b171dcc5ea7..eba8457d58020ab3877236571060d3168bb7d078 100644 (file)
--- a/client/tts_dbus.c
+++ b/client/tts_dbus.c
@@ -440,7 +440,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 registered_event_mask)
+int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask)
 {
        DBusError err;
        dbus_error_init(&err);
@@ -463,6 +463,7 @@ int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode, int registered_eve
                        DBUS_TYPE_INT32, &pid,
                        DBUS_TYPE_UINT32, &uid,
                        DBUS_TYPE_INT32, &mode,
+                       DBUS_TYPE_INT32, &playing_mode,
                        DBUS_TYPE_INT32, &registered_event_mask,
                        DBUS_TYPE_INVALID)) {
                dbus_message_unref(msg);
@@ -526,7 +527,7 @@ int tts_dbus_request_hello_sync(unsigned int uid)
        return result;
 }
 
-int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
+int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
 {
        DBusMessage* msg;
        DBusError err;
@@ -538,7 +539,7 @@ int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, int registere
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
                return TTS_ERROR_OPERATION_FAILED;
        } else {
-               SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : uid(%u)", uid);
+               SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : uid(%u), mode(%d), playing_mode(%d)", uid, (int)mode, (int)playing_mode);
        }
 
        int pid = getpid();
@@ -546,6 +547,7 @@ int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, int registere
                        DBUS_TYPE_INT32, &pid,
                        DBUS_TYPE_UINT32, &uid,
                        DBUS_TYPE_INT32, &mode,
+                       DBUS_TYPE_INT32, &playing_mode,
                        DBUS_TYPE_INT32, &registered_event_mask,
                        DBUS_TYPE_INVALID)) {
                dbus_message_unref(msg);

diff --git a/client/tts_dbus.h b/client/tts_dbus.h
index 4ef0ed5f2dee4ee596bedf8ac47315306ee9ea63..63844dc5f39a112b669b4462a69d9551ca0ab115 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 registered_event_mask);
+int tts_dbus_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_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, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
+int tts_dbus_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
 
 int tts_dbus_request_finalize(unsigned int uid);
 

diff --git a/client/tts_ipc.c b/client/tts_ipc.c
index b1af5a9d6628cafc109ddc36175920420936bf14..8e75326fbadc426074696fbb9ce5a48b142c6398 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 registered_event_mask)
+int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_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, registered_event_mask);
+       return g_vtable[REQUEST_HELLO](uid, mode, playing_mode, registered_event_mask);
 }
 
 int tts_ipc_request_hello_sync(unsigned int uid)
@@ -129,7 +129,7 @@ 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, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
+int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
 {
        SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_initialize");
 

diff --git a/client/tts_ipc.h b/client/tts_ipc.h
index fbddbbb76a2017d5ea86937324e933924f5a65a0..08abd120d544db65dc1095731821f4c418d5d7ac 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 registered_event_mask);
+int tts_ipc_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_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, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
+int tts_ipc_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
 
 int tts_ipc_request_finalize(unsigned int uid);
 

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 9110133943db344448571d0586aa1bd74c374602..ec86a340951b269becd1a5f806bf46178cff9735 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -336,7 +336,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, int registered_event_mask, tts_tidl_info_s* info)
+static int __invoke_register_callback(int pid, tts_mode_e mode, tts_playing_mode_e playing_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");
@@ -350,7 +350,7 @@ static int __invoke_register_callback(int pid, tts_mode_e mode, int registered_e
        }
 
        SLOG(LOG_ERROR, TAG_TTSC, ">>>>> Request register cb. uid(%d)", info->uid);
-       rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, pid, info->uid, (int)mode, registered_event_mask, info->notify_cb_h);
+       rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, pid, info->uid, (int)mode, (int)playing_mode, registered_event_mask, info->notify_cb_h);
        info->register_callback_invoked = true;
        return TTS_ERROR_NONE;
 }
@@ -424,7 +424,7 @@ static int __check_and_prepare_rpc_port(tts_tidl_info_s* info)
        return __reset_rpc_port(info, engine_id);
 }
 
-int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, int registered_event_mask)
+int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask)
 {
        SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
 
@@ -446,7 +446,7 @@ int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, int registered_eve
        }
 
        SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
-       if (TTS_ERROR_NONE != __invoke_register_callback(client->pid, mode, registered_event_mask, info)) {
+       if (TTS_ERROR_NONE != __invoke_register_callback(client->pid, mode, playing_mode, registered_event_mask, info)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to invoke register callback");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -547,9 +547,9 @@ 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, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
+int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed)
 {
-       SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize");
+       SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize : uid(%u), mode(%d), playing_mode(%d)", uid, (int)mode, (int)playing_mode);
 
        tts_client_s* client = tts_client_get_by_uid(uid);
        RETVM_IF(NULL == client, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Fail to get client");
@@ -561,7 +561,7 @@ int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, int registere
 
        bool tmp_credential_needed = false;
        int tmp_service_state = -1;
-       int ret = rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, (int)mode, registered_event_mask, &tmp_service_state, &tmp_credential_needed);
+       int ret = rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, (int)mode, (int)playing_mode, registered_event_mask, &tmp_service_state, &tmp_credential_needed);
        int exception = get_last_result();
        if (RPC_PORT_ERROR_NONE != exception) {
                ret = __convert_and_handle_tidl_error(exception, info);

diff --git a/client/tts_tidl.h b/client/tts_tidl.h
index 97a8de34bbd11a6d2bd2fa3312abc4c0e2036df3..e4740d403c01008c091a039b3e6ff45a4f76100f 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 registered_event_mask);
+int tts_tidl_request_hello(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_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, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
+int tts_tidl_request_initialize(unsigned int uid, tts_mode_e mode, tts_playing_mode_e playing_mode, int registered_event_mask, tts_service_state_e* service_state, bool* credential_needed);
 
 int tts_tidl_request_finalize(unsigned int uid);
 

diff --git a/include/tts.h b/include/tts.h
index 0ceb0faa2987303683a3e7e1ca9f563822ce017f..63fb7c2710281f34143f68fb4a69fb8fbac14414 100644 (file)
--- a/include/tts.h
+++ b/include/tts.h
@@ -110,6 +110,16 @@ typedef enum {
 } tts_synthesized_pcm_event_e;
 
 
+/**
+ * @brief Enumration for playing mode of TTS.
+ * @since_tizen 7.5
+*/
+typedef enum {
+       TTS_PLAYING_MODE_BY_SERVICE = 0, /**< Mode for TTS playing on TTS service */
+       TTS_PLAYING_MODE_BY_CLIENT = 1, /**< Mode for TTS playing on TTS client */
+} tts_playing_mode_e;
+
+
 /**
  * @brief Definition for automatic speaking speed.
  * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
@@ -368,6 +378,24 @@ int tts_set_mode(tts_h tts, tts_mode_e mode);
 int tts_get_mode(tts_h tts, tts_mode_e* mode);
 
 
+/**
+ * @brief Sets the TTS playing mode.
+ * @since_tizen 7.5
+ * @param[in] tts The TTS handle
+ * @param[in] mode The mode
+ * @return @c 0 on success,
+ *        otherwise a negative error value
+ * @retval #TTS_ERROR_NONE Successful
+ * @retval #TTS_ERROR_NOT_SUPPORTED TTS NOT supported
+ * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #TTS_ERROR_INVALID_STATE Invalid state
+ * @pre The state should be #TTS_STATE_CREATED.
+ * @see tts_get_playing_mode()
+ * @see tts_play()
+ */
+int tts_set_playing_mode(tts_h tts, tts_playing_mode_e mode);
+
+
 /**
  * @brief Sets the app credential.
  * @details Using this API, the application can set a credential.

diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp
index 4808bc9168c38c57e32f08ad65fae32538335551..c59b8b26ba7e1dc92450c8b0678cb5a303bc37ce 100644 (file)
--- a/server/ttsd_data.cpp
+++ b/server/ttsd_data.cpp
@@ -38,6 +38,7 @@ typedef struct
        app_tts_state_e state;
        tts_app_play_type_e type;
        ttsd_mode_e     mode;
+       ttsd_playing_mode_e playing_mode;
        ttse_result_event_e result_event;
 
        std::list<speak_data_s*> m_speak_data;
@@ -159,7 +160,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, int registered_event_mask, tts_ipc_method_e method)
+int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, ttsd_playing_mode_e playing_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) ) {
@@ -174,6 +175,7 @@ int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, int regist
        app.state = APP_STATE_READY;
        app.type = TTS_APP_PLAY_TYPE_SYNTH;
        app.mode = mode;
+       app.playing_mode = playing_mode;
        app.result_event = TTSE_RESULT_EVENT_FAIL;
        app.ipc_method = method;
        app.credential = nullptr;

diff --git a/server/ttsd_data.h b/server/ttsd_data.h
index 15bd856cca392e087572b7915a97872822b529d5..a1a0782f2c2f07cca724bb40b8b1ea3ac5a25d3d 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, int registered_event_mask, tts_ipc_method_e method);
+int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, ttsd_playing_mode_e playing_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 d338d88cd727f356227a46ad42d094d59a8e80c4..59ffc0e62c07b47329be2adb32eb7a9ee4fc5166 100644 (file)
--- a/server/ttsd_dbus_server.c
+++ b/server/ttsd_dbus_server.c
@@ -32,11 +32,13 @@ int ttsd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
        int pid;
        unsigned int uid;
        int mode = 0;
+       int playing_mode = 0;
        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, &playing_mode,
                DBUS_TYPE_INT32, &registered_event_mask,
                DBUS_TYPE_INVALID);
 
@@ -44,7 +46,7 @@ int ttsd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
                SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : get arguments error (%s)", err.message);
                dbus_error_free(&err);
        } else {
-               SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : pid(%d), uid(%u), mode(%d)", pid, uid, mode);
+               SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : pid(%d), uid(%u), mode(%d), playing_mode(%d)", pid, uid, mode, playing_mode);
                bool is_initialized = false;
                bool is_credential_needed = false;
                ttsd_state_e service_state = TTSD_STATE_INVALID;
@@ -53,7 +55,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, registered_event_mask, TTS_IPC_METHOD_DBUS, &service_state, &is_credential_needed);
+                       ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, (ttsd_playing_mode_e)playing_mode, registered_event_mask, TTS_IPC_METHOD_DBUS, &service_state, &is_credential_needed);
                        if (0 != ret) {
                                SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : server initialize, ret(%d)", ret);
                        }
@@ -106,6 +108,7 @@ int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
        bool credential_needed = 0;
        ttsd_state_e service_state = TTSD_STATE_INVALID;
        int mode = 0;
+       int playing_mode = 0;
        int registered_event_mask = 0;
        int ret = 0;
 
@@ -113,6 +116,7 @@ int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                DBUS_TYPE_INT32, &pid,
                DBUS_TYPE_UINT32, &uid,
                DBUS_TYPE_INT32, &mode,
+               DBUS_TYPE_INT32, &playing_mode,
                DBUS_TYPE_INT32, &registered_event_mask,
                DBUS_TYPE_INVALID);
 
@@ -123,8 +127,8 @@ int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                dbus_error_free(&err);
                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, registered_event_mask, TTS_IPC_METHOD_DBUS, &service_state, &credential_needed);
+               SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts initialize : pid(%d), uid(%u), mode(%d), playing_mode(%d)", pid, uid, mode, playing_mode);
+               ret = ttsd_server_initialize(pid, uid, (ttsd_mode_e)mode, (ttsd_playing_mode_e)playing_mode, registered_event_mask, TTS_IPC_METHOD_DBUS, &service_state, &credential_needed);
                ttsd_server_update_instant_reprepare_client();
        }
 

diff --git a/server/ttsd_main.h b/server/ttsd_main.h
index 40e886c3e31599d392eb154e69b5c1b78b3ccf41..c39559ab5968e0fdb5f771efdb3450be7a9e3da4 100644 (file)
--- a/server/ttsd_main.h
+++ b/server/ttsd_main.h
@@ -60,6 +60,11 @@ typedef enum {
        TTSD_MODE_INTERRUPT                     /**< Interrupt mode */
 } ttsd_mode_e;
 
+typedef enum {
+       TTSD_PLAYING_MODE_BY_SERVICE = 0, /**< Mode for TTS playing on TTS service */
+       TTSD_PLAYING_MODE_BY_CLIENT = 1, /**< Mode for TTS playing on TTS client */
+} ttsd_playing_mode_e;
+
 typedef enum {
        TTSD_INTERRUPTED_PAUSED = 0,    /**< Current state change 'Pause' */
        TTSD_INTERRUPTED_STOPPED        /**< Current state change 'Ready' */

diff --git a/server/ttsd_server.c b/server/ttsd_server.c
index 268283975d160a6384fb8ce7a5c86f4bd43ec968..3b7db8d2a60378466360fbae0abd6d172275d1ad 100644 (file)
--- a/server/ttsd_server.c
+++ b/server/ttsd_server.c
@@ -787,7 +787,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, int registered_event_mask, tts_ipc_method_e method, ttsd_state_e* service_state, bool* credential_needed)
+int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, ttsd_playing_mode_e playing_mode, int registered_event_mask, tts_ipc_method_e method, ttsd_state_e* service_state, bool* credential_needed)
 {
        SLOG(LOG_INFO, tts_tag(), "[Server] Server initialize");
 
@@ -796,7 +796,7 @@ int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, int regi
                return TTSD_ERROR_NONE;
        }
 
-       if (TTSD_ERROR_NONE != ttsd_data_new_client(pid, uid, mode, registered_event_mask, method)) {
+       if (TTSD_ERROR_NONE != ttsd_data_new_client(pid, uid, mode, playing_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 4576074e6a4e2767af8f325255d898fc85860b8a..f6dddca8511b62bf6ac49f1e7832f1385a71bd4a 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, int registered_event_mask, tts_ipc_method_e method, ttsd_state_e* service_state, bool* credential_needed);
+int ttsd_server_initialize(int pid, unsigned int uid, ttsd_mode_e mode, ttsd_playing_mode_e playing_mode, int registered_event_mask, tts_ipc_method_e method, ttsd_state_e* service_state, bool* credential_needed);
 
 int ttsd_server_finalize(unsigned int uid);
 

diff --git a/server/ttsd_tidl.c b/server/ttsd_tidl.c
index 0f15a441f71ec9ec89440a8151667928a84f9a33..f1bb408925e62439b7dc29faedeb35b1d88de7cb 100644 (file)
--- a/server/ttsd_tidl.c
+++ b/server/ttsd_tidl.c
@@ -138,10 +138,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, int registered_event_mask, 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 playing_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), registered mask(%x)", u_uid, mode, registered_event_mask);
+       SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%u), mode(%d), playing_mode(%d), registered mask(%x)", u_uid, mode, playing_mode, registered_event_mask);
 
        bool is_initialized = false;
        ttsd_server_is_already_initialized(pid, u_uid, &is_initialized);
@@ -152,7 +152,7 @@ static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid,
 
        if (false == is_initialized) {
                bool is_credential_needed = false;
-               ret = ttsd_server_initialize(pid, u_uid, mode, registered_event_mask, TTS_IPC_METHOD_TIDL, &service_state, &is_credential_needed);
+               ret = ttsd_server_initialize(pid, u_uid, mode, playing_mode, registered_event_mask, TTS_IPC_METHOD_TIDL, &service_state, &is_credential_needed);
                if (0 != ret) {
                        SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : server initialize, ret(%d)", ret);
                }
@@ -270,13 +270,13 @@ int ttsdc_tidl_send_hello(int pid, unsigned int uid, int ret, int service_state,
        return TTSD_ERROR_NONE;
 }
 
-static int __initialize_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, int registered_event_mask, int *service_state, bool *credential_needed, void *user_data)
+static int __initialize_cb(rpc_port_stub_tts_context_h context, int pid, int uid, int mode, int playing_mode, int registered_event_mask, int *service_state, 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);
 
        ttsd_state_e tmp_service_state = TTSD_STATE_INVALID;
-       if (0 != ttsd_server_initialize(pid, u_uid, mode, registered_event_mask, TTS_IPC_METHOD_TIDL, &tmp_service_state, credential_needed)) {
+       if (0 != ttsd_server_initialize(pid, u_uid, mode, playing_mode, registered_event_mask, TTS_IPC_METHOD_TIDL, &tmp_service_state, credential_needed)) {
                return TTSD_ERROR_OPERATION_FAILED;
        }
        ttsd_server_update_instant_reprepare_client();

diff --git a/tidl/tts.tidl b/tidl/tts.tidl
index a50ed58f1b84b7e8b9ef1eb89f45957ce7d29e1e..505137b680f37c367ad9c4d54bde0af022087882 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, int registered_event_mask, notify_cb callback) async;
+       void register_cb(int pid, int uid, int mode, int playing_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, in int registered_event_mask, out int service_state, out bool credential_needed);
+       int initialize(in int pid, in int uid, in int mode, in int playing_mode, in int registered_event_mask, out int service_state, 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);