client/tts.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 <dirent.h>
  15 #include <Ecore.h>
  16 #include <iconv.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <system_info.h>
  21 #include <vconf.h>
  22
  23 #include "tts.h"
  24 #include "tts_client.h"
  25 #include "tts_config_mgr.h"
  26 #include "tts_dbus.h"
  27 #include "tts_main.h"
  28
  29
  30 static bool g_is_daemon_started = false;
  31
  32 static bool g_is_noti_daemon_started = false;
  33
  34 static bool g_is_sr_daemon_started = false;
  35
  36 static Ecore_Timer* g_connect_timer = NULL;
  37
  38 static bool g_screen_reader;
  39
  40 /* Function definition */
  41 static Eina_Bool __tts_notify_state_changed(void *data);
  42 static Eina_Bool __tts_notify_error(void *data);
  43
  44 const char* tts_tag()
  45 {
  46         return "ttsc";
  47 }
  48
  49 static const char* __tts_get_error_code(tts_error_e err)
  50 {
  51         switch(err) {
  52         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
  53         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
  54         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
  55         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
  56         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
  57         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
  58         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
  59         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
  60         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
  61         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
  62         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
  63         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
  64         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
  65         default:
  66                 return "Invalid error code";
  67         }
  68         return NULL;
  69 }
  70
  71 static int __tts_convert_config_error_code(tts_config_error_e code)
  72 {
  73         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_ERROR_NONE;
  74         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_ERROR_OUT_OF_MEMORY;
  75         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_ERROR_IO_ERROR;
  76         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_ERROR_INVALID_PARAMETER;
  77         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_ERROR_INVALID_STATE;
  78         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_ERROR_INVALID_VOICE;
  79         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_ERROR_ENGINE_NOT_FOUND;
  80         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_ERROR_OPERATION_FAILED;
  81         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_ERROR_OPERATION_FAILED;
  82
  83         return code;
  84 }
  85
  86 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)
  87 {
  88         SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
  89                 before_lang, before_voice_type, language, voice_type);
  90
  91         GList* client_list = NULL;
  92         client_list = tts_client_get_client_list();
  93
  94         GList *iter = NULL;
  95         tts_client_s *data = NULL;
  96
  97         if (g_list_length(client_list) > 0) {
  98                 /* Get a first item */
  99                 iter = g_list_first(client_list);
 100
 101                 while (NULL != iter) {
 102                         data = iter->data;
 103                         if (NULL != data->default_voice_changed_cb) {
 104                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
 105                                 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
 106                                         language, voice_type, data->default_voice_changed_user_data);
 107                         }
 108
 109                         /* Next item */
 110                         iter = g_list_next(iter);
 111                 }
 112         }
 113
 114         return;
 115 }
 116
 117 int tts_create(tts_h* tts)
 118 {
 119         bool tts_supported = false;
 120         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 121                 if (false == tts_supported) {
 122                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 123                         return TTS_ERROR_NOT_SUPPORTED;
 124                 }
 125         }
 126
 127         SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
 128
 129         /* check param */
 130         if (NULL == tts) {
 131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 132                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 133                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 134                 return TTS_ERROR_INVALID_PARAMETER;
 135         }
 136
 137         if (0 == tts_client_get_size()) {
 138                 if (0 != tts_dbus_open_connection()) {
 139                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
 140                         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 141                         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 142                         return TTS_ERROR_OPERATION_FAILED;
 143                 }
 144         }
 145
 146         if (0 != tts_client_new(tts)) {
 147                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
 148                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 149                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 150                 return TTS_ERROR_OUT_OF_MEMORY;
 151         }
 152
 153         tts_client_s* client = tts_client_get(*tts);
 154         if (NULL == client) {
 155                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 156                 return TTS_ERROR_OPERATION_FAILED;
 157         }
 158
 159         int ret = tts_config_mgr_initialize(client->uid);
 160         if (0 != ret) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
 162                 tts_client_destroy(*tts);
 163                 return __tts_convert_config_error_code(ret);
 164         }
 165
 166         ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
 167         if (0 != ret) {
 168                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 169                 tts_client_destroy(*tts);
 170                 return __tts_convert_config_error_code(ret);
 171         }
 172
 173         g_is_daemon_started = false;
 174         g_is_noti_daemon_started = false;
 175         g_is_sr_daemon_started = false;
 176
 177         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 178         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 179
 180         return TTS_ERROR_NONE;
 181 }
 182
 183 int tts_destroy(tts_h tts)
 184 {
 185         bool tts_supported = false;
 186         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 187                 if (false == tts_supported) {
 188                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 189                         return TTS_ERROR_NOT_SUPPORTED;
 190                 }
 191         }
 192
 193         SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
 194
 195         if (NULL == tts) {
 196                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 197                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 198                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 199                 return TTS_ERROR_INVALID_PARAMETER;
 200         }
 201
 202         tts_client_s* client = tts_client_get(tts);
 203
 204         /* check handle */
 205         if (NULL == client) {
 206                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 207                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 208                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 209                 return TTS_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         /* check used callback */
 213         if (0 != tts_client_get_use_callback(client)) {
 214                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 215                 return TTS_ERROR_OPERATION_FAILED;
 216         }
 217
 218         tts_config_mgr_finalize(client->uid);
 219
 220         int ret = -1;
 221         int count = 0;
 222
 223         /* check state */
 224         switch (client->current_state) {
 225         case TTS_STATE_PAUSED:
 226         case TTS_STATE_PLAYING:
 227         case TTS_STATE_READY:
 228                 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 229                         while (0 != ret) {
 230                                 ret = tts_dbus_request_finalize(client->uid);
 231                                 if (0 != ret) {
 232                                         if (TTS_ERROR_TIMED_OUT != ret) {
 233                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 234                                                 break;
 235                                         } else {
 236                                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
 237                                                 usleep(10);
 238                                                 count++;
 239                                                 if (10 == count) {
 240                                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 241                                                         break;
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246                 } else {
 247                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 248                 }
 249
 250                 if (TTS_MODE_SCREEN_READER == client->mode)
 251                         g_is_sr_daemon_started = false;
 252                 else if (TTS_MODE_NOTIFICATION == client->mode)
 253                         g_is_noti_daemon_started = false;
 254                 else
 255                         g_is_daemon_started = false;
 256
 257                 if (0 == tts_client_get_mode_client_count(client->mode)) {
 258                         SLOG(LOG_DEBUG, TAG_TTSC, "Close file msg connection : mode(%d)", client->mode);
 259                         ret = tts_file_msg_close_connection(client->mode);
 260                         if (0 != ret)
 261                                 SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to close file message connection");
 262                 }
 263
 264                 client->before_state = client->current_state;
 265                 client->current_state = TTS_STATE_CREATED;
 266
 267         case TTS_STATE_CREATED:
 268                 if (NULL != g_connect_timer) {
 269                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 270                         ecore_timer_del(g_connect_timer);
 271                 }
 272                 /* Free resources */
 273                 tts_client_destroy(tts);
 274                 break;
 275
 276         default:
 277                 break;
 278         }
 279
 280         if (0 == tts_client_get_size()) {
 281                 if (0 != tts_dbus_close_connection()) {
 282                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 283                 }
 284         }
 285
 286         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 287         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 288
 289         return TTS_ERROR_NONE;
 290 }
 291
 292 void __tts_screen_reader_changed_cb(bool value)
 293 {
 294         g_screen_reader = value;
 295 }
 296
 297 int tts_set_mode(tts_h tts, tts_mode_e mode)
 298 {
 299         bool tts_supported = false;
 300         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 301                 if (false == tts_supported) {
 302                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 303                         return TTS_ERROR_NOT_SUPPORTED;
 304                 }
 305         }
 306
 307         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
 308
 309         tts_client_s* client = tts_client_get(tts);
 310
 311         /* check handle */
 312         if (NULL == client) {
 313                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 314                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 315                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 316                 return TTS_ERROR_INVALID_PARAMETER;
 317         }
 318
 319         /* check state */
 320         if (client->current_state != TTS_STATE_CREATED) {
 321                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 322                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 323                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 324                 return TTS_ERROR_INVALID_STATE;
 325         }
 326
 327         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
 328                 client->mode = mode;
 329         } else {
 330                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 331                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 332                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 333                 return TTS_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         if (TTS_MODE_SCREEN_READER == mode) {
 337                 int ret;
 338                 int screen_reader;
 339                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 340                 if (0 != ret) {
 341                         SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 342                         return TTS_ERROR_OPERATION_FAILED;
 343                 }
 344                 g_screen_reader = (bool)screen_reader;
 345                 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
 346         } else {
 347                 tts_config_unset_screen_reader_callback(client->uid);
 348         }
 349
 350         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 351         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 352
 353         return TTS_ERROR_NONE;
 354 }
 355
 356 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 357 {
 358         bool tts_supported = false;
 359         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 360                 if (false == tts_supported) {
 361                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 362                         return TTS_ERROR_NOT_SUPPORTED;
 363                 }
 364         }
 365
 366         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
 367
 368         tts_client_s* client = tts_client_get(tts);
 369
 370         /* check handle */
 371         if (NULL == client) {
 372                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 373                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 374                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 375                 return TTS_ERROR_INVALID_PARAMETER;
 376         }
 377
 378         /* check state */
 379         if (client->current_state != TTS_STATE_CREATED) {
 380                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 381                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 382                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 383                 return TTS_ERROR_INVALID_STATE;
 384         }
 385
 386         if (NULL == mode) {
 387                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 388                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 389                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 390                 return TTS_ERROR_INVALID_PARAMETER;
 391         }
 392
 393         *mode = client->mode;
 394
 395         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 396         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 397
 398         return TTS_ERROR_NONE;
 399 }
 400
 401 static void* __fork_tts_daemon(void* data)
 402 {
 403         char daemon_path[64] = {'\0',};
 404         int pid, i;
 405         tts_mode_e mode;
 406
 407         mode = (tts_mode_e)data;
 408
 409         if (TTS_MODE_DEFAULT == mode) {
 410                 snprintf(daemon_path, 64, "%s", "/usr/bin/tts-daemon");
 411         } else if (TTS_MODE_NOTIFICATION == mode) {
 412                 snprintf(daemon_path, 64, "%s", "/usr/bin/tts-daemon-noti");
 413         } else if (TTS_MODE_SCREEN_READER == mode) {
 414                 snprintf(daemon_path, 64, "%s", "/usr/bin/tts-daemon-sr");
 415         } else {
 416                 SLOG(LOG_ERROR, TAG_TTSC, "mode is not valid");
 417                 return (void*)-1;
 418         }
 419
 420         /* fork-exec daemom */
 421         pid = fork();
 422
 423         switch(pid) {
 424         case -1:
 425                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to create daemon");
 426                 break;
 427
 428         case 0:
 429                 setsid();
 430                 for (i = 0;i < _NSIG;i++)
 431                         signal(i, SIG_DFL);
 432
 433                 execl(daemon_path, daemon_path, NULL);
 434                 break;
 435
 436         default:
 437                 break;
 438         }
 439
 440         return (void*) 1;
 441 }
 442
 443 static Eina_Bool __tts_connect_daemon(void *data)
 444 {
 445         tts_h tts = (tts_h)data;
 446         tts_client_s* client = tts_client_get(tts);
 447
 448         /* check handle */
 449         if (NULL == client) {
 450                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 451                 g_connect_timer = NULL;
 452                 return EINA_FALSE;
 453         }
 454
 455         /* Send hello */
 456         if (0 != tts_dbus_request_hello(client->uid)) {
 457                 pthread_t thread;
 458                 int thread_id;
 459
 460                 if (TTS_MODE_SCREEN_READER == client->mode) {
 461                         if (false == g_is_sr_daemon_started) {
 462                                 g_is_sr_daemon_started = true;
 463                                 thread_id = pthread_create(&thread, NULL, __fork_tts_daemon, (void*)TTS_MODE_SCREEN_READER);
 464                                 if (thread_id < 0) {
 465                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to make thread");
 466                                         g_connect_timer = NULL;
 467                                         return EINA_FALSE;
 468                                 }
 469                                 pthread_detach(thread);
 470                         }
 471                 } else if (TTS_MODE_NOTIFICATION == client->mode) {
 472                         if (false == g_is_noti_daemon_started) {
 473                                 g_is_noti_daemon_started = true;
 474                                 thread_id = pthread_create(&thread, NULL, __fork_tts_daemon, (void*)TTS_MODE_NOTIFICATION);
 475                                 if (thread_id < 0) {
 476                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to make thread");
 477                                         g_connect_timer = NULL;
 478                                         return EINA_FALSE;
 479                                 }
 480                                 pthread_detach(thread);
 481                         }
 482                 } else {
 483                         if (false == g_is_daemon_started) {
 484                                 g_is_daemon_started = true;
 485                                 thread_id = pthread_create(&thread, NULL, __fork_tts_daemon, (void*)TTS_MODE_DEFAULT);
 486                                 if (thread_id < 0) {
 487                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to make thread");
 488                                         g_connect_timer = NULL;
 489                                         return EINA_FALSE;
 490                                 }
 491                                 pthread_detach(thread);
 492                         }
 493                 }
 494
 495                 return EINA_TRUE;
 496         }
 497
 498         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
 499
 500         /* do request initialize */
 501         int ret = -1;
 502         ret = tts_dbus_request_initialize(client->uid);
 503
 504         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 505                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 506
 507                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 508                 client->utt_id = -1;
 509
 510                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 511                 g_connect_timer = NULL;
 512                 return EINA_FALSE;
 513
 514         } else if (TTS_ERROR_NONE != ret) {
 515                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 516                 return EINA_TRUE;
 517
 518         } else {
 519                 /* success to connect tts-daemon */
 520         }
 521
 522         g_connect_timer = NULL;
 523
 524         if (0 == tts_client_get_mode_client_count(client->mode)) {
 525                 SLOG(LOG_DEBUG, TAG_TTSC, "Open file msg connection : mode(%d)", client->mode);
 526                 ret = tts_file_msg_open_connection(client->mode);
 527                 if (0 != ret) {
 528                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open file message connection");
 529                         ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 530                         return EINA_FALSE;
 531                 }
 532         }
 533
 534         client = tts_client_get(tts);
 535         /* check handle */
 536         if (NULL == client) {
 537                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 538                 return EINA_FALSE;
 539         }
 540
 541         client->before_state = client->current_state;
 542         client->current_state = TTS_STATE_READY;
 543
 544         if (NULL != client->state_changed_cb) {
 545                 tts_client_use_callback(client);
 546                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 547                 tts_client_not_use_callback(client);
 548         } else {
 549                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 550         }
 551
 552         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 553         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 554
 555         return EINA_FALSE;
 556 }
 557
 558 int tts_prepare(tts_h tts)
 559 {
 560         bool tts_supported = false;
 561         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 562                 if (false == tts_supported) {
 563                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 564                         return TTS_ERROR_NOT_SUPPORTED;
 565                 }
 566         }
 567
 568         SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
 569
 570         tts_client_s* client = tts_client_get(tts);
 571
 572         /* check handle */
 573         if (NULL == client) {
 574                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 575                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 576                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 577                 return TTS_ERROR_INVALID_PARAMETER;
 578         }
 579
 580         /* check state */
 581         if (client->current_state != TTS_STATE_CREATED) {
 582                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 583                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 584                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 585                 return TTS_ERROR_INVALID_STATE;
 586         }
 587
 588         g_connect_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 589
 590         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 591         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 592
 593         return TTS_ERROR_NONE;
 594 }
 595
 596 int tts_unprepare(tts_h tts)
 597 {
 598         bool tts_supported = false;
 599         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 600                 if (false == tts_supported) {
 601                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 602                         return TTS_ERROR_NOT_SUPPORTED;
 603                 }
 604         }
 605
 606         SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
 607
 608         tts_client_s* client = tts_client_get(tts);
 609
 610         /* check handle */
 611         if (NULL == client) {
 612                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 613                 return TTS_ERROR_INVALID_PARAMETER;
 614         }
 615
 616         /* check state */
 617         if (client->current_state != TTS_STATE_READY) {
 618                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 619                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 620                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 621                 return TTS_ERROR_INVALID_STATE;
 622         }
 623
 624         int ret = -1;
 625         int count = 0;
 626         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 627                 while (0 != ret) {
 628                         ret = tts_dbus_request_finalize(client->uid);
 629                         if (0 != ret) {
 630                                 if (TTS_ERROR_TIMED_OUT != ret) {
 631                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 632                                         break;
 633                                 } else {
 634                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 635                                         usleep(10);
 636                                         count++;
 637                                         if (10 == count) {
 638                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 639                                                 break;
 640                                         }
 641                                 }
 642                         }
 643                 }
 644         } else {
 645                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 646         }
 647
 648         if (TTS_MODE_SCREEN_READER == client->mode)
 649                 g_is_sr_daemon_started = false;
 650         else if (TTS_MODE_NOTIFICATION == client->mode)
 651                 g_is_noti_daemon_started = false;
 652         else
 653                 g_is_daemon_started = false;
 654
 655         client->before_state = client->current_state;
 656         client->current_state = TTS_STATE_CREATED;
 657
 658         if (NULL != client->state_changed_cb) {
 659                 tts_client_use_callback(client);
 660                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 661                 tts_client_not_use_callback(client);
 662                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 663         }
 664
 665         /* Close file message connection */
 666         if (0 == tts_client_get_mode_client_count(client->mode)) {
 667                 SLOG(LOG_DEBUG, TAG_TTSC, "Close file msg connection : mode(%d)", client->mode);
 668                 ret = tts_file_msg_close_connection(client->mode);
 669                 if (0 != ret)
 670                         SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to close file message connection");
 671         }
 672
 673         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 674         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 675
 676         return TTS_ERROR_NONE;
 677 }
 678
 679 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 680 {
 681         tts_h tts = (tts_h)user_data;
 682
 683         tts_client_s* client = tts_client_get(tts);
 684         if (NULL == client) {
 685                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 686                 return false;
 687         }
 688
 689         /* call callback function */
 690         if (NULL != client->supported_voice_cb) {
 691                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 692         } else {
 693                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 694         }
 695
 696         return false;
 697 }
 698
 699 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 700 {
 701         bool tts_supported = false;
 702         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 703                 if (false == tts_supported) {
 704                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 705                         return TTS_ERROR_NOT_SUPPORTED;
 706                 }
 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         bool tts_supported = false;
 761         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 762                 if (false == tts_supported) {
 763                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 764                         return TTS_ERROR_NOT_SUPPORTED;
 765                 }
 766         }
 767
 768         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 769
 770         if (NULL == tts) {
 771                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 772                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 773                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 774                 return TTS_ERROR_INVALID_PARAMETER;
 775
 776         }
 777         tts_client_s* client = tts_client_get(tts);
 778
 779         if (NULL == client) {
 780                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 781                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 782                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 783                 return TTS_ERROR_INVALID_PARAMETER;
 784         }
 785
 786         /* Request call remote method */
 787         int ret = 0;
 788         ret = tts_config_mgr_get_voice(lang, vctype);
 789         if (0 != ret) {
 790                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 791                 return __tts_convert_config_error_code(ret);
 792         } else {
 793                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 794         }
 795
 796         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 797         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 798
 799         return ret;
 800 }
 801
 802 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 803 {
 804         bool tts_supported = false;
 805         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 806                 if (false == tts_supported) {
 807                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 808                         return TTS_ERROR_NOT_SUPPORTED;
 809                 }
 810         }
 811
 812         if (NULL == tts || NULL == size) {
 813                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 814                 return TTS_ERROR_INVALID_PARAMETER;
 815         }
 816
 817         tts_client_s* client = tts_client_get(tts);
 818
 819         if (NULL == client) {
 820                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 821                 return TTS_ERROR_INVALID_PARAMETER;
 822         }
 823
 824         if (TTS_STATE_READY != client->current_state) {
 825                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 826                 return TTS_ERROR_INVALID_STATE;
 827         }
 828
 829         *size = TTS_MAX_TEXT_SIZE;
 830
 831         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 832         return TTS_ERROR_NONE;
 833 }
 834
 835 int tts_get_state(tts_h tts, tts_state_e* state)
 836 {
 837         bool tts_supported = false;
 838         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 839                 if (false == tts_supported) {
 840                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 841                         return TTS_ERROR_NOT_SUPPORTED;
 842                 }
 843         }
 844
 845         if (NULL == tts || NULL == state) {
 846                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 847                 return TTS_ERROR_INVALID_PARAMETER;
 848         }
 849
 850         tts_client_s* client = tts_client_get(tts);
 851
 852         if (NULL == client) {
 853                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 854                 return TTS_ERROR_INVALID_PARAMETER;
 855         }
 856
 857         *state = client->current_state;
 858
 859         switch(*state) {
 860                 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 861                 case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 862                 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 863                 case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 864                 default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 865         }
 866
 867         return TTS_ERROR_NONE;
 868 }
 869
 870 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 871 {
 872         bool tts_supported = false;
 873         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 874                 if (false == tts_supported) {
 875                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 876                         return TTS_ERROR_NOT_SUPPORTED;
 877                 }
 878         }
 879
 880         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 881                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 882                 return TTS_ERROR_INVALID_PARAMETER;
 883         }
 884
 885         tts_client_s* client = tts_client_get(tts);
 886
 887         if (NULL == client) {
 888                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 889                 return TTS_ERROR_INVALID_PARAMETER;
 890         }
 891
 892         *min = TTS_SPEED_MIN;
 893         *normal = TTS_SPEED_NORMAL;
 894         *max = TTS_SPEED_MAX;
 895
 896         return TTS_ERROR_NONE;
 897 }
 898
 899 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 900 {
 901         bool tts_supported = false;
 902         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
 903                 if (false == tts_supported) {
 904                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
 905                         return TTS_ERROR_NOT_SUPPORTED;
 906                 }
 907         }
 908
 909         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 910
 911         if (NULL == tts || NULL == utt_id) {
 912                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 913                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 914                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 915                 return TTS_ERROR_INVALID_PARAMETER;
 916         }
 917
 918         tts_client_s* client = tts_client_get(tts);
 919
 920         if (NULL == client) {
 921                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 922                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 923                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 924                 return TTS_ERROR_INVALID_PARAMETER;
 925         }
 926
 927         if (TTS_STATE_CREATED == client->current_state) {
 928                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 929                 return TTS_ERROR_INVALID_STATE;
 930         }
 931
 932         if (TTS_MAX_TEXT_SIZE < strlen(text)) {
 933                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is too big.");
 934                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 935                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 936                 return TTS_ERROR_INVALID_PARAMETER;
 937         }
 938
 939         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 940                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 941                 return TTS_ERROR_INVALID_STATE;
 942         }
 943
 944         /* check valid utf8 */
 945         iconv_t *ict;
 946         ict = iconv_open("utf-8", "");
 947         if ((iconv_t)-1 == ict) {
 948                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
 949                 return TTS_ERROR_OPERATION_FAILED;
 950         }
 951
 952         size_t len = strlen(text);
 953         char *in_tmp = NULL;
 954         char in_buf[TTS_MAX_TEXT_SIZE];
 955         char *out_tmp = NULL;
 956         char out_buf[TTS_MAX_TEXT_SIZE];
 957         size_t len_tmp = sizeof(out_buf);
 958
 959         memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
 960         snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
 961         in_tmp = in_buf;
 962
 963         memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
 964         out_tmp = out_buf;
 965
 966         size_t st;
 967         st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
 968         if ((size_t)-1 == st) {
 969                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
 970                 iconv_close(ict);
 971                 return TTS_ERROR_INVALID_PARAMETER;
 972         }
 973         iconv_close(ict);
 974         SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
 975
 976         /* change default language value */
 977         char* temp = NULL;
 978
 979         if (NULL == language)
 980                 temp = strdup("default");
 981         else
 982                 temp = strdup(language);
 983
 984         client->current_utt_id ++;
 985         if (client->current_utt_id == 10000) {
 986                 client->current_utt_id = 1;
 987         }
 988
 989         /* do request */
 990         int ret = -1;
 991         int count = 0;
 992         while (0 != ret) {
 993                 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id);
 994                 if (0 != ret) {
 995                         if (TTS_ERROR_TIMED_OUT != ret) {
 996                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 997                                 break;
 998                         } else {
 999                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
1000                                 usleep(10);
1001                                 count++;
1002                                 if (10 == count) {
1003                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1004                                         break;
1005                                 }
1006                         }
1007                 } else {
1008                         *utt_id = client->current_utt_id;
1009                 }
1010         }
1011
1012         if (NULL != temp)       free(temp);
1013
1014         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1015         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1016
1017         return ret;
1018 }
1019
1020 int tts_play(tts_h tts)
1021 {
1022         bool tts_supported = false;
1023         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1024                 if (false == tts_supported) {
1025                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1026                         return TTS_ERROR_NOT_SUPPORTED;
1027                 }
1028         }
1029
1030         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
1031
1032         if (NULL == tts) {
1033                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
1034                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1035                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1036                 return TTS_ERROR_INVALID_PARAMETER;
1037         }
1038
1039         tts_client_s* client = tts_client_get(tts);
1040
1041         if (NULL == client) {
1042                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
1043                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1044                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1045                 return TTS_ERROR_INVALID_PARAMETER;
1046         }
1047
1048         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
1049                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
1050                 return TTS_ERROR_INVALID_STATE;
1051         }
1052
1053         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1054                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1055                 return TTS_ERROR_INVALID_STATE;
1056         }
1057
1058         int ret = -1;
1059         int count = 0;
1060         while (0 != ret) {
1061                 ret = tts_dbus_request_play(client->uid);
1062                 if (0 != ret) {
1063                         if (TTS_ERROR_TIMED_OUT != ret) {
1064                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1065                                 return ret;
1066                         } else {
1067                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
1068                                 usleep(10);
1069                                 count++;
1070                                 if (10 == count) {
1071                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1072                                         return ret;
1073                                 }
1074                         }
1075                 }
1076         }
1077
1078         client->before_state = client->current_state;
1079         client->current_state = TTS_STATE_PLAYING;
1080
1081         if (NULL != client->state_changed_cb) {
1082                 tts_client_use_callback(client);
1083                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1084                 tts_client_not_use_callback(client);
1085                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1086         }
1087
1088         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1089         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1090
1091         return TTS_ERROR_NONE;
1092 }
1093
1094
1095 int tts_stop(tts_h tts)
1096 {
1097         bool tts_supported = false;
1098         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1099                 if (false == tts_supported) {
1100                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1101                         return TTS_ERROR_NOT_SUPPORTED;
1102                 }
1103         }
1104
1105         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
1106
1107         if (NULL == tts) {
1108                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1109                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1110                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1111                 return TTS_ERROR_INVALID_PARAMETER;
1112         }
1113
1114         tts_client_s* client = tts_client_get(tts);
1115
1116         if (NULL == client) {
1117                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1118                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1119                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1120                 return TTS_ERROR_INVALID_PARAMETER;
1121         }
1122
1123         if (TTS_STATE_CREATED == client->current_state) {
1124                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
1125                 return TTS_ERROR_INVALID_STATE;
1126         }
1127
1128         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1129                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1130                 return TTS_ERROR_INVALID_STATE;
1131         }
1132
1133         int ret = -1;
1134         int count = 0;
1135         while (0 != ret) {
1136                 ret = tts_dbus_request_stop(client->uid);
1137                 if (0 != ret) {
1138                         if (TTS_ERROR_TIMED_OUT != ret) {
1139                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1140                                 return ret;
1141                         } else {
1142                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
1143                                 usleep(10);
1144                                 count++;
1145                                 if (10 == count) {
1146                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1147                                         return ret;
1148                                 }
1149                         }
1150                 }
1151         }
1152
1153         client->before_state = client->current_state;
1154         client->current_state = TTS_STATE_READY;
1155
1156         if (NULL != client->state_changed_cb) {
1157                 tts_client_use_callback(client);
1158                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1159                 tts_client_not_use_callback(client);
1160                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1161         }
1162
1163         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1164         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1165
1166         return TTS_ERROR_NONE;
1167 }
1168
1169
1170 int tts_pause(tts_h tts)
1171 {
1172         bool tts_supported = false;
1173         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1174                 if (false == tts_supported) {
1175                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1176                         return TTS_ERROR_NOT_SUPPORTED;
1177                 }
1178         }
1179
1180         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1181
1182         if (NULL == tts) {
1183                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1184                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1185                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1186                 return TTS_ERROR_INVALID_PARAMETER;
1187         }
1188
1189         tts_client_s* client = tts_client_get(tts);
1190
1191         if (NULL == client) {
1192                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1193                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1194                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1195                 return TTS_ERROR_INVALID_PARAMETER;
1196         }
1197
1198         if (TTS_STATE_PLAYING != client->current_state) {
1199                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1200                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1201                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1202                 return TTS_ERROR_INVALID_STATE;
1203         }
1204
1205         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1206                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1207                 return TTS_ERROR_INVALID_STATE;
1208         }
1209
1210         int ret = -1;
1211         int count = 0;
1212         while (0 != ret) {
1213                 ret = tts_dbus_request_pause(client->uid);
1214                 if (0 != ret) {
1215                         if (TTS_ERROR_TIMED_OUT != ret) {
1216                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1217                                 return ret;
1218                         } else {
1219                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1220                                 usleep(10);
1221                                 count++;
1222                                 if (10 == count) {
1223                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1224                                         return ret;
1225                                 }
1226                         }
1227                 }
1228         }
1229
1230         client->before_state = client->current_state;
1231         client->current_state = TTS_STATE_PAUSED;
1232
1233         if (NULL != client->state_changed_cb) {
1234                 tts_client_use_callback(client);
1235                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1236                 tts_client_not_use_callback(client);
1237                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1238         }
1239
1240         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1241         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1242
1243         return TTS_ERROR_NONE;
1244 }
1245
1246 static Eina_Bool __tts_notify_error(void *data)
1247 {
1248         tts_h tts = (tts_h)data;
1249
1250         tts_client_s* client = tts_client_get(tts);
1251
1252         /* check handle */
1253         if (NULL == client) {
1254                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1255                 return EINA_FALSE;
1256         }
1257
1258         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1259
1260         if (NULL != client->error_cb) {
1261                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1262                 tts_client_use_callback(client);
1263                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data );
1264                 tts_client_not_use_callback(client);
1265         } else {
1266                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1267         }
1268
1269         return EINA_FALSE;
1270 }
1271
1272 int __tts_cb_error(int uid, tts_error_e reason, int utt_id)
1273 {
1274         tts_client_s* client = tts_client_get_by_uid(uid);
1275
1276         if (NULL == client) {
1277                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1278                 return TTS_ERROR_INVALID_PARAMETER;
1279         }
1280
1281         client->utt_id = utt_id;
1282         client->reason = reason;
1283
1284         /* call callback function */
1285         if (NULL != client->error_cb) {
1286                 ecore_timer_add(0, __tts_notify_error, client->tts);
1287         } else {
1288                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1289         }
1290
1291         return 0;
1292 }
1293
1294 static Eina_Bool __tts_notify_state_changed(void *data)
1295 {
1296         tts_h tts = (tts_h)data;
1297
1298         tts_client_s* client = tts_client_get(tts);
1299
1300         /* check handle */
1301         if (NULL == client) {
1302                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1303                 return EINA_FALSE;
1304         }
1305
1306         if (NULL != client->state_changed_cb) {
1307                 tts_client_use_callback(client);
1308                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1309                 tts_client_not_use_callback(client);
1310                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1311         } else {
1312                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1313         }
1314
1315         return EINA_FALSE;
1316 }
1317
1318 int __tts_cb_set_state(int uid, int state)
1319 {
1320         tts_client_s* client = tts_client_get_by_uid(uid);
1321         if( NULL == client ) {
1322                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1323                 return -1;
1324         }
1325
1326         tts_state_e state_from_daemon = (tts_state_e)state;
1327
1328         if (client->current_state == state_from_daemon) {
1329                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1330                 return 0;
1331         }
1332
1333         if (NULL != client->state_changed_cb) {
1334                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1335         } else {
1336                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1337         }
1338
1339         client->before_state = client->current_state;
1340         client->current_state = state_from_daemon;
1341
1342         return 0;
1343 }
1344
1345 static Eina_Bool __tts_notify_utt_started(void *data)
1346 {
1347         tts_h tts = (tts_h)data;
1348
1349         tts_client_s* client = tts_client_get(tts);
1350
1351         /* check handle */
1352         if (NULL == client) {
1353                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt started : A handle is not valid");
1354                 return EINA_FALSE;
1355         }
1356
1357         if (NULL != client->utt_started_cb) {
1358                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1359                 tts_client_use_callback(client);
1360                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1361                 tts_client_not_use_callback(client);
1362         } else {
1363                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1364         }
1365
1366         return EINA_FALSE;
1367 }
1368
1369 int __tts_cb_utt_started(int uid, int utt_id)
1370 {
1371         tts_client_s* client = tts_client_get_by_uid(uid);
1372
1373         if (NULL == client) {
1374                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1375                 return TTS_ERROR_INVALID_PARAMETER;
1376         }
1377
1378         SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1379
1380         client->utt_id = utt_id;
1381
1382         /* call callback function */
1383         if (NULL != client->utt_started_cb) {
1384                 ecore_timer_add(0, __tts_notify_utt_started, client->tts);
1385         } else {
1386                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1387         }
1388
1389         return 0;
1390 }
1391
1392 static Eina_Bool __tts_notify_utt_completed(void *data)
1393 {
1394         tts_h tts = (tts_h)data;
1395
1396         tts_client_s* client = tts_client_get(tts);
1397
1398         /* check handle */
1399         if (NULL == client) {
1400                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt completed : A handle is not valid");
1401                 return EINA_FALSE;
1402         }
1403
1404         if (NULL != client->utt_completeted_cb) {
1405                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1406                 tts_client_use_callback(client);
1407                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1408                 tts_client_not_use_callback(client);
1409         } else {
1410                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1411         }
1412
1413         return EINA_FALSE;
1414 }
1415
1416 int __tts_cb_utt_completed(int uid, int utt_id)
1417 {
1418         tts_client_s* client = tts_client_get_by_uid(uid);
1419
1420         if (NULL == client) {
1421                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1422                 return TTS_ERROR_INVALID_PARAMETER;
1423         }
1424
1425         SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1426
1427         client->utt_id = utt_id;
1428
1429         /* call callback function */
1430         if (NULL != client->utt_completeted_cb) {
1431                 ecore_timer_add(0, __tts_notify_utt_completed, client->tts);
1432         } else {
1433                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1434         }
1435
1436         return 0;
1437 }
1438
1439 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1440 {
1441         bool tts_supported = false;
1442         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1443                 if (false == tts_supported) {
1444                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1445                         return TTS_ERROR_NOT_SUPPORTED;
1446                 }
1447         }
1448
1449         if (NULL == tts || NULL == callback) {
1450                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1451                 return TTS_ERROR_INVALID_PARAMETER;
1452         }
1453
1454         tts_client_s* client = tts_client_get(tts);
1455
1456         if (NULL == client) {
1457                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1458                 return TTS_ERROR_INVALID_PARAMETER;
1459         }
1460
1461         if (TTS_STATE_CREATED != client->current_state) {
1462                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1463                 return TTS_ERROR_INVALID_STATE;
1464         }
1465
1466         client->state_changed_cb = callback;
1467         client->state_changed_user_data = user_data;
1468
1469         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1470
1471         return 0;
1472 }
1473
1474 int tts_unset_state_changed_cb(tts_h tts)
1475 {
1476         bool tts_supported = false;
1477         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1478                 if (false == tts_supported) {
1479                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1480                         return TTS_ERROR_NOT_SUPPORTED;
1481                 }
1482         }
1483
1484         if (NULL == tts) {
1485                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1486                 return TTS_ERROR_INVALID_PARAMETER;
1487         }
1488
1489         tts_client_s* client = tts_client_get(tts);
1490
1491         if (NULL == client) {
1492                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1493                 return TTS_ERROR_INVALID_PARAMETER;
1494         }
1495
1496         if (TTS_STATE_CREATED != client->current_state) {
1497                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1498                 return TTS_ERROR_INVALID_STATE;
1499         }
1500
1501         client->state_changed_cb = NULL;
1502         client->state_changed_user_data = NULL;
1503
1504         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1505
1506         return 0;
1507 }
1508
1509 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1510 {
1511         bool tts_supported = false;
1512         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1513                 if (false == tts_supported) {
1514                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1515                         return TTS_ERROR_NOT_SUPPORTED;
1516                 }
1517         }
1518
1519         if (NULL == tts || NULL == callback) {
1520                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1521                 return TTS_ERROR_INVALID_PARAMETER;
1522         }
1523
1524         tts_client_s* client = tts_client_get(tts);
1525
1526         if (NULL == client) {
1527                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1528                 return TTS_ERROR_INVALID_PARAMETER;
1529         }
1530
1531         if (TTS_STATE_CREATED != client->current_state) {
1532                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1533                 return TTS_ERROR_INVALID_STATE;
1534         }
1535
1536         client->utt_started_cb = callback;
1537         client->utt_started_user_data = user_data;
1538
1539         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1540
1541         return 0;
1542 }
1543
1544 int tts_unset_utterance_started_cb(tts_h tts)
1545 {
1546         bool tts_supported = false;
1547         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1548                 if (false == tts_supported) {
1549                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1550                         return TTS_ERROR_NOT_SUPPORTED;
1551                 }
1552         }
1553
1554         if (NULL == tts) {
1555                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1556                 return TTS_ERROR_INVALID_PARAMETER;
1557         }
1558
1559         tts_client_s* client = tts_client_get(tts);
1560
1561         if (NULL == client) {
1562                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1563                 return TTS_ERROR_INVALID_PARAMETER;
1564         }
1565
1566         if (TTS_STATE_CREATED != client->current_state) {
1567                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1568                 return TTS_ERROR_INVALID_STATE;
1569         }
1570
1571         client->utt_started_cb = NULL;
1572         client->utt_started_user_data = NULL;
1573
1574         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1575
1576         return 0;
1577 }
1578
1579 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1580 {
1581         bool tts_supported = false;
1582         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1583                 if (false == tts_supported) {
1584                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1585                         return TTS_ERROR_NOT_SUPPORTED;
1586                 }
1587         }
1588
1589         if (NULL == tts || NULL == callback) {
1590                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
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] Set utt completed cb : A handle is not valid");
1598                 return TTS_ERROR_INVALID_PARAMETER;
1599         }
1600
1601         if (TTS_STATE_CREATED != client->current_state) {
1602                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1603                 return TTS_ERROR_INVALID_STATE;
1604         }
1605
1606         client->utt_completeted_cb = callback;
1607         client->utt_completed_user_data = user_data;
1608
1609         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1610
1611         return 0;
1612 }
1613
1614 int tts_unset_utterance_completed_cb(tts_h tts)
1615 {
1616         bool tts_supported = false;
1617         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1618                 if (false == tts_supported) {
1619                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1620                         return TTS_ERROR_NOT_SUPPORTED;
1621                 }
1622         }
1623
1624         if (NULL == tts) {
1625                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1626                 return TTS_ERROR_INVALID_PARAMETER;
1627         }
1628
1629         tts_client_s* client = tts_client_get(tts);
1630
1631         if (NULL == client) {
1632                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1633                 return TTS_ERROR_INVALID_PARAMETER;
1634         }
1635
1636         if (TTS_STATE_CREATED != client->current_state) {
1637                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1638                 return TTS_ERROR_INVALID_STATE;
1639         }
1640
1641         client->utt_completeted_cb = NULL;
1642         client->utt_completed_user_data = NULL;
1643
1644         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1645         return 0;
1646 }
1647
1648 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1649 {
1650         bool tts_supported = false;
1651         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1652                 if (false == tts_supported) {
1653                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1654                         return TTS_ERROR_NOT_SUPPORTED;
1655                 }
1656         }
1657
1658         if (NULL == tts || NULL == callback) {
1659                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1660                 return TTS_ERROR_INVALID_PARAMETER;
1661         }
1662
1663         tts_client_s* client = tts_client_get(tts);
1664
1665         if (NULL == client) {
1666                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1667                 return TTS_ERROR_INVALID_PARAMETER;
1668         }
1669
1670         if (TTS_STATE_CREATED != client->current_state) {
1671                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1672                 return TTS_ERROR_INVALID_STATE;
1673         }
1674
1675         client->error_cb = callback;
1676         client->error_user_data = user_data;
1677
1678         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1679
1680         return 0;
1681 }
1682
1683 int tts_unset_error_cb(tts_h tts)
1684 {
1685         bool tts_supported = false;
1686         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1687                 if (false == tts_supported) {
1688                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1689                         return TTS_ERROR_NOT_SUPPORTED;
1690                 }
1691         }
1692
1693         if (NULL == tts) {
1694                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1695                 return TTS_ERROR_INVALID_PARAMETER;
1696         }
1697
1698         tts_client_s* client = tts_client_get(tts);
1699
1700         if (NULL == client) {
1701                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1702                 return TTS_ERROR_INVALID_PARAMETER;
1703         }
1704
1705         if (TTS_STATE_CREATED != client->current_state) {
1706                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1707                 return TTS_ERROR_INVALID_STATE;
1708         }
1709
1710         client->error_cb = NULL;
1711         client->error_user_data = NULL;
1712
1713         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1714
1715         return 0;
1716 }
1717
1718 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1719 {
1720         bool tts_supported = false;
1721         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1722                 if (false == tts_supported) {
1723                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1724                         return TTS_ERROR_NOT_SUPPORTED;
1725                 }
1726         }
1727
1728         if (NULL == tts || NULL == callback) {
1729                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
1730                 return TTS_ERROR_INVALID_PARAMETER;
1731         }
1732
1733         tts_client_s* client = tts_client_get(tts);
1734
1735         if (NULL == client) {
1736                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
1737                 return TTS_ERROR_INVALID_PARAMETER;
1738         }
1739
1740         if (TTS_STATE_CREATED != client->current_state) {
1741                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
1742                 return TTS_ERROR_INVALID_STATE;
1743         }
1744
1745         client->default_voice_changed_cb = callback;
1746         client->default_voice_changed_user_data = user_data;
1747
1748         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
1749
1750         return 0;
1751 }
1752
1753 int tts_unset_default_voice_changed_cb(tts_h tts)
1754 {
1755         bool tts_supported = false;
1756         if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
1757                 if (false == tts_supported) {
1758                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS NOT supported");
1759                         return TTS_ERROR_NOT_SUPPORTED;
1760                 }
1761         }
1762
1763         if (NULL == tts) {
1764                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
1765                 return TTS_ERROR_INVALID_PARAMETER;
1766         }
1767
1768         tts_client_s* client = tts_client_get(tts);
1769
1770         if (NULL == client) {
1771                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
1772                 return TTS_ERROR_INVALID_PARAMETER;
1773         }
1774
1775         if (TTS_STATE_CREATED != client->current_state) {
1776                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
1777                 return TTS_ERROR_INVALID_STATE;
1778         }
1779
1780         client->default_voice_changed_cb = NULL;
1781         client->default_voice_changed_user_data = NULL;
1782
1783         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
1784
1785         return 0;
1786 }