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