client/tts.c

   1 /*
   2 *  Copyright (c) 2012, 2013 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
  15 #include <sys/wait.h>
  16 #include <Ecore.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <dirent.h>
  20
  21 #include "tts_main.h"
  22 #include "tts_client.h"
  23 #include "tts_dbus.h"
  24
  25 #define MAX_TEXT_COUNT 2000
  26
  27 static bool g_is_daemon_started = false;
  28
  29 static bool g_is_noti_daemon_started = false;
  30
  31 static bool g_is_sr_daemon_started = false;
  32
  33 static Ecore_Timer* g_connect_timer = NULL;
  34
  35 /* Function definition */
  36 static int __tts_check_tts_daemon(tts_mode_e mode);
  37 static Eina_Bool __tts_notify_state_changed(void *data);
  38 static Eina_Bool __tts_notify_error(void *data);
  39
  40 int tts_create(tts_h* tts)
  41 {
  42         SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
  43
  44         /* check param */
  45         if (NULL == tts) {
  46                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
  47                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  48                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  49                 return TTS_ERROR_INVALID_PARAMETER;
  50         }
  51
  52         if (0 == tts_client_get_size()) {
  53                 if (0 != tts_dbus_open_connection()) {
  54                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
  55                         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  56                         SLOG(LOG_DEBUG, TAG_TTSC, " ");
  57                         return TTS_ERROR_OPERATION_FAILED;
  58                 }
  59         }
  60
  61         if (0 != tts_client_new(tts)) {
  62                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
  63                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  64                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  65                 return TTS_ERROR_OUT_OF_MEMORY;
  66         }
  67
  68         g_is_daemon_started = false;
  69         g_is_noti_daemon_started = false;
  70         g_is_sr_daemon_started = false;
  71
  72         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  73         SLOG(LOG_DEBUG, TAG_TTSC, " ");
  74
  75         return TTS_ERROR_NONE;
  76 }
  77
  78 int tts_destroy(tts_h tts)
  79 {
  80         SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
  81
  82         if (NULL == tts) {
  83                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
  84                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  85                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  86                 return TTS_ERROR_INVALID_PARAMETER;
  87         }
  88
  89         tts_client_s* client = tts_client_get(tts);
  90
  91         /* check handle */
  92         if (NULL == client) {
  93                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
  94                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  95                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  96                 return TTS_ERROR_INVALID_PARAMETER;
  97         }
  98
  99         /* check used callback */
 100         if (0 != tts_client_get_use_callback(client)) {
 101                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 102                 return TTS_ERROR_OPERATION_FAILED;
 103         }
 104
 105         int ret = -1;
 106
 107         /* check state */
 108         switch (client->current_state) {
 109         case TTS_STATE_PAUSED:
 110         case TTS_STATE_PLAYING:
 111         case TTS_STATE_READY:
 112                 /* Request Finalize */
 113                 ret = tts_dbus_request_finalize(client->uid);
 114                 if (0 != ret) {
 115                         SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to request finalize");
 116                 }
 117
 118                 if (TTS_MODE_SCREEN_READER == client->mode)
 119                         g_is_sr_daemon_started = false;
 120                 else if (TTS_MODE_NOTIFICATION == client->mode)
 121                         g_is_noti_daemon_started = false;
 122                 else
 123                         g_is_daemon_started = false;
 124
 125                 client->before_state = client->current_state;
 126                 client->current_state = TTS_STATE_CREATED;
 127
 128                 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
 129
 130                 /* Close file message connection */
 131                 if (0 == tts_client_get_connected_client_count()) {
 132                         SLOG(LOG_DEBUG, TAG_TTSC, "Close file msg connection");
 133                         ret = tts_file_msg_close_connection();
 134                         if (0 != ret)
 135                                 SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to close file message connection");
 136                 }
 137
 138         case TTS_STATE_CREATED:
 139                 if (NULL != g_connect_timer) {
 140                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 141                         ecore_timer_del(g_connect_timer);
 142                 }
 143                 /* Free resources */
 144                 tts_client_destroy(tts);
 145                 break;
 146         }
 147
 148         if (0 == tts_client_get_size()) {
 149                 if (0 != tts_dbus_close_connection()) {
 150                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 151                 }
 152         }
 153
 154         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 155         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 156
 157         return TTS_ERROR_NONE;
 158 }
 159
 160 int tts_set_mode(tts_h tts, tts_mode_e mode)
 161 {
 162         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
 163
 164         tts_client_s* client = tts_client_get(tts);
 165
 166         /* check handle */
 167         if (NULL == client) {
 168                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 169                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 170                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 171                 return TTS_ERROR_INVALID_PARAMETER;
 172         }
 173
 174         /* check state */
 175         if (client->current_state != TTS_STATE_CREATED) {
 176                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 177                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 178                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 179                 return TTS_ERROR_INVALID_STATE;
 180         }
 181
 182         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
 183                 client->mode = mode;
 184         } else {
 185                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 186                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 187                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 188                 return TTS_ERROR_INVALID_PARAMETER;
 189         }
 190
 191         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 192         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 193
 194         return TTS_ERROR_NONE;
 195 }
 196
 197 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 198 {
 199         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
 200
 201         tts_client_s* client = tts_client_get(tts);
 202
 203         /* check handle */
 204         if (NULL == client) {
 205                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 206                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 207                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 208                 return TTS_ERROR_INVALID_PARAMETER;
 209         }
 210
 211         /* check state */
 212         if (client->current_state != TTS_STATE_CREATED) {
 213                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 214                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 215                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 216                 return TTS_ERROR_INVALID_STATE;
 217         }
 218
 219         if (NULL == mode) {
 220                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 221                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 222                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 223                 return TTS_ERROR_INVALID_PARAMETER;
 224         }
 225
 226         *mode = client->mode;
 227
 228         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 229         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 230
 231         return TTS_ERROR_NONE;
 232 }
 233
 234 static Eina_Bool __tts_connect_daemon(void *data)
 235 {
 236         tts_h tts = (tts_h)data;
 237
 238         tts_client_s* client = tts_client_get(tts);
 239
 240         /* check handle */
 241         if (NULL == client) {
 242                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 243                 return EINA_FALSE;
 244         }
 245
 246         /* Send hello */
 247         if (0 != tts_dbus_request_hello(client->uid)) {
 248                 if (TTS_MODE_SCREEN_READER == client->mode) {
 249                         if (false == g_is_sr_daemon_started) {
 250                                 g_is_sr_daemon_started = true;
 251                                 __tts_check_tts_daemon(client->mode);
 252                         }
 253                 } else if (TTS_MODE_NOTIFICATION == client->mode) {
 254                         if (false == g_is_noti_daemon_started) {
 255                                 g_is_noti_daemon_started = true;
 256                                 __tts_check_tts_daemon(client->mode);
 257                         }
 258                 } else {
 259                         if (false == g_is_daemon_started) {
 260                                 g_is_daemon_started = true;
 261                                 __tts_check_tts_daemon(client->mode);
 262                         }
 263                 }
 264
 265                 return EINA_TRUE;
 266         }
 267
 268         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
 269
 270         /* do request initialize */
 271         int ret = -1;
 272
 273         ret = tts_dbus_request_initialize(client->uid);
 274
 275         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 276                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found");
 277
 278                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 279                 client->utt_id = -1;
 280
 281                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 282                 return EINA_FALSE;
 283
 284         } else if (TTS_ERROR_NONE != ret) {
 285                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection");
 286
 287                 client->reason = TTS_ERROR_TIMED_OUT;
 288                 client->utt_id = -1;
 289
 290                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 291                 return EINA_FALSE;
 292         } else {
 293                 /* success to connect tts-daemon */
 294         }
 295
 296         if (0 == tts_client_get_connected_client_count()) {
 297                 SLOG(LOG_DEBUG, TAG_TTSC, "Open file msg connection");
 298                 ret = tts_file_msg_open_connection();
 299                 if (0 != ret) {
 300                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open file message connection");
 301                         ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 302                         return EINA_FALSE;
 303                 }
 304         }
 305
 306         client->before_state = client->current_state;
 307         client->current_state = TTS_STATE_READY;
 308
 309         ecore_timer_add(0, __tts_notify_state_changed, (void*)client->tts);
 310
 311         g_connect_timer = NULL;
 312
 313         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] uid(%d)", client->uid);
 314
 315         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 316         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 317
 318         return EINA_FALSE;
 319 }
 320
 321 int tts_prepare(tts_h tts)
 322 {
 323         SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
 324
 325         tts_client_s* client = tts_client_get(tts);
 326
 327         /* check handle */
 328         if (NULL == client) {
 329                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 330                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 331                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 332                 return TTS_ERROR_INVALID_PARAMETER;
 333         }
 334
 335         /* check state */
 336         if (client->current_state != TTS_STATE_CREATED) {
 337                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 338                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 339                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 340                 return TTS_ERROR_INVALID_STATE;
 341         }
 342
 343         g_connect_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 344
 345         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 346         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 347
 348         return TTS_ERROR_NONE;
 349 }
 350
 351 int tts_unprepare(tts_h tts)
 352 {
 353         SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
 354
 355         tts_client_s* client = tts_client_get(tts);
 356
 357         /* check handle */
 358         if (NULL == client) {
 359                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 360                 return TTS_ERROR_INVALID_PARAMETER;
 361         }
 362
 363         /* check state */
 364         if (client->current_state != TTS_STATE_READY) {
 365                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 366                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 367                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 368                 return TTS_ERROR_INVALID_STATE;
 369         }
 370
 371         int ret;
 372
 373         ret = tts_dbus_request_finalize(client->uid);
 374         if (0 != ret) {
 375                 SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to request finalize");
 376         }
 377
 378         if (TTS_MODE_SCREEN_READER == client->mode)
 379                 g_is_sr_daemon_started = false;
 380         else if (TTS_MODE_NOTIFICATION == client->mode)
 381                 g_is_noti_daemon_started = false;
 382         else
 383                 g_is_daemon_started = false;
 384
 385         client->before_state = client->current_state;
 386         client->current_state = TTS_STATE_CREATED;
 387
 388         ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
 389
 390         /* Close file message connection */
 391         if (0 == tts_client_get_connected_client_count()) {
 392                 SLOG(LOG_DEBUG, TAG_TTSC, "Close file msg connection");
 393                 ret = tts_file_msg_close_connection();
 394                 if (0 != ret)
 395                         SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to close file message connection");
 396         }
 397
 398         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 399         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 400
 401         return TTS_ERROR_NONE;
 402 }
 403
 404 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 405 {
 406         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 407
 408         if (NULL == tts || NULL == callback) {
 409                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 410                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 411                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 412                 return TTS_ERROR_INVALID_PARAMETER;
 413         }
 414
 415         tts_client_s* client = tts_client_get(tts);
 416
 417         /* check handle */
 418         if (NULL == client) {
 419                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 420                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 421                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 422                 return TTS_ERROR_INVALID_PARAMETER;
 423         }
 424
 425         if (TTS_STATE_READY != client->current_state) {
 426                 SLOG(LOG_ERROR, TAG_TTSC, "Current state is NOT 'READY'.");
 427                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 428                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 429                 return TTS_ERROR_INVALID_STATE;
 430         }
 431
 432         int ret = 0;
 433         ret = tts_dbus_request_get_support_voice(client->uid, client->tts, callback, user_data);
 434         if (0 != ret) {
 435                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 436         }
 437
 438         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 439         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 440
 441         return ret;
 442 }
 443
 444 int tts_get_default_voice(tts_h tts, char** lang, tts_voice_type_e* vctype)
 445 {
 446         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 447
 448         if (NULL == tts) {
 449                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 450                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 451                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 452                 return TTS_ERROR_INVALID_PARAMETER;
 453
 454         }
 455         tts_client_s* client = tts_client_get(tts);
 456
 457         if (NULL == client) {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 459                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 460                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 461                 return TTS_ERROR_INVALID_PARAMETER;
 462         }
 463
 464         if (TTS_STATE_READY != client->current_state) {
 465                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is NOT 'READY'. ");
 466                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 467                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 468                 return TTS_ERROR_INVALID_STATE;
 469         }
 470
 471         /* Request call remote method */
 472         int ret = 0;
 473         ret = tts_dbus_request_get_default_voice(client->uid, lang, vctype );
 474
 475         if (0 != ret) {
 476                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 477         }
 478
 479         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 480         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 481
 482         return ret;
 483 }
 484
 485 int tts_get_max_text_count(tts_h tts, int* count)
 486 {
 487         if (NULL == tts || NULL == count) {
 488                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 489                 return TTS_ERROR_INVALID_PARAMETER;
 490         }
 491
 492         tts_client_s* client = tts_client_get(tts);
 493
 494         if (NULL == client) {
 495                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 496                 return TTS_ERROR_INVALID_PARAMETER;
 497         }
 498
 499         if (TTS_STATE_READY != client->current_state) {
 500                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 501                 return TTS_ERROR_INVALID_STATE;
 502         }
 503
 504         *count = MAX_TEXT_COUNT;
 505
 506         SLOG(LOG_DEBUG, TAG_TTSC, "[Suceess] Get max text count");
 507         return TTS_ERROR_NONE;
 508 }
 509
 510 int tts_get_state(tts_h tts, tts_state_e* state)
 511 {
 512         if (NULL == tts || NULL == state) {
 513                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 514                 return TTS_ERROR_INVALID_PARAMETER;
 515         }
 516
 517         tts_client_s* client = tts_client_get(tts);
 518
 519         if (NULL == client) {
 520                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 521                 return TTS_ERROR_INVALID_PARAMETER;
 522         }
 523
 524         *state = client->current_state;
 525
 526         switch(*state) {
 527                 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 528                 case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 529                 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 530                 case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 531         }
 532
 533         return TTS_ERROR_NONE;
 534 }
 535
 536 int tts_add_text(tts_h tts, const char* text, const char* language, tts_voice_type_e voice_type, tts_speed_e speed, int* utt_id)
 537 {
 538         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 539
 540         if (NULL == tts || NULL == utt_id) {
 541                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 542                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 543                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 544                 return TTS_ERROR_INVALID_PARAMETER;
 545         }
 546
 547         tts_client_s* client = tts_client_get(tts);
 548
 549         if (NULL == client) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 551                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 552                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 553                 return TTS_ERROR_INVALID_PARAMETER;
 554         }
 555
 556         if (TTS_STATE_CREATED == client->current_state) {
 557                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 558                 return TTS_ERROR_INVALID_STATE;
 559         }
 560
 561         if (MAX_TEXT_COUNT < strlen(text)) {
 562                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is too big.");
 563                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 564                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 565                 return TTS_ERROR_INVALID_PARAMETER;
 566         }
 567
 568         /* change default language value */
 569         char* temp = NULL;
 570
 571         if (NULL == language)
 572                 temp = strdup("default");
 573         else
 574                 temp = strdup(language);
 575
 576         client->current_utt_id ++;
 577         if (client->current_utt_id == 10000) {
 578                 client->current_utt_id = 1;
 579         }
 580
 581         /* do request */
 582         int ret = 0;
 583         ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id);
 584         if (0 != ret) {
 585                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 586         } else {
 587                 *utt_id = client->current_utt_id;
 588         }
 589
 590         if (NULL != temp)
 591                 free(temp);
 592
 593         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 594         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 595
 596         return ret;
 597 }
 598
 599 int tts_play(tts_h tts)
 600 {
 601         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
 602
 603         if (NULL == tts) {
 604                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
 605                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 606                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 607                 return TTS_ERROR_INVALID_PARAMETER;
 608         }
 609
 610         tts_client_s* client = tts_client_get(tts);
 611
 612         if (NULL == client) {
 613                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
 614                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 615                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 616                 return TTS_ERROR_INVALID_PARAMETER;
 617         }
 618
 619         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
 620                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
 621                 return TTS_ERROR_INVALID_STATE;
 622         }
 623
 624         int ret = 0;
 625         ret = tts_dbus_request_play(client->uid);
 626         if (0 != ret) {
 627                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request play : result(%d)", ret);
 628                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 629                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 630                 return ret;
 631         }
 632
 633         client->before_state = client->current_state;
 634         client->current_state = TTS_STATE_PLAYING;
 635
 636         if (NULL != client->state_changed_cb) {
 637                 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
 638         } else {
 639                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 640         }
 641
 642         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 643         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 644
 645         return TTS_ERROR_NONE;
 646 }
 647
 648
 649 int tts_stop(tts_h tts)
 650 {
 651         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
 652
 653         if (NULL == tts) {
 654                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 655                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 656                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 657                 return TTS_ERROR_INVALID_PARAMETER;
 658         }
 659
 660         tts_client_s* client = tts_client_get(tts);
 661
 662         if (NULL == client) {
 663                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 664                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 665                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 666                 return TTS_ERROR_INVALID_PARAMETER;
 667         }
 668
 669         if (TTS_STATE_CREATED == client->current_state) {
 670                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 671                 return TTS_ERROR_INVALID_STATE;
 672         }
 673
 674         int ret = 0;
 675         ret = tts_dbus_request_stop(client->uid);
 676         if (0 != ret) {
 677                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 678                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 679                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 680                 return ret;
 681         }
 682
 683         client->before_state = client->current_state;
 684         client->current_state = TTS_STATE_READY;
 685
 686         if (NULL != client->state_changed_cb) {
 687                 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
 688         } else {
 689                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 690         }
 691
 692         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 693         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 694
 695         return TTS_ERROR_NONE;
 696 }
 697
 698
 699 int tts_pause(tts_h tts)
 700 {
 701         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
 702
 703         if (NULL == tts) {
 704                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 705                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 706                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 707                 return TTS_ERROR_INVALID_PARAMETER;
 708         }
 709
 710         tts_client_s* client = tts_client_get(tts);
 711
 712         if (NULL == client) {
 713                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 714                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 715                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 716                 return TTS_ERROR_INVALID_PARAMETER;
 717         }
 718
 719         if (TTS_STATE_PLAYING != client->current_state) {
 720                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
 721                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 722                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 723                 return TTS_ERROR_INVALID_STATE;
 724         }
 725
 726         int ret = 0;
 727         ret = tts_dbus_request_pause(client->uid);
 728         if (0 != ret) {
 729                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request pause : result(%d)", ret);
 730                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 731                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 732                 return ret;
 733         }
 734
 735         client->before_state = client->current_state;
 736         client->current_state = TTS_STATE_PAUSED;
 737
 738         if (NULL != client->state_changed_cb) {
 739                 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
 740         } else {
 741                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 742         }
 743
 744         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 745         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 746
 747         return TTS_ERROR_NONE;
 748 }
 749
 750 static Eina_Bool __tts_notify_error(void *data)
 751 {
 752         tts_h tts = (tts_h)data;
 753
 754         tts_client_s* client = tts_client_get(tts);
 755
 756         /* check handle */
 757         if (NULL == client) {
 758                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
 759                 return EINA_FALSE;
 760         }
 761
 762         if (NULL != client->error_cb) {
 763                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
 764                 tts_client_use_callback(client);
 765                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data );
 766                 tts_client_not_use_callback(client);
 767         } else {
 768                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
 769         }
 770
 771         return EINA_FALSE;
 772 }
 773
 774 int __tts_cb_error(int uid, tts_error_e reason, int utt_id)
 775 {
 776         tts_client_s* client = tts_client_get_by_uid(uid);
 777
 778         if (NULL == client) {
 779                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
 780                 return TTS_ERROR_INVALID_PARAMETER;
 781         }
 782
 783         client->utt_id = utt_id;
 784         client->reason = reason;
 785
 786         /* call callback function */
 787         if (NULL != client->error_cb) {
 788                 ecore_timer_add(0, __tts_notify_error, client->tts);
 789         } else {
 790                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
 791         }
 792
 793         return 0;
 794 }
 795
 796 static Eina_Bool __tts_notify_state_changed(void *data)
 797 {
 798         tts_h tts = (tts_h)data;
 799
 800         tts_client_s* client = tts_client_get(tts);
 801
 802         /* check handle */
 803         if (NULL == client) {
 804                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
 805                 return EINA_FALSE;
 806         }
 807
 808         if (NULL != client->state_changed_cb) {
 809                 tts_client_use_callback(client);
 810                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 811                 tts_client_not_use_callback(client);
 812                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 813         } else {
 814                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 815         }
 816
 817         return EINA_FALSE;
 818 }
 819
 820 int __tts_cb_set_state(int uid, int state)
 821 {
 822         tts_client_s* client = tts_client_get_by_uid(uid);
 823         if( NULL == client ) {
 824                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
 825                 return -1;
 826         }
 827
 828         tts_state_e state_from_daemon = (tts_state_e)state;
 829
 830         if (client->current_state == state_from_daemon) {
 831                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
 832                 return 0;
 833         }
 834
 835         if (NULL != client->state_changed_cb) {
 836                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
 837         } else {
 838                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
 839         }
 840
 841         client->before_state = client->current_state;
 842         client->current_state = state_from_daemon;
 843
 844         return 0;
 845 }
 846
 847 static Eina_Bool __tts_notify_utt_started(void *data)
 848 {
 849         tts_h tts = (tts_h)data;
 850
 851         tts_client_s* client = tts_client_get(tts);
 852
 853         /* check handle */
 854         if (NULL == client) {
 855                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt started : A handle is not valid");
 856                 return EINA_FALSE;
 857         }
 858
 859         if (NULL != client->utt_started_cb) {
 860                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
 861                 tts_client_use_callback(client);
 862                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
 863                 tts_client_not_use_callback(client);
 864         } else {
 865                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
 866         }
 867
 868         return EINA_FALSE;
 869 }
 870
 871 int __tts_cb_utt_started(int uid, int utt_id)
 872 {
 873         tts_client_s* client = tts_client_get_by_uid(uid);
 874
 875         if (NULL == client) {
 876                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
 877                 return TTS_ERROR_INVALID_PARAMETER;
 878         }
 879
 880         SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
 881
 882         client->utt_id = utt_id;
 883
 884         /* call callback function */
 885         if (NULL != client->utt_started_cb) {
 886                 ecore_timer_add(0, __tts_notify_utt_started, client->tts);
 887         } else {
 888                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
 889         }
 890
 891         return 0;
 892 }
 893
 894 static Eina_Bool __tts_notify_utt_completed(void *data)
 895 {
 896         tts_h tts = (tts_h)data;
 897
 898         tts_client_s* client = tts_client_get(tts);
 899
 900         /* check handle */
 901         if (NULL == client) {
 902                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt completed : A handle is not valid");
 903                 return EINA_FALSE;
 904         }
 905
 906         if (NULL != client->utt_completeted_cb) {
 907                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
 908                 tts_client_use_callback(client);
 909                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
 910                 tts_client_not_use_callback(client);
 911         } else {
 912                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
 913         }
 914
 915         return EINA_FALSE;
 916 }
 917
 918 int __tts_cb_utt_completed(int uid, int utt_id)
 919 {
 920         tts_client_s* client = tts_client_get_by_uid(uid);
 921
 922         if (NULL == client) {
 923                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
 924                 return TTS_ERROR_INVALID_PARAMETER;
 925         }
 926
 927         SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
 928
 929         client->utt_id = utt_id;
 930
 931         /* call callback function */
 932         if (NULL != client->utt_completeted_cb) {
 933                 ecore_timer_add(0, __tts_notify_utt_completed, client->tts);
 934         } else {
 935                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
 936         }
 937
 938         return 0;
 939 }
 940
 941 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
 942 {
 943         if (NULL == tts || NULL == callback) {
 944                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
 945                 return TTS_ERROR_INVALID_PARAMETER;
 946         }
 947
 948         tts_client_s* client = tts_client_get(tts);
 949
 950         if (NULL == client) {
 951                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
 952                 return TTS_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         if (TTS_STATE_CREATED != client->current_state) {
 956                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
 957                 return TTS_ERROR_INVALID_STATE;
 958         }
 959
 960         client->state_changed_cb = callback;
 961         client->state_changed_user_data = user_data;
 962
 963         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
 964
 965         return 0;
 966 }
 967
 968 int tts_unset_state_changed_cb(tts_h tts)
 969 {
 970         if (NULL == tts) {
 971                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
 972                 return TTS_ERROR_INVALID_PARAMETER;
 973         }
 974
 975         tts_client_s* client = tts_client_get(tts);
 976
 977         if (NULL == client) {
 978                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
 979                 return TTS_ERROR_INVALID_PARAMETER;
 980         }
 981
 982         if (TTS_STATE_CREATED != client->current_state) {
 983                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
 984                 return TTS_ERROR_INVALID_STATE;
 985         }
 986
 987         client->state_changed_cb = NULL;
 988         client->state_changed_user_data = NULL;
 989
 990         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
 991
 992         return 0;
 993 }
 994
 995 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
 996 {
 997         if (NULL == tts || NULL == callback) {
 998                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
 999                 return TTS_ERROR_INVALID_PARAMETER;
1000         }
1001
1002         tts_client_s* client = tts_client_get(tts);
1003
1004         if (NULL == client) {
1005                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1006                 return TTS_ERROR_INVALID_PARAMETER;
1007         }
1008
1009         if (TTS_STATE_CREATED != client->current_state) {
1010                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1011                 return TTS_ERROR_INVALID_STATE;
1012         }
1013
1014         client->utt_started_cb = callback;
1015         client->utt_started_user_data = user_data;
1016
1017         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1018
1019         return 0;
1020 }
1021
1022 int tts_unset_utterance_started_cb(tts_h tts)
1023 {
1024         if (NULL == tts) {
1025                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1026                 return TTS_ERROR_INVALID_PARAMETER;
1027         }
1028
1029         tts_client_s* client = tts_client_get(tts);
1030
1031         if (NULL == client) {
1032                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1033                 return TTS_ERROR_INVALID_PARAMETER;
1034         }
1035
1036         if (TTS_STATE_CREATED != client->current_state) {
1037                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1038                 return TTS_ERROR_INVALID_STATE;
1039         }
1040
1041         client->utt_started_cb = NULL;
1042         client->utt_started_user_data = NULL;
1043
1044         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1045
1046         return 0;
1047 }
1048
1049 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1050 {
1051         if (NULL == tts || NULL == callback) {
1052                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1053                 return TTS_ERROR_INVALID_PARAMETER;
1054         }
1055
1056         tts_client_s* client = tts_client_get(tts);
1057
1058         if (NULL == client) {
1059                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1060                 return TTS_ERROR_INVALID_PARAMETER;
1061         }
1062
1063         if (TTS_STATE_CREATED != client->current_state) {
1064                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1065                 return TTS_ERROR_INVALID_STATE;
1066         }
1067
1068         client->utt_completeted_cb = callback;
1069         client->utt_completed_user_data = user_data;
1070
1071         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1072
1073         return 0;
1074 }
1075
1076 int tts_unset_utterance_completed_cb(tts_h tts)
1077 {
1078         if (NULL == tts) {
1079                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1080                 return TTS_ERROR_INVALID_PARAMETER;
1081         }
1082
1083         tts_client_s* client = tts_client_get(tts);
1084
1085         if (NULL == client) {
1086                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1087                 return TTS_ERROR_INVALID_PARAMETER;
1088         }
1089
1090         if (TTS_STATE_CREATED != client->current_state) {
1091                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1092                 return TTS_ERROR_INVALID_STATE;
1093         }
1094
1095         client->utt_completeted_cb = NULL;
1096         client->utt_completed_user_data = NULL;
1097
1098         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1099         return 0;
1100 }
1101
1102 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1103 {
1104         if (NULL == tts || NULL == callback) {
1105                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1106                 return TTS_ERROR_INVALID_PARAMETER;
1107         }
1108
1109         tts_client_s* client = tts_client_get(tts);
1110
1111         if (NULL == client) {
1112                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1113                 return TTS_ERROR_INVALID_PARAMETER;
1114         }
1115
1116         if (TTS_STATE_CREATED != client->current_state) {
1117                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1118                 return TTS_ERROR_INVALID_STATE;
1119         }
1120
1121         client->error_cb = callback;
1122         client->error_user_data = user_data;
1123
1124         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1125
1126         return 0;
1127 }
1128
1129 int tts_unset_error_cb(tts_h tts)
1130 {
1131         if (NULL == tts) {
1132                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1133                 return TTS_ERROR_INVALID_PARAMETER;
1134         }
1135
1136         tts_client_s* client = tts_client_get(tts);
1137
1138         if (NULL == client) {
1139                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1140                 return TTS_ERROR_INVALID_PARAMETER;
1141         }
1142
1143         if (TTS_STATE_CREATED != client->current_state) {
1144                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1145                 return TTS_ERROR_INVALID_STATE;
1146         }
1147
1148         client->error_cb = NULL;
1149         client->error_user_data = NULL;
1150
1151         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1152
1153         return 0;
1154 }
1155
1156 static int __get_cmd_line(char *file, char *buf)
1157 {
1158         FILE *fp = NULL;
1159
1160         fp = fopen(file, "r");
1161         if (fp == NULL) {
1162                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get command line");
1163                 return -1;
1164         }
1165
1166         memset(buf, 0, 256);
1167         if (NULL == fgets(buf, 256, fp)) {
1168                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to fget command line");
1169                 fclose(fp);
1170                 return -1;
1171         }
1172         fclose(fp);
1173
1174         return 0;
1175 }
1176
1177 static bool __tts_is_alive(char* daemon_path)
1178 {
1179         DIR *dir;
1180         struct dirent *entry;
1181         struct stat filestat;
1182
1183         int pid;
1184         char cmdLine[256] = {'\0',};
1185         char tempPath[256] = {'\0',};
1186
1187         dir  = opendir("/proc");
1188         if (NULL == dir) {
1189                 SLOG(LOG_ERROR, TAG_TTSC, "process checking is FAILED");
1190                 return FALSE;
1191         }
1192
1193         while ((entry = readdir(dir)) != NULL) {
1194                 if (0 != lstat(entry->d_name, &filestat)) {
1195                         continue;
1196                 }
1197
1198                 if (!S_ISDIR(filestat.st_mode)) {
1199                         continue;
1200                 }
1201
1202                 pid = atoi(entry->d_name);
1203                 if (pid <= 0) continue;
1204
1205                 sprintf(tempPath, "/proc/%d/cmdline", pid);
1206                 if (0 != __get_cmd_line(tempPath, cmdLine)) {
1207                         continue;
1208                 }
1209
1210                 if (0 == strncmp(cmdLine, daemon_path, strlen(daemon_path))) {
1211                         SLOG(LOG_DEBUG, TAG_TTSC, "%s is ALIVE !!", daemon_path);
1212                         closedir(dir);
1213                         return TRUE;
1214                 }
1215         }
1216
1217         SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO %s !!", daemon_path);
1218
1219         closedir(dir);
1220         return FALSE;
1221 }
1222
1223 static int __tts_check_tts_daemon(tts_mode_e mode)
1224 {
1225         char daemon_path[64] = {'\0',};
1226         int pid, i;
1227
1228         if (TTS_MODE_DEFAULT == mode) {
1229                 strcpy(daemon_path, "/usr/bin/tts-daemon");
1230         } else if (TTS_MODE_NOTIFICATION == mode) {
1231                 strcpy(daemon_path, "/usr/bin/tts-daemon-noti");
1232         } else if (TTS_MODE_SCREEN_READER == mode) {
1233                 strcpy(daemon_path, "/usr/bin/tts-daemon-sr");
1234         } else {
1235                 SLOG(LOG_ERROR, TAG_TTSC, "mode is not valid");
1236                 return -1;
1237         }
1238
1239         if (TRUE == __tts_is_alive(daemon_path)) {
1240                 return 0;
1241         }
1242
1243         /* fork-exec daemom */
1244         pid = fork();
1245
1246         switch(pid) {
1247         case -1:
1248                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to create daemon");
1249                 break;
1250
1251         case 0:
1252                 setsid();
1253                 for (i = 0;i < _NSIG;i++)
1254                         signal(i, SIG_DFL);
1255
1256                 execl(daemon_path, daemon_path, NULL);
1257                 break;
1258
1259         default:
1260                 break;
1261         }
1262
1263         return 0;
1264 }