server/ttsd_data.cpp

   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 <list>
  15 #include <pthread.h>
  16 #include <mutex>
  17 #include <vector>
  18 #include <atomic>
  19
  20 #include "ActivatedModes.h"
  21
  22 #include "ttsd_data.h"
  23
  24 using namespace std;
  25
  26 typedef struct
  27 {
  28         char*   lang;
  29         int     vctype;
  30 }used_voice_s;
  31
  32 typedef struct
  33 {
  34         int             pid;
  35         unsigned int            uid;
  36         int             utt_id_stopped;
  37         app_tts_state_e state;
  38         tts_app_play_type_e type;
  39         ttsd_mode_e     mode;
  40         ttse_result_event_e result_event;
  41
  42         std::list<speak_data_s*> m_speak_data;
  43         std::list<sound_data_s*> m_wav_data;
  44         bool paused_data_existing;
  45
  46         std::list<used_voice_s> m_used_voice;
  47         tts_ipc_method_e ipc_method;
  48
  49         char* credential;
  50         int registered_event_mask;
  51 } app_data_s;
  52
  53 static vector<app_data_s> g_app_list;
  54
  55 static mutex g_app_data_mutex;
  56
  57 /* If engine is running */
  58 static atomic<ttsd_synthesis_control_e> g_synth_control;
  59
  60 static ActivatedModes g_activated_modes;
  61
  62 #ifdef DATA_DEBUG
  63 static void __data_show_list()
  64 {
  65         SLOG(LOG_DEBUG, tts_tag(), "----- client list -----");
  66
  67         unsigned int i = 0;
  68         for (auto& appData : g_app_list) {
  69                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, appData.pid, appData.uid, appData.state);
  70                 i++;
  71         }
  72
  73         if (0 == i) {
  74                 SLOG(LOG_DEBUG, tts_tag(), "No Client");
  75         }
  76
  77         SLOG(LOG_DEBUG, tts_tag(), "-----------------------");
  78 }
  79
  80 static void __data_show_sound_list(app_data_s& app_data)
  81 {
  82         SLOG(LOG_DEBUG, tts_tag(), "----- Sound list -----");
  83
  84         unsigned int i = 0;
  85         for (auto& wavData : app_data.m_wav_data) {
  86                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
  87                                 i + 1, wavData, wavData->data, wavData->data_size, wavData->utt_id, wavData->audio_type);
  88                 i++;
  89         }
  90
  91         if (0 == i) {
  92                 SLOG(LOG_DEBUG, tts_tag(), "No Sound Data");
  93         }
  94
  95         SLOG(LOG_DEBUG, tts_tag(), "----------------------");
  96 }
  97
  98 static void __data_show_text_list(app_data_s& app_data)
  99 {
 100         SLOG(LOG_DEBUG, tts_tag(), "----- Text list -----");
 101
 102         unsigned int i = 0;
 103         for (auto& speakData : app_data.m_speak_data) {
 104                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)",
 105                                 i + 1, speakData, speakData->lang, speakData->vctype, speakData->speed, speakData->utt_id, speakData->text);
 106                 i++;
 107         }
 108
 109         if (0 == i) {
 110                 SLOG(LOG_DEBUG, tts_tag(), "No Text Data");
 111         }
 112
 113         SLOG(LOG_DEBUG, tts_tag(), "---------------------");
 114 }
 115
 116 static void __data_show_used_voice_list(app_data_s& app_data)
 117 {
 118         SLOG(LOG_DEBUG, tts_tag(), "----- Used voice list -----");
 119
 120         unsigned int i = 0;
 121         for (auto& usedVoice : app_data.m_used_voice) {
 122                 SLOG(LOG_DEBUG, tts_tag(), "[%dth] lang(%s), vctype(%d)", i + 1, usedVoice.lang, usedVoice.vctype);
 123                 i++;
 124         }
 125
 126         if (0 == i) {
 127                 SLOG(LOG_DEBUG, tts_tag(), "No Voice Data");
 128         }
 129
 130         SLOG(LOG_DEBUG, tts_tag(), "---------------------------");
 131 }
 132 #endif
 133
 134 /*
 135 * ttsd data functions
 136 */
 137
 138 int ttsd_data_set_synth_control(ttsd_synthesis_control_e control)
 139 {
 140         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] set synth_control(%d)", control);
 141         g_synth_control = control;
 142         return 0;
 143 }
 144
 145 ttsd_synthesis_control_e ttsd_data_get_synth_control()
 146 {
 147         return g_synth_control.load();
 148 }
 149
 150 static app_data_s* __get_client_app_data(unsigned int uid)
 151 {
 152         for (auto& app_data : g_app_list) {
 153                 if (app_data.uid == uid) {
 154                         return &app_data;
 155                 }
 156         }
 157
 158         return nullptr;
 159 }
 160
 161 int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, int registered_event_mask, tts_ipc_method_e method)
 162 {
 163         lock_guard<mutex> lock(g_app_data_mutex);
 164         if(nullptr != __get_client_app_data(uid) ) {
 165                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is already registered (%u)", uid);
 166                 return TTSD_ERROR_INVALID_PARAMETER;
 167         }
 168
 169         app_data_s app;
 170         app.pid = pid;
 171         app.uid = uid;
 172         app.utt_id_stopped = 0;
 173         app.state = APP_STATE_READY;
 174         app.type = TTS_APP_PLAY_TYPE_SYNTH;
 175         app.mode = mode;
 176         app.result_event = TTSE_RESULT_EVENT_FAIL;
 177         app.ipc_method = method;
 178         app.credential = nullptr;
 179         app.paused_data_existing = false;
 180         app.registered_event_mask = registered_event_mask;
 181
 182         g_app_list.push_back(app);
 183         g_activated_modes.addMode(mode);
 184
 185 #ifdef DATA_DEBUG
 186         __data_show_list();
 187 #endif
 188
 189         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] New client. pid(%d), uid(%u)", app.pid, app.uid);
 190
 191         return TTSD_ERROR_NONE;
 192 }
 193
 194 static inline void __destroy_speak_data(speak_data_s* speak_data)
 195 {
 196         SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] utt(%d), text(%s), lang(%s), vctype(%d) speed(%d)",
 197                         speak_data->utt_id, speak_data->text, speak_data->lang, speak_data->vctype, speak_data->speed);
 198
 199         free(speak_data->text);
 200         free(speak_data->lang);
 201
 202         delete speak_data;
 203 }
 204
 205 static inline void __destroy_sound_data(sound_data_s* sound_data)
 206 {
 207         SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] event(%d) data(%p) size(%d) rate(%d) utt(%d)",
 208                         sound_data, sound_data->event, sound_data->data, sound_data->data_size, sound_data->rate, sound_data->utt_id);
 209
 210         delete[] sound_data->data;
 211         delete sound_data;
 212 }
 213
 214 static void __clean_data(app_data_s& app_data)
 215 {
 216         SLOG(LOG_ERROR, tts_tag(), "[INFO] Clean data. uid(%u)", app_data.uid);
 217
 218         int removed_last_uttid = -1;
 219         for (auto& speak_data : app_data.m_speak_data) {
 220                 if (nullptr == speak_data) {
 221                         continue;
 222                 }
 223
 224                 removed_last_uttid = speak_data->utt_id;
 225
 226                 __destroy_speak_data(speak_data);
 227                 speak_data = nullptr;
 228         }
 229
 230         if (-1 != removed_last_uttid) {
 231                 app_data.utt_id_stopped = removed_last_uttid;
 232         }
 233
 234         for (auto& sound_data : app_data.m_wav_data) {
 235                 if (nullptr == sound_data) {
 236                         continue;
 237                 }
 238
 239                 __destroy_sound_data(sound_data);
 240                 sound_data = nullptr;
 241         }
 242
 243         app_data.m_speak_data.clear();
 244         app_data.m_wav_data.clear();
 245 }
 246
 247 int ttsd_data_delete_client(unsigned int uid)
 248 {
 249         lock_guard<mutex> lock(g_app_data_mutex);
 250         int index = 0;
 251         for (auto& app_data : g_app_list) {
 252                 if (app_data.uid == uid) {
 253                         break;
 254                 }
 255
 256                 index++;
 257         }
 258
 259         if (index >= (int)g_app_list.size()) {
 260                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 261                 return TTSD_ERROR_INVALID_PARAMETER;
 262         }
 263
 264         __clean_data(g_app_list[index]);
 265
 266         ttsd_mode_e mode = g_app_list[index].mode;
 267         g_app_list.erase(g_app_list.begin() + index);
 268         g_activated_modes.removeMode(mode);
 269
 270 #ifdef DATA_DEBUG
 271         __data_show_list();
 272 #endif
 273
 274         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Client is deleted. uid(%u), index(%d)", uid, index);
 275
 276         return TTSD_ERROR_NONE;
 277 }
 278
 279 int ttsd_data_is_client(unsigned int uid)
 280 {
 281         lock_guard<mutex> lock(g_app_data_mutex);
 282         int vsize = g_app_list.size();
 283         for (int i = 0; i < vsize; i++) {
 284                 if(g_app_list[i].uid == uid) {
 285                         return i;
 286                 }
 287         }
 288
 289         SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no corresponding client. uid(%u)", uid);
 290
 291         return -1;
 292 }
 293
 294 int ttsd_data_get_client_count()
 295 {
 296         int num_client = g_app_list.size();
 297         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Number of clients(%d)", num_client);
 298
 299         return num_client;
 300 }
 301
 302 int ttsd_data_get_pid(unsigned int uid)
 303 {
 304         lock_guard<mutex> lock(g_app_data_mutex);
 305         app_data_s* app_data = __get_client_app_data(uid);
 306         if (nullptr == app_data) {
 307                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 308                 return -1;
 309         }
 310
 311         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u), pid(%d)", uid, app_data->pid);
 312
 313         return app_data->pid;
 314 }
 315
 316 tts_ipc_method_e ttsd_data_get_ipc_method(unsigned int uid)
 317 {
 318         lock_guard<mutex> lock(g_app_data_mutex);
 319         app_data_s* app_data = __get_client_app_data(uid);
 320         if (nullptr == app_data) {
 321                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 322                 return TTS_IPC_METHOD_UNDEFINED;
 323         }
 324
 325         return app_data->ipc_method;
 326 }
 327
 328 ttsd_mode_e ttsd_data_get_mode(unsigned int uid)
 329 {
 330         lock_guard<mutex> lock(g_app_data_mutex);
 331         app_data_s* app_data = __get_client_app_data(uid);
 332         if (nullptr == app_data) {
 333                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 334                 return TTSD_MODE_DEFAULT;
 335         }
 336
 337         return app_data->mode;
 338 }
 339
 340 int ttsd_data_set_credential(unsigned int uid, const char* credential)
 341 {
 342         lock_guard<mutex> lock(g_app_data_mutex);
 343         app_data_s* app_data = __get_client_app_data(uid);
 344         if (nullptr == app_data) {
 345                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 346                 return TTSD_ERROR_INVALID_PARAMETER;
 347         }
 348
 349         free(app_data->credential);
 350         app_data->credential = nullptr;
 351
 352         if (credential) {
 353                 app_data->credential = strdup(credential);
 354         }
 355
 356         return TTSD_ERROR_NONE;
 357 }
 358
 359 char* ttsd_data_get_credential(unsigned int uid)
 360 {
 361         lock_guard<mutex> lock(g_app_data_mutex);
 362         app_data_s* app_data = __get_client_app_data(uid);
 363         if (nullptr == app_data) {
 364                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 365                 return nullptr;
 366         }
 367
 368         if (nullptr == app_data->credential) {
 369                 return nullptr;
 370         }
 371
 372         return strdup(app_data->credential);
 373 }
 374
 375 int ttsd_data_get_speak_data_size(unsigned int uid)
 376 {
 377         lock_guard<mutex> lock(g_app_data_mutex);
 378         app_data_s* app_data = __get_client_app_data(uid);
 379         if (nullptr == app_data) {
 380                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 381                 return TTSD_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         return app_data->m_speak_data.size();
 385 }
 386
 387 int ttsd_data_set_used_voice(unsigned int uid, const char* lang, int type)
 388 {
 389         lock_guard<mutex> lock(g_app_data_mutex);
 390         app_data_s* app_data = __get_client_app_data(uid);
 391         if (nullptr == app_data) {
 392                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 393                 return TTSD_ERROR_INVALID_PARAMETER;
 394         }
 395
 396         /* Find voice */
 397         list<used_voice_s>& usedVoices = app_data->m_used_voice;
 398         for (auto& voice : usedVoices) {
 399                 if (0 == strncmp(lang, voice.lang, strlen(lang)) && type == voice.vctype) {
 400                         SLOG(LOG_DEBUG, tts_tag(), "[DATA] The voice is already registered (%s)(%d)", lang, type);
 401                         return 0;
 402                 }
 403         }
 404
 405         /* Add voice */
 406         used_voice_s used_voice;
 407         used_voice.lang = strdup(lang);
 408         used_voice.vctype = type;
 409
 410         try {
 411                 usedVoices.push_back(used_voice);
 412         } catch (const std::bad_alloc&) {
 413                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_used_voice (bad_alloc)");
 414                 return -1;
 415         }
 416         SLOG(LOG_ERROR, tts_tag(), "[DATA] lang(%s), vctype(%d)", used_voice.lang, used_voice.vctype);
 417
 418 #ifdef DATA_DEBUG
 419         __data_show_used_voice_list(*app_data);
 420 #endif
 421
 422         return -1;      /* Need to load voice*/
 423 }
 424
 425 int ttsd_data_reset_used_voice(unsigned int uid, ttsd_used_voice_cb callback)
 426 {
 427         unique_lock<mutex> lock(g_app_data_mutex);
 428         app_data_s* app_data = __get_client_app_data(uid);
 429         if (nullptr == app_data) {
 430                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 431                 return TTSD_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         if (nullptr == callback) {
 435                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] Used voice callback is nullptr");
 436         }
 437
 438         /* Find voice */
 439         list<used_voice_s>& usedVoices = app_data->m_used_voice;
 440         for (auto& voice : usedVoices) {
 441                 if (nullptr != callback) {
 442                         lock.unlock();
 443                         callback(voice.lang, voice.vctype);
 444                         lock.lock();
 445                 }
 446
 447                 if (nullptr != voice.lang) {
 448                         free(voice.lang);
 449                         voice.lang = nullptr;
 450                 }
 451         }
 452         usedVoices.clear();
 453
 454 #ifdef DATA_DEBUG
 455         __data_show_used_voice_list(*app_data);
 456 #endif
 457
 458         return TTSD_ERROR_NONE;
 459 }
 460
 461 speak_data_s* ttsd_data_create_speak_data(const char* text, const char* language, int voice_type, int speed, int utt_id)
 462 {
 463         speak_data_s* speak_data = new speak_data_s();
 464         if (nullptr == speak_data) {
 465                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory for speak_data_s");
 466                 return nullptr;
 467         }
 468
 469         speak_data->text = strdup(text);
 470         speak_data->lang = strdup(language);
 471
 472         speak_data->vctype = voice_type;
 473         speak_data->speed = speed;
 474         speak_data->utt_id = utt_id;
 475
 476         return speak_data;
 477 }
 478
 479 void ttsd_data_destroy_speak_data(speak_data_s* speak_data)
 480 {
 481         if (nullptr == speak_data) {
 482                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] data is nullptr");
 483                 return;
 484         }
 485         __destroy_speak_data(speak_data);
 486 }
 487
 488 int ttsd_data_add_speak_data(unsigned int uid, speak_data_s* data)
 489 {
 490         lock_guard<mutex> lock(g_app_data_mutex);
 491         app_data_s* app_data = __get_client_app_data(uid);
 492         if (nullptr == app_data) {
 493                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 494                 return TTSD_ERROR_INVALID_PARAMETER;
 495         }
 496
 497         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
 498
 499         try {
 500                 list<speak_data_s*>& speakData = app_data->m_speak_data;
 501                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] m_speak_data size(%zu)", speakData.size());
 502                 speakData.push_back(data);
 503         } catch (const std::bad_alloc&) {
 504                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_speak_data (bad_alloc)");
 505                 return TTSD_ERROR_OUT_OF_MEMORY;
 506         }
 507
 508         SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), text(%s), lang(%s), vctype(%d), speed(%d)",
 509                         data, data->utt_id, data->text, data->lang, data->vctype, data->speed);
 510
 511         if (1 == data->utt_id)
 512                 app_data->utt_id_stopped = 0;
 513
 514 #ifdef DATA_DEBUG
 515         __data_show_text_list(*app_data);
 516 #endif
 517
 518         return TTSD_ERROR_NONE;
 519 }
 520
 521 static speak_data_s* __get_speak_data(app_data_s* app_data)
 522 {
 523         if (app_data->m_speak_data.empty()) {
 524 #ifdef DATA_DEBUG
 525                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
 526 #endif
 527                 return nullptr;
 528         }
 529
 530 #ifdef DATA_DEBUG
 531         __data_show_text_list(*app_data);
 532 #endif
 533
 534         return app_data->m_speak_data.front();
 535 }
 536
 537 int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data)
 538 {
 539         lock_guard<mutex> lock(g_app_data_mutex);
 540         app_data_s* app_data = __get_client_app_data(uid);
 541         if (nullptr == app_data) {
 542                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 543                 return TTSD_ERROR_INVALID_PARAMETER;
 544         }
 545
 546         speak_data_s* speakData = __get_speak_data(app_data);
 547         if (nullptr == speakData) {
 548                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
 549                 return TTSD_ERROR_OPERATION_FAILED;
 550         }
 551
 552         app_data->m_speak_data.pop_front();
 553         *data = speakData;
 554
 555         return TTSD_ERROR_NONE;
 556 }
 557
 558 sound_data_s* ttsd_data_create_sound_data(int utt_id, const void* data, unsigned int data_size, ttse_result_event_e event,
 559                 ttse_audio_type_e audio_type, int rate, int channels)
 560 {
 561         /* add wav data */
 562         sound_data_s* sound_data = new sound_data_s();
 563         if (nullptr == sound_data) {
 564                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory for speak_data_s");
 565                 return nullptr;
 566         }
 567
 568         sound_data->data = nullptr;
 569         sound_data->data_size = 0;
 570
 571         if (nullptr != data && 0 < data_size) {
 572                 sound_data->data = new char[data_size];
 573                 if (nullptr != sound_data->data) {
 574                         memcpy(sound_data->data, data, data_size);
 575                         sound_data->data_size = data_size;
 576                         SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] event(%d) sound_data(%p) data(%p) size(%u)",
 577                                 event, sound_data, sound_data->data, sound_data->data_size);
 578                 } else {
 579                         SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
 580                 }
 581         } else {
 582                 SLOG(LOG_ERROR, tts_tag(), "Sound data is nullptr");
 583         }
 584
 585         sound_data->utt_id = utt_id;
 586         sound_data->event = event;
 587         sound_data->audio_type = audio_type;
 588         sound_data->rate = rate;
 589         sound_data->channels = channels;
 590         sound_data->played_data_size = 0;
 591
 592         return sound_data;
 593 }
 594
 595 void ttsd_data_destroy_sound_data(sound_data_s* sound_data)
 596 {
 597         if (nullptr == sound_data) {
 598                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] data is nullptr");
 599                 return;
 600         }
 601
 602         __destroy_sound_data(sound_data);
 603 }
 604
 605 int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data)
 606 {
 607         lock_guard<mutex> lock(g_app_data_mutex);
 608         app_data_s* app_data = __get_client_app_data(uid);
 609         if (nullptr == app_data) {
 610                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 611                 return TTSD_ERROR_INVALID_PARAMETER;
 612         }
 613
 614         if (nullptr == data) {
 615                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] sound data is nullptr");
 616                 return TTSD_ERROR_INVALID_PARAMETER;
 617         }
 618
 619         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
 620
 621         try {
 622                 list<sound_data_s*>& wavData = app_data->m_wav_data;
 623                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] m_wav_data size(%zu)", wavData.size());
 624                 wavData.push_back(data);
 625         } catch (const std::bad_alloc&) {
 626                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_sound_data (bad_alloc)");
 627                 return TTSD_ERROR_OUT_OF_MEMORY;
 628         }
 629         SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), data(%p) data size(%d), type(%d)",
 630                         data, data->utt_id, data->data, data->data_size, data->audio_type);
 631
 632 #ifdef DATA_DEBUG
 633         __data_show_sound_list(*app_data);
 634 #endif
 635
 636         return TTSD_ERROR_NONE;
 637 }
 638
 639 static sound_data_s* __get_sound_data(app_data_s* app_data)
 640 {
 641         if (app_data->m_wav_data.empty()) {
 642 #ifdef DATA_DEBUG
 643                 SLOG(LOG_DEBUG, tts_tag(), "[DATA] There is no wav data");
 644 #endif
 645                 return nullptr;
 646         }
 647
 648 #ifdef DATA_DEBUG
 649         __data_show_sound_list(*app_data);
 650 #endif
 651
 652         return app_data->m_wav_data.front();
 653 }
 654
 655 sound_data_s* ttsd_data_get_first_sound_data(unsigned int uid)
 656 {
 657         lock_guard<mutex> lock(g_app_data_mutex);
 658         app_data_s* app_data = __get_client_app_data(uid);
 659         if (nullptr == app_data) {
 660                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 661                 return nullptr;
 662         }
 663
 664         sound_data_s* soundData = __get_sound_data(app_data);
 665         if (nullptr == soundData) {
 666                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no sound data");
 667                 return nullptr;
 668         }
 669
 670         app_data->m_wav_data.pop_front();
 671         return soundData;
 672 }
 673
 674 int ttsd_data_get_sound_data_size(unsigned int uid)
 675 {
 676         lock_guard<mutex> lock(g_app_data_mutex);
 677         app_data_s* app_data = __get_client_app_data(uid);
 678         if (nullptr == app_data) {
 679                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 680                 return -1;
 681         }
 682
 683         return app_data->m_wav_data.size();
 684 }
 685
 686 int ttsd_data_set_last_sound_result_event(unsigned int uid, ttse_result_event_e event)
 687 {
 688         lock_guard<mutex> lock(g_app_data_mutex);
 689         app_data_s* app_data = __get_client_app_data(uid);
 690         if (nullptr == app_data) {
 691                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 692                 return TTSE_ERROR_INVALID_PARAMETER;
 693         }
 694
 695         app_data->result_event = event;
 696         return TTSE_ERROR_NONE;
 697 }
 698
 699 ttse_result_event_e ttsd_data_get_last_sound_result_event(unsigned int uid)
 700 {
 701         lock_guard<mutex> lock(g_app_data_mutex);
 702         app_data_s* app_data = __get_client_app_data(uid);
 703         if (nullptr == app_data) {
 704                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 705                 return TTSE_RESULT_EVENT_FAIL;
 706         }
 707
 708         return app_data->result_event;
 709 }
 710
 711 int ttsd_data_clear_data(unsigned int uid)
 712 {
 713         lock_guard<mutex> lock(g_app_data_mutex);
 714         app_data_s* app_data = __get_client_app_data(uid);
 715         if (nullptr == app_data) {
 716                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 717                 return TTSD_ERROR_INVALID_PARAMETER;
 718         }
 719
 720         __clean_data(*app_data);
 721
 722         return TTSD_ERROR_NONE;
 723 }
 724
 725 app_tts_state_e ttsd_data_get_client_state(unsigned int uid)
 726 {
 727         lock_guard<mutex> lock(g_app_data_mutex);
 728         app_data_s* app_data = __get_client_app_data(uid);
 729         if (nullptr == app_data) {
 730                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 731                 return APP_STATE_NONE;
 732         }
 733
 734         return app_data->state;
 735 }
 736
 737 static unsigned int __get_playing_app_uid()
 738 {
 739         for (auto& app : g_app_list) {
 740                 if (APP_STATE_PLAYING == app.state) {
 741                         return app.uid;
 742                 }
 743         }
 744
 745         return -1;
 746 }
 747
 748 int ttsd_data_set_client_state(unsigned int uid, app_tts_state_e state)
 749 {
 750         lock_guard<mutex> lock(g_app_data_mutex);
 751         app_data_s* app_data = __get_client_app_data(uid);
 752         if (nullptr == app_data) {
 753                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 754                 return TTSD_ERROR_INVALID_PARAMETER;
 755         }
 756
 757         if (app_data->state == state) {
 758                 SLOG(LOG_ERROR, tts_tag(), "[DATA] Already current state. (%d)", state);
 759                 return TTSD_ERROR_NONE;
 760         }
 761
 762         /* The client of playing state of all clients is only one. need to check state. */
 763         int playing_uid = __get_playing_app_uid();
 764         if (APP_STATE_PLAYING == state && 0 < playing_uid) {
 765                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] A playing client has already existed. playing app uid(%u)", playing_uid);
 766                 return TTSD_ERROR_OPERATION_FAILED;
 767         }
 768
 769         app_data->state = state;
 770
 771         return TTSD_ERROR_NONE;
 772 }
 773
 774 tts_app_play_type_e ttsd_data_get_play_type(unsigned int uid)
 775 {
 776         lock_guard<mutex> lock(g_app_data_mutex);
 777         app_data_s* app_data = __get_client_app_data(uid);
 778         if (nullptr == app_data) {
 779                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 780                 return TTS_APP_PLAY_TYPE_SYNTH;
 781         }
 782
 783         return app_data->type;
 784 }
 785
 786 int ttsd_data_set_play_type(unsigned int uid, tts_app_play_type_e type)
 787 {
 788         lock_guard<mutex> lock(g_app_data_mutex);
 789         app_data_s* app_data = __get_client_app_data(uid);
 790         if (nullptr == app_data) {
 791                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 792                 return TTSD_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         app_data->type = type;
 796
 797         return TTSD_ERROR_NONE;
 798 }
 799
 800 int ttsd_data_set_paused_data(unsigned int uid, sound_data_s* sound_data)
 801 {
 802         lock_guard<mutex> lock(g_app_data_mutex);
 803         app_data_s* app_data = __get_client_app_data(uid);
 804         if (nullptr == app_data) {
 805                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 806                 return TTSD_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         if (sound_data) {
 810                 app_data->m_wav_data.push_front(sound_data);
 811                 app_data->paused_data_existing = true;
 812         } else {
 813                 app_data->paused_data_existing = false;
 814         }
 815
 816         return TTSD_ERROR_NONE;
 817 }
 818
 819 bool ttsd_data_is_paused_data_existing(unsigned int uid)
 820 {
 821         lock_guard<mutex> lock(g_app_data_mutex);
 822         app_data_s* app_data = __get_client_app_data(uid);
 823         if (nullptr == app_data) {
 824                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 825                 return false;
 826         }
 827
 828         return app_data->paused_data_existing;
 829 }
 830
 831 bool ttsd_data_is_service_state_changed_cb_set(unsigned int uid)
 832 {
 833         lock_guard<mutex> lock(g_app_data_mutex);
 834         app_data_s* app_data = __get_client_app_data(uid);
 835         if (nullptr == app_data) {
 836                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 837                 return false;
 838         }
 839
 840         bool is_service_state_changed_cb_set = ((app_data->registered_event_mask & TTS_EVENT_MASK_SERVICE_STATE_CHANGED) != 0);
 841         return is_service_state_changed_cb_set;
 842 }
 843
 844 unsigned int ttsd_data_get_current_playing()
 845 {
 846         lock_guard<mutex> lock(g_app_data_mutex);
 847         unsigned int uid = __get_playing_app_uid();
 848
 849         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Current playing uid(%u)", uid);
 850
 851         return uid;
 852 }
 853
 854 int ttsd_data_foreach_clients(ttsd_data_get_client_cb callback, void* user_data)
 855 {
 856         if (nullptr == callback) {
 857                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] input data is nullptr!!");
 858                 return -1;
 859         }
 860
 861 #ifdef DATA_DEBUG
 862         __data_show_list();
 863 #endif
 864
 865         /* Copy app info */
 866         vector<app_data_s> temp_app_list;
 867
 868         unique_lock<mutex> lock(g_app_data_mutex);
 869         int vsize = g_app_list.size();
 870         for (int i = 0; i < vsize; i++) {
 871                 app_data_s app = {0, };
 872                 app.pid = g_app_list[i].pid;
 873                 app.uid = g_app_list[i].uid;
 874                 app.utt_id_stopped = 0;
 875                 app.state = g_app_list[i].state;
 876
 877                 temp_app_list.push_back(app);
 878         }
 879         lock.unlock();
 880
 881         for (int i = 0; i < vsize; i++) {
 882                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state);
 883                 if (false == callback(temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state, user_data)) {
 884                         break;
 885                 }
 886         }
 887
 888         return 0;
 889 }
 890
 891 bool ttsd_data_is_uttid_valid(unsigned int uid, int uttid)
 892 {
 893         lock_guard<mutex> lock(g_app_data_mutex);
 894         app_data_s* app_data = __get_client_app_data(uid);
 895         if (nullptr == app_data) {
 896                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 897                 return false;
 898         }
 899
 900         if (uttid < app_data->utt_id_stopped)
 901                 return false;
 902
 903         return true;
 904 }
 905
 906 int ttsd_data_get_same_pid_client_count(int pid)
 907 {
 908         lock_guard<mutex> lock(g_app_data_mutex);
 909         int number = 0;
 910         for (auto& appData : g_app_list) {
 911                 if(appData.pid == pid) {
 912                         number++;
 913                 }
 914         }
 915
 916         return number;
 917 }
 918
 919 int ttsd_data_get_activated_mode()
 920 {
 921         return g_activated_modes.getModes();
 922 }
 923
 924 int ttsd_data_save_error_log(unsigned int uid, FILE* fp)
 925 {
 926         lock_guard<mutex> lock(g_app_data_mutex);
 927         app_data_s* app_data = __get_client_app_data(uid);
 928         if (nullptr == app_data) {
 929                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid client");
 930                 return -1;
 931         }
 932
 933         /* pid */
 934         fprintf(fp, "pid - %d", app_data->pid);
 935
 936         /* app state */
 937         fprintf(fp, "app state - %d", app_data->state);
 938
 939         /* get sound data */
 940         fprintf(fp, "----- Sound list -----");
 941         unsigned int i = 0;
 942         for (auto& wavData : app_data->m_wav_data) {
 943                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
 944                                 i, wavData, wavData->data, wavData->data_size, wavData->utt_id, wavData->audio_type);
 945                 i++;
 946         }
 947         fprintf(fp, "----------------------");
 948
 949         /* get speck data */
 950         fprintf(fp, "----- Text list -----");
 951
 952         i = 0;
 953         for (auto& speakData : app_data->m_speak_data) {
 954                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)",
 955                                 i, speakData, speakData->lang, speakData->vctype, speakData->speed, speakData->utt_id, speakData->text);
 956                 i++;
 957         }
 958         fprintf(fp, "---------------------");
 959
 960         return 0;
 961 }