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 #define VCONFKEY_VOICE_INPUT_LANGUAGE     "db/voice_input/language"
  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                                 SECURE_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                                                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *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                                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *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
 198                 GSList *iter = NULL;
 199                 stt_config_client_s* temp_client = NULL;
 200
 201                 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence))
 202                         return ECORE_CALLBACK_PASS_ON;
 203
 204                 /* Engine changed */
 205                 if (NULL != engine || NULL != setting) {
 206                         /* engine changed */
 207                         if (NULL != engine) {
 208                                 if (NULL != g_config_info->engine_id)   free(g_config_info->engine_id);
 209                                 g_config_info->engine_id = strdup(engine);
 210                         }
 211
 212                         if (NULL != setting) {
 213                                 if (NULL != g_config_info->setting)     free(g_config_info->setting);
 214                                 g_config_info->setting = strdup(setting);
 215                         }
 216
 217                         if (NULL != lang) {
 218                                 if (NULL != g_config_info->language)    free(g_config_info->language);
 219                                 g_config_info->language = strdup(lang);
 220                         }
 221
 222                         if (-1 != silence)      g_config_info->silence_detection = silence;
 223
 224                         /* Call all callbacks of client*/
 225                         iter = g_slist_nth(g_config_client_list, 0);
 226
 227                         while (NULL != iter) {
 228                                 temp_client = iter->data;
 229
 230                                 if (NULL != temp_client) {
 231                                         if (NULL != temp_client->engine_cb) {
 232                                                 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
 233                                                         g_config_info->silence_detection, temp_client->user_data);
 234                                         }
 235                                 }
 236
 237                                 iter = g_slist_next(iter);
 238                         }
 239                 }
 240
 241                 if (-1 != auto_lang) {
 242                         g_config_info->auto_lang = auto_lang;
 243                 }
 244
 245                 /* Only language changed */
 246                 if (NULL == engine && NULL != lang) {
 247                         char* before_lang = NULL;
 248                         before_lang = strdup(g_config_info->language);
 249
 250                         if (NULL != lang) {
 251                                 if (NULL != g_config_info->language)    free(g_config_info->language);
 252                                 g_config_info->language = strdup(lang);
 253                         }
 254
 255                         /* Call all callbacks of client*/
 256                         iter = g_slist_nth(g_config_client_list, 0);
 257
 258                         while (NULL != iter) {
 259                                 temp_client = iter->data;
 260
 261                                 if (NULL != temp_client) {
 262                                         if (NULL != temp_client->lang_cb) {
 263                                                 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
 264                                         }
 265                                 }
 266
 267                                 iter = g_slist_next(iter);
 268                         }
 269
 270                         if (NULL != before_lang) {
 271                                 free(before_lang);
 272                         }
 273                 }
 274
 275                 if (-1 != silence) {
 276                         /* silence detection changed */
 277                         g_config_info->silence_detection = silence;
 278
 279                         /* Call all callbacks of client*/
 280                         iter = g_slist_nth(g_config_client_list, 0);
 281
 282                         while (NULL != iter) {
 283                                 temp_client = iter->data;
 284
 285                                 if (NULL != temp_client) {
 286                                         if (NULL != temp_client->bool_cb) {
 287                                                 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
 288                                         }
 289                                 }
 290
 291                                 iter = g_slist_next(iter);
 292                         }
 293                 }
 294
 295                 if (NULL != engine)     free(engine);
 296                 if (NULL != setting)    free(setting);
 297                 if (NULL != lang)       free(lang);
 298         } else {
 299                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
 300         }
 301
 302         SLOG(LOG_DEBUG, stt_tag(), "=====");
 303         SLOG(LOG_DEBUG, stt_tag(), " ");
 304
 305         return ECORE_CALLBACK_PASS_ON;
 306 }
 307
 308 int __stt_config_mgr_register_config_event()
 309 {
 310         /* get file notification handler */
 311         int fd;
 312         int wd;
 313
 314         fd = inotify_init();
 315         if (fd < 0) {
 316                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
 317                 return -1;
 318         }
 319         g_fd_noti = fd;
 320
 321         wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
 322         g_wd_noti = wd;
 323
 324         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);
 325         if (NULL == g_fd_handler_noti) {
 326                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
 327                 return -1;
 328         }
 329
 330         return 0;
 331 }
 332
 333 int __stt_config_mgr_unregister_config_event()
 334 {
 335         /* delete inotify variable */
 336         ecore_main_fd_handler_del(g_fd_handler_noti);
 337         inotify_rm_watch(g_fd_noti, g_wd_noti);
 338         close(g_fd_noti);
 339
 340         return 0;
 341 }
 342
 343 int __stt_config_set_auto_language()
 344 {
 345         char* value = NULL;
 346         value = vconf_get_str(VCONFKEY_VOICE_INPUT_LANGUAGE);
 347         if (NULL == value) {
 348                 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get voice input language");
 349                 return -1;
 350         }
 351
 352         char candidate_lang[6] = {'\0', };
 353
 354         /* Check auto is on or not */
 355         if (0 == strncmp(value, "auto", 4)) {
 356                 free(value);
 357
 358                 value = vconf_get_str(VCONFKEY_LANGSET);
 359                 if (NULL == value) {
 360                         SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
 361                         return -1;
 362                 }
 363
 364                 strncpy(candidate_lang, value, 5);
 365                 free(value);
 366
 367                 /* Check current language */
 368                 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
 369                         SECURE_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                         SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
 373                 }
 374         } else {
 375                 strncpy(candidate_lang, value, 5);
 376                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Voice input language is NOT auto. Voice input language : %s", candidate_lang);
 377
 378                 free(value);
 379         }
 380
 381         if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
 382                 /* stt default language change */
 383                 if (NULL == g_config_info->language) {
 384                         SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
 385                         return -1;
 386                 }
 387
 388                 char* before_lang = NULL;
 389                 if (0 != stt_parser_set_language(candidate_lang)) {
 390                         SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
 391                         return -1;
 392                 }
 393
 394                 before_lang = strdup(g_config_info->language);
 395
 396                 free(g_config_info->language);
 397                 g_config_info->language = strdup(candidate_lang);
 398
 399                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
 400
 401                 /* Call all callbacks of client*/
 402                 GSList *iter = NULL;
 403                 stt_config_client_s* temp_client = NULL;
 404
 405                 iter = g_slist_nth(g_config_client_list, 0);
 406
 407                 while (NULL != iter) {
 408                         temp_client = iter->data;
 409
 410                         if (NULL != temp_client) {
 411                                 if (NULL != temp_client->lang_cb) {
 412                                         temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
 413                                 }
 414                         }
 415
 416                         iter = g_slist_next(iter);
 417                 }
 418
 419                 if (NULL != before_lang) {
 420                         free(before_lang);
 421                 }
 422         } else {
 423                 /* Candidate language is not valid */
 424                 char* tmp_language = NULL;
 425                 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
 426                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
 427                         return -1;
 428                 }
 429
 430                 if (NULL == tmp_language) {
 431                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
 432                         return -1;
 433                 }
 434
 435                 if (0 != stt_parser_set_language(tmp_language)) {
 436                         free(tmp_language);
 437                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
 438                         return -1;
 439                 }
 440
 441                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
 442
 443                 /* Call all callbacks of client*/
 444                 GSList *iter = NULL;
 445                 stt_config_client_s* temp_client = NULL;
 446
 447                 iter = g_slist_nth(g_config_client_list, 0);
 448
 449                 while (NULL != iter) {
 450                         temp_client = iter->data;
 451
 452                         if (NULL != temp_client) {
 453                                 if (NULL != temp_client->lang_cb) {
 454                                         temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
 455                                 }
 456                         }
 457
 458                         iter = g_slist_next(iter);
 459                 }
 460
 461                 if (NULL != g_config_info->language) {
 462                         free(g_config_info->language);
 463                         g_config_info->language = strdup(tmp_language);
 464                 }
 465
 466                 free(tmp_language);
 467         }
 468
 469         return 0;
 470 }
 471
 472 void __stt_config_language_changed_cb(keynode_t *key, void *data)
 473 {
 474         if (true == g_config_info->auto_lang) {
 475                 /* Get voice input vconf key */
 476                 __stt_config_set_auto_language();
 477         }
 478
 479         return;
 480 }
 481
 482 int stt_config_mgr_initialize(int uid)
 483 {
 484         GSList *iter = NULL;
 485         int* get_uid;
 486         stt_config_client_s* temp_client = NULL;
 487
 488         if (0 < g_slist_length(g_config_client_list)) {
 489                 /* Check uid */
 490                 iter = g_slist_nth(g_config_client_list, 0);
 491
 492                 while (NULL != iter) {
 493                         get_uid = iter->data;
 494
 495                         if (uid == *get_uid) {
 496                                 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
 497                                 return 0;
 498                         }
 499
 500                         iter = g_slist_next(iter);
 501                 }
 502
 503                 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 504                 temp_client->uid = uid;
 505                 temp_client->bool_cb = NULL;
 506                 temp_client->engine_cb = NULL;
 507                 temp_client->lang_cb = NULL;
 508                 temp_client->user_data = NULL;
 509
 510                 /* Add uid */
 511                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 512
 513                 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
 514                 return STT_CONFIG_ERROR_NONE;
 515         }
 516
 517         /* Get file name from default engine directory */
 518         DIR *dp = NULL;
 519         int ret = -1;
 520         struct dirent entry;
 521         struct dirent *dirp = NULL;
 522
 523         g_engine_list = NULL;
 524
 525         dp  = opendir(STT_DEFAULT_ENGINE_INFO);
 526         if (NULL != dp) {
 527                 do {
 528                         ret = readdir_r(dp, &entry, &dirp);
 529                         if (0 != ret) {
 530                                 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
 531                                 break;
 532                         }
 533
 534                         if (NULL != dirp) {
 535                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 536                                         continue;
 537
 538                                 stt_engine_info_s* info;
 539                                 char* filepath;
 540                                 int filesize;
 541
 542                                 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
 543                                 filepath = (char*)calloc(filesize, sizeof(char));
 544
 545                                 if (NULL != filepath) {
 546                                         snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
 547                                 } else {
 548                                         SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
 549                                         continue;
 550                                 }
 551
 552                                 if (0 == stt_parser_get_engine_info(filepath, &info)) {
 553                                         g_engine_list = g_slist_append(g_engine_list, info);
 554                                 }
 555
 556                                 if (NULL != filepath)
 557                                         free(filepath);
 558                         }
 559                 } while (NULL != dirp);
 560
 561                 closedir(dp);
 562         } else {
 563                 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
 564         }
 565
 566         __stt_config_mgr_print_engine_info();
 567
 568         if (0 != stt_parser_load_config(&g_config_info)) {
 569                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
 570                 return -1;
 571         }
 572
 573         if (true == g_config_info->auto_lang) {
 574                 /* Check language with display language */
 575                 __stt_config_set_auto_language();
 576         } else {
 577                 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
 578                         /* Default language is not valid */
 579                         char* tmp_language;
 580                         if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
 581                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
 582                                 return -1;
 583                         }
 584
 585                         if (NULL != tmp_language) {
 586                                 if (NULL != g_config_info->language) {
 587                                         free(g_config_info->language);
 588                                         g_config_info->language = strdup(tmp_language);
 589                                 }
 590
 591                                 free(tmp_language);
 592                         }
 593                 }
 594         }
 595
 596         /* print daemon config */
 597         SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
 598         SECURE_SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
 599         SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
 600         SECURE_SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
 601         SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
 602         SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 603         SLOG(LOG_DEBUG, stt_tag(), "===================");
 604
 605         if (0 != __stt_config_mgr_register_config_event()) {
 606                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
 607                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 608         }
 609
 610         /* Register to detect display language change */
 611         vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
 612         vconf_notify_key_changed(VCONFKEY_VOICE_INPUT_LANGUAGE, __stt_config_language_changed_cb, NULL);
 613
 614         temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
 615         temp_client->uid = uid;
 616         temp_client->bool_cb = NULL;
 617         temp_client->engine_cb = NULL;
 618         temp_client->lang_cb = NULL;
 619         temp_client->user_data = NULL;
 620
 621         /* Add uid */
 622         g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 623
 624         return STT_CONFIG_ERROR_NONE;
 625 }
 626
 627 int stt_config_mgr_finalize(int uid)
 628 {
 629         GSList *iter = NULL;
 630         stt_config_client_s* temp_client = NULL;
 631
 632         if (0 < g_slist_length(g_config_client_list)) {
 633                 /* Check uid */
 634                 iter = g_slist_nth(g_config_client_list, 0);
 635
 636                 while (NULL != iter) {
 637                         temp_client = iter->data;
 638
 639                         if (NULL != temp_client) {
 640                                 if (uid == temp_client->uid) {
 641                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 642                                         free(temp_client);
 643                                         temp_client = NULL;
 644                                         break;
 645                                 }
 646                         }
 647
 648                         iter = g_slist_next(iter);
 649                 }
 650         }
 651
 652         if (0 < g_slist_length(g_config_client_list)) {
 653                 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
 654                 return STT_CONFIG_ERROR_NONE;
 655         }
 656
 657         stt_engine_info_s *engine_info = NULL;
 658
 659         if (0 < g_slist_length(g_engine_list)) {
 660
 661                 /* Get a first item */
 662                 iter = g_slist_nth(g_engine_list, 0);
 663
 664                 while (NULL != iter) {
 665                         engine_info = iter->data;
 666
 667                         if (NULL != engine_info) {
 668                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 669
 670                                 stt_parser_free_engine_info(engine_info);
 671                         }
 672
 673                         iter = g_slist_nth(g_engine_list, 0);
 674                 }
 675         }
 676
 677         vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
 678         vconf_ignore_key_changed(VCONFKEY_VOICE_INPUT_LANGUAGE, __stt_config_language_changed_cb);
 679
 680         __stt_config_mgr_unregister_config_event();
 681
 682         if (NULL != g_config_info) {
 683                 stt_parser_unload_config(g_config_info);
 684                 g_config_info = NULL;
 685         }
 686
 687         return STT_CONFIG_ERROR_NONE;
 688 }
 689
 690 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)
 691 {
 692         GSList *iter = NULL;
 693         stt_config_client_s* temp_client = NULL;
 694
 695         /* Call all callbacks of client*/
 696         iter = g_slist_nth(g_config_client_list, 0);
 697
 698         while (NULL != iter) {
 699                 temp_client = iter->data;
 700
 701                 if (NULL != temp_client) {
 702                         if (uid == temp_client->uid) {
 703                                 temp_client->engine_cb = engine_cb;
 704                                 temp_client->lang_cb = lang_cb;
 705                                 temp_client->bool_cb = bool_cb;
 706                                 temp_client->user_data = user_data;
 707                         }
 708                 }
 709
 710                 iter = g_slist_next(iter);
 711         }
 712
 713         return STT_CONFIG_ERROR_NONE;
 714 }
 715
 716 int stt_config_mgr_unset_callback(int uid)
 717 {
 718         GSList *iter = NULL;
 719         stt_config_client_s* temp_client = NULL;
 720
 721         /* Call all callbacks of client*/
 722         iter = g_slist_nth(g_config_client_list, 0);
 723
 724         while (NULL != iter) {
 725                 temp_client = iter->data;
 726
 727                 if (NULL != temp_client) {
 728                         if (uid == temp_client->uid) {
 729                                 temp_client->engine_cb = NULL;
 730                                 temp_client->lang_cb = NULL;
 731                                 temp_client->bool_cb = NULL;
 732                                 temp_client->user_data = NULL;
 733                         }
 734                 }
 735
 736                 iter = g_slist_next(iter);
 737         }
 738
 739         return STT_CONFIG_ERROR_NONE;
 740 }
 741
 742 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
 743 {
 744         if (0 >= g_slist_length(g_config_client_list)) {
 745                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 746                 return STT_CONFIG_ERROR_INVALID_STATE;
 747         }
 748
 749         if (NULL == callback) {
 750                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 751         }
 752
 753         GSList *iter = NULL;
 754         stt_engine_info_s *engine_info = NULL;
 755
 756         if (0 >= g_slist_length(g_engine_list)) {
 757                 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
 758                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 759         }
 760
 761         /* Get a first item */
 762         iter = g_slist_nth(g_engine_list, 0);
 763
 764         while (NULL != iter) {
 765                 engine_info = iter->data;
 766
 767                 if (NULL == engine_info) {
 768                         SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
 769                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 770                 }
 771
 772                 if (false == callback(engine_info->uuid, engine_info->name,
 773                         engine_info->setting, engine_info->support_silence_detection, user_data)) {
 774                         break;
 775                 }
 776
 777                 iter = g_slist_next(iter);
 778         }
 779
 780         return STT_CONFIG_ERROR_NONE;
 781 }
 782
 783 int stt_config_mgr_get_engine(char** engine)
 784 {
 785         if (0 >= g_slist_length(g_config_client_list)) {
 786                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 787                 return STT_CONFIG_ERROR_INVALID_STATE;
 788         }
 789
 790         if (NULL == engine) {
 791                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 792         }
 793
 794         if (NULL != g_config_info->engine_id) {
 795                 *engine = strdup(g_config_info->engine_id);
 796         } else {
 797                 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
 798                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 799         }
 800
 801         return STT_CONFIG_ERROR_NONE;
 802 }
 803
 804 int stt_config_mgr_set_engine(const char* engine)
 805 {
 806         if (0 >= g_slist_length(g_config_client_list)) {
 807                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 808                 return STT_CONFIG_ERROR_INVALID_STATE;
 809         }
 810
 811         if (NULL == g_config_info) {
 812                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 813         }
 814
 815         if (NULL == engine || NULL == g_config_info->engine_id) {
 816                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         /* Check current engine id with new engine id */
 820         if (0 == strcmp(g_config_info->engine_id, engine)) {
 821                 return 0;
 822         }
 823
 824         SECURE_SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
 825
 826         GSList *iter = NULL;
 827         stt_engine_info_s *engine_info = NULL;
 828         bool is_valid_engine = false;
 829
 830         /* Get a first item */
 831         iter = g_slist_nth(g_engine_list, 0);
 832
 833         while (NULL != iter) {
 834                 engine_info = iter->data;
 835
 836                 if (NULL == engine_info) {
 837                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
 838                         iter = g_slist_next(iter);
 839                         continue;
 840                 }
 841
 842                 /* Check engine id is valid */
 843                 if (0 != strcmp(engine, engine_info->uuid)) {
 844                         iter = g_slist_next(iter);
 845                         continue;
 846                 }
 847
 848                 if (NULL != g_config_info->engine_id)
 849                         free(g_config_info->engine_id);
 850
 851                 g_config_info->engine_id = strdup(engine);
 852
 853                 if (NULL != g_config_info->setting) {
 854                         free(g_config_info->setting);
 855                 }
 856
 857                 if (NULL != engine_info->setting) {
 858                         g_config_info->setting = strdup(engine_info->setting);
 859                 } else {
 860                         g_config_info->setting = NULL;
 861                 }
 862
 863                 /* Engine is valid*/
 864                 GSList *iter_lang = NULL;
 865                 char* lang;
 866                 bool is_valid_lang = false;
 867
 868                 /* Get a first item */
 869                 iter_lang = g_slist_nth(engine_info->languages, 0);
 870
 871                 while (NULL != iter_lang) {
 872                         /*Get handle data from list*/
 873                         lang = iter_lang->data;
 874
 875                         SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
 876                         if (NULL != lang) {
 877                                 if (0 == strcmp(lang, g_config_info->language)) {
 878                                         /* language is valid */
 879                                         is_valid_lang = true;
 880
 881                                         if (NULL != g_config_info->language) {
 882                                                 free(g_config_info->language);
 883
 884                                                 g_config_info->language = strdup(lang);
 885                                         }
 886                                         break;
 887                                 }
 888                         }
 889
 890                         /*Get next item*/
 891                         iter_lang = g_slist_next(iter_lang);
 892                 }
 893
 894                 if (false == is_valid_lang) {
 895                         if (NULL != g_config_info->language) {
 896                                 free(g_config_info->language);
 897
 898                                 iter_lang = g_slist_nth(engine_info->languages, 0);
 899                                 lang = iter_lang->data;
 900
 901                                 g_config_info->language = strdup(lang);
 902                         }
 903                 }
 904
 905                 /* Check options */
 906                 if (false == engine_info->support_silence_detection) {
 907                         if (true == g_config_info->silence_detection)
 908                                 g_config_info->silence_detection = false;
 909                 }
 910
 911                 is_valid_engine = true;
 912                 break;
 913         }
 914
 915         if (true == is_valid_engine) {
 916                 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
 917                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Engine : %s", g_config_info->engine_id);
 918                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Setting : %s", g_config_info->setting);
 919                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  language : %s", g_config_info->language);
 920                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
 921
 922                 if ( 0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
 923                         g_config_info->silence_detection)) {
 924                                 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
 925                                 return STT_CONFIG_ERROR_OPERATION_FAILED;
 926                 }
 927         } else {
 928                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
 929                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 930         }
 931
 932         return 0;
 933 }
 934
 935 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
 936 {
 937         if (0 >= g_slist_length(g_engine_list)) {
 938                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
 939                 return STT_CONFIG_ERROR_INVALID_STATE;
 940         }
 941
 942         if (NULL == agreement) {
 943                 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
 944                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
 945         }
 946
 947         GSList *iter = NULL;
 948         stt_engine_info_s *engine_info = NULL;
 949         char* current_engine = NULL;
 950
 951         if (NULL == engine) {
 952                 current_engine = strdup(g_config_info->engine_id);
 953         } else {
 954                 current_engine = strdup(engine);
 955         }
 956
 957         /* Get a first item */
 958         iter = g_slist_nth(g_engine_list, 0);
 959
 960         while (NULL != iter) {
 961                 engine_info = iter->data;
 962
 963                 if (NULL == engine_info) {
 964                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
 965                         if (NULL != current_engine)     free(current_engine);
 966                         return STT_CONFIG_ERROR_OPERATION_FAILED;
 967                 }
 968
 969                 if (0 != strcmp(current_engine, engine_info->uuid)) {
 970                         iter = g_slist_next(iter);
 971                         continue;
 972                 }
 973
 974                 if (NULL != engine_info->agreement) {
 975                         *agreement = strdup(engine_info->agreement);
 976                 } else {
 977                         SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
 978                 }
 979                 break;
 980         }
 981
 982         if (NULL != current_engine)     free(current_engine);
 983
 984         return STT_CONFIG_ERROR_NONE;
 985 }
 986
 987 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
 988 {
 989         if (0 >= g_slist_length(g_config_client_list)) {
 990                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
 991                 return STT_CONFIG_ERROR_INVALID_STATE;
 992         }
 993
 994         if (0 >= g_slist_length(g_engine_list)) {
 995                 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
 996                 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
 997         }
 998
 999         GSList *iter = NULL;
1000         stt_engine_info_s *engine_info = NULL;
1001
1002         /* Get a first item */
1003         iter = g_slist_nth(g_engine_list, 0);
1004
1005         while (NULL != iter) {
1006                 engine_info = iter->data;
1007
1008                 if (NULL == engine_info) {
1009                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1010                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1011                 }
1012
1013                 if (0 != strcmp(engine_id, engine_info->uuid)) {
1014                         iter = g_slist_next(iter);
1015                         continue;
1016                 }
1017
1018                 GSList *iter_lang = NULL;
1019                 char* lang;
1020
1021                 /* Get a first item */
1022                 iter_lang = g_slist_nth(engine_info->languages, 0);
1023
1024                 while (NULL != iter_lang) {
1025                         /*Get handle data from list*/
1026                         lang = iter_lang->data;
1027
1028                         SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1029                         if (NULL != lang) {
1030                                 if (false == callback(engine_info->uuid, lang, user_data))
1031                                         break;
1032                         }
1033
1034                         /*Get next item*/
1035                         iter_lang = g_slist_next(iter_lang);
1036                 }
1037                 break;
1038         }
1039
1040         return STT_CONFIG_ERROR_NONE;
1041 }
1042
1043 int stt_config_mgr_get_default_language(char** language)
1044 {
1045         if (0 >= g_slist_length(g_config_client_list)) {
1046                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1047                 return STT_CONFIG_ERROR_INVALID_STATE;
1048         }
1049
1050         if (NULL == language) {
1051                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1052         }
1053
1054         if (NULL != g_config_info->language) {
1055                 *language = strdup(g_config_info->language);
1056         } else {
1057                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1058                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1059         }
1060
1061         return STT_CONFIG_ERROR_NONE;
1062 }
1063
1064 int stt_config_mgr_set_default_language(const char* language)
1065 {
1066         if (0 >= g_slist_length(g_config_client_list)) {
1067                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1068                 return STT_CONFIG_ERROR_INVALID_STATE;
1069         }
1070
1071         if (NULL == language) {
1072                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1073         }
1074
1075         /* Check language is valid */
1076         if (NULL != g_config_info->language) {
1077                 if (0 != stt_parser_set_language(language)) {
1078                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1079                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1080                 }
1081                 free(g_config_info->language);
1082                 g_config_info->language = strdup(language);
1083         } else {
1084                 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1085                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1086         }
1087
1088         return STT_CONFIG_ERROR_NONE;
1089 }
1090
1091 int stt_config_mgr_get_auto_language(bool* value)
1092 {
1093         if (0 >= g_slist_length(g_config_client_list)) {
1094                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1095                 return STT_CONFIG_ERROR_INVALID_STATE;
1096         }
1097
1098         if (NULL == value) {
1099                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1100         }
1101
1102         *value = g_config_info->auto_lang;
1103
1104         return STT_CONFIG_ERROR_NONE;
1105 }
1106
1107 int stt_config_mgr_set_auto_language(bool value)
1108 {
1109         if (0 >= g_slist_length(g_config_client_list)) {
1110                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1111                 return STT_CONFIG_ERROR_INVALID_STATE;
1112         }
1113
1114         if (g_config_info->auto_lang != value) {
1115                 /* Check language is valid */
1116                 if (0 != stt_parser_set_auto_lang(value)) {
1117                         SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1118                         return STT_CONFIG_ERROR_OPERATION_FAILED;
1119                 }
1120                 g_config_info->auto_lang = value;
1121
1122                 if (true == g_config_info->auto_lang) {
1123                         __stt_config_set_auto_language();
1124                 }
1125         }
1126
1127         return STT_CONFIG_ERROR_NONE;
1128 }
1129
1130 int stt_config_mgr_get_silence_detection(bool* value)
1131 {
1132         if (0 >= g_slist_length(g_config_client_list)) {
1133                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1134                 return STT_CONFIG_ERROR_INVALID_STATE;
1135         }
1136
1137         if (NULL == value)
1138                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1139
1140         *value = g_config_info->silence_detection;
1141
1142         return STT_CONFIG_ERROR_NONE;
1143 }
1144
1145 int stt_config_mgr_set_silence_detection(bool value)
1146 {
1147         if (0 >= g_slist_length(g_config_client_list)) {
1148                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1149                 return STT_CONFIG_ERROR_INVALID_STATE;
1150         }
1151
1152         if (0 != stt_parser_set_silence_detection(value)) {
1153                 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1154                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1155         }
1156
1157         g_config_info->silence_detection = value;
1158
1159         return STT_CONFIG_ERROR_NONE;
1160 }
1161
1162 bool stt_config_check_default_engine_is_valid(const char* engine)
1163 {
1164         if (0 >= g_slist_length(g_config_client_list)) {
1165                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1166                 return false;
1167         }
1168
1169         if (NULL == engine) {
1170                 return false;
1171         }
1172
1173         if (0 >= g_slist_length(g_engine_list))
1174                 return false;
1175
1176         GSList *iter = NULL;
1177         stt_engine_info_s *engine_info = NULL;
1178
1179         /* Get a first item */
1180         iter = g_slist_nth(g_engine_list, 0);
1181
1182         while (NULL != iter) {
1183                 engine_info = iter->data;
1184
1185                 if (NULL != engine_info) {
1186                         if (0 == strcmp(engine, engine_info->uuid)) {
1187                                 return true;
1188                         }
1189                 }
1190                 iter = g_slist_next(iter);
1191         }
1192
1193         return false;
1194 }
1195
1196 bool stt_config_check_default_language_is_valid(const char* language)
1197 {
1198         if (0 >= g_slist_length(g_config_client_list)) {
1199                 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1200                 return false;
1201         }
1202
1203         if (NULL == language) {
1204                 return false;
1205         }
1206
1207         if (NULL == g_config_info->engine_id) {
1208                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1209                 return false;
1210         }
1211
1212         if (0 >= g_slist_length(g_engine_list))
1213                 return false;
1214
1215         GSList *iter = NULL;
1216         stt_engine_info_s *engine_info = NULL;
1217
1218         /* Get a first item */
1219         iter = g_slist_nth(g_engine_list, 0);
1220
1221         while (NULL != iter) {
1222                 engine_info = iter->data;
1223
1224                 if (NULL == engine_info) {
1225                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1226                         iter = g_slist_next(iter);
1227                         continue;
1228                 }
1229
1230                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1231                         iter = g_slist_next(iter);
1232                         continue;
1233                 }
1234
1235                 GSList *iter_lang = NULL;
1236                 char* lang;
1237
1238                 /* Get a first item */
1239                 iter_lang = g_slist_nth(engine_info->languages, 0);
1240
1241                 while (NULL != iter_lang) {
1242                         lang = iter_lang->data;
1243
1244                         if (0 == strcmp(language, lang))
1245                                 return true;
1246
1247                         /*Get next item*/
1248                         iter_lang = g_slist_next(iter_lang);
1249                 }
1250                 break;
1251         }
1252
1253         return false;
1254 }
1255
1256 int __stt_config_mgr_print_engine_info()
1257 {
1258         GSList *iter = NULL;
1259         stt_engine_info_s *engine_info = NULL;
1260
1261         if (0 >= g_slist_length(g_engine_list)) {
1262                 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1263                 SLOG(LOG_DEBUG, stt_tag(), "  No Engine in engine directory");
1264                 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1265                 return 0;
1266         }
1267
1268         /* Get a first item */
1269         iter = g_slist_nth(g_engine_list, 0);
1270
1271         SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1272
1273         int i = 1;
1274         while (NULL != iter) {
1275                 engine_info = iter->data;
1276
1277                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1278                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1279                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " id   : %s", engine_info->uuid);
1280                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1281                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1282
1283                 SLOG(LOG_DEBUG, stt_tag(), " languages");
1284                 GSList *iter_lang = NULL;
1285                 char* lang;
1286                 if (g_slist_length(engine_info->languages) > 0) {
1287                         /* Get a first item */
1288                         iter_lang = g_slist_nth(engine_info->languages, 0);
1289
1290                         int j = 1;
1291                         while (NULL != iter_lang) {
1292                                 /*Get handle data from list*/
1293                                 lang = iter_lang->data;
1294
1295                                 SECURE_SLOG(LOG_DEBUG, stt_tag(), "  [%dth] %s", j, lang);
1296
1297                                 /*Get next item*/
1298                                 iter_lang = g_slist_next(iter_lang);
1299                                 j++;
1300                         }
1301                 } else {
1302                         SLOG(LOG_ERROR, stt_tag(), "  language is NONE");
1303                 }
1304                 SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1305                         engine_info->support_silence_detection ? "true" : "false");
1306                 iter = g_slist_next(iter);
1307                 i++;
1308         }
1309         SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1310
1311         return 0;
1312 }
1313
1314
1315
1316 /**
1317 * time info functions
1318 */
1319 static GSList* g_time_list = NULL;
1320
1321 int stt_config_mgr_reset_time_info()
1322 {
1323         /* Remove time info */
1324         GSList *iter = NULL;
1325         stt_result_time_info_s *data = NULL;
1326
1327         /* Remove time info */
1328         iter = g_slist_nth(g_time_list, 0);
1329         while (NULL != iter) {
1330                 data = iter->data;
1331
1332                 g_time_list = g_slist_remove(g_time_list, data);
1333                 if (NULL != data) {
1334                         if (NULL == data->text) free(data->text);
1335                         free(data);
1336                 }
1337
1338                 /*Get next item*/
1339                 iter = g_slist_nth(g_time_list, 0);
1340         }
1341
1342         return 0;
1343 }
1344
1345 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1346 {
1347         if (NULL == text) {
1348                 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1349                 return -1;
1350         }
1351
1352         stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1353
1354         info->index = index;
1355         info->event = event;
1356         if (NULL != text) {
1357                 info->text = strdup(text);
1358         }
1359         info->start_time = start_time;
1360         info->end_time = end_time;
1361
1362         /* Add item to global list */
1363         g_time_list = g_slist_append(g_time_list, info);
1364
1365         return 0;
1366 }
1367
1368 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1369 {
1370         if (NULL == callback) {
1371                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1372                 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1373         }
1374
1375         GSList* temp_time = NULL;
1376         int ret;
1377         ret = stt_parser_get_time_info(&temp_time);
1378         if (0 != ret) {
1379                 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1380                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1381         }
1382
1383         GSList *iter = NULL;
1384         stt_result_time_info_s *data = NULL;
1385
1386         /* Get a first item */
1387         iter = g_slist_nth(temp_time, 0);
1388         while (NULL != iter) {
1389                 data = iter->data;
1390
1391                 if (false == callback(data->index, data->event, data->text,
1392                         data->start_time, data->end_time, user_data)) {
1393                         break;
1394                 }
1395
1396                 /*Get next item*/
1397                 iter = g_slist_next(iter);
1398         }
1399
1400         /* Remove time info */
1401         iter = g_slist_nth(temp_time, 0);
1402         while (NULL != iter) {
1403                 data = iter->data;
1404
1405                 if (NULL != data) {
1406                         temp_time = g_slist_remove(temp_time, data);
1407
1408                         if (NULL == data->text) free(data->text);
1409                         free(data);
1410                 }
1411
1412                 /*Get next item*/
1413                 iter = g_slist_nth(temp_time, 0);
1414         }
1415
1416         return STT_CONFIG_ERROR_NONE;
1417 }
1418
1419 int stt_config_mgr_save_time_info_file()
1420 {
1421         if (0 == g_slist_length(g_time_list)) {
1422                 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1423                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1424         }
1425
1426         int ret = 0;
1427         ret = stt_parser_set_time_info(g_time_list);
1428         if (0 != ret) {
1429                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1430                 return STT_CONFIG_ERROR_OPERATION_FAILED;
1431         }
1432
1433         return STT_CONFIG_ERROR_NONE;
1434 }
1435
1436 int stt_config_mgr_remove_time_info_file()
1437 {
1438         stt_parser_clear_time_info();
1439
1440         return STT_CONFIG_ERROR_NONE;
1441 }