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