common/stt_config_mgr.c

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