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
 188         if (0 != tts_setting_dbus_close_connection()) {
 189                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection\n ");
 190         } else {
 191                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Finalize");
 192         }
 193
 194         g_state = TTS_SETTING_STATE_NONE;
 195
 196         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 197         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 198
 199         return TTS_SETTING_ERROR_NONE;
 200 }
 201
 202 int tts_setting_foreach_supported_engines(tts_setting_supported_engine_cb callback, void* user_data)
 203 {
 204         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported engines");
 205
 206         if (TTS_SETTING_STATE_NONE == g_state) {
 207                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 208                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 209                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 210                 return TTS_SETTING_ERROR_INVALID_STATE;
 211         }
 212
 213         if (NULL == callback) {
 214                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Callback is NULL");
 215                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 216                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 217                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 218         }
 219
 220         int ret = tts_setting_dbus_request_get_engine_list(callback, user_data);
 221         if (0 != ret) {
 222                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 223         } else {
 224                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported engines");
 225         }
 226
 227         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 228         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 229
 230         return ret;
 231 }
 232
 233 int tts_setting_get_engine(char** engine_id)
 234 {
 235         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get current engine");
 236
 237         if (TTS_SETTING_STATE_NONE == g_state) {
 238                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 239                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 240                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 241                 return TTS_SETTING_ERROR_INVALID_STATE;
 242         }
 243
 244         if (NULL == engine_id) {
 245                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 246                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 247                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 248                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 249         }
 250
 251         int ret = tts_setting_dbus_request_get_engine(engine_id);
 252         if (0 != ret) {
 253                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 254         } else {
 255                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get current engine");
 256         }
 257
 258         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 259         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 260
 261         return ret;
 262 }
 263
 264 int tts_setting_set_engine(const char* engine_id)
 265 {
 266         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set current engine");
 267
 268         if (TTS_SETTING_STATE_NONE == g_state) {
 269                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 270                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 271                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 272                 return TTS_SETTING_ERROR_INVALID_STATE;
 273         }
 274
 275         if (NULL == engine_id) {
 276                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 277                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 278                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 279                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 280         }
 281
 282         int ret = tts_setting_dbus_request_set_engine(engine_id);
 283         if (0 != ret) {
 284                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 285         } else {
 286                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set current engine");
 287         }
 288
 289         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 290         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 291
 292         return ret;
 293 }
 294
 295 int tts_setting_foreach_surpported_voices(tts_setting_supported_voice_cb callback, void* user_data)
 296 {
 297         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 298
 299         if (TTS_SETTING_STATE_NONE == g_state) {
 300                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 301                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 302                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 303                 return TTS_SETTING_ERROR_INVALID_STATE;
 304         }
 305
 306         if (NULL == callback) {
 307                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 308                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 309                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 310                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 311         }
 312
 313         int ret = tts_setting_dbus_request_get_voice_list(callback, user_data);
 314
 315         if (0 != ret) {
 316                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 317         } else {
 318                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported voices");
 319         }
 320
 321         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 322         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 323
 324         return ret;
 325 }
 326
 327 int tts_setting_get_default_voice(char** language, tts_setting_voice_type_e* voice_type)
 328 {
 329         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 330
 331         if (TTS_SETTING_STATE_NONE == g_state) {
 332                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 333                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 334                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 335                 return TTS_SETTING_ERROR_INVALID_STATE;
 336         }
 337
 338         if (NULL == language || NULL == voice_type) {
 339                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 340                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 341                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 342                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 343         }
 344
 345         int ret = tts_setting_dbus_request_get_default_voice(language, voice_type);
 346         if (0 != ret) {
 347                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 348         } else {
 349                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported voices");
 350         }
 351
 352         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 353         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 354
 355         return ret;
 356 }
 357
 358 int tts_setting_set_default_voice(const char* language, tts_setting_voice_type_e voice_type)
 359 {
 360         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default voice");
 361
 362         if (TTS_SETTING_STATE_NONE == g_state) {
 363                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 364                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 365                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 366                 return TTS_SETTING_ERROR_INVALID_STATE;
 367         }
 368
 369         if (NULL == language) {
 370                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 371                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 372                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 373                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 374         }
 375
 376         if (voice_type < TTS_SETTING_VOICE_TYPE_MALE || TTS_SETTING_VOICE_TYPE_USER3 < voice_type ) {
 377                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid voice type");
 378                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 379                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 380                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 381         }
 382
 383         int ret = tts_setting_dbus_request_set_default_voice(language, voice_type);
 384         if (0 != ret) {
 385                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 386         } else {
 387                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice");
 388         }
 389
 390         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 391         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 392
 393         return ret;
 394 }
 395
 396
 397 int tts_setting_get_default_speed(tts_setting_speed_e* speed)
 398 {
 399         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default speed");
 400
 401         if (TTS_SETTING_STATE_NONE == g_state) {
 402                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 403                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 404                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 405                 return TTS_SETTING_ERROR_INVALID_STATE;
 406         }
 407
 408         if (NULL == speed) {
 409                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 410                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 411                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 412                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 413         }
 414
 415         int temp;
 416         temp = 0;
 417
 418         int ret = tts_setting_dbus_request_get_default_speed(&temp);
 419         if (0 != ret) {
 420                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 421         } else {
 422                 /* Copy value */
 423                 *speed = (tts_setting_speed_e)temp;
 424                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default speed : %d ", (int)*speed);
 425         }
 426
 427         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 428         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 429
 430         return ret;
 431 }
 432
 433
 434 int tts_setting_set_default_speed(tts_setting_speed_e speed)
 435 {
 436         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default speed");
 437
 438         if (TTS_SETTING_STATE_NONE == g_state) {
 439                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 440                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 441                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 442                 return TTS_SETTING_ERROR_INVALID_STATE;
 443         }
 444
 445         if (speed < TTS_SETTING_SPEED_VERY_SLOW || TTS_SETTING_SPEED_VERY_FAST < speed) {
 446                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid speed");
 447                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 448                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 449                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 450         }
 451
 452         int ret = tts_setting_dbus_request_set_default_speed((int)speed);
 453         if (0 != ret) {
 454                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 455         } else {
 456                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default speed");
 457         }
 458
 459         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 460         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 461
 462         return ret;
 463 }
 464
 465 int tts_setting_foreach_engine_settings(tts_setting_engine_setting_cb callback, void* user_data)
 466 {
 467         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach engine setting");
 468
 469         if (TTS_SETTING_STATE_NONE == g_state) {
 470                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 471                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 472                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 473                 return TTS_SETTING_ERROR_INVALID_STATE;
 474         }
 475
 476         if (NULL == callback) {
 477                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 478                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 479                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 480                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 481         }
 482
 483         int ret = tts_setting_dbus_request_get_engine_setting(callback, user_data);
 484         if (0 != ret) {
 485                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 486         } else {
 487                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach engine setting");
 488         }
 489
 490         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 491         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 492
 493         return ret;
 494 }
 495
 496 int tts_setting_set_engine_setting(const char* key, const char* value)
 497 {
 498         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set engine setting");
 499
 500         if (TTS_SETTING_STATE_NONE == g_state) {
 501                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 502                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 503                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 504                 return TTS_SETTING_ERROR_INVALID_STATE;
 505         }
 506
 507         if(NULL == key || NULL == value) {
 508                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 509                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 510                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 511                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         int ret = tts_setting_dbus_request_set_engine_setting(key, value);
 515         if (0 != ret) {
 516                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 517         } else {
 518                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach engine setting");
 519         }
 520
 521         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 522         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 523
 524         return ret;
 525 }
 526
 527 int __setting_get_cmd_line(char *file, char *buf)
 528 {
 529         FILE *fp = NULL;
 530         int i;
 531
 532         fp = fopen(file, "r");
 533         if (fp == NULL) {
 534                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get command line");
 535                 return -1;
 536         }
 537
 538         memset(buf, 0, 256);
 539         fgets(buf, 256, fp);
 540         fclose(fp);
 541
 542         return 0;
 543 }
 544
 545 /* Functions for tts-daemon fork */
 546 static bool __tts_setting_is_alive()
 547 {
 548         DIR *dir;
 549         struct dirent *entry;
 550         struct stat filestat;
 551
 552         int pid;
 553         char cmdLine[256];
 554         char tempPath[256];
 555
 556         dir  = opendir("/proc");
 557         if (NULL == dir) {
 558                 SLOG(LOG_ERROR, TAG_TTSC, "process checking is FAILED");
 559                 return FALSE;
 560         }
 561
 562         while ((entry = readdir(dir)) != NULL) {
 563                 if (0 != lstat(entry->d_name, &filestat))
 564                         continue;
 565
 566                 if (!S_ISDIR(filestat.st_mode))
 567                         continue;
 568
 569                 pid = atoi(entry->d_name);
 570                 if (pid <= 0) continue;
 571
 572                 sprintf(tempPath, "/proc/%d/cmdline", pid);
 573                 if (0 != __setting_get_cmd_line(tempPath, cmdLine)) {
 574                         continue;
 575                 }
 576
 577                 if (0 == strncmp(cmdLine, "[tts-daemon]", strlen("[tts-daemon]")) ||
 578                         0 == strncmp(cmdLine, "tts-daemon", strlen("tts-daemon")) ||
 579                         0 == strncmp(cmdLine, "/usr/bin/tts-daemon", strlen("/usr/bin/tts-daemon"))) {
 580                                 SLOG(LOG_DEBUG, TAG_TTSC, "tts-daemon is ALIVE !! \n");
 581                                 closedir(dir);
 582                                 return TRUE;
 583                 }
 584         }
 585         SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO tts-daemon !! \n");
 586
 587         closedir(dir);
 588         return FALSE;
 589
 590 }
 591
 592 static void __setting_my_sig_child(int signo, siginfo_t *info, void *data)
 593 {
 594         int status;
 595         pid_t child_pid, child_pgid;
 596
 597         child_pgid = getpgid(info->si_pid);
 598         SLOG(LOG_DEBUG, TAG_TTSC, "Signal handler: dead pid = %d, pgid = %d", info->si_pid, child_pgid);
 599
 600         while ((child_pid = waitpid(-1, &status, WNOHANG)) > 0) {
 601                 if(child_pid == child_pgid)
 602                         killpg(child_pgid, SIGKILL);
 603         }
 604
 605         return;
 606 }
 607
 608 static int __check_setting_tts_daemon()
 609 {
 610         if( TRUE == __tts_setting_is_alive() )
 611                 return 0;
 612
 613         /* fork-exec tts-daemom */
 614         int pid, i;
 615         struct sigaction act, dummy;
 616
 617         act.sa_handler = NULL;
 618         act.sa_sigaction = __setting_my_sig_child;
 619         sigemptyset(&act.sa_mask);
 620         act.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
 621
 622         if (sigaction(SIGCHLD, &act, &dummy) < 0) {
 623                 SLOG(LOG_ERROR, TAG_TTSC, "Cannot make a signal handler");
 624                 return -1;
 625         }
 626
 627         pid = fork();
 628
 629         switch(pid) {
 630         case -1:
 631                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create tts-daemon ");
 632                 break;
 633
 634         case 0:
 635                 setsid();
 636                 for( i = 0 ; i < _NSIG ; i++ )
 637                         signal(i, SIG_DFL);
 638
 639                 execl("/usr/bin/tts-daemon", "/usr/bin/tts-daemon", NULL);
 640                 break;
 641
 642         default:
 643                 break;
 644         }
 645
 646         return 0;
 647 }