client/tts.c

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