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