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