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