common/stt_config_mgr.c

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