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                                 SECURE_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                                                 SECURE_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                                 SECURE_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                 SECURE_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                 SECURE_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 }
 494
 495 void __stt_config_release_engine()
 496 {
 497         GSList *iter = NULL;
 498         stt_engine_info_s *engine_info = NULL;
 499
 500         if (0 < g_slist_length(g_engine_list)) {
 501
 502                 /* Get a first item */
 503                 iter = g_slist_nth(g_engine_list, 0);
 504
 505                 while (NULL != iter) {
 506                         engine_info = iter->data;
 507
 508                         if (NULL != engine_info) {
 509                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 510
 511                                 stt_parser_free_engine_info(engine_info);
 512                         }
 513
 514                         iter = g_slist_nth(g_engine_list, 0);
 515                 }
 516         }
 517 }
 518
 519 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
 520 {
 521         if (NULL == engine_id) {
 522                 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
 523                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 524         }
 525
 526         GSList *iter = NULL;
 527         stt_engine_info_s *engine_info = NULL;
 528
 529         if (0 >= g_slist_length(g_engine_list)) {
 530                 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
 531                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 532         }
 533
 534         /* Get a first item */
 535         iter = g_slist_nth(g_engine_list, 0);
 536
 537         while (NULL != iter) {
 538                 engine_info = iter->data;
 539
 540                 if (NULL == engine_info) {
 541                         SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
 542                         return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 543                 }
 544
 545                 if (0 == strcmp(engine_id, engine_info->uuid)) {
 546                         SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
 547                         return STT_CONFIG_ERROR_NONE;
 548                 }
 549
 550                 iter = g_slist_next(iter);
 551         }
 552
 553         /* Change default engine */
 554         iter = g_slist_nth(g_engine_list, 0);
 555         engine_info = iter->data;
 556         if (NULL == engine_info) {
 557                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
 558                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 559         }
 560
 561         if (NULL != g_config_info->engine_id) {
 562                 free(g_config_info->engine_id);
 563                 g_config_info->engine_id = NULL;
 564         }
 565         if (NULL != g_config_info->setting) {
 566                 free(g_config_info->setting);
 567                 g_config_info->setting = NULL;
 568         }
 569
 570         if (NULL != engine_info->uuid) {
 571                 g_config_info->engine_id = strdup(engine_info->uuid);
 572         }
 573
 574         if (NULL != engine_info->setting) {
 575                 g_config_info->setting = strdup(engine_info->setting);
 576         }
 577
 578         /* Engine is valid*/
 579         GSList *iter_lang = NULL;
 580         char* lang;
 581         bool is_valid_lang = false;
 582
 583         if (0 >= g_slist_length(engine_info->languages)) {
 584                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
 585                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 586         }
 587
 588         /* Get a first item */
 589         iter_lang = g_slist_nth(engine_info->languages, 0);
 590
 591         while (NULL != iter_lang) {
 592                 /*Get handle data from list*/
 593                 lang = iter_lang->data;
 594
 595                 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
 596                 if (NULL != lang) {
 597                         if (0 == strcmp(lang, g_config_info->language)) {
 598                                 /* language is valid */
 599                                 is_valid_lang = true;
 600                                 break;
 601                         }
 602                 }
 603
 604                 /*Get next item*/
 605                 iter_lang = g_slist_next(iter_lang);
 606         }
 607
 608         if (false == is_valid_lang) {
 609                 iter_lang = g_slist_nth(engine_info->languages, 0);
 610                 if (NULL != iter_lang) {
 611                         lang = iter_lang->data;
 612                         if (NULL != lang) {
 613                                 if (NULL != g_config_info->language)
 614                                         free(g_config_info->language);
 615                                 g_config_info->language = strdup(lang);
 616                         }
 617                 }
 618         }
 619
 620         /* Check options */
 621         if (false == engine_info->support_silence_detection) {
 622                 if (true == g_config_info->silence_detection)
 623                         g_config_info->silence_detection = false;
 624         }
 625
 626         SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
 627         SLOG(LOG_DEBUG, stt_tag(), "  Engine : %s", g_config_info->engine_id);
 628         SLOG(LOG_DEBUG, stt_tag(), "  Setting : %s", g_config_info->setting);
 629         SLOG(LOG_DEBUG, stt_tag(), "  language : %s", g_config_info->language);
 630         SLOG(LOG_DEBUG, stt_tag(), "  Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 631
 632         if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
 633                 g_config_info->silence_detection)) {
 634                         SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
 635                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 636         }
 637
 638         return STT_CONFIG_ERROR_NONE;
 639 }
 640
 641 int stt_config_mgr_initialize(int uid)
 642 {
 643         GSList *iter = NULL;
 644         int* get_uid;
 645         stt_config_client_s* temp_client = NULL;
 646
 647         if (0 < g_slist_length(g_config_client_list)) {
 648                 /* Check uid */
 649                 iter = g_slist_nth(g_config_client_list, 0);
 650
 651                 while (NULL != iter) {
 652                         get_uid = iter->data;
 653
 654                         if (uid == *get_uid) {
 655                                 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
 656                                 return 0;
 657                         }
 658
 659                         iter = g_slist_next(iter);
 660                 }
 661
 662                 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 663                 if (NULL == temp_client) {
 664                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
 665                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;
 666                 }
 667                 temp_client->uid = uid;
 668                 temp_client->bool_cb = NULL;
 669                 temp_client->engine_cb = NULL;
 670                 temp_client->lang_cb = NULL;
 671                 temp_client->user_data = NULL;
 672
 673                 /* Add uid */
 674                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 675
 676                 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
 677                 return STT_CONFIG_ERROR_NONE;
 678         }
 679
 680         /* Get file name from default engine directory */
 681         DIR *dp = NULL;
 682         int ret = -1;
 683         struct dirent entry;
 684         struct dirent *dirp = NULL;
 685
 686         g_engine_list = NULL;
 687
 688         dp  = opendir(STT_DEFAULT_ENGINE_INFO);
 689         if (NULL != dp) {
 690                 do {
 691                         ret = readdir_r(dp, &entry, &dirp);
 692                         if (0 != ret) {
 693                                 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
 694                                 break;
 695                         }
 696
 697                         if (NULL != dirp) {
 698                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 699                                         continue;
 700
 701                                 stt_engine_info_s* info;
 702                                 char* filepath;
 703                                 int filesize;
 704
 705                                 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
 706                                 filepath = (char*)calloc(filesize, sizeof(char));
 707
 708                                 if (NULL != filepath) {
 709                                         snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
 710                                 } else {
 711                                         SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
 712                                         continue;
 713                                 }
 714
 715                                 if (0 == stt_parser_get_engine_info(filepath, &info)) {
 716                                         g_engine_list = g_slist_append(g_engine_list, info);
 717                                 }
 718
 719                                 if (NULL != filepath)
 720                                         free(filepath);
 721                         }
 722                 } while (NULL != dirp);
 723
 724                 closedir(dp);
 725         } else {
 726                 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
 727         }
 728
 729         __stt_config_mgr_print_engine_info();
 730
 731         if (0 != stt_parser_load_config(&g_config_info)) {
 732                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
 733                 __stt_config_release_client(uid);
 734                 __stt_config_release_engine();
 735                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 736         }
 737
 738         /* Check whether engine id is valid */
 739         if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
 740                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
 741                 __stt_config_release_client(uid);
 742                 __stt_config_release_engine();
 743                 stt_parser_unload_config(g_config_info);
 744                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 745         }
 746
 747         if (true == g_config_info->auto_lang) {
 748                 /* Check language with display language */
 749                 __stt_config_set_auto_language();
 750         } else {
 751                 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
 752                         /* Default language is not valid */
 753                         char* tmp_language;
 754                         if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
 755                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
 756                                 __stt_config_release_client(uid);
 757                                 __stt_config_release_engine();
 758                                 stt_parser_unload_config(g_config_info);
 759                                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 760                         }
 761
 762                         if (NULL != tmp_language) {
 763                                 if (NULL != g_config_info->language) {
 764                                         free(g_config_info->language);
 765                                         g_config_info->language = strdup(tmp_language);
 766                                 }
 767
 768                                 free(tmp_language);
 769                         }
 770                 }
 771         }
 772
 773         /* print daemon config */
 774         SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
 775         SECURE_SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
 776         SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
 777         SECURE_SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
 778         SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
 779         SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 780         SLOG(LOG_DEBUG, stt_tag(), "===================");
 781
 782         if (0 != __stt_config_mgr_register_config_event()) {
 783                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
 784                 __stt_config_release_client(uid);
 785                 __stt_config_release_engine();
 786                 stt_parser_unload_config(g_config_info);
 787                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 788         }
 789
 790         /* Register to detect display language change */
 791         vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
 792
 793         temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 794         if (NULL == temp_client) {
 795                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
 796                 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
 797         }
 798         temp_client->uid = uid;
 799         temp_client->bool_cb = NULL;
 800         temp_client->engine_cb = NULL;
 801         temp_client->lang_cb = NULL;
 802         temp_client->user_data = NULL;
 803
 804         /* Add uid */
 805         g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 806
 807         return STT_CONFIG_ERROR_NONE;
 808 }
 809
 810 int stt_config_mgr_finalize(int uid)
 811 {
 812         GSList *iter = NULL;
 813         stt_config_client_s* temp_client = NULL;
 814
 815         if (0 < g_slist_length(g_config_client_list)) {
 816                 /* Check uid */
 817                 iter = g_slist_nth(g_config_client_list, 0);
 818
 819                 while (NULL != iter) {
 820                         temp_client = iter->data;
 821
 822                         if (NULL != temp_client) {
 823                                 if (uid == temp_client->uid) {
 824                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 825                                         free(temp_client);
 826                                         temp_client = NULL;
 827                                         break;
 828                                 }
 829                         }
 830
 831                         iter = g_slist_next(iter);
 832                 }
 833         }
 834
 835         if (0 < g_slist_length(g_config_client_list)) {
 836                 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
 837                 return STT_CONFIG_ERROR_NONE;
 838         }
 839
 840         stt_engine_info_s *engine_info = NULL;
 841
 842         if (0 < g_slist_length(g_engine_list)) {
 843
 844                 /* Get a first item */
 845                 iter = g_slist_nth(g_engine_list, 0);
 846
 847                 while (NULL != iter) {
 848                         engine_info = iter->data;
 849
 850                         if (NULL != engine_info) {
 851                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 852
 853                                 stt_parser_free_engine_info(engine_info);
 854                         }
 855
 856                         iter = g_slist_nth(g_engine_list, 0);
 857                 }
 858         }
 859
 860         vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
 861
 862         __stt_config_mgr_unregister_config_event();
 863
 864         if (NULL != g_config_info) {
 865                 stt_parser_unload_config(g_config_info);
 866                 g_config_info = NULL;
 867         }
 868
 869         return STT_CONFIG_ERROR_NONE;
 870 }
 871
 872 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)
 873 {
 874         GSList *iter = NULL;
 875         stt_config_client_s* temp_client = NULL;
 876
 877         /* Call all callbacks of client*/
 878         iter = g_slist_nth(g_config_client_list, 0);
 879
 880         while (NULL != iter) {
 881                 temp_client = iter->data;
 882
 883                 if (NULL != temp_client) {
 884                         if (uid == temp_client->uid) {
 885                                 temp_client->engine_cb = engine_cb;
 886                                 temp_client->lang_cb = lang_cb;
 887                                 temp_client->bool_cb = bool_cb;
 888                                 temp_client->user_data = user_data;
 889                         }
 890                 }
 891
 892                 iter = g_slist_next(iter);
 893         }
 894
 895         return STT_CONFIG_ERROR_NONE;
 896 }
 897
 898 int stt_config_mgr_unset_callback(int uid)
 899 {
 900         GSList *iter = NULL;
 901         stt_config_client_s* temp_client = NULL;
 902
 903         /* Call all callbacks of client*/
 904         iter = g_slist_nth(g_config_client_list, 0);
 905
 906         while (NULL != iter) {
 907                 temp_client = iter->data;
 908
 909                 if (NULL != temp_client) {
 910                         if (uid == temp_client->uid) {
 911                                 temp_client->engine_cb = NULL;
 912                                 temp_client->lang_cb = NULL;
 913                                 temp_client->bool_cb = NULL;
 914                                 temp_client->user_data = NULL;
 915                         }
 916                 }
 917
 918                 iter = g_slist_next(iter);
 919         }
 920
 921         return STT_CONFIG_ERROR_NONE;
 922 }
 923
 924 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
 925 {
 926         if (0 >= g_slist_length(g_config_client_list)) {
 927                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 928                 return STT_CONFIG_ERROR_INVALID_STATE;
 929         }
 930
 931         if (NULL == callback) {
 932                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 933         }
 934
 935         GSList *iter = NULL;
 936         stt_engine_info_s *engine_info = NULL;
 937
 938         if (0 >= g_slist_length(g_engine_list)) {
 939                 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
 940                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 941         }
 942
 943         /* Get a first item */
 944         iter = g_slist_nth(g_engine_list, 0);
 945
 946         while (NULL != iter) {
 947                 engine_info = iter->data;
 948
 949                 if (NULL == engine_info) {
 950                         SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
 951                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 952                 }
 953
 954                 if (false == callback(engine_info->uuid, engine_info->name,
 955                         engine_info->setting, engine_info->support_silence_detection, user_data)) {
 956                         break;
 957                 }
 958
 959                 iter = g_slist_next(iter);
 960         }
 961
 962         return STT_CONFIG_ERROR_NONE;
 963 }
 964
 965 int stt_config_mgr_get_engine(char** engine)
 966 {
 967         if (0 >= g_slist_length(g_config_client_list)) {
 968                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 969                 return STT_CONFIG_ERROR_INVALID_STATE;
 970         }
 971
 972         if (NULL == engine) {
 973                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 974         }
 975
 976         if (NULL != g_config_info->engine_id) {
 977                 *engine = strdup(g_config_info->engine_id);
 978         } else {
 979                 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
 980                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 981         }
 982
 983         return STT_CONFIG_ERROR_NONE;
 984 }
 985
 986 int stt_config_mgr_set_engine(const char* engine)
 987 {
 988         if (0 >= g_slist_length(g_config_client_list)) {
 989                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 990                 return STT_CONFIG_ERROR_INVALID_STATE;
 991         }
 992
 993         if (NULL == g_config_info) {
 994                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 995         }
 996
 997         if (NULL == engine || NULL == g_config_info->engine_id) {
 998                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 999         }
1000
1001         /* Check current engine id with new engine id */
1002         if (0 == strcmp(g_config_info->engine_id, engine)) {
1003                 return 0;
1004         }
1005
1006         SECURE_SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1007
1008         GSList *iter = NULL;
1009         stt_engine_info_s *engine_info = NULL;
1010         bool is_valid_engine = false;
1011
1012         /* Get a first item */
1013         iter = g_slist_nth(g_engine_list, 0);
1014
1015         while (NULL != iter) {
1016                 engine_info = iter->data;
1017
1018                 if (NULL == engine_info) {
1019                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1020                         iter = g_slist_next(iter);
1021                         continue;
1022                 }
1023
1024                 /* Check engine id is valid */
1025                 if (0 != strcmp(engine, engine_info->uuid)) {
1026                         iter = g_slist_next(iter);
1027                         continue;
1028                 }
1029
1030                 if (NULL != g_config_info->engine_id)
1031                         free(g_config_info->engine_id);
1032
1033                 g_config_info->engine_id = strdup(engine);
1034
1035                 if (NULL != g_config_info->setting) {
1036                         free(g_config_info->setting);
1037                 }
1038
1039                 if (NULL != engine_info->setting) {
1040                         g_config_info->setting = strdup(engine_info->setting);
1041                 } else {
1042                         g_config_info->setting = NULL;
1043                 }
1044
1045                 /* Engine is valid*/
1046                 GSList *iter_lang = NULL;
1047                 char* lang;
1048                 bool is_valid_lang = false;
1049
1050                 /* Get a first item */
1051                 iter_lang = g_slist_nth(engine_info->languages, 0);
1052
1053                 while (NULL != iter_lang) {
1054                         /*Get handle data from list*/
1055                         lang = iter_lang->data;
1056
1057                         SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1058                         if (NULL != lang) {
1059                                 if (0 == strcmp(lang, g_config_info->language)) {
1060                                         /* language is valid */
1061                                         is_valid_lang = true;
1062
1063                                         if (NULL != g_config_info->language) {
1064                                                 free(g_config_info->language);
1065
1066                                                 g_config_info->language = strdup(lang);
1067                                         }
1068                                         break;
1069                                 }
1070                         }
1071
1072                         /*Get next item*/
1073                         iter_lang = g_slist_next(iter_lang);
1074                 }
1075
1076                 if (false == is_valid_lang) {
1077                         if (NULL != g_config_info->language) {
1078                                 free(g_config_info->language);
1079
1080                                 iter_lang = g_slist_nth(engine_info->languages, 0);
1081                                 lang = iter_lang->data;
1082
1083                                 g_config_info->language = strdup(lang);
1084                         }
1085                 }
1086
1087                 /* Check options */
1088                 if (false == engine_info->support_silence_detection) {
1089                         if (true == g_config_info->silence_detection)
1090                                 g_config_info->silence_detection = false;
1091                 }
1092
1093                 is_valid_engine = true;
1094                 break;
1095         }
1096
1097         if (true == is_valid_engine) {
1098                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1099                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Engine : %s", g_config_info->engine_id);
1100                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Setting : %s", g_config_info->setting);
1101                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  language : %s", g_config_info->language);
1102                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1103
1104                 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1105                         g_config_info->silence_detection)) {
1106                                 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1107                                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1108                 }
1109         } else {
1110                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1111                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1112         }
1113
1114         return 0;
1115 }
1116
1117 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1118 {
1119         if (0 >= g_slist_length(g_engine_list)) {
1120                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1121                 return STT_CONFIG_ERROR_INVALID_STATE;
1122         }
1123
1124         if (NULL == agreement) {
1125                 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1126                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1127         }
1128
1129         GSList *iter = NULL;
1130         stt_engine_info_s *engine_info = NULL;
1131         char* current_engine = NULL;
1132
1133         if (NULL == engine) {
1134                 current_engine = strdup(g_config_info->engine_id);
1135                 if (NULL == current_engine) {
1136                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1137                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1138                 }
1139         } else {
1140                 current_engine = strdup(engine);
1141                 if (NULL == current_engine) {
1142                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1143                         return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1144                 }
1145         }
1146
1147         /* Get a first item */
1148         iter = g_slist_nth(g_engine_list, 0);
1149
1150         while (NULL != iter) {
1151                 engine_info = iter->data;
1152
1153                 if (NULL == engine_info) {
1154                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1155                         if (NULL != current_engine)     free(current_engine);
1156                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1157                 }
1158
1159                 if (0 != strcmp(current_engine, engine_info->uuid)) {
1160                         iter = g_slist_next(iter);
1161                         continue;
1162                 }
1163
1164                 if (NULL != engine_info->agreement) {
1165                         *agreement = strdup(engine_info->agreement);
1166                 } else {
1167                         SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1168                 }
1169                 break;
1170         }
1171
1172         if (NULL != current_engine)     free(current_engine);
1173
1174         return STT_CONFIG_ERROR_NONE;
1175 }
1176
1177 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1178 {
1179         if (0 >= g_slist_length(g_config_client_list)) {
1180                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1181                 return STT_CONFIG_ERROR_INVALID_STATE;
1182         }
1183
1184         if (0 >= g_slist_length(g_engine_list)) {
1185                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1186                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1187         }
1188
1189         GSList *iter = NULL;
1190         stt_engine_info_s *engine_info = NULL;
1191
1192         /* Get a first item */
1193         iter = g_slist_nth(g_engine_list, 0);
1194
1195         while (NULL != iter) {
1196                 engine_info = iter->data;
1197
1198                 if (NULL == engine_info) {
1199                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1200                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1201                 }
1202
1203                 if (0 != strcmp(engine_id, engine_info->uuid)) {
1204                         iter = g_slist_next(iter);
1205                         continue;
1206                 }
1207
1208                 GSList *iter_lang = NULL;
1209                 char* lang;
1210
1211                 /* Get a first item */
1212                 iter_lang = g_slist_nth(engine_info->languages, 0);
1213
1214                 while (NULL != iter_lang) {
1215                         /*Get handle data from list*/
1216                         lang = iter_lang->data;
1217
1218                         SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1219                         if (NULL != lang) {
1220                                 if (false == callback(engine_info->uuid, lang, user_data))
1221                                         break;
1222                         }
1223
1224                         /*Get next item*/
1225                         iter_lang = g_slist_next(iter_lang);
1226                 }
1227                 break;
1228         }
1229
1230         return STT_CONFIG_ERROR_NONE;
1231 }
1232
1233 int stt_config_mgr_get_default_language(char** language)
1234 {
1235         if (0 >= g_slist_length(g_config_client_list)) {
1236                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1237                 return STT_CONFIG_ERROR_INVALID_STATE;
1238         }
1239
1240         if (NULL == language) {
1241                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1242         }
1243
1244         if (NULL != g_config_info->language) {
1245                 *language = strdup(g_config_info->language);
1246         } else {
1247                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1248                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1249         }
1250
1251         return STT_CONFIG_ERROR_NONE;
1252 }
1253
1254 int stt_config_mgr_set_default_language(const char* language)
1255 {
1256         if (0 >= g_slist_length(g_config_client_list)) {
1257                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1258                 return STT_CONFIG_ERROR_INVALID_STATE;
1259         }
1260
1261         if (NULL == language) {
1262                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1263         }
1264
1265         /* Check language is valid */
1266         if (NULL != g_config_info->language) {
1267                 if (0 != stt_parser_set_language(language)) {
1268                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1269                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1270                 }
1271                 free(g_config_info->language);
1272                 g_config_info->language = strdup(language);
1273         } else {
1274                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1275                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1276         }
1277
1278         return STT_CONFIG_ERROR_NONE;
1279 }
1280
1281 int stt_config_mgr_get_auto_language(bool* value)
1282 {
1283         if (0 >= g_slist_length(g_config_client_list)) {
1284                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1285                 return STT_CONFIG_ERROR_INVALID_STATE;
1286         }
1287
1288         if (NULL == value) {
1289                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1290         }
1291
1292         *value = g_config_info->auto_lang;
1293
1294         return STT_CONFIG_ERROR_NONE;
1295 }
1296
1297 int stt_config_mgr_set_auto_language(bool value)
1298 {
1299         if (0 >= g_slist_length(g_config_client_list)) {
1300                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1301                 return STT_CONFIG_ERROR_INVALID_STATE;
1302         }
1303
1304         if (g_config_info->auto_lang != value) {
1305                 /* Check language is valid */
1306                 if (0 != stt_parser_set_auto_lang(value)) {
1307                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1308                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1309                 }
1310                 g_config_info->auto_lang = value;
1311
1312                 if (true == g_config_info->auto_lang) {
1313                         __stt_config_set_auto_language();
1314                 }
1315         }
1316
1317         return STT_CONFIG_ERROR_NONE;
1318 }
1319
1320 int stt_config_mgr_get_silence_detection(bool* value)
1321 {
1322         if (0 >= g_slist_length(g_config_client_list)) {
1323                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1324                 return STT_CONFIG_ERROR_INVALID_STATE;
1325         }
1326
1327         if (NULL == value)
1328                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1329
1330         *value = g_config_info->silence_detection;
1331
1332         return STT_CONFIG_ERROR_NONE;
1333 }
1334
1335 int stt_config_mgr_set_silence_detection(bool value)
1336 {
1337         if (0 >= g_slist_length(g_config_client_list)) {
1338                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1339                 return STT_CONFIG_ERROR_INVALID_STATE;
1340         }
1341
1342         if (0 != stt_parser_set_silence_detection(value)) {
1343                 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1344                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1345         }
1346
1347         g_config_info->silence_detection = value;
1348
1349         return STT_CONFIG_ERROR_NONE;
1350 }
1351
1352 bool stt_config_check_default_engine_is_valid(const char* engine)
1353 {
1354         if (0 >= g_slist_length(g_config_client_list)) {
1355                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1356                 return false;
1357         }
1358
1359         if (NULL == engine) {
1360                 return false;
1361         }
1362
1363         if (0 >= g_slist_length(g_engine_list))
1364                 return false;
1365
1366         GSList *iter = NULL;
1367         stt_engine_info_s *engine_info = NULL;
1368
1369         /* Get a first item */
1370         iter = g_slist_nth(g_engine_list, 0);
1371
1372         while (NULL != iter) {
1373                 engine_info = iter->data;
1374
1375                 if (NULL != engine_info) {
1376                         if (0 == strcmp(engine, engine_info->uuid)) {
1377                                 return true;
1378                         }
1379                 }
1380                 iter = g_slist_next(iter);
1381         }
1382
1383         return false;
1384 }
1385
1386 bool stt_config_check_default_language_is_valid(const char* language)
1387 {
1388         if (0 >= g_slist_length(g_config_client_list)) {
1389                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1390                 return false;
1391         }
1392
1393         if (NULL == language) {
1394                 return false;
1395         }
1396
1397         if (NULL == g_config_info->engine_id) {
1398                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1399                 return false;
1400         }
1401
1402         if (0 >= g_slist_length(g_engine_list))
1403                 return false;
1404
1405         GSList *iter = NULL;
1406         stt_engine_info_s *engine_info = NULL;
1407
1408         /* Get a first item */
1409         iter = g_slist_nth(g_engine_list, 0);
1410
1411         while (NULL != iter) {
1412                 engine_info = iter->data;
1413
1414                 if (NULL == engine_info) {
1415                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1416                         iter = g_slist_next(iter);
1417                         continue;
1418                 }
1419
1420                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1421                         iter = g_slist_next(iter);
1422                         continue;
1423                 }
1424
1425                 GSList *iter_lang = NULL;
1426                 char* lang;
1427
1428                 /* Get a first item */
1429                 iter_lang = g_slist_nth(engine_info->languages, 0);
1430
1431                 while (NULL != iter_lang) {
1432                         lang = iter_lang->data;
1433
1434                         if (0 == strcmp(language, lang))
1435                                 return true;
1436
1437                         /*Get next item*/
1438                         iter_lang = g_slist_next(iter_lang);
1439                 }
1440                 break;
1441         }
1442
1443         return false;
1444 }
1445
1446 int __stt_config_mgr_print_engine_info()
1447 {
1448         GSList *iter = NULL;
1449         stt_engine_info_s *engine_info = NULL;
1450
1451         if (0 >= g_slist_length(g_engine_list)) {
1452                 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1453                 SLOG(LOG_DEBUG, stt_tag(), "  No Engine in engine directory");
1454                 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1455                 return 0;
1456         }
1457
1458         /* Get a first item */
1459         iter = g_slist_nth(g_engine_list, 0);
1460
1461         SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1462
1463         int i = 1;
1464         while (NULL != iter) {
1465                 engine_info = iter->data;
1466
1467                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1468                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1469                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " id   : %s", engine_info->uuid);
1470                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1471                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1472
1473                 SLOG(LOG_DEBUG, stt_tag(), " languages");
1474                 GSList *iter_lang = NULL;
1475                 char* lang;
1476                 if (g_slist_length(engine_info->languages) > 0) {
1477                         /* Get a first item */
1478                         iter_lang = g_slist_nth(engine_info->languages, 0);
1479
1480                         int j = 1;
1481                         while (NULL != iter_lang) {
1482                                 /*Get handle data from list*/
1483                                 lang = iter_lang->data;
1484
1485                                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  [%dth] %s", j, lang);
1486
1487                                 /*Get next item*/
1488                                 iter_lang = g_slist_next(iter_lang);
1489                                 j++;
1490                         }
1491                 } else {
1492                         SLOG(LOG_ERROR, stt_tag(), "  language is NONE");
1493                 }
1494                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1495                         engine_info->support_silence_detection ? "true" : "false");
1496                 iter = g_slist_next(iter);
1497                 i++;
1498         }
1499         SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1500
1501         return 0;
1502 }
1503
1504
1505
1506 /**
1507 * time info functions
1508 */
1509 static GSList* g_time_list = NULL;
1510
1511 int stt_config_mgr_reset_time_info()
1512 {
1513         /* Remove time info */
1514         GSList *iter = NULL;
1515         stt_result_time_info_s *data = NULL;
1516
1517         /* Remove time info */
1518         iter = g_slist_nth(g_time_list, 0);
1519         while (NULL != iter) {
1520                 data = iter->data;
1521
1522                 g_time_list = g_slist_remove(g_time_list, data);
1523                 if (NULL != data) {
1524                         if (NULL == data->text) free(data->text);
1525                         free(data);
1526                 }
1527
1528                 /*Get next item*/
1529                 iter = g_slist_nth(g_time_list, 0);
1530         }
1531
1532         return 0;
1533 }
1534
1535 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1536 {
1537         if (NULL == text) {
1538                 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1539                 return -1;
1540         }
1541
1542         stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1543         if (NULL == info) {
1544                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1545                 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1546         }
1547         info->index = index;
1548         info->event = event;
1549         if (NULL != text) {
1550                 info->text = strdup(text);
1551         }
1552         info->start_time = start_time;
1553         info->end_time = end_time;
1554
1555         /* Add item to global list */
1556         g_time_list = g_slist_append(g_time_list, info);
1557
1558         return 0;
1559 }
1560
1561 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1562 {
1563         if (NULL == callback) {
1564                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1565                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1566         }
1567
1568         GSList* temp_time = NULL;
1569         int ret;
1570         ret = stt_parser_get_time_info(&temp_time);
1571         if (0 != ret) {
1572                 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1573                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1574         }
1575
1576         GSList *iter = NULL;
1577         stt_result_time_info_s *data = NULL;
1578
1579         /* Get a first item */
1580         iter = g_slist_nth(temp_time, 0);
1581         while (NULL != iter) {
1582                 data = iter->data;
1583
1584                 if (false == callback(data->index, data->event, data->text,
1585                         data->start_time, data->end_time, user_data)) {
1586                         break;
1587                 }
1588
1589                 /*Get next item*/
1590                 iter = g_slist_next(iter);
1591         }
1592
1593         /* Remove time info */
1594         iter = g_slist_nth(temp_time, 0);
1595         while (NULL != iter) {
1596                 data = iter->data;
1597
1598                 if (NULL != data) {
1599                         temp_time = g_slist_remove(temp_time, data);
1600
1601                         if (NULL == data->text) free(data->text);
1602                         free(data);
1603                 }
1604
1605                 /*Get next item*/
1606                 iter = g_slist_nth(temp_time, 0);
1607         }
1608
1609         return STT_CONFIG_ERROR_NONE;
1610 }
1611
1612 int stt_config_mgr_save_time_info_file()
1613 {
1614         if (0 == g_slist_length(g_time_list)) {
1615                 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1616                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1617         }
1618
1619         int ret = 0;
1620         ret = stt_parser_set_time_info(g_time_list);
1621         if (0 != ret) {
1622                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1623                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1624         }
1625
1626         return STT_CONFIG_ERROR_NONE;
1627 }
1628
1629 int stt_config_mgr_remove_time_info_file()
1630 {
1631         stt_parser_clear_time_info();
1632
1633         return STT_CONFIG_ERROR_NONE;
1634 }