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