client/tts.c

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