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