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