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