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>
24 #include "stt_config_mgr.h"
26 #include "stt_config_parser.h"
31 stt_config_engine_changed_cb engine_cb;
32 stt_config_lang_changed_cb lang_cb;
33 stt_config_bool_changed_cb bool_cb;
35 } stt_config_client_s;
38 extern const char* stt_tag();
40 static GSList* g_engine_list = NULL;
42 static GSList* g_config_client_list = NULL;
44 static stt_config_s* g_config_info;
46 static Ecore_Fd_Handler* g_fd_handler_noti = NULL;
50 int __stt_config_mgr_print_engine_info();
52 bool __stt_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
54 if (NULL == engine_id || NULL == language) {
55 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
60 stt_engine_info_s *engine_info = NULL;
62 if (0 >= g_slist_length(g_engine_list)) {
63 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
67 /* Get a first item */
68 iter = g_slist_nth(g_engine_list, 0);
70 while (NULL != iter) {
71 engine_info = iter->data;
73 if (NULL == engine_info) {
74 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
78 if (0 != strcmp(engine_id, engine_info->uuid)) {
79 iter = g_slist_next(iter);
83 GSList *iter_lang = NULL;
85 if (g_slist_length(engine_info->languages) > 0) {
86 /* Get a first item */
87 iter_lang = g_slist_nth(engine_info->languages, 0);
90 while (NULL != iter_lang) {
91 /*Get handle data from list*/
92 engine_lang = iter_lang->data;
94 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", i, engine_lang);
96 if (0 == strcmp(language, engine_lang)) {
101 iter_lang = g_slist_next(iter_lang);
111 int __stt_config_mgr_select_lang(const char* engine_id, char** language)
113 if (NULL == engine_id || NULL == language) {
114 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
119 stt_engine_info_s *engine_info = NULL;
121 if (0 >= g_slist_length(g_engine_list)) {
122 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
126 /* Get a first item */
127 iter = g_slist_nth(g_engine_list, 0);
129 while (NULL != iter) {
130 engine_info = iter->data;
132 if (NULL == engine_info) {
133 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
137 if (0 != strcmp(engine_id, engine_info->uuid)) {
138 iter = g_slist_next(iter);
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);
148 while (NULL != iter_lang) {
149 engine_lang = iter_lang->data;
150 if (NULL != engine_lang) {
151 /* Default language is STT_BASE_LANGUAGE */
152 if (0 == strcmp(STT_BASE_LANGUAGE, engine_lang)) {
153 *language = strdup(engine_lang);
154 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", (NULL == *language) ? "NULL" : *language);
159 iter_lang = g_slist_next(iter_lang);
162 /* Not support STT_BASE_LANGUAGE */
163 if (NULL != engine_lang) {
164 *language = strdup(engine_lang);
165 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", (NULL == *language) ? "NULL" : *language);
175 Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
177 SLOG(LOG_DEBUG, stt_tag(), "===== Config changed callback event");
180 struct inotify_event event;
181 memset(&event, '\0', sizeof(struct inotify_event));
183 length = read(g_fd_noti, &event, sizeof(struct inotify_event));
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;
191 if (IN_MODIFY == event.mask) {
193 char* setting = NULL;
200 stt_config_client_s* temp_client = NULL;
202 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
203 return ECORE_CALLBACK_PASS_ON;
206 if (NULL != engine || NULL != setting) {
208 if (NULL != engine) {
209 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
210 g_config_info->engine_id = strdup(engine);
213 if (NULL != setting) {
214 if (NULL != g_config_info->setting) free(g_config_info->setting);
215 g_config_info->setting = strdup(setting);
219 if (NULL != g_config_info->language) free(g_config_info->language);
220 g_config_info->language = strdup(lang);
223 if (-1 != silence) g_config_info->silence_detection = silence;
225 if (-1 != credential) g_config_info->credential = credential;
227 /* Call all callbacks of client*/
228 iter = g_slist_nth(g_config_client_list, 0);
230 while (NULL != iter) {
231 temp_client = iter->data;
233 if (NULL != temp_client) {
234 if (NULL != temp_client->engine_cb) {
235 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
236 g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
240 iter = g_slist_next(iter);
244 if (-1 != auto_lang) {
245 g_config_info->auto_lang = auto_lang;
248 /* Only language changed */
249 if (NULL == engine && NULL != lang) {
250 char* before_lang = NULL;
251 before_lang = strdup(g_config_info->language);
254 if (NULL != g_config_info->language) free(g_config_info->language);
255 g_config_info->language = strdup(lang);
258 /* Call all callbacks of client*/
259 iter = g_slist_nth(g_config_client_list, 0);
261 while (NULL != iter) {
262 temp_client = iter->data;
264 if (NULL != temp_client) {
265 if (NULL != temp_client->lang_cb) {
266 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
270 iter = g_slist_next(iter);
273 if (NULL != before_lang) {
279 /* silence detection changed */
280 g_config_info->silence_detection = silence;
282 /* Call all callbacks of client*/
283 iter = g_slist_nth(g_config_client_list, 0);
285 while (NULL != iter) {
286 temp_client = iter->data;
288 if (NULL != temp_client) {
289 if (NULL != temp_client->bool_cb) {
290 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
294 iter = g_slist_next(iter);
298 if (NULL != engine) free(engine);
299 if (NULL != setting) free(setting);
300 if (NULL != lang) free(lang);
302 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
305 SLOG(LOG_DEBUG, stt_tag(), "=====");
306 SLOG(LOG_DEBUG, stt_tag(), " ");
308 return ECORE_CALLBACK_PASS_ON;
311 int __stt_config_mgr_register_config_event()
313 /* get file notification handler */
319 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
324 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
327 g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
328 if (NULL == g_fd_handler_noti) {
329 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
336 int __stt_config_mgr_unregister_config_event()
338 /* delete inotify variable */
339 ecore_main_fd_handler_del(g_fd_handler_noti);
340 inotify_rm_watch(g_fd_noti, g_wd_noti);
346 int __stt_config_set_auto_language()
349 char candidate_lang[6] = {'\0', };
351 value = vconf_get_str(VCONFKEY_LANGSET);
353 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
357 strncpy(candidate_lang, value, 5);
360 /* Check current config info */
361 if (NULL == g_config_info) {
362 SLOG(LOG_ERROR, stt_tag(), "Current config info is NULL");
363 return STT_CONFIG_ERROR_OPERATION_FAILED;
366 /* Check current language */
367 if (NULL == g_config_info->language) {
368 SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
369 return STT_CONFIG_ERROR_OPERATION_FAILED;
372 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
373 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
376 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
379 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
380 char* before_lang = NULL;
381 if (0 != stt_parser_set_language(candidate_lang)) {
382 SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
386 before_lang = strdup(g_config_info->language);
388 free(g_config_info->language);
389 g_config_info->language = strdup(candidate_lang);
391 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
393 /* Call all callbacks of client*/
395 stt_config_client_s* temp_client = NULL;
397 iter = g_slist_nth(g_config_client_list, 0);
399 while (NULL != iter) {
400 temp_client = iter->data;
402 if (NULL != temp_client) {
403 if (NULL != temp_client->lang_cb) {
404 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
408 iter = g_slist_next(iter);
411 if (NULL != before_lang) {
415 /* Candidate language is not valid */
416 char* tmp_language = NULL;
417 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
418 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
422 if (NULL == tmp_language) {
423 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
427 if (0 != stt_parser_set_language(tmp_language)) {
429 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
433 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
435 /* Call all callbacks of client*/
437 stt_config_client_s* temp_client = NULL;
439 iter = g_slist_nth(g_config_client_list, 0);
441 while (NULL != iter) {
442 temp_client = iter->data;
444 if (NULL != temp_client) {
445 if (NULL != temp_client->lang_cb) {
446 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
450 iter = g_slist_next(iter);
453 free(g_config_info->language);
454 g_config_info->language = strdup(tmp_language);
463 void __stt_config_language_changed_cb(keynode_t *key, void *data)
465 if (true == g_config_info->auto_lang) {
466 /* Get voice input vconf key */
467 __stt_config_set_auto_language();
473 void __stt_config_release_client(int uid)
476 stt_config_client_s* temp_client = NULL;
478 if (0 < g_slist_length(g_config_client_list)) {
480 iter = g_slist_nth(g_config_client_list, 0);
482 while (NULL != iter) {
483 temp_client = iter->data;
485 if (NULL != temp_client) {
486 if (uid == temp_client->uid) {
487 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
494 iter = g_slist_next(iter);
498 if (0 < g_slist_length(g_config_client_list)) {
499 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
504 void __stt_config_release_engine()
507 stt_engine_info_s *engine_info = NULL;
509 if (0 < g_slist_length(g_engine_list)) {
511 /* Get a first item */
512 iter = g_slist_nth(g_engine_list, 0);
514 while (NULL != iter) {
515 engine_info = iter->data;
517 if (NULL != engine_info) {
518 g_engine_list = g_slist_remove(g_engine_list, engine_info);
520 stt_parser_free_engine_info(engine_info);
523 iter = g_slist_nth(g_engine_list, 0);
529 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
531 if (NULL == engine_id) {
532 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
533 return STT_CONFIG_ERROR_INVALID_PARAMETER;
537 stt_engine_info_s *engine_info = NULL;
539 if (0 >= g_slist_length(g_engine_list)) {
540 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
541 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
544 /* Get a first item */
545 iter = g_slist_nth(g_engine_list, 0);
547 while (NULL != iter) {
548 engine_info = iter->data;
550 if (NULL == engine_info) {
551 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
552 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
555 if (0 == strcmp(engine_id, engine_info->uuid)) {
556 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
557 return STT_CONFIG_ERROR_NONE;
560 iter = g_slist_next(iter);
563 /* Change default engine */
564 iter = g_slist_nth(g_engine_list, 0);
566 SLOG(LOG_ERROR, stt_tag(), "Operation failed - false engine");
567 return STT_CONFIG_ERROR_OPERATION_FAILED;
570 engine_info = iter->data;
571 if (NULL == engine_info) {
572 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
573 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
576 if (NULL != g_config_info->engine_id) {
577 free(g_config_info->engine_id);
578 g_config_info->engine_id = NULL;
580 if (NULL != g_config_info->setting) {
581 free(g_config_info->setting);
582 g_config_info->setting = NULL;
585 if (NULL != engine_info->uuid) {
586 g_config_info->engine_id = strdup(engine_info->uuid);
589 if (NULL != engine_info->setting) {
590 g_config_info->setting = strdup(engine_info->setting);
594 GSList *iter_lang = NULL;
596 bool is_valid_lang = false;
598 if (0 >= g_slist_length(engine_info->languages)) {
599 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
600 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
603 /* Get a first item */
604 iter_lang = g_slist_nth(engine_info->languages, 0);
606 while (NULL != iter_lang) {
607 /*Get handle data from list*/
608 lang = iter_lang->data;
610 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
612 if (0 == strcmp(lang, g_config_info->language)) {
613 /* language is valid */
614 is_valid_lang = true;
620 iter_lang = g_slist_next(iter_lang);
623 if (false == is_valid_lang) {
624 iter_lang = g_slist_nth(engine_info->languages, 0);
625 if (NULL != iter_lang) {
626 lang = iter_lang->data;
628 if (NULL != g_config_info->language)
629 free(g_config_info->language);
630 g_config_info->language = strdup(lang);
636 if (false == engine_info->support_silence_detection) {
637 if (true == g_config_info->silence_detection)
638 g_config_info->silence_detection = false;
641 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
642 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
643 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
644 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
645 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
646 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
648 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
649 g_config_info->silence_detection, g_config_info->credential)) {
650 SLOG(LOG_ERROR, stt_tag(), "Fail to save config");
651 return STT_CONFIG_ERROR_OPERATION_FAILED;
654 return STT_CONFIG_ERROR_NONE;
657 static void __get_engine_list(const char* directory)
662 struct dirent *dirp = NULL;
664 if (NULL == directory) {
665 SLOG(LOG_ERROR, stt_tag(), "[Directory ERROR] Directory is NULL");
669 dp = opendir(directory);
672 ret = readdir_r(dp, &entry, &dirp);
674 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
679 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
682 stt_engine_info_s* info;
683 char* filepath = NULL;
686 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
687 filepath = (char*)calloc(filesize, sizeof(char));
689 if (NULL != filepath) {
690 snprintf(filepath, filesize, "%s/%s", directory, dirp->d_name);
692 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
696 if (0 == stt_parser_get_engine_info(filepath, &info)) {
697 g_engine_list = g_slist_append(g_engine_list, info);
700 if (NULL != filepath) {
705 } while (NULL != dirp);
709 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open directory");
715 int stt_config_mgr_initialize(int uid)
719 stt_config_client_s* temp_client = NULL;
721 if (0 < g_slist_length(g_config_client_list)) {
723 iter = g_slist_nth(g_config_client_list, 0);
725 while (NULL != iter) {
726 get_uid = iter->data;
728 if (uid == *get_uid) {
729 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
733 iter = g_slist_next(iter);
736 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
737 if (NULL == temp_client) {
738 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
739 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
741 temp_client->uid = uid;
742 temp_client->bool_cb = NULL;
743 temp_client->engine_cb = NULL;
744 temp_client->lang_cb = NULL;
745 temp_client->user_data = NULL;
748 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
750 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
751 return STT_CONFIG_ERROR_NONE;
754 /* Make directories */
755 if (0 != access(STT_CONFIG_BASE, F_OK)) {
756 if (0 != mkdir(STT_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
757 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_CONFIG_BASE);
758 __stt_config_release_client(uid);
759 return STT_CONFIG_ERROR_OPERATION_FAILED;
761 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_CONFIG_BASE);
765 if (0 != access(STT_HOME, F_OK)) {
766 if (0 != mkdir(STT_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
767 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_HOME);
768 __stt_config_release_client(uid);
769 return STT_CONFIG_ERROR_OPERATION_FAILED;
771 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_HOME);
775 if (0 != access(STT_DOWNLOAD_BASE, F_OK)) {
776 if (0 != mkdir(STT_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
777 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_BASE);
778 __stt_config_release_client(uid);
779 return STT_CONFIG_ERROR_OPERATION_FAILED;
781 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_BASE);
785 if (0 != access(STT_DOWNLOAD_ENGINE_INFO, F_OK)) {
786 if (0 != mkdir(STT_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
787 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
788 __stt_config_release_client(uid);
789 return STT_CONFIG_ERROR_OPERATION_FAILED;
791 SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
796 /* Get file name from default engine directory */
797 g_engine_list = NULL;
799 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
801 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get default engine list");
802 __get_engine_list(STT_DEFAULT_ENGINE_INFO);
803 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get download engine list");
804 __get_engine_list(STT_DOWNLOAD_ENGINE_INFO);
806 __stt_config_mgr_print_engine_info();
808 if (0 != stt_parser_load_config(&g_config_info)) {
809 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
810 __stt_config_release_client(uid);
811 __stt_config_release_engine();
812 return STT_CONFIG_ERROR_OPERATION_FAILED;
815 /* Check whether engine id is valid */
816 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
817 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
818 __stt_config_release_client(uid);
819 __stt_config_release_engine();
820 stt_parser_unload_config(g_config_info);
821 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
824 if (true == g_config_info->auto_lang) {
825 /* Check language with display language */
826 __stt_config_set_auto_language();
828 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
829 /* Default language is not valid */
831 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
832 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
833 __stt_config_release_client(uid);
834 __stt_config_release_engine();
835 stt_parser_unload_config(g_config_info);
836 return STT_CONFIG_ERROR_OPERATION_FAILED;
839 if (NULL != tmp_language) {
840 if (NULL != g_config_info->language) {
841 free(g_config_info->language);
842 g_config_info->language = strdup(tmp_language);
850 /* print stt-service config */
851 SLOG(LOG_DEBUG, stt_tag(), "== STT service config ==");
852 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
853 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
854 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
855 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
856 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
857 SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
858 SLOG(LOG_DEBUG, stt_tag(), "===================");
860 if (0 != __stt_config_mgr_register_config_event()) {
861 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
862 __stt_config_release_client(uid);
863 __stt_config_release_engine();
864 stt_parser_unload_config(g_config_info);
865 return STT_CONFIG_ERROR_OPERATION_FAILED;
868 /* Register to detect display language change */
869 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
871 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
872 if (NULL == temp_client) {
873 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
874 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
876 temp_client->uid = uid;
877 temp_client->bool_cb = NULL;
878 temp_client->engine_cb = NULL;
879 temp_client->lang_cb = NULL;
880 temp_client->user_data = NULL;
883 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
885 return STT_CONFIG_ERROR_NONE;
888 int stt_config_mgr_finalize(int uid)
891 stt_config_client_s* temp_client = NULL;
893 if (0 < g_slist_length(g_config_client_list)) {
895 iter = g_slist_nth(g_config_client_list, 0);
897 while (NULL != iter) {
898 temp_client = iter->data;
900 if (NULL != temp_client) {
901 if (uid == temp_client->uid) {
902 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
909 iter = g_slist_next(iter);
913 if (0 < g_slist_length(g_config_client_list)) {
914 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
915 return STT_CONFIG_ERROR_NONE;
918 stt_engine_info_s *engine_info = NULL;
920 if (0 < g_slist_length(g_engine_list)) {
922 /* Get a first item */
923 iter = g_slist_nth(g_engine_list, 0);
925 while (NULL != iter) {
926 engine_info = iter->data;
928 if (NULL != engine_info) {
929 g_engine_list = g_slist_remove(g_engine_list, engine_info);
931 stt_parser_free_engine_info(engine_info);
934 iter = g_slist_nth(g_engine_list, 0);
938 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
940 __stt_config_mgr_unregister_config_event();
942 if (NULL != g_config_info) {
943 stt_parser_unload_config(g_config_info);
944 g_config_info = NULL;
947 return STT_CONFIG_ERROR_NONE;
950 int stt_config_mgr_set_callback(int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data)
953 stt_config_client_s* temp_client = NULL;
955 /* Call all callbacks of client*/
956 iter = g_slist_nth(g_config_client_list, 0);
958 while (NULL != iter) {
959 temp_client = iter->data;
961 if (NULL != temp_client) {
962 if (uid == temp_client->uid) {
963 temp_client->engine_cb = engine_cb;
964 temp_client->lang_cb = lang_cb;
965 temp_client->bool_cb = bool_cb;
966 temp_client->user_data = user_data;
970 iter = g_slist_next(iter);
973 return STT_CONFIG_ERROR_NONE;
976 int stt_config_mgr_unset_callback(int uid)
979 stt_config_client_s* temp_client = NULL;
981 /* Call all callbacks of client*/
982 iter = g_slist_nth(g_config_client_list, 0);
984 while (NULL != iter) {
985 temp_client = iter->data;
987 if (NULL != temp_client) {
988 if (uid == temp_client->uid) {
989 temp_client->engine_cb = NULL;
990 temp_client->lang_cb = NULL;
991 temp_client->bool_cb = NULL;
992 temp_client->user_data = NULL;
996 iter = g_slist_next(iter);
999 return STT_CONFIG_ERROR_NONE;
1002 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
1004 if (0 >= g_slist_length(g_config_client_list)) {
1005 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1006 return STT_CONFIG_ERROR_INVALID_STATE;
1009 if (NULL == callback) {
1010 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1013 GSList *iter = NULL;
1014 stt_engine_info_s *engine_info = NULL;
1016 if (0 >= g_slist_length(g_engine_list)) {
1017 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
1018 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1021 /* Get a first item */
1022 iter = g_slist_nth(g_engine_list, 0);
1024 while (NULL != iter) {
1025 engine_info = iter->data;
1027 if (NULL == engine_info) {
1028 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
1029 return STT_CONFIG_ERROR_OPERATION_FAILED;
1032 if (false == callback(engine_info->uuid, engine_info->name,
1033 engine_info->setting, engine_info->support_silence_detection, user_data)) {
1037 iter = g_slist_next(iter);
1040 return STT_CONFIG_ERROR_NONE;
1043 int stt_config_mgr_get_engine(char** engine)
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;
1050 if (NULL == engine) {
1051 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1054 if (NULL != g_config_info->engine_id) {
1055 *engine = strdup(g_config_info->engine_id);
1057 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
1058 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1061 return STT_CONFIG_ERROR_NONE;
1064 int __stt_config_set_buxtonkey(const char* engine)
1067 struct buxton_client * bux_cli;
1068 struct buxton_layer * bux_layer;
1069 struct buxton_value * bux_val;
1071 int ret = buxton_open(&bux_cli, NULL, NULL);
1073 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
1074 return STT_CONFIG_ERROR_OPERATION_FAILED;
1076 bux_layer = buxton_create_layer("system");
1077 if (NULL == bux_layer) {
1078 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
1079 buxton_close(bux_cli);
1081 return STT_CONFIG_ERROR_OPERATION_FAILED;
1083 bux_val = buxton_value_create_string(engine);
1084 if (NULL == bux_val) {
1085 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1086 buxton_free_layer(bux_layer);
1087 buxton_close(bux_cli);
1090 return STT_CONFIG_ERROR_OPERATION_FAILED;
1092 SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1095 ret = buxton_set_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, bux_val);
1097 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to set value sync, ret(%d)", ret);
1098 buxton_value_free(bux_val);
1099 buxton_free_layer(bux_layer);
1100 buxton_close(bux_cli);
1105 return STT_CONFIG_ERROR_OPERATION_FAILED;
1107 SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %s", STT_ENGINE_DB_DEFAULT);
1109 buxton_value_free(bux_val);
1110 buxton_free_layer(bux_layer);
1111 buxton_close(bux_cli);
1117 return STT_CONFIG_ERROR_NONE;
1120 int stt_config_mgr_set_engine(const char* engine)
1122 if (0 >= g_slist_length(g_config_client_list)) {
1123 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1124 return STT_CONFIG_ERROR_INVALID_STATE;
1127 if (NULL == g_config_info) {
1128 return STT_CONFIG_ERROR_OPERATION_FAILED;
1131 if (NULL == engine || NULL == g_config_info->engine_id) {
1132 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1135 /* Check current engine id with new engine id */
1136 if (0 == strcmp(g_config_info->engine_id, engine)) {
1140 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1142 int ret = __stt_config_set_buxtonkey(engine);
1144 SLOG(LOG_ERROR, stt_tag(), "[ERROR] set buxtonkey Failed!!!");
1148 GSList *iter = NULL;
1149 stt_engine_info_s *engine_info = NULL;
1150 bool is_valid_engine = false;
1152 /* Get a first item */
1153 iter = g_slist_nth(g_engine_list, 0);
1155 while (NULL != iter) {
1156 engine_info = iter->data;
1158 if (NULL == engine_info) {
1159 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1160 iter = g_slist_next(iter);
1164 /* Check engine id is valid */
1165 if (0 != strcmp(engine, engine_info->uuid)) {
1166 iter = g_slist_next(iter);
1170 if (NULL != g_config_info->engine_id) {
1171 free(g_config_info->engine_id);
1172 g_config_info->engine_id = NULL;
1175 g_config_info->engine_id = strdup(engine);
1177 if (NULL != g_config_info->setting) {
1178 free(g_config_info->setting);
1179 g_config_info->setting = NULL;
1182 if (NULL != engine_info->setting) {
1183 g_config_info->setting = strdup(engine_info->setting);
1185 g_config_info->setting = NULL;
1188 /* Engine is valid*/
1189 GSList *iter_lang = NULL;
1191 bool is_valid_lang = false;
1193 /* Get a first item */
1194 iter_lang = g_slist_nth(engine_info->languages, 0);
1196 while (NULL != iter_lang) {
1197 /*Get handle data from list*/
1198 lang = iter_lang->data;
1200 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1201 if (NULL != lang && NULL != g_config_info->language) {
1202 if (0 == strcmp(lang, g_config_info->language)) {
1203 /* language is valid */
1204 is_valid_lang = true;
1206 free(g_config_info->language);
1207 g_config_info->language = strdup(lang);
1214 iter_lang = g_slist_next(iter_lang);
1217 if (false == is_valid_lang) {
1218 if (NULL != g_config_info->language) {
1219 free(g_config_info->language);
1220 g_config_info->language = NULL;
1222 iter_lang = g_slist_nth(engine_info->languages, 0);
1223 if (NULL == iter_lang) {
1224 SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
1228 lang = iter_lang->data;
1230 g_config_info->language = strdup(lang);
1235 if (false == engine_info->support_silence_detection) {
1236 if (true == g_config_info->silence_detection)
1237 g_config_info->silence_detection = false;
1240 if (false == engine_info->need_credential) {
1241 if (true == g_config_info->credential)
1242 g_config_info->credential = false;
1245 is_valid_engine = true;
1249 if (true == is_valid_engine) {
1250 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1251 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1252 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1253 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1254 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1255 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1257 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1258 g_config_info->silence_detection, g_config_info->credential)) {
1259 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1260 return STT_CONFIG_ERROR_OPERATION_FAILED;
1263 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1264 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1270 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1272 if (0 >= g_slist_length(g_engine_list)) {
1273 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1274 return STT_CONFIG_ERROR_INVALID_STATE;
1277 if (NULL == agreement) {
1278 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1279 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1282 GSList *iter = NULL;
1283 stt_engine_info_s *engine_info = NULL;
1284 char* current_engine = NULL;
1286 if (NULL == engine) {
1287 current_engine = strdup(g_config_info->engine_id);
1288 if (NULL == current_engine) {
1289 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1290 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1293 current_engine = strdup(engine);
1294 if (NULL == current_engine) {
1295 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1296 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1300 /* Get a first item */
1301 iter = g_slist_nth(g_engine_list, 0);
1303 while (NULL != iter) {
1304 engine_info = iter->data;
1306 if (NULL == engine_info) {
1307 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1308 if (NULL != current_engine) free(current_engine);
1309 return STT_CONFIG_ERROR_OPERATION_FAILED;
1312 if (0 != strcmp(current_engine, engine_info->uuid)) {
1313 iter = g_slist_next(iter);
1317 if (NULL != engine_info->agreement) {
1318 *agreement = strdup(engine_info->agreement);
1320 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1325 if (NULL != current_engine) free(current_engine);
1327 return STT_CONFIG_ERROR_NONE;
1330 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1332 if (0 >= g_slist_length(g_config_client_list)) {
1333 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1334 return STT_CONFIG_ERROR_INVALID_STATE;
1337 if (0 >= g_slist_length(g_engine_list)) {
1338 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1339 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1342 GSList *iter = NULL;
1343 stt_engine_info_s *engine_info = NULL;
1345 /* Get a first item */
1346 iter = g_slist_nth(g_engine_list, 0);
1348 while (NULL != iter) {
1349 engine_info = iter->data;
1351 if (NULL == engine_info) {
1352 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1353 return STT_CONFIG_ERROR_OPERATION_FAILED;
1356 if (0 != strcmp(engine_id, engine_info->uuid)) {
1357 iter = g_slist_next(iter);
1361 GSList *iter_lang = NULL;
1364 /* Get a first item */
1365 iter_lang = g_slist_nth(engine_info->languages, 0);
1367 while (NULL != iter_lang) {
1368 /*Get handle data from list*/
1369 lang = iter_lang->data;
1372 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1373 if (false == callback(engine_info->uuid, lang, user_data))
1378 iter_lang = g_slist_next(iter_lang);
1383 return STT_CONFIG_ERROR_NONE;
1386 int stt_config_mgr_get_default_language(char** language)
1388 if (0 >= g_slist_length(g_config_client_list)) {
1389 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1390 return STT_CONFIG_ERROR_INVALID_STATE;
1393 if (NULL == language) {
1394 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1397 if (NULL != g_config_info->language) {
1398 *language = strdup(g_config_info->language);
1400 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1401 return STT_CONFIG_ERROR_OPERATION_FAILED;
1404 return STT_CONFIG_ERROR_NONE;
1407 int stt_config_mgr_set_default_language(const char* language)
1409 if (0 >= g_slist_length(g_config_client_list)) {
1410 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1411 return STT_CONFIG_ERROR_INVALID_STATE;
1414 if (NULL == language) {
1415 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1418 /* Check language is valid */
1419 if (NULL != g_config_info->language) {
1420 if (0 != stt_parser_set_language(language)) {
1421 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1422 return STT_CONFIG_ERROR_OPERATION_FAILED;
1424 free(g_config_info->language);
1425 g_config_info->language = strdup(language);
1427 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1428 return STT_CONFIG_ERROR_OPERATION_FAILED;
1431 return STT_CONFIG_ERROR_NONE;
1434 int stt_config_mgr_get_auto_language(bool* value)
1436 if (0 >= g_slist_length(g_config_client_list)) {
1437 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1438 return STT_CONFIG_ERROR_INVALID_STATE;
1441 if (NULL == value) {
1442 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1445 *value = g_config_info->auto_lang;
1447 return STT_CONFIG_ERROR_NONE;
1450 int stt_config_mgr_set_auto_language(bool value)
1452 if (0 >= g_slist_length(g_config_client_list)) {
1453 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1454 return STT_CONFIG_ERROR_INVALID_STATE;
1457 if (g_config_info->auto_lang != value) {
1458 /* Check language is valid */
1459 if (0 != stt_parser_set_auto_lang(value)) {
1460 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1461 return STT_CONFIG_ERROR_OPERATION_FAILED;
1463 g_config_info->auto_lang = value;
1465 if (true == g_config_info->auto_lang) {
1466 __stt_config_set_auto_language();
1470 return STT_CONFIG_ERROR_NONE;
1473 int stt_config_mgr_get_silence_detection(bool* value)
1475 if (0 >= g_slist_length(g_config_client_list)) {
1476 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1477 return STT_CONFIG_ERROR_INVALID_STATE;
1481 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1483 *value = g_config_info->silence_detection;
1485 return STT_CONFIG_ERROR_NONE;
1488 int stt_config_mgr_set_silence_detection(bool value)
1490 if (0 >= g_slist_length(g_config_client_list)) {
1491 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1492 return STT_CONFIG_ERROR_INVALID_STATE;
1495 if (0 != stt_parser_set_silence_detection(value)) {
1496 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1497 return STT_CONFIG_ERROR_OPERATION_FAILED;
1500 g_config_info->silence_detection = value;
1502 return STT_CONFIG_ERROR_NONE;
1505 bool stt_config_check_default_engine_is_valid(const char* engine)
1507 if (0 >= g_slist_length(g_config_client_list)) {
1508 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1512 if (NULL == engine) {
1516 if (0 >= g_slist_length(g_engine_list))
1519 GSList *iter = NULL;
1520 stt_engine_info_s *engine_info = NULL;
1522 /* Get a first item */
1523 iter = g_slist_nth(g_engine_list, 0);
1525 while (NULL != iter) {
1526 engine_info = iter->data;
1528 if (NULL != engine_info) {
1529 if (0 == strcmp(engine, engine_info->uuid)) {
1533 iter = g_slist_next(iter);
1539 bool stt_config_check_default_language_is_valid(const char* language)
1541 if (0 >= g_slist_length(g_config_client_list)) {
1542 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1546 if (NULL == language) {
1550 if (NULL == g_config_info->engine_id) {
1551 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1555 if (0 >= g_slist_length(g_engine_list))
1558 GSList *iter = NULL;
1559 stt_engine_info_s *engine_info = NULL;
1561 /* Get a first item */
1562 iter = g_slist_nth(g_engine_list, 0);
1564 while (NULL != iter) {
1565 engine_info = iter->data;
1567 if (NULL == engine_info) {
1568 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1569 iter = g_slist_next(iter);
1573 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1574 iter = g_slist_next(iter);
1578 GSList *iter_lang = NULL;
1581 /* Get a first item */
1582 iter_lang = g_slist_nth(engine_info->languages, 0);
1584 while (NULL != iter_lang) {
1585 lang = iter_lang->data;
1587 if (0 == strcmp(language, lang))
1591 iter_lang = g_slist_next(iter_lang);
1599 int __stt_config_mgr_print_engine_info()
1601 GSList *iter = NULL;
1602 stt_engine_info_s *engine_info = NULL;
1604 if (0 >= g_slist_length(g_engine_list)) {
1605 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1606 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1607 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1611 /* Get a first item */
1612 iter = g_slist_nth(g_engine_list, 0);
1614 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1617 while (NULL != iter) {
1618 engine_info = iter->data;
1620 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1621 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1622 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1623 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1624 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1626 SLOG(LOG_DEBUG, stt_tag(), " languages");
1627 GSList *iter_lang = NULL;
1629 if (g_slist_length(engine_info->languages) > 0) {
1630 /* Get a first item */
1631 iter_lang = g_slist_nth(engine_info->languages, 0);
1634 while (NULL != iter_lang) {
1635 /*Get handle data from list*/
1636 lang = iter_lang->data;
1638 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1641 iter_lang = g_slist_next(iter_lang);
1645 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1647 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1648 engine_info->support_silence_detection ? "true" : "false");
1649 iter = g_slist_next(iter);
1652 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1660 * time info functions
1662 static GSList* g_time_list = NULL;
1664 int stt_config_mgr_reset_time_info()
1666 /* Remove time info */
1667 GSList *iter = NULL;
1668 stt_result_time_info_s *data = NULL;
1670 /* Remove time info */
1671 iter = g_slist_nth(g_time_list, 0);
1672 while (NULL != iter) {
1675 g_time_list = g_slist_remove(g_time_list, data);
1677 if (NULL != data->text) {
1686 iter = g_slist_nth(g_time_list, 0);
1692 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1695 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1699 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1701 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1702 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1704 info->index = index;
1705 info->event = event;
1707 info->text = strdup(text);
1709 info->start_time = start_time;
1710 info->end_time = end_time;
1712 SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: index(%d), text(%s), start time(%d), end_time(%d)", info->index, (NULL == info->text) ? "NULL" : info->text, info->start_time, info->end_time);
1714 /* Add item to global list */
1715 g_time_list = g_slist_append(g_time_list, info);
1717 SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: g_time_list length(%d)", g_slist_length(g_time_list));
1722 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1724 if (NULL == callback) {
1725 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1726 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1729 GSList* temp_time = NULL;
1731 ret = stt_parser_get_time_info(&temp_time);
1733 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1734 return STT_CONFIG_ERROR_OPERATION_FAILED;
1737 GSList *iter = NULL;
1738 stt_result_time_info_s *data = NULL;
1740 /* Get a first item */
1741 iter = g_slist_nth(temp_time, 0);
1742 while (NULL != iter) {
1745 if (false == callback(data->index, data->event, data->text,
1746 data->start_time, data->end_time, user_data)) {
1751 iter = g_slist_next(iter);
1754 /* Remove time info */
1755 iter = g_slist_nth(temp_time, 0);
1756 while (NULL != iter) {
1760 temp_time = g_slist_remove(temp_time, data);
1762 if (NULL != data->text) {
1771 iter = g_slist_nth(temp_time, 0);
1774 return STT_CONFIG_ERROR_NONE;
1777 int stt_config_mgr_save_time_info_file()
1779 if (0 == g_slist_length(g_time_list)) {
1780 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1781 return STT_CONFIG_ERROR_OPERATION_FAILED;
1785 ret = stt_parser_set_time_info(g_time_list);
1787 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1788 return STT_CONFIG_ERROR_OPERATION_FAILED;
1791 return STT_CONFIG_ERROR_NONE;
1794 int stt_config_mgr_remove_time_info_file()
1796 stt_parser_clear_time_info();
1798 return STT_CONFIG_ERROR_NONE;