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