client/tts.c

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