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