X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=server%2Fttsd_player.c;h=54d1ef622fc26d4eca0de7081000388a9966525b;hb=f09e5290b213b4bb7f6f2bdf49188008e363aec6;hp=405d5d75ed3db531ac5245c8681dc8f6b8981bfa;hpb=77b73b49dacbda05924fb1f46075e14acceb79aa;p=platform%2Fcore%2Fuifw%2Ftts.git

diff --git a/server/ttsd_player.c b/server/ttsd_player.c
index 405d5d7..54d1ef6 100644
--- a/server/ttsd_player.c
+++ b/server/ttsd_player.c
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved 
+*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -14,12 +14,16 @@
 #include <audio_io.h>
 #include <Ecore.h>
 #include <sound_manager.h>
+#include <sound_manager_internal.h>
 
 #include "ttsd_main.h"
 #include "ttsd_player.h"
 #include "ttsd_data.h"
 #include "ttsd_dbus.h"
 
+#include "tts_internal.h"
+#include "ttsd_server.h"
+
 /*
 * Internal data structure
 */
@@ -28,21 +32,22 @@ typedef enum {
 	AUDIO_STATE_NONE = 0,
 	AUDIO_STATE_READY,
 	AUDIO_STATE_PLAY
-}audio_state_e;
+} audio_state_e;
 
 typedef struct {
 	int			uid;	/** client id */
-	app_state_e		state;	/** client state */
+	app_tts_state_e		state;	/** client state */
 
 	/* Current utterance information */
-	ttsp_result_event_e	event;	/** event of last utterance */
+	ttse_result_event_e	event;	/** event of last utterance */
 
 	bool			is_paused_data;
 	int			idx;
-	sound_data_s		paused_data;
-}player_s;
+	sound_data_s*		paused_data;
+} player_s;
 
 #define SOUND_BUFFER_LENGTH	2048
+#define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
 
 /** player init info */
 static bool g_player_init = false;
@@ -56,14 +61,17 @@ static player_s* g_playing_info;
 /* player state */
 static audio_state_e g_audio_state;
 
-static ttsp_audio_type_e g_audio_type;
+static ttse_audio_type_e g_audio_type;
 
 static int g_sampling_rate;
 
 static audio_out_h g_audio_h;
 
+static sound_stream_info_h g_stream_info_h;
+
+static int g_focus_watch_id;
 /*
-* Internal Interfaces 
+* Internal Interfaces
 */
 
 player_s* __player_get_item(int uid)
@@ -91,73 +99,145 @@ player_s* __player_get_item(int uid)
 	return NULL;
 }
 
-void __player_audio_io_interrupted_cb(audio_io_interrupted_code_e code, void *user_data)
+void __player_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
+							sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
 {
-	SLOG(LOG_DEBUG, get_tag(), "===== INTERRUPTED CALLBACK");
+	SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
 
-	SLOG(LOG_WARN, get_tag(), "[Player] code : %d", (int)code);
+	if (stream_info != g_stream_info_h) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
+		return;
+	}
+	SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d) and extra info(%s)", (int)focus_state, (int)reason_for_change, extra_info);
 
-	g_audio_state = AUDIO_STATE_READY;
+	if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
+		if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
+			g_audio_state = AUDIO_STATE_READY;
 
-	if (NULL == g_playing_info) {
-		SLOG(LOG_WARN, get_tag(), "[Player WARNING] No current player");
-		return;
+			if (NULL == g_playing_info) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+				return;
+			}
+
+			if (APP_STATE_PLAYING == g_playing_info->state) {
+				int uid = g_playing_info->uid;
+
+				if (0 != ttsd_player_pause(uid)) {
+					SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
+					return;
+				}
+
+				ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
+				int pid = ttsd_data_get_pid(uid);
+				/* send message to client about changing state */
+				ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
+			}
+		} else {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
+		}
+	}
+
+/*	if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
+		if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
+			g_audio_state = AUDIO_STATE_PLAY;
+
+			if (NULL == g_playing_info) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+				return;
+			}
+
+			if (APP_STATE_PAUSED == g_playing_info->state) {
+				int uid = g_playing_info->uid;
+
+				g_audio_state = AUDIO_STATE_PLAY;
+				if (0 != ttsd_player_resume(uid)) {
+					SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
+					g_audio_state = AUDIO_STATE_READY;
+					return;
+				}
+
+				ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
+				int pid = ttsd_data_get_pid(uid);
+				ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
+			}
+
+		} else {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
+		}
 	}
+*/
+	SLOG(LOG_DEBUG, tts_tag(), "@@@");
 
-	if (APP_STATE_PLAYING == g_playing_info->state) {
-		g_playing_info->state = APP_STATE_PAUSED;
+	return;
+}
 
-		ttsd_data_set_client_state(g_playing_info->uid, APP_STATE_PAUSED);
+void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason,
+								const char *extra_info, void *user_data)
+{
+	SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
 
-		int pid = ttsd_data_get_pid(g_playing_info->uid);
+	ttsd_mode_e mode = ttsd_get_mode();
 
-		/* send message to client about changing state */
-		ttsdc_send_set_state_message (pid, g_playing_info->uid, APP_STATE_PAUSED);
+	if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
+		return;
 	}
 
-	SLOG(LOG_DEBUG, get_tag(), "=====");
-	SLOG(LOG_DEBUG, get_tag(), "  ");
+	if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 
+			NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
+		/* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
+		g_audio_state = AUDIO_STATE_READY;
+
+		if (NULL == g_playing_info) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+			return;
+		}
+
+		if (APP_STATE_PLAYING == g_playing_info->state) {
+			int uid = g_playing_info->uid;
+
+			if (0 != ttsd_server_stop(uid)) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
+				return;
+			}
+			if (0 != ttsd_player_stop(uid)) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
+				return;
+			}
+
+			ttsd_data_set_client_state(uid, APP_STATE_READY);
+			int pid = ttsd_data_get_pid(uid);
+			/* send message to client about changing state */
+			ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
+		} else {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] Not playing state");
+		}
+	} else {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] This is not Interrupt mode or not playing state.");
+	}
 
 	return;
 }
 
-static int __create_audio_out(ttsp_audio_type_e type, int rate)
+static int __create_audio_out(ttse_audio_type_e type, int rate)
 {
 	int ret = -1;
 	audio_sample_type_e sample_type;
 
-	if (TTSP_AUDIO_TYPE_RAW_S16 == type) {
+	if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
 		sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
 	} else {
 		sample_type = AUDIO_SAMPLE_TYPE_U8;
 	}
 
-	ret = audio_out_create(rate, AUDIO_CHANNEL_MONO, sample_type, SOUND_TYPE_MEDIA, &g_audio_h);
+	ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
 	if (AUDIO_IO_ERROR_NONE != ret) {
 		g_audio_state = AUDIO_STATE_NONE;
 		g_audio_h = NULL;
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to create audio");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
 		return -1;
 	} else {
-		SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Create audio");
-	}
-
-	if (TTSD_MODE_DEFAULT != ttsd_get_mode()) {
-		ret = audio_out_ignore_session(g_audio_h);
-		if (AUDIO_IO_ERROR_NONE != ret) {
-			g_audio_state = AUDIO_STATE_NONE;
-			g_audio_h = NULL;
-			SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to set ignore session");
-			return -1;
-		}
-	}
-
-	ret = audio_out_set_interrupted_cb(g_audio_h, __player_audio_io_interrupted_cb, NULL);
-	if (AUDIO_IO_ERROR_NONE != ret) {
-		g_audio_state = AUDIO_STATE_NONE;
-		g_audio_h = NULL;
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to set callback function");
-		return -1;
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
 	}
 
 	g_audio_type = type;
@@ -171,19 +251,19 @@ static int __create_audio_out(ttsp_audio_type_e type, int rate)
 static int __destroy_audio_out()
 {
 	if (NULL == g_audio_h) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Current handle is not valid");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
 		return -1;
 	}
 
 	int ret = -1;
 	ret = audio_out_destroy(g_audio_h);
 	if (AUDIO_IO_ERROR_NONE != ret) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to destroy audio");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
 		return -1;
 	} else {
-		SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Destroy audio");
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
 	}
-	
+
 	g_audio_type = 0;
 	g_sampling_rate = 0;
 
@@ -195,123 +275,291 @@ static int __destroy_audio_out()
 
 static void __end_play_thread(void *data, Ecore_Thread *thread)
 {
-	SLOG(LOG_DEBUG, get_tag(), "===== End thread");
+	SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
+}
+
+static void __set_policy_for_playing(int volume)
+{
+	/* Set stream info */
+	int ret;
+	ttsd_mode_e mode = ttsd_get_mode();
+	if (TTSD_MODE_DEFAULT == mode) {
+		ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
+		if (SOUND_MANAGER_ERROR_NONE != ret) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
+		} else {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
+		}
+	} else if (TTSD_MODE_INTERRUPT == mode) {
+		ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
+		if (SOUND_MANAGER_ERROR_NONE != ret) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
+		} else {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
+		}
+	}
+
+	ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
+	if (AUDIO_IO_ERROR_NONE != ret) {
+		SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
+	}
+
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
+
 	return;
 }
 
+static void __unset_policy_for_playing()
+{
+	int ret;
+	ttsd_mode_e mode = ttsd_get_mode();
+	/* Unset stream info */
+	if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
+		sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
+		ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
+		if (SOUND_MANAGER_ERROR_NONE != ret) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
+		}
+
+		if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
+			if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
+				ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
+				SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
+			}
+
+			if (SOUND_MANAGER_ERROR_NONE != ret) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
+			}
+		}
+	}
+
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
+
+	return;
+}
+
+int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
+{
+	int ret;
+	ttsd_mode_e mode = ttsd_get_mode();
+
+	if (TTSD_MODE_INTERRUPT != mode) {
+		/* check the current playback focus */
+		sound_stream_focus_change_reason_e reason;
+		int sound_behavior = 0;
+		char *extra_info = NULL;
+
+		ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
+
+		if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info) {
+			if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
+				SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
+				*is_current_interrupt = true;
+
+				free(extra_info);
+				extra_info = NULL;
+
+				return TTSD_ERROR_NONE;
+			}
+		}
+
+		if (NULL != extra_info) {
+			free(extra_info);
+			extra_info = NULL;
+		}
+	}
+
+	*is_current_interrupt = false;
+
+	return TTSD_ERROR_NONE;
+}
+
 static void __play_thread(void *data, Ecore_Thread *thread)
 {
-	SLOG(LOG_DEBUG, get_tag(), "===== Start thread");
+	SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
 
 	if (NULL == g_playing_info) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] No current player");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
 		return;
 	}
 
 	player_s* player = g_playing_info;
-	sound_data_s wdata;
+	sound_data_s* sound_data = NULL;
 
 	int ret = -1;
 	int len = SOUND_BUFFER_LENGTH;
 	int idx = 0;
 
+	/* set volume policy as 40% */
+	__set_policy_for_playing(40);
 	while (1) {
 		if (true == player->is_paused_data) {
 			/* Resume player */
-			wdata.data = player->paused_data.data;
-			wdata.data_size = player->paused_data.data_size;
-			wdata.utt_id = player->paused_data.utt_id;
-			wdata.audio_type = player->paused_data.audio_type;
-			wdata.rate = player->paused_data.rate;
-			wdata.channels = player->paused_data.channels;
-			wdata.event = player->paused_data.event;
+			sound_data = player->paused_data;
+			player->paused_data = NULL;
 
 			idx = player->idx;
 
 			player->is_paused_data = false;
 			player->idx = 0;
-		} else {
-			if (0 != ttsd_data_get_sound_data(player->uid, &wdata)) {
-				g_playing_info = NULL;
-				SLOG(LOG_DEBUG, get_tag(), "[Player] No sound data. Finish thread");
 
+			if (NULL == sound_data) {
 				/* Request unprepare */
 				ret = audio_out_unprepare(g_audio_h);
 				if (AUDIO_IO_ERROR_NONE != ret) {
-					SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+					SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 				} else {
-					SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio");
+					SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 				}
 
 				g_audio_state = AUDIO_STATE_READY;
+
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
 				return;
 			}
+			SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)", 
+				sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
+		} else {
+			sound_data = NULL;
+			ret = ttsd_data_get_sound_data(player->uid, &sound_data);
+			if (0 != ret || NULL == sound_data) {
+				/* empty queue */
+				SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
+				/* release audio & recover session */
+				ret = audio_out_unprepare(g_audio_h);
+				if (AUDIO_IO_ERROR_NONE != ret) {
+					SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+				} else {
+					SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
+				}
+				g_audio_state = AUDIO_STATE_READY;
+
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
+
+				/* wait for new audio data come */
+				while (1) {
+					usleep(10000);
+					if (NULL == g_playing_info) {
+						/* current playing uid is replaced */
+						SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
+						return;
+					} else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
+						/* new audio data come */
+						SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
+						break;
+					}
+				}
+
+				SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
+
+				/* set volume policy as 40%, when resume play thread*/
+				__set_policy_for_playing(40);
+
+				/* resume play thread */
+				player->state = APP_STATE_PLAYING;
+				continue;
+			}
 
-			/* If wdata's event is 'start', current wdata is first data of engine for synthesis. 
+			/* If wdata's event is 'start', current wdata is first data of engine for synthesis.
 			 * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
-			 * When previous wdata's event is 'finish' and current wdata's event is 'finish', 
-			 * the player should send utt started event. 
+			 * When previous wdata's event is 'finish' and current wdata's event is 'finish',
+			 * the player should send utt started event.
 			 */
-			if (TTSP_RESULT_EVENT_START == wdata.event ||
-			   (TTSP_RESULT_EVENT_FINISH == player->event && TTSP_RESULT_EVENT_FINISH == wdata.event)) {
+			if (TTSE_RESULT_EVENT_START == sound_data->event ||
+			   (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 				int pid = ttsd_data_get_pid(player->uid);
 
 				if (pid <= 0) {
-					SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid");
+					SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
+					/* unset volume policy, volume will be 100% */
+					__unset_policy_for_playing();
+
+					if (NULL != sound_data->data) {
+						free(sound_data->data);
+						sound_data->data = NULL;
+					}
+					free(sound_data);
+					sound_data = NULL;
 					return;
 				}
 
-				if (0 != ttsdc_send_utt_start_message(pid, player->uid, wdata.utt_id)) {
-					SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)", 
-						pid, player->uid, wdata.utt_id);
+				if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
+					SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)", 
+						pid, player->uid, sound_data->utt_id);
 				}
-				SLOG(LOG_DEBUG, get_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, wdata.utt_id);
+				SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 			}
 
 			/* Save last event to check utterance start */
-			player->event = wdata.event;
+			player->event = sound_data->event;
 			idx = 0;
 
-			if (NULL == wdata.data || 0 >= wdata.data_size) {
-				if (TTSP_RESULT_EVENT_FINISH == wdata.event) {
-					SLOG(LOG_DEBUG, get_tag(), "No sound data");
+			if (NULL == sound_data->data || 0 >= sound_data->data_size) {
+				if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
+					SLOG(LOG_DEBUG, tts_tag(), "No sound data");
 					/* send utterence finish signal */
 					int pid = ttsd_data_get_pid(player->uid);
 
 					if (pid <= 0) {
-						SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid");
+						SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
+						/* unset volume policy, volume will be 100% */
+						__unset_policy_for_playing();
+						if (NULL != sound_data->data) {
+							free(sound_data->data);
+							sound_data->data = NULL;
+						}
+						free(sound_data);
+						sound_data = NULL;
 						return;
 					}
-					if (0 != ttsdc_send_utt_finish_message(pid, player->uid, wdata.utt_id)) {
-						SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", pid, player->uid, wdata.utt_id);
+					if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
+						SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", 
+							pid, player->uid, sound_data->utt_id);
 					}
 				}
-				SLOG(LOG_DEBUG, get_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, wdata.utt_id);
+				SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+				if (NULL != sound_data->data) {
+					free(sound_data->data);
+					sound_data->data = NULL;
+				}
+				free(sound_data);
+				sound_data = NULL;
 				continue;
 			}
 		}
 
-		SLOG(LOG_DEBUG, get_tag(), "[Player] Sound info : id(%d) size(%d) audiotype(%d) rate(%d) event(%d)", 
-			wdata.utt_id, wdata.data_size, wdata.audio_type, wdata.rate, wdata.event);
-
-		if (g_sampling_rate != wdata.rate || g_audio_type != wdata.audio_type) {
-			SLOG(LOG_DEBUG, get_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
+		if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
 			if (NULL != g_audio_h) {
 				__destroy_audio_out();
 			}
 
-			if (0 > __create_audio_out(wdata.audio_type, wdata.rate)) {
-				SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to create audio out");
+			if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
+				SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
+
+				if (NULL != sound_data->data) {
+					free(sound_data->data);
+					sound_data->data = NULL;
+				}
+				free(sound_data);
+				sound_data = NULL;
+
 				return;
 			}
+
+			__set_policy_for_playing(40);
 		}
 
 		while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
-			if ((unsigned int)idx >= wdata.data_size)
+			if ((unsigned int)idx >= sound_data->data_size)
 				break;
 
-			if ((unsigned int)idx + SOUND_BUFFER_LENGTH > wdata.data_size) {
-				len = wdata.data_size - idx;
+			if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
+				len = sound_data->data_size - idx;
 			} else {
 				len = SOUND_BUFFER_LENGTH;
 			}
@@ -320,116 +568,213 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 				/* Request prepare */
 				ret = audio_out_prepare(g_audio_h);
 				if (AUDIO_IO_ERROR_NONE != ret) {
-					SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
+					SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
 					g_playing_info = NULL;
+					/* unset volume policy, volume will be 100% */
+					__unset_policy_for_playing();
+
+					if (NULL != sound_data->data) {
+						free(sound_data->data);
+						sound_data->data = NULL;
+					}
+
+					free(sound_data);
+					sound_data = NULL;
+
 					return;
 				}
-				SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Prepare audio");
+				SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
 				g_audio_state = AUDIO_STATE_PLAY;
 			}
 
-			char* temp_data = wdata.data;
+			char* temp_data = sound_data->data;
 			ret = audio_out_write(g_audio_h, &temp_data[idx], len);
 			if (0 > ret) {
-				SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to audio write - %d", ret);
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
 			} else {
 				idx += len;
 			}
 
+			if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
+				SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
+				g_audio_state = AUDIO_STATE_READY;
+				ret = audio_out_unprepare(g_audio_h);
+				if (AUDIO_IO_ERROR_NONE != ret) {
+					SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+				}
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
+
+				if (NULL != sound_data) {
+					if (NULL != sound_data->data) {
+						free(sound_data->data);
+						sound_data->data = NULL;
+					}
+
+					free(sound_data);
+					sound_data = NULL;
+				}
+
+				return;
+			}
+
 			if (APP_STATE_PAUSED == player->state) {
 				/* Save data */
-				player->paused_data.data = wdata.data;
-				player->paused_data.data_size = wdata.data_size;
-				player->paused_data.utt_id = wdata.utt_id;
-				player->paused_data.audio_type = wdata.audio_type;
-				player->paused_data.rate = wdata.rate;
-				player->paused_data.channels = wdata.channels;
-				player->paused_data.event = wdata.event;
+				player->paused_data = sound_data;
 
 				player->is_paused_data = true;
 				player->idx = idx;
 
 				g_audio_state = AUDIO_STATE_READY;
-				SLOG(LOG_DEBUG, get_tag(), "[Player] Stop player thread by pause");
+				SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
 
 				/* Request prepare */
 				ret = audio_out_unprepare(g_audio_h);
 				if (AUDIO_IO_ERROR_NONE != ret) {
-					SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+					SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 				} else {
-					SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio");
+					SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 				}
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
 				return;
 			}
 		}
 
-		if (NULL != wdata.data) {
-			free(wdata.data);
-			wdata.data = NULL;
-		}
-
-		if (APP_STATE_READY == player->state) {
+		if (NULL == g_playing_info && APP_STATE_READY == player->state) {
+			/* player_stop */ 
 			g_audio_state = AUDIO_STATE_READY;
-			SLOG(LOG_DEBUG, get_tag(), "[Player] Stop player thread");
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
 
 			/* Request prepare */
 			ret = audio_out_unprepare(g_audio_h);
 			if (AUDIO_IO_ERROR_NONE != ret) {
-				SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+				SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 			} else {
-				SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio");
+				SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
+			}
+
+			if (NULL != sound_data) {
+				if (NULL != sound_data->data) {
+					free(sound_data->data);
+					sound_data->data = NULL;
+				}
+
+				free(sound_data);
+				sound_data = NULL;
 			}
+			/* unset volume policy, volume will be 100% */
+			__unset_policy_for_playing();
 			return;
 		}
 
-		if (TTSP_RESULT_EVENT_FINISH == wdata.event) {
+		if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
+			(TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 			/* send utterence finish signal */
 			int pid = ttsd_data_get_pid(player->uid);
 
 			if (pid <= 0) {
-				SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid");
+				SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
+				if (NULL != sound_data->data) {
+					free(sound_data->data);
+					sound_data->data = NULL;
+				}
+
+				free(sound_data);
+				sound_data = NULL;
 				return;
 			}
 
-			if (0 != ttsdc_send_utt_finish_message(pid, player->uid, wdata.utt_id)) {
-				SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", 
-					pid, player->uid, wdata.utt_id);
+			if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
+				SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", 
+					pid, player->uid, sound_data->utt_id);
+				/* unset volume policy, volume will be 100% */
+				__unset_policy_for_playing();
+				if (NULL != sound_data->data) {
+					free(sound_data->data);
+					sound_data->data = NULL;
+				}
+
+				free(sound_data);
+				sound_data = NULL;
 				return;
 			}
 
-			SLOG(LOG_DEBUG, get_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, wdata.utt_id);
+			SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+		}
+
+		if (NULL != sound_data) {
+			if (NULL != sound_data->data) {
+				free(sound_data->data);
+				sound_data->data = NULL;
+			}
+
+			free(sound_data);
+			sound_data = NULL;
+		}
+
+		if (NULL == g_playing_info) {
+			SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
+			g_audio_state = AUDIO_STATE_READY;
+			ret = audio_out_unprepare(g_audio_h);
+			if (AUDIO_IO_ERROR_NONE != ret) {
+				SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+			}
+			/* unset volume policy, volume will be 100% */
+			__unset_policy_for_playing();
+
+			return;
 		}
 	}
 }
 
 /*
-* Player Interfaces 
+* Player Interfaces
 */
 int ttsd_player_init()
 {
 	g_playing_info = NULL;
 	g_audio_state = AUDIO_STATE_NONE;
 	g_audio_h = NULL;
-	
+
 	int ret;
 
-	if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
-		ret = sound_manager_set_session_type(SOUND_SESSION_TYPE_MEDIA);
-		if (0 != ret) {
-			SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to set session type");
-		}
-		
-		ret = sound_manager_set_media_session_option(SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START, SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY);
-		if (0 != ret) {
-			SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail set media session option");	
+	ecore_thread_max_set(1);
+
+	int cnt = 0;
+	while (1) {
+		if (0 == access(FOCUS_SERVER_READY, F_OK)) {
+			SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
+			break;
 		} else {
-			SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] set media session option");	
+			if (0 == cnt++ % 10)
+				SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
+			usleep(50000);
 		}
 	}
 
+	ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
+	if (SOUND_MANAGER_ERROR_NONE != ret) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
+		return -1;
+	} else {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
+	}
+
+	/* add sound focus state watch callback */
+	ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
+	if (SOUND_MANAGER_ERROR_NONE != ret) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
+		return -1;
+	} else {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
+	}
+
 	ecore_thread_max_set(1);
-		
-	ret = __create_audio_out(TTSP_AUDIO_TYPE_RAW_S16, 16000);
+
+	ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
 	if (0 != ret)
 		return -1;
 
@@ -441,36 +786,51 @@ int ttsd_player_init()
 int ttsd_player_release(void)
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return TTSD_ERROR_OPERATION_FAILED;
 	}
 
 	int ret;
 
-	ret = __destroy_audio_out();
-	if (0 != ret)
-		return -1;
-
-	SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] ==========================");
-	SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
-	SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] ==========================");
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
 
 	/* The thread should be released */
 	int thread_count = ecore_thread_active_get();
 	int count = 0;
 	while (0 < thread_count) {
-		usleep(10);
+		usleep(10000);
 
 		count++;
-		if (100 == count) {
-			SLOG(LOG_WARN, get_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
+		if (20 == count) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
 			break;
 		}
 
 		thread_count = ecore_thread_active_get();
 	}
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Thread is released");
+	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
+
+	ret = __destroy_audio_out();
+	if (0 != ret)
+		return -1;
+
+	ret = sound_manager_destroy_stream_information(g_stream_info_h);
+	if (SOUND_MANAGER_ERROR_NONE != ret) {
+		SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
+	} else {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
+	}
+
+	/* remove focus state watch callback */
+	ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
+	if (SOUND_MANAGER_ERROR_NONE != ret) {
+		SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
+	} else {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
+	}
 
 	/* clear g_player_list */
 	g_playing_info = NULL;
@@ -482,26 +842,30 @@ int ttsd_player_release(void)
 int ttsd_player_create_instance(int uid)
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
-	
+
 	/* Check uid is duplicated */
 	if (NULL != __player_get_item(uid)) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is already registered", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
 		return -1;
 	}
 
 	player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
+	if (NULL == new_client) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
+		return TTSE_ERROR_OUT_OF_MEMORY;
+	}
 
 	new_client->uid = uid;
-	new_client->event = TTSP_RESULT_EVENT_FINISH;
+	new_client->event = TTSE_RESULT_EVENT_FINISH;
 	new_client->state = APP_STATE_READY;
 	new_client->is_paused_data = false;
 	new_client->idx = 0;
-	new_client->paused_data.data = NULL;
+	new_client->paused_data = NULL;
 	
-	SLOG(LOG_DEBUG, get_tag(), "[Player] Create player : uid(%d)", uid);
+	SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
 
 	g_player_list = g_list_append(g_player_list, new_client);
 
@@ -511,14 +875,14 @@ int ttsd_player_create_instance(int uid)
 int ttsd_player_destroy_instance(int uid)
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
 	player_s* current;
 	current = __player_get_item(uid);
 	if (NULL == current) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 		return -1;
 	}
 
@@ -542,18 +906,19 @@ int ttsd_player_destroy_instance(int uid)
 			if (NULL != data) {
 				/* compare uid */
 				if (uid == data->uid) {
-					g_player_list = g_list_remove_link(g_player_list, iter);				
+					g_player_list = g_list_remove_link(g_player_list, iter);
 					free(data);
+					g_list_free(iter);		
 					break;
 				}
 			}
-				
+
 			/* Get next item */
 			iter = g_list_next(iter);
 		}
 	}
 
-	SLOG(LOG_DEBUG, get_tag(), "[PLAYER Success] Destroy instance");
+	SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
 
 	return 0;
 }
@@ -561,22 +926,25 @@ int ttsd_player_destroy_instance(int uid)
 int ttsd_player_play(int uid)
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
 	if (NULL != g_playing_info) {
 		if (uid == g_playing_info->uid) {
-			SLOG(LOG_DEBUG, get_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
 			return 0;
+		} else {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
+			ttsd_player_stop(g_playing_info->uid);
 		}
 	}
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player] start play : uid(%d)", uid );
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
 
 	/* Check sound queue size */
 	if (0 == ttsd_data_get_sound_data_size(uid)) {
-		SLOG(LOG_WARN, get_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid); 
+		SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
 		return -1;
 	}
 
@@ -584,18 +952,18 @@ int ttsd_player_play(int uid)
 	player_s* current;
 	current = __player_get_item(uid);
 	if (NULL == current) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 		return -1;
 	}
 
 	current->state = APP_STATE_PLAYING;
-	
+
 	g_playing_info = current;
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
+	SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
 
 	if (0 < ttsd_data_get_sound_data_size(current->uid)) {
-		SLOG(LOG_DEBUG, get_tag(), "[Player] Run thread");
+		SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
 		ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
 	}
 
@@ -605,7 +973,7 @@ int ttsd_player_play(int uid)
 int ttsd_player_stop(int uid)
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized");
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
@@ -613,7 +981,7 @@ int ttsd_player_stop(int uid)
 	player_s* current;
 	current = __player_get_item(uid);
 	if (NULL == current) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 		return -1;
 	}
 
@@ -624,32 +992,99 @@ int ttsd_player_stop(int uid)
 			g_playing_info = NULL;
 		}
 	} else {
-		SLOG(LOG_DEBUG, get_tag(), "[Player] No current playing"); 
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
+	}
+
+	if (true == current->is_paused_data) {
+		if (NULL != current->paused_data) {
+			if (NULL != current->paused_data->data) {
+				free(current->paused_data->data);
+				current->paused_data->data = NULL;
+			}
+
+			free(current->paused_data);
+			current->paused_data = NULL;
+		}
+	}
+
+	current->event = TTSE_RESULT_EVENT_FINISH;
+	current->state = APP_STATE_READY;
+	current->is_paused_data = false;
+	current->idx = 0;
+
+	if (NULL == g_playing_info) {
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+		SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+
+		/* The thread should be released */
+		int thread_count = ecore_thread_active_get();
+		int count = 0;
+		while (0 < thread_count) {
+			usleep(10000);
+
+			count++;
+			if (30 == count) {
+				SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
+				break;
+			}
+
+			thread_count = ecore_thread_active_get();
+		}
+
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+		SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+		SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+	}
+
+	SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
+
+	return 0;
+}
+
+int ttsd_player_clear(int uid)
+{
+	if (false == g_player_init) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
+		return -1;
+	}
+
+	/* Check uid */
+	player_s* current;
+	current = __player_get_item(uid);
+	if (NULL == current) {
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
+		return -1;
 	}
 
 	if (true == current->is_paused_data) {
-		if (NULL != current->paused_data.data) {
-			free(current->paused_data.data);
-			current->paused_data.data = NULL;
+		if (NULL != current->paused_data) {
+			if (NULL != current->paused_data->data) {
+				free(current->paused_data->data);
+				current->paused_data->data = NULL;
+			}
+
+			free(current->paused_data);
+			current->paused_data = NULL;
 		}
 	}
 
-	current->event = TTSP_RESULT_EVENT_FINISH;
+	current->event = TTSE_RESULT_EVENT_FINISH;
 	current->state = APP_STATE_READY;
 	current->is_paused_data = false;
 	current->idx = 0;
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
+	SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
 
 	return 0;
 }
 
 int ttsd_player_pause(int uid)
 {
-	SLOG(LOG_DEBUG, get_tag(), "[Player] pause player : uid(%d)", uid );
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
 
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
@@ -657,7 +1092,7 @@ int ttsd_player_pause(int uid)
 	player_s* current;
 	current = __player_get_item(uid);
 	if (NULL == current) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
 		return -1;
 	}
 
@@ -673,15 +1108,40 @@ int ttsd_player_pause(int uid)
 
 	current->state = APP_STATE_PAUSED;
 
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+	SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+
+	/* The thread should be released */
+	int thread_count = ecore_thread_active_get();
+	int count = 0;
+	while (0 < thread_count) {
+		usleep(10000);
+
+		count++;
+		if (30 == count) {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
+			break;
+		}
+
+		thread_count = ecore_thread_active_get();
+	}
+
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+	SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+
+	SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
+
 	return 0;
 }
 
 int ttsd_player_resume(int uid)
 {
-	SLOG(LOG_DEBUG, get_tag(), "[Player] Resume player : uid(%d)", uid );
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
 
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
@@ -689,7 +1149,7 @@ int ttsd_player_resume(int uid)
 	player_s* current;
 	current = __player_get_item(uid);
 	if (NULL == current) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 		return -1;
 	}
 
@@ -700,7 +1160,7 @@ int ttsd_player_resume(int uid)
 	current->state = APP_STATE_PLAYING;
 	g_playing_info = current;
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player] Run thread");
+	SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
 	ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
 
 	return 0;
@@ -709,7 +1169,7 @@ int ttsd_player_resume(int uid)
 int ttsd_player_all_stop()
 {
 	if (false == g_player_init) {
-		SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized" );
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 		return -1;
 	}
 
@@ -726,35 +1186,87 @@ int ttsd_player_all_stop()
 			/* Get handle data from list */
 			data = (player_s*)iter->data;
 
-			app_state_e state;
+			app_tts_state_e state;
 			if (0 > ttsd_data_get_client_state(data->uid, &state)) {
-				SLOG(LOG_ERROR, get_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
+				SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
 				ttsd_player_destroy_instance(data->uid);
 				iter = g_list_next(iter);
 				continue;
 			}
 
 			if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
-				data->event = TTSP_RESULT_EVENT_FINISH;
+				data->event = TTSE_RESULT_EVENT_FINISH;
 				data->state = APP_STATE_READY;
 
 				if (true == data->is_paused_data) {
-					if (NULL != data->paused_data.data) {
-						free(data->paused_data.data);
-						data->paused_data.data = NULL;
+					if (NULL != data->paused_data) {
+						if (NULL != data->paused_data->data) {
+							free(data->paused_data->data);
+							data->paused_data->data = NULL;
+						}
+
+						free(data->paused_data);
+						data->paused_data = NULL;
 					}
 				}
-				
+
 				data->is_paused_data = false;
 				data->idx = 0;
 			}
-			
+
 			/* Get next item */
 			iter = g_list_next(iter);
 		}
 	}
 
-	SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] player all stop!!");
+	SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
 
 	return 0;
 }
+
+int ttsd_player_play_pcm(int uid)
+{
+	if (false == g_player_init) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
+		return -1;
+	}
+
+	if (NULL != g_playing_info) {
+		if (uid == g_playing_info->uid) {
+			SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
+			return 0;
+		} else {
+			SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
+			ttsd_player_stop(g_playing_info->uid);
+		}
+	}
+
+	SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
+
+	/* Check sound queue size */
+	if (0 == ttsd_data_get_sound_data_size(uid)) {
+		SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
+	}
+
+	/* Check uid */
+	player_s* current;
+	current = __player_get_item(uid);
+	if (NULL == current) {
+		SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+		return -1;
+	}
+
+	current->state = APP_STATE_PLAYING;
+
+	g_playing_info = current;
+
+	SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
+
+	if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
+		SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
+		ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
+	}
+
+	return 0;
+}
+