client/stt_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 "stt_main.h"
  22 #include "stt_setting.h"
  23 #include "stt_setting_dbus.h"
  24
  25
  26 static int __check_setting_stt_daemon();
  27
  28 static bool g_is_daemon_started = false;
  29
  30 static stt_setting_state_e g_state = STT_SETTING_STATE_NONE;
  31
  32 static stt_setting_initialized_cb g_initialized_cb;
  33
  34 static void* g_user_data;
  35
  36 static int g_reason;
  37
  38 /* API Implementation */
  39 static Eina_Bool __stt_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 __stt_setting_connect_daemon(void *data)
  47 {
  48         /* Send hello */
  49         if (0 != stt_setting_dbus_request_hello()) {
  50                 if (false == g_is_daemon_started) {
  51                         g_is_daemon_started = true;
  52                         __check_setting_stt_daemon();
  53                 }
  54                 return EINA_TRUE;
  55         }
  56
  57         SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
  58
  59         /* do request initialize */
  60         int ret = -1;
  61
  62         ret = stt_setting_dbus_request_initialize();
  63
  64         if (STT_SETTING_ERROR_ENGINE_NOT_FOUND == ret) {
  65                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine not found");
  66         } else if (STT_SETTING_ERROR_NONE != ret) {
  67                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to connection : %d", ret);
  68         } else {
  69                 /* success to connect stt-daemon */
  70                 g_state = STT_SETTING_STATE_READY;
  71         }
  72
  73         g_reason = ret;
  74
  75         ecore_timer_add(0, __stt_setting_initialized, NULL);
  76
  77         SLOG(LOG_DEBUG, TAG_STTC, "=====");
  78         SLOG(LOG_DEBUG, TAG_STTC, " ");
  79
  80         return EINA_FALSE;
  81 }
  82
  83 int stt_setting_initialize ()
  84 {
  85         SLOG(LOG_DEBUG, TAG_STTC, "===== Initialize STT Setting");
  86
  87         int ret = 0;
  88         if (STT_SETTING_STATE_READY == g_state) {
  89                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] STT Setting has already been initialized. \n");
  90                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
  91                 SLOG(LOG_DEBUG, TAG_STTC, " ");
  92                 return STT_SETTING_ERROR_NONE;
  93         }
  94
  95         if (0 != stt_setting_dbus_open_connection()) {
  96                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection\n");
  97                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
  98                 SLOG(LOG_DEBUG, TAG_STTC, " ");
  99                 return STT_SETTING_ERROR_OPERATION_FAILED;
 100         }
 101
 102         /* Send hello */
 103         if (0 != stt_setting_dbus_request_hello()) {
 104                 __check_setting_stt_daemon();
 105         }
 106
 107         /* do request */
 108         int i = 1;
 109         while(1) {
 110                 ret = stt_setting_dbus_request_initialize();
 111
 112                 if (STT_SETTING_ERROR_ENGINE_NOT_FOUND == ret) {
 113                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine not found");
 114                         break;
 115                 } else if(ret) {
 116                         sleep(1);
 117                         if (i == 3) {
 118                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection Time out");
 119                                 ret = STT_SETTING_ERROR_TIMED_OUT;
 120                                 break;
 121                         }
 122                         i++;
 123                 } else {
 124                         /* success to connect stt-daemon */
 125                         break;
 126                 }
 127         }
 128
 129         if (STT_SETTING_ERROR_NONE == ret) {
 130                 g_state = STT_SETTING_STATE_READY;
 131                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Initialize");
 132         }
 133
 134         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 135         SLOG(LOG_DEBUG, TAG_STTC, " ");
 136
 137         return ret;
 138 }
 139
 140 int stt_setting_initialize_async(stt_setting_initialized_cb callback, void* user_data)
 141 {
 142         SLOG(LOG_DEBUG, TAG_STTC, "===== Initialize STT Setting");
 143
 144         if (STT_SETTING_STATE_READY == g_state) {
 145                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] STT Setting has already been initialized. \n");
 146                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 147                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 148                 return STT_SETTING_ERROR_NONE;
 149         }
 150
 151         if( 0 != stt_setting_dbus_open_connection() ) {
 152                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection\n ");
 153                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 154                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 155                 return STT_SETTING_ERROR_OPERATION_FAILED;
 156         }
 157
 158         g_initialized_cb = callback;
 159         g_user_data = user_data;
 160
 161         ecore_timer_add(0, __stt_setting_connect_daemon, NULL);
 162
 163         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 164         SLOG(LOG_DEBUG, TAG_STTC, " ");
 165
 166         return STT_SETTING_ERROR_NONE;
 167 }
 168
 169 int stt_setting_finalize ()
 170 {
 171         SLOG(LOG_DEBUG, TAG_STTC, "===== Finalize STT Setting");
 172
 173         int ret = 0;
 174
 175         if (STT_SETTING_STATE_NONE == g_state) {
 176                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Not initialized");
 177                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 178                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 179                 return STT_SETTING_ERROR_INVALID_STATE;
 180         }
 181
 182         ret = stt_setting_dbus_request_finalilze();
 183         if (0 != ret) {
 184                 SLOG(LOG_ERROR, TAG_STTC, "Fail : finialize(%d)", ret);
 185                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 186                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 187                 return ret;
 188         }
 189
 190         if (0 != stt_setting_dbus_close_connection()) {
 191                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
 192         } else {
 193                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Finalize");
 194         }
 195
 196         g_state = STT_SETTING_STATE_NONE;
 197
 198         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 199         SLOG(LOG_DEBUG, TAG_STTC, " ");
 200
 201         return STT_SETTING_ERROR_NONE;
 202 }
 203
 204 int stt_setting_foreach_supported_engines(stt_setting_supported_engine_cb callback, void* user_data)
 205 {
 206         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach supported engines");
 207
 208         if (STT_SETTING_STATE_NONE == g_state) {
 209                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 210                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 211                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 212                 return STT_SETTING_ERROR_INVALID_STATE;
 213         }
 214
 215         if (NULL == callback) {
 216                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
 217                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 218                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 219                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 220         }
 221
 222         int ret = stt_setting_dbus_request_get_engine_list(callback, user_data);
 223         if (0 != ret) {
 224                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 225         } else {
 226                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach supported engines");
 227         }
 228
 229         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 230         SLOG(LOG_DEBUG, TAG_STTC, " ");
 231
 232         return ret;
 233 }
 234
 235 int stt_setting_get_engine(char** engine_id)
 236 {
 237         SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
 238
 239         if (STT_SETTING_STATE_NONE == g_state) {
 240                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 241                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 242                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 243                 return STT_SETTING_ERROR_INVALID_STATE;
 244         }
 245
 246         if (NULL == engine_id) {
 247                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine id is NULL");
 248                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 249                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 250                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         int ret = stt_setting_dbus_request_get_engine(engine_id);
 254         if (0 != ret) {
 255                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 256         } else {
 257                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get current engine");
 258         }
 259
 260         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 261         SLOG(LOG_DEBUG, TAG_STTC, " ");
 262
 263         return ret;
 264 }
 265
 266 int stt_setting_set_engine(const char* engine_id)
 267 {
 268         SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
 269
 270         if (STT_SETTING_STATE_NONE == g_state) {
 271                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 272                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 273                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 274                 return STT_SETTING_ERROR_INVALID_STATE;
 275         }
 276
 277         if (NULL == engine_id) {
 278                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine id is NULL");
 279                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 280                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 281                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 282         }
 283
 284         int ret = stt_setting_dbus_request_set_engine(engine_id);
 285         if (0 != ret) {
 286                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 287         } else {
 288                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set current engine");
 289         }
 290
 291         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 292         SLOG(LOG_DEBUG, TAG_STTC, " ");
 293
 294         return ret;
 295 }
 296
 297 int stt_setting_foreach_supported_languages(stt_setting_supported_language_cb callback, void* user_data)
 298 {
 299         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach supported languages");
 300
 301         if (STT_SETTING_STATE_NONE == g_state) {
 302                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 303                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 304                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 305                 return STT_SETTING_ERROR_INVALID_STATE;
 306         }
 307
 308         if (NULL == callback) {
 309                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Param is NULL");
 310                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 311                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 312                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 313         }
 314
 315         int ret = stt_setting_dbus_request_get_language_list(callback, user_data);
 316
 317         if (0 != ret) {
 318                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 319         } else {
 320                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach supported languages");
 321         }
 322
 323         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 324         SLOG(LOG_DEBUG, TAG_STTC, " ");
 325
 326         return ret;
 327 }
 328
 329 int stt_setting_get_default_language(char** language)
 330 {
 331         SLOG(LOG_DEBUG, TAG_STTC, "===== Get default language");
 332
 333         if (STT_SETTING_STATE_NONE == g_state) {
 334                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 335                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 336                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 337                 return STT_SETTING_ERROR_INVALID_STATE;
 338         }
 339
 340         if (NULL == language) {
 341                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 342                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 343                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 344                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 345         }
 346
 347         int ret = stt_setting_dbus_request_get_default_language(language);
 348         if (0 != ret) {
 349                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 350         } else {
 351                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach supported voices");
 352         }
 353
 354         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 355         SLOG(LOG_DEBUG, TAG_STTC, " ");
 356
 357         return ret;
 358 }
 359
 360 int stt_setting_set_default_language(const char* language)
 361 {
 362         SLOG(LOG_DEBUG, TAG_STTC, "===== Set default language");
 363
 364         if (STT_SETTING_STATE_NONE == g_state) {
 365                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 366                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 367                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 368                 return STT_SETTING_ERROR_INVALID_STATE;
 369         }
 370
 371         if (NULL == language) {
 372                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 373                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 374                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 375                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 376         }
 377
 378         int ret = stt_setting_dbus_request_set_default_language(language);
 379         if (0 != ret) {
 380                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 381         } else {
 382                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set default voice");
 383         }
 384
 385         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 386         SLOG(LOG_DEBUG, TAG_STTC, " ");
 387
 388         return ret;
 389 }
 390
 391 int stt_setting_get_profanity_filter(bool* value)
 392 {
 393         SLOG(LOG_DEBUG, TAG_STTC, "===== Get profanity filter");
 394
 395         int ret = 0;
 396
 397         if (STT_SETTING_STATE_NONE == g_state) {
 398                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 399                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 400                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 401                 return STT_SETTING_ERROR_INVALID_STATE;
 402         }
 403
 404         if (NULL == value) {
 405                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 406                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 407                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 408                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 409         }
 410
 411         ret = stt_setting_dbus_request_get_profanity_filter(value);
 412         if (0 != ret) {
 413                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 414         } else {
 415                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get profanity filter(%s)", *value ? "true":"false");
 416         }
 417
 418         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 419         SLOG(LOG_DEBUG, TAG_STTC, " ");
 420
 421         return ret;
 422 }
 423
 424 int stt_setting_set_profanity_filter(const bool value)
 425 {
 426         SLOG(LOG_DEBUG, TAG_STTC, "===== Set profanity filter");
 427
 428         int ret = 0;
 429
 430         if (STT_SETTING_STATE_NONE == g_state) {
 431                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 432                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 433                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 434                 return STT_SETTING_ERROR_INVALID_STATE;
 435         }
 436
 437         ret = stt_setting_dbus_request_set_profanity_filter(value);
 438         if (0 != ret) {
 439                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 440         } else {
 441                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set profanity filter(%s)", value ? "true":"false");
 442         }
 443
 444         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 445         SLOG(LOG_DEBUG, TAG_STTC, " ");
 446
 447         return ret;
 448 }
 449
 450 int stt_setting_get_punctuation_override(bool* value)
 451 {
 452         SLOG(LOG_DEBUG, TAG_STTC, "===== Get punctuation override");
 453
 454         int ret = 0;
 455
 456         if (STT_SETTING_STATE_NONE == g_state) {
 457                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 458                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 459                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 460                 return STT_SETTING_ERROR_INVALID_STATE;
 461         }
 462
 463         if (NULL == value) {
 464                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] param is NULL");
 465                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 466                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 467                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 468         }
 469
 470         ret = stt_setting_dbus_request_get_punctuation_override(value);
 471         if (0 != ret) {
 472                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 473         } else {
 474                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get punctuation override(%s)", *value ? "true":"false");
 475         }
 476
 477         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 478         SLOG(LOG_DEBUG, TAG_STTC, " ");
 479
 480         return ret;
 481 }
 482
 483 int stt_setting_set_punctuation_override(bool value)
 484 {
 485         SLOG(LOG_DEBUG, TAG_STTC, "===== Set punctuation override");
 486
 487         int ret = 0;
 488
 489         if (STT_SETTING_STATE_NONE == g_state) {
 490                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 491                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 492                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 493                 return STT_SETTING_ERROR_INVALID_STATE;
 494         }
 495
 496         ret = stt_setting_dbus_request_set_punctuation_override(value);
 497         if (0 != ret) {
 498                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 499         } else {
 500                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set punctuation override(%s)", value ? "true":"false");
 501         }
 502
 503         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 504         SLOG(LOG_DEBUG, TAG_STTC, " ");
 505
 506         return ret;
 507 }
 508
 509 int stt_setting_get_silence_detection(bool* value)
 510 {
 511         SLOG(LOG_DEBUG, TAG_STTC, "===== Get silence detection");
 512
 513         int ret = 0;
 514
 515         if (STT_SETTING_STATE_NONE == g_state) {
 516                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 517                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 518                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 519                 return STT_SETTING_ERROR_INVALID_STATE;
 520         }
 521
 522         if (NULL == value) {
 523                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] param is NULL");
 524                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 525                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 526                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 527         }
 528
 529         ret = stt_setting_dbus_request_get_silence_detection(value);
 530         if (0 != ret) {
 531                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 532         } else {
 533                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get silence detection(%s)", *value ? "true":"false");
 534         }
 535
 536         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 537         SLOG(LOG_DEBUG, TAG_STTC, " ");
 538
 539         return ret;
 540 }
 541
 542 int stt_setting_set_silence_detection(bool value)
 543 {
 544         SLOG(LOG_DEBUG, TAG_STTC, "===== Set silence detection");
 545
 546         int ret = 0;
 547
 548         if (STT_SETTING_STATE_NONE == g_state) {
 549                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 550                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 551                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 552                 return STT_SETTING_ERROR_INVALID_STATE;
 553         }
 554
 555         ret = stt_setting_dbus_request_set_silence_detection(value);
 556         if (0 != ret) {
 557                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 558         } else {
 559                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set silence detection(%s)", value ? "true":"false");
 560         }
 561
 562         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 563         SLOG(LOG_DEBUG, TAG_STTC, " ");
 564
 565         return ret;
 566 }
 567
 568 int stt_setting_foreach_engine_settings(stt_setting_engine_setting_cb callback, void* user_data)
 569 {
 570         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach engine setting");
 571
 572         int ret = 0;
 573
 574         if (STT_SETTING_STATE_NONE == g_state) {
 575                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 576                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 577                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 578                 return STT_SETTING_ERROR_INVALID_STATE;
 579         }
 580
 581         if (NULL == callback) {
 582                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] parameter is NULL");
 583                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 584                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 585                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 586         }
 587
 588         ret = stt_setting_dbus_request_get_engine_setting(callback, user_data);
 589         if (0 != ret) {
 590                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 591         } else {
 592                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach engine setting");
 593         }
 594
 595         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 596         SLOG(LOG_DEBUG, TAG_STTC, " ");
 597
 598         return ret;
 599 }
 600
 601 int stt_setting_set_engine_setting(const char* key, const char* value)
 602 {
 603         SLOG(LOG_DEBUG, TAG_STTC, "===== Set engine setting");
 604
 605         int ret = 0;
 606
 607         if (STT_SETTING_STATE_NONE == g_state) {
 608                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 609                 return STT_SETTING_ERROR_INVALID_STATE;
 610         }
 611
 612         if (NULL == key || NULL == value) {
 613                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] parameter is NULL");
 614                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 615         }
 616
 617         ret = stt_setting_dbus_request_set_engine_setting(key, value);
 618         if (0 != ret) {
 619                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR]  Result (%d)", ret);
 620         } else {
 621                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set engine setting(%s)", *value ? "true":"false");
 622         }
 623
 624         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 625         SLOG(LOG_DEBUG, TAG_STTC, " ");
 626
 627         return ret;
 628 }
 629
 630 int __setting_get_cmd_line(char *file, char *buf)
 631 {
 632         FILE *fp = NULL;
 633         int i;
 634
 635         fp = fopen(file, "r");
 636         if (fp == NULL) {
 637                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get command line");
 638                 return -1;
 639         }
 640
 641         memset(buf, 0, 256);
 642         fgets(buf, 256, fp);
 643         fclose(fp);
 644
 645         return 0;
 646 }
 647
 648 static bool __stt_setting_is_alive()
 649 {
 650         DIR *dir;
 651         struct dirent *entry;
 652         struct stat filestat;
 653
 654         int pid;
 655         char cmdLine[256];
 656         char tempPath[256];
 657
 658         dir  = opendir("/proc");
 659         if (NULL == dir) {
 660                 SLOG(LOG_ERROR, TAG_STTC, "process checking is FAILED");
 661                 return FALSE;
 662         }
 663
 664         while ((entry = readdir(dir)) != NULL) {
 665                 if (0 != lstat(entry->d_name, &filestat))
 666                         continue;
 667
 668                 if (!S_ISDIR(filestat.st_mode))
 669                         continue;
 670
 671                 pid = atoi(entry->d_name);
 672                 if (pid <= 0) continue;
 673
 674                 sprintf(tempPath, "/proc/%d/cmdline", pid);
 675                 if (0 != __setting_get_cmd_line(tempPath, cmdLine)) {
 676                         continue;
 677                 }
 678
 679                 if ( 0 == strncmp(cmdLine, "[stt-daemon]", strlen("[stt-daemon]")) ||
 680                         0 == strncmp(cmdLine, "stt-daemon", strlen("stt-daemon")) ||
 681                         0 == strncmp(cmdLine, "/usr/bin/stt-daemon", strlen("/usr/bin/stt-daemon"))) {
 682                                 SLOG(LOG_DEBUG, TAG_STTC, "stt-daemon is ALIVE !! \n");
 683                                 closedir(dir);
 684                                 return TRUE;
 685                 }
 686         }
 687         SLOG(LOG_DEBUG, TAG_STTC, "THERE IS NO stt-daemon !! \n");
 688
 689         closedir(dir);
 690         return FALSE;
 691
 692 }
 693
 694 static void __setting_my_sig_child(int signo, siginfo_t *info, void *data)
 695 {
 696         int status = 0;
 697         pid_t child_pid, child_pgid;
 698
 699         child_pgid = getpgid(info->si_pid);
 700         SLOG(LOG_DEBUG, TAG_STTC, "Signal handler: dead pid = %d, pgid = %d\n", info->si_pid, child_pgid);
 701
 702         while ((child_pid = waitpid(-1, &status, WNOHANG)) > 0) {
 703                 if(child_pid == child_pgid)
 704                         killpg(child_pgid, SIGKILL);
 705         }
 706
 707         return;
 708 }
 709
 710 int __check_setting_stt_daemon()
 711 {
 712         if (TRUE == __stt_setting_is_alive())
 713                 return 0;
 714
 715         /* fork-exec stt-daemom */
 716         int pid = 0, i = 0;
 717         struct sigaction act, dummy;
 718         act.sa_handler = NULL;
 719         act.sa_sigaction = __setting_my_sig_child;
 720         sigemptyset(&act.sa_mask);
 721         act.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
 722
 723         if (sigaction(SIGCHLD, &act, &dummy) < 0) {
 724                 SLOG(LOG_ERROR, TAG_STTC, "%s\n", "Cannot make a signal handler\n");
 725                 return -1;
 726         }
 727
 728         pid = fork();
 729
 730         switch(pid) {
 731         case -1:
 732                 SLOG(LOG_DEBUG, TAG_STTC, "Fail to create stt-daemon");
 733                 break;
 734
 735         case 0:
 736                 setsid();
 737                 for( i = 0 ; i < _NSIG ; i++ )
 738                         signal(i, SIG_DFL);
 739
 740                 execl("/usr/bin/stt-daemon", "/usr/bin/stt-daemon", NULL);
 741                 break;
 742
 743         default:
 744                 break;
 745         }
 746
 747         return 0;
 748 }
 749