client/tts_setting.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/types.h>
  18 #include <sys/stat.h>
  19 #include <dirent.h>
  20
  21 #include "tts_main.h"
  22 #include "tts_setting.h"
  23 #include "tts_setting_dbus.h"
  24
  25 static bool g_is_daemon_started = false;
  26
  27 static int __check_setting_tts_daemon();
  28
  29 static tts_setting_state_e g_state = TTS_SETTING_STATE_NONE;
  30
  31 static tts_setting_initialized_cb g_initialized_cb;
  32 static void* g_user_data;
  33
  34 static int g_reason;
  35
  36 /* API Implementation */
  37 static Eina_Bool __tts_setting_initialized(void *data)
  38 {
  39         g_initialized_cb(g_state, g_reason, g_user_data);
  40
  41         return EINA_FALSE;
  42 }
  43
  44 static Eina_Bool __tts_setting_connect_daemon(void *data)
  45 {
  46         /* Send hello */
  47         if (0 != tts_setting_dbus_request_hello()) {
  48                 if (false == g_is_daemon_started) {
  49                         g_is_daemon_started = true;
  50                         __check_setting_tts_daemon();
  51                 }
  52                 return EINA_TRUE;
  53         }
  54
  55         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
  56
  57         /* do request initialize */
  58         int ret = -1;
  59
  60         ret = tts_setting_dbus_request_initialize();
  61
  62         if (TTS_SETTING_ERROR_ENGINE_NOT_FOUND == ret) {
  63                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found");
  64         } else if (TTS_SETTING_ERROR_NONE != ret) {
  65                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection : %d", ret);
  66         } else {
  67                 /* success to connect tts-daemon */
  68                 g_state = TTS_SETTING_STATE_READY;
  69         }
  70
  71         g_reason = ret;
  72
  73         ecore_timer_add(0, __tts_setting_initialized, NULL);
  74
  75         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  76         SLOG(LOG_DEBUG, TAG_TTSC, " ");
  77
  78         return EINA_FALSE;
  79 }
  80
  81 int tts_setting_initialize()
  82 {
  83         SLOG(LOG_DEBUG, TAG_TTSC, "===== Initialize TTS Setting");
  84
  85         if (TTS_SETTING_STATE_READY == g_state) {
  86                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] TTS Setting has already been initialized. \n");
  87                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  88                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  89                 return TTS_SETTING_ERROR_NONE;
  90         }
  91
  92         if( 0 != tts_setting_dbus_open_connection() ) {
  93                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open connection\n ");
  94                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  95                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  96                 return TTS_SETTING_ERROR_OPERATION_FAILED;
  97         }
  98
  99         /* Send hello */
 100         if (0 != tts_setting_dbus_request_hello()) {
 101                 __check_setting_tts_daemon();
 102         }
 103
 104         /* do request */
 105         int i = 1;
 106         int ret = 0;
 107         while(1) {
 108                 ret = tts_setting_dbus_request_initialize();
 109
 110                 if( TTS_SETTING_ERROR_ENGINE_NOT_FOUND == ret ) {
 111                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found");
 112                         break;
 113                 } else if(ret) {
 114                         sleep(1);
 115                         if (i == 3) {
 116                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Connection Time out");
 117                                 ret = TTS_SETTING_ERROR_TIMED_OUT;
 118                                 break;
 119                         }
 120                         i++;
 121                 } else {
 122                         /* success to connect tts-daemon */
 123                         break;
 124                 }
 125         }
 126
 127         if (TTS_SETTING_ERROR_NONE == ret) {
 128                 g_state = TTS_SETTING_STATE_READY;
 129                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Initialize");
 130         }
 131
 132         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 133         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 134
 135         return ret;
 136 }
 137
 138 int tts_setting_initialize_async(tts_setting_initialized_cb callback, void* user_data)
 139 {
 140         SLOG(LOG_DEBUG, TAG_TTSC, "===== Initialize TTS Setting");
 141
 142         if (TTS_SETTING_STATE_READY == g_state) {
 143                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] TTS Setting has already been initialized. \n");
 144                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 145                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 146                 return TTS_SETTING_ERROR_NONE;
 147         }
 148
 149         if( 0 != tts_setting_dbus_open_connection() ) {
 150                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open connection\n ");
 151                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 152                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 153                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 154         }
 155
 156         g_initialized_cb = callback;
 157         g_user_data = user_data;
 158
 159         ecore_timer_add(0, __tts_setting_connect_daemon, NULL);
 160
 161         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 162         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 163
 164         return TTS_SETTING_ERROR_NONE;
 165 }
 166
 167
 168 int tts_setting_finalize()
 169 {
 170         SLOG(LOG_DEBUG, TAG_TTSC, "===== Finalize TTS Setting");
 171
 172         if (TTS_SETTING_STATE_NONE == g_state) {
 173                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Not initialized");
 174                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 175                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 176                 return TTS_SETTING_ERROR_INVALID_STATE;
 177         }
 178
 179         int ret = tts_setting_dbus_request_finalilze();
 180         if (0 != ret) {
 181                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 182                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 183                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 184
 185                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 186         }
 187         g_is_daemon_started = false;
 188
 189         if (0 != tts_setting_dbus_close_connection()) {
 190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection\n ");
 191         } else {
 192                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Finalize");
 193         }
 194
 195         g_state = TTS_SETTING_STATE_NONE;
 196
 197         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 198         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 199
 200         return TTS_SETTING_ERROR_NONE;
 201 }
 202
 203 int tts_setting_foreach_supported_engines(tts_setting_supported_engine_cb callback, void* user_data)
 204 {
 205         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported engines");
 206
 207         if (TTS_SETTING_STATE_NONE == g_state) {
 208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 209                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 210                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 211                 return TTS_SETTING_ERROR_INVALID_STATE;
 212         }
 213
 214         if (NULL == callback) {
 215                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Callback is NULL");
 216                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 217                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 218                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 219         }
 220
 221         int ret = tts_setting_dbus_request_get_engine_list(callback, user_data);
 222         if (0 != ret) {
 223                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 224         } else {
 225                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported engines");
 226         }
 227
 228         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 229         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 230
 231         return ret;
 232 }
 233
 234 int tts_setting_get_engine(char** engine_id)
 235 {
 236         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get current engine");
 237
 238         if (TTS_SETTING_STATE_NONE == g_state) {
 239                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 240                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 241                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 242                 return TTS_SETTING_ERROR_INVALID_STATE;
 243         }
 244
 245         if (NULL == engine_id) {
 246                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 247                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 248                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 249                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 250         }
 251
 252         int ret = tts_setting_dbus_request_get_engine(engine_id);
 253         if (0 != ret) {
 254                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 255         } else {
 256                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get current engine");
 257         }
 258
 259         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 260         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 261
 262         return ret;
 263 }
 264
 265 int tts_setting_set_engine(const char* engine_id)
 266 {
 267         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set current engine");
 268
 269         if (TTS_SETTING_STATE_NONE == g_state) {
 270                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 271                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 272                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 273                 return TTS_SETTING_ERROR_INVALID_STATE;
 274         }
 275
 276         if (NULL == engine_id) {
 277                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 278                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 279                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 280                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 281         }
 282
 283         int ret = tts_setting_dbus_request_set_engine(engine_id);
 284         if (0 != ret) {
 285                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 286         } else {
 287                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set current engine");
 288         }
 289
 290         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 291         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 292
 293         return ret;
 294 }
 295
 296 int tts_setting_foreach_surpported_voices(tts_setting_supported_voice_cb callback, void* user_data)
 297 {
 298         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 299
 300         if (TTS_SETTING_STATE_NONE == g_state) {
 301                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 302                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 303                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 304                 return TTS_SETTING_ERROR_INVALID_STATE;
 305         }
 306
 307         if (NULL == callback) {
 308                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 309                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 310                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 311                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         int ret = tts_setting_dbus_request_get_voice_list(callback, user_data);
 315
 316         if (0 != ret) {
 317                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 318         } else {
 319                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported voices");
 320         }
 321
 322         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 323         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 324
 325         return ret;
 326 }
 327
 328 int tts_setting_get_default_voice(char** language, tts_setting_voice_type_e* voice_type)
 329 {
 330         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 331
 332         if (TTS_SETTING_STATE_NONE == g_state) {
 333                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 334                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 335                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 336                 return TTS_SETTING_ERROR_INVALID_STATE;
 337         }
 338
 339         if (NULL == language || NULL == voice_type) {
 340                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 341                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 342                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 343                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 344         }
 345
 346         int ret = tts_setting_dbus_request_get_default_voice(language, voice_type);
 347         if (0 != ret) {
 348                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 349         } else {
 350                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported voices");
 351         }
 352
 353         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 354         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 355
 356         return ret;
 357 }
 358
 359 int tts_setting_set_default_voice(const char* language, tts_setting_voice_type_e voice_type)
 360 {
 361         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default voice");
 362
 363         if (TTS_SETTING_STATE_NONE == g_state) {
 364                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 365                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 366                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 367                 return TTS_SETTING_ERROR_INVALID_STATE;
 368         }
 369
 370         if (NULL == language) {
 371                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 372                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 373                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 374                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 375         }
 376
 377         if (voice_type < TTS_SETTING_VOICE_TYPE_MALE || TTS_SETTING_VOICE_TYPE_USER3 < voice_type ) {
 378                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid voice type");
 379                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 380                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 381                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         int ret = tts_setting_dbus_request_set_default_voice(language, voice_type);
 385         if (0 != ret) {
 386                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 387         } else {
 388                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice");
 389         }
 390
 391         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 392         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 393
 394         return ret;
 395 }
 396
 397
 398 int tts_setting_get_default_speed(tts_setting_speed_e* speed)
 399 {
 400         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default speed");
 401
 402         if (TTS_SETTING_STATE_NONE == g_state) {
 403                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 404                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 405                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 406                 return TTS_SETTING_ERROR_INVALID_STATE;
 407         }
 408
 409         if (NULL == speed) {
 410                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 411                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 412                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 413                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 414         }
 415
 416         int temp;
 417         temp = 0;
 418
 419         int ret = tts_setting_dbus_request_get_default_speed(&temp);
 420         if (0 != ret) {
 421                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 422         } else {
 423                 /* Copy value */
 424                 *speed = (tts_setting_speed_e)temp;
 425                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default speed : %d ", (int)*speed);
 426         }
 427
 428         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 429         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 430
 431         return ret;
 432 }
 433
 434
 435 int tts_setting_set_default_speed(tts_setting_speed_e speed)
 436 {
 437         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default speed");
 438
 439         if (TTS_SETTING_STATE_NONE == g_state) {
 440                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 441                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 442                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 443                 return TTS_SETTING_ERROR_INVALID_STATE;
 444         }
 445
 446         if (speed < TTS_SETTING_SPEED_VERY_SLOW || TTS_SETTING_SPEED_VERY_FAST < speed) {
 447                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid speed");
 448                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 449                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 450                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         int ret = tts_setting_dbus_request_set_default_speed((int)speed);
 454         if (0 != ret) {
 455                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 456         } else {
 457                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default speed");
 458         }
 459
 460         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 461         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 462
 463         return ret;
 464 }
 465
 466 int tts_setting_foreach_engine_settings(tts_setting_engine_setting_cb callback, void* user_data)
 467 {
 468         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach engine setting");
 469
 470         if (TTS_SETTING_STATE_NONE == g_state) {
 471                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 472                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 473                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 474                 return TTS_SETTING_ERROR_INVALID_STATE;
 475         }
 476
 477         if (NULL == callback) {
 478                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 479                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 480                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 481                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 482         }
 483
 484         int ret = tts_setting_dbus_request_get_engine_setting(callback, user_data);
 485         if (0 != ret) {
 486                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 487         } else {
 488                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach engine setting");
 489         }
 490
 491         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 492         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 493
 494         return ret;
 495 }
 496
 497 int tts_setting_set_engine_setting(const char* key, const char* value)
 498 {
 499         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set engine setting");
 500
 501         if (TTS_SETTING_STATE_NONE == g_state) {
 502                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 503                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 504                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 505                 return TTS_SETTING_ERROR_INVALID_STATE;
 506         }
 507
 508         if(NULL == key || NULL == value) {
 509                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 510                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 511                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 512                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 513         }
 514
 515         int ret = tts_setting_dbus_request_set_engine_setting(key, value);
 516         if (0 != ret) {
 517                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 518         } else {
 519                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach engine setting");
 520         }
 521
 522         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 523         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 524
 525         return ret;
 526 }
 527
 528 int __setting_get_cmd_line(char *file, char *buf)
 529 {
 530         FILE *fp = NULL;
 531         int i;
 532
 533         fp = fopen(file, "r");
 534         if (fp == NULL) {
 535                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get command line");
 536                 return -1;
 537         }
 538
 539         memset(buf, 0, 256);
 540         fgets(buf, 256, fp);
 541         fclose(fp);
 542
 543         return 0;
 544 }
 545
 546 /* Functions for tts-daemon fork */
 547 static bool __tts_setting_is_alive()
 548 {
 549         DIR *dir;
 550         struct dirent *entry;
 551         struct stat filestat;
 552
 553         int pid;
 554         char cmdLine[256];
 555         char tempPath[256];
 556
 557         dir  = opendir("/proc");
 558         if (NULL == dir) {
 559                 SLOG(LOG_ERROR, TAG_TTSC, "process checking is FAILED");
 560                 return FALSE;
 561         }
 562
 563         while ((entry = readdir(dir)) != NULL) {
 564                 if (0 != lstat(entry->d_name, &filestat))
 565                         continue;
 566
 567                 if (!S_ISDIR(filestat.st_mode))
 568                         continue;
 569
 570                 pid = atoi(entry->d_name);
 571                 if (pid <= 0) continue;
 572
 573                 sprintf(tempPath, "/proc/%d/cmdline", pid);
 574                 if (0 != __setting_get_cmd_line(tempPath, cmdLine)) {
 575                         continue;
 576                 }
 577
 578                 if (0 == strncmp(cmdLine, "[tts-daemon]", strlen("[tts-daemon]")) ||
 579                         0 == strncmp(cmdLine, "tts-daemon", strlen("tts-daemon")) ||
 580                         0 == strncmp(cmdLine, "/usr/bin/tts-daemon", strlen("/usr/bin/tts-daemon"))) {
 581                                 SLOG(LOG_DEBUG, TAG_TTSC, "tts-daemon is ALIVE !! \n");
 582                                 closedir(dir);
 583                                 return TRUE;
 584                 }
 585         }
 586         SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO tts-daemon !! \n");
 587
 588         closedir(dir);
 589         return FALSE;
 590
 591 }
 592
 593 static int __check_setting_tts_daemon()
 594 {
 595         if( TRUE == __tts_setting_is_alive() )
 596                 return 0;
 597
 598         /* fork-exec tts-daemom */
 599         int pid, i;
 600
 601         pid = fork();
 602
 603         switch(pid) {
 604         case -1:
 605                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create tts-daemon ");
 606                 break;
 607
 608         case 0:
 609                 setsid();
 610                 for( i = 0 ; i < _NSIG ; i++ )
 611                         signal(i, SIG_DFL);
 612
 613                 execl("/usr/bin/tts-daemon", "/usr/bin/tts-daemon", NULL);
 614                 break;
 615
 616         default:
 617                 break;
 618         }
 619
 620         return 0;
 621 }