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