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