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                         if (NULL != key) {
 532                                 free(key);
 533                                 key = NULL;
 534                         }
 535                         return TTS_ERROR_OUT_OF_MEMORY;
 536                 }
 537         } else {
 538                 key = strdup("DisableServerTTS");
 539         }
 540
 541         if (NULL == key) {
 542                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
 543                 return TTS_ERROR_OUT_OF_MEMORY;
 544         }
 545
 546         int pid = getpid();
 547         char* appid = NULL;
 548         int ret = app_manager_get_app_id(pid, &appid);
 549         if (0 != ret || NULL == appid) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 551                 free(key);
 552                 key = NULL;
 553                 if (NULL != appid) {
 554                         free(appid);
 555                         appid = NULL;
 556                 }
 557                 return TTS_ERROR_OPERATION_FAILED;
 558         }
 559
 560         ret = tts_set_private_data(tts, key, appid);
 561         if (0 != ret) {
 562                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
 563                 free(key);
 564                 key = NULL;
 565                 free(appid);
 566                 appid = NULL;
 567                 return ret;
 568         }
 569
 570         free(appid);
 571         appid = NULL;
 572         free(key);
 573         key = NULL;
 574
 575         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 576
 577         return TTS_ERROR_NONE;
 578 }
 579
 580 static Eina_Bool __tts_connect_daemon(void *data)
 581 {
 582         tts_h tts = (tts_h)data;
 583         tts_client_s* client = tts_client_get(tts);
 584
 585         /* check handle */
 586         if (NULL == client) {
 587                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 588                 return EINA_FALSE;
 589         }
 590
 591         /* Send hello */
 592         if (0 != tts_dbus_request_hello(client->uid)) {
 593                 return EINA_TRUE;
 594         }
 595
 596         SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 597
 598         /* do request initialize */
 599         int ret = -1;
 600         bool credential_needed = false;
 601
 602         ret = tts_dbus_request_initialize(client->uid, &credential_needed);
 603
 604         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 605                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 606
 607                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 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_PERMISSION_DENIED == ret) {
 615                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 616
 617                 client->reason = TTS_ERROR_PERMISSION_DENIED;
 618                 client->utt_id = -1;
 619
 620                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 621                 client->conn_timer = NULL;
 622                 return EINA_FALSE;
 623
 624         } else if (TTS_ERROR_NONE != ret) {
 625                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 626                 return EINA_TRUE;
 627
 628         } else {
 629                 /* success to connect tts-daemon */
 630                 client->credential_needed = credential_needed;
 631                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 632         }
 633
 634         client->conn_timer = NULL;
 635
 636         client = tts_client_get(tts);
 637         /* check handle */
 638         if (NULL == client) {
 639                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 640                 return EINA_FALSE;
 641         }
 642
 643         client->before_state = client->current_state;
 644         client->current_state = TTS_STATE_READY;
 645
 646         if (NULL != client->state_changed_cb) {
 647                 tts_client_use_callback(client);
 648                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 649                 tts_client_not_use_callback(client);
 650         } else {
 651                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 652         }
 653
 654         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 655
 656         return EINA_FALSE;
 657 }
 658
 659 int tts_prepare(tts_h tts)
 660 {
 661         if (0 != __tts_get_feature_enabled()) {
 662                 return TTS_ERROR_NOT_SUPPORTED;
 663         }
 664
 665         SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 666
 667         tts_client_s* client = tts_client_get(tts);
 668
 669         /* check handle */
 670         if (NULL == client) {
 671                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 672                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 673                 return TTS_ERROR_INVALID_PARAMETER;
 674         }
 675
 676         /* check state */
 677         if (client->current_state != TTS_STATE_CREATED) {
 678                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 679                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 680                 return TTS_ERROR_INVALID_STATE;
 681         }
 682
 683         client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 684
 685         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 686
 687         return TTS_ERROR_NONE;
 688 }
 689
 690 int tts_prepare_sync(tts_h tts)
 691 {
 692         if (0 != __tts_get_feature_enabled()) {
 693                 return TTS_ERROR_NOT_SUPPORTED;
 694         }
 695
 696         SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 697
 698         tts_client_s* client = tts_client_get(tts);
 699
 700         /* check handle */
 701         if (NULL == client) {
 702                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 703                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 704                 return TTS_ERROR_INVALID_PARAMETER;
 705         }
 706
 707         /* check state */
 708         if (client->current_state != TTS_STATE_CREATED) {
 709                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 710                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 711                 return TTS_ERROR_INVALID_STATE;
 712         }
 713
 714         int cnt = 0;
 715         while (EINA_TRUE == __tts_connect_daemon(NULL) && TTS_CONNECTION_RETRY_COUNT > cnt) {
 716                 cnt++;
 717         }
 718
 719         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 720
 721         if (TTS_CONNECTION_RETRY_COUNT == cnt) {
 722                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
 723                 return TTS_ERROR_OPERATION_FAILED;
 724         }
 725
 726         return TTS_ERROR_NONE;
 727 }
 728
 729 int tts_unprepare(tts_h tts)
 730 {
 731         if (0 != __tts_get_feature_enabled()) {
 732                 return TTS_ERROR_NOT_SUPPORTED;
 733         }
 734
 735         SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
 736
 737         tts_client_s* client = tts_client_get(tts);
 738
 739         /* check handle */
 740         if (NULL == client) {
 741                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 742                 return TTS_ERROR_INVALID_PARAMETER;
 743         }
 744
 745         /* check state */
 746         if (client->current_state != TTS_STATE_READY) {
 747                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 748                 return TTS_ERROR_INVALID_STATE;
 749         }
 750
 751         int ret = -1;
 752         int count = 0;
 753         int screen_reader = -1;
 754
 755         ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 756         if (0 != ret) {
 757                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get screen reader");
 758         } else {
 759                 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);
 760                 g_screen_reader = (bool)screen_reader;
 761         }
 762
 763         bool is_prepared = false;
 764         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 765                 do {
 766                         ret = tts_dbus_request_finalize(client->uid);
 767                         if (0 != ret) {
 768                                 if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
 769                                         if (0 == tts_prepare_sync(tts)) {
 770                                                 is_prepared = true;
 771                                                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
 772                                         }
 773                                 } else if (TTS_ERROR_TIMED_OUT != ret) {
 774                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 775                                         break;
 776                                 } else {
 777                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 778                                         usleep(10000);
 779                                         count++;
 780                                         if (TTS_RETRY_COUNT == count) {
 781                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 782                                                 break;
 783                                         }
 784                                 }
 785                         }
 786                 } while (0 != ret);
 787         } else {
 788                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 789         }
 790
 791         client->before_state = client->current_state;
 792         client->current_state = TTS_STATE_CREATED;
 793
 794         if (NULL != client->state_changed_cb) {
 795                 tts_client_use_callback(client);
 796                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 797                 tts_client_not_use_callback(client);
 798                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 799         }
 800
 801         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 802
 803         return TTS_ERROR_NONE;
 804 }
 805
 806 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 807 {
 808         tts_h tts = (tts_h)user_data;
 809
 810         tts_client_s* client = tts_client_get(tts);
 811         if (NULL == client) {
 812                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 813                 return false;
 814         }
 815
 816         /* call callback function */
 817         if (NULL != client->supported_voice_cb) {
 818                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 819         } else {
 820                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 821         }
 822
 823         return false;
 824 }
 825
 826 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 827 {
 828         if (0 != __tts_get_feature_enabled()) {
 829                 return TTS_ERROR_NOT_SUPPORTED;
 830         }
 831
 832         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 833
 834         if (NULL == tts || NULL == callback) {
 835                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 836                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 837                 return TTS_ERROR_INVALID_PARAMETER;
 838         }
 839
 840         tts_client_s* client = tts_client_get(tts);
 841
 842         /* check handle */
 843         if (NULL == client) {
 844                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 845                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 846                 return TTS_ERROR_INVALID_PARAMETER;
 847         }
 848
 849         int ret = 0;
 850         char* current_engine = NULL;
 851         ret = tts_config_mgr_get_engine(&current_engine);
 852         if (0 != ret) {
 853                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 854                 return __tts_convert_config_error_code(ret);
 855         }
 856
 857         client->supported_voice_cb = callback;
 858         client->supported_voice_user_data = user_data;
 859
 860         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 861
 862         if (NULL != current_engine) {
 863                 free(current_engine);
 864                 current_engine = NULL;
 865         }
 866
 867         client->supported_voice_cb = NULL;
 868         client->supported_voice_user_data = NULL;
 869
 870         if (0 != ret) {
 871                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 872                 ret = TTS_ERROR_OPERATION_FAILED;
 873         }
 874
 875         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 876
 877         return ret;
 878 }
 879
 880 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 881 {
 882         if (0 != __tts_get_feature_enabled()) {
 883                 return TTS_ERROR_NOT_SUPPORTED;
 884         }
 885
 886         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 887
 888         if (NULL == tts) {
 889                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 890                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 891                 return TTS_ERROR_INVALID_PARAMETER;
 892
 893         }
 894         tts_client_s* client = tts_client_get(tts);
 895
 896         if (NULL == client) {
 897                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 898                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 899                 return TTS_ERROR_INVALID_PARAMETER;
 900         }
 901
 902         /* Request call remote method */
 903         int ret = 0;
 904         ret = tts_config_mgr_get_voice(lang, vctype);
 905         if (0 != ret) {
 906                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 907                 return __tts_convert_config_error_code(ret);
 908         } else {
 909                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 910         }
 911
 912         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 913
 914         return ret;
 915 }
 916
 917 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 918 {
 919         if (0 != __tts_get_feature_enabled()) {
 920                 return TTS_ERROR_NOT_SUPPORTED;
 921         }
 922
 923         if (NULL == tts || NULL == size) {
 924                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 925                 return TTS_ERROR_INVALID_PARAMETER;
 926         }
 927
 928         tts_client_s* client = tts_client_get(tts);
 929
 930         if (NULL == client) {
 931                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 932                 return TTS_ERROR_INVALID_PARAMETER;
 933         }
 934
 935         if (TTS_STATE_READY != client->current_state) {
 936                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 937                 return TTS_ERROR_INVALID_STATE;
 938         }
 939
 940         if (0 != tts_config_mgr_get_max_text_size(size)) {
 941                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
 942                 return TTS_ERROR_INVALID_PARAMETER;
 943         }
 944
 945         g_max_text_size = (int)*size;
 946
 947         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 948         return TTS_ERROR_NONE;
 949 }
 950
 951 int tts_get_state(tts_h tts, tts_state_e* state)
 952 {
 953         if (0 != __tts_get_feature_enabled()) {
 954                 return TTS_ERROR_NOT_SUPPORTED;
 955         }
 956
 957         if (NULL == tts || NULL == state) {
 958                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 959                 return TTS_ERROR_INVALID_PARAMETER;
 960         }
 961
 962         tts_client_s* client = tts_client_get(tts);
 963
 964         if (NULL == client) {
 965                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 966                 return TTS_ERROR_INVALID_PARAMETER;
 967         }
 968
 969         *state = client->current_state;
 970
 971         switch (*state) {
 972         case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 973         case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 974         case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 975         case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 976         default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 977         }
 978
 979         return TTS_ERROR_NONE;
 980 }
 981
 982 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 983 {
 984         if (0 != __tts_get_feature_enabled()) {
 985                 return TTS_ERROR_NOT_SUPPORTED;
 986         }
 987
 988         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 989                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 990                 return TTS_ERROR_INVALID_PARAMETER;
 991         }
 992
 993         tts_client_s* client = tts_client_get(tts);
 994
 995         if (NULL == client) {
 996                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 997                 return TTS_ERROR_INVALID_PARAMETER;
 998         }
 999
1000         *min = TTS_SPEED_MIN;
1001         *normal = TTS_SPEED_NORMAL;
1002         *max = TTS_SPEED_MAX;
1003
1004         return TTS_ERROR_NONE;
1005 }
1006
1007 int tts_get_error_message(tts_h tts, char** err_msg)
1008 {
1009         if (0 != __tts_get_feature_enabled()) {
1010                 return TTS_ERROR_NOT_SUPPORTED;
1011         }
1012
1013         if (NULL == tts || NULL == err_msg) {
1014                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1015                 return TTS_ERROR_INVALID_PARAMETER;
1016         }
1017
1018         tts_client_s* client = tts_client_get(tts);
1019
1020         if (NULL == client) {
1021                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
1022                 return TTS_ERROR_INVALID_PARAMETER;
1023         }
1024
1025         if (NULL != client->err_msg) {
1026                 *err_msg = strdup(client->err_msg);
1027                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (%s)", *err_msg);
1028         } else {
1029                 *err_msg = NULL;
1030                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
1031         }
1032
1033         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1034
1035         return TTS_ERROR_NONE;
1036 }
1037
1038 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1039 {
1040         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Add text: text(%s), language(%s), type(%d)", (NULL == text) ? "NULL" : text, (NULL == language) ? "NULL" : language, voice_type);
1041
1042         if (0 != __tts_get_feature_enabled()) {
1043                 return TTS_ERROR_NOT_SUPPORTED;
1044         }
1045
1046         if (speed < 0) {
1047                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
1048                 return TTS_ERROR_INVALID_PARAMETER;
1049         }
1050
1051         if (voice_type < 0) {
1052                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
1053                 return TTS_ERROR_INVALID_PARAMETER;
1054         }
1055
1056         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
1057
1058         if (NULL == tts || NULL == utt_id) {
1059                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
1060                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1061                 return TTS_ERROR_INVALID_PARAMETER;
1062         }
1063
1064         tts_client_s* client = tts_client_get(tts);
1065
1066         if (NULL == client) {
1067                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1068                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1069                 return TTS_ERROR_INVALID_PARAMETER;
1070         }
1071
1072         if (TTS_STATE_CREATED == client->current_state) {
1073                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1074                 return TTS_ERROR_INVALID_STATE;
1075         }
1076
1077         if (-1 == g_max_text_size) {
1078                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1079                 if (0 != tts_config_mgr_get_max_text_size((unsigned int*)&g_max_text_size)) {
1080                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
1081                         return TTS_ERROR_INVALID_PARAMETER;
1082                 }
1083         }
1084
1085         if (0 == g_max_text_size) {
1086                 if (strlen(text) <= 0) {
1087                         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
1088                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
1089                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1090                         return TTS_ERROR_INVALID_PARAMETER;
1091                 }
1092         } else {
1093                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
1094                 if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
1095                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
1096                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1097                         return TTS_ERROR_INVALID_PARAMETER;
1098                 }
1099         }
1100
1101         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
1102                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
1103                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1104                 return TTS_ERROR_INVALID_PARAMETER;
1105         }
1106
1107         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1108                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1109                 return TTS_ERROR_INVALID_STATE;
1110         }
1111
1112         if (true == client->credential_needed && NULL == client->credential) {
1113                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1114                 return TTS_ERROR_PERMISSION_DENIED;
1115         }
1116
1117         /* check valid utf8 */
1118         bool valid = false;
1119
1120         DBusError err;
1121         dbus_error_init(&err);
1122
1123         valid = dbus_validate_utf8(text, &err);
1124         if (dbus_error_is_set(&err)) {
1125                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
1126                 dbus_error_free(&err);
1127                 return TTS_ERROR_INVALID_PARAMETER;
1128         }
1129
1130         if (valid != true) {
1131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
1132                 return TTS_ERROR_INVALID_PARAMETER;
1133         }
1134         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - text is '%s'", text);
1135
1136         /* change default language value */
1137         char* temp = NULL;
1138
1139         if (NULL == language)
1140                 temp = strdup("default");
1141         else
1142                 temp = strdup(language);
1143
1144         client->current_utt_id++;
1145         if (client->current_utt_id == 10000) {
1146                 client->current_utt_id = 1;
1147         }
1148
1149         /* do request */
1150         int ret = -1;
1151         int count = 0;
1152         bool is_prepared = false;
1153         while (0 != ret) {
1154                 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
1155                 if (0 != ret) {
1156                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1157                                 if (0 == tts_prepare_sync(tts)) {
1158                                         is_prepared = true;
1159                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1160                                 }
1161                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1162                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1163                                 break;
1164                         } else {
1165                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1166                                 usleep(10000);
1167                                 count++;
1168                                 if (TTS_RETRY_MIN_COUNT == count) {
1169                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1170                                         break;
1171                                 }
1172                         }
1173                 } else {
1174                         *utt_id = client->current_utt_id;
1175                 }
1176         }
1177
1178         if (NULL != temp) {
1179                 free(temp);
1180                 temp = NULL;
1181         }
1182
1183         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1184
1185         return ret;
1186 }
1187
1188 static void __tts_play_async(void *data)
1189 {
1190         tts_h tts = (tts_h)data;
1191         tts_client_s* client = tts_client_get(tts);
1192
1193         /* check handle */
1194         if (NULL == client) {
1195                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1196                 return;
1197         }
1198
1199         int ret = -1;
1200         int count = 0;
1201         bool is_prepared = false;
1202         while (0 != ret) {
1203                 ret = tts_dbus_request_play(client->uid, client->credential);
1204                 if (0 != ret) {
1205                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1206                                 if (0 == tts_prepare_sync(tts)) {
1207                                         is_prepared = true;
1208                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1209                                 }
1210                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1211                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1212                                 break;
1213                         } else {
1214                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1215                                 usleep(10000);
1216                                 count++;
1217                                 if (TTS_RETRY_COUNT == count) {
1218                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1219                                         break;
1220                                 }
1221                         }
1222                 }
1223         }
1224
1225         if (0 != ret) {
1226                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play tts : %s", __tts_get_error_code(ret));
1227
1228                 client->reason = ret;
1229                 client->utt_id = -1;
1230
1231                 ecore_timer_add(0, __tts_notify_error, client->tts);
1232                 return;
1233         }
1234
1235         client->before_state = client->current_state;
1236         client->current_state = TTS_STATE_PLAYING;
1237
1238         if (NULL != client->state_changed_cb) {
1239                 tts_client_use_callback(client);
1240                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1241                 tts_client_not_use_callback(client);
1242                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1243         }
1244
1245         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1246
1247         return;
1248 }
1249
1250 int tts_play_async(tts_h tts)
1251 {
1252         if (0 != __tts_get_feature_enabled()) {
1253                 return TTS_ERROR_NOT_SUPPORTED;
1254         }
1255
1256         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
1257
1258         if (NULL == tts) {
1259                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1260                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1261                 return TTS_ERROR_INVALID_PARAMETER;
1262         }
1263
1264         tts_client_s* client = tts_client_get(tts);
1265
1266         if (NULL == client) {
1267                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1268                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1269                 return TTS_ERROR_INVALID_PARAMETER;
1270         }
1271
1272         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1273                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1274                 return TTS_ERROR_INVALID_STATE;
1275         }
1276
1277         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1278                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1279                 return TTS_ERROR_INVALID_STATE;
1280         }
1281
1282         if (true == client->credential_needed && NULL == client->credential) {
1283                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1284                 return TTS_ERROR_PERMISSION_DENIED;
1285         }
1286
1287         ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
1288
1289         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1290
1291         return TTS_ERROR_NONE;
1292 }
1293
1294 int tts_play(tts_h tts)
1295 {
1296         if (0 != __tts_get_feature_enabled()) {
1297                 return TTS_ERROR_NOT_SUPPORTED;
1298         }
1299
1300         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
1301
1302         if (NULL == tts) {
1303                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1304                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1305                 return TTS_ERROR_INVALID_PARAMETER;
1306         }
1307
1308         tts_client_s* client = tts_client_get(tts);
1309
1310         if (NULL == client) {
1311                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1312                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1313                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1314                 return TTS_ERROR_INVALID_PARAMETER;
1315         }
1316
1317         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1318                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1319                 return TTS_ERROR_INVALID_STATE;
1320         }
1321
1322         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1323                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1324                 return TTS_ERROR_INVALID_STATE;
1325         }
1326
1327         if (true == client->credential_needed && NULL == client->credential) {
1328                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
1329                 return TTS_ERROR_PERMISSION_DENIED;
1330         }
1331
1332         int ret = -1;
1333         int count = 0;
1334         bool is_prepared = false;
1335         while (0 != ret) {
1336                 ret = tts_dbus_request_play(client->uid, client->credential);
1337                 if (0 != ret) {
1338                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1339                                 if (0 == tts_prepare_sync(tts)) {
1340                                         is_prepared = true;
1341                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1342                                 }
1343                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1344                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1345                                 return ret;
1346                         } else {
1347                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1348                                 usleep(10000);
1349                                 count++;
1350                                 if (TTS_RETRY_COUNT == count) {
1351                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1352                                         return ret;
1353                                 }
1354                         }
1355                 }
1356         }
1357
1358         client->before_state = client->current_state;
1359         client->current_state = TTS_STATE_PLAYING;
1360
1361         if (NULL != client->state_changed_cb) {
1362                 tts_client_use_callback(client);
1363                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1364                 tts_client_not_use_callback(client);
1365                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1366         }
1367
1368         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1369
1370         return TTS_ERROR_NONE;
1371 }
1372
1373 static void __tts_stop_async(void *data)
1374 {
1375         tts_h tts = (tts_h)data;
1376         tts_client_s* client = tts_client_get(tts);
1377
1378         /* check handle */
1379         if (NULL == client) {
1380                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1381                 return;
1382         }
1383
1384         int ret = -1;
1385         int count = 0;
1386         bool is_prepared = false;
1387         while (0 != ret) {
1388                 ret = tts_dbus_request_stop(client->uid);
1389                 if (0 != ret) {
1390                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1391                                 if (0 == tts_prepare_sync(tts)) {
1392                                         is_prepared = true;
1393                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1394                                 }
1395                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1396                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1397                                 break;
1398                         } else {
1399                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1400                                 usleep(10000);
1401                                 count++;
1402                                 if (TTS_RETRY_COUNT == count) {
1403                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1404                                         break;
1405                                 }
1406                         }
1407                 }
1408         }
1409
1410         if (0 != ret) {
1411                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to stop tts : %s", __tts_get_error_code(ret));
1412
1413                 client->reason = ret;
1414                 client->utt_id = -1;
1415
1416                 ecore_timer_add(0, __tts_notify_error, client->tts);
1417                 return;
1418         }
1419
1420         client->before_state = client->current_state;
1421         client->current_state = TTS_STATE_READY;
1422
1423         if (NULL != client->state_changed_cb) {
1424                 tts_client_use_callback(client);
1425                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1426                 tts_client_not_use_callback(client);
1427                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1428         }
1429
1430         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1431
1432         return;
1433 }
1434
1435 int tts_stop_aync(tts_h tts)
1436 {
1437         if (0 != __tts_get_feature_enabled()) {
1438                 return TTS_ERROR_NOT_SUPPORTED;
1439         }
1440
1441         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
1442
1443         if (NULL == tts) {
1444                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1445                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1446                 return TTS_ERROR_INVALID_PARAMETER;
1447         }
1448
1449         tts_client_s* client = tts_client_get(tts);
1450
1451         if (NULL == client) {
1452                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1453                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1454                 return TTS_ERROR_INVALID_PARAMETER;
1455         }
1456
1457         if (TTS_STATE_CREATED == client->current_state) {
1458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1459                 return TTS_ERROR_INVALID_STATE;
1460         }
1461
1462         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1463                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1464                 return TTS_ERROR_INVALID_STATE;
1465         }
1466
1467         ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
1468
1469         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1470
1471         return TTS_ERROR_NONE;
1472 }
1473
1474 int tts_stop(tts_h tts)
1475 {
1476         if (0 != __tts_get_feature_enabled()) {
1477                 return TTS_ERROR_NOT_SUPPORTED;
1478         }
1479
1480         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
1481
1482         if (NULL == tts) {
1483                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1484                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1485                 return TTS_ERROR_INVALID_PARAMETER;
1486         }
1487
1488         tts_client_s* client = tts_client_get(tts);
1489
1490         if (NULL == client) {
1491                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1492                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1493                 return TTS_ERROR_INVALID_PARAMETER;
1494         }
1495
1496         if (TTS_STATE_CREATED == client->current_state) {
1497                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1498                 return TTS_ERROR_INVALID_STATE;
1499         }
1500
1501         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1502                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1503                 return TTS_ERROR_INVALID_STATE;
1504         }
1505
1506         int ret = -1;
1507         int count = 0;
1508         bool is_prepared = false;
1509         while (0 != ret) {
1510                 ret = tts_dbus_request_stop(client->uid);
1511                 if (0 != ret) {
1512                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1513                                 if (0 == tts_prepare_sync(tts)) {
1514                                         is_prepared = true;
1515                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1516                                 }
1517                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1518                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1519                                 return ret;
1520                         } else {
1521                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1522                                 usleep(10000);
1523                                 count++;
1524                                 if (TTS_RETRY_COUNT == count) {
1525                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1526                                         return ret;
1527                                 }
1528                         }
1529                 }
1530         }
1531
1532         client->before_state = client->current_state;
1533         client->current_state = TTS_STATE_READY;
1534
1535         if (NULL != client->state_changed_cb) {
1536                 tts_client_use_callback(client);
1537                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1538                 tts_client_not_use_callback(client);
1539                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1540         }
1541
1542         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1543
1544         return TTS_ERROR_NONE;
1545 }
1546
1547 static void __tts_pause_async(void *data)
1548 {
1549         tts_h tts = (tts_h)data;
1550         tts_client_s* client = tts_client_get(tts);
1551
1552         /* check handle */
1553         if (NULL == client) {
1554                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1555                 return;
1556         }
1557
1558         int ret = -1;
1559         int count = 0;
1560         bool is_prepared = false;
1561         while (0 != ret) {
1562                 ret = tts_dbus_request_pause(client->uid);
1563                 if (0 != ret) {
1564                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1565                                 if (0 == tts_prepare_sync(tts)) {
1566                                         is_prepared = true;
1567                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1568                                 }
1569                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1570                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1571                                 break;
1572                         } else {
1573                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1574                                 usleep(10000);
1575                                 count++;
1576                                 if (TTS_RETRY_COUNT == count) {
1577                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1578                                         break;
1579                                 }
1580                         }
1581                 }
1582         }
1583
1584         if (0 != ret) {
1585                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to pause tts : %s", __tts_get_error_code(ret));
1586
1587                 client->reason = ret;
1588                 client->utt_id = -1;
1589
1590                 ecore_timer_add(0, __tts_notify_error, client->tts);
1591                 return;
1592         }
1593
1594         client->before_state = client->current_state;
1595         client->current_state = TTS_STATE_PAUSED;
1596
1597         if (NULL != client->state_changed_cb) {
1598                 tts_client_use_callback(client);
1599                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1600                 tts_client_not_use_callback(client);
1601                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1602         }
1603
1604         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1605
1606         return;
1607 }
1608
1609 int tts_pause_async(tts_h tts)
1610 {
1611         if (0 != __tts_get_feature_enabled()) {
1612                 return TTS_ERROR_NOT_SUPPORTED;
1613         }
1614
1615         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
1616
1617         if (NULL == tts) {
1618                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1619                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1620                 return TTS_ERROR_INVALID_PARAMETER;
1621         }
1622
1623         tts_client_s* client = tts_client_get(tts);
1624
1625         if (NULL == client) {
1626                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1627                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1628                 return TTS_ERROR_INVALID_PARAMETER;
1629         }
1630
1631         if (TTS_STATE_PLAYING != client->current_state) {
1632                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1633                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1634                 return TTS_ERROR_INVALID_STATE;
1635         }
1636
1637         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1638                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1639                 return TTS_ERROR_INVALID_STATE;
1640         }
1641
1642         ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
1643
1644         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1645
1646         return TTS_ERROR_NONE;
1647 }
1648
1649 int tts_pause(tts_h tts)
1650 {
1651         if (0 != __tts_get_feature_enabled()) {
1652                 return TTS_ERROR_NOT_SUPPORTED;
1653         }
1654
1655         SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
1656
1657         if (NULL == tts) {
1658                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1659                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1660                 return TTS_ERROR_INVALID_PARAMETER;
1661         }
1662
1663         tts_client_s* client = tts_client_get(tts);
1664
1665         if (NULL == client) {
1666                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1667                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1668                 return TTS_ERROR_INVALID_PARAMETER;
1669         }
1670
1671         if (TTS_STATE_PLAYING != client->current_state) {
1672                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1673                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1674                 return TTS_ERROR_INVALID_STATE;
1675         }
1676
1677         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1678                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1679                 return TTS_ERROR_INVALID_STATE;
1680         }
1681
1682         int ret = -1;
1683         int count = 0;
1684         bool is_prepared = false;
1685         while (0 != ret) {
1686                 ret = tts_dbus_request_pause(client->uid);
1687                 if (0 != ret) {
1688                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1689                                 if (0 == tts_prepare_sync(tts)) {
1690                                         is_prepared = true;
1691                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1692                                 }
1693                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1694                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1695                                 return ret;
1696                         } else {
1697                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1698                                 usleep(10000);
1699                                 count++;
1700                                 if (TTS_RETRY_COUNT == count) {
1701                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1702                                         return ret;
1703                                 }
1704                         }
1705                 }
1706         }
1707
1708         client->before_state = client->current_state;
1709         client->current_state = TTS_STATE_PAUSED;
1710
1711         if (NULL != client->state_changed_cb) {
1712                 tts_client_use_callback(client);
1713                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1714                 tts_client_not_use_callback(client);
1715                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1716         }
1717
1718         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1719
1720         return TTS_ERROR_NONE;
1721 }
1722
1723 int tts_set_private_data(tts_h tts, const char* key, const char* data)
1724 {
1725         if (0 != __tts_get_feature_enabled()) {
1726                 return TTS_ERROR_NOT_SUPPORTED;
1727         }
1728
1729         SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
1730
1731         if (NULL == tts) {
1732                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
1733                 return TTS_ERROR_INVALID_PARAMETER;
1734         }
1735
1736         if (NULL == key || NULL == data) {
1737                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1738                 return TTS_ERROR_INVALID_PARAMETER;
1739         }
1740
1741         tts_client_s* client = tts_client_get(tts);
1742
1743         if (NULL == client) {
1744                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1745                 return TTS_ERROR_INVALID_PARAMETER;
1746         }
1747
1748         if (TTS_STATE_READY != client->current_state) {
1749                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1750                 return TTS_ERROR_INVALID_STATE;
1751         }
1752
1753         if (true != client->internal && (0 == strcmp(key, "EnableServerTTS") || 0 == strcmp(key, "DisableServerTTS"))) {
1754                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] This is not an internal app");
1755                 return TTS_ERROR_INVALID_PARAMETER;
1756         }
1757
1758         int ret = -1;
1759         int count = 0;
1760         bool is_prepared = false;
1761         while (0 != ret) {
1762                 ret = tts_dbus_request_set_private_data(client->uid, key, data);
1763                 if (0 != ret) {
1764                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1765                                 if (0 == tts_prepare_sync(tts)) {
1766                                         is_prepared = true;
1767                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1768                                 }
1769                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1770                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1771                                 return ret;
1772                         } else {
1773                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1774                                 usleep(10000);
1775                                 count++;
1776                                 if (TTS_RETRY_COUNT == count) {
1777                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1778                                         return ret;
1779                                 }
1780                         }
1781                 }
1782         }
1783
1784         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1785
1786         return 0;
1787 }
1788
1789 int tts_get_private_data(tts_h tts, const char* key, char** data)
1790 {
1791         if (0 != __tts_get_feature_enabled()) {
1792                 return TTS_ERROR_NOT_SUPPORTED;
1793         }
1794
1795         SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
1796
1797         if (NULL == tts) {
1798                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1799                 return TTS_ERROR_INVALID_PARAMETER;
1800         }
1801
1802         if (NULL == key || NULL == data) {
1803                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid parameter");
1804                 return TTS_ERROR_INVALID_PARAMETER;
1805         }
1806
1807         tts_client_s* client = tts_client_get(tts);
1808
1809         if (NULL == client) {
1810                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1811                 return TTS_ERROR_INVALID_PARAMETER;
1812         }
1813
1814         if (TTS_STATE_READY != client->current_state) {
1815                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid state : Current state is NOT 'READY'");
1816                 return TTS_ERROR_INVALID_STATE;
1817         }
1818
1819         int ret = -1;
1820         int count = 0;
1821         bool is_prepared = false;
1822         while (0 != ret) {
1823                 ret = tts_dbus_request_get_private_data(client->uid, key, data);
1824                 if (0 != ret) {
1825                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
1826                                 if (0 == tts_prepare_sync(tts)) {
1827                                         is_prepared = true;
1828                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
1829                                 }
1830                         } else if (TTS_ERROR_TIMED_OUT != ret) {
1831                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1832                                 return ret;
1833                         } else {
1834                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry : %s", __tts_get_error_code(ret));
1835                                 usleep(10000);
1836                                 count++;
1837                                 if (TTS_RETRY_COUNT == count) {
1838                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1839                                         return ret;
1840                                 }
1841                         }
1842                 }
1843         }
1844
1845         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1846                 free(*data);
1847                 *data = NULL;
1848         }
1849
1850         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1851
1852         return 0;
1853 }
1854
1855 static Eina_Bool __tts_notify_error(void *data)
1856 {
1857         tts_h tts = (tts_h)data;
1858
1859         tts_client_s* client = tts_client_get(tts);
1860
1861         /* check handle */
1862         if (NULL == client) {
1863                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1864                 return EINA_FALSE;
1865         }
1866
1867         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1868
1869         if (NULL != client->error_cb) {
1870                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1871                 tts_client_use_callback(client);
1872                 g_err_callback_status = true;
1873                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1874                 g_err_callback_status = false;
1875                 tts_client_not_use_callback(client);
1876         } else {
1877                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1878         }
1879
1880         return EINA_FALSE;
1881 }
1882
1883 int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char* err_msg)
1884 {
1885         if (-1 == uid) {
1886                 GList* client_list = NULL;
1887                 client_list = tts_client_get_client_list();
1888
1889                 GList *iter = NULL;
1890                 tts_client_s *data = NULL;
1891
1892                 if (g_list_length(client_list) > 0) {
1893                         /* Get a first item */
1894                         iter = g_list_first(client_list);
1895
1896                         while (NULL != iter) {
1897                                 data = iter->data;
1898
1899                                 data->utt_id = utt_id;
1900                                 data->reason = reason;
1901                                 if (NULL != data->err_msg) {
1902                                         free(data->err_msg);
1903                                         data->err_msg = NULL;
1904                                 }
1905                                 if (NULL != err_msg)
1906                                         data->err_msg = strdup(err_msg);
1907
1908                                 /* call callback function */
1909                                 if (NULL != data->error_cb) {
1910                                         ecore_timer_add(0, __tts_notify_error, data->tts);
1911                                 } else {
1912                                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1913                                 }
1914
1915                                 if (TTS_ERROR_SERVICE_RESET == reason) {
1916                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1917
1918                                         data->current_state = TTS_STATE_CREATED;
1919                                         if (0 != tts_prepare(data->tts)) {
1920                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1921                                         }
1922                                 }
1923
1924                                 /* Next item */
1925                                 iter = g_list_next(iter);
1926                         }
1927                 }
1928         } else {
1929                 tts_client_s* client = tts_client_get_by_uid(uid);
1930
1931                 if (NULL == client) {
1932                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1933                         return TTS_ERROR_INVALID_PARAMETER;
1934                 }
1935
1936                 client->utt_id = utt_id;
1937                 client->reason = reason;
1938                 if (NULL != client->err_msg) {
1939                         free(client->err_msg);
1940                         client->err_msg = NULL;
1941                 }
1942                 if (NULL != err_msg)
1943                         client->err_msg = strdup(err_msg);
1944
1945                 /* call callback function */
1946                 if (NULL != client->error_cb) {
1947                         ecore_timer_add(0, __tts_notify_error, client->tts);
1948                 } else {
1949                         SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1950                 }
1951
1952                 if (TTS_ERROR_SERVICE_RESET == reason) {
1953                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1954
1955                         client->current_state = TTS_STATE_CREATED;
1956                         if (0 != tts_prepare(client->tts)) {
1957                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare");
1958                         }
1959                 }
1960         }
1961
1962         return 0;
1963 }
1964
1965 static Eina_Bool __tts_notify_state_changed(void *data)
1966 {
1967         tts_h tts = (tts_h)data;
1968
1969         tts_client_s* client = tts_client_get(tts);
1970
1971         /* check handle */
1972         if (NULL == client) {
1973                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1974                 return EINA_FALSE;
1975         }
1976
1977         if (NULL != client->state_changed_cb) {
1978                 tts_client_use_callback(client);
1979                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1980                 tts_client_not_use_callback(client);
1981                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1982         } else {
1983                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1984         }
1985
1986         return EINA_FALSE;
1987 }
1988
1989 int __tts_cb_set_state(int uid, int state)
1990 {
1991         tts_client_s* client = tts_client_get_by_uid(uid);
1992         if (NULL == client) {
1993                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1994                 return -1;
1995         }
1996
1997         tts_state_e state_from_daemon = (tts_state_e)state;
1998
1999         if (client->current_state == state_from_daemon) {
2000                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
2001                 return 0;
2002         }
2003
2004         if (NULL != client->state_changed_cb) {
2005                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
2006         } else {
2007                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
2008         }
2009
2010         client->before_state = client->current_state;
2011         client->current_state = state_from_daemon;
2012
2013         return 0;
2014 }
2015
2016 int __tts_cb_utt_started(int uid, int utt_id)
2017 {
2018         tts_client_s* client = tts_client_get_by_uid(uid);
2019
2020         if (NULL == client) {
2021                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2022                 return TTS_ERROR_INVALID_PARAMETER;
2023         }
2024
2025         SLOG(LOG_INFO, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
2026
2027         client->utt_id = utt_id;
2028
2029         /* call callback function */
2030         if (NULL != client->utt_started_cb) {
2031                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
2032                 tts_client_use_callback(client);
2033                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
2034                 tts_client_not_use_callback(client);
2035         } else {
2036                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
2037         }
2038
2039         return 0;
2040 }
2041
2042 int __tts_cb_utt_completed(int uid, int utt_id)
2043 {
2044         tts_client_s* client = tts_client_get_by_uid(uid);
2045
2046         if (NULL == client) {
2047                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
2048                 return TTS_ERROR_INVALID_PARAMETER;
2049         }
2050
2051         SLOG(LOG_INFO, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
2052
2053         client->utt_id = utt_id;
2054
2055         /* call callback function */
2056         if (NULL != client->utt_completeted_cb) {
2057                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
2058                 tts_client_use_callback(client);
2059                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
2060                 tts_client_not_use_callback(client);
2061         } else {
2062                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
2063         }
2064
2065         return 0;
2066 }
2067
2068 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
2069 {
2070         if (0 != __tts_get_feature_enabled()) {
2071                 return TTS_ERROR_NOT_SUPPORTED;
2072         }
2073
2074         if (NULL == tts || NULL == callback) {
2075                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
2076                 return TTS_ERROR_INVALID_PARAMETER;
2077         }
2078
2079         tts_client_s* client = tts_client_get(tts);
2080
2081         if (NULL == client) {
2082                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
2083                 return TTS_ERROR_INVALID_PARAMETER;
2084         }
2085
2086         if (TTS_STATE_CREATED != client->current_state) {
2087                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
2088                 return TTS_ERROR_INVALID_STATE;
2089         }
2090
2091         client->state_changed_cb = callback;
2092         client->state_changed_user_data = user_data;
2093
2094         SLOG(LOG_INFO, TAG_TTSC, "[SUCCESS] Set state changed cb");
2095
2096         return 0;
2097 }
2098
2099 int tts_unset_state_changed_cb(tts_h tts)
2100 {
2101         if (0 != __tts_get_feature_enabled()) {
2102                 return TTS_ERROR_NOT_SUPPORTED;
2103         }
2104
2105         if (NULL == tts) {
2106                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
2107                 return TTS_ERROR_INVALID_PARAMETER;
2108         }
2109
2110         tts_client_s* client = tts_client_get(tts);
2111
2112         if (NULL == client) {
2113                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
2114                 return TTS_ERROR_INVALID_PARAMETER;
2115         }
2116
2117         if (TTS_STATE_CREATED != client->current_state) {
2118                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
2119                 return TTS_ERROR_INVALID_STATE;
2120         }
2121
2122         client->state_changed_cb = NULL;
2123         client->state_changed_user_data = NULL;
2124
2125         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
2126
2127         return 0;
2128 }
2129
2130 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
2131 {
2132         if (0 != __tts_get_feature_enabled()) {
2133                 return TTS_ERROR_NOT_SUPPORTED;
2134         }
2135
2136         if (NULL == tts || NULL == callback) {
2137                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
2138                 return TTS_ERROR_INVALID_PARAMETER;
2139         }
2140
2141         tts_client_s* client = tts_client_get(tts);
2142
2143         if (NULL == client) {
2144                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
2145                 return TTS_ERROR_INVALID_PARAMETER;
2146         }
2147
2148         if (TTS_STATE_CREATED != client->current_state) {
2149                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
2150                 return TTS_ERROR_INVALID_STATE;
2151         }
2152
2153         client->utt_started_cb = callback;
2154         client->utt_started_user_data = user_data;
2155
2156         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
2157
2158         return 0;
2159 }
2160
2161 int tts_unset_utterance_started_cb(tts_h tts)
2162 {
2163         if (0 != __tts_get_feature_enabled()) {
2164                 return TTS_ERROR_NOT_SUPPORTED;
2165         }
2166
2167         if (NULL == tts) {
2168                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
2169                 return TTS_ERROR_INVALID_PARAMETER;
2170         }
2171
2172         tts_client_s* client = tts_client_get(tts);
2173
2174         if (NULL == client) {
2175                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
2176                 return TTS_ERROR_INVALID_PARAMETER;
2177         }
2178
2179         if (TTS_STATE_CREATED != client->current_state) {
2180                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
2181                 return TTS_ERROR_INVALID_STATE;
2182         }
2183
2184         client->utt_started_cb = NULL;
2185         client->utt_started_user_data = NULL;
2186
2187         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
2188
2189         return 0;
2190 }
2191
2192 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
2193 {
2194         if (0 != __tts_get_feature_enabled()) {
2195                 return TTS_ERROR_NOT_SUPPORTED;
2196         }
2197
2198         if (NULL == tts || NULL == callback) {
2199                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
2200                 return TTS_ERROR_INVALID_PARAMETER;
2201         }
2202
2203         tts_client_s* client = tts_client_get(tts);
2204
2205         if (NULL == client) {
2206                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
2207                 return TTS_ERROR_INVALID_PARAMETER;
2208         }
2209
2210         if (TTS_STATE_CREATED != client->current_state) {
2211                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
2212                 return TTS_ERROR_INVALID_STATE;
2213         }
2214
2215         client->utt_completeted_cb = callback;
2216         client->utt_completed_user_data = user_data;
2217
2218         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
2219
2220         return 0;
2221 }
2222
2223 int tts_unset_utterance_completed_cb(tts_h tts)
2224 {
2225         if (0 != __tts_get_feature_enabled()) {
2226                 return TTS_ERROR_NOT_SUPPORTED;
2227         }
2228
2229         if (NULL == tts) {
2230                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
2231                 return TTS_ERROR_INVALID_PARAMETER;
2232         }
2233
2234         tts_client_s* client = tts_client_get(tts);
2235
2236         if (NULL == client) {
2237                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
2238                 return TTS_ERROR_INVALID_PARAMETER;
2239         }
2240
2241         if (TTS_STATE_CREATED != client->current_state) {
2242                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
2243                 return TTS_ERROR_INVALID_STATE;
2244         }
2245
2246         client->utt_completeted_cb = NULL;
2247         client->utt_completed_user_data = NULL;
2248
2249         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
2250         return 0;
2251 }
2252
2253 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
2254 {
2255         if (0 != __tts_get_feature_enabled()) {
2256                 return TTS_ERROR_NOT_SUPPORTED;
2257         }
2258
2259         if (NULL == tts || NULL == callback) {
2260                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
2261                 return TTS_ERROR_INVALID_PARAMETER;
2262         }
2263
2264         tts_client_s* client = tts_client_get(tts);
2265
2266         if (NULL == client) {
2267                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
2268                 return TTS_ERROR_INVALID_PARAMETER;
2269         }
2270
2271         if (TTS_STATE_CREATED != client->current_state) {
2272                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
2273                 return TTS_ERROR_INVALID_STATE;
2274         }
2275
2276         client->error_cb = callback;
2277         client->error_user_data = user_data;
2278
2279         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
2280
2281         return 0;
2282 }
2283
2284 int tts_unset_error_cb(tts_h tts)
2285 {
2286         if (0 != __tts_get_feature_enabled()) {
2287                 return TTS_ERROR_NOT_SUPPORTED;
2288         }
2289
2290         if (NULL == tts) {
2291                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
2292                 return TTS_ERROR_INVALID_PARAMETER;
2293         }
2294
2295         tts_client_s* client = tts_client_get(tts);
2296
2297         if (NULL == client) {
2298                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
2299                 return TTS_ERROR_INVALID_PARAMETER;
2300         }
2301
2302         if (TTS_STATE_CREATED != client->current_state) {
2303                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
2304                 return TTS_ERROR_INVALID_STATE;
2305         }
2306
2307         client->error_cb = NULL;
2308         client->error_user_data = NULL;
2309
2310         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
2311
2312         return 0;
2313 }
2314
2315 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
2316 {
2317         if (0 != __tts_get_feature_enabled()) {
2318                 return TTS_ERROR_NOT_SUPPORTED;
2319         }
2320
2321         if (NULL == tts || NULL == callback) {
2322                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
2323                 return TTS_ERROR_INVALID_PARAMETER;
2324         }
2325
2326         tts_client_s* client = tts_client_get(tts);
2327
2328         if (NULL == client) {
2329                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
2330                 return TTS_ERROR_INVALID_PARAMETER;
2331         }
2332
2333         if (TTS_STATE_CREATED != client->current_state) {
2334                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
2335                 return TTS_ERROR_INVALID_STATE;
2336         }
2337
2338         client->default_voice_changed_cb = callback;
2339         client->default_voice_changed_user_data = user_data;
2340
2341         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
2342
2343         return 0;
2344 }
2345
2346 int tts_unset_default_voice_changed_cb(tts_h tts)
2347 {
2348         if (0 != __tts_get_feature_enabled()) {
2349                 return TTS_ERROR_NOT_SUPPORTED;
2350         }
2351
2352         if (NULL == tts) {
2353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
2354                 return TTS_ERROR_INVALID_PARAMETER;
2355         }
2356
2357         tts_client_s* client = tts_client_get(tts);
2358
2359         if (NULL == client) {
2360                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
2361                 return TTS_ERROR_INVALID_PARAMETER;
2362         }
2363
2364         if (TTS_STATE_CREATED != client->current_state) {
2365                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
2366                 return TTS_ERROR_INVALID_STATE;
2367         }
2368
2369         client->default_voice_changed_cb = NULL;
2370         client->default_voice_changed_user_data = NULL;
2371
2372         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
2373
2374         return 0;
2375 }
2376
2377 int tts_set_engine_changed_cb(tts_h tts, tts_engine_changed_cb callback, void* user_data)
2378 {
2379         if (0 != __tts_get_feature_enabled()) {
2380                 return TTS_ERROR_NOT_SUPPORTED;
2381         }
2382
2383         if (NULL == tts || NULL == callback) {
2384                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Input parameter is null");
2385                 return TTS_ERROR_INVALID_PARAMETER;
2386         }
2387
2388         tts_client_s* client = tts_client_get(tts);
2389
2390         if (NULL == client) {
2391                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : A handle is not valid");
2392                 return TTS_ERROR_INVALID_PARAMETER;
2393         }
2394
2395         if (TTS_STATE_CREATED != client->current_state) {
2396                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set engine changed cb : Current state is not 'Created'.");
2397                 return TTS_ERROR_INVALID_STATE;
2398         }
2399
2400         client->engine_changed_cb = callback;
2401         client->engine_changed_user_data = user_data;
2402
2403         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set engine changed cb");
2404
2405         return 0;
2406 }
2407
2408 int tts_unset_engine_changed_cb(tts_h tts)
2409 {
2410         if (0 != __tts_get_feature_enabled()) {
2411                 return TTS_ERROR_NOT_SUPPORTED;
2412         }
2413
2414         if (NULL == tts) {
2415                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Input parameter is null");
2416                 return TTS_ERROR_INVALID_PARAMETER;
2417         }
2418
2419         tts_client_s* client = tts_client_get(tts);
2420
2421         if (NULL == client) {
2422                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : A handle is not valid");
2423                 return TTS_ERROR_INVALID_PARAMETER;
2424         }
2425
2426         if (TTS_STATE_CREATED != client->current_state) {
2427                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset engine changed cb : Current state is not 'Created'.");
2428                 return TTS_ERROR_INVALID_STATE;
2429         }
2430
2431         client->engine_changed_cb = NULL;
2432         client->engine_changed_user_data = NULL;
2433
2434         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset engine changed cb");
2435
2436         return 0;
2437 }
2438
2439 int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
2440 {
2441         if (0 != __tts_get_feature_enabled()) {
2442                 return TTS_ERROR_NOT_SUPPORTED;
2443         }
2444
2445         SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
2446
2447         if (NULL == tts) {
2448                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2449                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2450                 return TTS_ERROR_INVALID_PARAMETER;
2451         }
2452
2453         tts_client_s* client = tts_client_get(tts);
2454
2455         if (NULL == client) {
2456                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2457                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2458                 return TTS_ERROR_INVALID_PARAMETER;
2459         }
2460
2461         if (TTS_STATE_CREATED == client->current_state) {
2462                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2463                 return TTS_ERROR_INVALID_STATE;
2464         }
2465
2466         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2467                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2468                 return TTS_ERROR_INVALID_STATE;
2469         }
2470
2471         int ret = -1;
2472         int count = 0;
2473         bool is_prepared = false;
2474         while (0 != ret) {
2475                 ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
2476                 if (0 != ret) {
2477                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2478                                 if (0 == tts_prepare_sync(tts)) {
2479                                         is_prepared = true;
2480                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2481                                 }
2482                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2483                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2484                                 return ret;
2485                         } else {
2486                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
2487                                 usleep(10000);
2488                                 count++;
2489                                 if (TTS_RETRY_COUNT == count) {
2490                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2491                                         return ret;
2492                                 }
2493                         }
2494                 }
2495         }
2496
2497         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2498
2499         return TTS_ERROR_NONE;
2500 }
2501
2502 int tts_play_pcm(tts_h tts)
2503 {
2504         if (0 != __tts_get_feature_enabled()) {
2505                 return TTS_ERROR_NOT_SUPPORTED;
2506         }
2507
2508         SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
2509
2510         if (NULL == tts) {
2511                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2512                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2513                 return TTS_ERROR_INVALID_PARAMETER;
2514         }
2515
2516         tts_client_s* client = tts_client_get(tts);
2517
2518         if (NULL == client) {
2519                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2520                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2521                 return TTS_ERROR_INVALID_PARAMETER;
2522         }
2523
2524         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
2525                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2526                 return TTS_ERROR_INVALID_STATE;
2527         }
2528
2529         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2530                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2531                 return TTS_ERROR_INVALID_STATE;
2532         }
2533
2534         int ret = -1;
2535         int count = 0;
2536         bool is_prepared = false;
2537         while (0 != ret) {
2538                 ret = tts_dbus_request_play_pcm(client->uid);
2539                 if (0 != ret) {
2540                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2541                                 if (0 == tts_prepare_sync(tts)) {
2542                                         is_prepared = true;
2543                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2544                                 }
2545                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2546                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2547                                 return ret;
2548                         } else {
2549                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
2550                                 usleep(10000);
2551                                 count++;
2552                                 if (TTS_RETRY_COUNT == count) {
2553                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2554                                         return ret;
2555                                 }
2556                         }
2557                 }
2558         }
2559
2560         client->before_state = client->current_state;
2561         client->current_state = TTS_STATE_PLAYING;
2562
2563         if (NULL != client->state_changed_cb) {
2564                 tts_client_use_callback(client);
2565                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2566                 tts_client_not_use_callback(client);
2567                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2568         }
2569
2570         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2571
2572         return TTS_ERROR_NONE;
2573 }
2574
2575 int tts_stop_pcm(tts_h tts)
2576 {
2577         if (0 != __tts_get_feature_enabled()) {
2578                 return TTS_ERROR_NOT_SUPPORTED;
2579         }
2580
2581         SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
2582
2583         if (NULL == tts) {
2584                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
2585                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2586                 return TTS_ERROR_INVALID_PARAMETER;
2587         }
2588
2589         tts_client_s* client = tts_client_get(tts);
2590
2591         if (NULL == client) {
2592                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
2593                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2594                 return TTS_ERROR_INVALID_PARAMETER;
2595         }
2596
2597         if (TTS_STATE_CREATED == client->current_state) {
2598                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
2599                 return TTS_ERROR_INVALID_STATE;
2600         }
2601
2602         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
2603                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
2604                 return TTS_ERROR_INVALID_STATE;
2605         }
2606
2607         int ret = -1;
2608         int count = 0;
2609         bool is_prepared = false;
2610         while (0 != ret) {
2611                 ret = tts_dbus_request_stop_pcm(client->uid);
2612                 if (0 != ret) {
2613                         if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2614                                 if (0 == tts_prepare_sync(tts)) {
2615                                         is_prepared = true;
2616                                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
2617                                 }
2618                         } else if (TTS_ERROR_TIMED_OUT != ret) {
2619                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
2620                                 return ret;
2621                         } else {
2622                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
2623                                 usleep(10000);
2624                                 count++;
2625                                 if (TTS_RETRY_COUNT == count) {
2626                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
2627                                         return ret;
2628                                 }
2629                         }
2630                 }
2631         }
2632
2633         client->before_state = client->current_state;
2634         client->current_state = TTS_STATE_READY;
2635
2636         if (NULL != client->state_changed_cb) {
2637                 tts_client_use_callback(client);
2638                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
2639                 tts_client_not_use_callback(client);
2640                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
2641         }
2642
2643         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
2644
2645         return TTS_ERROR_NONE;
2646 }