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         if (NULL != client->credential) {
 430                 free(client->credential);
 431                 client->credential = NULL;
 432         }
 433         client->credential = strdup(credential);
 434
 435         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 436         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 437
 438         return TTS_ERROR_NONE;
 439 }
 440
 441 static Eina_Bool __tts_connect_daemon(void *data)
 442 {
 443         tts_h tts = (tts_h)data;
 444         tts_client_s* client = tts_client_get(tts);
 445
 446         /* check handle */
 447         if (NULL == client) {
 448                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 449                 return EINA_FALSE;
 450         }
 451
 452         /* Send hello */
 453         if (0 != tts_dbus_request_hello(client->uid)) {
 454                 return EINA_TRUE;
 455         }
 456
 457         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
 458
 459         /* do request initialize */
 460         int ret = -1;
 461         bool credential_needed = false;
 462
 463         ret = tts_dbus_request_initialize(client->uid, &credential_needed);
 464
 465         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 466                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 467
 468                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 469                 client->utt_id = -1;
 470
 471                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 472                 client->conn_timer = NULL;
 473                 return EINA_FALSE;
 474
 475         } else if (TTS_ERROR_NONE != ret) {
 476                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 477                 return EINA_TRUE;
 478
 479         } else {
 480                 /* success to connect tts-daemon */
 481                 client->credential_needed = credential_needed;
 482                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 483         }
 484
 485         client->conn_timer = NULL;
 486
 487         client = tts_client_get(tts);
 488         /* check handle */
 489         if (NULL == client) {
 490                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 491                 return EINA_FALSE;
 492         }
 493
 494         client->before_state = client->current_state;
 495         client->current_state = TTS_STATE_READY;
 496
 497         if (NULL != client->state_changed_cb) {
 498                 tts_client_use_callback(client);
 499                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 500                 tts_client_not_use_callback(client);
 501         } else {
 502                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 503         }
 504
 505         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 506         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 507
 508         return EINA_FALSE;
 509 }
 510
 511 int tts_prepare(tts_h tts)
 512 {
 513         if (0 != __tts_get_feature_enabled()) {
 514                 return TTS_ERROR_NOT_SUPPORTED;
 515         }
 516
 517         SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
 518
 519         tts_client_s* client = tts_client_get(tts);
 520
 521         /* check handle */
 522         if (NULL == client) {
 523                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 524                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 525                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 526                 return TTS_ERROR_INVALID_PARAMETER;
 527         }
 528
 529         /* check state */
 530         if (client->current_state != TTS_STATE_CREATED) {
 531                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 532                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 533                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 534                 return TTS_ERROR_INVALID_STATE;
 535         }
 536
 537         client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 538
 539         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 540         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 541
 542         return TTS_ERROR_NONE;
 543 }
 544
 545 int tts_unprepare(tts_h tts)
 546 {
 547         if (0 != __tts_get_feature_enabled()) {
 548                 return TTS_ERROR_NOT_SUPPORTED;
 549         }
 550
 551         SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
 552
 553         tts_client_s* client = tts_client_get(tts);
 554
 555         /* check handle */
 556         if (NULL == client) {
 557                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 558                 return TTS_ERROR_INVALID_PARAMETER;
 559         }
 560
 561         /* check state */
 562         if (client->current_state != TTS_STATE_READY) {
 563                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 564                 return TTS_ERROR_INVALID_STATE;
 565         }
 566
 567         int ret = -1;
 568         int count = 0;
 569         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 570                 while (0 != ret) {
 571                         ret = tts_dbus_request_finalize(client->uid);
 572                         if (0 != ret) {
 573                                 if (TTS_ERROR_TIMED_OUT != ret) {
 574                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 575                                         break;
 576                                 } else {
 577                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 578                                         usleep(10000);
 579                                         count++;
 580                                         if (TTS_RETRY_COUNT == count) {
 581                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 582                                                 break;
 583                                         }
 584                                 }
 585                         }
 586                 }
 587         } else {
 588                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 589         }
 590
 591         client->before_state = client->current_state;
 592         client->current_state = TTS_STATE_CREATED;
 593
 594         if (NULL != client->state_changed_cb) {
 595                 tts_client_use_callback(client);
 596                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 597                 tts_client_not_use_callback(client);
 598                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 599         }
 600
 601         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 602         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 603
 604         return TTS_ERROR_NONE;
 605 }
 606
 607 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 608 {
 609         tts_h tts = (tts_h)user_data;
 610
 611         tts_client_s* client = tts_client_get(tts);
 612         if (NULL == client) {
 613                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 614                 return false;
 615         }
 616
 617         /* call callback function */
 618         if (NULL != client->supported_voice_cb) {
 619                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 620         } else {
 621                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 622         }
 623
 624         return false;
 625 }
 626
 627 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 628 {
 629         if (0 != __tts_get_feature_enabled()) {
 630                 return TTS_ERROR_NOT_SUPPORTED;
 631         }
 632
 633         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 634
 635         if (NULL == tts || NULL == callback) {
 636                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 637                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 638                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 639                 return TTS_ERROR_INVALID_PARAMETER;
 640         }
 641
 642         tts_client_s* client = tts_client_get(tts);
 643
 644         /* check handle */
 645         if (NULL == client) {
 646                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 647                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 648                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 649                 return TTS_ERROR_INVALID_PARAMETER;
 650         }
 651
 652         int ret = 0;
 653         char* current_engine = NULL;
 654         ret = tts_config_mgr_get_engine(&current_engine);
 655         if (0 != ret) {
 656                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 657                 return __tts_convert_config_error_code(ret);
 658         }
 659
 660         client->supported_voice_cb = callback;
 661         client->supported_voice_user_data = user_data;
 662
 663         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 664
 665         if (NULL != current_engine)
 666                 free(current_engine);
 667
 668         client->supported_voice_cb = NULL;
 669         client->supported_voice_user_data = NULL;
 670
 671         if (0 != ret) {
 672                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 673                 ret = TTS_ERROR_OPERATION_FAILED;
 674         }
 675
 676         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 677         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 678
 679         return ret;
 680 }
 681
 682 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 683 {
 684         if (0 != __tts_get_feature_enabled()) {
 685                 return TTS_ERROR_NOT_SUPPORTED;
 686         }
 687
 688         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 689
 690         if (NULL == tts) {
 691                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 692                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 693                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 694                 return TTS_ERROR_INVALID_PARAMETER;
 695
 696         }
 697         tts_client_s* client = tts_client_get(tts);
 698
 699         if (NULL == client) {
 700                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 701                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 702                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 703                 return TTS_ERROR_INVALID_PARAMETER;
 704         }
 705
 706         /* Request call remote method */
 707         int ret = 0;
 708         ret = tts_config_mgr_get_voice(lang, vctype);
 709         if (0 != ret) {
 710                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 711                 return __tts_convert_config_error_code(ret);
 712         } else {
 713                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 714         }
 715
 716         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 717         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 718
 719         return ret;
 720 }
 721
 722 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 723 {
 724         if (0 != __tts_get_feature_enabled()) {
 725                 return TTS_ERROR_NOT_SUPPORTED;
 726         }
 727
 728         if (NULL == tts || NULL == size) {
 729                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 730                 return TTS_ERROR_INVALID_PARAMETER;
 731         }
 732
 733         tts_client_s* client = tts_client_get(tts);
 734
 735         if (NULL == client) {
 736                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 737                 return TTS_ERROR_INVALID_PARAMETER;
 738         }
 739
 740         if (TTS_STATE_READY != client->current_state) {
 741                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 742                 return TTS_ERROR_INVALID_STATE;
 743         }
 744
 745         *size = TTS_MAX_TEXT_SIZE;
 746
 747         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 748         return TTS_ERROR_NONE;
 749 }
 750
 751 int tts_get_state(tts_h tts, tts_state_e* state)
 752 {
 753         if (0 != __tts_get_feature_enabled()) {
 754                 return TTS_ERROR_NOT_SUPPORTED;
 755         }
 756
 757         if (NULL == tts || NULL == state) {
 758                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 759                 return TTS_ERROR_INVALID_PARAMETER;
 760         }
 761
 762         tts_client_s* client = tts_client_get(tts);
 763
 764         if (NULL == client) {
 765                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 766                 return TTS_ERROR_INVALID_PARAMETER;
 767         }
 768
 769         *state = client->current_state;
 770
 771         switch (*state) {
 772         case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 773         case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 774         case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 775         case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 776         default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 777         }
 778
 779         return TTS_ERROR_NONE;
 780 }
 781
 782 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 783 {
 784         if (0 != __tts_get_feature_enabled()) {
 785                 return TTS_ERROR_NOT_SUPPORTED;
 786         }
 787
 788         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 789                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 790                 return TTS_ERROR_INVALID_PARAMETER;
 791         }
 792
 793         tts_client_s* client = tts_client_get(tts);
 794
 795         if (NULL == client) {
 796                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 797                 return TTS_ERROR_INVALID_PARAMETER;
 798         }
 799
 800         *min = TTS_SPEED_MIN;
 801         *normal = TTS_SPEED_NORMAL;
 802         *max = TTS_SPEED_MAX;
 803
 804         return TTS_ERROR_NONE;
 805 }
 806
 807 int tts_get_error_message(tts_h tts, char** err_msg)
 808 {
 809         if (0 != __tts_get_feature_enabled()) {
 810                 return TTS_ERROR_NOT_SUPPORTED;
 811         }
 812
 813         if (NULL == tts || NULL == err_msg) {
 814                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 815                 return TTS_ERROR_INVALID_PARAMETER;
 816         }
 817
 818         tts_client_s* client = tts_client_get(tts);
 819
 820         if (NULL == client) {
 821                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 822                 return TTS_ERROR_INVALID_PARAMETER;
 823         }
 824
 825         if (NULL != client->err_msg) {
 826                 *err_msg = strdup(client->err_msg);
 827                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
 828         } else {
 829                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
 830         }
 831
 832         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 833         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 834
 835         return TTS_ERROR_NONE;
 836 }
 837
 838 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 839 {
 840         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
 841
 842         if (0 != __tts_get_feature_enabled()) {
 843                 return TTS_ERROR_NOT_SUPPORTED;
 844         }
 845
 846         if (speed < 0) {
 847                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
 848                 return TTS_ERROR_INVALID_PARAMETER;
 849         }
 850
 851         if (voice_type < 0) {
 852                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
 853                 return TTS_ERROR_INVALID_PARAMETER;
 854         }
 855
 856         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 857
 858         if (NULL == tts || NULL == utt_id) {
 859                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 860                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 861                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 862                 return TTS_ERROR_INVALID_PARAMETER;
 863         }
 864
 865         tts_client_s* client = tts_client_get(tts);
 866
 867         if (NULL == client) {
 868                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 869                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 870                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 871                 return TTS_ERROR_INVALID_PARAMETER;
 872         }
 873
 874         if (TTS_STATE_CREATED == client->current_state) {
 875                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 876                 return TTS_ERROR_INVALID_STATE;
 877         }
 878
 879         if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
 880                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 881                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 882                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 883                 return TTS_ERROR_INVALID_PARAMETER;
 884         }
 885
 886         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
 887                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
 888                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 889                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 890                 return TTS_ERROR_INVALID_PARAMETER;
 891         }
 892
 893         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 894                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 895                 return TTS_ERROR_INVALID_STATE;
 896         }
 897
 898         if (true == client->credential_needed && NULL == client->credential) {
 899                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
 900                 return TTS_ERROR_PERMISSION_DENIED;
 901         }
 902
 903         /* check valid utf8 */
 904         iconv_t *ict;
 905         ict = iconv_open("utf-8", "");
 906         if ((iconv_t)-1 == ict) {
 907                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
 908                 return TTS_ERROR_OPERATION_FAILED;
 909         }
 910
 911         size_t len = strlen(text);
 912         char *in_tmp = NULL;
 913         char in_buf[TTS_MAX_TEXT_SIZE];
 914         char *out_tmp = NULL;
 915         char out_buf[TTS_MAX_TEXT_SIZE];
 916         size_t len_tmp = sizeof(out_buf);
 917
 918         memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
 919         snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
 920         in_tmp = in_buf;
 921
 922         memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
 923         out_tmp = out_buf;
 924
 925         size_t st;
 926         st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
 927         if ((size_t)-1 == st) {
 928                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
 929                 iconv_close(ict);
 930                 return TTS_ERROR_INVALID_PARAMETER;
 931         }
 932         iconv_close(ict);
 933         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
 934
 935         /* change default language value */
 936         char* temp = NULL;
 937
 938         if (NULL == language)
 939                 temp = strdup("default");
 940         else
 941                 temp = strdup(language);
 942
 943         client->current_utt_id++;
 944         if (client->current_utt_id == 10000) {
 945                 client->current_utt_id = 1;
 946         }
 947
 948         /* do request */
 949         int ret = -1;
 950         int count = 0;
 951         while (0 != ret) {
 952                 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id, client->credential);
 953                 if (0 != ret) {
 954                         if (TTS_ERROR_TIMED_OUT != ret) {
 955                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 956                                 break;
 957                         } else {
 958                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
 959                                 usleep(10000);
 960                                 count++;
 961                                 if (TTS_RETRY_MIN_COUNT == count) {
 962                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 963                                         break;
 964                                 }
 965                         }
 966                 } else {
 967                         *utt_id = client->current_utt_id;
 968                 }
 969         }
 970
 971         if (NULL != temp)       free(temp);
 972
 973         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 974         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 975
 976         return ret;
 977 }
 978
 979 static void __tts_play_async(void *data)
 980 {
 981         tts_h tts = (tts_h)data;
 982         tts_client_s* client = tts_client_get(tts);
 983
 984         /* check handle */
 985         if (NULL == client) {
 986                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 987                 return;
 988         }
 989
 990         int ret = -1;
 991         int count = 0;
 992         while (0 != ret) {
 993                 ret = tts_dbus_request_play(client->uid, client->credential);
 994                 if (0 != ret) {
 995                         if (TTS_ERROR_TIMED_OUT != ret) {
 996                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 997                                 break;
 998                         } else {
 999                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1000                                 usleep(10000);
1001                                 count++;
1002                                 if (TTS_RETRY_COUNT == count) {
1003                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1004                                         break;
1005                                 }
1006                         }
1007                 }
1008         }
1009
1010         if (0 != ret) {
1011                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1012
1013                 client->reason = ret;
1014                 client->utt_id = -1;
1015
1016                 ecore_timer_add(0, __tts_notify_error, client->tts);
1017                 return;
1018         }
1019
1020         client->before_state = client->current_state;
1021         client->current_state = TTS_STATE_PLAYING;
1022
1023         if (NULL != client->state_changed_cb) {
1024                 tts_client_use_callback(client);
1025                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1026                 tts_client_not_use_callback(client);
1027                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1028         }
1029
1030         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1031         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1032
1033         return;
1034 }
1035
1036 int tts_play_async(tts_h tts)
1037 {
1038         if (0 != __tts_get_feature_enabled()) {
1039                 return TTS_ERROR_NOT_SUPPORTED;
1040         }
1041
1042         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1043
1044         if (NULL == tts) {
1045                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1046                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1047                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1048                 return TTS_ERROR_INVALID_PARAMETER;
1049         }
1050
1051         tts_client_s* client = tts_client_get(tts);
1052
1053         if (NULL == client) {
1054                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1055                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1056                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1057                 return TTS_ERROR_INVALID_PARAMETER;
1058         }
1059
1060         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1061                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1062                 return TTS_ERROR_INVALID_STATE;
1063         }
1064
1065         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1066                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1067                 return TTS_ERROR_INVALID_STATE;
1068         }
1069
1070         if (true == client->credential_needed && NULL == client->credential) {
1071                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1072                 return TTS_ERROR_PERMISSION_DENIED;
1073         }
1074
1075         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1076
1077         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1078         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1079
1080         return TTS_ERROR_NONE;
1081 }
1082
1083 int tts_play(tts_h tts)
1084 {
1085         if (0 != __tts_get_feature_enabled()) {
1086                 return TTS_ERROR_NOT_SUPPORTED;
1087         }
1088
1089         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1090
1091         if (NULL == tts) {
1092                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1093                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1094                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1095                 return TTS_ERROR_INVALID_PARAMETER;
1096         }
1097
1098         tts_client_s* client = tts_client_get(tts);
1099
1100         if (NULL == client) {
1101                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1102                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1103                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1104                 return TTS_ERROR_INVALID_PARAMETER;
1105         }
1106
1107         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1108                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1109                 return TTS_ERROR_INVALID_STATE;
1110         }
1111
1112         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1113                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1114                 return TTS_ERROR_INVALID_STATE;
1115         }
1116
1117         if (true == client->credential_needed && NULL == client->credential) {
1118                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1119                 return TTS_ERROR_PERMISSION_DENIED;
1120         }
1121
1122         int ret = -1;
1123         int count = 0;
1124         while (0 != ret) {
1125                 ret = tts_dbus_request_play(client->uid, client->credential);
1126                 if (0 != ret) {
1127                         if (TTS_ERROR_TIMED_OUT != ret) {
1128                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1129                                 return ret;
1130                         } else {
1131                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1132                                 usleep(10000);
1133                                 count++;
1134                                 if (TTS_RETRY_COUNT == count) {
1135                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1136                                         return ret;
1137                                 }
1138                         }
1139                 }
1140         }
1141
1142         client->before_state = client->current_state;
1143         client->current_state = TTS_STATE_PLAYING;
1144
1145         if (NULL != client->state_changed_cb) {
1146                 tts_client_use_callback(client);
1147                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1148                 tts_client_not_use_callback(client);
1149                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1150         }
1151
1152         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1153         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1154
1155         return TTS_ERROR_NONE;
1156 }
1157
1158 static void __tts_stop_async(void *data)
1159 {
1160         tts_h tts = (tts_h)data;
1161         tts_client_s* client = tts_client_get(tts);
1162
1163         /* check handle */
1164         if (NULL == client) {
1165                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1166                 return;
1167         }
1168
1169         int ret = -1;
1170         int count = 0;
1171         while (0 != ret) {
1172                 ret = tts_dbus_request_stop(client->uid);
1173                 if (0 != ret) {
1174                         if (TTS_ERROR_TIMED_OUT != ret) {
1175                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1176                                 break;
1177                         } else {
1178                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1179                                 usleep(10000);
1180                                 count++;
1181                                 if (TTS_RETRY_COUNT == count) {
1182                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1183                                         break;
1184                                 }
1185                         }
1186                 }
1187         }
1188
1189         if (0 != ret) {
1190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1191
1192                 client->reason = ret;
1193                 client->utt_id = -1;
1194
1195                 ecore_timer_add(0, __tts_notify_error, client->tts);
1196                 return;
1197         }
1198
1199         client->before_state = client->current_state;
1200         client->current_state = TTS_STATE_READY;
1201
1202         if (NULL != client->state_changed_cb) {
1203                 tts_client_use_callback(client);
1204                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1205                 tts_client_not_use_callback(client);
1206                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1207         }
1208
1209         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1210         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1211
1212         return;
1213 }
1214
1215 int tts_stop_aync(tts_h tts)
1216 {
1217         if (0 != __tts_get_feature_enabled()) {
1218                 return TTS_ERROR_NOT_SUPPORTED;
1219         }
1220
1221         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1222
1223         if (NULL == tts) {
1224                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1225                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1226                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1227                 return TTS_ERROR_INVALID_PARAMETER;
1228         }
1229
1230         tts_client_s* client = tts_client_get(tts);
1231
1232         if (NULL == client) {
1233                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1234                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1235                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1236                 return TTS_ERROR_INVALID_PARAMETER;
1237         }
1238
1239         if (TTS_STATE_CREATED == client->current_state) {
1240                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1241                 return TTS_ERROR_INVALID_STATE;
1242         }
1243
1244         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1245                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1246                 return TTS_ERROR_INVALID_STATE;
1247         }
1248
1249         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1250
1251         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1252         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1253
1254         return TTS_ERROR_NONE;
1255 }
1256
1257 int tts_stop(tts_h tts)
1258 {
1259         if (0 != __tts_get_feature_enabled()) {
1260                 return TTS_ERROR_NOT_SUPPORTED;
1261         }
1262
1263         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1264
1265         if (NULL == tts) {
1266                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1267                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1268                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1269                 return TTS_ERROR_INVALID_PARAMETER;
1270         }
1271
1272         tts_client_s* client = tts_client_get(tts);
1273
1274         if (NULL == client) {
1275                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1276                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1277                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1278                 return TTS_ERROR_INVALID_PARAMETER;
1279         }
1280
1281         if (TTS_STATE_CREATED == client->current_state) {
1282                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1283                 return TTS_ERROR_INVALID_STATE;
1284         }
1285
1286         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1287                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1288                 return TTS_ERROR_INVALID_STATE;
1289         }
1290
1291         int ret = -1;
1292         int count = 0;
1293         while (0 != ret) {
1294                 ret = tts_dbus_request_stop(client->uid);
1295                 if (0 != ret) {
1296                         if (TTS_ERROR_TIMED_OUT != ret) {
1297                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1298                                 return ret;
1299                         } else {
1300                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1301                                 usleep(10000);
1302                                 count++;
1303                                 if (TTS_RETRY_COUNT == count) {
1304                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1305                                         return ret;
1306                                 }
1307                         }
1308                 }
1309         }
1310
1311         client->before_state = client->current_state;
1312         client->current_state = TTS_STATE_READY;
1313
1314         if (NULL != client->state_changed_cb) {
1315                 tts_client_use_callback(client);
1316                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1317                 tts_client_not_use_callback(client);
1318                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1319         }
1320
1321         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1322         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1323
1324         return TTS_ERROR_NONE;
1325 }
1326
1327 static void __tts_pause_async(void *data)
1328 {
1329         tts_h tts = (tts_h)data;
1330         tts_client_s* client = tts_client_get(tts);
1331
1332         /* check handle */
1333         if (NULL == client) {
1334                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1335                 return;
1336         }
1337
1338         int ret = -1;
1339         int count = 0;
1340         while (0 != ret) {
1341                 ret = tts_dbus_request_pause(client->uid);
1342                 if (0 != ret) {
1343                         if (TTS_ERROR_TIMED_OUT != ret) {
1344                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1345                                 break;
1346                         } else {
1347                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1348                                 usleep(10000);
1349                                 count++;
1350                                 if (TTS_RETRY_COUNT == count) {
1351                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1352                                         break;
1353                                 }
1354                         }
1355                 }
1356         }
1357
1358         if (0 != ret) {
1359                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1360
1361                 client->reason = ret;
1362                 client->utt_id = -1;
1363
1364                 ecore_timer_add(0, __tts_notify_error, client->tts);
1365                 return;
1366         }
1367
1368         client->before_state = client->current_state;
1369         client->current_state = TTS_STATE_PAUSED;
1370
1371         if (NULL != client->state_changed_cb) {
1372                 tts_client_use_callback(client);
1373                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1374                 tts_client_not_use_callback(client);
1375                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1376         }
1377
1378         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1379         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1380
1381         return;
1382 }
1383
1384 int tts_pause_async(tts_h tts)
1385 {
1386         if (0 != __tts_get_feature_enabled()) {
1387                 return TTS_ERROR_NOT_SUPPORTED;
1388         }
1389
1390         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1391
1392         if (NULL == tts) {
1393                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1394                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1395                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1396                 return TTS_ERROR_INVALID_PARAMETER;
1397         }
1398
1399         tts_client_s* client = tts_client_get(tts);
1400
1401         if (NULL == client) {
1402                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1403                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1404                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1405                 return TTS_ERROR_INVALID_PARAMETER;
1406         }
1407
1408         if (TTS_STATE_PLAYING != client->current_state) {
1409                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1410                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1411                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1412                 return TTS_ERROR_INVALID_STATE;
1413         }
1414
1415         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1416                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1417                 return TTS_ERROR_INVALID_STATE;
1418         }
1419
1420         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1421
1422         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1423         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1424
1425         return TTS_ERROR_NONE;
1426 }
1427
1428 int tts_pause(tts_h tts)
1429 {
1430         if (0 != __tts_get_feature_enabled()) {
1431                 return TTS_ERROR_NOT_SUPPORTED;
1432         }
1433
1434         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1435
1436         if (NULL == tts) {
1437                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1438                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1439                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1440                 return TTS_ERROR_INVALID_PARAMETER;
1441         }
1442
1443         tts_client_s* client = tts_client_get(tts);
1444
1445         if (NULL == client) {
1446                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1447                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1448                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1449                 return TTS_ERROR_INVALID_PARAMETER;
1450         }
1451
1452         if (TTS_STATE_PLAYING != client->current_state) {
1453                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1454                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1455                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1456                 return TTS_ERROR_INVALID_STATE;
1457         }
1458
1459         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1460                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1461                 return TTS_ERROR_INVALID_STATE;
1462         }
1463
1464         int ret = -1;
1465         int count = 0;
1466         while (0 != ret) {
1467                 ret = tts_dbus_request_pause(client->uid);
1468                 if (0 != ret) {
1469                         if (TTS_ERROR_TIMED_OUT != ret) {
1470                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1471                                 return ret;
1472                         } else {
1473                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1474                                 usleep(10000);
1475                                 count++;
1476                                 if (TTS_RETRY_COUNT == count) {
1477                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1478                                         return ret;
1479                                 }
1480                         }
1481                 }
1482         }
1483
1484         client->before_state = client->current_state;
1485         client->current_state = TTS_STATE_PAUSED;
1486
1487         if (NULL != client->state_changed_cb) {
1488                 tts_client_use_callback(client);
1489                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1490                 tts_client_not_use_callback(client);
1491                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1492         }
1493
1494         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1495         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1496
1497         return TTS_ERROR_NONE;
1498 }
1499
1500 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1501 {
1502         if (0 != __tts_get_feature_enabled()) {
1503                 return TTS_ERROR_NOT_SUPPORTED;
1504         }
1505
1506         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set private data");
1507
1508         if (NULL == tts) {
1509                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1510                 return TTS_ERROR_INVALID_PARAMETER;
1511         }
1512
1513         if (NULL == key || NULL == data) {
1514                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1515                 return TTS_ERROR_INVALID_PARAMETER;
1516         }
1517
1518         tts_client_s* client = tts_client_get(tts);
1519
1520         if (NULL == client) {
1521                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1522                 return TTS_ERROR_INVALID_PARAMETER;
1523         }
1524
1525         if (TTS_STATE_READY != client->current_state) {
1526                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1527                 return TTS_ERROR_INVALID_STATE;
1528         }
1529
1530         int ret = -1;
1531         int count = 0;
1532         while (0 != ret) {
1533                 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1534                 if (0 != ret) {
1535                         if (TTS_ERROR_TIMED_OUT != ret) {
1536                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1537                                 return ret;
1538                         } else {
1539                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1540                                 usleep(10000);
1541                                 count++;
1542                                 if (TTS_RETRY_COUNT == count) {
1543                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1544                                         return ret;
1545                                 }
1546                         }
1547                 }
1548         }
1549
1550         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1551         SLOG(LOG_DEBUG, TAG_TTSC, "");
1552
1553         return 0;
1554 }
1555
1556 int tts_get_private_data(tts_h tts, const char* key, char** data)
1557 {
1558         if (0 != __tts_get_feature_enabled()) {
1559                 return TTS_ERROR_NOT_SUPPORTED;
1560         }
1561
1562         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get private data");
1563
1564         if (NULL == tts) {
1565                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1566                 return TTS_ERROR_INVALID_PARAMETER;
1567         }
1568
1569         if (NULL == key || NULL == data) {
1570                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1571                 return TTS_ERROR_INVALID_PARAMETER;
1572         }
1573
1574         tts_client_s* client = tts_client_get(tts);
1575
1576         if (NULL == client) {
1577                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1578                 return TTS_ERROR_INVALID_PARAMETER;
1579         }
1580
1581         if (TTS_STATE_READY != client->current_state) {
1582                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1583                 return TTS_ERROR_INVALID_STATE;
1584         }
1585
1586         int ret = -1;
1587         int count = 0;
1588         while (0 != ret) {
1589                 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1590                 if (0 != ret) {
1591                         if (TTS_ERROR_TIMED_OUT != ret) {
1592                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1593                                 return ret;
1594                         } else {
1595                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1596                                 usleep(10000);
1597                                 count++;
1598                                 if (TTS_RETRY_COUNT == count) {
1599                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1600                                         return ret;
1601                                 }
1602                         }
1603                 }
1604         }
1605
1606         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1607                 free(*data);
1608                 *data = NULL;
1609         }
1610
1611         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1612         SLOG(LOG_DEBUG, TAG_TTSC, "");
1613
1614         return 0;
1615 }
1616
1617 static Eina_Bool __tts_notify_error(void *data)
1618 {
1619         tts_h tts = (tts_h)data;
1620
1621         tts_client_s* client = tts_client_get(tts);
1622
1623         /* check handle */
1624         if (NULL == client) {
1625                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1626                 return EINA_FALSE;
1627         }
1628
1629         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1630
1631         if (NULL != client->error_cb) {
1632                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1633                 tts_client_use_callback(client);
1634                 g_err_callback_status = true;
1635                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1636                 g_err_callback_status = false;
1637                 tts_client_not_use_callback(client);
1638         } else {
1639                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1640         }
1641
1642         return EINA_FALSE;
1643 }
1644
1645 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1646 {
1647         tts_client_s* client = tts_client_get_by_uid(uid);
1648
1649         if (NULL == client) {
1650                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1651                 return TTS_ERROR_INVALID_PARAMETER;
1652         }
1653
1654         client->utt_id = utt_id;
1655         client->reason = reason;
1656         if (NULL != client->err_msg) {
1657                 free(client->err_msg);
1658                 client->err_msg = NULL;
1659         }
1660         client->err_msg = strdup(err_msg);
1661
1662         /* call callback function */
1663         if (NULL != client->error_cb) {
1664                 ecore_timer_add(0, __tts_notify_error, client->tts);
1665         } else {
1666                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1667         }
1668
1669         if (TTS_ERROR_SERVICE_RESET == reason) {
1670                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1671
1672                 client->current_state = TTS_STATE_CREATED;
1673                 if (0 != tts_prepare(client->tts)) {
1674                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1675                 }
1676         }
1677
1678         return 0;
1679 }
1680
1681 static Eina_Bool __tts_notify_state_changed(void *data)
1682 {
1683         tts_h tts = (tts_h)data;
1684
1685         tts_client_s* client = tts_client_get(tts);
1686
1687         /* check handle */
1688         if (NULL == client) {
1689                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1690                 return EINA_FALSE;
1691         }
1692
1693         if (NULL != client->state_changed_cb) {
1694                 tts_client_use_callback(client);
1695                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1696                 tts_client_not_use_callback(client);
1697                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1698         } else {
1699                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1700         }
1701
1702         return EINA_FALSE;
1703 }
1704
1705 int __tts_cb_set_state(int uid, int state)
1706 {
1707         tts_client_s* client = tts_client_get_by_uid(uid);
1708         if (NULL == client) {
1709                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1710                 return -1;
1711         }
1712
1713         tts_state_e state_from_daemon = (tts_state_e)state;
1714
1715         if (client->current_state == state_from_daemon) {
1716                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1717                 return 0;
1718         }
1719
1720         if (NULL != client->state_changed_cb) {
1721                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1722         } else {
1723                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1724         }
1725
1726         client->before_state = client->current_state;
1727         client->current_state = state_from_daemon;
1728
1729         return 0;
1730 }
1731
1732 int __tts_cb_utt_started(int uid, int utt_id)
1733 {
1734         tts_client_s* client = tts_client_get_by_uid(uid);
1735
1736         if (NULL == client) {
1737                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1738                 return TTS_ERROR_INVALID_PARAMETER;
1739         }
1740
1741         SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1742
1743         client->utt_id = utt_id;
1744
1745         /* call callback function */
1746         if (NULL != client->utt_started_cb) {
1747                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1748                 tts_client_use_callback(client);
1749                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1750                 tts_client_not_use_callback(client);
1751         } else {
1752                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1753         }
1754
1755         return 0;
1756 }
1757
1758 int __tts_cb_utt_completed(int uid, int utt_id)
1759 {
1760         tts_client_s* client = tts_client_get_by_uid(uid);
1761
1762         if (NULL == client) {
1763                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1764                 return TTS_ERROR_INVALID_PARAMETER;
1765         }
1766
1767         SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1768
1769         client->utt_id = utt_id;
1770
1771         /* call callback function */
1772         if (NULL != client->utt_completeted_cb) {
1773                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1774                 tts_client_use_callback(client);
1775                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1776                 tts_client_not_use_callback(client);
1777         } else {
1778                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1779         }
1780
1781         return 0;
1782 }
1783
1784 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1785 {
1786         if (0 != __tts_get_feature_enabled()) {
1787                 return TTS_ERROR_NOT_SUPPORTED;
1788         }
1789
1790         if (NULL == tts || NULL == callback) {
1791                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1792                 return TTS_ERROR_INVALID_PARAMETER;
1793         }
1794
1795         tts_client_s* client = tts_client_get(tts);
1796
1797         if (NULL == client) {
1798                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1799                 return TTS_ERROR_INVALID_PARAMETER;
1800         }
1801
1802         if (TTS_STATE_CREATED != client->current_state) {
1803                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1804                 return TTS_ERROR_INVALID_STATE;
1805         }
1806
1807         client->state_changed_cb = callback;
1808         client->state_changed_user_data = user_data;
1809
1810         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1811
1812         return 0;
1813 }
1814
1815 int tts_unset_state_changed_cb(tts_h tts)
1816 {
1817         if (0 != __tts_get_feature_enabled()) {
1818                 return TTS_ERROR_NOT_SUPPORTED;
1819         }
1820
1821         if (NULL == tts) {
1822                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1823                 return TTS_ERROR_INVALID_PARAMETER;
1824         }
1825
1826         tts_client_s* client = tts_client_get(tts);
1827
1828         if (NULL == client) {
1829                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1830                 return TTS_ERROR_INVALID_PARAMETER;
1831         }
1832
1833         if (TTS_STATE_CREATED != client->current_state) {
1834                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1835                 return TTS_ERROR_INVALID_STATE;
1836         }
1837
1838         client->state_changed_cb = NULL;
1839         client->state_changed_user_data = NULL;
1840
1841         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1842
1843         return 0;
1844 }
1845
1846 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1847 {
1848         if (0 != __tts_get_feature_enabled()) {
1849                 return TTS_ERROR_NOT_SUPPORTED;
1850         }
1851
1852         if (NULL == tts || NULL == callback) {
1853                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1854                 return TTS_ERROR_INVALID_PARAMETER;
1855         }
1856
1857         tts_client_s* client = tts_client_get(tts);
1858
1859         if (NULL == client) {
1860                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1861                 return TTS_ERROR_INVALID_PARAMETER;
1862         }
1863
1864         if (TTS_STATE_CREATED != client->current_state) {
1865                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1866                 return TTS_ERROR_INVALID_STATE;
1867         }
1868
1869         client->utt_started_cb = callback;
1870         client->utt_started_user_data = user_data;
1871
1872         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1873
1874         return 0;
1875 }
1876
1877 int tts_unset_utterance_started_cb(tts_h tts)
1878 {
1879         if (0 != __tts_get_feature_enabled()) {
1880                 return TTS_ERROR_NOT_SUPPORTED;
1881         }
1882
1883         if (NULL == tts) {
1884                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1885                 return TTS_ERROR_INVALID_PARAMETER;
1886         }
1887
1888         tts_client_s* client = tts_client_get(tts);
1889
1890         if (NULL == client) {
1891                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1892                 return TTS_ERROR_INVALID_PARAMETER;
1893         }
1894
1895         if (TTS_STATE_CREATED != client->current_state) {
1896                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1897                 return TTS_ERROR_INVALID_STATE;
1898         }
1899
1900         client->utt_started_cb = NULL;
1901         client->utt_started_user_data = NULL;
1902
1903         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1904
1905         return 0;
1906 }
1907
1908 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1909 {
1910         if (0 != __tts_get_feature_enabled()) {
1911                 return TTS_ERROR_NOT_SUPPORTED;
1912         }
1913
1914         if (NULL == tts || NULL == callback) {
1915                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1916                 return TTS_ERROR_INVALID_PARAMETER;
1917         }
1918
1919         tts_client_s* client = tts_client_get(tts);
1920
1921         if (NULL == client) {
1922                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1923                 return TTS_ERROR_INVALID_PARAMETER;
1924         }
1925
1926         if (TTS_STATE_CREATED != client->current_state) {
1927                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1928                 return TTS_ERROR_INVALID_STATE;
1929         }
1930
1931         client->utt_completeted_cb = callback;
1932         client->utt_completed_user_data = user_data;
1933
1934         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1935
1936         return 0;
1937 }
1938
1939 int tts_unset_utterance_completed_cb(tts_h tts)
1940 {
1941         if (0 != __tts_get_feature_enabled()) {
1942                 return TTS_ERROR_NOT_SUPPORTED;
1943         }
1944
1945         if (NULL == tts) {
1946                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1947                 return TTS_ERROR_INVALID_PARAMETER;
1948         }
1949
1950         tts_client_s* client = tts_client_get(tts);
1951
1952         if (NULL == client) {
1953                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1954                 return TTS_ERROR_INVALID_PARAMETER;
1955         }
1956
1957         if (TTS_STATE_CREATED != client->current_state) {
1958                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1959                 return TTS_ERROR_INVALID_STATE;
1960         }
1961
1962         client->utt_completeted_cb = NULL;
1963         client->utt_completed_user_data = NULL;
1964
1965         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1966         return 0;
1967 }
1968
1969 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1970 {
1971         if (0 != __tts_get_feature_enabled()) {
1972                 return TTS_ERROR_NOT_SUPPORTED;
1973         }
1974
1975         if (NULL == tts || NULL == callback) {
1976                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1977                 return TTS_ERROR_INVALID_PARAMETER;
1978         }
1979
1980         tts_client_s* client = tts_client_get(tts);
1981
1982         if (NULL == client) {
1983                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1984                 return TTS_ERROR_INVALID_PARAMETER;
1985         }
1986
1987         if (TTS_STATE_CREATED != client->current_state) {
1988                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1989                 return TTS_ERROR_INVALID_STATE;
1990         }
1991
1992         client->error_cb = callback;
1993         client->error_user_data = user_data;
1994
1995         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1996
1997         return 0;
1998 }
1999
2000 int tts_unset_error_cb(tts_h tts)
2001 {
2002         if (0 != __tts_get_feature_enabled()) {
2003                 return TTS_ERROR_NOT_SUPPORTED;
2004         }
2005
2006         if (NULL == tts) {
2007                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2008                 return TTS_ERROR_INVALID_PARAMETER;
2009         }
2010
2011         tts_client_s* client = tts_client_get(tts);
2012
2013         if (NULL == client) {
2014                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2015                 return TTS_ERROR_INVALID_PARAMETER;
2016         }
2017
2018         if (TTS_STATE_CREATED != client->current_state) {
2019                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2020                 return TTS_ERROR_INVALID_STATE;
2021         }
2022
2023         client->error_cb = NULL;
2024         client->error_user_data = NULL;
2025
2026         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2027
2028         return 0;
2029 }
2030
2031 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2032 {
2033         if (0 != __tts_get_feature_enabled()) {
2034                 return TTS_ERROR_NOT_SUPPORTED;
2035         }
2036
2037         if (NULL == tts || NULL == callback) {
2038                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2039                 return TTS_ERROR_INVALID_PARAMETER;
2040         }
2041
2042         tts_client_s* client = tts_client_get(tts);
2043
2044         if (NULL == client) {
2045                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2046                 return TTS_ERROR_INVALID_PARAMETER;
2047         }
2048
2049         if (TTS_STATE_CREATED != client->current_state) {
2050                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2051                 return TTS_ERROR_INVALID_STATE;
2052         }
2053
2054         client->default_voice_changed_cb = callback;
2055         client->default_voice_changed_user_data = user_data;
2056
2057         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2058
2059         return 0;
2060 }
2061
2062 int tts_unset_default_voice_changed_cb(tts_h tts)
2063 {
2064         if (0 != __tts_get_feature_enabled()) {
2065                 return TTS_ERROR_NOT_SUPPORTED;
2066         }
2067
2068         if (NULL == tts) {
2069                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2070                 return TTS_ERROR_INVALID_PARAMETER;
2071         }
2072
2073         tts_client_s* client = tts_client_get(tts);
2074
2075         if (NULL == client) {
2076                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2077                 return TTS_ERROR_INVALID_PARAMETER;
2078         }
2079
2080         if (TTS_STATE_CREATED != client->current_state) {
2081                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2082                 return TTS_ERROR_INVALID_STATE;
2083         }
2084
2085         client->default_voice_changed_cb = NULL;
2086         client->default_voice_changed_user_data = NULL;
2087
2088         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2089
2090         return 0;
2091 }
2092
2093 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2094 {
2095         if (0 != __tts_get_feature_enabled()) {
2096                 return TTS_ERROR_NOT_SUPPORTED;
2097         }
2098
2099         if (NULL == tts || NULL == callback) {
2100                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2101                 return TTS_ERROR_INVALID_PARAMETER;
2102         }
2103
2104         tts_client_s* client = tts_client_get(tts);
2105
2106         if (NULL == client) {
2107                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2108                 return TTS_ERROR_INVALID_PARAMETER;
2109         }
2110
2111         if (TTS_STATE_CREATED != client->current_state) {
2112                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2113                 return TTS_ERROR_INVALID_STATE;
2114         }
2115
2116         client->engine_changed_cb = callback;
2117         client->engine_changed_user_data = user_data;
2118
2119         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2120
2121         return 0;
2122 }
2123
2124 int tts_unset_engine_changed_cb(tts_h tts)
2125 {
2126         if (0 != __tts_get_feature_enabled()) {
2127                 return TTS_ERROR_NOT_SUPPORTED;
2128         }
2129
2130         if (NULL == tts) {
2131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2132                 return TTS_ERROR_INVALID_PARAMETER;
2133         }
2134
2135         tts_client_s* client = tts_client_get(tts);
2136
2137         if (NULL == client) {
2138                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2139                 return TTS_ERROR_INVALID_PARAMETER;
2140         }
2141
2142         if (TTS_STATE_CREATED != client->current_state) {
2143                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2144                 return TTS_ERROR_INVALID_STATE;
2145         }
2146
2147         client->engine_changed_cb = NULL;
2148         client->engine_changed_user_data = NULL;
2149
2150         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2151
2152         return 0;
2153 }
2154