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