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                         if (NULL != key) {
 532                                 free(key);
 533                                 key = NULL;
 534                         }
 535                         return TTS_ERROR_OUT_OF_MEMORY;
 536                 }
 537         } else {
 538                 key = strdup("DisableServerTTS");
 539         }
 540
 541         if (NULL == key) {
 542                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 543                 return TTS_ERROR_OUT_OF_MEMORY;
 544         }
 545
 546         int pid = getpid();
 547         char* appid = NULL;
 548         int ret = app_manager_get_app_id(pid, &appid);
 549         if (0 != ret || NULL == appid) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 551                 free(key);
 552                 key = NULL;
 553                 if (NULL != appid) {
 554                         free(appid);
 555                         appid = NULL;
 556                 }
 557                 return TTS_ERROR_OPERATION_FAILED;
 558         }
 559
 560         ret = tts_set_private_data(tts, key, appid);
 561         if (0 != ret) {
 562                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 563                 free(key);
 564                 key = NULL;
 565                 free(appid);
 566                 appid = NULL;
 567                 return ret;
 568         }
 569
 570         free(appid);
 571         appid = NULL;
 572         free(key);
 573         key = NULL;
 574
 575         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 576
 577         return TTS_ERROR_NONE;
 578 }
 579
 580 static Eina_Bool __tts_connect_daemon(void *data)
 581 {
 582         tts_h tts = (tts_h)data;
 583         tts_client_s* client = tts_client_get(tts);
 584
 585         /* check handle */
 586         if (NULL == client) {
 587                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 588                 return EINA_FALSE;
 589         }
 590
 591         /* Send hello */
 592         if (0 != tts_dbus_request_hello(client->uid)) {
 593                 return EINA_TRUE;
 594         }
 595
 596         SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 597
 598         /* do request initialize */
 599         int ret = -1;
 600         bool credential_needed = false;
 601
 602         ret = tts_dbus_request_initialize(client->uid, &credential_needed);
 603
 604         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 605                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 606
 607                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 608                 client->utt_id = -1;
 609
 610                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 611                 client->conn_timer = NULL;
 612                 return EINA_FALSE;
 613
 614         } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
 615                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 616
 617                 client->reason = TTS_ERROR_PERMISSION_DENIED;
 618                 client->utt_id = -1;
 619
 620                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 621                 client->conn_timer = NULL;
 622                 return EINA_FALSE;
 623
 624         } else if (TTS_ERROR_NONE != ret) {
 625                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 626                 return EINA_TRUE;
 627
 628         } else {
 629                 /* success to connect tts-daemon */
 630                 client->credential_needed = credential_needed;
 631                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 632         }
 633
 634         client->conn_timer = NULL;
 635
 636         client = tts_client_get(tts);
 637         /* check handle */
 638         if (NULL == client) {
 639                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 640                 return EINA_FALSE;
 641         }
 642
 643         client->before_state = client->current_state;
 644         client->current_state = TTS_STATE_READY;
 645
 646         if (NULL != client->state_changed_cb) {
 647                 tts_client_use_callback(client);
 648                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 649                 tts_client_not_use_callback(client);
 650         } else {
 651                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 652         }
 653
 654         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 655
 656         return EINA_FALSE;
 657 }
 658
 659 int tts_prepare(tts_h tts)
 660 {
 661         if (0 != __tts_get_feature_enabled()) {
 662                 return TTS_ERROR_NOT_SUPPORTED;
 663         }
 664
 665         SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 666
 667         tts_client_s* client = tts_client_get(tts);
 668
 669         /* check handle */
 670         if (NULL == client) {
 671                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 672                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 673                 return TTS_ERROR_INVALID_PARAMETER;
 674         }
 675
 676         /* check state */
 677         if (client->current_state != TTS_STATE_CREATED) {
 678                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 679                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 680                 return TTS_ERROR_INVALID_STATE;
 681         }
 682
 683         client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 684
 685         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 686
 687         return TTS_ERROR_NONE;
 688 }
 689
 690 int tts_unprepare(tts_h tts)
 691 {
 692         if (0 != __tts_get_feature_enabled()) {
 693                 return TTS_ERROR_NOT_SUPPORTED;
 694         }
 695
 696         SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
 697
 698         tts_client_s* client = tts_client_get(tts);
 699
 700         /* check handle */
 701         if (NULL == client) {
 702                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 703                 return TTS_ERROR_INVALID_PARAMETER;
 704         }
 705
 706         /* check state */
 707         if (client->current_state != TTS_STATE_READY) {
 708                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 709                 return TTS_ERROR_INVALID_STATE;
 710         }
 711
 712         int ret = -1;
 713         int count = 0;
 714         int screen_reader = -1;
 715
 716         ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 717         if (0 != ret) {
 718                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
 719         } else {
 720                 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);
 721                 g_screen_reader = (bool)screen_reader;
 722         }
 723
 724         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 725                 do {
 726                         ret = tts_dbus_request_finalize(client->uid);
 727                         if (0 != ret) {
 728                                 if (TTS_ERROR_TIMED_OUT != ret) {
 729                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 730                                         break;
 731                                 } else {
 732                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 733                                         usleep(10000);
 734                                         count++;
 735                                         if (TTS_RETRY_COUNT == count) {
 736                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 737                                                 break;
 738                                         }
 739                                 }
 740                         }
 741                 } while (0 != ret);
 742         } else {
 743                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 744         }
 745
 746         client->before_state = client->current_state;
 747         client->current_state = TTS_STATE_CREATED;
 748
 749         if (NULL != client->state_changed_cb) {
 750                 tts_client_use_callback(client);
 751                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 752                 tts_client_not_use_callback(client);
 753                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 754         }
 755
 756         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 757
 758         return TTS_ERROR_NONE;
 759 }
 760
 761 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 762 {
 763         tts_h tts = (tts_h)user_data;
 764
 765         tts_client_s* client = tts_client_get(tts);
 766         if (NULL == client) {
 767                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 768                 return false;
 769         }
 770
 771         /* call callback function */
 772         if (NULL != client->supported_voice_cb) {
 773                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 774         } else {
 775                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 776         }
 777
 778         return false;
 779 }
 780
 781 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 782 {
 783         if (0 != __tts_get_feature_enabled()) {
 784                 return TTS_ERROR_NOT_SUPPORTED;
 785         }
 786
 787         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 788
 789         if (NULL == tts || NULL == callback) {
 790                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 791                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 792                 return TTS_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         tts_client_s* client = tts_client_get(tts);
 796
 797         /* check handle */
 798         if (NULL == client) {
 799                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 800                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 801                 return TTS_ERROR_INVALID_PARAMETER;
 802         }
 803
 804         int ret = 0;
 805         char* current_engine = NULL;
 806         ret = tts_config_mgr_get_engine(&current_engine);
 807         if (0 != ret) {
 808                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 809                 return __tts_convert_config_error_code(ret);
 810         }
 811
 812         client->supported_voice_cb = callback;
 813         client->supported_voice_user_data = user_data;
 814
 815         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 816
 817         if (NULL != current_engine) {
 818                 free(current_engine);
 819                 current_engine = NULL;
 820         }
 821
 822         client->supported_voice_cb = NULL;
 823         client->supported_voice_user_data = NULL;
 824
 825         if (0 != ret) {
 826                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 827                 ret = TTS_ERROR_OPERATION_FAILED;
 828         }
 829
 830         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 831
 832         return ret;
 833 }
 834
 835 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 836 {
 837         if (0 != __tts_get_feature_enabled()) {
 838                 return TTS_ERROR_NOT_SUPPORTED;
 839         }
 840
 841         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 842
 843         if (NULL == tts) {
 844                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 845                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 846                 return TTS_ERROR_INVALID_PARAMETER;
 847
 848         }
 849         tts_client_s* client = tts_client_get(tts);
 850
 851         if (NULL == client) {
 852                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 853                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 854                 return TTS_ERROR_INVALID_PARAMETER;
 855         }
 856
 857         /* Request call remote method */
 858         int ret = 0;
 859         ret = tts_config_mgr_get_voice(lang, vctype);
 860         if (0 != ret) {
 861                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 862                 return __tts_convert_config_error_code(ret);
 863         } else {
 864                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 865         }
 866
 867         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 868
 869         return ret;
 870 }
 871
 872 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 873 {
 874         if (0 != __tts_get_feature_enabled()) {
 875                 return TTS_ERROR_NOT_SUPPORTED;
 876         }
 877
 878         if (NULL == tts || NULL == size) {
 879                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 880                 return TTS_ERROR_INVALID_PARAMETER;
 881         }
 882
 883         tts_client_s* client = tts_client_get(tts);
 884
 885         if (NULL == client) {
 886                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 887                 return TTS_ERROR_INVALID_PARAMETER;
 888         }
 889
 890         if (TTS_STATE_READY != client->current_state) {
 891                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 892                 return TTS_ERROR_INVALID_STATE;
 893         }
 894
 895         if (0 != tts_config_mgr_get_max_text_size(size)) {
 896                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
 897                 return TTS_ERROR_INVALID_PARAMETER;
 898         }
 899
 900         g_max_text_size = (int)*size;
 901
 902         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 903         return TTS_ERROR_NONE;
 904 }
 905
 906 int tts_get_state(tts_h tts, tts_state_e* state)
 907 {
 908         if (0 != __tts_get_feature_enabled()) {
 909                 return TTS_ERROR_NOT_SUPPORTED;
 910         }
 911
 912         if (NULL == tts || NULL == state) {
 913                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 914                 return TTS_ERROR_INVALID_PARAMETER;
 915         }
 916
 917         tts_client_s* client = tts_client_get(tts);
 918
 919         if (NULL == client) {
 920                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 921                 return TTS_ERROR_INVALID_PARAMETER;
 922         }
 923
 924         *state = client->current_state;
 925
 926         switch (*state) {
 927         case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 928         case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 929         case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 930         case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 931         default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 932         }
 933
 934         return TTS_ERROR_NONE;
 935 }
 936
 937 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 938 {
 939         if (0 != __tts_get_feature_enabled()) {
 940                 return TTS_ERROR_NOT_SUPPORTED;
 941         }
 942
 943         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 944                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 945                 return TTS_ERROR_INVALID_PARAMETER;
 946         }
 947
 948         tts_client_s* client = tts_client_get(tts);
 949
 950         if (NULL == client) {
 951                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 952                 return TTS_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         *min = TTS_SPEED_MIN;
 956         *normal = TTS_SPEED_NORMAL;
 957         *max = TTS_SPEED_MAX;
 958
 959         return TTS_ERROR_NONE;
 960 }
 961
 962 int tts_get_error_message(tts_h tts, char** err_msg)
 963 {
 964         if (0 != __tts_get_feature_enabled()) {
 965                 return TTS_ERROR_NOT_SUPPORTED;
 966         }
 967
 968         if (NULL == tts || NULL == err_msg) {
 969                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 970                 return TTS_ERROR_INVALID_PARAMETER;
 971         }
 972
 973         tts_client_s* client = tts_client_get(tts);
 974
 975         if (NULL == client) {
 976                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 977                 return TTS_ERROR_INVALID_PARAMETER;
 978         }
 979
 980         if (NULL != client->err_msg) {
 981                 *err_msg = strdup(client->err_msg);
 982                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
 983         } else {
 984                 *err_msg = NULL;
 985                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
 986         }
 987
 988         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 989
 990         return TTS_ERROR_NONE;
 991 }
 992
 993 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 994 {
 995         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
 996
 997         if (0 != __tts_get_feature_enabled()) {
 998                 return TTS_ERROR_NOT_SUPPORTED;
 999         }
1000
1001         if (speed < 0) {
1002                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1003                 return TTS_ERROR_INVALID_PARAMETER;
1004         }
1005
1006         if (voice_type < 0) {
1007                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1008                 return TTS_ERROR_INVALID_PARAMETER;
1009         }
1010
1011         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1012
1013         if (NULL == tts || NULL == utt_id) {
1014                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1015                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1016                 return TTS_ERROR_INVALID_PARAMETER;
1017         }
1018
1019         tts_client_s* client = tts_client_get(tts);
1020
1021         if (NULL == client) {
1022                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1023                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1024                 return TTS_ERROR_INVALID_PARAMETER;
1025         }
1026
1027         if (TTS_STATE_CREATED == client->current_state) {
1028                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1029                 return TTS_ERROR_INVALID_STATE;
1030         }
1031
1032         if (-1 == g_max_text_size) {
1033                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1034                 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1035                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1036                         return TTS_ERROR_INVALID_PARAMETER;
1037                 }
1038         }
1039
1040         if (0 == g_max_text_size) {
1041                 if (strlen(text) <= 0) {
1042                         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1043                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1044                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1045                         return TTS_ERROR_INVALID_PARAMETER;
1046                 }
1047         } else {
1048                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1049                 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1050                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1051                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1052                         return TTS_ERROR_INVALID_PARAMETER;
1053                 }
1054         }
1055
1056         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1057                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1058                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1059                 return TTS_ERROR_INVALID_PARAMETER;
1060         }
1061
1062         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1063                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1064                 return TTS_ERROR_INVALID_STATE;
1065         }
1066
1067         if (true == client->credential_needed && NULL == client->credential) {
1068                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1069                 return TTS_ERROR_PERMISSION_DENIED;
1070         }
1071
1072         /* check valid utf8 */
1073         bool valid = false;
1074
1075         DBusError err;
1076         dbus_error_init(&err);
1077
1078         valid = dbus_validate_utf8(text, &err);
1079         if (dbus_error_is_set(&err)) {
1080                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1081                 dbus_error_free(&err);
1082                 return TTS_ERROR_INVALID_PARAMETER;
1083         }
1084
1085         if (valid != true) {
1086                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1087                 return TTS_ERROR_INVALID_PARAMETER;
1088         }
1089         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1090
1091         /* change default language value */
1092         char* temp = NULL;
1093
1094         if (NULL == language)
1095                 temp = strdup("default");
1096         else
1097                 temp = strdup(language);
1098
1099         client->current_utt_id++;
1100         if (client->current_utt_id == 10000) {
1101                 client->current_utt_id = 1;
1102         }
1103
1104         /* do request */
1105         int ret = -1;
1106         int count = 0;
1107         while (0 != ret) {
1108                 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1109                 if (0 != ret) {
1110                         if (TTS_ERROR_TIMED_OUT != ret) {
1111                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1112                                 break;
1113                         } else {
1114                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1115                                 usleep(10000);
1116                                 count++;
1117                                 if (TTS_RETRY_MIN_COUNT == count) {
1118                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1119                                         break;
1120                                 }
1121                         }
1122                 } else {
1123                         *utt_id = client->current_utt_id;
1124                 }
1125         }
1126
1127         if (NULL != temp) {
1128                 free(temp);
1129                 temp = NULL;
1130         }
1131
1132         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1133
1134         return ret;
1135 }
1136
1137 static void __tts_play_async(void *data)
1138 {
1139         tts_h tts = (tts_h)data;
1140         tts_client_s* client = tts_client_get(tts);
1141
1142         /* check handle */
1143         if (NULL == client) {
1144                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1145                 return;
1146         }
1147
1148         int ret = -1;
1149         int count = 0;
1150         while (0 != ret) {
1151                 ret = tts_dbus_request_play(client->uid, client->credential);
1152                 if (0 != ret) {
1153                         if (TTS_ERROR_TIMED_OUT != ret) {
1154                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1155                                 break;
1156                         } else {
1157                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1158                                 usleep(10000);
1159                                 count++;
1160                                 if (TTS_RETRY_COUNT == count) {
1161                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1162                                         break;
1163                                 }
1164                         }
1165                 }
1166         }
1167
1168         if (0 != ret) {
1169                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1170
1171                 client->reason = ret;
1172                 client->utt_id = -1;
1173
1174                 ecore_timer_add(0, __tts_notify_error, client->tts);
1175                 return;
1176         }
1177
1178         client->before_state = client->current_state;
1179         client->current_state = TTS_STATE_PLAYING;
1180
1181         if (NULL != client->state_changed_cb) {
1182                 tts_client_use_callback(client);
1183                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1184                 tts_client_not_use_callback(client);
1185                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1186         }
1187
1188         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1189
1190         return;
1191 }
1192
1193 int tts_play_async(tts_h tts)
1194 {
1195         if (0 != __tts_get_feature_enabled()) {
1196                 return TTS_ERROR_NOT_SUPPORTED;
1197         }
1198
1199         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1200
1201         if (NULL == tts) {
1202                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1203                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1204                 return TTS_ERROR_INVALID_PARAMETER;
1205         }
1206
1207         tts_client_s* client = tts_client_get(tts);
1208
1209         if (NULL == client) {
1210                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1211                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1212                 return TTS_ERROR_INVALID_PARAMETER;
1213         }
1214
1215         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1216                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1217                 return TTS_ERROR_INVALID_STATE;
1218         }
1219
1220         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1221                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1222                 return TTS_ERROR_INVALID_STATE;
1223         }
1224
1225         if (true == client->credential_needed && NULL == client->credential) {
1226                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1227                 return TTS_ERROR_PERMISSION_DENIED;
1228         }
1229
1230         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1231
1232         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1233
1234         return TTS_ERROR_NONE;
1235 }
1236
1237 int tts_play(tts_h tts)
1238 {
1239         if (0 != __tts_get_feature_enabled()) {
1240                 return TTS_ERROR_NOT_SUPPORTED;
1241         }
1242
1243         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1244
1245         if (NULL == tts) {
1246                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1247                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1248                 return TTS_ERROR_INVALID_PARAMETER;
1249         }
1250
1251         tts_client_s* client = tts_client_get(tts);
1252
1253         if (NULL == client) {
1254                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1255                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1256                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1257                 return TTS_ERROR_INVALID_PARAMETER;
1258         }
1259
1260         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1261                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1262                 return TTS_ERROR_INVALID_STATE;
1263         }
1264
1265         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1266                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1267                 return TTS_ERROR_INVALID_STATE;
1268         }
1269
1270         if (true == client->credential_needed && NULL == client->credential) {
1271                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1272                 return TTS_ERROR_PERMISSION_DENIED;
1273         }
1274
1275         int ret = -1;
1276         int count = 0;
1277         while (0 != ret) {
1278                 ret = tts_dbus_request_play(client->uid, client->credential);
1279                 if (0 != ret) {
1280                         if (TTS_ERROR_TIMED_OUT != ret) {
1281                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1282                                 return ret;
1283                         } else {
1284                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1285                                 usleep(10000);
1286                                 count++;
1287                                 if (TTS_RETRY_COUNT == count) {
1288                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1289                                         return ret;
1290                                 }
1291                         }
1292                 }
1293         }
1294
1295         client->before_state = client->current_state;
1296         client->current_state = TTS_STATE_PLAYING;
1297
1298         if (NULL != client->state_changed_cb) {
1299                 tts_client_use_callback(client);
1300                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1301                 tts_client_not_use_callback(client);
1302                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1303         }
1304
1305         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1306
1307         return TTS_ERROR_NONE;
1308 }
1309
1310 static void __tts_stop_async(void *data)
1311 {
1312         tts_h tts = (tts_h)data;
1313         tts_client_s* client = tts_client_get(tts);
1314
1315         /* check handle */
1316         if (NULL == client) {
1317                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1318                 return;
1319         }
1320
1321         int ret = -1;
1322         int count = 0;
1323         while (0 != ret) {
1324                 ret = tts_dbus_request_stop(client->uid);
1325                 if (0 != ret) {
1326                         if (TTS_ERROR_TIMED_OUT != ret) {
1327                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1328                                 break;
1329                         } else {
1330                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1331                                 usleep(10000);
1332                                 count++;
1333                                 if (TTS_RETRY_COUNT == count) {
1334                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1335                                         break;
1336                                 }
1337                         }
1338                 }
1339         }
1340
1341         if (0 != ret) {
1342                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1343
1344                 client->reason = ret;
1345                 client->utt_id = -1;
1346
1347                 ecore_timer_add(0, __tts_notify_error, client->tts);
1348                 return;
1349         }
1350
1351         client->before_state = client->current_state;
1352         client->current_state = TTS_STATE_READY;
1353
1354         if (NULL != client->state_changed_cb) {
1355                 tts_client_use_callback(client);
1356                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1357                 tts_client_not_use_callback(client);
1358                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1359         }
1360
1361         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1362
1363         return;
1364 }
1365
1366 int tts_stop_aync(tts_h tts)
1367 {
1368         if (0 != __tts_get_feature_enabled()) {
1369                 return TTS_ERROR_NOT_SUPPORTED;
1370         }
1371
1372         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1373
1374         if (NULL == tts) {
1375                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1376                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1377                 return TTS_ERROR_INVALID_PARAMETER;
1378         }
1379
1380         tts_client_s* client = tts_client_get(tts);
1381
1382         if (NULL == client) {
1383                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1384                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1385                 return TTS_ERROR_INVALID_PARAMETER;
1386         }
1387
1388         if (TTS_STATE_CREATED == client->current_state) {
1389                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1390                 return TTS_ERROR_INVALID_STATE;
1391         }
1392
1393         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1394                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1395                 return TTS_ERROR_INVALID_STATE;
1396         }
1397
1398         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1399
1400         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1401
1402         return TTS_ERROR_NONE;
1403 }
1404
1405 int tts_stop(tts_h tts)
1406 {
1407         if (0 != __tts_get_feature_enabled()) {
1408                 return TTS_ERROR_NOT_SUPPORTED;
1409         }
1410
1411         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1412
1413         if (NULL == tts) {
1414                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1415                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1416                 return TTS_ERROR_INVALID_PARAMETER;
1417         }
1418
1419         tts_client_s* client = tts_client_get(tts);
1420
1421         if (NULL == client) {
1422                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1423                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1424                 return TTS_ERROR_INVALID_PARAMETER;
1425         }
1426
1427         if (TTS_STATE_CREATED == client->current_state) {
1428                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1429                 return TTS_ERROR_INVALID_STATE;
1430         }
1431
1432         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1433                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1434                 return TTS_ERROR_INVALID_STATE;
1435         }
1436
1437         int ret = -1;
1438         int count = 0;
1439         while (0 != ret) {
1440                 ret = tts_dbus_request_stop(client->uid);
1441                 if (0 != ret) {
1442                         if (TTS_ERROR_TIMED_OUT != ret) {
1443                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1444                                 return ret;
1445                         } else {
1446                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1447                                 usleep(10000);
1448                                 count++;
1449                                 if (TTS_RETRY_COUNT == count) {
1450                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1451                                         return ret;
1452                                 }
1453                         }
1454                 }
1455         }
1456
1457         client->before_state = client->current_state;
1458         client->current_state = TTS_STATE_READY;
1459
1460         if (NULL != client->state_changed_cb) {
1461                 tts_client_use_callback(client);
1462                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1463                 tts_client_not_use_callback(client);
1464                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1465         }
1466
1467         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1468
1469         return TTS_ERROR_NONE;
1470 }
1471
1472 static void __tts_pause_async(void *data)
1473 {
1474         tts_h tts = (tts_h)data;
1475         tts_client_s* client = tts_client_get(tts);
1476
1477         /* check handle */
1478         if (NULL == client) {
1479                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1480                 return;
1481         }
1482
1483         int ret = -1;
1484         int count = 0;
1485         while (0 != ret) {
1486                 ret = tts_dbus_request_pause(client->uid);
1487                 if (0 != ret) {
1488                         if (TTS_ERROR_TIMED_OUT != ret) {
1489                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1490                                 break;
1491                         } else {
1492                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1493                                 usleep(10000);
1494                                 count++;
1495                                 if (TTS_RETRY_COUNT == count) {
1496                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1497                                         break;
1498                                 }
1499                         }
1500                 }
1501         }
1502
1503         if (0 != ret) {
1504                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1505
1506                 client->reason = ret;
1507                 client->utt_id = -1;
1508
1509                 ecore_timer_add(0, __tts_notify_error, client->tts);
1510                 return;
1511         }
1512
1513         client->before_state = client->current_state;
1514         client->current_state = TTS_STATE_PAUSED;
1515
1516         if (NULL != client->state_changed_cb) {
1517                 tts_client_use_callback(client);
1518                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1519                 tts_client_not_use_callback(client);
1520                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1521         }
1522
1523         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1524
1525         return;
1526 }
1527
1528 int tts_pause_async(tts_h tts)
1529 {
1530         if (0 != __tts_get_feature_enabled()) {
1531                 return TTS_ERROR_NOT_SUPPORTED;
1532         }
1533
1534         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1535
1536         if (NULL == tts) {
1537                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1538                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1539                 return TTS_ERROR_INVALID_PARAMETER;
1540         }
1541
1542         tts_client_s* client = tts_client_get(tts);
1543
1544         if (NULL == client) {
1545                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1546                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1547                 return TTS_ERROR_INVALID_PARAMETER;
1548         }
1549
1550         if (TTS_STATE_PLAYING != client->current_state) {
1551                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1552                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1553                 return TTS_ERROR_INVALID_STATE;
1554         }
1555
1556         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1557                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1558                 return TTS_ERROR_INVALID_STATE;
1559         }
1560
1561         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1562
1563         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1564
1565         return TTS_ERROR_NONE;
1566 }
1567
1568 int tts_pause(tts_h tts)
1569 {
1570         if (0 != __tts_get_feature_enabled()) {
1571                 return TTS_ERROR_NOT_SUPPORTED;
1572         }
1573
1574         SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1575
1576         if (NULL == tts) {
1577                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1578                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1579                 return TTS_ERROR_INVALID_PARAMETER;
1580         }
1581
1582         tts_client_s* client = tts_client_get(tts);
1583
1584         if (NULL == client) {
1585                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1586                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1587                 return TTS_ERROR_INVALID_PARAMETER;
1588         }
1589
1590         if (TTS_STATE_PLAYING != client->current_state) {
1591                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1592                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1593                 return TTS_ERROR_INVALID_STATE;
1594         }
1595
1596         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1597                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1598                 return TTS_ERROR_INVALID_STATE;
1599         }
1600
1601         int ret = -1;
1602         int count = 0;
1603         while (0 != ret) {
1604                 ret = tts_dbus_request_pause(client->uid);
1605                 if (0 != ret) {
1606                         if (TTS_ERROR_TIMED_OUT != ret) {
1607                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1608                                 return ret;
1609                         } else {
1610                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1611                                 usleep(10000);
1612                                 count++;
1613                                 if (TTS_RETRY_COUNT == count) {
1614                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1615                                         return ret;
1616                                 }
1617                         }
1618                 }
1619         }
1620
1621         client->before_state = client->current_state;
1622         client->current_state = TTS_STATE_PAUSED;
1623
1624         if (NULL != client->state_changed_cb) {
1625                 tts_client_use_callback(client);
1626                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1627                 tts_client_not_use_callback(client);
1628                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1629         }
1630
1631         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1632
1633         return TTS_ERROR_NONE;
1634 }
1635
1636 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1637 {
1638         if (0 != __tts_get_feature_enabled()) {
1639                 return TTS_ERROR_NOT_SUPPORTED;
1640         }
1641
1642         SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1643
1644         if (NULL == tts) {
1645                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1646                 return TTS_ERROR_INVALID_PARAMETER;
1647         }
1648
1649         if (NULL == key || NULL == data) {
1650                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1651                 return TTS_ERROR_INVALID_PARAMETER;
1652         }
1653
1654         tts_client_s* client = tts_client_get(tts);
1655
1656         if (NULL == client) {
1657                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1658                 return TTS_ERROR_INVALID_PARAMETER;
1659         }
1660
1661         if (TTS_STATE_READY != client->current_state) {
1662                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1663                 return TTS_ERROR_INVALID_STATE;
1664         }
1665
1666         if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1667                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1668                 return TTS_ERROR_INVALID_PARAMETER;
1669         }
1670
1671         int ret = -1;
1672         int count = 0;
1673         while (0 != ret) {
1674                 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1675                 if (0 != ret) {
1676                         if (TTS_ERROR_TIMED_OUT != ret) {
1677                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1678                                 return ret;
1679                         } else {
1680                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1681                                 usleep(10000);
1682                                 count++;
1683                                 if (TTS_RETRY_COUNT == count) {
1684                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1685                                         return ret;
1686                                 }
1687                         }
1688                 }
1689         }
1690
1691         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1692
1693         return 0;
1694 }
1695
1696 int tts_get_private_data(tts_h tts, const char* key, char** data)
1697 {
1698         if (0 != __tts_get_feature_enabled()) {
1699                 return TTS_ERROR_NOT_SUPPORTED;
1700         }
1701
1702         SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1703
1704         if (NULL == tts) {
1705                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1706                 return TTS_ERROR_INVALID_PARAMETER;
1707         }
1708
1709         if (NULL == key || NULL == data) {
1710                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1711                 return TTS_ERROR_INVALID_PARAMETER;
1712         }
1713
1714         tts_client_s* client = tts_client_get(tts);
1715
1716         if (NULL == client) {
1717                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1718                 return TTS_ERROR_INVALID_PARAMETER;
1719         }
1720
1721         if (TTS_STATE_READY != client->current_state) {
1722                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1723                 return TTS_ERROR_INVALID_STATE;
1724         }
1725
1726         int ret = -1;
1727         int count = 0;
1728         while (0 != ret) {
1729                 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1730                 if (0 != ret) {
1731                         if (TTS_ERROR_TIMED_OUT != ret) {
1732                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1733                                 return ret;
1734                         } else {
1735                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1736                                 usleep(10000);
1737                                 count++;
1738                                 if (TTS_RETRY_COUNT == count) {
1739                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1740                                         return ret;
1741                                 }
1742                         }
1743                 }
1744         }
1745
1746         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1747                 free(*data);
1748                 *data = NULL;
1749         }
1750
1751         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1752
1753         return 0;
1754 }
1755
1756 static Eina_Bool __tts_notify_error(void *data)
1757 {
1758         tts_h tts = (tts_h)data;
1759
1760         tts_client_s* client = tts_client_get(tts);
1761
1762         /* check handle */
1763         if (NULL == client) {
1764                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1765                 return EINA_FALSE;
1766         }
1767
1768         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1769
1770         if (NULL != client->error_cb) {
1771                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1772                 tts_client_use_callback(client);
1773                 g_err_callback_status = true;
1774                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1775                 g_err_callback_status = false;
1776                 tts_client_not_use_callback(client);
1777         } else {
1778                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1779         }
1780
1781         return EINA_FALSE;
1782 }
1783
1784 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1785 {
1786         if (-1 == uid) {
1787                 GList* client_list = NULL;
1788                 client_list = tts_client_get_client_list();
1789
1790                 GList *iter = NULL;
1791                 tts_client_s *data = NULL;
1792
1793                 if (g_list_length(client_list) > 0) {
1794                         /* Get a first item */
1795                         iter = g_list_first(client_list);
1796
1797                         while (NULL != iter) {
1798                                 data = iter->data;
1799
1800                                 data->utt_id = utt_id;
1801                                 data->reason = reason;
1802                                 if (NULL != data->err_msg) {
1803                                         free(data->err_msg);
1804                                         data->err_msg = NULL;
1805                                 }
1806                                 if (NULL != err_msg)
1807                                         data->err_msg = strdup(err_msg);
1808
1809                                 /* call callback function */
1810                                 if (NULL != data->error_cb) {
1811                                         ecore_timer_add(0, __tts_notify_error, data->tts);
1812                                 } else {
1813                                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1814                                 }
1815
1816                                 if (TTS_ERROR_SERVICE_RESET == reason) {
1817                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1818
1819                                         data->current_state = TTS_STATE_CREATED;
1820                                         if (0 != tts_prepare(data->tts)) {
1821                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1822                                         }
1823                                 }
1824
1825                                 /* Next item */
1826                                 iter = g_list_next(iter);
1827                         }
1828                 }
1829         } else {
1830                 tts_client_s* client = tts_client_get_by_uid(uid);
1831
1832                 if (NULL == client) {
1833                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1834                         return TTS_ERROR_INVALID_PARAMETER;
1835                 }
1836
1837                 client->utt_id = utt_id;
1838                 client->reason = reason;
1839                 if (NULL != client->err_msg) {
1840                         free(client->err_msg);
1841                         client->err_msg = NULL;
1842                 }
1843                 if (NULL != err_msg)
1844                         client->err_msg = strdup(err_msg);
1845
1846                 /* call callback function */
1847                 if (NULL != client->error_cb) {
1848                         ecore_timer_add(0, __tts_notify_error, client->tts);
1849                 } else {
1850                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1851                 }
1852
1853                 if (TTS_ERROR_SERVICE_RESET == reason) {
1854                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1855
1856                         client->current_state = TTS_STATE_CREATED;
1857                         if (0 != tts_prepare(client->tts)) {
1858                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1859                         }
1860                 }
1861         }
1862
1863         return 0;
1864 }
1865
1866 static Eina_Bool __tts_notify_state_changed(void *data)
1867 {
1868         tts_h tts = (tts_h)data;
1869
1870         tts_client_s* client = tts_client_get(tts);
1871
1872         /* check handle */
1873         if (NULL == client) {
1874                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1875                 return EINA_FALSE;
1876         }
1877
1878         if (NULL != client->state_changed_cb) {
1879                 tts_client_use_callback(client);
1880                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1881                 tts_client_not_use_callback(client);
1882                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1883         } else {
1884                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1885         }
1886
1887         return EINA_FALSE;
1888 }
1889
1890 int __tts_cb_set_state(int uid, int state)
1891 {
1892         tts_client_s* client = tts_client_get_by_uid(uid);
1893         if (NULL == client) {
1894                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1895                 return -1;
1896         }
1897
1898         tts_state_e state_from_daemon = (tts_state_e)state;
1899
1900         if (client->current_state == state_from_daemon) {
1901                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1902                 return 0;
1903         }
1904
1905         if (NULL != client->state_changed_cb) {
1906                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1907         } else {
1908                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1909         }
1910
1911         client->before_state = client->current_state;
1912         client->current_state = state_from_daemon;
1913
1914         return 0;
1915 }
1916
1917 int __tts_cb_utt_started(int uid, int utt_id)
1918 {
1919         tts_client_s* client = tts_client_get_by_uid(uid);
1920
1921         if (NULL == client) {
1922                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1923                 return TTS_ERROR_INVALID_PARAMETER;
1924         }
1925
1926         SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1927
1928         client->utt_id = utt_id;
1929
1930         /* call callback function */
1931         if (NULL != client->utt_started_cb) {
1932                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1933                 tts_client_use_callback(client);
1934                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1935                 tts_client_not_use_callback(client);
1936         } else {
1937                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1938         }
1939
1940         return 0;
1941 }
1942
1943 int __tts_cb_utt_completed(int uid, int utt_id)
1944 {
1945         tts_client_s* client = tts_client_get_by_uid(uid);
1946
1947         if (NULL == client) {
1948                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1949                 return TTS_ERROR_INVALID_PARAMETER;
1950         }
1951
1952         SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1953
1954         client->utt_id = utt_id;
1955
1956         /* call callback function */
1957         if (NULL != client->utt_completeted_cb) {
1958                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1959                 tts_client_use_callback(client);
1960                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1961                 tts_client_not_use_callback(client);
1962         } else {
1963                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1964         }
1965
1966         return 0;
1967 }
1968
1969 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1970 {
1971         if (0 != __tts_get_feature_enabled()) {
1972                 return TTS_ERROR_NOT_SUPPORTED;
1973         }
1974
1975         if (NULL == tts || NULL == callback) {
1976                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1977                 return TTS_ERROR_INVALID_PARAMETER;
1978         }
1979
1980         tts_client_s* client = tts_client_get(tts);
1981
1982         if (NULL == client) {
1983                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1984                 return TTS_ERROR_INVALID_PARAMETER;
1985         }
1986
1987         if (TTS_STATE_CREATED != client->current_state) {
1988                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1989                 return TTS_ERROR_INVALID_STATE;
1990         }
1991
1992         client->state_changed_cb = callback;
1993         client->state_changed_user_data = user_data;
1994
1995         SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
1996
1997         return 0;
1998 }
1999
2000 int tts_unset_state_changed_cb(tts_h tts)
2001 {
2002         if (0 != __tts_get_feature_enabled()) {
2003                 return TTS_ERROR_NOT_SUPPORTED;
2004         }
2005
2006         if (NULL == tts) {
2007                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2008                 return TTS_ERROR_INVALID_PARAMETER;
2009         }
2010
2011         tts_client_s* client = tts_client_get(tts);
2012
2013         if (NULL == client) {
2014                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2015                 return TTS_ERROR_INVALID_PARAMETER;
2016         }
2017
2018         if (TTS_STATE_CREATED != client->current_state) {
2019                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2020                 return TTS_ERROR_INVALID_STATE;
2021         }
2022
2023         client->state_changed_cb = NULL;
2024         client->state_changed_user_data = NULL;
2025
2026         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2027
2028         return 0;
2029 }
2030
2031 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2032 {
2033         if (0 != __tts_get_feature_enabled()) {
2034                 return TTS_ERROR_NOT_SUPPORTED;
2035         }
2036
2037         if (NULL == tts || NULL == callback) {
2038                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2039                 return TTS_ERROR_INVALID_PARAMETER;
2040         }
2041
2042         tts_client_s* client = tts_client_get(tts);
2043
2044         if (NULL == client) {
2045                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2046                 return TTS_ERROR_INVALID_PARAMETER;
2047         }
2048
2049         if (TTS_STATE_CREATED != client->current_state) {
2050                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2051                 return TTS_ERROR_INVALID_STATE;
2052         }
2053
2054         client->utt_started_cb = callback;
2055         client->utt_started_user_data = user_data;
2056
2057         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2058
2059         return 0;
2060 }
2061
2062 int tts_unset_utterance_started_cb(tts_h tts)
2063 {
2064         if (0 != __tts_get_feature_enabled()) {
2065                 return TTS_ERROR_NOT_SUPPORTED;
2066         }
2067
2068         if (NULL == tts) {
2069                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2070                 return TTS_ERROR_INVALID_PARAMETER;
2071         }
2072
2073         tts_client_s* client = tts_client_get(tts);
2074
2075         if (NULL == client) {
2076                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2077                 return TTS_ERROR_INVALID_PARAMETER;
2078         }
2079
2080         if (TTS_STATE_CREATED != client->current_state) {
2081                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2082                 return TTS_ERROR_INVALID_STATE;
2083         }
2084
2085         client->utt_started_cb = NULL;
2086         client->utt_started_user_data = NULL;
2087
2088         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2089
2090         return 0;
2091 }
2092
2093 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2094 {
2095         if (0 != __tts_get_feature_enabled()) {
2096                 return TTS_ERROR_NOT_SUPPORTED;
2097         }
2098
2099         if (NULL == tts || NULL == callback) {
2100                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2101                 return TTS_ERROR_INVALID_PARAMETER;
2102         }
2103
2104         tts_client_s* client = tts_client_get(tts);
2105
2106         if (NULL == client) {
2107                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2108                 return TTS_ERROR_INVALID_PARAMETER;
2109         }
2110
2111         if (TTS_STATE_CREATED != client->current_state) {
2112                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2113                 return TTS_ERROR_INVALID_STATE;
2114         }
2115
2116         client->utt_completeted_cb = callback;
2117         client->utt_completed_user_data = user_data;
2118
2119         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2120
2121         return 0;
2122 }
2123
2124 int tts_unset_utterance_completed_cb(tts_h tts)
2125 {
2126         if (0 != __tts_get_feature_enabled()) {
2127                 return TTS_ERROR_NOT_SUPPORTED;
2128         }
2129
2130         if (NULL == tts) {
2131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2132                 return TTS_ERROR_INVALID_PARAMETER;
2133         }
2134
2135         tts_client_s* client = tts_client_get(tts);
2136
2137         if (NULL == client) {
2138                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2139                 return TTS_ERROR_INVALID_PARAMETER;
2140         }
2141
2142         if (TTS_STATE_CREATED != client->current_state) {
2143                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2144                 return TTS_ERROR_INVALID_STATE;
2145         }
2146
2147         client->utt_completeted_cb = NULL;
2148         client->utt_completed_user_data = NULL;
2149
2150         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2151         return 0;
2152 }
2153
2154 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2155 {
2156         if (0 != __tts_get_feature_enabled()) {
2157                 return TTS_ERROR_NOT_SUPPORTED;
2158         }
2159
2160         if (NULL == tts || NULL == callback) {
2161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2162                 return TTS_ERROR_INVALID_PARAMETER;
2163         }
2164
2165         tts_client_s* client = tts_client_get(tts);
2166
2167         if (NULL == client) {
2168                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2169                 return TTS_ERROR_INVALID_PARAMETER;
2170         }
2171
2172         if (TTS_STATE_CREATED != client->current_state) {
2173                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2174                 return TTS_ERROR_INVALID_STATE;
2175         }
2176
2177         client->error_cb = callback;
2178         client->error_user_data = user_data;
2179
2180         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2181
2182         return 0;
2183 }
2184
2185 int tts_unset_error_cb(tts_h tts)
2186 {
2187         if (0 != __tts_get_feature_enabled()) {
2188                 return TTS_ERROR_NOT_SUPPORTED;
2189         }
2190
2191         if (NULL == tts) {
2192                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2193                 return TTS_ERROR_INVALID_PARAMETER;
2194         }
2195
2196         tts_client_s* client = tts_client_get(tts);
2197
2198         if (NULL == client) {
2199                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2200                 return TTS_ERROR_INVALID_PARAMETER;
2201         }
2202
2203         if (TTS_STATE_CREATED != client->current_state) {
2204                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2205                 return TTS_ERROR_INVALID_STATE;
2206         }
2207
2208         client->error_cb = NULL;
2209         client->error_user_data = NULL;
2210
2211         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2212
2213         return 0;
2214 }
2215
2216 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2217 {
2218         if (0 != __tts_get_feature_enabled()) {
2219                 return TTS_ERROR_NOT_SUPPORTED;
2220         }
2221
2222         if (NULL == tts || NULL == callback) {
2223                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2224                 return TTS_ERROR_INVALID_PARAMETER;
2225         }
2226
2227         tts_client_s* client = tts_client_get(tts);
2228
2229         if (NULL == client) {
2230                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2231                 return TTS_ERROR_INVALID_PARAMETER;
2232         }
2233
2234         if (TTS_STATE_CREATED != client->current_state) {
2235                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2236                 return TTS_ERROR_INVALID_STATE;
2237         }
2238
2239         client->default_voice_changed_cb = callback;
2240         client->default_voice_changed_user_data = user_data;
2241
2242         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2243
2244         return 0;
2245 }
2246
2247 int tts_unset_default_voice_changed_cb(tts_h tts)
2248 {
2249         if (0 != __tts_get_feature_enabled()) {
2250                 return TTS_ERROR_NOT_SUPPORTED;
2251         }
2252
2253         if (NULL == tts) {
2254                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2255                 return TTS_ERROR_INVALID_PARAMETER;
2256         }
2257
2258         tts_client_s* client = tts_client_get(tts);
2259
2260         if (NULL == client) {
2261                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2262                 return TTS_ERROR_INVALID_PARAMETER;
2263         }
2264
2265         if (TTS_STATE_CREATED != client->current_state) {
2266                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2267                 return TTS_ERROR_INVALID_STATE;
2268         }
2269
2270         client->default_voice_changed_cb = NULL;
2271         client->default_voice_changed_user_data = NULL;
2272
2273         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2274
2275         return 0;
2276 }
2277
2278 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2279 {
2280         if (0 != __tts_get_feature_enabled()) {
2281                 return TTS_ERROR_NOT_SUPPORTED;
2282         }
2283
2284         if (NULL == tts || NULL == callback) {
2285                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2286                 return TTS_ERROR_INVALID_PARAMETER;
2287         }
2288
2289         tts_client_s* client = tts_client_get(tts);
2290
2291         if (NULL == client) {
2292                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2293                 return TTS_ERROR_INVALID_PARAMETER;
2294         }
2295
2296         if (TTS_STATE_CREATED != client->current_state) {
2297                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2298                 return TTS_ERROR_INVALID_STATE;
2299         }
2300
2301         client->engine_changed_cb = callback;
2302         client->engine_changed_user_data = user_data;
2303
2304         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2305
2306         return 0;
2307 }
2308
2309 int tts_unset_engine_changed_cb(tts_h tts)
2310 {
2311         if (0 != __tts_get_feature_enabled()) {
2312                 return TTS_ERROR_NOT_SUPPORTED;
2313         }
2314
2315         if (NULL == tts) {
2316                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2317                 return TTS_ERROR_INVALID_PARAMETER;
2318         }
2319
2320         tts_client_s* client = tts_client_get(tts);
2321
2322         if (NULL == client) {
2323                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2324                 return TTS_ERROR_INVALID_PARAMETER;
2325         }
2326
2327         if (TTS_STATE_CREATED != client->current_state) {
2328                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2329                 return TTS_ERROR_INVALID_STATE;
2330         }
2331
2332         client->engine_changed_cb = NULL;
2333         client->engine_changed_user_data = NULL;
2334
2335         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2336
2337         return 0;
2338 }
2339
2340 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2341 {
2342         if (0 != __tts_get_feature_enabled()) {
2343                 return TTS_ERROR_NOT_SUPPORTED;
2344         }
2345
2346         SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2347
2348         if (NULL == tts) {
2349                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2350                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2351                 return TTS_ERROR_INVALID_PARAMETER;
2352         }
2353
2354         tts_client_s* client = tts_client_get(tts);
2355
2356         if (NULL == client) {
2357                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2358                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2359                 return TTS_ERROR_INVALID_PARAMETER;
2360         }
2361
2362         if (TTS_STATE_CREATED == client->current_state) {
2363                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2364                 return TTS_ERROR_INVALID_STATE;
2365         }
2366
2367         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2368                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2369                 return TTS_ERROR_INVALID_STATE;
2370         }
2371
2372         int ret = -1;
2373         int count = 0;
2374         while (0 != ret) {
2375                 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2376                 if (0 != ret) {
2377                         if (TTS_ERROR_TIMED_OUT != ret) {
2378                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2379                                 return ret;
2380                         } else {
2381                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2382                                 usleep(10000);
2383                                 count++;
2384                                 if (TTS_RETRY_COUNT == count) {
2385                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2386                                         return ret;
2387                                 }
2388                         }
2389                 }
2390         }
2391
2392         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2393
2394         return TTS_ERROR_NONE;
2395 }
2396
2397 int tts_play_pcm(tts_h tts)
2398 {
2399         if (0 != __tts_get_feature_enabled()) {
2400                 return TTS_ERROR_NOT_SUPPORTED;
2401         }
2402
2403         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2404
2405         if (NULL == tts) {
2406                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2407                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2408                 return TTS_ERROR_INVALID_PARAMETER;
2409         }
2410
2411         tts_client_s* client = tts_client_get(tts);
2412
2413         if (NULL == client) {
2414                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2415                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2416                 return TTS_ERROR_INVALID_PARAMETER;
2417         }
2418
2419         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2420                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2421                 return TTS_ERROR_INVALID_STATE;
2422         }
2423
2424         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2425                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2426                 return TTS_ERROR_INVALID_STATE;
2427         }
2428
2429         int ret = -1;
2430         int count = 0;
2431         while (0 != ret) {
2432                 ret = tts_dbus_request_play_pcm(client->uid);
2433                 if (0 != ret) {
2434                         if (TTS_ERROR_TIMED_OUT != ret) {
2435                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2436                                 return ret;
2437                         } else {
2438                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2439                                 usleep(10000);
2440                                 count++;
2441                                 if (TTS_RETRY_COUNT == count) {
2442                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2443                                         return ret;
2444                                 }
2445                         }
2446                 }
2447         }
2448
2449         client->before_state = client->current_state;
2450         client->current_state = TTS_STATE_PLAYING;
2451
2452         if (NULL != client->state_changed_cb) {
2453                 tts_client_use_callback(client);
2454                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2455                 tts_client_not_use_callback(client);
2456                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2457         }
2458
2459         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2460
2461         return TTS_ERROR_NONE;
2462 }
2463
2464 int tts_stop_pcm(tts_h tts)
2465 {
2466         if (0 != __tts_get_feature_enabled()) {
2467                 return TTS_ERROR_NOT_SUPPORTED;
2468         }
2469
2470         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2471
2472         if (NULL == tts) {
2473                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2474                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2475                 return TTS_ERROR_INVALID_PARAMETER;
2476         }
2477
2478         tts_client_s* client = tts_client_get(tts);
2479
2480         if (NULL == client) {
2481                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2482                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2483                 return TTS_ERROR_INVALID_PARAMETER;
2484         }
2485
2486         if (TTS_STATE_CREATED == client->current_state) {
2487                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2488                 return TTS_ERROR_INVALID_STATE;
2489         }
2490
2491         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2492                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2493                 return TTS_ERROR_INVALID_STATE;
2494         }
2495
2496         int ret = -1;
2497         int count = 0;
2498         while (0 != ret) {
2499                 ret = tts_dbus_request_stop_pcm(client->uid);
2500                 if (0 != ret) {
2501                         if (TTS_ERROR_TIMED_OUT != ret) {
2502                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2503                                 return ret;
2504                         } else {
2505                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2506                                 usleep(10000);
2507                                 count++;
2508                                 if (TTS_RETRY_COUNT == count) {
2509                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2510                                         return ret;
2511                                 }
2512                         }
2513                 }
2514         }
2515
2516         client->before_state = client->current_state;
2517         client->current_state = TTS_STATE_READY;
2518
2519         if (NULL != client->state_changed_cb) {
2520                 tts_client_use_callback(client);
2521                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2522                 tts_client_not_use_callback(client);
2523                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2524         }
2525
2526         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2527
2528         return TTS_ERROR_NONE;
2529 }