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