client/tts_client.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
  15 #include "tts_client.h"
  16
  17 /* Constant value */
  18 static const int MAX_HANDLE_NUM = 999;
  19 static const int INVALID_HANDLE = -1;
  20
  21 /* allocated handle */
  22 static unsigned int g_allocated_handle = 0;
  23 /* client list */
  24 static GList *g_client_list = NULL;
  25
  26 /* pthread mutex */
  27 static pthread_mutex_t g_allocated_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
  28 static pthread_mutex_t g_client_list_mutex = PTHREAD_MUTEX_INITIALIZER;
  29 static pthread_mutex_t g_repeat_text_mutex = PTHREAD_MUTEX_INITIALIZER;
  30
  31
  32 static unsigned int __client_generate_uid(unsigned int pid)
  33 {
  34         pthread_mutex_lock(&g_allocated_handle_mutex);
  35         g_allocated_handle++;
  36
  37         if (g_allocated_handle > MAX_HANDLE_NUM) {
  38                 g_allocated_handle = 1;
  39         }
  40
  41         /* generate uid, handle number should be smaller than 1000 */
  42         unsigned int uid = pid * 1000u + g_allocated_handle;
  43         pthread_mutex_unlock(&g_allocated_handle_mutex);
  44
  45         return uid;
  46 }
  47
  48 static inline void __set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
  49 {
  50         if (callback != NULL) {
  51                 client->registered_event_mask |= TTS_EVENT_MASK_STATE_CHANGED;
  52         } else {
  53                 client->registered_event_mask &= ~TTS_EVENT_MASK_STATE_CHANGED;
  54         }
  55
  56         client->state_changed_cb = callback;
  57         client->state_changed_user_data = user_data;
  58 }
  59
  60 static inline void __set_utterance_started_cb(tts_client_s* client, tts_utterance_started_cb callback, void* user_data)
  61 {
  62         if (callback != NULL) {
  63                 client->registered_event_mask |= TTS_EVENT_MASK_UTTERANCE_STARTED;
  64         } else {
  65                 client->registered_event_mask &= ~TTS_EVENT_MASK_UTTERANCE_STARTED;
  66         }
  67
  68         client->utt_started_cb = callback;
  69         client->utt_started_user_data = user_data;
  70 }
  71
  72 static inline void __set_utterance_completed_cb(tts_client_s* client, tts_utterance_completed_cb callback, void* user_data)
  73 {
  74         if (callback != NULL) {
  75                 client->registered_event_mask |= TTS_EVENT_MASK_UTTERANCE_COMPLETED;
  76         } else {
  77                 client->registered_event_mask &= ~TTS_EVENT_MASK_UTTERANCE_COMPLETED;
  78         }
  79
  80         client->utt_completed_cb = callback;
  81         client->utt_completed_user_data = user_data;
  82 }
  83
  84 static inline void __set_error_cb(tts_client_s* client, tts_error_cb callback, void* user_data)
  85 {
  86         if (callback != NULL) {
  87                 client->registered_event_mask |= TTS_EVENT_MASK_ERROR;
  88         } else {
  89                 client->registered_event_mask &= ~TTS_EVENT_MASK_ERROR;
  90         }
  91
  92         client->error_cb = callback;
  93         client->error_user_data = user_data;
  94 }
  95
  96 static inline void __set_default_voice_changed_cb(tts_client_s* client, tts_default_voice_changed_cb callback, void* user_data)
  97 {
  98         if (callback != NULL) {
  99                 client->registered_event_mask |= TTS_EVENT_MASK_DEFAULT_VOICE_CHANGED;
 100         } else {
 101                 client->registered_event_mask &= ~TTS_EVENT_MASK_DEFAULT_VOICE_CHANGED;
 102         }
 103
 104         client->default_voice_changed_cb = callback;
 105         client->default_voice_changed_user_data = user_data;
 106 }
 107
 108 static inline void __set_engine_changed_cb(tts_client_s* client, tts_engine_changed_cb callback, void* user_data)
 109 {
 110         if (callback != NULL) {
 111                 client->registered_event_mask |= TTS_EVENT_MASK_ENGINE_CHANGED;
 112         } else {
 113                 client->registered_event_mask &= ~TTS_EVENT_MASK_ENGINE_CHANGED;
 114         }
 115
 116         client->engine_changed_cb = callback;
 117         client->engine_changed_user_data = user_data;
 118 }
 119
 120 static inline void __set_screen_reader_changed_cb(tts_client_s* client, tts_screen_reader_changed_cb callback, void* user_data)
 121 {
 122         if (callback != NULL) {
 123                 client->registered_event_mask |= TTS_EVENT_MASK_SCREEN_READER_CHANGED;
 124         } else {
 125                 client->registered_event_mask &= ~TTS_EVENT_MASK_SCREEN_READER_CHANGED;
 126         }
 127
 128         client->screen_reader_changed_cb = callback;
 129         client->screen_reader_changed_user_data = user_data;
 130 }
 131
 132 static inline void __set_supported_voice_cb(tts_client_s* client, tts_supported_voice_cb callback, void* user_data)
 133 {
 134         client->supported_voice_cb = callback;
 135         client->supported_voice_user_data = user_data;
 136 }
 137
 138 static inline void __set_service_state_changed_cb(tts_client_s* client, tts_service_state_changed_cb callback, void* user_data)
 139 {
 140         if (callback != NULL) {
 141                 client->registered_event_mask |= TTS_EVENT_MASK_SERVICE_STATE_CHANGED;
 142         } else {
 143                 client->registered_event_mask &= ~TTS_EVENT_MASK_SERVICE_STATE_CHANGED;
 144         }
 145
 146         client->service_state_changed_cb = callback;
 147         client->service_state_changed_user_data = user_data;
 148 }
 149
 150 static inline void __set_synthesized_pcm_cb(tts_client_s* client, tts_synthesized_pcm_cb callback, void* user_data)
 151 {
 152         client->synthesized_pcm_cb = callback;
 153         client->synthesized_pcm_user_data = user_data;
 154 }
 155
 156 int tts_client_new(tts_h* tts)
 157 {
 158         tts_client_s* client = (tts_client_s*)calloc(1, sizeof(tts_client_s));
 159         if (NULL == client) {
 160                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 161                 return TTS_ERROR_OUT_OF_MEMORY;
 162         }
 163
 164         tts_h temp = (tts_h)calloc(1, sizeof(struct tts_s));
 165         if (NULL == temp) {
 166                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 167                 free(client);
 168                 return TTS_ERROR_OUT_OF_MEMORY;
 169         }
 170
 171         temp->handle = __client_generate_uid((unsigned int)getpid());
 172
 173         /* initialize client data */
 174         client->tts = temp;
 175         client->pid = getpid();
 176         client->uid = temp->handle;
 177         client->current_service_state = TTS_SERVICE_STATE_NONE;
 178
 179         pthread_mutex_lock(&g_client_list_mutex);
 180         g_client_list = g_list_append(g_client_list, client);
 181         pthread_mutex_unlock(&g_client_list_mutex);
 182
 183         *tts = temp;
 184
 185         SLOG(LOG_ERROR, TAG_TTSC, "[Success] Create client object : uid(%u)", client->uid);
 186
 187         return TTS_ERROR_NONE;
 188 }
 189
 190 int tts_client_destroy(tts_h tts)
 191 {
 192         if (tts == NULL) {
 193                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 194                 return TTS_ERROR_INVALID_PARAMETER;
 195         }
 196
 197         GList *iter = NULL;
 198         tts_client_s *data = NULL;
 199
 200         pthread_mutex_lock(&g_client_list_mutex);
 201         /* if list have item */
 202         if (g_list_length(g_client_list) > 0) {
 203                 /* Get a first item */
 204                 iter = g_list_first(g_client_list);
 205
 206                 while (NULL != iter) {
 207                         data = iter->data;
 208                         if (tts->handle == data->tts->handle) {
 209                                 tts->handle = TTS_INVALID_UID;
 210                                 g_client_list = g_list_remove_link(g_client_list, iter);
 211
 212                                 while (0 != data->cb_ref_count) {
 213                                         /* wait for release callback function */
 214                                 }
 215
 216                                 unsigned int uid = data->uid;
 217
 218                                 free(data->err_msg);
 219                                 free(data->credential);
 220
 221                                 pthread_mutex_lock(&g_repeat_text_mutex);
 222                                 free(data->text_repeat);
 223                                 data->text_repeat = NULL;
 224                                 pthread_mutex_unlock(&g_repeat_text_mutex);
 225
 226                                 memset(data, 0, sizeof(tts_client_s));
 227
 228                                 free(data);
 229                                 data = NULL;
 230
 231                                 free(tts);
 232                                 tts = NULL;
 233
 234                                 g_list_free(iter);
 235
 236                                 pthread_mutex_unlock(&g_client_list_mutex);
 237                                 SLOG(LOG_ERROR, TAG_TTSC, "Client destroy : uid(%u)", uid);
 238                                 return TTS_ERROR_NONE;
 239                         }
 240
 241                         /* Next item */
 242                         iter = g_list_next(iter);
 243                 }
 244         }
 245         pthread_mutex_unlock(&g_client_list_mutex);
 246         SLOG(LOG_ERROR, TAG_TTSC, "Fail to destroy client : handle is not valid");
 247
 248         return TTS_ERROR_INVALID_PARAMETER;
 249 }
 250
 251 tts_client_s* tts_client_get(tts_h tts)
 252 {
 253         if (tts == NULL) {
 254                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 255                 return NULL;
 256         }
 257
 258         GList *iter = NULL;
 259         tts_client_s *data = NULL;
 260
 261         pthread_mutex_lock(&g_client_list_mutex);
 262         if (g_list_length(g_client_list) > 0) {
 263                 /* Get a first item */
 264                 iter = g_list_first(g_client_list);
 265
 266                 while (NULL != iter) {
 267                         data = iter->data;
 268
 269                         if (tts->handle == data->tts->handle) {
 270                                 pthread_mutex_unlock(&g_client_list_mutex);
 271                                 return data;
 272                         }
 273
 274                         /* Next item */
 275                         iter = g_list_next(iter);
 276                 }
 277         }
 278
 279         pthread_mutex_unlock(&g_client_list_mutex);
 280         SLOG(LOG_ERROR, TAG_TTSC, "handle is not valid");
 281
 282         return NULL;
 283 }
 284
 285 tts_client_s* tts_client_get_by_uid(unsigned int uid)
 286 {
 287         if (uid == TTS_INVALID_UID) {
 288                 SLOG(LOG_ERROR, TAG_TTSC, "out of range : handle");
 289                 return NULL;
 290         }
 291
 292         GList *iter = NULL;
 293         tts_client_s *data = NULL;
 294
 295         pthread_mutex_lock(&g_client_list_mutex);
 296         if (g_list_length(g_client_list) > 0) {
 297                 /* Get a first item */
 298                 iter = g_list_first(g_client_list);
 299
 300                 while (NULL != iter) {
 301                         data = iter->data;
 302                         if (uid == data->uid) {
 303                                 pthread_mutex_unlock(&g_client_list_mutex);
 304                                 return data;
 305                         }
 306
 307                         /* Next item */
 308                         iter = g_list_next(iter);
 309                 }
 310         }
 311
 312         pthread_mutex_unlock(&g_client_list_mutex);
 313         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid(%u) is not valid", uid);
 314
 315         return NULL;
 316 }
 317
 318 bool tts_client_is_valid_uid(unsigned int uid)
 319 {
 320         if (NULL == tts_client_get_by_uid(uid)) {
 321                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Uid is not valid");
 322                 return false;
 323         }
 324
 325         return true;
 326 }
 327
 328 bool tts_client_is_valid_client(tts_client_s* client)
 329 {
 330         if (NULL == client) {
 331                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] Client is NULL");
 332                 return false;
 333         }
 334
 335         pthread_mutex_lock(&g_client_list_mutex);
 336         if (g_list_length(g_client_list) > 0) {
 337                 GList *iter = g_list_first(g_client_list);
 338                 while (NULL != iter) {
 339                         if (iter->data == client) {
 340                                 pthread_mutex_unlock(&g_client_list_mutex);
 341                                 return true;
 342                         }
 343
 344                         iter = g_list_next(iter);
 345                 }
 346         }
 347         pthread_mutex_unlock(&g_client_list_mutex);
 348
 349         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client(%p) is not valid", client);
 350         return false;
 351 }
 352
 353 tts_h tts_client_get_handle(tts_client_s* client)
 354 {
 355         if (false == tts_client_is_valid_client(client)) {
 356                 return NULL;
 357         }
 358
 359         return client->tts;
 360 }
 361
 362 unsigned int tts_client_get_size()
 363 {
 364         pthread_mutex_lock(&g_client_list_mutex);
 365         unsigned int size = g_list_length(g_client_list);
 366         pthread_mutex_unlock(&g_client_list_mutex);
 367
 368         return size;
 369 }
 370
 371 int tts_client_use_callback(tts_client_s* client)
 372 {
 373         client->cb_ref_count++;
 374         return 0;
 375 }
 376
 377 int tts_client_not_use_callback(tts_client_s* client)
 378 {
 379         client->cb_ref_count--;
 380         return 0;
 381 }
 382
 383 int tts_client_get_use_callback(tts_client_s* client)
 384 {
 385         return client->cb_ref_count;
 386 }
 387
 388 GList* tts_client_get_client_list()
 389 {
 390         GList* copy_list = NULL;
 391         pthread_mutex_lock(&g_client_list_mutex);
 392         copy_list = g_list_copy(g_client_list);
 393         pthread_mutex_unlock(&g_client_list_mutex);
 394
 395         return copy_list;
 396 }
 397
 398 unsigned int tts_client_get_uid(tts_client_s* client)
 399 {
 400         if (NULL == client || false == tts_client_is_valid_client(client)) {
 401                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client(%p) is not valid", client);
 402                 return TTS_INVALID_UID;
 403         }
 404
 405         return client->uid;
 406 }
 407
 408 void tts_client_set_current_state(tts_client_s* client, tts_state_e state)
 409 {
 410         if (false == tts_client_is_valid_client(client)) {
 411                 return;
 412         }
 413
 414         client->before_state = client->current_state;
 415         client->current_state = state;
 416 }
 417
 418 tts_state_e tts_client_get_current_state(tts_client_s* client)
 419 {
 420         if (false == tts_client_is_valid_client(client)) {
 421                 return TTS_STATE_INVALID;
 422         }
 423
 424         return client->current_state;
 425 }
 426
 427 void tts_client_set_current_service_state(tts_client_s* client, tts_service_state_e service_state)
 428 {
 429         if (false == tts_client_is_valid_client(client)) {
 430                 return;
 431         }
 432
 433         client->current_service_state = service_state;
 434 }
 435
 436 tts_service_state_e tts_client_get_current_service_state(tts_client_s* client)
 437 {
 438         if (false == tts_client_is_valid_client(client)) {
 439                 return TTS_SERVICE_STATE_NONE;
 440         }
 441
 442         return client->current_service_state;
 443 }
 444
 445 void tts_client_set_start_listening(unsigned int uid, bool is_listening_started)
 446 {
 447         tts_client_s* client = tts_client_get_by_uid(uid);
 448         if (NULL == client) {
 449                 return;
 450         }
 451
 452         client->start_listening = is_listening_started;
 453 }
 454
 455 bool tts_client_is_listening_started(unsigned int uid)
 456 {
 457         tts_client_s* client = tts_client_get_by_uid(uid);
 458         if (NULL == client) {
 459                 return false;
 460         }
 461
 462         return client->start_listening;
 463 }
 464
 465 void tts_client_set_reprepared(tts_client_s* client, bool is_reprepared)
 466 {
 467         if (false == tts_client_is_valid_client(client)) {
 468                 return;
 469         }
 470
 471         client->reprepared = is_reprepared;
 472 }
 473
 474 bool tts_client_is_reprepared(tts_client_s* client)
 475 {
 476         if (false == tts_client_is_valid_client(client)) {
 477                 return INVALID_HANDLE;
 478         }
 479
 480         return client->reprepared;
 481 }
 482
 483 void tts_client_set_service_out(tts_client_s* client, bool is_service_out)
 484 {
 485         if (false == tts_client_is_valid_client(client)) {
 486                 return;
 487         }
 488
 489         client->service_out = is_service_out;
 490 }
 491
 492 bool tts_client_is_service_out(tts_client_s* client)
 493 {
 494         if (false == tts_client_is_valid_client(client)) {
 495                 return false;
 496         }
 497
 498         return client->service_out;
 499 }
 500
 501 void tts_client_set_mode(tts_client_s* client, tts_mode_e mode)
 502 {
 503         if (false == tts_client_is_valid_client(client)) {
 504                 return;
 505         }
 506
 507         client->mode = mode;
 508 }
 509
 510 tts_mode_e tts_client_get_mode(tts_client_s* client)
 511 {
 512         if (false == tts_client_is_valid_client(client)) {
 513                 return INVALID_HANDLE;
 514         }
 515
 516         return client->mode;
 517 }
 518
 519 void tts_client_set_playing_mode(tts_client_s* client, tts_playing_mode_e mode)
 520 {
 521         if (false == tts_client_is_valid_client(client)) {
 522                 return;
 523         }
 524
 525         client->playing_mode = mode;
 526 }
 527
 528 tts_playing_mode_e tts_client_get_playing_mode(tts_client_s* client)
 529 {
 530         if (false == tts_client_is_valid_client(client)) {
 531                 return INVALID_HANDLE;
 532         }
 533
 534         return client->playing_mode;
 535 }
 536
 537 void tts_client_set_repeat_text(tts_client_s* client, const char* text)
 538 {
 539         if (NULL == client || false == tts_client_is_valid_client(client)) {
 540                 return;
 541         }
 542
 543         pthread_mutex_lock(&g_repeat_text_mutex);
 544         if (NULL != client->text_repeat) {
 545                 free(client->text_repeat);
 546         }
 547
 548         if (NULL != text) {
 549                 client->text_repeat = strdup(text);
 550         } else {
 551                 client->text_repeat = NULL;
 552         }
 553         pthread_mutex_unlock(&g_repeat_text_mutex);
 554 }
 555
 556 char* tts_client_get_repeat_text(tts_client_s* client)
 557 {
 558         if (NULL == client || false == tts_client_is_valid_client(client)) {
 559                 return NULL;
 560         }
 561
 562         char *repeat_text = NULL;
 563         pthread_mutex_lock(&g_repeat_text_mutex);
 564         if (NULL != client->text_repeat) {
 565                 repeat_text = strdup(client->text_repeat);
 566         }
 567         pthread_mutex_unlock(&g_repeat_text_mutex);
 568
 569         return repeat_text;
 570 }
 571
 572 int tts_client_new_utterance_id(tts_client_s* client)
 573 {
 574         if (NULL == client || false == tts_client_is_valid_client(client)) {
 575                 return INVALID_HANDLE;
 576         }
 577
 578         client->current_utt_id++;
 579         if (client->current_utt_id == 10000) {
 580                 client->current_utt_id = 1;
 581         }
 582
 583         return client->current_utt_id;
 584 }
 585
 586 void tts_client_set_error_message(tts_client_s* client, const char* error_message)
 587 {
 588         if (false == tts_client_is_valid_client(client)) {
 589                 return;
 590         }
 591
 592         free(client->err_msg);
 593         client->err_msg = NULL;
 594
 595         if (NULL != error_message) {
 596                 client->err_msg = strdup(error_message);
 597         }
 598 }
 599
 600 const char* tts_client_get_error_message(tts_client_s* client)
 601 {
 602         if (false == tts_client_is_valid_client(client)) {
 603                 return NULL;
 604         }
 605
 606         return client->err_msg;
 607 }
 608
 609 void tts_client_set_credential_key(tts_client_s* client, const char* credential_key)
 610 {
 611         if (false == tts_client_is_valid_client(client)) {
 612                 return;
 613         }
 614
 615         free(client->credential);
 616         client->credential = NULL;
 617
 618         if (NULL != credential_key) {
 619                 client->credential = strdup(credential_key);
 620         }
 621 }
 622
 623 const char* tts_client_get_credential_key(tts_client_s* client)
 624 {
 625         if (false == tts_client_is_valid_client(client)) {
 626                 return NULL;
 627         }
 628
 629         return client->credential;
 630 }
 631
 632 void tts_client_set_state_changed_cb(tts_client_s* client, tts_state_changed_cb callback, void* user_data)
 633 {
 634         if (false == tts_client_is_valid_client(client)) {
 635                 return;
 636         }
 637
 638         if (NULL == callback) {
 639                 if (NULL != client->notify_state_timer) {
 640                         ecore_timer_del(client->notify_state_timer);
 641                         client->notify_state_timer = NULL;
 642                 }
 643         }
 644         __set_state_changed_cb(client, callback, user_data);
 645 }
 646
 647 void tts_client_set_utterance_started_cb(tts_client_s* client, tts_utterance_started_cb callback, void* user_data)
 648 {
 649         if (false == tts_client_is_valid_client(client)) {
 650                 return;
 651         }
 652         __set_utterance_started_cb(client, callback, user_data);
 653 }
 654
 655 void tts_client_set_utterance_completed_cb(tts_client_s* client, tts_utterance_completed_cb callback, void* user_data)
 656 {
 657         if (false == tts_client_is_valid_client(client)) {
 658                 return;
 659         }
 660         __set_utterance_completed_cb(client, callback, user_data);
 661 }
 662
 663 void tts_client_set_error_cb(tts_client_s* client, tts_error_cb callback, void* user_data)
 664 {
 665         if (false == tts_client_is_valid_client(client)) {
 666                 return;
 667         }
 668
 669         if (NULL == callback) {
 670                 if (NULL != client->notify_error_timer) {
 671                         ecore_timer_del(client->notify_error_timer);
 672                         client->notify_error_timer = NULL;
 673                 }
 674         }
 675         __set_error_cb(client, callback, user_data);
 676 }
 677
 678 void tts_client_set_default_voice_changed_cb(tts_client_s* client, tts_default_voice_changed_cb callback, void* user_data)
 679 {
 680         if (false == tts_client_is_valid_client(client)) {
 681                 return;
 682         }
 683         __set_default_voice_changed_cb(client, callback, user_data);
 684 }
 685
 686 void tts_client_set_engine_changed_cb(tts_client_s* client, tts_engine_changed_cb callback, void* user_data)
 687 {
 688         if (false == tts_client_is_valid_client(client)) {
 689                 return;
 690         }
 691         __set_engine_changed_cb(client, callback, user_data);
 692 }
 693
 694 void tts_client_set_screen_reader_changed_cb(tts_client_s* client, tts_screen_reader_changed_cb callback, void* user_data)
 695 {
 696         if (false == tts_client_is_valid_client(client)) {
 697                 return;
 698         }
 699         __set_screen_reader_changed_cb(client, callback, user_data);
 700 }
 701
 702 void tts_client_set_supported_voice_cb(tts_client_s* client, tts_supported_voice_cb callback, void* user_data)
 703 {
 704         if (false == tts_client_is_valid_client(client)) {
 705                 return;
 706         }
 707         __set_supported_voice_cb(client, callback, user_data);
 708 }
 709
 710 void tts_client_set_service_state_changed_cb(tts_client_s* client, tts_service_state_changed_cb callback, void* user_data)
 711 {
 712         if (false == tts_client_is_valid_client(client)) {
 713                 return;
 714         }
 715         __set_service_state_changed_cb(client, callback, user_data);
 716 }
 717
 718 void tts_client_set_synthesized_pcm_cb(tts_client_s* client, tts_synthesized_pcm_cb callback, void* user_data)
 719 {
 720         if (false == tts_client_is_valid_client(client)) {
 721                 return;
 722         }
 723         __set_synthesized_pcm_cb(client, callback, user_data);
 724 }
 725
 726 tts_state_changed_cb tts_client_get_state_changed_cb(tts_client_s* client)
 727 {
 728         if (false == tts_client_is_valid_client(client)) {
 729                 return NULL;
 730         }
 731         return client->state_changed_cb;
 732 }
 733
 734 void* tts_client_get_state_changed_user_data(tts_client_s* client)
 735 {
 736         if (false == tts_client_is_valid_client(client)) {
 737                 return NULL;
 738         }
 739         return client->state_changed_user_data;
 740 }
 741
 742 tts_utterance_started_cb tts_client_get_utterance_started_cb(tts_client_s* client)
 743 {
 744         if (false == tts_client_is_valid_client(client)) {
 745                 return NULL;
 746         }
 747         return client->utt_started_cb;
 748 }
 749
 750 void* tts_client_get_utterance_started_user_data(tts_client_s* client)
 751 {
 752         if (false == tts_client_is_valid_client(client)) {
 753                 return NULL;
 754         }
 755         return client->utt_started_user_data;
 756 }
 757
 758 tts_utterance_completed_cb tts_client_get_utterance_completed_cb(tts_client_s* client)
 759 {
 760         if (false == tts_client_is_valid_client(client)) {
 761                 return NULL;
 762         }
 763         return client->utt_completed_cb;
 764 }
 765
 766 void* tts_client_get_utterance_completed_user_data(tts_client_s* client)
 767 {
 768         if (false == tts_client_is_valid_client(client)) {
 769                 return NULL;
 770         }
 771         return client->utt_completed_user_data;
 772 }
 773
 774 tts_error_cb tts_client_get_error_cb(tts_client_s* client)
 775 {
 776         if (false == tts_client_is_valid_client(client)) {
 777                 return NULL;
 778         }
 779         return client->error_cb;
 780 }
 781
 782 void* tts_client_get_error_user_data(tts_client_s* client)
 783 {
 784         if (false == tts_client_is_valid_client(client)) {
 785                 return NULL;
 786         }
 787         return client->error_user_data;
 788 }
 789
 790 //LCOV_EXCL_START
 791 tts_default_voice_changed_cb tts_client_get_default_voice_changed_cb(tts_client_s* client)
 792 {
 793         if (false == tts_client_is_valid_client(client)) {
 794                 return NULL;
 795         }
 796         return client->default_voice_changed_cb;
 797 }
 798
 799 void* tts_client_get_default_voice_changed_user_data(tts_client_s* client)
 800 {
 801         if (false == tts_client_is_valid_client(client)) {
 802                 return NULL;
 803         }
 804         return client->default_voice_changed_user_data;
 805 }
 806
 807 tts_engine_changed_cb tts_client_get_engine_changed_cb(tts_client_s* client)
 808 {
 809         if (false == tts_client_is_valid_client(client)) {
 810                 return NULL;
 811         }
 812         return client->engine_changed_cb;
 813 }
 814
 815 void* tts_client_get_engine_changed_user_data(tts_client_s* client)
 816 {
 817         if (false == tts_client_is_valid_client(client)) {
 818                 return NULL;
 819         }
 820         return client->engine_changed_user_data;
 821 }
 822 //LCOV_EXCL_STOP
 823
 824 tts_screen_reader_changed_cb tts_client_get_screen_reader_changed_cb(tts_client_s* client)
 825 {
 826         if (false == tts_client_is_valid_client(client)) {
 827                 return NULL;
 828         }
 829         return client->screen_reader_changed_cb;
 830 }
 831
 832 void* tts_client_get_screen_reader_changed_user_data(tts_client_s* client)
 833 {
 834         if (false == tts_client_is_valid_client(client)) {
 835                 return NULL;
 836         }
 837         return client->screen_reader_changed_user_data;
 838 }
 839
 840 tts_supported_voice_cb tts_client_get_supported_voice_cb(tts_client_s* client)
 841 {
 842         if (false == tts_client_is_valid_client(client)) {
 843                 return NULL;
 844         }
 845         return client->supported_voice_cb;
 846 }
 847
 848 void* tts_client_get_supported_voice_user_data(tts_client_s* client)
 849 {
 850         if (false == tts_client_is_valid_client(client)) {
 851                 return NULL;
 852         }
 853         return client->supported_voice_user_data;
 854 }
 855
 856 tts_service_state_changed_cb tts_client_get_service_state_changed_cb(tts_client_s* client)
 857 {
 858         if (false == tts_client_is_valid_client(client)) {
 859                 return NULL;
 860         }
 861         return client->service_state_changed_cb;
 862 }
 863
 864 void* tts_client_get_service_state_changed_user_data(tts_client_s* client)
 865 {
 866         if (false == tts_client_is_valid_client(client)) {
 867                 return NULL;
 868         }
 869         return client->service_state_changed_user_data;
 870 }
 871
 872 //LCOV_EXCL_START
 873 tts_synthesized_pcm_cb tts_client_get_synthesized_pcm_cb(tts_client_s* client)
 874 {
 875         if (false == tts_client_is_valid_client(client)) {
 876                 return NULL;
 877         }
 878         return client->synthesized_pcm_cb;
 879 }
 880
 881 void* tts_client_get_synthesized_pcm_user_data(tts_client_s* client)
 882 {
 883         if (false == tts_client_is_valid_client(client)) {
 884                 return NULL;
 885         }
 886         return client->synthesized_pcm_user_data;
 887 }
 888 //LCOV_EXCL_STOP
 889
 890 int tts_client_get_registered_event_mask(tts_client_s* client)
 891 {
 892         if (false == tts_client_is_valid_client(client)) {
 893                 return 0;
 894         }
 895         return client->registered_event_mask;
 896 }
 897
 898 void tts_client_unset_all_cb(tts_client_s* client)
 899 {
 900         if (false == tts_client_is_valid_client(client)) {
 901                 return;
 902         }
 903
 904         if (NULL != client->notify_state_timer) {
 905                 ecore_timer_del(client->notify_state_timer);
 906                 client->notify_state_timer = NULL;
 907         }
 908
 909         if (NULL != client->notify_error_timer) {
 910                 ecore_timer_del(client->notify_error_timer);
 911                 client->notify_error_timer = NULL;
 912         }
 913
 914         __set_state_changed_cb(client, NULL, NULL);
 915         __set_utterance_started_cb(client, NULL, NULL);
 916         __set_utterance_completed_cb(client, NULL, NULL);
 917         __set_error_cb(client, NULL, NULL);
 918         __set_default_voice_changed_cb(client, NULL, NULL);
 919         __set_engine_changed_cb(client, NULL, NULL);
 920         __set_supported_voice_cb(client, NULL, NULL);
 921         __set_service_state_changed_cb(client, NULL, NULL);
 922         __set_synthesized_pcm_cb(client, NULL, NULL);
 923 }