Fix calling set_policy for getting sound focus
[platform/core/uifw/tts.git] / server / ttsd_player.c
1 /*
2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 *  Licensed under the Apache License, Version 2.0 (the "License");
4 *  you may not use this file except in compliance with the License.
5 *  You may obtain a copy of the License at
6 *  http://www.apache.org/licenses/LICENSE-2.0
7 *  Unless required by applicable law or agreed to in writing, software
8 *  distributed under the License is distributed on an "AS IS" BASIS,
9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 *  See the License for the specific language governing permissions and
11 *  limitations under the License.
12 */
13
14 #include <audio_io.h>
15 #include <Ecore.h>
16 #include <sound_manager.h>
17 #include <sound_manager_internal.h>
18
19 #include "ttsd_main.h"
20 #include "ttsd_player.h"
21 #include "ttsd_data.h"
22 #include "ttsd_dbus.h"
23
24 #include "tts_internal.h"
25 #include "ttsd_server.h"
26
27 /*
28 * Internal data structure
29 */
30
31 typedef enum {
32         AUDIO_STATE_NONE = 0,
33         AUDIO_STATE_READY,
34         AUDIO_STATE_PLAY
35 } audio_state_e;
36
37 typedef struct {
38         int                     uid;    /** client id */
39         app_tts_state_e         state;  /** client state */
40
41         /* Current utterance information */
42         ttse_result_event_e     event;  /** event of last utterance */
43
44         bool                    is_paused_data;
45         int                     idx;
46         sound_data_s*           paused_data;
47 } player_s;
48
49 #define SOUND_BUFFER_LENGTH     2048
50 #define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
51
52 /** player init info */
53 static bool g_player_init = false;
54
55 /** Client list */
56 static GList *g_player_list;
57
58 /** current player information */
59 static player_s* g_playing_info;
60
61 /* player state */
62 static audio_state_e g_audio_state;
63
64 static ttse_audio_type_e g_audio_type;
65
66 static int g_sampling_rate;
67
68 static audio_out_h g_audio_h;
69
70 static sound_stream_info_h g_stream_info_h;
71
72 static int g_focus_watch_id;
73 /*
74 * Internal Interfaces
75 */
76
77 player_s* __player_get_item(int uid)
78 {
79         GList *iter = NULL;
80         player_s *data = NULL;
81
82         if (0 < g_list_length(g_player_list)) {
83                 /* Get a first item */
84                 iter = g_list_first(g_player_list);
85
86                 while (NULL != iter) {
87                         /* Get handle data from list */
88                         data = (player_s*)iter->data;
89
90                         /* compare uid */
91                         if (uid == data->uid)
92                                 return data;
93
94                         /* Get next item */
95                         iter = g_list_next(iter);
96                 }
97         }
98
99         return NULL;
100 }
101
102 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,
103                                                         sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
104 {
105         SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
106
107         if (stream_info != g_stream_info_h) {
108                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
109                 return;
110         }
111         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);
112
113         if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
114                 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
115                         g_audio_state = AUDIO_STATE_READY;
116
117                         if (NULL == g_playing_info) {
118                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
119                                 return;
120                         }
121
122                         if (APP_STATE_PLAYING == g_playing_info->state) {
123                                 int uid = g_playing_info->uid;
124
125                                 if (0 != ttsd_player_pause(uid)) {
126                                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
127                                         return;
128                                 }
129
130                                 ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
131                                 int pid = ttsd_data_get_pid(uid);
132                                 /* send message to client about changing state */
133                                 ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
134                         }
135                 } else {
136                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
137                 }
138         }
139
140 /*      if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
141                 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
142                         g_audio_state = AUDIO_STATE_PLAY;
143
144                         if (NULL == g_playing_info) {
145                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
146                                 return;
147                         }
148
149                         if (APP_STATE_PAUSED == g_playing_info->state) {
150                                 int uid = g_playing_info->uid;
151
152                                 g_audio_state = AUDIO_STATE_PLAY;
153                                 if (0 != ttsd_player_resume(uid)) {
154                                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
155                                         g_audio_state = AUDIO_STATE_READY;
156                                         return;
157                                 }
158
159                                 ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
160                                 int pid = ttsd_data_get_pid(uid);
161                                 ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
162                         }
163
164                 } else {
165                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
166                 }
167         }
168 */
169         SLOG(LOG_DEBUG, tts_tag(), "@@@");
170
171         return;
172 }
173
174 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,
175                                                                 const char *extra_info, void *user_data)
176 {
177         SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
178
179         ttsd_mode_e mode = ttsd_get_mode();
180
181         if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
182                 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
183                 return;
184         }
185
186         if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 
187                         NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
188                 /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
189                 g_audio_state = AUDIO_STATE_READY;
190
191                 if (NULL == g_playing_info) {
192                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
193                         return;
194                 }
195
196                 if (APP_STATE_PLAYING == g_playing_info->state) {
197                         int uid = g_playing_info->uid;
198
199                         if (0 != ttsd_server_stop(uid)) {
200                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
201                                 return;
202                         }
203                         if (0 != ttsd_player_stop(uid)) {
204                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
205                                 return;
206                         }
207
208                         ttsd_data_set_client_state(uid, APP_STATE_READY);
209                         int pid = ttsd_data_get_pid(uid);
210                         /* send message to client about changing state */
211                         ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
212                 } else {
213                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Not playing state");
214                 }
215         } else {
216                 SLOG(LOG_DEBUG, tts_tag(), "[Player] This is not Interrupt mode or not playing state.");
217         }
218
219         return;
220 }
221
222 static int __create_audio_out(ttse_audio_type_e type, int rate)
223 {
224         int ret = -1;
225         audio_sample_type_e sample_type;
226
227         if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
228                 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
229         } else {
230                 sample_type = AUDIO_SAMPLE_TYPE_U8;
231         }
232
233         ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
234         if (AUDIO_IO_ERROR_NONE != ret) {
235                 g_audio_state = AUDIO_STATE_NONE;
236                 g_audio_h = NULL;
237                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
238                 return -1;
239         } else {
240                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
241         }
242
243         g_audio_type = type;
244         g_sampling_rate = rate;
245
246         g_audio_state = AUDIO_STATE_READY;
247
248         return 0;
249 }
250
251 static int __destroy_audio_out()
252 {
253         if (NULL == g_audio_h) {
254                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
255                 return -1;
256         }
257
258         int ret = -1;
259         ret = audio_out_destroy(g_audio_h);
260         if (AUDIO_IO_ERROR_NONE != ret) {
261                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
262                 return -1;
263         } else {
264                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
265         }
266
267         g_audio_type = 0;
268         g_sampling_rate = 0;
269
270         g_audio_state = AUDIO_STATE_NONE;
271         g_audio_h = NULL;
272
273         return 0;
274 }
275
276 static void __end_play_thread(void *data, Ecore_Thread *thread)
277 {
278         SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
279 }
280
281 static void __set_policy_for_playing(int volume)
282 {
283         /* Set stream info */
284         int ret;
285         ttsd_mode_e mode = ttsd_get_mode();
286         if (TTSD_MODE_DEFAULT == mode) {
287                 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
288                 if (SOUND_MANAGER_ERROR_NONE != ret) {
289                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
290                 } else {
291                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
292                 }
293         } else if (TTSD_MODE_INTERRUPT == mode) {
294                 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
295                 if (SOUND_MANAGER_ERROR_NONE != ret) {
296                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
297                 } else {
298                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
299                 }
300         }
301
302         ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
303         if (AUDIO_IO_ERROR_NONE != ret) {
304                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
305         }
306
307         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
308
309         return;
310 }
311
312 static void __unset_policy_for_playing()
313 {
314         int ret;
315         ttsd_mode_e mode = ttsd_get_mode();
316         /* Unset stream info */
317         if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
318                 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
319                 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
320                 if (SOUND_MANAGER_ERROR_NONE != ret) {
321                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
322                 }
323
324                 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
325                         if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
326                                 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
327                                 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
328                         }
329
330                         if (SOUND_MANAGER_ERROR_NONE != ret) {
331                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
332                         }
333                 }
334         }
335
336         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
337
338         return;
339 }
340
341 int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
342 {
343         int ret;
344         ttsd_mode_e mode = ttsd_get_mode();
345
346         if (TTSD_MODE_INTERRUPT != mode) {
347                 /* check the current playback focus */
348                 sound_stream_focus_change_reason_e reason;
349                 int sound_behavior = 0;
350                 char *extra_info = NULL;
351
352                 ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
353
354                 SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior);
355
356                 if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) {
357                         if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
358                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
359                                 *is_current_interrupt = true;
360
361                                 free(extra_info);
362                                 extra_info = NULL;
363
364                                 return TTSD_ERROR_NONE;
365                         }
366                 }
367
368                 if (NULL != extra_info) {
369                         free(extra_info);
370                         extra_info = NULL;
371                 }
372         }
373
374         *is_current_interrupt = false;
375
376         return TTSD_ERROR_NONE;
377 }
378
379 static void __play_thread(void *data, Ecore_Thread *thread)
380 {
381         SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
382
383         if (NULL == g_playing_info) {
384                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
385                 return;
386         }
387
388         player_s* player = g_playing_info;
389         sound_data_s* sound_data = NULL;
390
391         int ret = -1;
392         int len = SOUND_BUFFER_LENGTH;
393         int idx = 0;
394
395         /* set volume policy as 40% */
396         __set_policy_for_playing(40);
397         while (1) {
398                 if (true == player->is_paused_data) {
399                         /* Resume player */
400                         sound_data = player->paused_data;
401                         player->paused_data = NULL;
402
403                         idx = player->idx;
404
405                         player->is_paused_data = false;
406                         player->idx = 0;
407
408                         if (NULL == sound_data) {
409                                 /* Request unprepare */
410                                 ret = audio_out_unprepare(g_audio_h);
411                                 if (AUDIO_IO_ERROR_NONE != ret) {
412                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
413                                 } else {
414                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
415                                 }
416
417                                 g_audio_state = AUDIO_STATE_READY;
418
419                                 /* unset volume policy, volume will be 100% */
420                                 __unset_policy_for_playing();
421                                 return;
422                         }
423                         SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)", 
424                                 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
425                 } else {
426                         sound_data = NULL;
427                         ret = ttsd_data_get_sound_data(player->uid, &sound_data);
428                         if (0 != ret || NULL == sound_data) {
429                                 /* empty queue */
430                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
431
432                                 /* wait for new audio data come */
433                                 while (1) {
434                                         usleep(10000);
435                                         if (NULL == g_playing_info) {
436                                                 /* current playing uid is replaced */
437                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
438                                                 if (AUDIO_STATE_PLAY == g_audio_state) {
439                                                         /* release audio & recover session */
440                                                         ret = audio_out_unprepare(g_audio_h);
441                                                         if (AUDIO_IO_ERROR_NONE != ret) {
442                                                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
443                                                         } else {
444                                                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
445                                                         }
446                                                         g_audio_state = AUDIO_STATE_READY;
447                                                 }
448                                                 /* unset volume policy, volume will be 100% */
449                                                 __unset_policy_for_playing();
450                                                 return;
451                                         } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
452                                                 /* new audio data come */
453                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
454                                                 break;
455                                         }
456
457                                         /* If engine is not on processing */
458                                         if (TTSD_SYNTHESIS_CONTROL_DOING != ttsd_get_synth_control()) {
459                                                 if (AUDIO_STATE_PLAY == g_audio_state) {
460                                                         /* release audio & recover session */
461                                                         ret = audio_out_unprepare(g_audio_h);
462                                                         if (AUDIO_IO_ERROR_NONE != ret) {
463                                                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
464                                                         } else {
465                                                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
466                                                         }
467                                                         g_audio_state = AUDIO_STATE_READY;
468
469                                                         /* unset volume policy, volume will be 100% */
470                                                         __unset_policy_for_playing();
471                                                 }
472                                         }
473                                 }
474
475                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
476
477                                 if (AUDIO_STATE_READY == g_audio_state) {
478                                         /* set volume policy as 40%, when resume play thread*/
479                                         __set_policy_for_playing(40);
480                                 }
481
482                                 /* resume play thread */
483                                 player->state = APP_STATE_PLAYING;
484                                 continue;
485                         }
486
487                         /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
488                          * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
489                          * When previous wdata's event is 'finish' and current wdata's event is 'finish',
490                          * the player should send utt started event.
491                          */
492                         if (TTSE_RESULT_EVENT_START == sound_data->event ||
493                            (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
494                                 int pid = ttsd_data_get_pid(player->uid);
495
496                                 if (pid <= 0) {
497                                         SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
498                                         /* unset volume policy, volume will be 100% */
499                                         __unset_policy_for_playing();
500
501                                         return;
502                                 }
503
504                                 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
505                                         SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)", 
506                                                 pid, player->uid, sound_data->utt_id);
507                                 }
508                                 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
509                         }
510
511                         /* Save last event to check utterance start */
512                         player->event = sound_data->event;
513                         idx = 0;
514
515                         if (NULL == sound_data->data || 0 >= sound_data->data_size) {
516                                 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
517                                         SLOG(LOG_DEBUG, tts_tag(), "No sound data");
518                                         /* send utterence finish signal */
519                                         int pid = ttsd_data_get_pid(player->uid);
520
521                                         if (pid <= 0) {
522                                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
523                                                 /* unset volume policy, volume will be 100% */
524                                                 __unset_policy_for_playing();
525                                                 return;
526                                         }
527                                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
528                                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", 
529                                                         pid, player->uid, sound_data->utt_id);
530                                         }
531                                 }
532                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
533                                 ttsd_data_clear_sound_data(player->uid, &sound_data);
534                                 continue;
535                         }
536                 }
537
538                 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
539                         SLOG(LOG_INFO, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
540                         if (NULL != g_audio_h) {
541                                 __destroy_audio_out();
542                         }
543
544                         if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
545                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
546                                 /* unset volume policy, volume will be 100% */
547                                 __unset_policy_for_playing();
548
549                                 ttsd_data_clear_sound_data(player->uid, &sound_data);
550
551                                 return;
552                         }
553                 }
554
555                 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
556                         if ((unsigned int)idx >= sound_data->data_size)
557                                 break;
558
559                         if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
560                                 len = sound_data->data_size - idx;
561                         } else {
562                                 len = SOUND_BUFFER_LENGTH;
563                         }
564
565                         if (AUDIO_STATE_READY == g_audio_state) {
566                                 /* Request prepare */
567                                 ret = audio_out_prepare(g_audio_h);
568                                 if (AUDIO_IO_ERROR_NONE != ret) {
569                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
570                                         g_playing_info = NULL;
571                                         /* unset volume policy, volume will be 100% */
572                                         __unset_policy_for_playing();
573
574                                         ttsd_data_clear_sound_data(player->uid, &sound_data);
575
576                                         return;
577                                 }
578                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
579                                 g_audio_state = AUDIO_STATE_PLAY;
580                         }
581
582                         char* temp_data = sound_data->data;
583                         SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)",
584                                         temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len);
585                         ret = audio_out_write(g_audio_h, &temp_data[idx], len);
586                         if (0 > ret) {
587                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
588                         } else {
589                                 idx += len;
590                                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] After audio_out_write");
591                         }
592
593                         if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
594                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
595                                 g_audio_state = AUDIO_STATE_READY;
596                                 ret = audio_out_unprepare(g_audio_h);
597                                 if (AUDIO_IO_ERROR_NONE != ret) {
598                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
599                                 }
600                                 /* unset volume policy, volume will be 100% */
601                                 __unset_policy_for_playing();
602
603                                 ttsd_data_clear_sound_data(player->uid, &sound_data);
604
605                                 return;
606                         }
607
608                         if (APP_STATE_PAUSED == player->state) {
609                                 /* Save data */
610                                 player->paused_data = sound_data;
611
612                                 player->is_paused_data = true;
613                                 player->idx = idx;
614
615                                 g_audio_state = AUDIO_STATE_READY;
616                                 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
617
618                                 /* Request prepare */
619                                 ret = audio_out_unprepare(g_audio_h);
620                                 if (AUDIO_IO_ERROR_NONE != ret) {
621                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
622                                 } else {
623                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
624                                 }
625                                 /* unset volume policy, volume will be 100% */
626                                 __unset_policy_for_playing();
627                                 return;
628                         }
629                 }
630
631                 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
632                         /* player_stop */ 
633                         g_audio_state = AUDIO_STATE_READY;
634                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
635
636                         /* Request prepare */
637                         ret = audio_out_unprepare(g_audio_h);
638                         if (AUDIO_IO_ERROR_NONE != ret) {
639                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
640                         } else {
641                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
642                         }
643
644                         ttsd_data_clear_sound_data(player->uid, &sound_data);
645                         /* unset volume policy, volume will be 100% */
646                         __unset_policy_for_playing();
647                         return;
648                 }
649
650                 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
651                         (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
652                         /* send utterence finish signal */
653                         int pid = ttsd_data_get_pid(player->uid);
654
655                         if (pid <= 0) {
656                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
657                                 /* unset volume policy, volume will be 100% */
658                                 __unset_policy_for_playing();
659
660                                 return;
661                         }
662
663                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
664                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", 
665                                         pid, player->uid, sound_data->utt_id);
666                                 /* unset volume policy, volume will be 100% */
667                                 __unset_policy_for_playing();
668
669                                 ttsd_data_clear_sound_data(player->uid, &sound_data);
670                                 return;
671                         }
672
673                         SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
674                 }
675
676                 ttsd_data_clear_sound_data(player->uid, &sound_data);
677
678                 if (NULL == g_playing_info) {
679                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
680                         g_audio_state = AUDIO_STATE_READY;
681                         ret = audio_out_unprepare(g_audio_h);
682                         if (AUDIO_IO_ERROR_NONE != ret) {
683                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
684                         }
685                         /* unset volume policy, volume will be 100% */
686                         __unset_policy_for_playing();
687
688                         return;
689                 }
690         }
691 }
692
693 /*
694 * Player Interfaces
695 */
696 int ttsd_player_init()
697 {
698         g_playing_info = NULL;
699         g_audio_state = AUDIO_STATE_NONE;
700         g_audio_h = NULL;
701
702         int ret;
703
704         ecore_thread_max_set(1);
705
706         int cnt = 0;
707         while (1) {
708                 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
709                         SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
710                         break;
711                 } else {
712                         if (0 == cnt++ % 10)
713                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
714                         usleep(50000);
715                 }
716         }
717
718         ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
719         if (SOUND_MANAGER_ERROR_NONE != ret) {
720                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
721                 return -1;
722         } else {
723                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
724         }
725
726         /* add sound focus state watch callback */
727         ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
728         if (SOUND_MANAGER_ERROR_NONE != ret) {
729                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
730                 sound_manager_destroy_stream_information(g_stream_info_h);
731                 return -1;
732         } else {
733                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
734         }
735
736         ecore_thread_max_set(1);
737
738         ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
739         if (0 != ret) {
740                 sound_manager_destroy_stream_information(g_stream_info_h);
741                 sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
742                 return -1;
743         }
744
745         g_player_init = true;
746
747         return 0;
748 }
749
750 int ttsd_player_release(void)
751 {
752         if (false == g_player_init) {
753                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
754                 return TTSD_ERROR_OPERATION_FAILED;
755         }
756
757         int ret;
758
759         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
760         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
761         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
762
763         /* The thread should be released */
764         int thread_count = ecore_thread_active_get();
765         int count = 0;
766         while (0 < thread_count) {
767                 usleep(10000);
768
769                 count++;
770                 if (20 == count) {
771                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
772                         break;
773                 }
774
775                 thread_count = ecore_thread_active_get();
776         }
777
778         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
779
780         ret = __destroy_audio_out();
781         if (0 != ret)
782                 return -1;
783
784         ret = sound_manager_destroy_stream_information(g_stream_info_h);
785         if (SOUND_MANAGER_ERROR_NONE != ret) {
786                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
787         } else {
788                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
789         }
790
791         /* remove focus state watch callback */
792         ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
793         if (SOUND_MANAGER_ERROR_NONE != ret) {
794                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
795         } else {
796                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
797         }
798
799         /* clear g_player_list */
800         g_playing_info = NULL;
801         g_player_init = false;
802
803         return 0;
804 }
805
806 int ttsd_player_create_instance(int uid)
807 {
808         if (false == g_player_init) {
809                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
810                 return -1;
811         }
812
813         /* Check uid is duplicated */
814         if (NULL != __player_get_item(uid)) {
815                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
816                 return -1;
817         }
818
819         player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
820         if (NULL == new_client) {
821                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
822                 return TTSE_ERROR_OUT_OF_MEMORY;
823         }
824
825         new_client->uid = uid;
826         new_client->event = TTSE_RESULT_EVENT_FINISH;
827         new_client->state = APP_STATE_READY;
828         new_client->is_paused_data = false;
829         new_client->idx = 0;
830         new_client->paused_data = NULL;
831         
832         SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
833
834         g_player_list = g_list_append(g_player_list, new_client);
835
836         return 0;
837 }
838
839 int ttsd_player_destroy_instance(int uid)
840 {
841         if (false == g_player_init) {
842                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
843                 return -1;
844         }
845
846         player_s* current;
847         current = __player_get_item(uid);
848         if (NULL == current) {
849                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
850                 return -1;
851         }
852
853         if (NULL != g_playing_info) {
854                 if (uid == g_playing_info->uid) {
855                         g_playing_info = NULL;
856                 }
857         }
858
859         GList *iter = NULL;
860         player_s *data = NULL;
861
862         if (0 < g_list_length(g_player_list)) {
863                 /* Get a first item */
864                 iter = g_list_first(g_player_list);
865
866                 while (NULL != iter) {
867                         /* Get handle data from list */
868                         data = (player_s*)iter->data;
869
870                         if (NULL != data) {
871                                 /* compare uid */
872                                 if (uid == data->uid) {
873                                         g_player_list = g_list_remove_link(g_player_list, iter);
874                                         free(data);
875                                         g_list_free(iter);              
876                                         break;
877                                 }
878                         }
879
880                         /* Get next item */
881                         iter = g_list_next(iter);
882                 }
883         }
884
885         SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
886
887         return 0;
888 }
889
890 int ttsd_player_play(int uid)
891 {
892         if (false == g_player_init) {
893                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
894                 return -1;
895         }
896
897         if (NULL != g_playing_info) {
898                 if (uid == g_playing_info->uid) {
899                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
900                         return 0;
901                 } else {
902                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
903                         ttsd_player_stop(g_playing_info->uid);
904                 }
905         }
906
907         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
908
909         /* Check sound queue size */
910         if (0 == ttsd_data_get_sound_data_size(uid)) {
911                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
912                 return -1;
913         }
914
915         /* Check uid */
916         player_s* current;
917         current = __player_get_item(uid);
918         if (NULL == current) {
919                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
920                 return -1;
921         }
922
923         current->state = APP_STATE_PLAYING;
924
925         g_playing_info = current;
926
927         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
928
929         if (0 < ttsd_data_get_sound_data_size(current->uid)) {
930                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
931                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
932         }
933
934         return 0;
935 }
936
937 int ttsd_player_stop(int uid)
938 {
939         if (false == g_player_init) {
940                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
941                 return -1;
942         }
943
944         /* Check uid */
945         player_s* current;
946         current = __player_get_item(uid);
947         if (NULL == current) {
948                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
949                 return -1;
950         }
951
952         /* check whether uid is current playing or not */
953         if (NULL != g_playing_info) {
954                 if (uid == g_playing_info->uid) {
955                         /* release current playing info */
956                         g_playing_info = NULL;
957                 }
958         } else {
959                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
960         }
961
962         if (true == current->is_paused_data) {
963                 if (NULL != current->paused_data) {
964                         if (NULL != current->paused_data->data) {
965                                 free(current->paused_data->data);
966                                 current->paused_data->data = NULL;
967                         }
968
969                         free(current->paused_data);
970                         current->paused_data = NULL;
971                 }
972         }
973
974         current->event = TTSE_RESULT_EVENT_FINISH;
975         current->state = APP_STATE_READY;
976         current->is_paused_data = false;
977         current->idx = 0;
978
979         if (NULL == g_playing_info) {
980                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
981                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
982                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
983
984                 /* The thread should be released */
985                 int thread_count = ecore_thread_active_get();
986                 int count = 0;
987                 while (0 < thread_count) {
988                         usleep(10000);
989
990                         count++;
991                         if (30 == count) {
992                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
993                                 break;
994                         }
995
996                         thread_count = ecore_thread_active_get();
997                 }
998
999                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1000                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1001                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1002         }
1003
1004         SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
1005
1006         return 0;
1007 }
1008
1009 int ttsd_player_clear(int uid)
1010 {
1011         if (false == g_player_init) {
1012                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1013                 return -1;
1014         }
1015
1016         /* Check uid */
1017         player_s* current;
1018         current = __player_get_item(uid);
1019         if (NULL == current) {
1020                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); 
1021                 return -1;
1022         }
1023
1024         if (true == current->is_paused_data) {
1025                 if (NULL != current->paused_data) {
1026                         if (NULL != current->paused_data->data) {
1027                                 free(current->paused_data->data);
1028                                 current->paused_data->data = NULL;
1029                         }
1030
1031                         free(current->paused_data);
1032                         current->paused_data = NULL;
1033                 }
1034         }
1035
1036         current->event = TTSE_RESULT_EVENT_FINISH;
1037         current->state = APP_STATE_READY;
1038         current->is_paused_data = false;
1039         current->idx = 0;
1040
1041         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
1042
1043         return 0;
1044 }
1045
1046 int ttsd_player_pause(int uid)
1047 {
1048         SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
1049
1050         if (false == g_player_init) {
1051                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1052                 return -1;
1053         }
1054
1055         /* Check uid */
1056         player_s* current;
1057         current = __player_get_item(uid);
1058         if (NULL == current) {
1059                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
1060                 return -1;
1061         }
1062
1063         /* check whether uid is current playing or not */
1064         if (NULL != g_playing_info) {
1065                 if (uid == g_playing_info->uid) {
1066                         /* release current playing info */
1067                         g_playing_info = NULL;
1068                 } else {
1069                         /* error case */
1070                 }
1071         }
1072
1073         current->state = APP_STATE_PAUSED;
1074
1075         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1076         SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1077         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1078
1079         /* The thread should be released */
1080         int thread_count = ecore_thread_active_get();
1081         int count = 0;
1082         while (0 < thread_count) {
1083                 usleep(10000);
1084
1085                 count++;
1086                 if (30 == count) {
1087                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1088                         break;
1089                 }
1090
1091                 thread_count = ecore_thread_active_get();
1092         }
1093
1094         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1095         SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1096         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1097
1098         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
1099
1100         return 0;
1101 }
1102
1103 int ttsd_player_resume(int uid)
1104 {
1105         SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
1106
1107         if (false == g_player_init) {
1108                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1109                 return -1;
1110         }
1111
1112         /* Check id */
1113         player_s* current;
1114         current = __player_get_item(uid);
1115         if (NULL == current) {
1116                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1117                 return -1;
1118         }
1119
1120         /* check current player */
1121         if (NULL != g_playing_info)
1122                 g_playing_info = NULL;
1123
1124         current->state = APP_STATE_PLAYING;
1125         g_playing_info = current;
1126
1127         SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1128         ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1129
1130         return 0;
1131 }
1132
1133 int ttsd_player_all_stop()
1134 {
1135         if (false == g_player_init) {
1136                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1137                 return -1;
1138         }
1139
1140         g_playing_info = NULL;
1141
1142         GList *iter = NULL;
1143         player_s *data = NULL;
1144
1145         if (0 < g_list_length(g_player_list)) {
1146                 /* Get a first item */
1147                 iter = g_list_first(g_player_list);
1148
1149                 while (NULL != iter) {
1150                         /* Get handle data from list */
1151                         data = (player_s*)iter->data;
1152
1153                         app_tts_state_e state;
1154                         if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1155                                 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1156                                 ttsd_player_destroy_instance(data->uid);
1157                                 iter = g_list_next(iter);
1158                                 continue;
1159                         }
1160
1161                         if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1162                                 data->event = TTSE_RESULT_EVENT_FINISH;
1163                                 data->state = APP_STATE_READY;
1164
1165                                 if (true == data->is_paused_data) {
1166                                         if (NULL != data->paused_data) {
1167                                                 if (NULL != data->paused_data->data) {
1168                                                         free(data->paused_data->data);
1169                                                         data->paused_data->data = NULL;
1170                                                 }
1171
1172                                                 free(data->paused_data);
1173                                                 data->paused_data = NULL;
1174                                         }
1175                                 }
1176
1177                                 data->is_paused_data = false;
1178                                 data->idx = 0;
1179                         }
1180
1181                         /* Get next item */
1182                         iter = g_list_next(iter);
1183                 }
1184         }
1185
1186         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
1187
1188         return 0;
1189 }
1190
1191 int ttsd_player_play_pcm(int uid)
1192 {
1193         if (false == g_player_init) {
1194                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1195                 return -1;
1196         }
1197
1198         if (NULL != g_playing_info) {
1199                 if (uid == g_playing_info->uid) {
1200                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1201                         return 0;
1202                 } else {
1203                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1204                         ttsd_player_stop(g_playing_info->uid);
1205                 }
1206         }
1207
1208         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1209
1210         /* Check sound queue size */
1211         if (0 == ttsd_data_get_sound_data_size(uid)) {
1212                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1213         }
1214
1215         /* Check uid */
1216         player_s* current;
1217         current = __player_get_item(uid);
1218         if (NULL == current) {
1219                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1220                 return -1;
1221         }
1222
1223         current->state = APP_STATE_PLAYING;
1224
1225         g_playing_info = current;
1226
1227         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1228
1229         if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
1230                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1231                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1232         }
1233
1234         return 0;
1235 }
1236