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