X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=client%2Ftts.c;h=08e8d9a3fa238b7852faa77d8e5f5df74e00d51f;hb=68ae641b2958e1df09406cef9374092830f640b6;hp=19684fc833389aafb2aa141c51d65ad8a32d09c8;hpb=b4d4f1363f5aac36eec86963e729c3c37f8d0bc5;p=platform%2Fcore%2Fuifw%2Ftts.git

diff --git a/client/tts.c b/client/tts.c
index 19684fc..08e8d9a 100644
--- a/client/tts.c
+++ b/client/tts.c
@@ -11,6 +11,7 @@
 *  limitations under the License.
 */
 
+#include <app_manager.h>
 #include <dirent.h>
 #include <Ecore.h>
 #include <iconv.h>
@@ -26,6 +27,7 @@
 #include "tts_dbus.h"
 #include "tts_main.h"
 
+#include "tts_internal.h"
 
 static bool g_screen_reader;
 
@@ -33,6 +35,19 @@ static int g_feature_enabled = -1;
 
 static bool g_err_callback_status = false;
 
+static int g_max_text_size = -1;
+
+static Ecore_Timer* g_check_state_timer = NULL;
+
+
+/* for repetition */
+static char* g_language = NULL;
+
+static int g_voice_type = -1;
+
+static int g_speed = -1;
+
+
 /* Function definition */
 static Eina_Bool __tts_notify_state_changed(void *data);
 static Eina_Bool __tts_notify_error(void *data);
@@ -105,6 +120,7 @@ static int __tts_convert_config_error_code(tts_config_error_e code)
 	return code;
 }
 
+//LCOV_EXCL_START
 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
 {
 	SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
@@ -128,6 +144,14 @@ void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_typ
 					language, voice_type, data->default_voice_changed_user_data);
 			}
 
+			/* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
+			if (0 != strncmp(before_lang, language, strlen(before_lang))) {
+				if (NULL != data->text_repeat) {
+					free(data->text_repeat);
+					data->text_repeat = NULL;
+				}
+			}
+
 			/* Next item */
 			iter = g_list_next(iter);
 		}
@@ -136,19 +160,91 @@ void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_typ
 	return;
 }
 
+static Eina_Bool __reconnect_by_engine_changed(void* data)
+{
+	tts_h tts = (tts_h)data;
+
+	tts_client_s* client = tts_client_get(tts);
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
+		return EINA_FALSE;
+	}
+
+	if (TTS_STATE_READY != client->current_state) {
+		usleep(10000);
+		return EINA_TRUE;
+	}
+
+	int ret = tts_unprepare(tts);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
+	}
+	ret = tts_prepare(tts);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
+	}
+
+	return EINA_FALSE;
+}
+
+void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
+{
+	tts_h tts = (tts_h)user_data;
+
+	tts_client_s* client = tts_client_get(tts);
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
+		return;
+	}
+
+	if (NULL != engine_id)	SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
+	if (NULL != setting)	SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
+	if (NULL != language)	SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
+	SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
+
+	/* When the default engine is changed, please unload the old engine and load the new one. */
+	int ret = -1;
+
+	if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
+		ret = tts_stop(tts);
+		if (0 != ret) {
+			SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
+		}
+
+		ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
+	} else if (TTS_STATE_READY == client->current_state) {
+		ret = tts_unprepare(tts);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
+		}
+		ret = tts_prepare(tts);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
+		}
+	}
+
+	/* call callback function */
+	if (NULL != client->engine_changed_cb) {
+		client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
+	} else {
+		SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
+	}
+	return;
+}
+//LCOV_EXCL_STOP
+
 int tts_create(tts_h* tts)
 {
 	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
 
 	/* check param */
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -177,14 +273,14 @@ int tts_create(tts_h* tts)
 		return __tts_convert_config_error_code(ret);
 	}
 
-	ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
+	ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 		tts_client_destroy(*tts);
 		return __tts_convert_config_error_code(ret);
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 	SLOG(LOG_DEBUG, TAG_TTSC, " ");
 
 	return TTS_ERROR_NONE;
@@ -196,7 +292,7 @@ int tts_destroy(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
@@ -221,16 +317,25 @@ int tts_destroy(tts_h tts)
 
 	int ret = -1;
 	int count = 0;
+	int screen_reader = -1;
 
 	/* check state */
 	switch (client->current_state) {
 	case TTS_STATE_PAUSED:
 	case TTS_STATE_PLAYING:
 	case TTS_STATE_READY:
+		ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
+		} else {
+			SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
+			g_screen_reader = (bool)screen_reader;
+		}
 		if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
-			while (0 != ret) {
+			do {
 				ret = tts_dbus_request_finalize(client->uid);
 				if (0 != ret) {
+					//LCOV_EXCL_START
 					if (TTS_ERROR_TIMED_OUT != ret) {
 						SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 						break;
@@ -243,8 +348,9 @@ int tts_destroy(tts_h tts)
 							break;
 						}
 					}
+					//LCOV_EXCL_STOP
 				}
-			}
+			} while (0 != ret);
 		} else {
 			SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 		}
@@ -272,18 +378,30 @@ int tts_destroy(tts_h tts)
 		}
 	}
 
+	if (NULL != g_language) {
+		free(g_language);
+		g_language = NULL;
+	}
+
+	/* Delete state timer before destroying handle */
+	if (NULL != g_check_state_timer) {
+		ecore_timer_del(g_check_state_timer);
+		g_check_state_timer = NULL;
+	}
+
 	tts = NULL;
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 void __tts_screen_reader_changed_cb(bool value)
 {
 	g_screen_reader = value;
 }
+//LCOV_EXCL_STOP
 
 int tts_set_mode(tts_h tts, tts_mode_e mode)
 {
@@ -291,31 +409,30 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
 
 	tts_client_s* client = tts_client_get(tts);
 
 	/* check handle */
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
 	/* check state */
 	if (client->current_state != TTS_STATE_CREATED) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		SLOG(LOG_DEBUG, TAG_TTSC, " ");
 		return TTS_ERROR_INVALID_STATE;
 	}
 
-	if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
+	if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
 		client->mode = mode;
 	} else {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		SLOG(LOG_DEBUG, TAG_TTSC, " ");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
@@ -334,8 +451,7 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
 		tts_config_unset_screen_reader_callback(client->uid);
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
@@ -346,14 +462,14 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
 
 	tts_client_s* client = tts_client_get(tts);
 
 	/* check handle */
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		SLOG(LOG_DEBUG, TAG_TTSC, " ");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
@@ -361,7 +477,7 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 	/* check state */
 	if (client->current_state != TTS_STATE_CREATED) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		SLOG(LOG_DEBUG, TAG_TTSC, " ");
 		return TTS_ERROR_INVALID_STATE;
 	}
@@ -373,7 +489,7 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 
 	*mode = client->mode;
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 	SLOG(LOG_DEBUG, TAG_TTSC, " ");
 
 	return TTS_ERROR_NONE;
@@ -381,7 +497,7 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 
 int tts_set_credential(tts_h tts, const char* credential)
 {
-	if(0 != __tts_get_feature_enabled()) {
+	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
@@ -402,13 +518,103 @@ int tts_set_credential(tts_h tts, const char* credential)
 		return TTS_ERROR_INVALID_STATE;
 	}
 
+	if (NULL != client->credential) {
+		free(client->credential);
+		client->credential = NULL;
+	}
 	client->credential = strdup(credential);
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+	return TTS_ERROR_NONE;
+}
+
+//LCOV_EXCL_START
+int tts_set_server_tts(tts_h tts, const char* credential)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	if (NULL != client->credential) {
+		free(client->credential);
+		client->credential = NULL;
+	}
+
+	client->internal = true;
+
+	char* key = NULL;
+	if (NULL != credential) {
+		key = strdup("EnableServerTTS");
+		client->credential = strdup(credential);
+		if (NULL == client->credential) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
+			if (NULL != key) {
+				free(key);
+				key = NULL;
+			}
+			return TTS_ERROR_OUT_OF_MEMORY;
+		}
+	} else {
+		key = strdup("DisableServerTTS");
+	}
+
+	if (NULL == key) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
+		return TTS_ERROR_OUT_OF_MEMORY;
+	}
+
+	int pid = getpid();
+	char* appid = NULL;
+	int ret = app_manager_get_app_id(pid, &appid);
+	if (0 != ret || NULL == appid) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
+		free(key);
+		key = NULL;
+		if (NULL != appid) {
+			free(appid);
+			appid = NULL;
+		}
+		return TTS_ERROR_OPERATION_FAILED;
+	}
+
+	ret = tts_set_private_data(tts, key, appid);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
+		free(key);
+		key = NULL;
+		free(appid);
+		appid = NULL;
+		return ret;
+	}
+
+	free(appid);
+	appid = NULL;
+	free(key);
+	key = NULL;
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
+// LCOV_EXCL_STOP
 
 static Eina_Bool __tts_connect_daemon(void *data)
 {
@@ -426,7 +632,7 @@ static Eina_Bool __tts_connect_daemon(void *data)
 		return EINA_TRUE;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 
 	/* do request initialize */
 	int ret = -1;
@@ -441,7 +647,23 @@ static Eina_Bool __tts_connect_daemon(void *data)
 		client->utt_id = -1;
 
 		ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
-		client->conn_timer = NULL;
+		if (client->conn_timer) {
+			ecore_timer_del(client->conn_timer);
+			client->conn_timer = NULL;
+		}
+		return EINA_FALSE;
+
+	} else if (TTS_ERROR_PERMISSION_DENIED == ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
+
+		client->reason = TTS_ERROR_PERMISSION_DENIED;
+		client->utt_id = -1;
+
+		ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
+		if (client->conn_timer) {
+			ecore_timer_del(client->conn_timer);
+			client->conn_timer = NULL;
+		}
 		return EINA_FALSE;
 
 	} else if (TTS_ERROR_NONE != ret) {
@@ -454,7 +676,10 @@ static Eina_Bool __tts_connect_daemon(void *data)
 		SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 	}
 
-	client->conn_timer = NULL;
+	if (client->conn_timer) {
+		ecore_timer_del(client->conn_timer);
+		client->conn_timer = NULL;
+	}
 
 	client = tts_client_get(tts);
 	/* check handle */
@@ -474,8 +699,7 @@ static Eina_Bool __tts_connect_daemon(void *data)
 		SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return EINA_FALSE;
 }
@@ -486,33 +710,77 @@ int tts_prepare(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 
 	tts_client_s* client = tts_client_get(tts);
 
 	/* check handle */
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
 	/* check state */
 	if (client->current_state != TTS_STATE_CREATED) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_STATE;
 	}
 
-	client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
+	ecore_thread_main_loop_begin();
+	if (client->conn_timer) {
+		ecore_timer_del(client->conn_timer);
+		client->conn_timer = NULL;
+	}
+	client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
+	ecore_thread_main_loop_end();
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	return TTS_ERROR_NONE;
+}
+
+//LCOV_EXCL_START
+int tts_prepare_sync(tts_h tts)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
+
+	tts_client_s* client = tts_client_get(tts);
+
+	/* check handle */
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	/* check state */
+	if (client->current_state != TTS_STATE_CREATED) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	int cnt = 0;
+	while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
+		cnt++;
+	}
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+	if (TTS_CONNECTION_RETRY_COUNT == cnt) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
+		return TTS_ERROR_OPERATION_FAILED;
+	}
 
 	return TTS_ERROR_NONE;
 }
+//LCOV_EXCL_STOP
 
 int tts_unprepare(tts_h tts)
 {
@@ -520,7 +788,7 @@ int tts_unprepare(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
 
 	tts_client_s* client = tts_client_get(tts);
 
@@ -538,11 +806,29 @@ int tts_unprepare(tts_h tts)
 
 	int ret = -1;
 	int count = 0;
+	int screen_reader = -1;
+
+	ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
+	} else {
+		SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
+		g_screen_reader = (bool)screen_reader;
+	}
+
+	bool is_prepared = false;
 	if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
-		while (0 != ret) {
+		do {
 			ret = tts_dbus_request_finalize(client->uid);
 			if (0 != ret) {
-				if (TTS_ERROR_TIMED_OUT != ret) {
+				//LCOV_EXCL_START
+				if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+					client->current_state = TTS_STATE_CREATED;
+					if (0 == tts_prepare_sync(tts)) {
+						is_prepared = true;
+						SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+					}
+				} else if (TTS_ERROR_TIMED_OUT != ret) {
 					SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 					break;
 				} else {
@@ -554,8 +840,9 @@ int tts_unprepare(tts_h tts)
 						break;
 					}
 				}
+				//LCOV_EXCL_STOP
 			}
-		}
+		} while (0 != ret);
 	} else {
 		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 	}
@@ -570,8 +857,7 @@ int tts_unprepare(tts_h tts)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
@@ -602,12 +888,11 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 
 	if (NULL == tts || NULL == callback) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -616,8 +901,7 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
 	/* check handle */
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -634,8 +918,10 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
 
 	ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 
-	if (NULL != current_engine)
+	if (NULL != current_engine) {
 		free(current_engine);
+		current_engine = NULL;
+	}
 
 	client->supported_voice_cb = NULL;
 	client->supported_voice_user_data = NULL;
@@ -645,8 +931,7 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
 		ret = TTS_ERROR_OPERATION_FAILED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return ret;
 }
@@ -657,12 +942,11 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 
 	}
@@ -670,8 +954,7 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -685,8 +968,7 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 		SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return ret;
 }
@@ -714,7 +996,12 @@ int tts_get_max_text_size(tts_h tts, unsigned int* size)
 		return TTS_ERROR_INVALID_STATE;
 	}
 
-	*size = TTS_MAX_TEXT_SIZE;
+	if (0 != tts_config_mgr_get_max_text_size(size)) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	g_max_text_size = (int)*size;
 
 	SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 	return TTS_ERROR_NONE;
@@ -778,7 +1065,7 @@ int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 
 int tts_get_error_message(tts_h tts, char** err_msg)
 {
-	if(0 != __tts_get_feature_enabled()) {
+	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
@@ -798,17 +1085,19 @@ int tts_get_error_message(tts_h tts, char** err_msg)
 		*err_msg = strdup(client->err_msg);
 		SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
 	} else {
+		*err_msg = NULL;
 		SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
 
 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 {
+	SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
+
 	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
@@ -823,12 +1112,11 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
 
 	if (NULL == tts || NULL == utt_id) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -836,8 +1124,7 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -846,17 +1133,33 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 		return TTS_ERROR_INVALID_STATE;
 	}
 
-	if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
-		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
-		return TTS_ERROR_INVALID_PARAMETER;
+	if (-1 == g_max_text_size) {
+		SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
+		if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
+			return TTS_ERROR_INVALID_PARAMETER;
+		}
+	}
+
+	if (0 == g_max_text_size) {
+		if (strlen(text) <= 0) {
+			SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
+			SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+			return TTS_ERROR_INVALID_PARAMETER;
+		}
+	} else {
+		SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
+		if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
+			SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+			return TTS_ERROR_INVALID_PARAMETER;
+		}
 	}
 
 	if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -871,36 +1174,45 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 	}
 
 	/* check valid utf8 */
-	iconv_t *ict;
-	ict = iconv_open("utf-8", "");
-	if ((iconv_t)-1 == ict) {
-		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
-		return TTS_ERROR_OPERATION_FAILED;
+	bool valid = false;
+
+	DBusError err;
+	dbus_error_init(&err);
+
+	valid = dbus_validate_utf8(text, &err);
+	if (dbus_error_is_set(&err)) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
+		dbus_error_free(&err);
+		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
-	size_t len = strlen(text);
-	char *in_tmp = NULL;
-	char in_buf[TTS_MAX_TEXT_SIZE];
-	char *out_tmp = NULL;
-	char out_buf[TTS_MAX_TEXT_SIZE];
-	size_t len_tmp = sizeof(out_buf);
+	if (valid != true) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+	SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
 
-	memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
-	snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
-	in_tmp = in_buf;
+	/* save texts for repetition */
+	if (NULL != client->text_repeat) {
+		free(client->text_repeat);
+		client->text_repeat = NULL;
+	}
 
-	memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
-	out_tmp = out_buf;
+	client->text_repeat = strdup(text);
 
-	size_t st;
-	st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
-	if ((size_t)-1 == st) {
-		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
-		iconv_close(ict);
-		return TTS_ERROR_INVALID_PARAMETER;
+	if (NULL != g_language) {
+		free(g_language);
+		g_language = NULL;
 	}
-	iconv_close(ict);
-	SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
+	if (NULL == language)
+		g_language = NULL;
+	else
+		g_language = strdup(language);
+
+	g_voice_type = voice_type;
+	g_speed = speed;
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] repeat: text(%s), language(%s), voice type(%d), speed(%d)", client->text_repeat, g_language, g_voice_type, g_speed);
 
 	/* change default language value */
 	char* temp = NULL;
@@ -918,34 +1230,46 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 	/* do request */
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
-		ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
+		ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				break;
 			} else {
 				SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
 				usleep(10000);
 				count++;
-				if (TTS_RETRY_COUNT == count) {
+				if (TTS_RETRY_MIN_COUNT == count) {
 					SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 					break;
 				}
 			}
+			//LCOV_EXCL_STOP
 		} else {
 			*utt_id = client->current_utt_id;
 		}
 	}
 
-	if (NULL != temp)	free(temp);
+	if (NULL != temp) {
+		free(temp);
+		temp = NULL;
+	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return ret;
 }
 
+//LCOV_EXCL_START
 static void __tts_play_async(void *data)
 {
 	tts_h tts = (tts_h)data;
@@ -959,10 +1283,17 @@ static void __tts_play_async(void *data)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_play(client->uid, client->credential);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				break;
 			} else {
@@ -997,8 +1328,7 @@ static void __tts_play_async(void *data)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return;
 }
@@ -1009,12 +1339,11 @@ int tts_play_async(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1022,8 +1351,7 @@ int tts_play_async(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1044,24 +1372,22 @@ int tts_play_async(tts_h tts)
 
 	ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
-
+//LCOV_EXCL_STOP
 int tts_play(tts_h tts)
 {
 	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1069,7 +1395,7 @@ int tts_play(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		SLOG(LOG_DEBUG, TAG_TTSC, " ");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
@@ -1091,10 +1417,18 @@ int tts_play(tts_h tts)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_play(client->uid, client->credential);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				return ret;
 			} else {
@@ -1106,6 +1440,7 @@ int tts_play(tts_h tts)
 					return ret;
 				}
 			}
+			//LCOV_EXCL_STOP
 		}
 	}
 
@@ -1119,12 +1454,11 @@ int tts_play(tts_h tts)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
-
+//LCOV_EXCL_START
 static void __tts_stop_async(void *data)
 {
 	tts_h tts = (tts_h)data;
@@ -1138,10 +1472,17 @@ static void __tts_stop_async(void *data)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_stop(client->uid);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				break;
 			} else {
@@ -1176,8 +1517,7 @@ static void __tts_stop_async(void *data)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return;
 }
@@ -1188,12 +1528,11 @@ int tts_stop_aync(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1201,8 +1540,7 @@ int tts_stop_aync(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1218,24 +1556,22 @@ int tts_stop_aync(tts_h tts)
 
 	ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
-
+//LCOV_EXCL_STOP
 int tts_stop(tts_h tts)
 {
 	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1243,8 +1579,7 @@ int tts_stop(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1260,10 +1595,18 @@ int tts_stop(tts_h tts)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_stop(client->uid);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				return ret;
 			} else {
@@ -1275,6 +1618,7 @@ int tts_stop(tts_h tts)
 					return ret;
 				}
 			}
+			//LCOV_EXCL_STOP
 		}
 	}
 
@@ -1288,12 +1632,11 @@ int tts_stop(tts_h tts)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
-
+//LCOV_EXCL_START
 static void __tts_pause_async(void *data)
 {
 	tts_h tts = (tts_h)data;
@@ -1307,10 +1650,17 @@ static void __tts_pause_async(void *data)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_pause(client->uid);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				break;
 			} else {
@@ -1345,8 +1695,7 @@ static void __tts_pause_async(void *data)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return;
 }
@@ -1357,12 +1706,11 @@ int tts_pause_async(tts_h tts)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1370,15 +1718,13 @@ int tts_pause_async(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
 	if (TTS_STATE_PLAYING != client->current_state) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_STATE;
 	}
 
@@ -1389,24 +1735,22 @@ int tts_pause_async(tts_h tts)
 
 	ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
-
+//LCOV_EXCL_STOP
 int tts_pause(tts_h tts)
 {
 	if (0 != __tts_get_feature_enabled()) {
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1414,15 +1758,13 @@ int tts_pause(tts_h tts)
 
 	if (NULL == client) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
 	if (TTS_STATE_PLAYING != client->current_state) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-		SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-		SLOG(LOG_DEBUG, TAG_TTSC, " ");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 		return TTS_ERROR_INVALID_STATE;
 	}
 
@@ -1433,10 +1775,18 @@ int tts_pause(tts_h tts)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_pause(client->uid);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				return ret;
 			} else {
@@ -1448,6 +1798,7 @@ int tts_pause(tts_h tts)
 					return ret;
 				}
 			}
+			//LCOV_EXCL_STOP
 		}
 	}
 
@@ -1461,8 +1812,7 @@ int tts_pause(tts_h tts)
 		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, " ");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return TTS_ERROR_NONE;
 }
@@ -1473,7 +1823,7 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
@@ -1497,12 +1847,25 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
 		return TTS_ERROR_INVALID_STATE;
 	}
 
+	if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_set_private_data(client->uid, key, data);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				return ret;
 			} else {
@@ -1514,11 +1877,11 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
 					return ret;
 				}
 			}
+			//LCOV_EXCL_STOP
 		}
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, "");
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return 0;
 }
@@ -1529,7 +1892,7 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
 		return TTS_ERROR_NOT_SUPPORTED;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
 
 	if (NULL == tts) {
 		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
@@ -1555,10 +1918,18 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
 
 	int ret = -1;
 	int count = 0;
+	bool is_prepared = false;
 	while (0 != ret) {
 		ret = tts_dbus_request_get_private_data(client->uid, key, data);
 		if (0 != ret) {
-			if (TTS_ERROR_TIMED_OUT != ret) {
+			//LCOV_EXCL_START
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
 				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 				return ret;
 			} else {
@@ -1570,15 +1941,21 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
 					return ret;
 				}
 			}
+			//LCOV_EXCL_STOP
 		}
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-	SLOG(LOG_DEBUG, TAG_TTSC, "");
+	if (0 == strncmp(*data, "NULL", strlen(*data))) {
+		free(*data);
+		*data = NULL;
+	}
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
 	return 0;
 }
 
+//LCOV_EXCL_START
 static Eina_Bool __tts_notify_error(void *data)
 {
 	tts_h tts = (tts_h)data;
@@ -1609,34 +1986,80 @@ static Eina_Bool __tts_notify_error(void *data)
 
 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
 {
-	tts_client_s* client = tts_client_get_by_uid(uid);
+	if (-1 == uid) {
+		GList* client_list = NULL;
+		client_list = tts_client_get_client_list();
 
-	if (NULL == client) {
-		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
-		return TTS_ERROR_INVALID_PARAMETER;
-	}
+		GList *iter = NULL;
+		tts_client_s *data = NULL;
 
-	client->utt_id = utt_id;
-	client->reason = reason;
-	if (NULL != client->err_msg) {
-		free(client->err_msg);
-		client->err_msg = NULL;
-	}
-	client->err_msg = strdup(err_msg);
+		if (g_list_length(client_list) > 0) {
+			/* Get a first item */
+			iter = g_list_first(client_list);
 
-	/* call callback function */
-	if (NULL != client->error_cb) {
-		ecore_timer_add(0, __tts_notify_error, client->tts);
+			while (NULL != iter) {
+				data = iter->data;
+
+				data->utt_id = utt_id;
+				data->reason = reason;
+				if (NULL != data->err_msg) {
+					free(data->err_msg);
+					data->err_msg = NULL;
+				}
+				if (NULL != err_msg)
+					data->err_msg = strdup(err_msg);
+
+				/* call callback function */
+				if (NULL != data->error_cb) {
+					ecore_timer_add(0, __tts_notify_error, data->tts);
+				} else {
+					SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
+				}
+
+				if (TTS_ERROR_SERVICE_RESET == reason) {
+					SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
+
+					data->current_state = TTS_STATE_CREATED;
+					if (0 != tts_prepare(data->tts)) {
+						SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
+					}
+				}
+
+				/* Next item */
+				iter = g_list_next(iter);
+			}
+		}
 	} else {
-		SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
-	}
+		tts_client_s* client = tts_client_get_by_uid(uid);
 
-	if (TTS_ERROR_SERVICE_RESET == reason) {
-		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
+		if (NULL == client) {
+			SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
+			return TTS_ERROR_INVALID_PARAMETER;
+		}
 
-		client->current_state = TTS_STATE_CREATED;
-		if (0 != tts_prepare(client->tts)) {
-			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
+		client->utt_id = utt_id;
+		client->reason = reason;
+		if (NULL != client->err_msg) {
+			free(client->err_msg);
+			client->err_msg = NULL;
+		}
+		if (NULL != err_msg)
+			client->err_msg = strdup(err_msg);
+
+		/* call callback function */
+		if (NULL != client->error_cb) {
+			ecore_timer_add(0, __tts_notify_error, client->tts);
+		} else {
+			SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
+		}
+
+		if (TTS_ERROR_SERVICE_RESET == reason) {
+			SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
+
+			client->current_state = TTS_STATE_CREATED;
+			if (0 != tts_prepare(client->tts)) {
+				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
+			}
 		}
 	}
 
@@ -1683,7 +2106,11 @@ int __tts_cb_set_state(int uid, int state)
 	}
 
 	if (NULL != client->state_changed_cb) {
-		ecore_timer_add(0, __tts_notify_state_changed, client->tts);
+		if (NULL != g_check_state_timer) {
+			ecore_timer_del(g_check_state_timer);
+			g_check_state_timer = NULL;
+		}
+		g_check_state_timer = ecore_timer_add(0, __tts_notify_state_changed, client->tts);
 	} else {
 		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 	}
@@ -1693,6 +2120,7 @@ int __tts_cb_set_state(int uid, int state)
 
 	return 0;
 }
+//LCOV_EXCL_STOP
 
 int __tts_cb_utt_started(int uid, int utt_id)
 {
@@ -1703,7 +2131,7 @@ int __tts_cb_utt_started(int uid, int utt_id)
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
+	SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
 
 	client->utt_id = utt_id;
 
@@ -1729,7 +2157,7 @@ int __tts_cb_utt_completed(int uid, int utt_id)
 		return TTS_ERROR_INVALID_PARAMETER;
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
+	SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
 
 	client->utt_id = utt_id;
 
@@ -1772,7 +2200,7 @@ int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* use
 	client->state_changed_cb = callback;
 	client->state_changed_user_data = user_data;
 
-	SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
+	SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
 
 	return 0;
 }
@@ -1803,6 +2231,11 @@ int tts_unset_state_changed_cb(tts_h tts)
 	client->state_changed_cb = NULL;
 	client->state_changed_user_data = NULL;
 
+	if (NULL != g_check_state_timer) {
+		ecore_timer_del(g_check_state_timer);
+		g_check_state_timer = NULL;
+	}
+
 	SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
 
 	return 0;
@@ -2054,3 +2487,372 @@ int tts_unset_default_voice_changed_cb(tts_h tts)
 
 	return 0;
 }
+
+int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	if (NULL == tts || NULL == callback) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_CREATED != client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	client->engine_changed_cb = callback;
+	client->engine_changed_user_data = user_data;
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
+
+	return 0;
+}
+
+int tts_unset_engine_changed_cb(tts_h tts)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_CREATED != client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	client->engine_changed_cb = NULL;
+	client->engine_changed_user_data = NULL;
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
+
+	return 0;
+}
+
+//LCOV_EXCL_START
+int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_CREATED == client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	int ret = -1;
+	int count = 0;
+	bool is_prepared = false;
+	while (0 != ret) {
+		ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
+		if (0 != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
+				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+				return ret;
+			} else {
+				SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
+				usleep(10000);
+				count++;
+				if (TTS_RETRY_COUNT == count) {
+					SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+					return ret;
+				}
+			}
+		}
+	}
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+	return TTS_ERROR_NONE;
+}
+
+int tts_play_pcm(tts_h tts)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	int ret = -1;
+	int count = 0;
+	bool is_prepared = false;
+	while (0 != ret) {
+		ret = tts_dbus_request_play_pcm(client->uid);
+		if (0 != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
+				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+				return ret;
+			} else {
+				SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
+				usleep(10000);
+				count++;
+				if (TTS_RETRY_COUNT == count) {
+					SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+					return ret;
+				}
+			}
+		}
+	}
+
+	client->before_state = client->current_state;
+	client->current_state = TTS_STATE_PLAYING;
+
+	if (NULL != client->state_changed_cb) {
+		tts_client_use_callback(client);
+		client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
+		tts_client_not_use_callback(client);
+		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
+	}
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+	return TTS_ERROR_NONE;
+}
+
+int tts_stop_pcm(tts_h tts)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_CREATED == client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+		SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	int ret = -1;
+	int count = 0;
+	bool is_prepared = false;
+	while (0 != ret) {
+		ret = tts_dbus_request_stop_pcm(client->uid);
+		if (0 != ret) {
+			if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+				client->current_state = TTS_STATE_CREATED;
+				if (0 == tts_prepare_sync(tts)) {
+					is_prepared = true;
+					SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+				}
+			} else if (TTS_ERROR_TIMED_OUT != ret) {
+				SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+				return ret;
+			} else {
+				SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
+				usleep(10000);
+				count++;
+				if (TTS_RETRY_COUNT == count) {
+					SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+					return ret;
+				}
+			}
+		}
+	}
+
+	client->before_state = client->current_state;
+	client->current_state = TTS_STATE_READY;
+
+	if (NULL != client->state_changed_cb) {
+		tts_client_use_callback(client);
+		client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
+		tts_client_not_use_callback(client);
+		SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
+	}
+
+	SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+	return TTS_ERROR_NONE;
+}
+//LCOV_EXCL_STOP
+
+int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
+{
+	if (0 != __tts_get_feature_enabled()) {
+		return TTS_ERROR_NOT_SUPPORTED;
+	}
+
+	SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
+
+	if (NULL == tts) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == text_repeat || NULL == utt_id) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	*text_repeat = NULL;
+	*utt_id = -1;
+
+	tts_client_s* client = tts_client_get(tts);
+
+	if (NULL == client) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+		SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+		return TTS_ERROR_INVALID_PARAMETER;
+	}
+
+	if (TTS_STATE_READY != client->current_state) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
+		return TTS_ERROR_INVALID_STATE;
+	}
+
+	/* Clear the legacy and Add texts to be played repeatedly */
+	int ret = -1;
+	ret = tts_stop(tts);
+	if (TTS_ERROR_NONE != ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
+		return ret;
+	}
+
+	if (NULL != client->text_repeat) {
+		char* tmp_text = strdup(client->text_repeat);
+		char* tmp_lang = NULL;
+		if (NULL != g_language) {
+			tmp_lang = strdup(g_language);
+		}
+		ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
+		if (TTS_ERROR_NONE != ret) {
+			SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
+			if (NULL != tmp_text) {
+				free(tmp_text);
+				tmp_text = NULL;
+			}
+			if (NULL != tmp_lang) {
+				free(tmp_lang);
+				tmp_lang = NULL;
+			}
+			return ret;
+		}
+		*text_repeat = strdup(client->text_repeat);
+		SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
+		if (NULL != tmp_text) {
+			free(tmp_text);
+			tmp_text = NULL;
+		}
+		if (NULL != tmp_lang) {
+			free(tmp_lang);
+			tmp_lang = NULL;
+		}
+	} else {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
+		return TTS_ERROR_OPERATION_FAILED;
+	}
+
+	/* Play added texts */
+	ret = tts_play(tts);
+	if (TTS_ERROR_NONE != ret) {
+		SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
+		if (NULL != *text_repeat) {
+			free(*text_repeat);
+			*text_repeat = NULL;
+		}
+		*utt_id = -1;
+		return ret;
+	}
+
+	return TTS_ERROR_NONE;
+}