client/tts.c

   1 /*
   2 *  Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <dirent.h>
  15 #include <Ecore.h>
  16 #include <iconv.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <system_info.h>
  21 #include <vconf.h>
  22
  23 #include "tts.h"
  24 #include "tts_client.h"
  25 #include "tts_config_mgr.h"
  26 #include "tts_dbus.h"
  27 #include "tts_main.h"
  28
  29
  30 static bool g_screen_reader;
  31
  32 static int g_feature_enabled = -1;
  33
  34 static bool g_err_callback_status = false;
  35
  36 /* Function definition */
  37 static Eina_Bool __tts_notify_state_changed(void *data);
  38 static Eina_Bool __tts_notify_error(void *data);
  39
  40 const char* tts_tag()
  41 {
  42         return "ttsc";
  43 }
  44
  45 static int __tts_get_feature_enabled()
  46 {
  47         if (0 == g_feature_enabled) {
  48                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  49                 return TTS_ERROR_NOT_SUPPORTED;
  50         } else if (-1 == g_feature_enabled) {
  51                 bool tts_supported = false;
  52                 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
  53                         if (false == tts_supported) {
  54                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  55                                 g_feature_enabled = 0;
  56                                 return TTS_ERROR_NOT_SUPPORTED;
  57                         }
  58
  59                         g_feature_enabled = 1;
  60                 } else {
  61                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
  62                         return TTS_ERROR_NOT_SUPPORTED;
  63                 }
  64         }
  65
  66         return 0;
  67 }
  68
  69 static const char* __tts_get_error_code(tts_error_e err)
  70 {
  71         switch (err) {
  72         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
  73         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
  74         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
  75         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
  76         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
  77         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
  78         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
  79         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
  80         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
  81         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
  82         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
  83         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
  84         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
  85         default:
  86                 return "Invalid error code";
  87         }
  88         return NULL;
  89 }
  90
  91 static int __tts_convert_config_error_code(tts_config_error_e code)
  92 {
  93         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_ERROR_NONE;
  94         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_ERROR_OUT_OF_MEMORY;
  95         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_ERROR_IO_ERROR;
  96         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_ERROR_INVALID_PARAMETER;
  97         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_ERROR_INVALID_STATE;
  98         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_ERROR_INVALID_VOICE;
  99         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_ERROR_ENGINE_NOT_FOUND;
 100         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_ERROR_OPERATION_FAILED;
 101         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_ERROR_OPERATION_FAILED;
 102
 103         return code;
 104 }
 105
 106 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
 107 {
 108         SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
 109                 before_lang, before_voice_type, language, voice_type);
 110
 111         GList* client_list = NULL;
 112         client_list = tts_client_get_client_list();
 113
 114         GList *iter = NULL;
 115         tts_client_s *data = NULL;
 116
 117         if (g_list_length(client_list) > 0) {
 118                 /* Get a first item */
 119                 iter = g_list_first(client_list);
 120
 121                 while (NULL != iter) {
 122                         data = iter->data;
 123                         if (NULL != data->default_voice_changed_cb) {
 124                                 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
 125                                 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
 126                                         language, voice_type, data->default_voice_changed_user_data);
 127                         }
 128
 129                         /* Next item */
 130                         iter = g_list_next(iter);
 131                 }
 132         }
 133
 134         return;
 135 }
 136
 137 int tts_create(tts_h* tts)
 138 {
 139         if (0 != __tts_get_feature_enabled()) {
 140                 return TTS_ERROR_NOT_SUPPORTED;
 141         }
 142
 143         SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
 144
 145         /* check param */
 146         if (NULL == tts) {
 147                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 148                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 149                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 150                 return TTS_ERROR_INVALID_PARAMETER;
 151         }
 152
 153         if (0 == tts_client_get_size()) {
 154                 if (0 != tts_dbus_open_connection()) {
 155                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
 156                         return TTS_ERROR_OPERATION_FAILED;
 157                 }
 158         }
 159
 160         if (0 != tts_client_new(tts)) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
 162                 return TTS_ERROR_OUT_OF_MEMORY;
 163         }
 164
 165         tts_client_s* client = tts_client_get(*tts);
 166         if (NULL == client) {
 167                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 168                 return TTS_ERROR_OPERATION_FAILED;
 169         }
 170
 171         int ret = tts_config_mgr_initialize(client->uid);
 172         if (0 != ret) {
 173                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
 174                 tts_client_destroy(*tts);
 175                 return __tts_convert_config_error_code(ret);
 176         }
 177
 178         ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 181                 tts_client_destroy(*tts);
 182                 return __tts_convert_config_error_code(ret);
 183         }
 184
 185         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 186         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 187
 188         return TTS_ERROR_NONE;
 189 }
 190
 191 int tts_destroy(tts_h tts)
 192 {
 193         if (0 != __tts_get_feature_enabled()) {
 194                 return TTS_ERROR_NOT_SUPPORTED;
 195         }
 196
 197         SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
 198
 199         if (NULL == tts) {
 200                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 201                 return TTS_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         tts_client_s* client = tts_client_get(tts);
 205
 206         /* check handle */
 207         if (NULL == client) {
 208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 209                 return TTS_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         /* check used callback */
 213         if (0 != tts_client_get_use_callback(client)) {
 214                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 215                 return TTS_ERROR_OPERATION_FAILED;
 216         }
 217
 218         tts_config_mgr_finalize(client->uid);
 219
 220         int ret = -1;
 221         int count = 0;
 222
 223         /* check state */
 224         switch (client->current_state) {
 225         case TTS_STATE_PAUSED:
 226         case TTS_STATE_PLAYING:
 227         case TTS_STATE_READY:
 228                 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 229                         while (0 != ret) {
 230                                 ret = tts_dbus_request_finalize(client->uid);
 231                                 if (0 != ret) {
 232                                         if (TTS_ERROR_TIMED_OUT != ret) {
 233                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 234                                                 break;
 235                                         } else {
 236                                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
 237                                                 usleep(10000);
 238                                                 count++;
 239                                                 if (TTS_RETRY_COUNT == count) {
 240                                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 241                                                         break;
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246                 } else {
 247                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 248                 }
 249
 250                 client->before_state = client->current_state;
 251                 client->current_state = TTS_STATE_CREATED;
 252
 253         case TTS_STATE_CREATED:
 254                 if (NULL != client->conn_timer) {
 255                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 256                         ecore_timer_del(client->conn_timer);
 257                         client->conn_timer = NULL;
 258                 }
 259                 /* Free resources */
 260                 tts_client_destroy(tts);
 261                 break;
 262
 263         default:
 264                 break;
 265         }
 266
 267         if (0 == tts_client_get_size()) {
 268                 if (0 != tts_dbus_close_connection()) {
 269                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 270                 }
 271         }
 272
 273         tts = NULL;
 274
 275         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 276         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 277
 278         return TTS_ERROR_NONE;
 279 }
 280
 281 void __tts_screen_reader_changed_cb(bool value)
 282 {
 283         g_screen_reader = value;
 284 }
 285
 286 int tts_set_mode(tts_h tts, tts_mode_e mode)
 287 {
 288         if (0 != __tts_get_feature_enabled()) {
 289                 return TTS_ERROR_NOT_SUPPORTED;
 290         }
 291
 292         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
 293
 294         tts_client_s* client = tts_client_get(tts);
 295
 296         /* check handle */
 297         if (NULL == client) {
 298                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 299                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 300                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 301                 return TTS_ERROR_INVALID_PARAMETER;
 302         }
 303
 304         /* check state */
 305         if (client->current_state != TTS_STATE_CREATED) {
 306                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 307                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 308                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 309                 return TTS_ERROR_INVALID_STATE;
 310         }
 311
 312         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
 313                 client->mode = mode;
 314         } else {
 315                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 316                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 317                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 318                 return TTS_ERROR_INVALID_PARAMETER;
 319         }
 320
 321         if (TTS_MODE_SCREEN_READER == mode) {
 322                 int ret;
 323                 int screen_reader;
 324                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 325                 if (0 != ret) {
 326                         SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 327                         return TTS_ERROR_OPERATION_FAILED;
 328                 }
 329                 g_screen_reader = (bool)screen_reader;
 330                 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
 331         } else {
 332                 tts_config_unset_screen_reader_callback(client->uid);
 333         }
 334
 335         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 336         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 337
 338         return TTS_ERROR_NONE;
 339 }
 340
 341 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 342 {
 343         if (0 != __tts_get_feature_enabled()) {
 344                 return TTS_ERROR_NOT_SUPPORTED;
 345         }
 346
 347         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
 348
 349         tts_client_s* client = tts_client_get(tts);
 350
 351         /* check handle */
 352         if (NULL == client) {
 353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 354                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 355                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 356                 return TTS_ERROR_INVALID_PARAMETER;
 357         }
 358
 359         /* check state */
 360         if (client->current_state != TTS_STATE_CREATED) {
 361                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 362                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 363                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 364                 return TTS_ERROR_INVALID_STATE;
 365         }
 366
 367         if (NULL == mode) {
 368                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 369                 return TTS_ERROR_INVALID_PARAMETER;
 370         }
 371
 372         *mode = client->mode;
 373
 374         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 375         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 376
 377         return TTS_ERROR_NONE;
 378 }
 379
 380 static Eina_Bool __tts_connect_daemon(void *data)
 381 {
 382         tts_h tts = (tts_h)data;
 383         tts_client_s* client = tts_client_get(tts);
 384
 385         /* check handle */
 386         if (NULL == client) {
 387                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 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                 client->conn_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         client->conn_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         client->conn_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_get_error_message(tts_h tts, char** err_msg)
 743 {
 744         if(0 != __tts_get_feature_enabled()) {
 745                 return TTS_ERROR_NOT_SUPPORTED;
 746         }
 747
 748         if (NULL == tts || NULL == err_msg) {
 749                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 750                 return TTS_ERROR_INVALID_PARAMETER;
 751         }
 752
 753         tts_client_s* client = tts_client_get(tts);
 754
 755         if (NULL == client) {
 756                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 757                 return TTS_ERROR_INVALID_PARAMETER;
 758         }
 759
 760         if (NULL != client->err_msg) {
 761                 *err_msg = strdup(client->err_msg);
 762                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
 763         } else {
 764                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
 765         }
 766
 767         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 768         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 769
 770         return TTS_ERROR_NONE;
 771 }
 772
 773 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 774 {
 775         if (0 != __tts_get_feature_enabled()) {
 776                 return TTS_ERROR_NOT_SUPPORTED;
 777         }
 778
 779         if (speed < 0) {
 780                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
 781                 return TTS_ERROR_INVALID_PARAMETER;
 782         }
 783
 784         if (voice_type < 0) {
 785                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
 786                 return TTS_ERROR_INVALID_PARAMETER;
 787         }
 788
 789         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 790
 791         if (NULL == tts || NULL == utt_id) {
 792                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 793                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 794                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 795                 return TTS_ERROR_INVALID_PARAMETER;
 796         }
 797
 798         tts_client_s* client = tts_client_get(tts);
 799
 800         if (NULL == client) {
 801                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 802                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 803                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 804                 return TTS_ERROR_INVALID_PARAMETER;
 805         }
 806
 807         if (TTS_STATE_CREATED == client->current_state) {
 808                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 809                 return TTS_ERROR_INVALID_STATE;
 810         }
 811
 812         if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
 813                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 814                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 815                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 816                 return TTS_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
 820                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
 821                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 822                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 823                 return TTS_ERROR_INVALID_PARAMETER;
 824         }
 825
 826         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 827                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 828                 return TTS_ERROR_INVALID_STATE;
 829         }
 830
 831         /* check valid utf8 */
 832         iconv_t *ict;
 833         ict = iconv_open("utf-8", "");
 834         if ((iconv_t)-1 == ict) {
 835                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
 836                 return TTS_ERROR_OPERATION_FAILED;
 837         }
 838
 839         size_t len = strlen(text);
 840         char *in_tmp = NULL;
 841         char in_buf[TTS_MAX_TEXT_SIZE];
 842         char *out_tmp = NULL;
 843         char out_buf[TTS_MAX_TEXT_SIZE];
 844         size_t len_tmp = sizeof(out_buf);
 845
 846         memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
 847         snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
 848         in_tmp = in_buf;
 849
 850         memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
 851         out_tmp = out_buf;
 852
 853         size_t st;
 854         st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
 855         if ((size_t)-1 == st) {
 856                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
 857                 iconv_close(ict);
 858                 return TTS_ERROR_INVALID_PARAMETER;
 859         }
 860         iconv_close(ict);
 861         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
 862
 863         /* change default language value */
 864         char* temp = NULL;
 865
 866         if (NULL == language)
 867                 temp = strdup("default");
 868         else
 869                 temp = strdup(language);
 870
 871         client->current_utt_id++;
 872         if (client->current_utt_id == 10000) {
 873                 client->current_utt_id = 1;
 874         }
 875
 876         /* do request */
 877         int ret = -1;
 878         int count = 0;
 879         while (0 != ret) {
 880                 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id);
 881                 if (0 != ret) {
 882                         if (TTS_ERROR_TIMED_OUT != ret) {
 883                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 884                                 break;
 885                         } else {
 886                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
 887                                 usleep(10000);
 888                                 count++;
 889                                 if (TTS_RETRY_COUNT == count) {
 890                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 891                                         break;
 892                                 }
 893                         }
 894                 } else {
 895                         *utt_id = client->current_utt_id;
 896                 }
 897         }
 898
 899         if (NULL != temp)       free(temp);
 900
 901         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 902         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 903
 904         return ret;
 905 }
 906
 907 static void __tts_play_async(void *data)
 908 {
 909         tts_h tts = (tts_h)data;
 910         tts_client_s* client = tts_client_get(tts);
 911
 912         /* check handle */
 913         if (NULL == client) {
 914                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 915                 return;
 916         }
 917
 918         int ret = -1;
 919         int count = 0;
 920         while (0 != ret) {
 921                 ret = tts_dbus_request_play(client->uid);
 922                 if (0 != ret) {
 923                         if (TTS_ERROR_TIMED_OUT != ret) {
 924                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 925                                 break;
 926                         } else {
 927                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
 928                                 usleep(10000);
 929                                 count++;
 930                                 if (TTS_RETRY_COUNT == count) {
 931                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 932                                         break;
 933                                 }
 934                         }
 935                 }
 936         }
 937
 938         if (0 != ret) {
 939                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
 940
 941                 client->reason = ret;
 942                 client->utt_id = -1;
 943
 944                 ecore_timer_add(0, __tts_notify_error, client->tts);
 945                 return;
 946         }
 947
 948         client->before_state = client->current_state;
 949         client->current_state = TTS_STATE_PLAYING;
 950
 951         if (NULL != client->state_changed_cb) {
 952                 tts_client_use_callback(client);
 953                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 954                 tts_client_not_use_callback(client);
 955                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 956         }
 957
 958         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 959         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 960
 961         return;
 962 }
 963
 964 int tts_play_async(tts_h tts)
 965 {
 966         if (0 != __tts_get_feature_enabled()) {
 967                 return TTS_ERROR_NOT_SUPPORTED;
 968         }
 969
 970         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
 971
 972         if (NULL == tts) {
 973                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
 974                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 975                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 976                 return TTS_ERROR_INVALID_PARAMETER;
 977         }
 978
 979         tts_client_s* client = tts_client_get(tts);
 980
 981         if (NULL == client) {
 982                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
 983                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 984                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 985                 return TTS_ERROR_INVALID_PARAMETER;
 986         }
 987
 988         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
 989                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
 990                 return TTS_ERROR_INVALID_STATE;
 991         }
 992
 993         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 994                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 995                 return TTS_ERROR_INVALID_STATE;
 996         }
 997
 998         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
 999
1000         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1001         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1002
1003         return TTS_ERROR_NONE;
1004 }
1005
1006 int tts_play(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         int ret = -1;
1041         int count = 0;
1042         while (0 != ret) {
1043                 ret = tts_dbus_request_play(client->uid);
1044                 if (0 != ret) {
1045                         if (TTS_ERROR_TIMED_OUT != ret) {
1046                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1047                                 return ret;
1048                         } else {
1049                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1050                                 usleep(10000);
1051                                 count++;
1052                                 if (TTS_RETRY_COUNT == count) {
1053                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1054                                         return ret;
1055                                 }
1056                         }
1057                 }
1058         }
1059
1060         client->before_state = client->current_state;
1061         client->current_state = TTS_STATE_PLAYING;
1062
1063         if (NULL != client->state_changed_cb) {
1064                 tts_client_use_callback(client);
1065                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1066                 tts_client_not_use_callback(client);
1067                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1068         }
1069
1070         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1071         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1072
1073         return TTS_ERROR_NONE;
1074 }
1075
1076 static void __tts_stop_async(void *data)
1077 {
1078         tts_h tts = (tts_h)data;
1079         tts_client_s* client = tts_client_get(tts);
1080
1081         /* check handle */
1082         if (NULL == client) {
1083                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1084                 return;
1085         }
1086
1087         int ret = -1;
1088         int count = 0;
1089         while (0 != ret) {
1090                 ret = tts_dbus_request_stop(client->uid);
1091                 if (0 != ret) {
1092                         if (TTS_ERROR_TIMED_OUT != ret) {
1093                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1094                                 break;
1095                         } else {
1096                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1097                                 usleep(10000);
1098                                 count++;
1099                                 if (TTS_RETRY_COUNT == count) {
1100                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1101                                         break;
1102                                 }
1103                         }
1104                 }
1105         }
1106
1107         if (0 != ret) {
1108                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1109
1110                 client->reason = ret;
1111                 client->utt_id = -1;
1112
1113                 ecore_timer_add(0, __tts_notify_error, client->tts);
1114                 return;
1115         }
1116
1117         client->before_state = client->current_state;
1118         client->current_state = TTS_STATE_READY;
1119
1120         if (NULL != client->state_changed_cb) {
1121                 tts_client_use_callback(client);
1122                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1123                 tts_client_not_use_callback(client);
1124                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1125         }
1126
1127         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1128         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1129
1130         return;
1131 }
1132
1133 int tts_stop_aync(tts_h tts)
1134 {
1135         if (0 != __tts_get_feature_enabled()) {
1136                 return TTS_ERROR_NOT_SUPPORTED;
1137         }
1138
1139         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1140
1141         if (NULL == tts) {
1142                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1143                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1144                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1145                 return TTS_ERROR_INVALID_PARAMETER;
1146         }
1147
1148         tts_client_s* client = tts_client_get(tts);
1149
1150         if (NULL == client) {
1151                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1152                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1153                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1154                 return TTS_ERROR_INVALID_PARAMETER;
1155         }
1156
1157         if (TTS_STATE_CREATED == client->current_state) {
1158                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1159                 return TTS_ERROR_INVALID_STATE;
1160         }
1161
1162         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1163                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1164                 return TTS_ERROR_INVALID_STATE;
1165         }
1166
1167         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1168
1169         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1170         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1171
1172         return TTS_ERROR_NONE;
1173 }
1174
1175 int tts_stop(tts_h tts)
1176 {
1177         if (0 != __tts_get_feature_enabled()) {
1178                 return TTS_ERROR_NOT_SUPPORTED;
1179         }
1180
1181         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1182
1183         if (NULL == tts) {
1184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1185                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1186                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1187                 return TTS_ERROR_INVALID_PARAMETER;
1188         }
1189
1190         tts_client_s* client = tts_client_get(tts);
1191
1192         if (NULL == client) {
1193                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1194                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1195                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1196                 return TTS_ERROR_INVALID_PARAMETER;
1197         }
1198
1199         if (TTS_STATE_CREATED == client->current_state) {
1200                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1201                 return TTS_ERROR_INVALID_STATE;
1202         }
1203
1204         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1205                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1206                 return TTS_ERROR_INVALID_STATE;
1207         }
1208
1209         int ret = -1;
1210         int count = 0;
1211         while (0 != ret) {
1212                 ret = tts_dbus_request_stop(client->uid);
1213                 if (0 != ret) {
1214                         if (TTS_ERROR_TIMED_OUT != ret) {
1215                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1216                                 return ret;
1217                         } else {
1218                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1219                                 usleep(10000);
1220                                 count++;
1221                                 if (TTS_RETRY_COUNT == count) {
1222                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1223                                         return ret;
1224                                 }
1225                         }
1226                 }
1227         }
1228
1229         client->before_state = client->current_state;
1230         client->current_state = TTS_STATE_READY;
1231
1232         if (NULL != client->state_changed_cb) {
1233                 tts_client_use_callback(client);
1234                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1235                 tts_client_not_use_callback(client);
1236                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1237         }
1238
1239         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1240         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1241
1242         return TTS_ERROR_NONE;
1243 }
1244
1245 static void __tts_pause_async(void *data)
1246 {
1247         tts_h tts = (tts_h)data;
1248         tts_client_s* client = tts_client_get(tts);
1249
1250         /* check handle */
1251         if (NULL == client) {
1252                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1253                 return;
1254         }
1255
1256         int ret = -1;
1257         int count = 0;
1258         while (0 != ret) {
1259                 ret = tts_dbus_request_pause(client->uid);
1260                 if (0 != ret) {
1261                         if (TTS_ERROR_TIMED_OUT != ret) {
1262                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1263                                 break;
1264                         } else {
1265                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1266                                 usleep(10000);
1267                                 count++;
1268                                 if (TTS_RETRY_COUNT == count) {
1269                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1270                                         break;
1271                                 }
1272                         }
1273                 }
1274         }
1275
1276         if (0 != ret) {
1277                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1278
1279                 client->reason = ret;
1280                 client->utt_id = -1;
1281
1282                 ecore_timer_add(0, __tts_notify_error, client->tts);
1283                 return;
1284         }
1285
1286         client->before_state = client->current_state;
1287         client->current_state = TTS_STATE_PAUSED;
1288
1289         if (NULL != client->state_changed_cb) {
1290                 tts_client_use_callback(client);
1291                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1292                 tts_client_not_use_callback(client);
1293                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1294         }
1295
1296         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1297         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1298
1299         return;
1300 }
1301
1302 int tts_pause_async(tts_h tts)
1303 {
1304         if (0 != __tts_get_feature_enabled()) {
1305                 return TTS_ERROR_NOT_SUPPORTED;
1306         }
1307
1308         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1309
1310         if (NULL == tts) {
1311                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1312                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1313                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1314                 return TTS_ERROR_INVALID_PARAMETER;
1315         }
1316
1317         tts_client_s* client = tts_client_get(tts);
1318
1319         if (NULL == client) {
1320                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1321                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1322                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1323                 return TTS_ERROR_INVALID_PARAMETER;
1324         }
1325
1326         if (TTS_STATE_PLAYING != client->current_state) {
1327                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1328                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1329                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1330                 return TTS_ERROR_INVALID_STATE;
1331         }
1332
1333         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1334                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1335                 return TTS_ERROR_INVALID_STATE;
1336         }
1337
1338         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1339
1340         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1341         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1342
1343         return TTS_ERROR_NONE;
1344 }
1345
1346 int tts_pause(tts_h tts)
1347 {
1348         if (0 != __tts_get_feature_enabled()) {
1349                 return TTS_ERROR_NOT_SUPPORTED;
1350         }
1351
1352         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1353
1354         if (NULL == tts) {
1355                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1356                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1357                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1358                 return TTS_ERROR_INVALID_PARAMETER;
1359         }
1360
1361         tts_client_s* client = tts_client_get(tts);
1362
1363         if (NULL == client) {
1364                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1365                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1366                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1367                 return TTS_ERROR_INVALID_PARAMETER;
1368         }
1369
1370         if (TTS_STATE_PLAYING != client->current_state) {
1371                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1372                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1373                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1374                 return TTS_ERROR_INVALID_STATE;
1375         }
1376
1377         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1378                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1379                 return TTS_ERROR_INVALID_STATE;
1380         }
1381
1382         int ret = -1;
1383         int count = 0;
1384         while (0 != ret) {
1385                 ret = tts_dbus_request_pause(client->uid);
1386                 if (0 != ret) {
1387                         if (TTS_ERROR_TIMED_OUT != ret) {
1388                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1389                                 return ret;
1390                         } else {
1391                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1392                                 usleep(10000);
1393                                 count++;
1394                                 if (TTS_RETRY_COUNT == count) {
1395                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1396                                         return ret;
1397                                 }
1398                         }
1399                 }
1400         }
1401
1402         client->before_state = client->current_state;
1403         client->current_state = TTS_STATE_PAUSED;
1404
1405         if (NULL != client->state_changed_cb) {
1406                 tts_client_use_callback(client);
1407                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1408                 tts_client_not_use_callback(client);
1409                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1410         }
1411
1412         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1413         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1414
1415         return TTS_ERROR_NONE;
1416 }
1417
1418 static Eina_Bool __tts_notify_error(void *data)
1419 {
1420         tts_h tts = (tts_h)data;
1421
1422         tts_client_s* client = tts_client_get(tts);
1423
1424         /* check handle */
1425         if (NULL == client) {
1426                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1427                 return EINA_FALSE;
1428         }
1429
1430         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1431
1432         if (NULL != client->error_cb) {
1433                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1434                 tts_client_use_callback(client);
1435                 g_err_callback_status = true;
1436                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1437                 g_err_callback_status = false;
1438                 tts_client_not_use_callback(client);
1439         } else {
1440                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1441         }
1442
1443         return EINA_FALSE;
1444 }
1445
1446 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1447 {
1448         tts_client_s* client = tts_client_get_by_uid(uid);
1449
1450         if (NULL == client) {
1451                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1452                 return TTS_ERROR_INVALID_PARAMETER;
1453         }
1454
1455         client->utt_id = utt_id;
1456         client->reason = reason;
1457         if (NULL != client->err_msg) {
1458                 free(client->err_msg);
1459                 client->err_msg = NULL;
1460         }
1461         client->err_msg = strdup(err_msg);
1462
1463         /* call callback function */
1464         if (NULL != client->error_cb) {
1465                 ecore_timer_add(0, __tts_notify_error, client->tts);
1466         } else {
1467                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1468         }
1469
1470         return 0;
1471 }
1472
1473 static Eina_Bool __tts_notify_state_changed(void *data)
1474 {
1475         tts_h tts = (tts_h)data;
1476
1477         tts_client_s* client = tts_client_get(tts);
1478
1479         /* check handle */
1480         if (NULL == client) {
1481                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1482                 return EINA_FALSE;
1483         }
1484
1485         if (NULL != client->state_changed_cb) {
1486                 tts_client_use_callback(client);
1487                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1488                 tts_client_not_use_callback(client);
1489                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1490         } else {
1491                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1492         }
1493
1494         return EINA_FALSE;
1495 }
1496
1497 int __tts_cb_set_state(int uid, int state)
1498 {
1499         tts_client_s* client = tts_client_get_by_uid(uid);
1500         if (NULL == client) {
1501                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1502                 return -1;
1503         }
1504
1505         tts_state_e state_from_daemon = (tts_state_e)state;
1506
1507         if (client->current_state == state_from_daemon) {
1508                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1509                 return 0;
1510         }
1511
1512         if (NULL != client->state_changed_cb) {
1513                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1514         } else {
1515                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1516         }
1517
1518         client->before_state = client->current_state;
1519         client->current_state = state_from_daemon;
1520
1521         return 0;
1522 }
1523
1524 int __tts_cb_utt_started(int uid, int utt_id)
1525 {
1526         tts_client_s* client = tts_client_get_by_uid(uid);
1527
1528         if (NULL == client) {
1529                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1530                 return TTS_ERROR_INVALID_PARAMETER;
1531         }
1532
1533         SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1534
1535         client->utt_id = utt_id;
1536
1537         /* call callback function */
1538         if (NULL != client->utt_started_cb) {
1539                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1540                 tts_client_use_callback(client);
1541                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1542                 tts_client_not_use_callback(client);
1543         } else {
1544                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1545         }
1546
1547         return 0;
1548 }
1549
1550 int __tts_cb_utt_completed(int uid, int utt_id)
1551 {
1552         tts_client_s* client = tts_client_get_by_uid(uid);
1553
1554         if (NULL == client) {
1555                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1556                 return TTS_ERROR_INVALID_PARAMETER;
1557         }
1558
1559         SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1560
1561         client->utt_id = utt_id;
1562
1563         /* call callback function */
1564         if (NULL != client->utt_completeted_cb) {
1565                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1566                 tts_client_use_callback(client);
1567                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1568                 tts_client_not_use_callback(client);
1569         } else {
1570                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1571         }
1572
1573         return 0;
1574 }
1575
1576 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1577 {
1578         if (0 != __tts_get_feature_enabled()) {
1579                 return TTS_ERROR_NOT_SUPPORTED;
1580         }
1581
1582         if (NULL == tts || NULL == callback) {
1583                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1584                 return TTS_ERROR_INVALID_PARAMETER;
1585         }
1586
1587         tts_client_s* client = tts_client_get(tts);
1588
1589         if (NULL == client) {
1590                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1591                 return TTS_ERROR_INVALID_PARAMETER;
1592         }
1593
1594         if (TTS_STATE_CREATED != client->current_state) {
1595                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1596                 return TTS_ERROR_INVALID_STATE;
1597         }
1598
1599         client->state_changed_cb = callback;
1600         client->state_changed_user_data = user_data;
1601
1602         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1603
1604         return 0;
1605 }
1606
1607 int tts_unset_state_changed_cb(tts_h tts)
1608 {
1609         if (0 != __tts_get_feature_enabled()) {
1610                 return TTS_ERROR_NOT_SUPPORTED;
1611         }
1612
1613         if (NULL == tts) {
1614                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1615                 return TTS_ERROR_INVALID_PARAMETER;
1616         }
1617
1618         tts_client_s* client = tts_client_get(tts);
1619
1620         if (NULL == client) {
1621                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1622                 return TTS_ERROR_INVALID_PARAMETER;
1623         }
1624
1625         if (TTS_STATE_CREATED != client->current_state) {
1626                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1627                 return TTS_ERROR_INVALID_STATE;
1628         }
1629
1630         client->state_changed_cb = NULL;
1631         client->state_changed_user_data = NULL;
1632
1633         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1634
1635         return 0;
1636 }
1637
1638 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1639 {
1640         if (0 != __tts_get_feature_enabled()) {
1641                 return TTS_ERROR_NOT_SUPPORTED;
1642         }
1643
1644         if (NULL == tts || NULL == callback) {
1645                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1646                 return TTS_ERROR_INVALID_PARAMETER;
1647         }
1648
1649         tts_client_s* client = tts_client_get(tts);
1650
1651         if (NULL == client) {
1652                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1653                 return TTS_ERROR_INVALID_PARAMETER;
1654         }
1655
1656         if (TTS_STATE_CREATED != client->current_state) {
1657                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1658                 return TTS_ERROR_INVALID_STATE;
1659         }
1660
1661         client->utt_started_cb = callback;
1662         client->utt_started_user_data = user_data;
1663
1664         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1665
1666         return 0;
1667 }
1668
1669 int tts_unset_utterance_started_cb(tts_h tts)
1670 {
1671         if (0 != __tts_get_feature_enabled()) {
1672                 return TTS_ERROR_NOT_SUPPORTED;
1673         }
1674
1675         if (NULL == tts) {
1676                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1677                 return TTS_ERROR_INVALID_PARAMETER;
1678         }
1679
1680         tts_client_s* client = tts_client_get(tts);
1681
1682         if (NULL == client) {
1683                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1684                 return TTS_ERROR_INVALID_PARAMETER;
1685         }
1686
1687         if (TTS_STATE_CREATED != client->current_state) {
1688                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1689                 return TTS_ERROR_INVALID_STATE;
1690         }
1691
1692         client->utt_started_cb = NULL;
1693         client->utt_started_user_data = NULL;
1694
1695         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1696
1697         return 0;
1698 }
1699
1700 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1701 {
1702         if (0 != __tts_get_feature_enabled()) {
1703                 return TTS_ERROR_NOT_SUPPORTED;
1704         }
1705
1706         if (NULL == tts || NULL == callback) {
1707                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1708                 return TTS_ERROR_INVALID_PARAMETER;
1709         }
1710
1711         tts_client_s* client = tts_client_get(tts);
1712
1713         if (NULL == client) {
1714                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1715                 return TTS_ERROR_INVALID_PARAMETER;
1716         }
1717
1718         if (TTS_STATE_CREATED != client->current_state) {
1719                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1720                 return TTS_ERROR_INVALID_STATE;
1721         }
1722
1723         client->utt_completeted_cb = callback;
1724         client->utt_completed_user_data = user_data;
1725
1726         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1727
1728         return 0;
1729 }
1730
1731 int tts_unset_utterance_completed_cb(tts_h tts)
1732 {
1733         if (0 != __tts_get_feature_enabled()) {
1734                 return TTS_ERROR_NOT_SUPPORTED;
1735         }
1736
1737         if (NULL == tts) {
1738                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1739                 return TTS_ERROR_INVALID_PARAMETER;
1740         }
1741
1742         tts_client_s* client = tts_client_get(tts);
1743
1744         if (NULL == client) {
1745                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1746                 return TTS_ERROR_INVALID_PARAMETER;
1747         }
1748
1749         if (TTS_STATE_CREATED != client->current_state) {
1750                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1751                 return TTS_ERROR_INVALID_STATE;
1752         }
1753
1754         client->utt_completeted_cb = NULL;
1755         client->utt_completed_user_data = NULL;
1756
1757         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1758         return 0;
1759 }
1760
1761 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1762 {
1763         if (0 != __tts_get_feature_enabled()) {
1764                 return TTS_ERROR_NOT_SUPPORTED;
1765         }
1766
1767         if (NULL == tts || NULL == callback) {
1768                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1769                 return TTS_ERROR_INVALID_PARAMETER;
1770         }
1771
1772         tts_client_s* client = tts_client_get(tts);
1773
1774         if (NULL == client) {
1775                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1776                 return TTS_ERROR_INVALID_PARAMETER;
1777         }
1778
1779         if (TTS_STATE_CREATED != client->current_state) {
1780                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1781                 return TTS_ERROR_INVALID_STATE;
1782         }
1783
1784         client->error_cb = callback;
1785         client->error_user_data = user_data;
1786
1787         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1788
1789         return 0;
1790 }
1791
1792 int tts_unset_error_cb(tts_h tts)
1793 {
1794         if (0 != __tts_get_feature_enabled()) {
1795                 return TTS_ERROR_NOT_SUPPORTED;
1796         }
1797
1798         if (NULL == tts) {
1799                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1800                 return TTS_ERROR_INVALID_PARAMETER;
1801         }
1802
1803         tts_client_s* client = tts_client_get(tts);
1804
1805         if (NULL == client) {
1806                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1807                 return TTS_ERROR_INVALID_PARAMETER;
1808         }
1809
1810         if (TTS_STATE_CREATED != client->current_state) {
1811                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1812                 return TTS_ERROR_INVALID_STATE;
1813         }
1814
1815         client->error_cb = NULL;
1816         client->error_user_data = NULL;
1817
1818         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1819
1820         return 0;
1821 }
1822
1823 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1824 {
1825         if (0 != __tts_get_feature_enabled()) {
1826                 return TTS_ERROR_NOT_SUPPORTED;
1827         }
1828
1829         if (NULL == tts || NULL == callback) {
1830                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
1831                 return TTS_ERROR_INVALID_PARAMETER;
1832         }
1833
1834         tts_client_s* client = tts_client_get(tts);
1835
1836         if (NULL == client) {
1837                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
1838                 return TTS_ERROR_INVALID_PARAMETER;
1839         }
1840
1841         if (TTS_STATE_CREATED != client->current_state) {
1842                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
1843                 return TTS_ERROR_INVALID_STATE;
1844         }
1845
1846         client->default_voice_changed_cb = callback;
1847         client->default_voice_changed_user_data = user_data;
1848
1849         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
1850
1851         return 0;
1852 }
1853
1854 int tts_unset_default_voice_changed_cb(tts_h tts)
1855 {
1856         if (0 != __tts_get_feature_enabled()) {
1857                 return TTS_ERROR_NOT_SUPPORTED;
1858         }
1859
1860         if (NULL == tts) {
1861                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
1862                 return TTS_ERROR_INVALID_PARAMETER;
1863         }
1864
1865         tts_client_s* client = tts_client_get(tts);
1866
1867         if (NULL == client) {
1868                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
1869                 return TTS_ERROR_INVALID_PARAMETER;
1870         }
1871
1872         if (TTS_STATE_CREATED != client->current_state) {
1873                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
1874                 return TTS_ERROR_INVALID_STATE;
1875         }
1876
1877         client->default_voice_changed_cb = NULL;
1878         client->default_voice_changed_user_data = NULL;
1879
1880         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
1881
1882         return 0;
1883 }