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