client/tts.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 <dirent.h>
  15 #include <Ecore.h>
  16 #include <iconv.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <system_info.h>
  21 #include <vconf.h>
  22
  23 #include "tts.h"
  24 #include "tts_client.h"
  25 #include "tts_config_mgr.h"
  26 #include "tts_dbus.h"
  27 #include "tts_main.h"
  28
  29
  30 static bool g_screen_reader;
  31
  32 static int g_feature_enabled = -1;
  33
  34 static bool g_err_callback_status = false;
  35
  36 /* Function definition */
  37 static Eina_Bool __tts_notify_state_changed(void *data);
  38 static Eina_Bool __tts_notify_error(void *data);
  39
  40 const char* tts_tag()
  41 {
  42         return "ttsc";
  43 }
  44
  45 static int __tts_get_feature_enabled()
  46 {
  47         if (0 == g_feature_enabled) {
  48                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  49                 return TTS_ERROR_NOT_SUPPORTED;
  50         } else if (-1 == g_feature_enabled) {
  51                 bool tts_supported = false;
  52                 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
  53                         if (false == tts_supported) {
  54                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  55                                 g_feature_enabled = 0;
  56                                 return TTS_ERROR_NOT_SUPPORTED;
  57                         }
  58
  59                         g_feature_enabled = 1;
  60                 } else {
  61                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
  62                         return TTS_ERROR_NOT_SUPPORTED;
  63                 }
  64         }
  65
  66         return 0;
  67 }
  68
  69 static const char* __tts_get_error_code(tts_error_e err)
  70 {
  71         switch (err) {
  72         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
  73         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
  74         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
  75         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
  76         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
  77         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
  78         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
  79         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
  80         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
  81         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
  82         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
  83         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
  84         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
  85         default:
  86                 return "Invalid error code";
  87         }
  88         return NULL;
  89 }
  90
  91 static int __tts_convert_config_error_code(tts_config_error_e code)
  92 {
  93         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_ERROR_NONE;
  94         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_ERROR_OUT_OF_MEMORY;
  95         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_ERROR_IO_ERROR;
  96         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_ERROR_INVALID_PARAMETER;
  97         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_ERROR_INVALID_STATE;
  98         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_ERROR_INVALID_VOICE;
  99         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_ERROR_ENGINE_NOT_FOUND;
 100         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_ERROR_OPERATION_FAILED;
 101         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_ERROR_OPERATION_FAILED;
 102
 103         return code;
 104 }
 105
 106 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)
 107 {
 108         SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
 109                 before_lang, before_voice_type, language, voice_type);
 110
 111         GList* client_list = NULL;
 112         client_list = tts_client_get_client_list();
 113
 114         GList *iter = NULL;
 115         tts_client_s *data = NULL;
 116
 117         if (g_list_length(client_list) > 0) {
 118                 /* Get a first item */
 119                 iter = g_list_first(client_list);
 120
 121                 while (NULL != iter) {
 122                         data = iter->data;
 123                         if (NULL != data->default_voice_changed_cb) {
 124                                 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
 125                                 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
 126                                         language, voice_type, data->default_voice_changed_user_data);
 127                         }
 128
 129                         /* Next item */
 130                         iter = g_list_next(iter);
 131                 }
 132         }
 133
 134         return;
 135 }
 136
 137 int tts_create(tts_h* tts)
 138 {
 139         if (0 != __tts_get_feature_enabled()) {
 140                 return TTS_ERROR_NOT_SUPPORTED;
 141         }
 142
 143         SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
 144
 145         /* check param */
 146         if (NULL == tts) {
 147                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 148                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 149                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 150                 return TTS_ERROR_INVALID_PARAMETER;
 151         }
 152
 153         if (0 == tts_client_get_size()) {
 154                 if (0 != tts_dbus_open_connection()) {
 155                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
 156                         return TTS_ERROR_OPERATION_FAILED;
 157                 }
 158         }
 159
 160         if (0 != tts_client_new(tts)) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
 162                 return TTS_ERROR_OUT_OF_MEMORY;
 163         }
 164
 165         tts_client_s* client = tts_client_get(*tts);
 166         if (NULL == client) {
 167                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 168                 return TTS_ERROR_OPERATION_FAILED;
 169         }
 170
 171         int ret = tts_config_mgr_initialize(client->uid);
 172         if (0 != ret) {
 173                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
 174                 tts_client_destroy(*tts);
 175                 return __tts_convert_config_error_code(ret);
 176         }
 177
 178         ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 181                 tts_client_destroy(*tts);
 182                 return __tts_convert_config_error_code(ret);
 183         }
 184
 185         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 186         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 187
 188         return TTS_ERROR_NONE;
 189 }
 190
 191 int tts_destroy(tts_h tts)
 192 {
 193         if (0 != __tts_get_feature_enabled()) {
 194                 return TTS_ERROR_NOT_SUPPORTED;
 195         }
 196
 197         SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
 198
 199         if (NULL == tts) {
 200                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 201                 return TTS_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         tts_client_s* client = tts_client_get(tts);
 205
 206         /* check handle */
 207         if (NULL == client) {
 208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 209                 return TTS_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         /* check used callback */
 213         if (0 != tts_client_get_use_callback(client)) {
 214                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 215                 return TTS_ERROR_OPERATION_FAILED;
 216         }
 217
 218         tts_config_mgr_finalize(client->uid);
 219
 220         int ret = -1;
 221         int count = 0;
 222
 223         /* check state */
 224         switch (client->current_state) {
 225         case TTS_STATE_PAUSED:
 226         case TTS_STATE_PLAYING:
 227         case TTS_STATE_READY:
 228                 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 229                         while (0 != ret) {
 230                                 ret = tts_dbus_request_finalize(client->uid);
 231                                 if (0 != ret) {
 232                                         if (TTS_ERROR_TIMED_OUT != ret) {
 233                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 234                                                 break;
 235                                         } else {
 236                                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
 237                                                 usleep(10000);
 238                                                 count++;
 239                                                 if (TTS_RETRY_COUNT == count) {
 240                                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 241                                                         break;
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246                 } else {
 247                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 248                 }
 249
 250                 client->before_state = client->current_state;
 251                 client->current_state = TTS_STATE_CREATED;
 252
 253         case TTS_STATE_CREATED:
 254                 if (NULL != client->conn_timer) {
 255                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 256                         ecore_timer_del(client->conn_timer);
 257                         client->conn_timer = NULL;
 258                 }
 259                 /* Free resources */
 260                 tts_client_destroy(tts);
 261                 break;
 262
 263         default:
 264                 break;
 265         }
 266
 267         if (0 == tts_client_get_size()) {
 268                 if (0 != tts_dbus_close_connection()) {
 269                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 270                 }
 271         }
 272
 273         tts = NULL;
 274
 275         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 276         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 277
 278         return TTS_ERROR_NONE;
 279 }
 280
 281 void __tts_screen_reader_changed_cb(bool value)
 282 {
 283         g_screen_reader = value;
 284 }
 285
 286 int tts_set_mode(tts_h tts, tts_mode_e mode)
 287 {
 288         if (0 != __tts_get_feature_enabled()) {
 289                 return TTS_ERROR_NOT_SUPPORTED;
 290         }
 291
 292         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
 293
 294         tts_client_s* client = tts_client_get(tts);
 295
 296         /* check handle */
 297         if (NULL == client) {
 298                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 299                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 300                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 301                 return TTS_ERROR_INVALID_PARAMETER;
 302         }
 303
 304         /* check state */
 305         if (client->current_state != TTS_STATE_CREATED) {
 306                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 307                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 308                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 309                 return TTS_ERROR_INVALID_STATE;
 310         }
 311
 312         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
 313                 client->mode = mode;
 314         } else {
 315                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 316                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 317                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 318                 return TTS_ERROR_INVALID_PARAMETER;
 319         }
 320
 321         if (TTS_MODE_SCREEN_READER == mode) {
 322                 int ret;
 323                 int screen_reader;
 324                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 325                 if (0 != ret) {
 326                         SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 327                         return TTS_ERROR_OPERATION_FAILED;
 328                 }
 329                 g_screen_reader = (bool)screen_reader;
 330                 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
 331         } else {
 332                 tts_config_unset_screen_reader_callback(client->uid);
 333         }
 334
 335         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 336         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 337
 338         return TTS_ERROR_NONE;
 339 }
 340
 341 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 342 {
 343         if (0 != __tts_get_feature_enabled()) {
 344                 return TTS_ERROR_NOT_SUPPORTED;
 345         }
 346
 347         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
 348
 349         tts_client_s* client = tts_client_get(tts);
 350
 351         /* check handle */
 352         if (NULL == client) {
 353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 354                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 355                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 356                 return TTS_ERROR_INVALID_PARAMETER;
 357         }
 358
 359         /* check state */
 360         if (client->current_state != TTS_STATE_CREATED) {
 361                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 362                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 363                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 364                 return TTS_ERROR_INVALID_STATE;
 365         }
 366
 367         if (NULL == mode) {
 368                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 369                 return TTS_ERROR_INVALID_PARAMETER;
 370         }
 371
 372         *mode = client->mode;
 373
 374         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 375         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 376
 377         return TTS_ERROR_NONE;
 378 }
 379
 380 int tts_set_credential(tts_h tts, const char* credential)
 381 {
 382         if(0 != __tts_get_feature_enabled()) {
 383                 return TTS_ERROR_NOT_SUPPORTED;
 384         }
 385
 386         if (NULL == tts || NULL == credential) {
 387                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 388                 return TTS_ERROR_INVALID_PARAMETER;
 389         }
 390
 391         tts_client_s* client = tts_client_get(tts);
 392
 393         if (NULL == client) {
 394                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 395                 return TTS_ERROR_INVALID_PARAMETER;
 396         }
 397
 398         if (TTS_STATE_CREATED != client->current_state && TTS_STATE_READY != client->current_state) {
 399                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid (%d).", client->current_state);
 400                 return TTS_ERROR_INVALID_STATE;
 401         }
 402
 403         client->credential = strdup(credential);
 404
 405         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 406         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 407
 408         return TTS_ERROR_NONE;
 409 }
 410
 411 static Eina_Bool __tts_connect_daemon(void *data)
 412 {
 413         tts_h tts = (tts_h)data;
 414         tts_client_s* client = tts_client_get(tts);
 415
 416         /* check handle */
 417         if (NULL == client) {
 418                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 419                 return EINA_FALSE;
 420         }
 421
 422         /* Send hello */
 423         if (0 != tts_dbus_request_hello(client->uid)) {
 424                 return EINA_TRUE;
 425         }
 426
 427         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
 428
 429         /* do request initialize */
 430         int ret = -1;
 431         bool credential_needed = false;
 432
 433         ret = tts_dbus_request_initialize(client->uid, &credential_needed);
 434
 435         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 436                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 437
 438                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 439                 client->utt_id = -1;
 440
 441                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 442                 client->conn_timer = NULL;
 443                 return EINA_FALSE;
 444
 445         } else if (TTS_ERROR_NONE != ret) {
 446                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 447                 return EINA_TRUE;
 448
 449         } else {
 450                 /* success to connect tts-daemon */
 451                 client->credential_needed = credential_needed;
 452                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 453         }
 454
 455         client->conn_timer = NULL;
 456
 457         client = tts_client_get(tts);
 458         /* check handle */
 459         if (NULL == client) {
 460                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 461                 return EINA_FALSE;
 462         }
 463
 464         client->before_state = client->current_state;
 465         client->current_state = TTS_STATE_READY;
 466
 467         if (NULL != client->state_changed_cb) {
 468                 tts_client_use_callback(client);
 469                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 470                 tts_client_not_use_callback(client);
 471         } else {
 472                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 473         }
 474
 475         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 476         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 477
 478         return EINA_FALSE;
 479 }
 480
 481 int tts_prepare(tts_h tts)
 482 {
 483         if (0 != __tts_get_feature_enabled()) {
 484                 return TTS_ERROR_NOT_SUPPORTED;
 485         }
 486
 487         SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
 488
 489         tts_client_s* client = tts_client_get(tts);
 490
 491         /* check handle */
 492         if (NULL == client) {
 493                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 494                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 495                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 496                 return TTS_ERROR_INVALID_PARAMETER;
 497         }
 498
 499         /* check state */
 500         if (client->current_state != TTS_STATE_CREATED) {
 501                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 502                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 503                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 504                 return TTS_ERROR_INVALID_STATE;
 505         }
 506
 507         client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 508
 509         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 510         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 511
 512         return TTS_ERROR_NONE;
 513 }
 514
 515 int tts_unprepare(tts_h tts)
 516 {
 517         if (0 != __tts_get_feature_enabled()) {
 518                 return TTS_ERROR_NOT_SUPPORTED;
 519         }
 520
 521         SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
 522
 523         tts_client_s* client = tts_client_get(tts);
 524
 525         /* check handle */
 526         if (NULL == client) {
 527                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 528                 return TTS_ERROR_INVALID_PARAMETER;
 529         }
 530
 531         /* check state */
 532         if (client->current_state != TTS_STATE_READY) {
 533                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 534                 return TTS_ERROR_INVALID_STATE;
 535         }
 536
 537         int ret = -1;
 538         int count = 0;
 539         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 540                 while (0 != ret) {
 541                         ret = tts_dbus_request_finalize(client->uid);
 542                         if (0 != ret) {
 543                                 if (TTS_ERROR_TIMED_OUT != ret) {
 544                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 545                                         break;
 546                                 } else {
 547                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 548                                         usleep(10000);
 549                                         count++;
 550                                         if (TTS_RETRY_COUNT == count) {
 551                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 552                                                 break;
 553                                         }
 554                                 }
 555                         }
 556                 }
 557         } else {
 558                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 559         }
 560
 561         client->before_state = client->current_state;
 562         client->current_state = TTS_STATE_CREATED;
 563
 564         if (NULL != client->state_changed_cb) {
 565                 tts_client_use_callback(client);
 566                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 567                 tts_client_not_use_callback(client);
 568                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 569         }
 570
 571         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 572         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 573
 574         return TTS_ERROR_NONE;
 575 }
 576
 577 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 578 {
 579         tts_h tts = (tts_h)user_data;
 580
 581         tts_client_s* client = tts_client_get(tts);
 582         if (NULL == client) {
 583                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 584                 return false;
 585         }
 586
 587         /* call callback function */
 588         if (NULL != client->supported_voice_cb) {
 589                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 590         } else {
 591                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 592         }
 593
 594         return false;
 595 }
 596
 597 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 598 {
 599         if (0 != __tts_get_feature_enabled()) {
 600                 return TTS_ERROR_NOT_SUPPORTED;
 601         }
 602
 603         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 604
 605         if (NULL == tts || NULL == callback) {
 606                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 607                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 608                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 609                 return TTS_ERROR_INVALID_PARAMETER;
 610         }
 611
 612         tts_client_s* client = tts_client_get(tts);
 613
 614         /* check handle */
 615         if (NULL == client) {
 616                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 617                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 618                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 619                 return TTS_ERROR_INVALID_PARAMETER;
 620         }
 621
 622         int ret = 0;
 623         char* current_engine = NULL;
 624         ret = tts_config_mgr_get_engine(&current_engine);
 625         if (0 != ret) {
 626                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 627                 return __tts_convert_config_error_code(ret);
 628         }
 629
 630         client->supported_voice_cb = callback;
 631         client->supported_voice_user_data = user_data;
 632
 633         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 634
 635         if (NULL != current_engine)
 636                 free(current_engine);
 637
 638         client->supported_voice_cb = NULL;
 639         client->supported_voice_user_data = NULL;
 640
 641         if (0 != ret) {
 642                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 643                 ret = TTS_ERROR_OPERATION_FAILED;
 644         }
 645
 646         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 647         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 648
 649         return ret;
 650 }
 651
 652 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 653 {
 654         if (0 != __tts_get_feature_enabled()) {
 655                 return TTS_ERROR_NOT_SUPPORTED;
 656         }
 657
 658         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 659
 660         if (NULL == tts) {
 661                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 662                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 663                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 664                 return TTS_ERROR_INVALID_PARAMETER;
 665
 666         }
 667         tts_client_s* client = tts_client_get(tts);
 668
 669         if (NULL == client) {
 670                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 671                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 672                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 673                 return TTS_ERROR_INVALID_PARAMETER;
 674         }
 675
 676         /* Request call remote method */
 677         int ret = 0;
 678         ret = tts_config_mgr_get_voice(lang, vctype);
 679         if (0 != ret) {
 680                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 681                 return __tts_convert_config_error_code(ret);
 682         } else {
 683                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 684         }
 685
 686         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 687         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 688
 689         return ret;
 690 }
 691
 692 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 693 {
 694         if (0 != __tts_get_feature_enabled()) {
 695                 return TTS_ERROR_NOT_SUPPORTED;
 696         }
 697
 698         if (NULL == tts || NULL == size) {
 699                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 700                 return TTS_ERROR_INVALID_PARAMETER;
 701         }
 702
 703         tts_client_s* client = tts_client_get(tts);
 704
 705         if (NULL == client) {
 706                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 707                 return TTS_ERROR_INVALID_PARAMETER;
 708         }
 709
 710         if (TTS_STATE_READY != client->current_state) {
 711                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 712                 return TTS_ERROR_INVALID_STATE;
 713         }
 714
 715         *size = TTS_MAX_TEXT_SIZE;
 716
 717         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 718         return TTS_ERROR_NONE;
 719 }
 720
 721 int tts_get_state(tts_h tts, tts_state_e* state)
 722 {
 723         if (0 != __tts_get_feature_enabled()) {
 724                 return TTS_ERROR_NOT_SUPPORTED;
 725         }
 726
 727         if (NULL == tts || NULL == state) {
 728                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 729                 return TTS_ERROR_INVALID_PARAMETER;
 730         }
 731
 732         tts_client_s* client = tts_client_get(tts);
 733
 734         if (NULL == client) {
 735                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 736                 return TTS_ERROR_INVALID_PARAMETER;
 737         }
 738
 739         *state = client->current_state;
 740
 741         switch (*state) {
 742         case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 743         case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 744         case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 745         case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 746         default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 747         }
 748
 749         return TTS_ERROR_NONE;
 750 }
 751
 752 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 753 {
 754         if (0 != __tts_get_feature_enabled()) {
 755                 return TTS_ERROR_NOT_SUPPORTED;
 756         }
 757
 758         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 759                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 760                 return TTS_ERROR_INVALID_PARAMETER;
 761         }
 762
 763         tts_client_s* client = tts_client_get(tts);
 764
 765         if (NULL == client) {
 766                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 767                 return TTS_ERROR_INVALID_PARAMETER;
 768         }
 769
 770         *min = TTS_SPEED_MIN;
 771         *normal = TTS_SPEED_NORMAL;
 772         *max = TTS_SPEED_MAX;
 773
 774         return TTS_ERROR_NONE;
 775 }
 776
 777 int tts_get_error_message(tts_h tts, char** err_msg)
 778 {
 779         if(0 != __tts_get_feature_enabled()) {
 780                 return TTS_ERROR_NOT_SUPPORTED;
 781         }
 782
 783         if (NULL == tts || NULL == err_msg) {
 784                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 785                 return TTS_ERROR_INVALID_PARAMETER;
 786         }
 787
 788         tts_client_s* client = tts_client_get(tts);
 789
 790         if (NULL == client) {
 791                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 792                 return TTS_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         if (NULL != client->err_msg) {
 796                 *err_msg = strdup(client->err_msg);
 797                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
 798         } else {
 799                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
 800         }
 801
 802         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 803         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 804
 805         return TTS_ERROR_NONE;
 806 }
 807
 808 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 809 {
 810         if (0 != __tts_get_feature_enabled()) {
 811                 return TTS_ERROR_NOT_SUPPORTED;
 812         }
 813
 814         if (speed < 0) {
 815                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
 816                 return TTS_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         if (voice_type < 0) {
 820                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
 821                 return TTS_ERROR_INVALID_PARAMETER;
 822         }
 823
 824         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 825
 826         if (NULL == tts || NULL == utt_id) {
 827                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 828                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 829                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 830                 return TTS_ERROR_INVALID_PARAMETER;
 831         }
 832
 833         tts_client_s* client = tts_client_get(tts);
 834
 835         if (NULL == client) {
 836                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 837                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 838                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 839                 return TTS_ERROR_INVALID_PARAMETER;
 840         }
 841
 842         if (TTS_STATE_CREATED == client->current_state) {
 843                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 844                 return TTS_ERROR_INVALID_STATE;
 845         }
 846
 847         if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
 848                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 849                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 850                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 851                 return TTS_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
 855                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
 856                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 857                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 858                 return TTS_ERROR_INVALID_PARAMETER;
 859         }
 860
 861         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 862                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 863                 return TTS_ERROR_INVALID_STATE;
 864         }
 865
 866         if (true == client->credential_needed && NULL == client->credential) {
 867                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
 868                 return TTS_ERROR_PERMISSION_DENIED;
 869         }
 870
 871         /* check valid utf8 */
 872         iconv_t *ict;
 873         ict = iconv_open("utf-8", "");
 874         if ((iconv_t)-1 == ict) {
 875                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
 876                 return TTS_ERROR_OPERATION_FAILED;
 877         }
 878
 879         size_t len = strlen(text);
 880         char *in_tmp = NULL;
 881         char in_buf[TTS_MAX_TEXT_SIZE];
 882         char *out_tmp = NULL;
 883         char out_buf[TTS_MAX_TEXT_SIZE];
 884         size_t len_tmp = sizeof(out_buf);
 885
 886         memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
 887         snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
 888         in_tmp = in_buf;
 889
 890         memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
 891         out_tmp = out_buf;
 892
 893         size_t st;
 894         st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
 895         if ((size_t)-1 == st) {
 896                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
 897                 iconv_close(ict);
 898                 return TTS_ERROR_INVALID_PARAMETER;
 899         }
 900         iconv_close(ict);
 901         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
 902
 903         /* change default language value */
 904         char* temp = NULL;
 905
 906         if (NULL == language)
 907                 temp = strdup("default");
 908         else
 909                 temp = strdup(language);
 910
 911         client->current_utt_id++;
 912         if (client->current_utt_id == 10000) {
 913                 client->current_utt_id = 1;
 914         }
 915
 916         /* do request */
 917         int ret = -1;
 918         int count = 0;
 919         while (0 != ret) {
 920                 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
 921                 if (0 != ret) {
 922                         if (TTS_ERROR_TIMED_OUT != ret) {
 923                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 924                                 break;
 925                         } else {
 926                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
 927                                 usleep(10000);
 928                                 count++;
 929                                 if (TTS_RETRY_COUNT == count) {
 930                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 931                                         break;
 932                                 }
 933                         }
 934                 } else {
 935                         *utt_id = client->current_utt_id;
 936                 }
 937         }
 938
 939         if (NULL != temp)       free(temp);
 940
 941         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 942         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 943
 944         return ret;
 945 }
 946
 947 static void __tts_play_async(void *data)
 948 {
 949         tts_h tts = (tts_h)data;
 950         tts_client_s* client = tts_client_get(tts);
 951
 952         /* check handle */
 953         if (NULL == client) {
 954                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 955                 return;
 956         }
 957
 958         int ret = -1;
 959         int count = 0;
 960         while (0 != ret) {
 961                 ret = tts_dbus_request_play(client->uid, client->credential);
 962                 if (0 != ret) {
 963                         if (TTS_ERROR_TIMED_OUT != ret) {
 964                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 965                                 break;
 966                         } else {
 967                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
 968                                 usleep(10000);
 969                                 count++;
 970                                 if (TTS_RETRY_COUNT == count) {
 971                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 972                                         break;
 973                                 }
 974                         }
 975                 }
 976         }
 977
 978         if (0 != ret) {
 979                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
 980
 981                 client->reason = ret;
 982                 client->utt_id = -1;
 983
 984                 ecore_timer_add(0, __tts_notify_error, client->tts);
 985                 return;
 986         }
 987
 988         client->before_state = client->current_state;
 989         client->current_state = TTS_STATE_PLAYING;
 990
 991         if (NULL != client->state_changed_cb) {
 992                 tts_client_use_callback(client);
 993                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 994                 tts_client_not_use_callback(client);
 995                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 996         }
 997
 998         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 999         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1000
1001         return;
1002 }
1003
1004 int tts_play_async(tts_h tts)
1005 {
1006         if (0 != __tts_get_feature_enabled()) {
1007                 return TTS_ERROR_NOT_SUPPORTED;
1008         }
1009
1010         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1011
1012         if (NULL == tts) {
1013                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle 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_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1029                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1030                 return TTS_ERROR_INVALID_STATE;
1031         }
1032
1033         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1034                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1035                 return TTS_ERROR_INVALID_STATE;
1036         }
1037
1038         if (true == client->credential_needed && NULL == client->credential) {
1039                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1040                 return TTS_ERROR_PERMISSION_DENIED;
1041         }
1042
1043         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1044
1045         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1046         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1047
1048         return TTS_ERROR_NONE;
1049 }
1050
1051 int tts_play(tts_h tts)
1052 {
1053         if (0 != __tts_get_feature_enabled()) {
1054                 return TTS_ERROR_NOT_SUPPORTED;
1055         }
1056
1057         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1058
1059         if (NULL == tts) {
1060                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1061                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1062                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1063                 return TTS_ERROR_INVALID_PARAMETER;
1064         }
1065
1066         tts_client_s* client = tts_client_get(tts);
1067
1068         if (NULL == client) {
1069                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1070                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1071                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1072                 return TTS_ERROR_INVALID_PARAMETER;
1073         }
1074
1075         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1076                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1077                 return TTS_ERROR_INVALID_STATE;
1078         }
1079
1080         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1081                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1082                 return TTS_ERROR_INVALID_STATE;
1083         }
1084
1085         if (true == client->credential_needed && NULL == client->credential) {
1086                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1087                 return TTS_ERROR_PERMISSION_DENIED;
1088         }
1089
1090         int ret = -1;
1091         int count = 0;
1092         while (0 != ret) {
1093                 ret = tts_dbus_request_play(client->uid, client->credential);
1094                 if (0 != ret) {
1095                         if (TTS_ERROR_TIMED_OUT != ret) {
1096                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1097                                 return ret;
1098                         } else {
1099                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1100                                 usleep(10000);
1101                                 count++;
1102                                 if (TTS_RETRY_COUNT == count) {
1103                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1104                                         return ret;
1105                                 }
1106                         }
1107                 }
1108         }
1109
1110         client->before_state = client->current_state;
1111         client->current_state = TTS_STATE_PLAYING;
1112
1113         if (NULL != client->state_changed_cb) {
1114                 tts_client_use_callback(client);
1115                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1116                 tts_client_not_use_callback(client);
1117                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1118         }
1119
1120         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1121         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1122
1123         return TTS_ERROR_NONE;
1124 }
1125
1126 static void __tts_stop_async(void *data)
1127 {
1128         tts_h tts = (tts_h)data;
1129         tts_client_s* client = tts_client_get(tts);
1130
1131         /* check handle */
1132         if (NULL == client) {
1133                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1134                 return;
1135         }
1136
1137         int ret = -1;
1138         int count = 0;
1139         while (0 != ret) {
1140                 ret = tts_dbus_request_stop(client->uid);
1141                 if (0 != ret) {
1142                         if (TTS_ERROR_TIMED_OUT != ret) {
1143                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1144                                 break;
1145                         } else {
1146                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1147                                 usleep(10000);
1148                                 count++;
1149                                 if (TTS_RETRY_COUNT == count) {
1150                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1151                                         break;
1152                                 }
1153                         }
1154                 }
1155         }
1156
1157         if (0 != ret) {
1158                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1159
1160                 client->reason = ret;
1161                 client->utt_id = -1;
1162
1163                 ecore_timer_add(0, __tts_notify_error, client->tts);
1164                 return;
1165         }
1166
1167         client->before_state = client->current_state;
1168         client->current_state = TTS_STATE_READY;
1169
1170         if (NULL != client->state_changed_cb) {
1171                 tts_client_use_callback(client);
1172                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1173                 tts_client_not_use_callback(client);
1174                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1175         }
1176
1177         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1178         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1179
1180         return;
1181 }
1182
1183 int tts_stop_aync(tts_h tts)
1184 {
1185         if (0 != __tts_get_feature_enabled()) {
1186                 return TTS_ERROR_NOT_SUPPORTED;
1187         }
1188
1189         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1190
1191         if (NULL == tts) {
1192                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1193                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1194                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1195                 return TTS_ERROR_INVALID_PARAMETER;
1196         }
1197
1198         tts_client_s* client = tts_client_get(tts);
1199
1200         if (NULL == client) {
1201                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1202                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1203                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1204                 return TTS_ERROR_INVALID_PARAMETER;
1205         }
1206
1207         if (TTS_STATE_CREATED == client->current_state) {
1208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1209                 return TTS_ERROR_INVALID_STATE;
1210         }
1211
1212         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1213                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1214                 return TTS_ERROR_INVALID_STATE;
1215         }
1216
1217         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1218
1219         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1220         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1221
1222         return TTS_ERROR_NONE;
1223 }
1224
1225 int tts_stop(tts_h tts)
1226 {
1227         if (0 != __tts_get_feature_enabled()) {
1228                 return TTS_ERROR_NOT_SUPPORTED;
1229         }
1230
1231         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1232
1233         if (NULL == tts) {
1234                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1235                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1236                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1237                 return TTS_ERROR_INVALID_PARAMETER;
1238         }
1239
1240         tts_client_s* client = tts_client_get(tts);
1241
1242         if (NULL == client) {
1243                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1244                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1245                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1246                 return TTS_ERROR_INVALID_PARAMETER;
1247         }
1248
1249         if (TTS_STATE_CREATED == client->current_state) {
1250                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1251                 return TTS_ERROR_INVALID_STATE;
1252         }
1253
1254         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1255                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1256                 return TTS_ERROR_INVALID_STATE;
1257         }
1258
1259         int ret = -1;
1260         int count = 0;
1261         while (0 != ret) {
1262                 ret = tts_dbus_request_stop(client->uid);
1263                 if (0 != ret) {
1264                         if (TTS_ERROR_TIMED_OUT != ret) {
1265                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1266                                 return ret;
1267                         } else {
1268                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1269                                 usleep(10000);
1270                                 count++;
1271                                 if (TTS_RETRY_COUNT == count) {
1272                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1273                                         return ret;
1274                                 }
1275                         }
1276                 }
1277         }
1278
1279         client->before_state = client->current_state;
1280         client->current_state = TTS_STATE_READY;
1281
1282         if (NULL != client->state_changed_cb) {
1283                 tts_client_use_callback(client);
1284                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1285                 tts_client_not_use_callback(client);
1286                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1287         }
1288
1289         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1290         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1291
1292         return TTS_ERROR_NONE;
1293 }
1294
1295 static void __tts_pause_async(void *data)
1296 {
1297         tts_h tts = (tts_h)data;
1298         tts_client_s* client = tts_client_get(tts);
1299
1300         /* check handle */
1301         if (NULL == client) {
1302                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1303                 return;
1304         }
1305
1306         int ret = -1;
1307         int count = 0;
1308         while (0 != ret) {
1309                 ret = tts_dbus_request_pause(client->uid);
1310                 if (0 != ret) {
1311                         if (TTS_ERROR_TIMED_OUT != ret) {
1312                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1313                                 break;
1314                         } else {
1315                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1316                                 usleep(10000);
1317                                 count++;
1318                                 if (TTS_RETRY_COUNT == count) {
1319                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1320                                         break;
1321                                 }
1322                         }
1323                 }
1324         }
1325
1326         if (0 != ret) {
1327                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1328
1329                 client->reason = ret;
1330                 client->utt_id = -1;
1331
1332                 ecore_timer_add(0, __tts_notify_error, client->tts);
1333                 return;
1334         }
1335
1336         client->before_state = client->current_state;
1337         client->current_state = TTS_STATE_PAUSED;
1338
1339         if (NULL != client->state_changed_cb) {
1340                 tts_client_use_callback(client);
1341                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1342                 tts_client_not_use_callback(client);
1343                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1344         }
1345
1346         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1347         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1348
1349         return;
1350 }
1351
1352 int tts_pause_async(tts_h tts)
1353 {
1354         if (0 != __tts_get_feature_enabled()) {
1355                 return TTS_ERROR_NOT_SUPPORTED;
1356         }
1357
1358         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1359
1360         if (NULL == tts) {
1361                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1362                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1363                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1364                 return TTS_ERROR_INVALID_PARAMETER;
1365         }
1366
1367         tts_client_s* client = tts_client_get(tts);
1368
1369         if (NULL == client) {
1370                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1371                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1372                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1373                 return TTS_ERROR_INVALID_PARAMETER;
1374         }
1375
1376         if (TTS_STATE_PLAYING != client->current_state) {
1377                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1378                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1379                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1380                 return TTS_ERROR_INVALID_STATE;
1381         }
1382
1383         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1384                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1385                 return TTS_ERROR_INVALID_STATE;
1386         }
1387
1388         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1389
1390         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1391         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1392
1393         return TTS_ERROR_NONE;
1394 }
1395
1396 int tts_pause(tts_h tts)
1397 {
1398         if (0 != __tts_get_feature_enabled()) {
1399                 return TTS_ERROR_NOT_SUPPORTED;
1400         }
1401
1402         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1403
1404         if (NULL == tts) {
1405                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1406                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1407                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1408                 return TTS_ERROR_INVALID_PARAMETER;
1409         }
1410
1411         tts_client_s* client = tts_client_get(tts);
1412
1413         if (NULL == client) {
1414                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1415                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1416                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1417                 return TTS_ERROR_INVALID_PARAMETER;
1418         }
1419
1420         if (TTS_STATE_PLAYING != client->current_state) {
1421                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1422                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1423                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1424                 return TTS_ERROR_INVALID_STATE;
1425         }
1426
1427         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1428                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1429                 return TTS_ERROR_INVALID_STATE;
1430         }
1431
1432         int ret = -1;
1433         int count = 0;
1434         while (0 != ret) {
1435                 ret = tts_dbus_request_pause(client->uid);
1436                 if (0 != ret) {
1437                         if (TTS_ERROR_TIMED_OUT != ret) {
1438                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1439                                 return ret;
1440                         } else {
1441                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1442                                 usleep(10000);
1443                                 count++;
1444                                 if (TTS_RETRY_COUNT == count) {
1445                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1446                                         return ret;
1447                                 }
1448                         }
1449                 }
1450         }
1451
1452         client->before_state = client->current_state;
1453         client->current_state = TTS_STATE_PAUSED;
1454
1455         if (NULL != client->state_changed_cb) {
1456                 tts_client_use_callback(client);
1457                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1458                 tts_client_not_use_callback(client);
1459                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1460         }
1461
1462         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1463         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1464
1465         return TTS_ERROR_NONE;
1466 }
1467
1468 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1469 {
1470         if (0 != __tts_get_feature_enabled()) {
1471                 return TTS_ERROR_NOT_SUPPORTED;
1472         }
1473
1474         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1475
1476         if (NULL == tts) {
1477                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1478                 return TTS_ERROR_INVALID_PARAMETER;
1479         }
1480
1481         if (NULL == key || NULL == data) {
1482                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1483                 return TTS_ERROR_INVALID_PARAMETER;
1484         }
1485
1486         tts_client_s* client = tts_client_get(tts);
1487
1488         if (NULL == client) {
1489                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1490                 return TTS_ERROR_INVALID_PARAMETER;
1491         }
1492
1493         if (TTS_STATE_READY != client->current_state) {
1494                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1495                 return TTS_ERROR_INVALID_STATE;
1496         }
1497
1498         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1499                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1500                 return TTS_ERROR_INVALID_STATE;
1501         }
1502
1503         int ret = -1;
1504         int count = 0;
1505         while (0 != ret) {
1506                 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1507                 if (0 != ret) {
1508                         if (TTS_ERROR_TIMED_OUT != ret) {
1509                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1510                                 return ret;
1511                         } else {
1512                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1513                                 usleep(10000);
1514                                 count++;
1515                                 if (TTS_RETRY_COUNT == count) {
1516                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1517                                         return ret;
1518                                 }
1519                         }
1520                 }
1521         }
1522
1523         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1524         SLOG(LOG_DEBUG, TAG_TTSC, "");
1525
1526         return 0;
1527 }
1528
1529 int tts_get_private_data(tts_h tts, const char* key, char** data)
1530 {
1531         if (0 != __tts_get_feature_enabled()) {
1532                 return TTS_ERROR_NOT_SUPPORTED;
1533         }
1534
1535         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1536
1537         if (NULL == tts) {
1538                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1539                 return TTS_ERROR_INVALID_PARAMETER;
1540         }
1541
1542         if (NULL == key || NULL == data) {
1543                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1544                 return TTS_ERROR_INVALID_PARAMETER;
1545         }
1546
1547         tts_client_s* client = tts_client_get(tts);
1548
1549         if (NULL == client) {
1550                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1551                 return TTS_ERROR_INVALID_PARAMETER;
1552         }
1553
1554         if (TTS_STATE_READY != client->current_state) {
1555                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1556                 return TTS_ERROR_INVALID_STATE;
1557         }
1558
1559         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1560                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1561                 return TTS_ERROR_INVALID_STATE;
1562         }
1563
1564         int ret = -1;
1565         int count = 0;
1566         while (0 != ret) {
1567                 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1568                 if (0 != ret) {
1569                         if (TTS_ERROR_TIMED_OUT != ret) {
1570                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1571                                 return ret;
1572                         } else {
1573                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1574                                 usleep(10000);
1575                                 count++;
1576                                 if (TTS_RETRY_COUNT == count) {
1577                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1578                                         return ret;
1579                                 }
1580                         }
1581                 }
1582         }
1583
1584         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1585         SLOG(LOG_DEBUG, TAG_TTSC, "");
1586
1587         return 0;
1588 }
1589
1590 static Eina_Bool __tts_notify_error(void *data)
1591 {
1592         tts_h tts = (tts_h)data;
1593
1594         tts_client_s* client = tts_client_get(tts);
1595
1596         /* check handle */
1597         if (NULL == client) {
1598                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1599                 return EINA_FALSE;
1600         }
1601
1602         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1603
1604         if (NULL != client->error_cb) {
1605                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1606                 tts_client_use_callback(client);
1607                 g_err_callback_status = true;
1608                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1609                 g_err_callback_status = false;
1610                 tts_client_not_use_callback(client);
1611         } else {
1612                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1613         }
1614
1615         return EINA_FALSE;
1616 }
1617
1618 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1619 {
1620         tts_client_s* client = tts_client_get_by_uid(uid);
1621
1622         if (NULL == client) {
1623                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1624                 return TTS_ERROR_INVALID_PARAMETER;
1625         }
1626
1627         client->utt_id = utt_id;
1628         client->reason = reason;
1629         if (NULL != client->err_msg) {
1630                 free(client->err_msg);
1631                 client->err_msg = NULL;
1632         }
1633         client->err_msg = strdup(err_msg);
1634
1635         /* call callback function */
1636         if (NULL != client->error_cb) {
1637                 ecore_timer_add(0, __tts_notify_error, client->tts);
1638         } else {
1639                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1640         }
1641
1642         return 0;
1643 }
1644
1645 static Eina_Bool __tts_notify_state_changed(void *data)
1646 {
1647         tts_h tts = (tts_h)data;
1648
1649         tts_client_s* client = tts_client_get(tts);
1650
1651         /* check handle */
1652         if (NULL == client) {
1653                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1654                 return EINA_FALSE;
1655         }
1656
1657         if (NULL != client->state_changed_cb) {
1658                 tts_client_use_callback(client);
1659                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1660                 tts_client_not_use_callback(client);
1661                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1662         } else {
1663                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1664         }
1665
1666         return EINA_FALSE;
1667 }
1668
1669 int __tts_cb_set_state(int uid, int state)
1670 {
1671         tts_client_s* client = tts_client_get_by_uid(uid);
1672         if (NULL == client) {
1673                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1674                 return -1;
1675         }
1676
1677         tts_state_e state_from_daemon = (tts_state_e)state;
1678
1679         if (client->current_state == state_from_daemon) {
1680                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1681                 return 0;
1682         }
1683
1684         if (NULL != client->state_changed_cb) {
1685                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1686         } else {
1687                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1688         }
1689
1690         client->before_state = client->current_state;
1691         client->current_state = state_from_daemon;
1692
1693         return 0;
1694 }
1695
1696 int __tts_cb_utt_started(int uid, int utt_id)
1697 {
1698         tts_client_s* client = tts_client_get_by_uid(uid);
1699
1700         if (NULL == client) {
1701                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1702                 return TTS_ERROR_INVALID_PARAMETER;
1703         }
1704
1705         SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1706
1707         client->utt_id = utt_id;
1708
1709         /* call callback function */
1710         if (NULL != client->utt_started_cb) {
1711                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1712                 tts_client_use_callback(client);
1713                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1714                 tts_client_not_use_callback(client);
1715         } else {
1716                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1717         }
1718
1719         return 0;
1720 }
1721
1722 int __tts_cb_utt_completed(int uid, int utt_id)
1723 {
1724         tts_client_s* client = tts_client_get_by_uid(uid);
1725
1726         if (NULL == client) {
1727                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1728                 return TTS_ERROR_INVALID_PARAMETER;
1729         }
1730
1731         SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1732
1733         client->utt_id = utt_id;
1734
1735         /* call callback function */
1736         if (NULL != client->utt_completeted_cb) {
1737                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1738                 tts_client_use_callback(client);
1739                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1740                 tts_client_not_use_callback(client);
1741         } else {
1742                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1743         }
1744
1745         return 0;
1746 }
1747
1748 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1749 {
1750         if (0 != __tts_get_feature_enabled()) {
1751                 return TTS_ERROR_NOT_SUPPORTED;
1752         }
1753
1754         if (NULL == tts || NULL == callback) {
1755                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1756                 return TTS_ERROR_INVALID_PARAMETER;
1757         }
1758
1759         tts_client_s* client = tts_client_get(tts);
1760
1761         if (NULL == client) {
1762                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1763                 return TTS_ERROR_INVALID_PARAMETER;
1764         }
1765
1766         if (TTS_STATE_CREATED != client->current_state) {
1767                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1768                 return TTS_ERROR_INVALID_STATE;
1769         }
1770
1771         client->state_changed_cb = callback;
1772         client->state_changed_user_data = user_data;
1773
1774         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1775
1776         return 0;
1777 }
1778
1779 int tts_unset_state_changed_cb(tts_h tts)
1780 {
1781         if (0 != __tts_get_feature_enabled()) {
1782                 return TTS_ERROR_NOT_SUPPORTED;
1783         }
1784
1785         if (NULL == tts) {
1786                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1787                 return TTS_ERROR_INVALID_PARAMETER;
1788         }
1789
1790         tts_client_s* client = tts_client_get(tts);
1791
1792         if (NULL == client) {
1793                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1794                 return TTS_ERROR_INVALID_PARAMETER;
1795         }
1796
1797         if (TTS_STATE_CREATED != client->current_state) {
1798                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1799                 return TTS_ERROR_INVALID_STATE;
1800         }
1801
1802         client->state_changed_cb = NULL;
1803         client->state_changed_user_data = NULL;
1804
1805         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1806
1807         return 0;
1808 }
1809
1810 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1811 {
1812         if (0 != __tts_get_feature_enabled()) {
1813                 return TTS_ERROR_NOT_SUPPORTED;
1814         }
1815
1816         if (NULL == tts || NULL == callback) {
1817                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1818                 return TTS_ERROR_INVALID_PARAMETER;
1819         }
1820
1821         tts_client_s* client = tts_client_get(tts);
1822
1823         if (NULL == client) {
1824                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1825                 return TTS_ERROR_INVALID_PARAMETER;
1826         }
1827
1828         if (TTS_STATE_CREATED != client->current_state) {
1829                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1830                 return TTS_ERROR_INVALID_STATE;
1831         }
1832
1833         client->utt_started_cb = callback;
1834         client->utt_started_user_data = user_data;
1835
1836         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1837
1838         return 0;
1839 }
1840
1841 int tts_unset_utterance_started_cb(tts_h tts)
1842 {
1843         if (0 != __tts_get_feature_enabled()) {
1844                 return TTS_ERROR_NOT_SUPPORTED;
1845         }
1846
1847         if (NULL == tts) {
1848                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1849                 return TTS_ERROR_INVALID_PARAMETER;
1850         }
1851
1852         tts_client_s* client = tts_client_get(tts);
1853
1854         if (NULL == client) {
1855                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1856                 return TTS_ERROR_INVALID_PARAMETER;
1857         }
1858
1859         if (TTS_STATE_CREATED != client->current_state) {
1860                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1861                 return TTS_ERROR_INVALID_STATE;
1862         }
1863
1864         client->utt_started_cb = NULL;
1865         client->utt_started_user_data = NULL;
1866
1867         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1868
1869         return 0;
1870 }
1871
1872 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1873 {
1874         if (0 != __tts_get_feature_enabled()) {
1875                 return TTS_ERROR_NOT_SUPPORTED;
1876         }
1877
1878         if (NULL == tts || NULL == callback) {
1879                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1880                 return TTS_ERROR_INVALID_PARAMETER;
1881         }
1882
1883         tts_client_s* client = tts_client_get(tts);
1884
1885         if (NULL == client) {
1886                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1887                 return TTS_ERROR_INVALID_PARAMETER;
1888         }
1889
1890         if (TTS_STATE_CREATED != client->current_state) {
1891                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1892                 return TTS_ERROR_INVALID_STATE;
1893         }
1894
1895         client->utt_completeted_cb = callback;
1896         client->utt_completed_user_data = user_data;
1897
1898         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1899
1900         return 0;
1901 }
1902
1903 int tts_unset_utterance_completed_cb(tts_h tts)
1904 {
1905         if (0 != __tts_get_feature_enabled()) {
1906                 return TTS_ERROR_NOT_SUPPORTED;
1907         }
1908
1909         if (NULL == tts) {
1910                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1911                 return TTS_ERROR_INVALID_PARAMETER;
1912         }
1913
1914         tts_client_s* client = tts_client_get(tts);
1915
1916         if (NULL == client) {
1917                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1918                 return TTS_ERROR_INVALID_PARAMETER;
1919         }
1920
1921         if (TTS_STATE_CREATED != client->current_state) {
1922                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1923                 return TTS_ERROR_INVALID_STATE;
1924         }
1925
1926         client->utt_completeted_cb = NULL;
1927         client->utt_completed_user_data = NULL;
1928
1929         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1930         return 0;
1931 }
1932
1933 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1934 {
1935         if (0 != __tts_get_feature_enabled()) {
1936                 return TTS_ERROR_NOT_SUPPORTED;
1937         }
1938
1939         if (NULL == tts || NULL == callback) {
1940                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1941                 return TTS_ERROR_INVALID_PARAMETER;
1942         }
1943
1944         tts_client_s* client = tts_client_get(tts);
1945
1946         if (NULL == client) {
1947                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1948                 return TTS_ERROR_INVALID_PARAMETER;
1949         }
1950
1951         if (TTS_STATE_CREATED != client->current_state) {
1952                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1953                 return TTS_ERROR_INVALID_STATE;
1954         }
1955
1956         client->error_cb = callback;
1957         client->error_user_data = user_data;
1958
1959         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1960
1961         return 0;
1962 }
1963
1964 int tts_unset_error_cb(tts_h tts)
1965 {
1966         if (0 != __tts_get_feature_enabled()) {
1967                 return TTS_ERROR_NOT_SUPPORTED;
1968         }
1969
1970         if (NULL == tts) {
1971                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1972                 return TTS_ERROR_INVALID_PARAMETER;
1973         }
1974
1975         tts_client_s* client = tts_client_get(tts);
1976
1977         if (NULL == client) {
1978                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1979                 return TTS_ERROR_INVALID_PARAMETER;
1980         }
1981
1982         if (TTS_STATE_CREATED != client->current_state) {
1983                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1984                 return TTS_ERROR_INVALID_STATE;
1985         }
1986
1987         client->error_cb = NULL;
1988         client->error_user_data = NULL;
1989
1990         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1991
1992         return 0;
1993 }
1994
1995 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1996 {
1997         if (0 != __tts_get_feature_enabled()) {
1998                 return TTS_ERROR_NOT_SUPPORTED;
1999         }
2000
2001         if (NULL == tts || NULL == callback) {
2002                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2003                 return TTS_ERROR_INVALID_PARAMETER;
2004         }
2005
2006         tts_client_s* client = tts_client_get(tts);
2007
2008         if (NULL == client) {
2009                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2010                 return TTS_ERROR_INVALID_PARAMETER;
2011         }
2012
2013         if (TTS_STATE_CREATED != client->current_state) {
2014                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2015                 return TTS_ERROR_INVALID_STATE;
2016         }
2017
2018         client->default_voice_changed_cb = callback;
2019         client->default_voice_changed_user_data = user_data;
2020
2021         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2022
2023         return 0;
2024 }
2025
2026 int tts_unset_default_voice_changed_cb(tts_h tts)
2027 {
2028         if (0 != __tts_get_feature_enabled()) {
2029                 return TTS_ERROR_NOT_SUPPORTED;
2030         }
2031
2032         if (NULL == tts) {
2033                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2034                 return TTS_ERROR_INVALID_PARAMETER;
2035         }
2036
2037         tts_client_s* client = tts_client_get(tts);
2038
2039         if (NULL == client) {
2040                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2041                 return TTS_ERROR_INVALID_PARAMETER;
2042         }
2043
2044         if (TTS_STATE_CREATED != client->current_state) {
2045                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2046                 return TTS_ERROR_INVALID_STATE;
2047         }
2048
2049         client->default_voice_changed_cb = NULL;
2050         client->default_voice_changed_user_data = NULL;
2051
2052         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2053
2054         return 0;
2055 }