2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
20 #include <sys/inotify.h>
23 #include "stt_config_mgr.h"
25 #include "stt_config_parser.h"
30 stt_config_engine_changed_cb engine_cb;
31 stt_config_lang_changed_cb lang_cb;
32 stt_config_bool_changed_cb bool_cb;
34 } stt_config_client_s;
37 extern const char* stt_tag();
39 static GSList* g_engine_list = NULL;
41 static GSList* g_config_client_list = NULL;
43 static stt_config_s* g_config_info;
45 static Ecore_Fd_Handler* g_fd_handler_noti = NULL;
49 int __stt_config_mgr_print_engine_info();
51 bool __stt_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
53 if (NULL == engine_id || NULL == language) {
54 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
59 stt_engine_info_s *engine_info = NULL;
61 if (0 >= g_slist_length(g_engine_list)) {
62 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
66 /* Get a first item */
67 iter = g_slist_nth(g_engine_list, 0);
69 while (NULL != iter) {
70 engine_info = iter->data;
72 if (NULL == engine_info) {
73 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
77 if (0 != strcmp(engine_id, engine_info->uuid)) {
78 iter = g_slist_next(iter);
82 GSList *iter_lang = NULL;
84 if (g_slist_length(engine_info->languages) > 0) {
85 /* Get a first item */
86 iter_lang = g_slist_nth(engine_info->languages, 0);
89 while (NULL != iter_lang) {
90 /*Get handle data from list*/
91 engine_lang = iter_lang->data;
93 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", i, engine_lang);
95 if (0 == strcmp(language, engine_lang)) {
100 iter_lang = g_slist_next(iter_lang);
110 int __stt_config_mgr_select_lang(const char* engine_id, char** language)
112 if (NULL == engine_id || NULL == language) {
113 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
118 stt_engine_info_s *engine_info = NULL;
120 if (0 >= g_slist_length(g_engine_list)) {
121 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
125 /* Get a first item */
126 iter = g_slist_nth(g_engine_list, 0);
128 while (NULL != iter) {
129 engine_info = iter->data;
131 if (NULL == engine_info) {
132 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
136 if (0 != strcmp(engine_id, engine_info->uuid)) {
137 iter = g_slist_next(iter);
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);
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", (NULL == *language) ? "NULL" : *language);
158 iter_lang = g_slist_next(iter_lang);
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", (NULL == *language) ? "NULL" : *language);
174 Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
176 SLOG(LOG_DEBUG, stt_tag(), "===== Config changed callback event");
179 struct inotify_event event;
180 memset(&event, '\0', sizeof(struct inotify_event));
182 length = read(g_fd_noti, &event, sizeof(struct inotify_event));
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;
190 if (IN_MODIFY == event.mask) {
192 char* setting = NULL;
199 stt_config_client_s* temp_client = NULL;
201 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
202 return ECORE_CALLBACK_PASS_ON;
205 if (NULL != engine || NULL != setting) {
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);
212 if (NULL != setting) {
213 if (NULL != g_config_info->setting) free(g_config_info->setting);
214 g_config_info->setting = strdup(setting);
218 if (NULL != g_config_info->language) free(g_config_info->language);
219 g_config_info->language = strdup(lang);
222 if (-1 != silence) g_config_info->silence_detection = silence;
224 if (-1 != credential) g_config_info->credential = credential;
226 /* Call all callbacks of client*/
227 iter = g_slist_nth(g_config_client_list, 0);
229 while (NULL != iter) {
230 temp_client = iter->data;
232 if (NULL != temp_client) {
233 if (NULL != temp_client->engine_cb) {
234 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
235 g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
239 iter = g_slist_next(iter);
243 if (-1 != auto_lang) {
244 g_config_info->auto_lang = auto_lang;
247 /* Only language changed */
248 if (NULL == engine && NULL != lang) {
249 char* before_lang = NULL;
250 before_lang = strdup(g_config_info->language);
253 if (NULL != g_config_info->language) free(g_config_info->language);
254 g_config_info->language = strdup(lang);
257 /* Call all callbacks of client*/
258 iter = g_slist_nth(g_config_client_list, 0);
260 while (NULL != iter) {
261 temp_client = iter->data;
263 if (NULL != temp_client) {
264 if (NULL != temp_client->lang_cb) {
265 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
269 iter = g_slist_next(iter);
272 if (NULL != before_lang) {
278 /* silence detection changed */
279 g_config_info->silence_detection = silence;
281 /* Call all callbacks of client*/
282 iter = g_slist_nth(g_config_client_list, 0);
284 while (NULL != iter) {
285 temp_client = iter->data;
287 if (NULL != temp_client) {
288 if (NULL != temp_client->bool_cb) {
289 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
293 iter = g_slist_next(iter);
297 if (NULL != engine) free(engine);
298 if (NULL != setting) free(setting);
299 if (NULL != lang) free(lang);
301 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
304 SLOG(LOG_DEBUG, stt_tag(), "=====");
305 SLOG(LOG_DEBUG, stt_tag(), " ");
307 return ECORE_CALLBACK_PASS_ON;
310 int __stt_config_mgr_register_config_event()
312 /* get file notification handler */
318 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
323 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
326 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);
327 if (NULL == g_fd_handler_noti) {
328 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
335 int __stt_config_mgr_unregister_config_event()
337 /* delete inotify variable */
338 ecore_main_fd_handler_del(g_fd_handler_noti);
339 inotify_rm_watch(g_fd_noti, g_wd_noti);
345 int __stt_config_set_auto_language()
348 char candidate_lang[6] = {'\0', };
350 value = vconf_get_str(VCONFKEY_LANGSET);
352 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
356 strncpy(candidate_lang, value, 5);
359 /* Check current config info */
360 if (NULL == g_config_info) {
361 SLOG(LOG_ERROR, stt_tag(), "Current config info is NULL");
362 return STT_CONFIG_ERROR_OPERATION_FAILED;
365 /* Check current language */
366 if (NULL == g_config_info->language) {
367 SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
368 return STT_CONFIG_ERROR_OPERATION_FAILED;
371 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
372 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
375 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
378 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
379 char* before_lang = NULL;
380 if (0 != stt_parser_set_language(candidate_lang)) {
381 SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
385 before_lang = strdup(g_config_info->language);
387 free(g_config_info->language);
388 g_config_info->language = strdup(candidate_lang);
390 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
392 /* Call all callbacks of client*/
394 stt_config_client_s* temp_client = NULL;
396 iter = g_slist_nth(g_config_client_list, 0);
398 while (NULL != iter) {
399 temp_client = iter->data;
401 if (NULL != temp_client) {
402 if (NULL != temp_client->lang_cb) {
403 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
407 iter = g_slist_next(iter);
410 if (NULL != before_lang) {
414 /* Candidate language is not valid */
415 char* tmp_language = NULL;
416 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
417 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
421 if (NULL == tmp_language) {
422 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
426 if (0 != stt_parser_set_language(tmp_language)) {
428 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
432 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
434 /* Call all callbacks of client*/
436 stt_config_client_s* temp_client = NULL;
438 iter = g_slist_nth(g_config_client_list, 0);
440 while (NULL != iter) {
441 temp_client = iter->data;
443 if (NULL != temp_client) {
444 if (NULL != temp_client->lang_cb) {
445 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
449 iter = g_slist_next(iter);
452 free(g_config_info->language);
453 g_config_info->language = strdup(tmp_language);
462 void __stt_config_language_changed_cb(keynode_t *key, void *data)
464 if (true == g_config_info->auto_lang) {
465 /* Get voice input vconf key */
466 __stt_config_set_auto_language();
472 void __stt_config_release_client(int uid)
475 stt_config_client_s* temp_client = NULL;
477 if (0 < g_slist_length(g_config_client_list)) {
479 iter = g_slist_nth(g_config_client_list, 0);
481 while (NULL != iter) {
482 temp_client = iter->data;
484 if (NULL != temp_client) {
485 if (uid == temp_client->uid) {
486 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
493 iter = g_slist_next(iter);
497 if (0 < g_slist_length(g_config_client_list)) {
498 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
503 void __stt_config_release_engine()
506 stt_engine_info_s *engine_info = NULL;
508 if (0 < g_slist_length(g_engine_list)) {
510 /* Get a first item */
511 iter = g_slist_nth(g_engine_list, 0);
513 while (NULL != iter) {
514 engine_info = iter->data;
516 if (NULL != engine_info) {
517 g_engine_list = g_slist_remove(g_engine_list, engine_info);
519 stt_parser_free_engine_info(engine_info);
522 iter = g_slist_nth(g_engine_list, 0);
528 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
530 if (NULL == engine_id) {
531 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
532 return STT_CONFIG_ERROR_INVALID_PARAMETER;
536 stt_engine_info_s *engine_info = NULL;
538 if (0 >= g_slist_length(g_engine_list)) {
539 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
540 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
543 /* Get a first item */
544 iter = g_slist_nth(g_engine_list, 0);
546 while (NULL != iter) {
547 engine_info = iter->data;
549 if (NULL == engine_info) {
550 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
551 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
554 if (0 == strcmp(engine_id, engine_info->uuid)) {
555 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
556 return STT_CONFIG_ERROR_NONE;
559 iter = g_slist_next(iter);
562 /* Change default engine */
563 iter = g_slist_nth(g_engine_list, 0);
565 SLOG(LOG_ERROR, stt_tag(), "Operation failed - false engine");
566 return STT_CONFIG_ERROR_OPERATION_FAILED;
569 engine_info = iter->data;
570 if (NULL == engine_info) {
571 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
572 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
575 if (NULL != g_config_info->engine_id) {
576 free(g_config_info->engine_id);
577 g_config_info->engine_id = NULL;
579 if (NULL != g_config_info->setting) {
580 free(g_config_info->setting);
581 g_config_info->setting = NULL;
584 if (NULL != engine_info->uuid) {
585 g_config_info->engine_id = strdup(engine_info->uuid);
588 if (NULL != engine_info->setting) {
589 g_config_info->setting = strdup(engine_info->setting);
593 GSList *iter_lang = NULL;
595 bool is_valid_lang = false;
597 if (0 >= g_slist_length(engine_info->languages)) {
598 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
599 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
602 /* Get a first item */
603 iter_lang = g_slist_nth(engine_info->languages, 0);
605 while (NULL != iter_lang) {
606 /*Get handle data from list*/
607 lang = iter_lang->data;
609 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
611 if (0 == strcmp(lang, g_config_info->language)) {
612 /* language is valid */
613 is_valid_lang = true;
619 iter_lang = g_slist_next(iter_lang);
622 if (false == is_valid_lang) {
623 iter_lang = g_slist_nth(engine_info->languages, 0);
624 if (NULL != iter_lang) {
625 lang = iter_lang->data;
627 if (NULL != g_config_info->language)
628 free(g_config_info->language);
629 g_config_info->language = strdup(lang);
635 if (false == engine_info->support_silence_detection) {
636 if (true == g_config_info->silence_detection)
637 g_config_info->silence_detection = false;
640 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
641 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
642 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
643 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
644 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
645 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
647 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
648 g_config_info->silence_detection, g_config_info->credential)) {
649 SLOG(LOG_ERROR, stt_tag(), "Fail to save config");
650 return STT_CONFIG_ERROR_OPERATION_FAILED;
653 return STT_CONFIG_ERROR_NONE;
656 static void __get_engine_list(const char* directory)
661 struct dirent *dirp = NULL;
663 if (NULL == directory) {
664 SLOG(LOG_ERROR, stt_tag(), "[Directory ERROR] Directory is NULL");
668 dp = opendir(directory);
671 ret = readdir_r(dp, &entry, &dirp);
673 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
678 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
681 stt_engine_info_s* info;
682 char* filepath = NULL;
685 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
686 filepath = (char*)calloc(filesize, sizeof(char));
688 if (NULL != filepath) {
689 snprintf(filepath, filesize, "%s/%s", directory, dirp->d_name);
691 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
695 if (0 == stt_parser_get_engine_info(filepath, &info)) {
696 g_engine_list = g_slist_append(g_engine_list, info);
699 if (NULL != filepath) {
704 } while (NULL != dirp);
708 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open directory");
714 int stt_config_mgr_initialize(int uid)
718 stt_config_client_s* temp_client = NULL;
720 if (0 < g_slist_length(g_config_client_list)) {
722 iter = g_slist_nth(g_config_client_list, 0);
724 while (NULL != iter) {
725 get_uid = iter->data;
727 if (uid == *get_uid) {
728 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
732 iter = g_slist_next(iter);
735 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
736 if (NULL == temp_client) {
737 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
738 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
740 temp_client->uid = uid;
741 temp_client->bool_cb = NULL;
742 temp_client->engine_cb = NULL;
743 temp_client->lang_cb = NULL;
744 temp_client->user_data = NULL;
747 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
749 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
750 return STT_CONFIG_ERROR_NONE;
753 /* Make directories */
754 if (0 != access(STT_CONFIG_BASE, F_OK)) {
755 if (0 != mkdir(STT_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
756 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_CONFIG_BASE);
757 __stt_config_release_client(uid);
758 return STT_CONFIG_ERROR_OPERATION_FAILED;
760 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_CONFIG_BASE);
764 if (0 != access(STT_HOME, F_OK)) {
765 if (0 != mkdir(STT_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
766 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_HOME);
767 __stt_config_release_client(uid);
768 return STT_CONFIG_ERROR_OPERATION_FAILED;
770 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_HOME);
774 if (0 != access(STT_DOWNLOAD_BASE, F_OK)) {
775 if (0 != mkdir(STT_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
776 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_BASE);
777 __stt_config_release_client(uid);
778 return STT_CONFIG_ERROR_OPERATION_FAILED;
780 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_BASE);
784 if (0 != access(STT_DOWNLOAD_ENGINE_INFO, F_OK)) {
785 if (0 != mkdir(STT_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
786 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
787 __stt_config_release_client(uid);
788 return STT_CONFIG_ERROR_OPERATION_FAILED;
790 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
795 /* Get file name from default engine directory */
796 g_engine_list = NULL;
798 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
800 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get default engine list");
801 __get_engine_list(STT_DEFAULT_ENGINE_INFO);
802 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get download engine list");
803 __get_engine_list(STT_DOWNLOAD_ENGINE_INFO);
805 __stt_config_mgr_print_engine_info();
807 if (0 != stt_parser_load_config(&g_config_info)) {
808 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
809 __stt_config_release_client(uid);
810 __stt_config_release_engine();
811 return STT_CONFIG_ERROR_OPERATION_FAILED;
814 /* Check whether engine id is valid */
815 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
816 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
817 __stt_config_release_client(uid);
818 __stt_config_release_engine();
819 stt_parser_unload_config(g_config_info);
820 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
823 if (true == g_config_info->auto_lang) {
824 /* Check language with display language */
825 __stt_config_set_auto_language();
827 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
828 /* Default language is not valid */
830 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
831 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
832 __stt_config_release_client(uid);
833 __stt_config_release_engine();
834 stt_parser_unload_config(g_config_info);
835 return STT_CONFIG_ERROR_OPERATION_FAILED;
838 if (NULL != tmp_language) {
839 if (NULL != g_config_info->language) {
840 free(g_config_info->language);
841 g_config_info->language = strdup(tmp_language);
849 /* print stt-service config */
850 SLOG(LOG_DEBUG, stt_tag(), "== STT service config ==");
851 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
852 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
853 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
854 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
855 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
856 SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
857 SLOG(LOG_DEBUG, stt_tag(), "===================");
859 if (0 != __stt_config_mgr_register_config_event()) {
860 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
861 __stt_config_release_client(uid);
862 __stt_config_release_engine();
863 stt_parser_unload_config(g_config_info);
864 return STT_CONFIG_ERROR_OPERATION_FAILED;
867 /* Register to detect display language change */
868 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
870 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
871 if (NULL == temp_client) {
872 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
873 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
875 temp_client->uid = uid;
876 temp_client->bool_cb = NULL;
877 temp_client->engine_cb = NULL;
878 temp_client->lang_cb = NULL;
879 temp_client->user_data = NULL;
882 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
884 return STT_CONFIG_ERROR_NONE;
887 int stt_config_mgr_finalize(int uid)
890 stt_config_client_s* temp_client = NULL;
892 if (0 < g_slist_length(g_config_client_list)) {
894 iter = g_slist_nth(g_config_client_list, 0);
896 while (NULL != iter) {
897 temp_client = iter->data;
899 if (NULL != temp_client) {
900 if (uid == temp_client->uid) {
901 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
908 iter = g_slist_next(iter);
912 if (0 < g_slist_length(g_config_client_list)) {
913 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
914 return STT_CONFIG_ERROR_NONE;
917 stt_engine_info_s *engine_info = NULL;
919 if (0 < g_slist_length(g_engine_list)) {
921 /* Get a first item */
922 iter = g_slist_nth(g_engine_list, 0);
924 while (NULL != iter) {
925 engine_info = iter->data;
927 if (NULL != engine_info) {
928 g_engine_list = g_slist_remove(g_engine_list, engine_info);
930 stt_parser_free_engine_info(engine_info);
933 iter = g_slist_nth(g_engine_list, 0);
937 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
939 __stt_config_mgr_unregister_config_event();
941 if (NULL != g_config_info) {
942 stt_parser_unload_config(g_config_info);
943 g_config_info = NULL;
946 return STT_CONFIG_ERROR_NONE;
949 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)
952 stt_config_client_s* temp_client = NULL;
954 /* Call all callbacks of client*/
955 iter = g_slist_nth(g_config_client_list, 0);
957 while (NULL != iter) {
958 temp_client = iter->data;
960 if (NULL != temp_client) {
961 if (uid == temp_client->uid) {
962 temp_client->engine_cb = engine_cb;
963 temp_client->lang_cb = lang_cb;
964 temp_client->bool_cb = bool_cb;
965 temp_client->user_data = user_data;
969 iter = g_slist_next(iter);
972 return STT_CONFIG_ERROR_NONE;
975 int stt_config_mgr_unset_callback(int uid)
978 stt_config_client_s* temp_client = NULL;
980 /* Call all callbacks of client*/
981 iter = g_slist_nth(g_config_client_list, 0);
983 while (NULL != iter) {
984 temp_client = iter->data;
986 if (NULL != temp_client) {
987 if (uid == temp_client->uid) {
988 temp_client->engine_cb = NULL;
989 temp_client->lang_cb = NULL;
990 temp_client->bool_cb = NULL;
991 temp_client->user_data = NULL;
995 iter = g_slist_next(iter);
998 return STT_CONFIG_ERROR_NONE;
1001 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
1003 if (0 >= g_slist_length(g_config_client_list)) {
1004 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1005 return STT_CONFIG_ERROR_INVALID_STATE;
1008 if (NULL == callback) {
1009 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1012 GSList *iter = NULL;
1013 stt_engine_info_s *engine_info = NULL;
1015 if (0 >= g_slist_length(g_engine_list)) {
1016 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
1017 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1020 /* Get a first item */
1021 iter = g_slist_nth(g_engine_list, 0);
1023 while (NULL != iter) {
1024 engine_info = iter->data;
1026 if (NULL == engine_info) {
1027 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
1028 return STT_CONFIG_ERROR_OPERATION_FAILED;
1031 if (false == callback(engine_info->uuid, engine_info->name,
1032 engine_info->setting, engine_info->support_silence_detection, user_data)) {
1036 iter = g_slist_next(iter);
1039 return STT_CONFIG_ERROR_NONE;
1042 int stt_config_mgr_get_engine(char** engine)
1044 if (0 >= g_slist_length(g_config_client_list)) {
1045 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1046 return STT_CONFIG_ERROR_INVALID_STATE;
1049 if (NULL == engine) {
1050 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1053 if (NULL != g_config_info->engine_id) {
1054 *engine = strdup(g_config_info->engine_id);
1056 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
1057 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1060 return STT_CONFIG_ERROR_NONE;
1063 int stt_config_mgr_set_engine(const char* engine)
1065 if (0 >= g_slist_length(g_config_client_list)) {
1066 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1067 return STT_CONFIG_ERROR_INVALID_STATE;
1070 if (NULL == g_config_info) {
1071 return STT_CONFIG_ERROR_OPERATION_FAILED;
1074 if (NULL == engine || NULL == g_config_info->engine_id) {
1075 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1078 /* Check current engine id with new engine id */
1079 if (0 == strcmp(g_config_info->engine_id, engine)) {
1083 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1085 GSList *iter = NULL;
1086 stt_engine_info_s *engine_info = NULL;
1087 bool is_valid_engine = false;
1089 /* Get a first item */
1090 iter = g_slist_nth(g_engine_list, 0);
1092 while (NULL != iter) {
1093 engine_info = iter->data;
1095 if (NULL == engine_info) {
1096 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1097 iter = g_slist_next(iter);
1101 /* Check engine id is valid */
1102 if (0 != strcmp(engine, engine_info->uuid)) {
1103 iter = g_slist_next(iter);
1107 if (NULL != g_config_info->engine_id) {
1108 free(g_config_info->engine_id);
1109 g_config_info->engine_id = NULL;
1112 g_config_info->engine_id = strdup(engine);
1114 if (NULL != g_config_info->setting) {
1115 free(g_config_info->setting);
1116 g_config_info->setting = NULL;
1119 if (NULL != engine_info->setting) {
1120 g_config_info->setting = strdup(engine_info->setting);
1122 g_config_info->setting = NULL;
1125 /* Engine is valid*/
1126 GSList *iter_lang = NULL;
1128 bool is_valid_lang = false;
1130 /* Get a first item */
1131 iter_lang = g_slist_nth(engine_info->languages, 0);
1133 while (NULL != iter_lang) {
1134 /*Get handle data from list*/
1135 lang = iter_lang->data;
1137 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1138 if (NULL != lang && NULL != g_config_info->language) {
1139 if (0 == strcmp(lang, g_config_info->language)) {
1140 /* language is valid */
1141 is_valid_lang = true;
1143 free(g_config_info->language);
1144 g_config_info->language = strdup(lang);
1151 iter_lang = g_slist_next(iter_lang);
1154 if (false == is_valid_lang) {
1155 if (NULL != g_config_info->language) {
1156 free(g_config_info->language);
1157 g_config_info->language = NULL;
1159 iter_lang = g_slist_nth(engine_info->languages, 0);
1160 if (NULL == iter_lang) {
1161 SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
1165 lang = iter_lang->data;
1167 g_config_info->language = strdup(lang);
1172 if (false == engine_info->support_silence_detection) {
1173 if (true == g_config_info->silence_detection)
1174 g_config_info->silence_detection = false;
1177 if (false == engine_info->need_credential) {
1178 if (true == g_config_info->credential)
1179 g_config_info->credential = false;
1182 is_valid_engine = true;
1186 if (true == is_valid_engine) {
1187 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1188 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1189 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1190 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1191 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1192 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1194 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1195 g_config_info->silence_detection, g_config_info->credential)) {
1196 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1197 return STT_CONFIG_ERROR_OPERATION_FAILED;
1200 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1201 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1207 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1209 if (0 >= g_slist_length(g_engine_list)) {
1210 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1211 return STT_CONFIG_ERROR_INVALID_STATE;
1214 if (NULL == agreement) {
1215 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1216 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1219 GSList *iter = NULL;
1220 stt_engine_info_s *engine_info = NULL;
1221 char* current_engine = NULL;
1223 if (NULL == engine) {
1224 current_engine = strdup(g_config_info->engine_id);
1225 if (NULL == current_engine) {
1226 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1227 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1230 current_engine = strdup(engine);
1231 if (NULL == current_engine) {
1232 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1233 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1237 /* Get a first item */
1238 iter = g_slist_nth(g_engine_list, 0);
1240 while (NULL != iter) {
1241 engine_info = iter->data;
1243 if (NULL == engine_info) {
1244 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1245 if (NULL != current_engine) free(current_engine);
1246 return STT_CONFIG_ERROR_OPERATION_FAILED;
1249 if (0 != strcmp(current_engine, engine_info->uuid)) {
1250 iter = g_slist_next(iter);
1254 if (NULL != engine_info->agreement) {
1255 *agreement = strdup(engine_info->agreement);
1257 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1262 if (NULL != current_engine) free(current_engine);
1264 return STT_CONFIG_ERROR_NONE;
1267 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1269 if (0 >= g_slist_length(g_config_client_list)) {
1270 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1271 return STT_CONFIG_ERROR_INVALID_STATE;
1274 if (0 >= g_slist_length(g_engine_list)) {
1275 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1276 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1279 GSList *iter = NULL;
1280 stt_engine_info_s *engine_info = NULL;
1282 /* Get a first item */
1283 iter = g_slist_nth(g_engine_list, 0);
1285 while (NULL != iter) {
1286 engine_info = iter->data;
1288 if (NULL == engine_info) {
1289 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1290 return STT_CONFIG_ERROR_OPERATION_FAILED;
1293 if (0 != strcmp(engine_id, engine_info->uuid)) {
1294 iter = g_slist_next(iter);
1298 GSList *iter_lang = NULL;
1301 /* Get a first item */
1302 iter_lang = g_slist_nth(engine_info->languages, 0);
1304 while (NULL != iter_lang) {
1305 /*Get handle data from list*/
1306 lang = iter_lang->data;
1309 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1310 if (false == callback(engine_info->uuid, lang, user_data))
1315 iter_lang = g_slist_next(iter_lang);
1320 return STT_CONFIG_ERROR_NONE;
1323 int stt_config_mgr_get_default_language(char** language)
1325 if (0 >= g_slist_length(g_config_client_list)) {
1326 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1327 return STT_CONFIG_ERROR_INVALID_STATE;
1330 if (NULL == language) {
1331 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1334 if (NULL != g_config_info->language) {
1335 *language = strdup(g_config_info->language);
1337 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1338 return STT_CONFIG_ERROR_OPERATION_FAILED;
1341 return STT_CONFIG_ERROR_NONE;
1344 int stt_config_mgr_set_default_language(const char* language)
1346 if (0 >= g_slist_length(g_config_client_list)) {
1347 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1348 return STT_CONFIG_ERROR_INVALID_STATE;
1351 if (NULL == language) {
1352 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1355 /* Check language is valid */
1356 if (NULL != g_config_info->language) {
1357 if (0 != stt_parser_set_language(language)) {
1358 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1359 return STT_CONFIG_ERROR_OPERATION_FAILED;
1361 free(g_config_info->language);
1362 g_config_info->language = strdup(language);
1364 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1365 return STT_CONFIG_ERROR_OPERATION_FAILED;
1368 return STT_CONFIG_ERROR_NONE;
1371 int stt_config_mgr_get_auto_language(bool* value)
1373 if (0 >= g_slist_length(g_config_client_list)) {
1374 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1375 return STT_CONFIG_ERROR_INVALID_STATE;
1378 if (NULL == value) {
1379 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1382 *value = g_config_info->auto_lang;
1384 return STT_CONFIG_ERROR_NONE;
1387 int stt_config_mgr_set_auto_language(bool value)
1389 if (0 >= g_slist_length(g_config_client_list)) {
1390 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1391 return STT_CONFIG_ERROR_INVALID_STATE;
1394 if (g_config_info->auto_lang != value) {
1395 /* Check language is valid */
1396 if (0 != stt_parser_set_auto_lang(value)) {
1397 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1398 return STT_CONFIG_ERROR_OPERATION_FAILED;
1400 g_config_info->auto_lang = value;
1402 if (true == g_config_info->auto_lang) {
1403 __stt_config_set_auto_language();
1407 return STT_CONFIG_ERROR_NONE;
1410 int stt_config_mgr_get_silence_detection(bool* value)
1412 if (0 >= g_slist_length(g_config_client_list)) {
1413 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1414 return STT_CONFIG_ERROR_INVALID_STATE;
1418 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1420 *value = g_config_info->silence_detection;
1422 return STT_CONFIG_ERROR_NONE;
1425 int stt_config_mgr_set_silence_detection(bool value)
1427 if (0 >= g_slist_length(g_config_client_list)) {
1428 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1429 return STT_CONFIG_ERROR_INVALID_STATE;
1432 if (0 != stt_parser_set_silence_detection(value)) {
1433 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1434 return STT_CONFIG_ERROR_OPERATION_FAILED;
1437 g_config_info->silence_detection = value;
1439 return STT_CONFIG_ERROR_NONE;
1442 bool stt_config_check_default_engine_is_valid(const char* engine)
1444 if (0 >= g_slist_length(g_config_client_list)) {
1445 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1449 if (NULL == engine) {
1453 if (0 >= g_slist_length(g_engine_list))
1456 GSList *iter = NULL;
1457 stt_engine_info_s *engine_info = NULL;
1459 /* Get a first item */
1460 iter = g_slist_nth(g_engine_list, 0);
1462 while (NULL != iter) {
1463 engine_info = iter->data;
1465 if (NULL != engine_info) {
1466 if (0 == strcmp(engine, engine_info->uuid)) {
1470 iter = g_slist_next(iter);
1476 bool stt_config_check_default_language_is_valid(const char* language)
1478 if (0 >= g_slist_length(g_config_client_list)) {
1479 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1483 if (NULL == language) {
1487 if (NULL == g_config_info->engine_id) {
1488 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1492 if (0 >= g_slist_length(g_engine_list))
1495 GSList *iter = NULL;
1496 stt_engine_info_s *engine_info = NULL;
1498 /* Get a first item */
1499 iter = g_slist_nth(g_engine_list, 0);
1501 while (NULL != iter) {
1502 engine_info = iter->data;
1504 if (NULL == engine_info) {
1505 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1506 iter = g_slist_next(iter);
1510 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1511 iter = g_slist_next(iter);
1515 GSList *iter_lang = NULL;
1518 /* Get a first item */
1519 iter_lang = g_slist_nth(engine_info->languages, 0);
1521 while (NULL != iter_lang) {
1522 lang = iter_lang->data;
1524 if (0 == strcmp(language, lang))
1528 iter_lang = g_slist_next(iter_lang);
1536 int __stt_config_mgr_print_engine_info()
1538 GSList *iter = NULL;
1539 stt_engine_info_s *engine_info = NULL;
1541 if (0 >= g_slist_length(g_engine_list)) {
1542 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1543 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1544 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1548 /* Get a first item */
1549 iter = g_slist_nth(g_engine_list, 0);
1551 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1554 while (NULL != iter) {
1555 engine_info = iter->data;
1557 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1558 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1559 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1560 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1561 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1563 SLOG(LOG_DEBUG, stt_tag(), " languages");
1564 GSList *iter_lang = NULL;
1566 if (g_slist_length(engine_info->languages) > 0) {
1567 /* Get a first item */
1568 iter_lang = g_slist_nth(engine_info->languages, 0);
1571 while (NULL != iter_lang) {
1572 /*Get handle data from list*/
1573 lang = iter_lang->data;
1575 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1578 iter_lang = g_slist_next(iter_lang);
1582 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1584 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1585 engine_info->support_silence_detection ? "true" : "false");
1586 iter = g_slist_next(iter);
1589 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1597 * time info functions
1599 static GSList* g_time_list = NULL;
1601 int stt_config_mgr_reset_time_info()
1603 /* Remove time info */
1604 GSList *iter = NULL;
1605 stt_result_time_info_s *data = NULL;
1607 /* Remove time info */
1608 iter = g_slist_nth(g_time_list, 0);
1609 while (NULL != iter) {
1612 g_time_list = g_slist_remove(g_time_list, data);
1614 if (NULL != data->text) {
1623 iter = g_slist_nth(g_time_list, 0);
1629 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1632 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1636 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1638 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1639 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1641 info->index = index;
1642 info->event = event;
1644 info->text = strdup(text);
1646 info->start_time = start_time;
1647 info->end_time = end_time;
1649 SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: index(%d), text(%s), start time(%d), end_time(%d)", info->index, (NULL == info->text) ? "NULL" : info->text, info->start_time, info->end_time);
1651 /* Add item to global list */
1652 g_time_list = g_slist_append(g_time_list, info);
1654 SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: g_time_list length(%d)", g_slist_length(g_time_list));
1659 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1661 if (NULL == callback) {
1662 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1663 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1666 GSList* temp_time = NULL;
1668 ret = stt_parser_get_time_info(&temp_time);
1670 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1671 return STT_CONFIG_ERROR_OPERATION_FAILED;
1674 GSList *iter = NULL;
1675 stt_result_time_info_s *data = NULL;
1677 /* Get a first item */
1678 iter = g_slist_nth(temp_time, 0);
1679 while (NULL != iter) {
1682 if (false == callback(data->index, data->event, data->text,
1683 data->start_time, data->end_time, user_data)) {
1688 iter = g_slist_next(iter);
1691 /* Remove time info */
1692 iter = g_slist_nth(temp_time, 0);
1693 while (NULL != iter) {
1697 temp_time = g_slist_remove(temp_time, data);
1699 if (NULL != data->text) {
1708 iter = g_slist_nth(temp_time, 0);
1711 return STT_CONFIG_ERROR_NONE;
1714 int stt_config_mgr_save_time_info_file()
1716 if (0 == g_slist_length(g_time_list)) {
1717 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1718 return STT_CONFIG_ERROR_OPERATION_FAILED;
1722 ret = stt_parser_set_time_info(g_time_list);
1724 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1725 return STT_CONFIG_ERROR_OPERATION_FAILED;
1728 return STT_CONFIG_ERROR_NONE;
1731 int stt_config_mgr_remove_time_info_file()
1733 stt_parser_clear_time_info();
1735 return STT_CONFIG_ERROR_NONE;