client/tts.c

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