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