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