From 623f6ee4bc2040bc60f430c61f9f634b62c26882 Mon Sep 17 00:00:00 2001
From: "wn.jang" <wn.jang@samsung.com>
Date: Fri, 9 Dec 2022 18:39:39 +0900
Subject: [PATCH] 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
---
 client/tts.c              | 20 ++++++++++++++++++++
 client/tts_client.c       | 18 ++++++++++++++++++
 client/tts_client.h       |  4 ++++
 client/tts_core.c         |  8 +++++---
 client/tts_dbus.c         |  8 +++++---
 client/tts_dbus.h         |  4 ++--
 client/tts_ipc.c          |  6 +++---
 client/tts_ipc.h          |  4 ++--
 client/tts_tidl.c         | 14 +++++++-------
 client/tts_tidl.h         |  4 ++--
 include/tts.h             | 28 ++++++++++++++++++++++++++++
 server/ttsd_data.cpp      |  4 +++-
 server/ttsd_data.h        |  2 +-
 server/ttsd_dbus_server.c | 12 ++++++++----
 server/ttsd_main.h        |  5 +++++
 server/ttsd_server.c      |  4 ++--
 server/ttsd_server.h      |  2 +-
 server/ttsd_tidl.c        | 10 +++++-----
 tidl/tts.tidl             |  4 ++--
 19 files changed, 123 insertions(+), 38 deletions(-)

diff --git a/client/tts.c b/client/tts.c
index a7b67f3..46de738 100644
--- 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 8cfc81b..ba8789a 100644
--- 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 4426775..b4e5bc1 100644
--- 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 fd4b4d6..28d5daa 100644
--- 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 c2f29ea..eba8457 100644
--- 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 4ef0ed5..63844dc 100644
--- 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 b1af5a9..8e75326 100644
--- 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 fbddbbb..08abd12 100644
--- 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 9110133..ec86a34 100644
--- 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 97a8de3..e4740d4 100644
--- 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 0ceb0fa..63fb7c2 100644
--- a/include/tts.h
+++ b/include/tts.h
@@ -111,6 +111,16 @@ typedef enum {
 
 
 /**
+ * @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
 */
@@ -369,6 +379,24 @@ 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.
  *          The credential is a key to verify the authorization about using the engine.
diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp
index 4808bc9..c59b8b2 100644
--- 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 15bd856..a1a0782 100644
--- 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 d338d88..59ffc0e 100644
--- 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 40e886c..c39559a 100644
--- a/server/ttsd_main.h
+++ b/server/ttsd_main.h
@@ -61,6 +61,11 @@ typedef enum {
 } 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' */
 } ttsd_interrupted_code_e;
diff --git a/server/ttsd_server.c b/server/ttsd_server.c
index 2682839..3b7db8d 100644
--- 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 4576074..f6dddca 100644
--- 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 0f15a44..f1bb408 100644
--- 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 a50ed58..505137b 100644
--- 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);
-- 
2.7.4