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