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