common/stt_config_mgr.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 #include <dirent.h>
  15 #include <dlfcn.h>
  16 #include <dlog.h>
  17 #include <Ecore.h>
  18 #include <glib.h>
  19 #include <unistd.h>
  20 #include <sys/inotify.h>
  21 #include <vconf.h>
  22
  23 #include "stt_config_mgr.h"
  24 #include "stt_defs.h"
  25 #include "stt_config_parser.h"
  26
  27
  28 typedef struct {
  29         int     uid;
  30         stt_config_engine_changed_cb    engine_cb;
  31         stt_config_lang_changed_cb      lang_cb;
  32         stt_config_bool_changed_cb      bool_cb;
  33         void*   user_data;
  34 } stt_config_client_s;
  35
  36
  37 extern const char* stt_tag();
  38
  39 static GSList* g_engine_list = NULL;
  40
  41 static GSList* g_config_client_list = NULL;
  42
  43 static stt_config_s* g_config_info;
  44
  45 static Ecore_Fd_Handler* g_fd_handler_noti = NULL;
  46 static int g_fd_noti;
  47 static int g_wd_noti;
  48
  49 int __stt_config_mgr_print_engine_info();
  50
  51 bool __stt_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
  52 {
  53         if (NULL == engine_id || NULL == language) {
  54                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
  55                 return false;
  56         }
  57
  58         GSList *iter = NULL;
  59         stt_engine_info_s *engine_info = NULL;
  60
  61         if (0 >= g_slist_length(g_engine_list)) {
  62                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
  63                 return false;
  64         }
  65
  66         /* Get a first item */
  67         iter = g_slist_nth(g_engine_list, 0);
  68
  69         while (NULL != iter) {
  70                 engine_info = iter->data;
  71
  72                 if (NULL == engine_info) {
  73                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
  74                         return false;
  75                 }
  76
  77                 if (0 != strcmp(engine_id, engine_info->uuid)) {
  78                         iter = g_slist_next(iter);
  79                         continue;
  80                 }
  81
  82                 GSList *iter_lang = NULL;
  83                 char* engine_lang;
  84                 if (g_slist_length(engine_info->languages) > 0) {
  85                         /* Get a first item */
  86                         iter_lang = g_slist_nth(engine_info->languages, 0);
  87
  88                         int i = 1;
  89                         while (NULL != iter_lang) {
  90                                 /*Get handle data from list*/
  91                                 engine_lang = iter_lang->data;
  92
  93                                 SLOG(LOG_DEBUG, stt_tag(), "  [%dth] %s", i, engine_lang);
  94
  95                                 if (0 == strcmp(language, engine_lang)) {
  96                                         return true;
  97                                 }
  98
  99                                 /*Get next item*/
 100                                 iter_lang = g_slist_next(iter_lang);
 101                                 i++;
 102                         }
 103                 }
 104                 break;
 105         }
 106
 107         return false;
 108 }
 109
 110 int __stt_config_mgr_select_lang(const char* engine_id, char** language)
 111 {
 112         if (NULL == engine_id || NULL == language) {
 113                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
 114                 return false;
 115         }
 116
 117         GSList *iter = NULL;
 118         stt_engine_info_s *engine_info = NULL;
 119
 120         if (0 >= g_slist_length(g_engine_list)) {
 121                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
 122                 return false;
 123         }
 124
 125         /* Get a first item */
 126         iter = g_slist_nth(g_engine_list, 0);
 127
 128         while (NULL != iter) {
 129                 engine_info = iter->data;
 130
 131                 if (NULL == engine_info) {
 132                         SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
 133                         return false;
 134                 }
 135
 136                 if (0 != strcmp(engine_id, engine_info->uuid)) {
 137                         iter = g_slist_next(iter);
 138                         continue;
 139                 }
 140
 141                 GSList *iter_lang = NULL;
 142                 char* engine_lang = NULL;
 143                 if (g_slist_length(engine_info->languages) > 0) {
 144                         /* Get a first item */
 145                         iter_lang = g_slist_nth(engine_info->languages, 0);
 146
 147                         while (NULL != iter_lang) {
 148                                 engine_lang = iter_lang->data;
 149                                 if (NULL != engine_lang) {
 150                                         /* Default language is STT_BASE_LANGUAGE */
 151                                         if (0 == strcmp(STT_BASE_LANGUAGE, engine_lang)) {
 152                                                 *language = strdup(engine_lang);
 153                                                 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *language);
 154                                                 return 0;
 155                                         }
 156                                 }
 157
 158                                 iter_lang = g_slist_next(iter_lang);
 159                         }
 160
 161                         /* Not support STT_BASE_LANGUAGE */
 162                         if (NULL != engine_lang) {
 163                                 *language = strdup(engine_lang);
 164                                 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *language);
 165                                 return 0;
 166                         }
 167                 }
 168                 break;
 169         }
 170
 171         return -1;
 172 }
 173
 174 Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
 175 {
 176         SLOG(LOG_DEBUG, stt_tag(), "===== Config changed callback event");
 177
 178         int length;
 179         struct inotify_event event;
 180         memset(&event, '\0', sizeof(struct inotify_event));
 181
 182         length = read(g_fd_noti, &event, sizeof(struct inotify_event));
 183         if (0 > length) {
 184                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty Inotify event");
 185                 SLOG(LOG_DEBUG, stt_tag(), "=====");
 186                 SLOG(LOG_DEBUG, stt_tag(), " ");
 187                 return ECORE_CALLBACK_PASS_ON;
 188         }
 189
 190         if (IN_MODIFY == event.mask) {
 191                 char* engine = NULL;
 192                 char* setting = NULL;
 193                 char* lang = NULL;
 194                 int auto_lang = -1;
 195                 int silence = -1;
 196
 197                 GSList *iter = NULL;
 198                 stt_config_client_s* temp_client = NULL;
 199
 200                 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence))
 201                         return ECORE_CALLBACK_PASS_ON;
 202
 203                 /* Engine changed */
 204                 if (NULL != engine || NULL != setting) {
 205                         /* engine changed */
 206                         if (NULL != engine) {
 207                                 if (NULL != g_config_info->engine_id)   free(g_config_info->engine_id);
 208                                 g_config_info->engine_id = strdup(engine);
 209                         }
 210
 211                         if (NULL != setting) {
 212                                 if (NULL != g_config_info->setting)     free(g_config_info->setting);
 213                                 g_config_info->setting = strdup(setting);
 214                         }
 215
 216                         if (NULL != lang) {
 217                                 if (NULL != g_config_info->language)    free(g_config_info->language);
 218                                 g_config_info->language = strdup(lang);
 219                         }
 220
 221                         if (-1 != silence)      g_config_info->silence_detection = silence;
 222
 223                         /* Call all callbacks of client*/
 224                         iter = g_slist_nth(g_config_client_list, 0);
 225
 226                         while (NULL != iter) {
 227                                 temp_client = iter->data;
 228
 229                                 if (NULL != temp_client) {
 230                                         if (NULL != temp_client->engine_cb) {
 231                                                 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
 232                                                         g_config_info->silence_detection, temp_client->user_data);
 233                                         }
 234                                 }
 235
 236                                 iter = g_slist_next(iter);
 237                         }
 238                 }
 239
 240                 if (-1 != auto_lang) {
 241                         g_config_info->auto_lang = auto_lang;
 242                 }
 243
 244                 /* Only language changed */
 245                 if (NULL == engine && NULL != lang) {
 246                         char* before_lang = NULL;
 247                         before_lang = strdup(g_config_info->language);
 248
 249                         if (NULL != lang) {
 250                                 if (NULL != g_config_info->language)    free(g_config_info->language);
 251                                 g_config_info->language = strdup(lang);
 252                         }
 253
 254                         /* Call all callbacks of client*/
 255                         iter = g_slist_nth(g_config_client_list, 0);
 256
 257                         while (NULL != iter) {
 258                                 temp_client = iter->data;
 259
 260                                 if (NULL != temp_client) {
 261                                         if (NULL != temp_client->lang_cb) {
 262                                                 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
 263                                         }
 264                                 }
 265
 266                                 iter = g_slist_next(iter);
 267                         }
 268
 269                         if (NULL != before_lang) {
 270                                 free(before_lang);
 271                         }
 272                 }
 273
 274                 if (-1 != silence) {
 275                         /* silence detection changed */
 276                         g_config_info->silence_detection = silence;
 277
 278                         /* Call all callbacks of client*/
 279                         iter = g_slist_nth(g_config_client_list, 0);
 280
 281                         while (NULL != iter) {
 282                                 temp_client = iter->data;
 283
 284                                 if (NULL != temp_client) {
 285                                         if (NULL != temp_client->bool_cb) {
 286                                                 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
 287                                         }
 288                                 }
 289
 290                                 iter = g_slist_next(iter);
 291                         }
 292                 }
 293
 294                 if (NULL != engine)     free(engine);
 295                 if (NULL != setting)    free(setting);
 296                 if (NULL != lang)       free(lang);
 297         } else {
 298                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
 299         }
 300
 301         SLOG(LOG_DEBUG, stt_tag(), "=====");
 302         SLOG(LOG_DEBUG, stt_tag(), " ");
 303
 304         return ECORE_CALLBACK_PASS_ON;
 305 }
 306
 307 int __stt_config_mgr_register_config_event()
 308 {
 309         /* get file notification handler */
 310         int fd;
 311         int wd;
 312
 313         fd = inotify_init();
 314         if (fd < 0) {
 315                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
 316                 return -1;
 317         }
 318         g_fd_noti = fd;
 319
 320         wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
 321         g_wd_noti = wd;
 322
 323         g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
 324         if (NULL == g_fd_handler_noti) {
 325                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
 326                 return -1;
 327         }
 328
 329         return 0;
 330 }
 331
 332 int __stt_config_mgr_unregister_config_event()
 333 {
 334         /* delete inotify variable */
 335         ecore_main_fd_handler_del(g_fd_handler_noti);
 336         inotify_rm_watch(g_fd_noti, g_wd_noti);
 337         close(g_fd_noti);
 338
 339         return 0;
 340 }
 341
 342 int __stt_config_set_auto_language()
 343 {
 344         char* value = NULL;
 345         char candidate_lang[6] = {'\0', };
 346
 347         value = vconf_get_str(VCONFKEY_LANGSET);
 348         if (NULL == value) {
 349                 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
 350                 return -1;
 351         }
 352
 353         strncpy(candidate_lang, value, 5);
 354         free(value);
 355
 356         /* Check current language */
 357         if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
 358                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
 359                 return 0;
 360         } else {
 361                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
 362         }
 363
 364         if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
 365                 /* stt default language change */
 366                 if (NULL == g_config_info->language) {
 367                         SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
 368                         return -1;
 369                 }
 370
 371                 char* before_lang = NULL;
 372                 if (0 != stt_parser_set_language(candidate_lang)) {
 373                         SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
 374                         return -1;
 375                 }
 376
 377                 before_lang = strdup(g_config_info->language);
 378
 379                 free(g_config_info->language);
 380                 g_config_info->language = strdup(candidate_lang);
 381
 382                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
 383
 384                 /* Call all callbacks of client*/
 385                 GSList *iter = NULL;
 386                 stt_config_client_s* temp_client = NULL;
 387
 388                 iter = g_slist_nth(g_config_client_list, 0);
 389
 390                 while (NULL != iter) {
 391                         temp_client = iter->data;
 392
 393                         if (NULL != temp_client) {
 394                                 if (NULL != temp_client->lang_cb) {
 395                                         temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
 396                                 }
 397                         }
 398
 399                         iter = g_slist_next(iter);
 400                 }
 401
 402                 if (NULL != before_lang) {
 403                         free(before_lang);
 404                 }
 405         } else {
 406                 /* Candidate language is not valid */
 407                 char* tmp_language = NULL;
 408                 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
 409                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
 410                         return -1;
 411                 }
 412
 413                 if (NULL == tmp_language) {
 414                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
 415                         return -1;
 416                 }
 417
 418                 if (0 != stt_parser_set_language(tmp_language)) {
 419                         free(tmp_language);
 420                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
 421                         return -1;
 422                 }
 423
 424                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
 425
 426                 /* Call all callbacks of client*/
 427                 GSList *iter = NULL;
 428                 stt_config_client_s* temp_client = NULL;
 429
 430                 iter = g_slist_nth(g_config_client_list, 0);
 431
 432                 while (NULL != iter) {
 433                         temp_client = iter->data;
 434
 435                         if (NULL != temp_client) {
 436                                 if (NULL != temp_client->lang_cb) {
 437                                         temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
 438                                 }
 439                         }
 440
 441                         iter = g_slist_next(iter);
 442                 }
 443
 444                 if (NULL != g_config_info->language) {
 445                         free(g_config_info->language);
 446                         g_config_info->language = strdup(tmp_language);
 447                 }
 448
 449                 free(tmp_language);
 450         }
 451
 452         return 0;
 453 }
 454
 455 void __stt_config_language_changed_cb(keynode_t *key, void *data)
 456 {
 457         if (true == g_config_info->auto_lang) {
 458                 /* Get voice input vconf key */
 459                 __stt_config_set_auto_language();
 460         }
 461
 462         return;
 463 }
 464
 465 void __stt_config_release_client(int uid)
 466 {
 467         GSList *iter = NULL;
 468         stt_config_client_s* temp_client = NULL;
 469
 470         if (0 < g_slist_length(g_config_client_list)) {
 471                 /* Check uid */
 472                 iter = g_slist_nth(g_config_client_list, 0);
 473
 474                 while (NULL != iter) {
 475                         temp_client = iter->data;
 476
 477                         if (NULL != temp_client) {
 478                                 if (uid == temp_client->uid) {
 479                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 480                                         free(temp_client);
 481                                         temp_client = NULL;
 482                                         break;
 483                                 }
 484                         }
 485
 486                         iter = g_slist_next(iter);
 487                 }
 488         }
 489
 490         if (0 < g_slist_length(g_config_client_list)) {
 491                 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
 492         }
 493         return;
 494 }
 495
 496 void __stt_config_release_engine()
 497 {
 498         GSList *iter = NULL;
 499         stt_engine_info_s *engine_info = NULL;
 500
 501         if (0 < g_slist_length(g_engine_list)) {
 502
 503                 /* Get a first item */
 504                 iter = g_slist_nth(g_engine_list, 0);
 505
 506                 while (NULL != iter) {
 507                         engine_info = iter->data;
 508
 509                         if (NULL != engine_info) {
 510                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 511
 512                                 stt_parser_free_engine_info(engine_info);
 513                         }
 514
 515                         iter = g_slist_nth(g_engine_list, 0);
 516                 }
 517         }
 518         return;
 519 }
 520
 521 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
 522 {
 523         if (NULL == engine_id) {
 524                 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
 525                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 526         }
 527
 528         GSList *iter = NULL;
 529         stt_engine_info_s *engine_info = NULL;
 530
 531         if (0 >= g_slist_length(g_engine_list)) {
 532                 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
 533                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 534         }
 535
 536         /* Get a first item */
 537         iter = g_slist_nth(g_engine_list, 0);
 538
 539         while (NULL != iter) {
 540                 engine_info = iter->data;
 541
 542                 if (NULL == engine_info) {
 543                         SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
 544                         return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 545                 }
 546
 547                 if (0 == strcmp(engine_id, engine_info->uuid)) {
 548                         SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
 549                         return STT_CONFIG_ERROR_NONE;
 550                 }
 551
 552                 iter = g_slist_next(iter);
 553         }
 554
 555         /* Change default engine */
 556         iter = g_slist_nth(g_engine_list, 0);
 557         engine_info = iter->data;
 558         if (NULL == engine_info) {
 559                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
 560                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 561         }
 562
 563         if (NULL != g_config_info->engine_id) {
 564                 free(g_config_info->engine_id);
 565                 g_config_info->engine_id = NULL;
 566         }
 567         if (NULL != g_config_info->setting) {
 568                 free(g_config_info->setting);
 569                 g_config_info->setting = NULL;
 570         }
 571
 572         if (NULL != engine_info->uuid) {
 573                 g_config_info->engine_id = strdup(engine_info->uuid);
 574         }
 575
 576         if (NULL != engine_info->setting) {
 577                 g_config_info->setting = strdup(engine_info->setting);
 578         }
 579
 580         /* Engine is valid*/
 581         GSList *iter_lang = NULL;
 582         char* lang;
 583         bool is_valid_lang = false;
 584
 585         if (0 >= g_slist_length(engine_info->languages)) {
 586                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
 587                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 588         }
 589
 590         /* Get a first item */
 591         iter_lang = g_slist_nth(engine_info->languages, 0);
 592
 593         while (NULL != iter_lang) {
 594                 /*Get handle data from list*/
 595                 lang = iter_lang->data;
 596
 597                 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
 598                 if (NULL != lang) {
 599                         if (0 == strcmp(lang, g_config_info->language)) {
 600                                 /* language is valid */
 601                                 is_valid_lang = true;
 602                                 break;
 603                         }
 604                 }
 605
 606                 /*Get next item*/
 607                 iter_lang = g_slist_next(iter_lang);
 608         }
 609
 610         if (false == is_valid_lang) {
 611                 iter_lang = g_slist_nth(engine_info->languages, 0);
 612                 if (NULL != iter_lang) {
 613                         lang = iter_lang->data;
 614                         if (NULL != lang) {
 615                                 if (NULL != g_config_info->language)
 616                                         free(g_config_info->language);
 617                                 g_config_info->language = strdup(lang);
 618                         }
 619                 }
 620         }
 621
 622         /* Check options */
 623         if (false == engine_info->support_silence_detection) {
 624                 if (true == g_config_info->silence_detection)
 625                         g_config_info->silence_detection = false;
 626         }
 627
 628         SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
 629         SLOG(LOG_DEBUG, stt_tag(), "  Engine : %s", g_config_info->engine_id);
 630         SLOG(LOG_DEBUG, stt_tag(), "  Setting : %s", g_config_info->setting);
 631         SLOG(LOG_DEBUG, stt_tag(), "  language : %s", g_config_info->language);
 632         SLOG(LOG_DEBUG, stt_tag(), "  Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 633
 634         if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
 635                 g_config_info->silence_detection)) {
 636                         SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
 637                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 638         }
 639
 640         return STT_CONFIG_ERROR_NONE;
 641 }
 642
 643 int stt_config_mgr_initialize(int uid)
 644 {
 645         GSList *iter = NULL;
 646         int* get_uid;
 647         stt_config_client_s* temp_client = NULL;
 648
 649         if (0 < g_slist_length(g_config_client_list)) {
 650                 /* Check uid */
 651                 iter = g_slist_nth(g_config_client_list, 0);
 652
 653                 while (NULL != iter) {
 654                         get_uid = iter->data;
 655
 656                         if (uid == *get_uid) {
 657                                 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
 658                                 return 0;
 659                         }
 660
 661                         iter = g_slist_next(iter);
 662                 }
 663
 664                 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 665                 if (NULL == temp_client) {
 666                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
 667                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;
 668                 }
 669                 temp_client->uid = uid;
 670                 temp_client->bool_cb = NULL;
 671                 temp_client->engine_cb = NULL;
 672                 temp_client->lang_cb = NULL;
 673                 temp_client->user_data = NULL;
 674
 675                 /* Add uid */
 676                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 677
 678                 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
 679                 return STT_CONFIG_ERROR_NONE;
 680         }
 681
 682         /* Get file name from default engine directory */
 683         DIR *dp = NULL;
 684         int ret = -1;
 685         struct dirent entry;
 686         struct dirent *dirp = NULL;
 687
 688         g_engine_list = NULL;
 689
 690         SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
 691         dp  = opendir(STT_DEFAULT_ENGINE_INFO);
 692         if (NULL != dp) {
 693                 do {
 694                         ret = readdir_r(dp, &entry, &dirp);
 695                         if (0 != ret) {
 696                                 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
 697                                 break;
 698                         }
 699
 700                         if (NULL != dirp) {
 701                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 702                                         continue;
 703
 704                                 stt_engine_info_s* info;
 705                                 char* filepath;
 706                                 int filesize;
 707
 708                                 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
 709                                 filepath = (char*)calloc(filesize, sizeof(char));
 710
 711                                 if (NULL != filepath) {
 712                                         snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
 713                                 } else {
 714                                         SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
 715                                         continue;
 716                                 }
 717
 718                                 if (0 == stt_parser_get_engine_info(filepath, &info)) {
 719                                         g_engine_list = g_slist_append(g_engine_list, info);
 720                                 }
 721
 722                                 if (NULL != filepath)
 723                                         free(filepath);
 724                         }
 725                 } while (NULL != dirp);
 726
 727                 closedir(dp);
 728         } else {
 729                 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
 730         }
 731
 732         __stt_config_mgr_print_engine_info();
 733
 734         if (0 != stt_parser_load_config(&g_config_info)) {
 735                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
 736                 __stt_config_release_client(uid);
 737                 __stt_config_release_engine();
 738                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 739         }
 740
 741         /* Check whether engine id is valid */
 742         if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
 743                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
 744                 __stt_config_release_client(uid);
 745                 __stt_config_release_engine();
 746                 stt_parser_unload_config(g_config_info);
 747                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 748         }
 749
 750         if (true == g_config_info->auto_lang) {
 751                 /* Check language with display language */
 752                 __stt_config_set_auto_language();
 753         } else {
 754                 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
 755                         /* Default language is not valid */
 756                         char* tmp_language;
 757                         if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
 758                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
 759                                 __stt_config_release_client(uid);
 760                                 __stt_config_release_engine();
 761                                 stt_parser_unload_config(g_config_info);
 762                                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 763                         }
 764
 765                         if (NULL != tmp_language) {
 766                                 if (NULL != g_config_info->language) {
 767                                         free(g_config_info->language);
 768                                         g_config_info->language = strdup(tmp_language);
 769                                 }
 770
 771                                 free(tmp_language);
 772                         }
 773                 }
 774         }
 775
 776         /* print daemon config */
 777         SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
 778         SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
 779         SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
 780         SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
 781         SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
 782         SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 783         SLOG(LOG_DEBUG, stt_tag(), "===================");
 784
 785         if (0 != __stt_config_mgr_register_config_event()) {
 786                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
 787                 __stt_config_release_client(uid);
 788                 __stt_config_release_engine();
 789                 stt_parser_unload_config(g_config_info);
 790                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 791         }
 792
 793         /* Register to detect display language change */
 794         vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
 795
 796         temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 797         if (NULL == temp_client) {
 798                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
 799                 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
 800         }
 801         temp_client->uid = uid;
 802         temp_client->bool_cb = NULL;
 803         temp_client->engine_cb = NULL;
 804         temp_client->lang_cb = NULL;
 805         temp_client->user_data = NULL;
 806
 807         /* Add uid */
 808         g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 809
 810         return STT_CONFIG_ERROR_NONE;
 811 }
 812
 813 int stt_config_mgr_finalize(int uid)
 814 {
 815         GSList *iter = NULL;
 816         stt_config_client_s* temp_client = NULL;
 817
 818         if (0 < g_slist_length(g_config_client_list)) {
 819                 /* Check uid */
 820                 iter = g_slist_nth(g_config_client_list, 0);
 821
 822                 while (NULL != iter) {
 823                         temp_client = iter->data;
 824
 825                         if (NULL != temp_client) {
 826                                 if (uid == temp_client->uid) {
 827                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 828                                         free(temp_client);
 829                                         temp_client = NULL;
 830                                         break;
 831                                 }
 832                         }
 833
 834                         iter = g_slist_next(iter);
 835                 }
 836         }
 837
 838         if (0 < g_slist_length(g_config_client_list)) {
 839                 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
 840                 return STT_CONFIG_ERROR_NONE;
 841         }
 842
 843         stt_engine_info_s *engine_info = NULL;
 844
 845         if (0 < g_slist_length(g_engine_list)) {
 846
 847                 /* Get a first item */
 848                 iter = g_slist_nth(g_engine_list, 0);
 849
 850                 while (NULL != iter) {
 851                         engine_info = iter->data;
 852
 853                         if (NULL != engine_info) {
 854                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 855
 856                                 stt_parser_free_engine_info(engine_info);
 857                         }
 858
 859                         iter = g_slist_nth(g_engine_list, 0);
 860                 }
 861         }
 862
 863         vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
 864
 865         __stt_config_mgr_unregister_config_event();
 866
 867         if (NULL != g_config_info) {
 868                 stt_parser_unload_config(g_config_info);
 869                 g_config_info = NULL;
 870         }
 871
 872         return STT_CONFIG_ERROR_NONE;
 873 }
 874
 875 int stt_config_mgr_set_callback(int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data)
 876 {
 877         GSList *iter = NULL;
 878         stt_config_client_s* temp_client = NULL;
 879
 880         /* Call all callbacks of client*/
 881         iter = g_slist_nth(g_config_client_list, 0);
 882
 883         while (NULL != iter) {
 884                 temp_client = iter->data;
 885
 886                 if (NULL != temp_client) {
 887                         if (uid == temp_client->uid) {
 888                                 temp_client->engine_cb = engine_cb;
 889                                 temp_client->lang_cb = lang_cb;
 890                                 temp_client->bool_cb = bool_cb;
 891                                 temp_client->user_data = user_data;
 892                         }
 893                 }
 894
 895                 iter = g_slist_next(iter);
 896         }
 897
 898         return STT_CONFIG_ERROR_NONE;
 899 }
 900
 901 int stt_config_mgr_unset_callback(int uid)
 902 {
 903         GSList *iter = NULL;
 904         stt_config_client_s* temp_client = NULL;
 905
 906         /* Call all callbacks of client*/
 907         iter = g_slist_nth(g_config_client_list, 0);
 908
 909         while (NULL != iter) {
 910                 temp_client = iter->data;
 911
 912                 if (NULL != temp_client) {
 913                         if (uid == temp_client->uid) {
 914                                 temp_client->engine_cb = NULL;
 915                                 temp_client->lang_cb = NULL;
 916                                 temp_client->bool_cb = NULL;
 917                                 temp_client->user_data = NULL;
 918                         }
 919                 }
 920
 921                 iter = g_slist_next(iter);
 922         }
 923
 924         return STT_CONFIG_ERROR_NONE;
 925 }
 926
 927 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
 928 {
 929         if (0 >= g_slist_length(g_config_client_list)) {
 930                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 931                 return STT_CONFIG_ERROR_INVALID_STATE;
 932         }
 933
 934         if (NULL == callback) {
 935                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 936         }
 937
 938         GSList *iter = NULL;
 939         stt_engine_info_s *engine_info = NULL;
 940
 941         if (0 >= g_slist_length(g_engine_list)) {
 942                 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
 943                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 944         }
 945
 946         /* Get a first item */
 947         iter = g_slist_nth(g_engine_list, 0);
 948
 949         while (NULL != iter) {
 950                 engine_info = iter->data;
 951
 952                 if (NULL == engine_info) {
 953                         SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
 954                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 955                 }
 956
 957                 if (false == callback(engine_info->uuid, engine_info->name,
 958                         engine_info->setting, engine_info->support_silence_detection, user_data)) {
 959                         break;
 960                 }
 961
 962                 iter = g_slist_next(iter);
 963         }
 964
 965         return STT_CONFIG_ERROR_NONE;
 966 }
 967
 968 int stt_config_mgr_get_engine(char** engine)
 969 {
 970         if (0 >= g_slist_length(g_config_client_list)) {
 971                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 972                 return STT_CONFIG_ERROR_INVALID_STATE;
 973         }
 974
 975         if (NULL == engine) {
 976                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 977         }
 978
 979         if (NULL != g_config_info->engine_id) {
 980                 *engine = strdup(g_config_info->engine_id);
 981         } else {
 982                 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
 983                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 984         }
 985
 986         return STT_CONFIG_ERROR_NONE;
 987 }
 988
 989 int stt_config_mgr_set_engine(const char* engine)
 990 {
 991         if (0 >= g_slist_length(g_config_client_list)) {
 992                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 993                 return STT_CONFIG_ERROR_INVALID_STATE;
 994         }
 995
 996         if (NULL == g_config_info) {
 997                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 998         }
 999
1000         if (NULL == engine || NULL == g_config_info->engine_id) {
1001                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1002         }
1003
1004         /* Check current engine id with new engine id */
1005         if (0 == strcmp(g_config_info->engine_id, engine)) {
1006                 return 0;
1007         }
1008
1009         SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1010
1011         GSList *iter = NULL;
1012         stt_engine_info_s *engine_info = NULL;
1013         bool is_valid_engine = false;
1014
1015         /* Get a first item */
1016         iter = g_slist_nth(g_engine_list, 0);
1017
1018         while (NULL != iter) {
1019                 engine_info = iter->data;
1020
1021                 if (NULL == engine_info) {
1022                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1023                         iter = g_slist_next(iter);
1024                         continue;
1025                 }
1026
1027                 /* Check engine id is valid */
1028                 if (0 != strcmp(engine, engine_info->uuid)) {
1029                         iter = g_slist_next(iter);
1030                         continue;
1031                 }
1032
1033                 if (NULL != g_config_info->engine_id)
1034                         free(g_config_info->engine_id);
1035
1036                 g_config_info->engine_id = strdup(engine);
1037
1038                 if (NULL != g_config_info->setting) {
1039                         free(g_config_info->setting);
1040                 }
1041
1042                 if (NULL != engine_info->setting) {
1043                         g_config_info->setting = strdup(engine_info->setting);
1044                 } else {
1045                         g_config_info->setting = NULL;
1046                 }
1047
1048                 /* Engine is valid*/
1049                 GSList *iter_lang = NULL;
1050                 char* lang;
1051                 bool is_valid_lang = false;
1052
1053                 /* Get a first item */
1054                 iter_lang = g_slist_nth(engine_info->languages, 0);
1055
1056                 while (NULL != iter_lang) {
1057                         /*Get handle data from list*/
1058                         lang = iter_lang->data;
1059
1060                         SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1061                         if (NULL != lang) {
1062                                 if (0 == strcmp(lang, g_config_info->language)) {
1063                                         /* language is valid */
1064                                         is_valid_lang = true;
1065
1066                                         if (NULL != g_config_info->language) {
1067                                                 free(g_config_info->language);
1068
1069                                                 g_config_info->language = strdup(lang);
1070                                         }
1071                                         break;
1072                                 }
1073                         }
1074
1075                         /*Get next item*/
1076                         iter_lang = g_slist_next(iter_lang);
1077                 }
1078
1079                 if (false == is_valid_lang) {
1080                         if (NULL != g_config_info->language) {
1081                                 free(g_config_info->language);
1082
1083                                 iter_lang = g_slist_nth(engine_info->languages, 0);
1084                                 lang = iter_lang->data;
1085
1086                                 g_config_info->language = strdup(lang);
1087                         }
1088                 }
1089
1090                 /* Check options */
1091                 if (false == engine_info->support_silence_detection) {
1092                         if (true == g_config_info->silence_detection)
1093                                 g_config_info->silence_detection = false;
1094                 }
1095
1096                 is_valid_engine = true;
1097                 break;
1098         }
1099
1100         if (true == is_valid_engine) {
1101                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1102                 SLOG(LOG_DEBUG, stt_tag(), "  Engine : %s", g_config_info->engine_id);
1103                 SLOG(LOG_DEBUG, stt_tag(), "  Setting : %s", g_config_info->setting);
1104                 SLOG(LOG_DEBUG, stt_tag(), "  language : %s", g_config_info->language);
1105                 SLOG(LOG_DEBUG, stt_tag(), "  Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1106
1107                 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1108                         g_config_info->silence_detection)) {
1109                                 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1110                                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1111                 }
1112         } else {
1113                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1114                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1115         }
1116
1117         return 0;
1118 }
1119
1120 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1121 {
1122         if (0 >= g_slist_length(g_engine_list)) {
1123                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1124                 return STT_CONFIG_ERROR_INVALID_STATE;
1125         }
1126
1127         if (NULL == agreement) {
1128                 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1129                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1130         }
1131
1132         GSList *iter = NULL;
1133         stt_engine_info_s *engine_info = NULL;
1134         char* current_engine = NULL;
1135
1136         if (NULL == engine) {
1137                 current_engine = strdup(g_config_info->engine_id);
1138                 if (NULL == current_engine) {
1139                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1140                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1141                 }
1142         } else {
1143                 current_engine = strdup(engine);
1144                 if (NULL == current_engine) {
1145                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1146                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1147                 }
1148         }
1149
1150         /* Get a first item */
1151         iter = g_slist_nth(g_engine_list, 0);
1152
1153         while (NULL != iter) {
1154                 engine_info = iter->data;
1155
1156                 if (NULL == engine_info) {
1157                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1158                         if (NULL != current_engine)     free(current_engine);
1159                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1160                 }
1161
1162                 if (0 != strcmp(current_engine, engine_info->uuid)) {
1163                         iter = g_slist_next(iter);
1164                         continue;
1165                 }
1166
1167                 if (NULL != engine_info->agreement) {
1168                         *agreement = strdup(engine_info->agreement);
1169                 } else {
1170                         SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1171                 }
1172                 break;
1173         }
1174
1175         if (NULL != current_engine)     free(current_engine);
1176
1177         return STT_CONFIG_ERROR_NONE;
1178 }
1179
1180 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1181 {
1182         if (0 >= g_slist_length(g_config_client_list)) {
1183                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1184                 return STT_CONFIG_ERROR_INVALID_STATE;
1185         }
1186
1187         if (0 >= g_slist_length(g_engine_list)) {
1188                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1189                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1190         }
1191
1192         GSList *iter = NULL;
1193         stt_engine_info_s *engine_info = NULL;
1194
1195         /* Get a first item */
1196         iter = g_slist_nth(g_engine_list, 0);
1197
1198         while (NULL != iter) {
1199                 engine_info = iter->data;
1200
1201                 if (NULL == engine_info) {
1202                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1203                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1204                 }
1205
1206                 if (0 != strcmp(engine_id, engine_info->uuid)) {
1207                         iter = g_slist_next(iter);
1208                         continue;
1209                 }
1210
1211                 GSList *iter_lang = NULL;
1212                 char* lang;
1213
1214                 /* Get a first item */
1215                 iter_lang = g_slist_nth(engine_info->languages, 0);
1216
1217                 while (NULL != iter_lang) {
1218                         /*Get handle data from list*/
1219                         lang = iter_lang->data;
1220
1221                         SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1222                         if (NULL != lang) {
1223                                 if (false == callback(engine_info->uuid, lang, user_data))
1224                                         break;
1225                         }
1226
1227                         /*Get next item*/
1228                         iter_lang = g_slist_next(iter_lang);
1229                 }
1230                 break;
1231         }
1232
1233         return STT_CONFIG_ERROR_NONE;
1234 }
1235
1236 int stt_config_mgr_get_default_language(char** language)
1237 {
1238         if (0 >= g_slist_length(g_config_client_list)) {
1239                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1240                 return STT_CONFIG_ERROR_INVALID_STATE;
1241         }
1242
1243         if (NULL == language) {
1244                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1245         }
1246
1247         if (NULL != g_config_info->language) {
1248                 *language = strdup(g_config_info->language);
1249         } else {
1250                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1251                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1252         }
1253
1254         return STT_CONFIG_ERROR_NONE;
1255 }
1256
1257 int stt_config_mgr_set_default_language(const char* language)
1258 {
1259         if (0 >= g_slist_length(g_config_client_list)) {
1260                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1261                 return STT_CONFIG_ERROR_INVALID_STATE;
1262         }
1263
1264         if (NULL == language) {
1265                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1266         }
1267
1268         /* Check language is valid */
1269         if (NULL != g_config_info->language) {
1270                 if (0 != stt_parser_set_language(language)) {
1271                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1272                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1273                 }
1274                 free(g_config_info->language);
1275                 g_config_info->language = strdup(language);
1276         } else {
1277                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1278                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1279         }
1280
1281         return STT_CONFIG_ERROR_NONE;
1282 }
1283
1284 int stt_config_mgr_get_auto_language(bool* value)
1285 {
1286         if (0 >= g_slist_length(g_config_client_list)) {
1287                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1288                 return STT_CONFIG_ERROR_INVALID_STATE;
1289         }
1290
1291         if (NULL == value) {
1292                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1293         }
1294
1295         *value = g_config_info->auto_lang;
1296
1297         return STT_CONFIG_ERROR_NONE;
1298 }
1299
1300 int stt_config_mgr_set_auto_language(bool value)
1301 {
1302         if (0 >= g_slist_length(g_config_client_list)) {
1303                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1304                 return STT_CONFIG_ERROR_INVALID_STATE;
1305         }
1306
1307         if (g_config_info->auto_lang != value) {
1308                 /* Check language is valid */
1309                 if (0 != stt_parser_set_auto_lang(value)) {
1310                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1311                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1312                 }
1313                 g_config_info->auto_lang = value;
1314
1315                 if (true == g_config_info->auto_lang) {
1316                         __stt_config_set_auto_language();
1317                 }
1318         }
1319
1320         return STT_CONFIG_ERROR_NONE;
1321 }
1322
1323 int stt_config_mgr_get_silence_detection(bool* value)
1324 {
1325         if (0 >= g_slist_length(g_config_client_list)) {
1326                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1327                 return STT_CONFIG_ERROR_INVALID_STATE;
1328         }
1329
1330         if (NULL == value)
1331                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1332
1333         *value = g_config_info->silence_detection;
1334
1335         return STT_CONFIG_ERROR_NONE;
1336 }
1337
1338 int stt_config_mgr_set_silence_detection(bool value)
1339 {
1340         if (0 >= g_slist_length(g_config_client_list)) {
1341                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1342                 return STT_CONFIG_ERROR_INVALID_STATE;
1343         }
1344
1345         if (0 != stt_parser_set_silence_detection(value)) {
1346                 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1347                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1348         }
1349
1350         g_config_info->silence_detection = value;
1351
1352         return STT_CONFIG_ERROR_NONE;
1353 }
1354
1355 bool stt_config_check_default_engine_is_valid(const char* engine)
1356 {
1357         if (0 >= g_slist_length(g_config_client_list)) {
1358                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1359                 return false;
1360         }
1361
1362         if (NULL == engine) {
1363                 return false;
1364         }
1365
1366         if (0 >= g_slist_length(g_engine_list))
1367                 return false;
1368
1369         GSList *iter = NULL;
1370         stt_engine_info_s *engine_info = NULL;
1371
1372         /* Get a first item */
1373         iter = g_slist_nth(g_engine_list, 0);
1374
1375         while (NULL != iter) {
1376                 engine_info = iter->data;
1377
1378                 if (NULL != engine_info) {
1379                         if (0 == strcmp(engine, engine_info->uuid)) {
1380                                 return true;
1381                         }
1382                 }
1383                 iter = g_slist_next(iter);
1384         }
1385
1386         return false;
1387 }
1388
1389 bool stt_config_check_default_language_is_valid(const char* language)
1390 {
1391         if (0 >= g_slist_length(g_config_client_list)) {
1392                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1393                 return false;
1394         }
1395
1396         if (NULL == language) {
1397                 return false;
1398         }
1399
1400         if (NULL == g_config_info->engine_id) {
1401                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1402                 return false;
1403         }
1404
1405         if (0 >= g_slist_length(g_engine_list))
1406                 return false;
1407
1408         GSList *iter = NULL;
1409         stt_engine_info_s *engine_info = NULL;
1410
1411         /* Get a first item */
1412         iter = g_slist_nth(g_engine_list, 0);
1413
1414         while (NULL != iter) {
1415                 engine_info = iter->data;
1416
1417                 if (NULL == engine_info) {
1418                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1419                         iter = g_slist_next(iter);
1420                         continue;
1421                 }
1422
1423                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1424                         iter = g_slist_next(iter);
1425                         continue;
1426                 }
1427
1428                 GSList *iter_lang = NULL;
1429                 char* lang;
1430
1431                 /* Get a first item */
1432                 iter_lang = g_slist_nth(engine_info->languages, 0);
1433
1434                 while (NULL != iter_lang) {
1435                         lang = iter_lang->data;
1436
1437                         if (0 == strcmp(language, lang))
1438                                 return true;
1439
1440                         /*Get next item*/
1441                         iter_lang = g_slist_next(iter_lang);
1442                 }
1443                 break;
1444         }
1445
1446         return false;
1447 }
1448
1449 int __stt_config_mgr_print_engine_info()
1450 {
1451         GSList *iter = NULL;
1452         stt_engine_info_s *engine_info = NULL;
1453
1454         if (0 >= g_slist_length(g_engine_list)) {
1455                 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1456                 SLOG(LOG_DEBUG, stt_tag(), "  No Engine in engine directory");
1457                 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1458                 return 0;
1459         }
1460
1461         /* Get a first item */
1462         iter = g_slist_nth(g_engine_list, 0);
1463
1464         SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1465
1466         int i = 1;
1467         while (NULL != iter) {
1468                 engine_info = iter->data;
1469
1470                 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1471                 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1472                 SLOG(LOG_DEBUG, stt_tag(), " id   : %s", engine_info->uuid);
1473                 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1474                 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1475
1476                 SLOG(LOG_DEBUG, stt_tag(), " languages");
1477                 GSList *iter_lang = NULL;
1478                 char* lang;
1479                 if (g_slist_length(engine_info->languages) > 0) {
1480                         /* Get a first item */
1481                         iter_lang = g_slist_nth(engine_info->languages, 0);
1482
1483                         int j = 1;
1484                         while (NULL != iter_lang) {
1485                                 /*Get handle data from list*/
1486                                 lang = iter_lang->data;
1487
1488                                 SLOG(LOG_DEBUG, stt_tag(), "  [%dth] %s", j, lang);
1489
1490                                 /*Get next item*/
1491                                 iter_lang = g_slist_next(iter_lang);
1492                                 j++;
1493                         }
1494                 } else {
1495                         SLOG(LOG_ERROR, stt_tag(), "  language is NONE");
1496                 }
1497                 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1498                         engine_info->support_silence_detection ? "true" : "false");
1499                 iter = g_slist_next(iter);
1500                 i++;
1501         }
1502         SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1503
1504         return 0;
1505 }
1506
1507
1508
1509 /**
1510 * time info functions
1511 */
1512 static GSList* g_time_list = NULL;
1513
1514 int stt_config_mgr_reset_time_info()
1515 {
1516         /* Remove time info */
1517         GSList *iter = NULL;
1518         stt_result_time_info_s *data = NULL;
1519
1520         /* Remove time info */
1521         iter = g_slist_nth(g_time_list, 0);
1522         while (NULL != iter) {
1523                 data = iter->data;
1524
1525                 g_time_list = g_slist_remove(g_time_list, data);
1526                 if (NULL != data) {
1527                         if (NULL != data->text) {
1528                                 free(data->text);
1529                                 data->text = NULL;
1530                         }
1531                         free(data);
1532                         data = NULL;
1533                 }
1534
1535                 /*Get next item*/
1536                 iter = g_slist_nth(g_time_list, 0);
1537         }
1538
1539         return 0;
1540 }
1541
1542 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1543 {
1544         if (NULL == text) {
1545                 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1546                 return -1;
1547         }
1548
1549         stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1550         if (NULL == info) {
1551                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1552                 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1553         }
1554         info->index = index;
1555         info->event = event;
1556         if (NULL != text) {
1557                 info->text = strdup(text);
1558         }
1559         info->start_time = start_time;
1560         info->end_time = end_time;
1561
1562         /* Add item to global list */
1563         g_time_list = g_slist_append(g_time_list, info);
1564
1565         return 0;
1566 }
1567
1568 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1569 {
1570         if (NULL == callback) {
1571                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1572                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1573         }
1574
1575         GSList* temp_time = NULL;
1576         int ret;
1577         ret = stt_parser_get_time_info(&temp_time);
1578         if (0 != ret) {
1579                 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1580                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1581         }
1582
1583         GSList *iter = NULL;
1584         stt_result_time_info_s *data = NULL;
1585
1586         /* Get a first item */
1587         iter = g_slist_nth(temp_time, 0);
1588         while (NULL != iter) {
1589                 data = iter->data;
1590
1591                 if (false == callback(data->index, data->event, data->text,
1592                         data->start_time, data->end_time, user_data)) {
1593                         break;
1594                 }
1595
1596                 /*Get next item*/
1597                 iter = g_slist_next(iter);
1598         }
1599
1600         /* Remove time info */
1601         iter = g_slist_nth(temp_time, 0);
1602         while (NULL != iter) {
1603                 data = iter->data;
1604
1605                 if (NULL != data) {
1606                         temp_time = g_slist_remove(temp_time, data);
1607
1608                         if (NULL != data->text) {
1609                                 free(data->text);
1610                                 data->text = NULL;
1611                         }
1612                         free(data);
1613                         data = NULL;
1614                 }
1615
1616                 /*Get next item*/
1617                 iter = g_slist_nth(temp_time, 0);
1618         }
1619
1620         return STT_CONFIG_ERROR_NONE;
1621 }
1622
1623 int stt_config_mgr_save_time_info_file()
1624 {
1625         if (0 == g_slist_length(g_time_list)) {
1626                 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1627                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1628         }
1629
1630         int ret = 0;
1631         ret = stt_parser_set_time_info(g_time_list);
1632         if (0 != ret) {
1633                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1634                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1635         }
1636
1637         return STT_CONFIG_ERROR_NONE;
1638 }
1639
1640 int stt_config_mgr_remove_time_info_file()
1641 {
1642         stt_parser_clear_time_info();
1643
1644         return STT_CONFIG_ERROR_NONE;
1645 }