client/tts.c

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