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