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