client/tts.c

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