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