client/tts.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <app_manager.h>
  15 #include <dirent.h>
  16 #include <Ecore.h>
  17 #include <iconv.h>
  18 #include <sys/stat.h>
  19 #include <sys/types.h>
  20 #include <sys/wait.h>
  21 #include <system_info.h>
  22 #include <vconf.h>
  23
  24 #include "tts.h"
  25 #include "tts_client.h"
  26 #include "tts_config_mgr.h"
  27 #include "tts_dbus.h"
  28 #include "tts_main.h"
  29
  30 #include "tts_internal.h"
  31
  32 static bool g_screen_reader;
  33
  34 static int g_feature_enabled = -1;
  35
  36 static bool g_err_callback_status = false;
  37
  38 static int g_max_text_size = -1;
  39
  40 static Ecore_Timer* g_check_state_timer = NULL;
  41
  42
  43 /* for repetition */
  44 static char* g_language = NULL;
  45
  46 static int g_voice_type = -1;
  47
  48 static int g_speed = -1;
  49
  50
  51 /* Function definition */
  52 static Eina_Bool __tts_notify_state_changed(void *data);
  53 static Eina_Bool __tts_notify_error(void *data);
  54
  55 const char* tts_tag()
  56 {
  57         return "ttsc";
  58 }
  59
  60 static int __tts_get_feature_enabled()
  61 {
  62         if (0 == g_feature_enabled) {
  63                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  64                 return TTS_ERROR_NOT_SUPPORTED;
  65         } else if (-1 == g_feature_enabled) {
  66                 bool tts_supported = false;
  67                 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
  68                         if (false == tts_supported) {
  69                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  70                                 g_feature_enabled = 0;
  71                                 return TTS_ERROR_NOT_SUPPORTED;
  72                         }
  73
  74                         g_feature_enabled = 1;
  75                 } else {
  76                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
  77                         return TTS_ERROR_NOT_SUPPORTED;
  78                 }
  79         }
  80
  81         return 0;
  82 }
  83
  84 static const char* __tts_get_error_code(tts_error_e err)
  85 {
  86         switch (err) {
  87         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
  88         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
  89         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
  90         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
  91         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
  92         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
  93         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
  94         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
  95         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
  96         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
  97         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
  98         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
  99         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
 100         case TTS_ERROR_NOT_SUPPORTED_FEATURE:   return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
 101         case TTS_ERROR_SERVICE_RESET:           return "TTS_ERROR_SERVICE_RESET";
 102         default:
 103                 return "Invalid error code";
 104         }
 105         return NULL;
 106 }
 107
 108 static int __tts_convert_config_error_code(tts_config_error_e code)
 109 {
 110         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_ERROR_NONE;
 111         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_ERROR_OUT_OF_MEMORY;
 112         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_ERROR_IO_ERROR;
 113         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_ERROR_INVALID_PARAMETER;
 114         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_ERROR_INVALID_STATE;
 115         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_ERROR_INVALID_VOICE;
 116         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_ERROR_ENGINE_NOT_FOUND;
 117         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_ERROR_OPERATION_FAILED;
 118         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_ERROR_NOT_SUPPORTED_FEATURE;
 119
 120         return code;
 121 }
 122
 123 //LCOV_EXCL_START
 124 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
 125 {
 126         SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
 127                 before_lang, before_voice_type, language, voice_type);
 128
 129         GList* client_list = NULL;
 130         client_list = tts_client_get_client_list();
 131
 132         GList *iter = NULL;
 133         tts_client_s *data = NULL;
 134
 135         if (g_list_length(client_list) > 0) {
 136                 /* Get a first item */
 137                 iter = g_list_first(client_list);
 138
 139                 while (NULL != iter) {
 140                         data = iter->data;
 141                         if (NULL != data->default_voice_changed_cb) {
 142                                 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
 143                                 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
 144                                         language, voice_type, data->default_voice_changed_user_data);
 145                         }
 146
 147                         /* Check whether language is changed or not. If it is changed, make 'text_repeat' NULL */
 148                         if (0 != strncmp(before_lang, language, strlen(before_lang))) {
 149                                 if (NULL != data->text_repeat) {
 150                                         free(data->text_repeat);
 151                                         data->text_repeat = NULL;
 152                                 }
 153                         }
 154
 155                         /* Next item */
 156                         iter = g_list_next(iter);
 157                 }
 158         }
 159
 160         return;
 161 }
 162
 163 static Eina_Bool __reconnect_by_engine_changed(void* data)
 164 {
 165         tts_h tts = (tts_h)data;
 166
 167         tts_client_s* client = tts_client_get(tts);
 168         if (NULL == client) {
 169                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 170                 return EINA_FALSE;
 171         }
 172
 173         if (TTS_STATE_READY != client->current_state) {
 174                 usleep(10000);
 175                 return EINA_TRUE;
 176         }
 177
 178         int ret = tts_unprepare(tts);
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
 181         }
 182         ret = tts_prepare(tts);
 183         if (0 != ret) {
 184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
 185         }
 186
 187         return EINA_FALSE;
 188 }
 189
 190 void _tts_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
 191 {
 192         tts_h tts = (tts_h)user_data;
 193
 194         tts_client_s* client = tts_client_get(tts);
 195         if (NULL == client) {
 196                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 197                 return;
 198         }
 199
 200         if (NULL != engine_id)  SLOG(LOG_DEBUG, TAG_TTSC, "Engine id(%s)", engine_id);
 201         if (NULL != setting)    SLOG(LOG_DEBUG, TAG_TTSC, "Engine setting(%s)", setting);
 202         if (NULL != language)   SLOG(LOG_DEBUG, TAG_TTSC, "Language(%s)", language);
 203         SLOG(LOG_DEBUG, TAG_TTSC, "Voice type(%d), Auto voice(%s), Credential(%s)", voice_type, auto_voice ? "on" : "off", need_credential ? "need" : "no need");
 204
 205         /* When the default engine is changed, please unload the old engine and load the new one. */
 206         int ret = -1;
 207
 208         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_PAUSED == client->current_state) {
 209                 ret = tts_stop(tts);
 210                 if (0 != ret) {
 211                         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] TTS client stopping...");
 212                 }
 213
 214                 ecore_idler_add(__reconnect_by_engine_changed, (void*)tts);
 215         } else if (TTS_STATE_READY == client->current_state) {
 216                 ret = tts_unprepare(tts);
 217                 if (0 != ret) {
 218                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to unprepare for setting a new engine... (%d)", ret);
 219                 }
 220                 ret = tts_prepare(tts);
 221                 if (0 != ret) {
 222                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
 223                 }
 224         }
 225
 226         /* call callback function */
 227         if (NULL != client->engine_changed_cb) {
 228                 client->engine_changed_cb(tts, engine_id, language, voice_type, need_credential, client->engine_changed_user_data);
 229         } else {
 230                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function for changed engine");
 231         }
 232         return;
 233 }
 234 //LCOV_EXCL_STOP
 235
 236 int tts_create(tts_h* tts)
 237 {
 238         if (0 != __tts_get_feature_enabled()) {
 239                 return TTS_ERROR_NOT_SUPPORTED;
 240         }
 241
 242         SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
 243
 244         /* check param */
 245         if (NULL == tts) {
 246                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 247                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 248                 return TTS_ERROR_INVALID_PARAMETER;
 249         }
 250
 251         if (0 == tts_client_get_size()) {
 252                 if (0 != tts_dbus_open_connection()) {
 253                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
 254                         return TTS_ERROR_OPERATION_FAILED;
 255                 }
 256         }
 257
 258         if (0 != tts_client_new(tts)) {
 259                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
 260                 return TTS_ERROR_OUT_OF_MEMORY;
 261         }
 262
 263         tts_client_s* client = tts_client_get(*tts);
 264         if (NULL == client) {
 265                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 266                 return TTS_ERROR_OPERATION_FAILED;
 267         }
 268
 269         int ret = tts_config_mgr_initialize(client->uid);
 270         if (0 != ret) {
 271                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
 272                 tts_client_destroy(*tts);
 273                 return __tts_convert_config_error_code(ret);
 274         }
 275
 276         ret = tts_config_mgr_set_callback(client->uid, _tts_config_engine_changed_cb, __tts_config_voice_changed_cb, NULL, NULL, client->tts);
 277         if (0 != ret) {
 278                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 279                 tts_client_destroy(*tts);
 280                 return __tts_convert_config_error_code(ret);
 281         }
 282
 283         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 284         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 285
 286         return TTS_ERROR_NONE;
 287 }
 288
 289 int tts_destroy(tts_h tts)
 290 {
 291         if (0 != __tts_get_feature_enabled()) {
 292                 return TTS_ERROR_NOT_SUPPORTED;
 293         }
 294
 295         SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
 296
 297         if (NULL == tts) {
 298                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 299                 return TTS_ERROR_INVALID_PARAMETER;
 300         }
 301
 302         tts_client_s* client = tts_client_get(tts);
 303
 304         /* check handle */
 305         if (NULL == client) {
 306                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 307                 return TTS_ERROR_INVALID_PARAMETER;
 308         }
 309
 310         /* check used callback */
 311         if (0 != tts_client_get_use_callback(client)) {
 312                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 313                 return TTS_ERROR_OPERATION_FAILED;
 314         }
 315
 316         tts_config_mgr_finalize(client->uid);
 317
 318         int ret = -1;
 319         int count = 0;
 320         int screen_reader = -1;
 321
 322         /* check state */
 323         switch (client->current_state) {
 324         case TTS_STATE_PAUSED:
 325         case TTS_STATE_PLAYING:
 326         case TTS_STATE_READY:
 327                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 328                 if (0 != ret) {
 329                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
 330                 } else {
 331                         SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
 332                         g_screen_reader = (bool)screen_reader;
 333                 }
 334                 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 335                         do {
 336                                 ret = tts_dbus_request_finalize(client->uid);
 337                                 if (0 != ret) {
 338                                         //LCOV_EXCL_START
 339                                         if (TTS_ERROR_TIMED_OUT != ret) {
 340                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 341                                                 break;
 342                                         } else {
 343                                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
 344                                                 usleep(10000);
 345                                                 count++;
 346                                                 if (TTS_RETRY_COUNT == count) {
 347                                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 348                                                         break;
 349                                                 }
 350                                         }
 351                                         //LCOV_EXCL_STOP
 352                                 }
 353                         } while (0 != ret);
 354                 } else {
 355                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 356                 }
 357
 358                 client->before_state = client->current_state;
 359                 client->current_state = TTS_STATE_CREATED;
 360
 361         case TTS_STATE_CREATED:
 362                 if (NULL != client->conn_timer) {
 363                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 364                         ecore_timer_del(client->conn_timer);
 365                         client->conn_timer = NULL;
 366                 }
 367                 /* Free resources */
 368                 tts_client_destroy(tts);
 369                 break;
 370
 371         default:
 372                 break;
 373         }
 374
 375         if (0 == tts_client_get_size()) {
 376                 if (0 != tts_dbus_close_connection()) {
 377                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 378                 }
 379         }
 380
 381         if (NULL != g_language) {
 382                 free(g_language);
 383                 g_language = NULL;
 384         }
 385
 386         /* Delete state timer before destroying handle */
 387         if (NULL != g_check_state_timer) {
 388                 ecore_timer_del(g_check_state_timer);
 389                 g_check_state_timer = NULL;
 390         }
 391
 392         tts = NULL;
 393
 394         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 395
 396         return TTS_ERROR_NONE;
 397 }
 398
 399 //LCOV_EXCL_START
 400 void __tts_screen_reader_changed_cb(bool value)
 401 {
 402         g_screen_reader = value;
 403 }
 404 //LCOV_EXCL_STOP
 405
 406 int tts_set_mode(tts_h tts, tts_mode_e mode)
 407 {
 408         if (0 != __tts_get_feature_enabled()) {
 409                 return TTS_ERROR_NOT_SUPPORTED;
 410         }
 411
 412         SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
 413
 414         tts_client_s* client = tts_client_get(tts);
 415
 416         /* check handle */
 417         if (NULL == client) {
 418                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 419                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 420                 return TTS_ERROR_INVALID_PARAMETER;
 421         }
 422
 423         /* check state */
 424         if (client->current_state != TTS_STATE_CREATED) {
 425                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 426                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 427                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 428                 return TTS_ERROR_INVALID_STATE;
 429         }
 430
 431         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
 432                 client->mode = mode;
 433         } else {
 434                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 435                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 436                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 437                 return TTS_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         if (TTS_MODE_SCREEN_READER == mode) {
 441                 int ret;
 442                 int screen_reader;
 443                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 444                 if (0 != ret) {
 445                         SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 446                         return TTS_ERROR_OPERATION_FAILED;
 447                 }
 448                 g_screen_reader = (bool)screen_reader;
 449                 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
 450         } else {
 451                 tts_config_unset_screen_reader_callback(client->uid);
 452         }
 453
 454         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 455
 456         return TTS_ERROR_NONE;
 457 }
 458
 459 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 460 {
 461         if (0 != __tts_get_feature_enabled()) {
 462                 return TTS_ERROR_NOT_SUPPORTED;
 463         }
 464
 465         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
 466
 467         tts_client_s* client = tts_client_get(tts);
 468
 469         /* check handle */
 470         if (NULL == client) {
 471                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 472                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 473                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 474                 return TTS_ERROR_INVALID_PARAMETER;
 475         }
 476
 477         /* check state */
 478         if (client->current_state != TTS_STATE_CREATED) {
 479                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 480                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 481                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 482                 return TTS_ERROR_INVALID_STATE;
 483         }
 484
 485         if (NULL == mode) {
 486                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 487                 return TTS_ERROR_INVALID_PARAMETER;
 488         }
 489
 490         *mode = client->mode;
 491
 492         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 493         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 494
 495         return TTS_ERROR_NONE;
 496 }
 497
 498 int tts_set_credential(tts_h tts, const char* credential)
 499 {
 500         if (0 != __tts_get_feature_enabled()) {
 501                 return TTS_ERROR_NOT_SUPPORTED;
 502         }
 503
 504         if (NULL == tts || NULL == credential) {
 505                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 506                 return TTS_ERROR_INVALID_PARAMETER;
 507         }
 508
 509         tts_client_s* client = tts_client_get(tts);
 510
 511         if (NULL == client) {
 512                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 513                 return TTS_ERROR_INVALID_PARAMETER;
 514         }
 515
 516         if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
 517                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
 518                 return TTS_ERROR_INVALID_STATE;
 519         }
 520
 521         if (NULL != client->credential) {
 522                 free(client->credential);
 523                 client->credential = NULL;
 524         }
 525         client->credential = strdup(credential);
 526
 527         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 528
 529         return TTS_ERROR_NONE;
 530 }
 531
 532 //LCOV_EXCL_START
 533 int tts_set_server_tts(tts_h tts, const char* credential)
 534 {
 535         if (0 != __tts_get_feature_enabled()) {
 536                 return TTS_ERROR_NOT_SUPPORTED;
 537         }
 538
 539         if (NULL == tts) {
 540                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 541                 return TTS_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         tts_client_s* client = tts_client_get(tts);
 545
 546         if (NULL == client) {
 547                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 548                 return TTS_ERROR_INVALID_PARAMETER;
 549         }
 550
 551         if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
 552                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
 553                 return TTS_ERROR_INVALID_STATE;
 554         }
 555
 556         if (NULL != client->credential) {
 557                 free(client->credential);
 558                 client->credential = NULL;
 559         }
 560
 561         client->internal = true;
 562
 563         char* key = NULL;
 564         if (NULL != credential) {
 565                 key = strdup("EnableServerTTS");
 566                 client->credential = strdup(credential);
 567                 if (NULL == client->credential) {
 568                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 569                         if (NULL != key) {
 570                                 free(key);
 571                                 key = NULL;
 572                         }
 573                         return TTS_ERROR_OUT_OF_MEMORY;
 574                 }
 575         } else {
 576                 key = strdup("DisableServerTTS");
 577         }
 578
 579         if (NULL == key) {
 580                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 581                 return TTS_ERROR_OUT_OF_MEMORY;
 582         }
 583
 584         int pid = getpid();
 585         char* appid = NULL;
 586         int ret = app_manager_get_app_id(pid, &appid);
 587         if (0 != ret || NULL == appid) {
 588                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 589                 free(key);
 590                 key = NULL;
 591                 if (NULL != appid) {
 592                         free(appid);
 593                         appid = NULL;
 594                 }
 595                 return TTS_ERROR_OPERATION_FAILED;
 596         }
 597
 598         ret = tts_set_private_data(tts, key, appid);
 599         if (0 != ret) {
 600                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 601                 free(key);
 602                 key = NULL;
 603                 free(appid);
 604                 appid = NULL;
 605                 return ret;
 606         }
 607
 608         free(appid);
 609         appid = NULL;
 610         free(key);
 611         key = NULL;
 612
 613         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 614
 615         return TTS_ERROR_NONE;
 616 }
 617 // LCOV_EXCL_STOP
 618
 619 static Eina_Bool __tts_connect_daemon(void *data)
 620 {
 621         tts_h tts = (tts_h)data;
 622         tts_client_s* client = tts_client_get(tts);
 623
 624         /* check handle */
 625         if (NULL == client) {
 626                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 627                 return EINA_FALSE;
 628         }
 629
 630         /* Send hello */
 631         if (0 != tts_dbus_request_hello(client->uid)) {
 632                 return EINA_TRUE;
 633         }
 634
 635         SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 636
 637         /* do request initialize */
 638         int ret = -1;
 639         bool credential_needed = false;
 640
 641         ret = tts_dbus_request_initialize(client->uid, &credential_needed);
 642
 643         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 644                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 645
 646                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 647                 client->utt_id = -1;
 648
 649                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 650                 if (client->conn_timer) {
 651                         ecore_timer_del(client->conn_timer);
 652                         client->conn_timer = NULL;
 653                 }
 654                 return EINA_FALSE;
 655
 656         } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
 657                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 658
 659                 client->reason = TTS_ERROR_PERMISSION_DENIED;
 660                 client->utt_id = -1;
 661
 662                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 663                 if (client->conn_timer) {
 664                         ecore_timer_del(client->conn_timer);
 665                         client->conn_timer = NULL;
 666                 }
 667                 return EINA_FALSE;
 668
 669         } else if (TTS_ERROR_NONE != ret) {
 670                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 671                 return EINA_TRUE;
 672
 673         } else {
 674                 /* success to connect tts-daemon */
 675                 client->credential_needed = credential_needed;
 676                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 677         }
 678
 679         if (client->conn_timer) {
 680                 ecore_timer_del(client->conn_timer);
 681                 client->conn_timer = NULL;
 682         }
 683
 684         client = tts_client_get(tts);
 685         /* check handle */
 686         if (NULL == client) {
 687                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 688                 return EINA_FALSE;
 689         }
 690
 691         client->before_state = client->current_state;
 692         client->current_state = TTS_STATE_READY;
 693
 694         if (NULL != client->state_changed_cb) {
 695                 tts_client_use_callback(client);
 696                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 697                 tts_client_not_use_callback(client);
 698         } else {
 699                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 700         }
 701
 702         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 703
 704         return EINA_FALSE;
 705 }
 706
 707 int tts_prepare(tts_h tts)
 708 {
 709         if (0 != __tts_get_feature_enabled()) {
 710                 return TTS_ERROR_NOT_SUPPORTED;
 711         }
 712
 713         SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 714
 715         tts_client_s* client = tts_client_get(tts);
 716
 717         /* check handle */
 718         if (NULL == client) {
 719                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 720                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 721                 return TTS_ERROR_INVALID_PARAMETER;
 722         }
 723
 724         /* check state */
 725         if (client->current_state != TTS_STATE_CREATED) {
 726                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 727                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 728                 return TTS_ERROR_INVALID_STATE;
 729         }
 730
 731         ecore_thread_main_loop_begin();
 732         if (client->conn_timer) {
 733                 ecore_timer_del(client->conn_timer);
 734                 client->conn_timer = NULL;
 735         }
 736         client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
 737         ecore_thread_main_loop_end();
 738
 739         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 740
 741         return TTS_ERROR_NONE;
 742 }
 743
 744 //LCOV_EXCL_START
 745 int tts_prepare_sync(tts_h tts)
 746 {
 747         if (0 != __tts_get_feature_enabled()) {
 748                 return TTS_ERROR_NOT_SUPPORTED;
 749         }
 750
 751         SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 752
 753         tts_client_s* client = tts_client_get(tts);
 754
 755         /* check handle */
 756         if (NULL == client) {
 757                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 758                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 759                 return TTS_ERROR_INVALID_PARAMETER;
 760         }
 761
 762         /* check state */
 763         if (client->current_state != TTS_STATE_CREATED) {
 764                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 765                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 766                 return TTS_ERROR_INVALID_STATE;
 767         }
 768
 769         int cnt = 0;
 770         while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
 771                 cnt++;
 772         }
 773
 774         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 775
 776         if (TTS_CONNECTION_RETRY_COUNT == cnt) {
 777                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
 778                 return TTS_ERROR_OPERATION_FAILED;
 779         }
 780
 781         return TTS_ERROR_NONE;
 782 }
 783 //LCOV_EXCL_STOP
 784
 785 int tts_unprepare(tts_h tts)
 786 {
 787         if (0 != __tts_get_feature_enabled()) {
 788                 return TTS_ERROR_NOT_SUPPORTED;
 789         }
 790
 791         SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
 792
 793         tts_client_s* client = tts_client_get(tts);
 794
 795         /* check handle */
 796         if (NULL == client) {
 797                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 798                 return TTS_ERROR_INVALID_PARAMETER;
 799         }
 800
 801         /* check state */
 802         if (client->current_state != TTS_STATE_READY) {
 803                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 804                 return TTS_ERROR_INVALID_STATE;
 805         }
 806
 807         int ret = -1;
 808         int count = 0;
 809         int screen_reader = -1;
 810
 811         ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 812         if (0 != ret) {
 813                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
 814         } else {
 815                 SLOG(LOG_INFO, tts_tag(), "[INFO] Success to get screen reader(%d), g_screen_reader(%s), client->mode(%d)", screen_reader, (true == g_screen_reader) ? "True" : "False", client->mode);
 816                 g_screen_reader = (bool)screen_reader;
 817         }
 818
 819         bool is_prepared = false;
 820         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 821                 do {
 822                         ret = tts_dbus_request_finalize(client->uid);
 823                         if (0 != ret) {
 824                                 //LCOV_EXCL_START
 825                                 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
 826                                         client->current_state = TTS_STATE_CREATED;
 827                                         if (0 == tts_prepare_sync(tts)) {
 828                                                 is_prepared = true;
 829                                                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
 830                                         }
 831                                 } else if (TTS_ERROR_TIMED_OUT != ret) {
 832                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 833                                         break;
 834                                 } else {
 835                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 836                                         usleep(10000);
 837                                         count++;
 838                                         if (TTS_RETRY_COUNT == count) {
 839                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 840                                                 break;
 841                                         }
 842                                 }
 843                                 //LCOV_EXCL_STOP
 844                         }
 845                 } while (0 != ret);
 846         } else {
 847                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 848         }
 849
 850         client->before_state = client->current_state;
 851         client->current_state = TTS_STATE_CREATED;
 852
 853         if (NULL != client->state_changed_cb) {
 854                 tts_client_use_callback(client);
 855                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 856                 tts_client_not_use_callback(client);
 857                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 858         }
 859
 860         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 861
 862         return TTS_ERROR_NONE;
 863 }
 864
 865 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 866 {
 867         tts_h tts = (tts_h)user_data;
 868
 869         tts_client_s* client = tts_client_get(tts);
 870         if (NULL == client) {
 871                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 872                 return false;
 873         }
 874
 875         /* call callback function */
 876         if (NULL != client->supported_voice_cb) {
 877                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 878         } else {
 879                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 880         }
 881
 882         return false;
 883 }
 884
 885 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 886 {
 887         if (0 != __tts_get_feature_enabled()) {
 888                 return TTS_ERROR_NOT_SUPPORTED;
 889         }
 890
 891         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 892
 893         if (NULL == tts || NULL == callback) {
 894                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 895                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 896                 return TTS_ERROR_INVALID_PARAMETER;
 897         }
 898
 899         tts_client_s* client = tts_client_get(tts);
 900
 901         /* check handle */
 902         if (NULL == client) {
 903                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 904                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 905                 return TTS_ERROR_INVALID_PARAMETER;
 906         }
 907
 908         int ret = 0;
 909         char* current_engine = NULL;
 910         ret = tts_config_mgr_get_engine(&current_engine);
 911         if (0 != ret) {
 912                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 913                 return __tts_convert_config_error_code(ret);
 914         }
 915
 916         client->supported_voice_cb = callback;
 917         client->supported_voice_user_data = user_data;
 918
 919         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 920
 921         if (NULL != current_engine) {
 922                 free(current_engine);
 923                 current_engine = NULL;
 924         }
 925
 926         client->supported_voice_cb = NULL;
 927         client->supported_voice_user_data = NULL;
 928
 929         if (0 != ret) {
 930                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 931                 ret = TTS_ERROR_OPERATION_FAILED;
 932         }
 933
 934         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 935
 936         return ret;
 937 }
 938
 939 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 940 {
 941         if (0 != __tts_get_feature_enabled()) {
 942                 return TTS_ERROR_NOT_SUPPORTED;
 943         }
 944
 945         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 946
 947         if (NULL == tts) {
 948                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 949                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 950                 return TTS_ERROR_INVALID_PARAMETER;
 951
 952         }
 953         tts_client_s* client = tts_client_get(tts);
 954
 955         if (NULL == client) {
 956                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 957                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 958                 return TTS_ERROR_INVALID_PARAMETER;
 959         }
 960
 961         /* Request call remote method */
 962         int ret = 0;
 963         ret = tts_config_mgr_get_voice(lang, vctype);
 964         if (0 != ret) {
 965                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 966                 return __tts_convert_config_error_code(ret);
 967         } else {
 968                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 969         }
 970
 971         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 972
 973         return ret;
 974 }
 975
 976 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 977 {
 978         if (0 != __tts_get_feature_enabled()) {
 979                 return TTS_ERROR_NOT_SUPPORTED;
 980         }
 981
 982         if (NULL == tts || NULL == size) {
 983                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 984                 return TTS_ERROR_INVALID_PARAMETER;
 985         }
 986
 987         tts_client_s* client = tts_client_get(tts);
 988
 989         if (NULL == client) {
 990                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 991                 return TTS_ERROR_INVALID_PARAMETER;
 992         }
 993
 994         if (TTS_STATE_READY != client->current_state) {
 995                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 996                 return TTS_ERROR_INVALID_STATE;
 997         }
 998
 999         if (0 != tts_config_mgr_get_max_text_size(size)) {
1000                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1001                 return TTS_ERROR_INVALID_PARAMETER;
1002         }
1003
1004         g_max_text_size = (int)*size;
1005
1006         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
1007         return TTS_ERROR_NONE;
1008 }
1009
1010 int tts_get_state(tts_h tts, tts_state_e* state)
1011 {
1012         if (0 != __tts_get_feature_enabled()) {
1013                 return TTS_ERROR_NOT_SUPPORTED;
1014         }
1015
1016         if (NULL == tts || NULL == state) {
1017                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
1018                 return TTS_ERROR_INVALID_PARAMETER;
1019         }
1020
1021         tts_client_s* client = tts_client_get(tts);
1022
1023         if (NULL == client) {
1024                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1025                 return TTS_ERROR_INVALID_PARAMETER;
1026         }
1027
1028         *state = client->current_state;
1029
1030         switch (*state) {
1031         case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
1032         case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
1033         case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
1034         case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
1035         default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
1036         }
1037
1038         return TTS_ERROR_NONE;
1039 }
1040
1041 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
1042 {
1043         if (0 != __tts_get_feature_enabled()) {
1044                 return TTS_ERROR_NOT_SUPPORTED;
1045         }
1046
1047         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
1048                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1049                 return TTS_ERROR_INVALID_PARAMETER;
1050         }
1051
1052         tts_client_s* client = tts_client_get(tts);
1053
1054         if (NULL == client) {
1055                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1056                 return TTS_ERROR_INVALID_PARAMETER;
1057         }
1058
1059         *min = TTS_SPEED_MIN;
1060         *normal = TTS_SPEED_NORMAL;
1061         *max = TTS_SPEED_MAX;
1062
1063         return TTS_ERROR_NONE;
1064 }
1065
1066 int tts_get_error_message(tts_h tts, char** err_msg)
1067 {
1068         if (0 != __tts_get_feature_enabled()) {
1069                 return TTS_ERROR_NOT_SUPPORTED;
1070         }
1071
1072         if (NULL == tts || NULL == err_msg) {
1073                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1074                 return TTS_ERROR_INVALID_PARAMETER;
1075         }
1076
1077         tts_client_s* client = tts_client_get(tts);
1078
1079         if (NULL == client) {
1080                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1081                 return TTS_ERROR_INVALID_PARAMETER;
1082         }
1083
1084         if (NULL != client->err_msg) {
1085                 *err_msg = strdup(client->err_msg);
1086                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1087         } else {
1088                 *err_msg = NULL;
1089                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1090         }
1091
1092         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1093
1094         return TTS_ERROR_NONE;
1095 }
1096
1097 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1098 {
1099         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1100
1101         if (0 != __tts_get_feature_enabled()) {
1102                 return TTS_ERROR_NOT_SUPPORTED;
1103         }
1104
1105         if (speed < 0) {
1106                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1107                 return TTS_ERROR_INVALID_PARAMETER;
1108         }
1109
1110         if (voice_type < 0) {
1111                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1112                 return TTS_ERROR_INVALID_PARAMETER;
1113         }
1114
1115         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1116
1117         if (NULL == tts || NULL == utt_id) {
1118                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1119                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1120                 return TTS_ERROR_INVALID_PARAMETER;
1121         }
1122
1123         tts_client_s* client = tts_client_get(tts);
1124
1125         if (NULL == client) {
1126                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1127                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1128                 return TTS_ERROR_INVALID_PARAMETER;
1129         }
1130
1131         if (TTS_STATE_CREATED == client->current_state) {
1132                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1133                 return TTS_ERROR_INVALID_STATE;
1134         }
1135
1136         if (-1 == g_max_text_size) {
1137                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1138                 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1139                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1140                         return TTS_ERROR_INVALID_PARAMETER;
1141                 }
1142         }
1143
1144         if (0 == g_max_text_size) {
1145                 if (strlen(text) <= 0) {
1146                         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1147                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1148                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1149                         return TTS_ERROR_INVALID_PARAMETER;
1150                 }
1151         } else {
1152                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1153                 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1154                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1155                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1156                         return TTS_ERROR_INVALID_PARAMETER;
1157                 }
1158         }
1159
1160         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1162                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1163                 return TTS_ERROR_INVALID_PARAMETER;
1164         }
1165
1166         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1167                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1168                 return TTS_ERROR_INVALID_STATE;
1169         }
1170
1171         if (true == client->credential_needed && NULL == client->credential) {
1172                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1173                 return TTS_ERROR_PERMISSION_DENIED;
1174         }
1175
1176         /* check valid utf8 */
1177         bool valid = false;
1178
1179         DBusError err;
1180         dbus_error_init(&err);
1181
1182         valid = dbus_validate_utf8(text, &err);
1183         if (dbus_error_is_set(&err)) {
1184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1185                 dbus_error_free(&err);
1186                 return TTS_ERROR_INVALID_PARAMETER;
1187         }
1188
1189         if (valid != true) {
1190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1191                 return TTS_ERROR_INVALID_PARAMETER;
1192         }
1193         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1194
1195         /* save texts for repetition */
1196         if (NULL != client->text_repeat) {
1197                 free(client->text_repeat);
1198                 client->text_repeat = NULL;
1199         }
1200
1201         client->text_repeat = strdup(text);
1202
1203         if (NULL != g_language) {
1204                 free(g_language);
1205                 g_language = NULL;
1206         }
1207         if (NULL == language)
1208                 g_language = NULL;
1209         else
1210                 g_language = strdup(language);
1211
1212         g_voice_type = voice_type;
1213         g_speed = speed;
1214
1215         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] repeat: text(%s), language(%s), voice type(%d), speed(%d)", client->text_repeat, g_language, g_voice_type, g_speed);
1216
1217         /* change default language value */
1218         char* temp = NULL;
1219
1220         if (NULL == language)
1221                 temp = strdup("default");
1222         else
1223                 temp = strdup(language);
1224
1225         client->current_utt_id++;
1226         if (client->current_utt_id == 10000) {
1227                 client->current_utt_id = 1;
1228         }
1229
1230         /* do request */
1231         int ret = -1;
1232         int count = 0;
1233         bool is_prepared = false;
1234         while (0 != ret) {
1235                 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1236                 if (0 != ret) {
1237                         //LCOV_EXCL_START
1238                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1239                                 client->current_state = TTS_STATE_CREATED;
1240                                 if (0 == tts_prepare_sync(tts)) {
1241                                         is_prepared = true;
1242                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1243                                 }
1244                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1245                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1246                                 break;
1247                         } else {
1248                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1249                                 usleep(10000);
1250                                 count++;
1251                                 if (TTS_RETRY_MIN_COUNT == count) {
1252                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1253                                         break;
1254                                 }
1255                         }
1256                         //LCOV_EXCL_STOP
1257                 } else {
1258                         *utt_id = client->current_utt_id;
1259                 }
1260         }
1261
1262         if (NULL != temp) {
1263                 free(temp);
1264                 temp = NULL;
1265         }
1266
1267         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1268
1269         return ret;
1270 }
1271
1272 //LCOV_EXCL_START
1273 static void __tts_play_async(void *data)
1274 {
1275         tts_h tts = (tts_h)data;
1276         tts_client_s* client = tts_client_get(tts);
1277
1278         /* check handle */
1279         if (NULL == client) {
1280                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1281                 return;
1282         }
1283
1284         int ret = -1;
1285         int count = 0;
1286         bool is_prepared = false;
1287         while (0 != ret) {
1288                 ret = tts_dbus_request_play(client->uid, client->credential);
1289                 if (0 != ret) {
1290                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1291                                 client->current_state = TTS_STATE_CREATED;
1292                                 if (0 == tts_prepare_sync(tts)) {
1293                                         is_prepared = true;
1294                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1295                                 }
1296                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1297                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1298                                 break;
1299                         } else {
1300                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1301                                 usleep(10000);
1302                                 count++;
1303                                 if (TTS_RETRY_COUNT == count) {
1304                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1305                                         break;
1306                                 }
1307                         }
1308                 }
1309         }
1310
1311         if (0 != ret) {
1312                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1313
1314                 client->reason = ret;
1315                 client->utt_id = -1;
1316
1317                 ecore_timer_add(0, __tts_notify_error, client->tts);
1318                 return;
1319         }
1320
1321         client->before_state = client->current_state;
1322         client->current_state = TTS_STATE_PLAYING;
1323
1324         if (NULL != client->state_changed_cb) {
1325                 tts_client_use_callback(client);
1326                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1327                 tts_client_not_use_callback(client);
1328                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1329         }
1330
1331         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1332
1333         return;
1334 }
1335
1336 int tts_play_async(tts_h tts)
1337 {
1338         if (0 != __tts_get_feature_enabled()) {
1339                 return TTS_ERROR_NOT_SUPPORTED;
1340         }
1341
1342         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1343
1344         if (NULL == tts) {
1345                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1346                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1347                 return TTS_ERROR_INVALID_PARAMETER;
1348         }
1349
1350         tts_client_s* client = tts_client_get(tts);
1351
1352         if (NULL == client) {
1353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1354                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1355                 return TTS_ERROR_INVALID_PARAMETER;
1356         }
1357
1358         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1359                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1360                 return TTS_ERROR_INVALID_STATE;
1361         }
1362
1363         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1364                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1365                 return TTS_ERROR_INVALID_STATE;
1366         }
1367
1368         if (true == client->credential_needed && NULL == client->credential) {
1369                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1370                 return TTS_ERROR_PERMISSION_DENIED;
1371         }
1372
1373         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1374
1375         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1376
1377         return TTS_ERROR_NONE;
1378 }
1379 //LCOV_EXCL_STOP
1380 int tts_play(tts_h tts)
1381 {
1382         if (0 != __tts_get_feature_enabled()) {
1383                 return TTS_ERROR_NOT_SUPPORTED;
1384         }
1385
1386         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1387
1388         if (NULL == tts) {
1389                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1390                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1391                 return TTS_ERROR_INVALID_PARAMETER;
1392         }
1393
1394         tts_client_s* client = tts_client_get(tts);
1395
1396         if (NULL == client) {
1397                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1398                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1399                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1400                 return TTS_ERROR_INVALID_PARAMETER;
1401         }
1402
1403         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1404                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1405                 return TTS_ERROR_INVALID_STATE;
1406         }
1407
1408         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1409                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1410                 return TTS_ERROR_INVALID_STATE;
1411         }
1412
1413         if (true == client->credential_needed && NULL == client->credential) {
1414                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1415                 return TTS_ERROR_PERMISSION_DENIED;
1416         }
1417
1418         int ret = -1;
1419         int count = 0;
1420         bool is_prepared = false;
1421         while (0 != ret) {
1422                 ret = tts_dbus_request_play(client->uid, client->credential);
1423                 if (0 != ret) {
1424                         //LCOV_EXCL_START
1425                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1426                                 client->current_state = TTS_STATE_CREATED;
1427                                 if (0 == tts_prepare_sync(tts)) {
1428                                         is_prepared = true;
1429                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1430                                 }
1431                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1432                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1433                                 return ret;
1434                         } else {
1435                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1436                                 usleep(10000);
1437                                 count++;
1438                                 if (TTS_RETRY_COUNT == count) {
1439                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1440                                         return ret;
1441                                 }
1442                         }
1443                         //LCOV_EXCL_STOP
1444                 }
1445         }
1446
1447         client->before_state = client->current_state;
1448         client->current_state = TTS_STATE_PLAYING;
1449
1450         if (NULL != client->state_changed_cb) {
1451                 tts_client_use_callback(client);
1452                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1453                 tts_client_not_use_callback(client);
1454                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1455         }
1456
1457         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1458
1459         return TTS_ERROR_NONE;
1460 }
1461 //LCOV_EXCL_START
1462 static void __tts_stop_async(void *data)
1463 {
1464         tts_h tts = (tts_h)data;
1465         tts_client_s* client = tts_client_get(tts);
1466
1467         /* check handle */
1468         if (NULL == client) {
1469                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1470                 return;
1471         }
1472
1473         int ret = -1;
1474         int count = 0;
1475         bool is_prepared = false;
1476         while (0 != ret) {
1477                 ret = tts_dbus_request_stop(client->uid);
1478                 if (0 != ret) {
1479                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1480                                 client->current_state = TTS_STATE_CREATED;
1481                                 if (0 == tts_prepare_sync(tts)) {
1482                                         is_prepared = true;
1483                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1484                                 }
1485                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1486                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1487                                 break;
1488                         } else {
1489                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1490                                 usleep(10000);
1491                                 count++;
1492                                 if (TTS_RETRY_COUNT == count) {
1493                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1494                                         break;
1495                                 }
1496                         }
1497                 }
1498         }
1499
1500         if (0 != ret) {
1501                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1502
1503                 client->reason = ret;
1504                 client->utt_id = -1;
1505
1506                 ecore_timer_add(0, __tts_notify_error, client->tts);
1507                 return;
1508         }
1509
1510         client->before_state = client->current_state;
1511         client->current_state = TTS_STATE_READY;
1512
1513         if (NULL != client->state_changed_cb) {
1514                 tts_client_use_callback(client);
1515                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1516                 tts_client_not_use_callback(client);
1517                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1518         }
1519
1520         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1521
1522         return;
1523 }
1524
1525 int tts_stop_aync(tts_h tts)
1526 {
1527         if (0 != __tts_get_feature_enabled()) {
1528                 return TTS_ERROR_NOT_SUPPORTED;
1529         }
1530
1531         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1532
1533         if (NULL == tts) {
1534                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1535                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1536                 return TTS_ERROR_INVALID_PARAMETER;
1537         }
1538
1539         tts_client_s* client = tts_client_get(tts);
1540
1541         if (NULL == client) {
1542                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1543                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1544                 return TTS_ERROR_INVALID_PARAMETER;
1545         }
1546
1547         if (TTS_STATE_CREATED == client->current_state) {
1548                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1549                 return TTS_ERROR_INVALID_STATE;
1550         }
1551
1552         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1553                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1554                 return TTS_ERROR_INVALID_STATE;
1555         }
1556
1557         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1558
1559         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1560
1561         return TTS_ERROR_NONE;
1562 }
1563 //LCOV_EXCL_STOP
1564 int tts_stop(tts_h tts)
1565 {
1566         if (0 != __tts_get_feature_enabled()) {
1567                 return TTS_ERROR_NOT_SUPPORTED;
1568         }
1569
1570         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1571
1572         if (NULL == tts) {
1573                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1574                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1575                 return TTS_ERROR_INVALID_PARAMETER;
1576         }
1577
1578         tts_client_s* client = tts_client_get(tts);
1579
1580         if (NULL == client) {
1581                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1582                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1583                 return TTS_ERROR_INVALID_PARAMETER;
1584         }
1585
1586         if (TTS_STATE_CREATED == client->current_state) {
1587                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1588                 return TTS_ERROR_INVALID_STATE;
1589         }
1590
1591         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1592                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1593                 return TTS_ERROR_INVALID_STATE;
1594         }
1595
1596         int ret = -1;
1597         int count = 0;
1598         bool is_prepared = false;
1599         while (0 != ret) {
1600                 ret = tts_dbus_request_stop(client->uid);
1601                 if (0 != ret) {
1602                         //LCOV_EXCL_START
1603                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1604                                 client->current_state = TTS_STATE_CREATED;
1605                                 if (0 == tts_prepare_sync(tts)) {
1606                                         is_prepared = true;
1607                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1608                                 }
1609                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1610                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1611                                 return ret;
1612                         } else {
1613                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1614                                 usleep(10000);
1615                                 count++;
1616                                 if (TTS_RETRY_COUNT == count) {
1617                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1618                                         return ret;
1619                                 }
1620                         }
1621                         //LCOV_EXCL_STOP
1622                 }
1623         }
1624
1625         client->before_state = client->current_state;
1626         client->current_state = TTS_STATE_READY;
1627
1628         if (NULL != client->state_changed_cb) {
1629                 tts_client_use_callback(client);
1630                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1631                 tts_client_not_use_callback(client);
1632                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1633         }
1634
1635         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1636
1637         return TTS_ERROR_NONE;
1638 }
1639 //LCOV_EXCL_START
1640 static void __tts_pause_async(void *data)
1641 {
1642         tts_h tts = (tts_h)data;
1643         tts_client_s* client = tts_client_get(tts);
1644
1645         /* check handle */
1646         if (NULL == client) {
1647                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1648                 return;
1649         }
1650
1651         int ret = -1;
1652         int count = 0;
1653         bool is_prepared = false;
1654         while (0 != ret) {
1655                 ret = tts_dbus_request_pause(client->uid);
1656                 if (0 != ret) {
1657                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1658                                 client->current_state = TTS_STATE_CREATED;
1659                                 if (0 == tts_prepare_sync(tts)) {
1660                                         is_prepared = true;
1661                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1662                                 }
1663                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1664                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1665                                 break;
1666                         } else {
1667                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1668                                 usleep(10000);
1669                                 count++;
1670                                 if (TTS_RETRY_COUNT == count) {
1671                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1672                                         break;
1673                                 }
1674                         }
1675                 }
1676         }
1677
1678         if (0 != ret) {
1679                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1680
1681                 client->reason = ret;
1682                 client->utt_id = -1;
1683
1684                 ecore_timer_add(0, __tts_notify_error, client->tts);
1685                 return;
1686         }
1687
1688         client->before_state = client->current_state;
1689         client->current_state = TTS_STATE_PAUSED;
1690
1691         if (NULL != client->state_changed_cb) {
1692                 tts_client_use_callback(client);
1693                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1694                 tts_client_not_use_callback(client);
1695                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1696         }
1697
1698         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1699
1700         return;
1701 }
1702
1703 int tts_pause_async(tts_h tts)
1704 {
1705         if (0 != __tts_get_feature_enabled()) {
1706                 return TTS_ERROR_NOT_SUPPORTED;
1707         }
1708
1709         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1710
1711         if (NULL == tts) {
1712                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1713                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1714                 return TTS_ERROR_INVALID_PARAMETER;
1715         }
1716
1717         tts_client_s* client = tts_client_get(tts);
1718
1719         if (NULL == client) {
1720                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1721                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1722                 return TTS_ERROR_INVALID_PARAMETER;
1723         }
1724
1725         if (TTS_STATE_PLAYING != client->current_state) {
1726                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1727                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1728                 return TTS_ERROR_INVALID_STATE;
1729         }
1730
1731         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1732                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1733                 return TTS_ERROR_INVALID_STATE;
1734         }
1735
1736         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1737
1738         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1739
1740         return TTS_ERROR_NONE;
1741 }
1742 //LCOV_EXCL_STOP
1743 int tts_pause(tts_h tts)
1744 {
1745         if (0 != __tts_get_feature_enabled()) {
1746                 return TTS_ERROR_NOT_SUPPORTED;
1747         }
1748
1749         SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1750
1751         if (NULL == tts) {
1752                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1753                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1754                 return TTS_ERROR_INVALID_PARAMETER;
1755         }
1756
1757         tts_client_s* client = tts_client_get(tts);
1758
1759         if (NULL == client) {
1760                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1761                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1762                 return TTS_ERROR_INVALID_PARAMETER;
1763         }
1764
1765         if (TTS_STATE_PLAYING != client->current_state) {
1766                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1767                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1768                 return TTS_ERROR_INVALID_STATE;
1769         }
1770
1771         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1772                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1773                 return TTS_ERROR_INVALID_STATE;
1774         }
1775
1776         int ret = -1;
1777         int count = 0;
1778         bool is_prepared = false;
1779         while (0 != ret) {
1780                 ret = tts_dbus_request_pause(client->uid);
1781                 if (0 != ret) {
1782                         //LCOV_EXCL_START
1783                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1784                                 client->current_state = TTS_STATE_CREATED;
1785                                 if (0 == tts_prepare_sync(tts)) {
1786                                         is_prepared = true;
1787                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1788                                 }
1789                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1790                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1791                                 return ret;
1792                         } else {
1793                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1794                                 usleep(10000);
1795                                 count++;
1796                                 if (TTS_RETRY_COUNT == count) {
1797                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1798                                         return ret;
1799                                 }
1800                         }
1801                         //LCOV_EXCL_STOP
1802                 }
1803         }
1804
1805         client->before_state = client->current_state;
1806         client->current_state = TTS_STATE_PAUSED;
1807
1808         if (NULL != client->state_changed_cb) {
1809                 tts_client_use_callback(client);
1810                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1811                 tts_client_not_use_callback(client);
1812                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1813         }
1814
1815         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1816
1817         return TTS_ERROR_NONE;
1818 }
1819
1820 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1821 {
1822         if (0 != __tts_get_feature_enabled()) {
1823                 return TTS_ERROR_NOT_SUPPORTED;
1824         }
1825
1826         SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1827
1828         if (NULL == tts) {
1829                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1830                 return TTS_ERROR_INVALID_PARAMETER;
1831         }
1832
1833         if (NULL == key || NULL == data) {
1834                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1835                 return TTS_ERROR_INVALID_PARAMETER;
1836         }
1837
1838         tts_client_s* client = tts_client_get(tts);
1839
1840         if (NULL == client) {
1841                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1842                 return TTS_ERROR_INVALID_PARAMETER;
1843         }
1844
1845         if (TTS_STATE_READY != client->current_state) {
1846                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1847                 return TTS_ERROR_INVALID_STATE;
1848         }
1849
1850         if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1851                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1852                 return TTS_ERROR_INVALID_PARAMETER;
1853         }
1854
1855         int ret = -1;
1856         int count = 0;
1857         bool is_prepared = false;
1858         while (0 != ret) {
1859                 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1860                 if (0 != ret) {
1861                         //LCOV_EXCL_START
1862                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1863                                 client->current_state = TTS_STATE_CREATED;
1864                                 if (0 == tts_prepare_sync(tts)) {
1865                                         is_prepared = true;
1866                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1867                                 }
1868                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1869                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1870                                 return ret;
1871                         } else {
1872                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1873                                 usleep(10000);
1874                                 count++;
1875                                 if (TTS_RETRY_COUNT == count) {
1876                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1877                                         return ret;
1878                                 }
1879                         }
1880                         //LCOV_EXCL_STOP
1881                 }
1882         }
1883
1884         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1885
1886         return 0;
1887 }
1888
1889 int tts_get_private_data(tts_h tts, const char* key, char** data)
1890 {
1891         if (0 != __tts_get_feature_enabled()) {
1892                 return TTS_ERROR_NOT_SUPPORTED;
1893         }
1894
1895         SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1896
1897         if (NULL == tts) {
1898                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1899                 return TTS_ERROR_INVALID_PARAMETER;
1900         }
1901
1902         if (NULL == key || NULL == data) {
1903                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1904                 return TTS_ERROR_INVALID_PARAMETER;
1905         }
1906
1907         tts_client_s* client = tts_client_get(tts);
1908
1909         if (NULL == client) {
1910                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1911                 return TTS_ERROR_INVALID_PARAMETER;
1912         }
1913
1914         if (TTS_STATE_READY != client->current_state) {
1915                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1916                 return TTS_ERROR_INVALID_STATE;
1917         }
1918
1919         int ret = -1;
1920         int count = 0;
1921         bool is_prepared = false;
1922         while (0 != ret) {
1923                 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1924                 if (0 != ret) {
1925                         //LCOV_EXCL_START
1926                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1927                                 client->current_state = TTS_STATE_CREATED;
1928                                 if (0 == tts_prepare_sync(tts)) {
1929                                         is_prepared = true;
1930                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1931                                 }
1932                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1933                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1934                                 return ret;
1935                         } else {
1936                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1937                                 usleep(10000);
1938                                 count++;
1939                                 if (TTS_RETRY_COUNT == count) {
1940                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1941                                         return ret;
1942                                 }
1943                         }
1944                         //LCOV_EXCL_STOP
1945                 }
1946         }
1947
1948         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1949                 free(*data);
1950                 *data = NULL;
1951         }
1952
1953         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1954
1955         return 0;
1956 }
1957
1958 //LCOV_EXCL_START
1959 static Eina_Bool __tts_notify_error(void *data)
1960 {
1961         tts_h tts = (tts_h)data;
1962
1963         tts_client_s* client = tts_client_get(tts);
1964
1965         /* check handle */
1966         if (NULL == client) {
1967                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1968                 return EINA_FALSE;
1969         }
1970
1971         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1972
1973         if (NULL != client->error_cb) {
1974                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1975                 tts_client_use_callback(client);
1976                 g_err_callback_status = true;
1977                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1978                 g_err_callback_status = false;
1979                 tts_client_not_use_callback(client);
1980         } else {
1981                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1982         }
1983
1984         return EINA_FALSE;
1985 }
1986
1987 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1988 {
1989         if (-1 == uid) {
1990                 GList* client_list = NULL;
1991                 client_list = tts_client_get_client_list();
1992
1993                 GList *iter = NULL;
1994                 tts_client_s *data = NULL;
1995
1996                 if (g_list_length(client_list) > 0) {
1997                         /* Get a first item */
1998                         iter = g_list_first(client_list);
1999
2000                         while (NULL != iter) {
2001                                 data = iter->data;
2002
2003                                 data->utt_id = utt_id;
2004                                 data->reason = reason;
2005                                 if (NULL != data->err_msg) {
2006                                         free(data->err_msg);
2007                                         data->err_msg = NULL;
2008                                 }
2009                                 if (NULL != err_msg)
2010                                         data->err_msg = strdup(err_msg);
2011
2012                                 /* call callback function */
2013                                 if (NULL != data->error_cb) {
2014                                         ecore_timer_add(0, __tts_notify_error, data->tts);
2015                                 } else {
2016                                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2017                                 }
2018
2019                                 if (TTS_ERROR_SERVICE_RESET == reason) {
2020                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2021
2022                                         data->current_state = TTS_STATE_CREATED;
2023                                         if (0 != tts_prepare(data->tts)) {
2024                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2025                                         }
2026                                 }
2027
2028                                 /* Next item */
2029                                 iter = g_list_next(iter);
2030                         }
2031                 }
2032         } else {
2033                 tts_client_s* client = tts_client_get_by_uid(uid);
2034
2035                 if (NULL == client) {
2036                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2037                         return TTS_ERROR_INVALID_PARAMETER;
2038                 }
2039
2040                 client->utt_id = utt_id;
2041                 client->reason = reason;
2042                 if (NULL != client->err_msg) {
2043                         free(client->err_msg);
2044                         client->err_msg = NULL;
2045                 }
2046                 if (NULL != err_msg)
2047                         client->err_msg = strdup(err_msg);
2048
2049                 /* call callback function */
2050                 if (NULL != client->error_cb) {
2051                         ecore_timer_add(0, __tts_notify_error, client->tts);
2052                 } else {
2053                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
2054                 }
2055
2056                 if (TTS_ERROR_SERVICE_RESET == reason) {
2057                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
2058
2059                         client->current_state = TTS_STATE_CREATED;
2060                         if (0 != tts_prepare(client->tts)) {
2061                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
2062                         }
2063                 }
2064         }
2065
2066         return 0;
2067 }
2068
2069 static Eina_Bool __tts_notify_state_changed(void *data)
2070 {
2071         tts_h tts = (tts_h)data;
2072
2073         tts_client_s* client = tts_client_get(tts);
2074
2075         /* check handle */
2076         if (NULL == client) {
2077                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
2078                 return EINA_FALSE;
2079         }
2080
2081         if (NULL != client->state_changed_cb) {
2082                 tts_client_use_callback(client);
2083                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2084                 tts_client_not_use_callback(client);
2085                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
2086         } else {
2087                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2088         }
2089
2090         return EINA_FALSE;
2091 }
2092
2093 int __tts_cb_set_state(int uid, int state)
2094 {
2095         tts_client_s* client = tts_client_get_by_uid(uid);
2096         if (NULL == client) {
2097                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
2098                 return -1;
2099         }
2100
2101         tts_state_e state_from_daemon = (tts_state_e)state;
2102
2103         if (client->current_state == state_from_daemon) {
2104                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2105                 return 0;
2106         }
2107
2108         if (NULL != client->state_changed_cb) {
2109                 if (NULL != g_check_state_timer) {
2110                         ecore_timer_del(g_check_state_timer);
2111                         g_check_state_timer = NULL;
2112                 }
2113                 g_check_state_timer = ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2114         } else {
2115                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2116         }
2117
2118         client->before_state = client->current_state;
2119         client->current_state = state_from_daemon;
2120
2121         return 0;
2122 }
2123 //LCOV_EXCL_STOP
2124
2125 int __tts_cb_utt_started(int uid, int utt_id)
2126 {
2127         tts_client_s* client = tts_client_get_by_uid(uid);
2128
2129         if (NULL == client) {
2130                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2131                 return TTS_ERROR_INVALID_PARAMETER;
2132         }
2133
2134         SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2135
2136         client->utt_id = utt_id;
2137
2138         /* call callback function */
2139         if (NULL != client->utt_started_cb) {
2140                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2141                 tts_client_use_callback(client);
2142                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2143                 tts_client_not_use_callback(client);
2144         } else {
2145                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2146         }
2147
2148         return 0;
2149 }
2150
2151 int __tts_cb_utt_completed(int uid, int utt_id)
2152 {
2153         tts_client_s* client = tts_client_get_by_uid(uid);
2154
2155         if (NULL == client) {
2156                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2157                 return TTS_ERROR_INVALID_PARAMETER;
2158         }
2159
2160         SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2161
2162         client->utt_id = utt_id;
2163
2164         /* call callback function */
2165         if (NULL != client->utt_completeted_cb) {
2166                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2167                 tts_client_use_callback(client);
2168                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2169                 tts_client_not_use_callback(client);
2170         } else {
2171                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2172         }
2173
2174         return 0;
2175 }
2176
2177 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2178 {
2179         if (0 != __tts_get_feature_enabled()) {
2180                 return TTS_ERROR_NOT_SUPPORTED;
2181         }
2182
2183         if (NULL == tts || NULL == callback) {
2184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2185                 return TTS_ERROR_INVALID_PARAMETER;
2186         }
2187
2188         tts_client_s* client = tts_client_get(tts);
2189
2190         if (NULL == client) {
2191                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2192                 return TTS_ERROR_INVALID_PARAMETER;
2193         }
2194
2195         if (TTS_STATE_CREATED != client->current_state) {
2196                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2197                 return TTS_ERROR_INVALID_STATE;
2198         }
2199
2200         client->state_changed_cb = callback;
2201         client->state_changed_user_data = user_data;
2202
2203         SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2204
2205         return 0;
2206 }
2207
2208 int tts_unset_state_changed_cb(tts_h tts)
2209 {
2210         if (0 != __tts_get_feature_enabled()) {
2211                 return TTS_ERROR_NOT_SUPPORTED;
2212         }
2213
2214         if (NULL == tts) {
2215                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2216                 return TTS_ERROR_INVALID_PARAMETER;
2217         }
2218
2219         tts_client_s* client = tts_client_get(tts);
2220
2221         if (NULL == client) {
2222                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2223                 return TTS_ERROR_INVALID_PARAMETER;
2224         }
2225
2226         if (TTS_STATE_CREATED != client->current_state) {
2227                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2228                 return TTS_ERROR_INVALID_STATE;
2229         }
2230
2231         client->state_changed_cb = NULL;
2232         client->state_changed_user_data = NULL;
2233
2234         if (NULL != g_check_state_timer) {
2235                 ecore_timer_del(g_check_state_timer);
2236                 g_check_state_timer = NULL;
2237         }
2238
2239         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2240
2241         return 0;
2242 }
2243
2244 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2245 {
2246         if (0 != __tts_get_feature_enabled()) {
2247                 return TTS_ERROR_NOT_SUPPORTED;
2248         }
2249
2250         if (NULL == tts || NULL == callback) {
2251                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2252                 return TTS_ERROR_INVALID_PARAMETER;
2253         }
2254
2255         tts_client_s* client = tts_client_get(tts);
2256
2257         if (NULL == client) {
2258                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2259                 return TTS_ERROR_INVALID_PARAMETER;
2260         }
2261
2262         if (TTS_STATE_CREATED != client->current_state) {
2263                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2264                 return TTS_ERROR_INVALID_STATE;
2265         }
2266
2267         client->utt_started_cb = callback;
2268         client->utt_started_user_data = user_data;
2269
2270         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2271
2272         return 0;
2273 }
2274
2275 int tts_unset_utterance_started_cb(tts_h tts)
2276 {
2277         if (0 != __tts_get_feature_enabled()) {
2278                 return TTS_ERROR_NOT_SUPPORTED;
2279         }
2280
2281         if (NULL == tts) {
2282                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2283                 return TTS_ERROR_INVALID_PARAMETER;
2284         }
2285
2286         tts_client_s* client = tts_client_get(tts);
2287
2288         if (NULL == client) {
2289                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2290                 return TTS_ERROR_INVALID_PARAMETER;
2291         }
2292
2293         if (TTS_STATE_CREATED != client->current_state) {
2294                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2295                 return TTS_ERROR_INVALID_STATE;
2296         }
2297
2298         client->utt_started_cb = NULL;
2299         client->utt_started_user_data = NULL;
2300
2301         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2302
2303         return 0;
2304 }
2305
2306 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2307 {
2308         if (0 != __tts_get_feature_enabled()) {
2309                 return TTS_ERROR_NOT_SUPPORTED;
2310         }
2311
2312         if (NULL == tts || NULL == callback) {
2313                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2314                 return TTS_ERROR_INVALID_PARAMETER;
2315         }
2316
2317         tts_client_s* client = tts_client_get(tts);
2318
2319         if (NULL == client) {
2320                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2321                 return TTS_ERROR_INVALID_PARAMETER;
2322         }
2323
2324         if (TTS_STATE_CREATED != client->current_state) {
2325                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2326                 return TTS_ERROR_INVALID_STATE;
2327         }
2328
2329         client->utt_completeted_cb = callback;
2330         client->utt_completed_user_data = user_data;
2331
2332         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2333
2334         return 0;
2335 }
2336
2337 int tts_unset_utterance_completed_cb(tts_h tts)
2338 {
2339         if (0 != __tts_get_feature_enabled()) {
2340                 return TTS_ERROR_NOT_SUPPORTED;
2341         }
2342
2343         if (NULL == tts) {
2344                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2345                 return TTS_ERROR_INVALID_PARAMETER;
2346         }
2347
2348         tts_client_s* client = tts_client_get(tts);
2349
2350         if (NULL == client) {
2351                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2352                 return TTS_ERROR_INVALID_PARAMETER;
2353         }
2354
2355         if (TTS_STATE_CREATED != client->current_state) {
2356                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2357                 return TTS_ERROR_INVALID_STATE;
2358         }
2359
2360         client->utt_completeted_cb = NULL;
2361         client->utt_completed_user_data = NULL;
2362
2363         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2364         return 0;
2365 }
2366
2367 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2368 {
2369         if (0 != __tts_get_feature_enabled()) {
2370                 return TTS_ERROR_NOT_SUPPORTED;
2371         }
2372
2373         if (NULL == tts || NULL == callback) {
2374                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2375                 return TTS_ERROR_INVALID_PARAMETER;
2376         }
2377
2378         tts_client_s* client = tts_client_get(tts);
2379
2380         if (NULL == client) {
2381                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2382                 return TTS_ERROR_INVALID_PARAMETER;
2383         }
2384
2385         if (TTS_STATE_CREATED != client->current_state) {
2386                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2387                 return TTS_ERROR_INVALID_STATE;
2388         }
2389
2390         client->error_cb = callback;
2391         client->error_user_data = user_data;
2392
2393         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2394
2395         return 0;
2396 }
2397
2398 int tts_unset_error_cb(tts_h tts)
2399 {
2400         if (0 != __tts_get_feature_enabled()) {
2401                 return TTS_ERROR_NOT_SUPPORTED;
2402         }
2403
2404         if (NULL == tts) {
2405                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2406                 return TTS_ERROR_INVALID_PARAMETER;
2407         }
2408
2409         tts_client_s* client = tts_client_get(tts);
2410
2411         if (NULL == client) {
2412                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2413                 return TTS_ERROR_INVALID_PARAMETER;
2414         }
2415
2416         if (TTS_STATE_CREATED != client->current_state) {
2417                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2418                 return TTS_ERROR_INVALID_STATE;
2419         }
2420
2421         client->error_cb = NULL;
2422         client->error_user_data = NULL;
2423
2424         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2425
2426         return 0;
2427 }
2428
2429 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2430 {
2431         if (0 != __tts_get_feature_enabled()) {
2432                 return TTS_ERROR_NOT_SUPPORTED;
2433         }
2434
2435         if (NULL == tts || NULL == callback) {
2436                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2437                 return TTS_ERROR_INVALID_PARAMETER;
2438         }
2439
2440         tts_client_s* client = tts_client_get(tts);
2441
2442         if (NULL == client) {
2443                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2444                 return TTS_ERROR_INVALID_PARAMETER;
2445         }
2446
2447         if (TTS_STATE_CREATED != client->current_state) {
2448                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2449                 return TTS_ERROR_INVALID_STATE;
2450         }
2451
2452         client->default_voice_changed_cb = callback;
2453         client->default_voice_changed_user_data = user_data;
2454
2455         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2456
2457         return 0;
2458 }
2459
2460 int tts_unset_default_voice_changed_cb(tts_h tts)
2461 {
2462         if (0 != __tts_get_feature_enabled()) {
2463                 return TTS_ERROR_NOT_SUPPORTED;
2464         }
2465
2466         if (NULL == tts) {
2467                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2468                 return TTS_ERROR_INVALID_PARAMETER;
2469         }
2470
2471         tts_client_s* client = tts_client_get(tts);
2472
2473         if (NULL == client) {
2474                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2475                 return TTS_ERROR_INVALID_PARAMETER;
2476         }
2477
2478         if (TTS_STATE_CREATED != client->current_state) {
2479                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2480                 return TTS_ERROR_INVALID_STATE;
2481         }
2482
2483         client->default_voice_changed_cb = NULL;
2484         client->default_voice_changed_user_data = NULL;
2485
2486         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2487
2488         return 0;
2489 }
2490
2491 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2492 {
2493         if (0 != __tts_get_feature_enabled()) {
2494                 return TTS_ERROR_NOT_SUPPORTED;
2495         }
2496
2497         if (NULL == tts || NULL == callback) {
2498                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2499                 return TTS_ERROR_INVALID_PARAMETER;
2500         }
2501
2502         tts_client_s* client = tts_client_get(tts);
2503
2504         if (NULL == client) {
2505                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2506                 return TTS_ERROR_INVALID_PARAMETER;
2507         }
2508
2509         if (TTS_STATE_CREATED != client->current_state) {
2510                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2511                 return TTS_ERROR_INVALID_STATE;
2512         }
2513
2514         client->engine_changed_cb = callback;
2515         client->engine_changed_user_data = user_data;
2516
2517         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2518
2519         return 0;
2520 }
2521
2522 int tts_unset_engine_changed_cb(tts_h tts)
2523 {
2524         if (0 != __tts_get_feature_enabled()) {
2525                 return TTS_ERROR_NOT_SUPPORTED;
2526         }
2527
2528         if (NULL == tts) {
2529                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2530                 return TTS_ERROR_INVALID_PARAMETER;
2531         }
2532
2533         tts_client_s* client = tts_client_get(tts);
2534
2535         if (NULL == client) {
2536                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2537                 return TTS_ERROR_INVALID_PARAMETER;
2538         }
2539
2540         if (TTS_STATE_CREATED != client->current_state) {
2541                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2542                 return TTS_ERROR_INVALID_STATE;
2543         }
2544
2545         client->engine_changed_cb = NULL;
2546         client->engine_changed_user_data = NULL;
2547
2548         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2549
2550         return 0;
2551 }
2552
2553 //LCOV_EXCL_START
2554 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2555 {
2556         if (0 != __tts_get_feature_enabled()) {
2557                 return TTS_ERROR_NOT_SUPPORTED;
2558         }
2559
2560         SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2561
2562         if (NULL == tts) {
2563                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2564                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2565                 return TTS_ERROR_INVALID_PARAMETER;
2566         }
2567
2568         tts_client_s* client = tts_client_get(tts);
2569
2570         if (NULL == client) {
2571                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2572                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2573                 return TTS_ERROR_INVALID_PARAMETER;
2574         }
2575
2576         if (TTS_STATE_CREATED == client->current_state) {
2577                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2578                 return TTS_ERROR_INVALID_STATE;
2579         }
2580
2581         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2582                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2583                 return TTS_ERROR_INVALID_STATE;
2584         }
2585
2586         int ret = -1;
2587         int count = 0;
2588         bool is_prepared = false;
2589         while (0 != ret) {
2590                 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2591                 if (0 != ret) {
2592                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2593                                 client->current_state = TTS_STATE_CREATED;
2594                                 if (0 == tts_prepare_sync(tts)) {
2595                                         is_prepared = true;
2596                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2597                                 }
2598                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2599                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2600                                 return ret;
2601                         } else {
2602                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2603                                 usleep(10000);
2604                                 count++;
2605                                 if (TTS_RETRY_COUNT == count) {
2606                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2607                                         return ret;
2608                                 }
2609                         }
2610                 }
2611         }
2612
2613         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2614
2615         return TTS_ERROR_NONE;
2616 }
2617
2618 int tts_play_pcm(tts_h tts)
2619 {
2620         if (0 != __tts_get_feature_enabled()) {
2621                 return TTS_ERROR_NOT_SUPPORTED;
2622         }
2623
2624         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2625
2626         if (NULL == tts) {
2627                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2628                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2629                 return TTS_ERROR_INVALID_PARAMETER;
2630         }
2631
2632         tts_client_s* client = tts_client_get(tts);
2633
2634         if (NULL == client) {
2635                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2636                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2637                 return TTS_ERROR_INVALID_PARAMETER;
2638         }
2639
2640         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2641                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2642                 return TTS_ERROR_INVALID_STATE;
2643         }
2644
2645         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2646                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2647                 return TTS_ERROR_INVALID_STATE;
2648         }
2649
2650         int ret = -1;
2651         int count = 0;
2652         bool is_prepared = false;
2653         while (0 != ret) {
2654                 ret = tts_dbus_request_play_pcm(client->uid);
2655                 if (0 != ret) {
2656                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2657                                 client->current_state = TTS_STATE_CREATED;
2658                                 if (0 == tts_prepare_sync(tts)) {
2659                                         is_prepared = true;
2660                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2661                                 }
2662                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2663                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2664                                 return ret;
2665                         } else {
2666                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2667                                 usleep(10000);
2668                                 count++;
2669                                 if (TTS_RETRY_COUNT == count) {
2670                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2671                                         return ret;
2672                                 }
2673                         }
2674                 }
2675         }
2676
2677         client->before_state = client->current_state;
2678         client->current_state = TTS_STATE_PLAYING;
2679
2680         if (NULL != client->state_changed_cb) {
2681                 tts_client_use_callback(client);
2682                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2683                 tts_client_not_use_callback(client);
2684                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2685         }
2686
2687         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2688
2689         return TTS_ERROR_NONE;
2690 }
2691
2692 int tts_stop_pcm(tts_h tts)
2693 {
2694         if (0 != __tts_get_feature_enabled()) {
2695                 return TTS_ERROR_NOT_SUPPORTED;
2696         }
2697
2698         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2699
2700         if (NULL == tts) {
2701                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2702                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2703                 return TTS_ERROR_INVALID_PARAMETER;
2704         }
2705
2706         tts_client_s* client = tts_client_get(tts);
2707
2708         if (NULL == client) {
2709                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2710                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2711                 return TTS_ERROR_INVALID_PARAMETER;
2712         }
2713
2714         if (TTS_STATE_CREATED == client->current_state) {
2715                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2716                 return TTS_ERROR_INVALID_STATE;
2717         }
2718
2719         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2720                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2721                 return TTS_ERROR_INVALID_STATE;
2722         }
2723
2724         int ret = -1;
2725         int count = 0;
2726         bool is_prepared = false;
2727         while (0 != ret) {
2728                 ret = tts_dbus_request_stop_pcm(client->uid);
2729                 if (0 != ret) {
2730                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2731                                 client->current_state = TTS_STATE_CREATED;
2732                                 if (0 == tts_prepare_sync(tts)) {
2733                                         is_prepared = true;
2734                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2735                                 }
2736                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2737                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2738                                 return ret;
2739                         } else {
2740                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2741                                 usleep(10000);
2742                                 count++;
2743                                 if (TTS_RETRY_COUNT == count) {
2744                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2745                                         return ret;
2746                                 }
2747                         }
2748                 }
2749         }
2750
2751         client->before_state = client->current_state;
2752         client->current_state = TTS_STATE_READY;
2753
2754         if (NULL != client->state_changed_cb) {
2755                 tts_client_use_callback(client);
2756                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2757                 tts_client_not_use_callback(client);
2758                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2759         }
2760
2761         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2762
2763         return TTS_ERROR_NONE;
2764 }
2765 //LCOV_EXCL_STOP
2766
2767 int tts_repeat(tts_h tts, char** text_repeat, int* utt_id)
2768 {
2769         if (0 != __tts_get_feature_enabled()) {
2770                 return TTS_ERROR_NOT_SUPPORTED;
2771         }
2772
2773         SLOG(LOG_INFO, TAG_TTSC, "@@@ Repeat TTS");
2774
2775         if (NULL == tts) {
2776                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2777                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2778                 return TTS_ERROR_INVALID_PARAMETER;
2779         }
2780
2781         if (NULL == text_repeat || NULL == utt_id) {
2782                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null.");
2783                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2784                 return TTS_ERROR_INVALID_PARAMETER;
2785         }
2786
2787         *text_repeat = NULL;
2788         *utt_id = -1;
2789
2790         tts_client_s* client = tts_client_get(tts);
2791
2792         if (NULL == client) {
2793                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2794                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2795                 return TTS_ERROR_INVALID_PARAMETER;
2796         }
2797
2798         if (TTS_STATE_READY != client->current_state) {
2799                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid. (%d)", client->current_state);
2800                 return TTS_ERROR_INVALID_STATE;
2801         }
2802
2803         /* Clear the legacy and Add texts to be played repeatedly */
2804         int ret = -1;
2805         ret = tts_stop(tts);
2806         if (TTS_ERROR_NONE != ret) {
2807                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to clear the legacy");
2808                 return ret;
2809         }
2810
2811         if (NULL != client->text_repeat) {
2812                 char* tmp_text = strdup(client->text_repeat);
2813                 char* tmp_lang = NULL;
2814                 if (NULL != g_language) {
2815                         tmp_lang = strdup(g_language);
2816                 }
2817                 ret = tts_add_text(tts, tmp_text, tmp_lang, g_voice_type, g_speed, utt_id);
2818                 if (TTS_ERROR_NONE != ret) {
2819                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
2820                         if (NULL != tmp_text) {
2821                                 free(tmp_text);
2822                                 tmp_text = NULL;
2823                         }
2824                         if (NULL != tmp_lang) {
2825                                 free(tmp_lang);
2826                                 tmp_lang = NULL;
2827                         }
2828                         return ret;
2829                 }
2830                 *text_repeat = strdup(client->text_repeat);
2831                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", *text_repeat, *utt_id);
2832                 if (NULL != tmp_text) {
2833                         free(tmp_text);
2834                         tmp_text = NULL;
2835                 }
2836                 if (NULL != tmp_lang) {
2837                         free(tmp_lang);
2838                         tmp_lang = NULL;
2839                 }
2840         } else {
2841                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
2842                 return TTS_ERROR_OPERATION_FAILED;
2843         }
2844
2845         /* Play added texts */
2846         ret = tts_play(tts);
2847         if (TTS_ERROR_NONE != ret) {
2848                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
2849                 if (NULL != *text_repeat) {
2850                         free(*text_repeat);
2851                         *text_repeat = NULL;
2852                 }
2853                 *utt_id = -1;
2854                 return ret;
2855         }
2856
2857         return TTS_ERROR_NONE;
2858 }