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