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.
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", *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", *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;
198 stt_config_client_s* temp_client = NULL;
200 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence))
201 return ECORE_CALLBACK_PASS_ON;
204 if (NULL != engine || NULL != setting) {
206 if (NULL != engine) {
207 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
208 g_config_info->engine_id = strdup(engine);
211 if (NULL != setting) {
212 if (NULL != g_config_info->setting) free(g_config_info->setting);
213 g_config_info->setting = strdup(setting);
217 if (NULL != g_config_info->language) free(g_config_info->language);
218 g_config_info->language = strdup(lang);
221 if (-1 != silence) g_config_info->silence_detection = silence;
223 /* Call all callbacks of client*/
224 iter = g_slist_nth(g_config_client_list, 0);
226 while (NULL != iter) {
227 temp_client = iter->data;
229 if (NULL != temp_client) {
230 if (NULL != temp_client->engine_cb) {
231 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
232 g_config_info->silence_detection, temp_client->user_data);
236 iter = g_slist_next(iter);
240 if (-1 != auto_lang) {
241 g_config_info->auto_lang = auto_lang;
244 /* Only language changed */
245 if (NULL == engine && NULL != lang) {
246 char* before_lang = NULL;
247 before_lang = strdup(g_config_info->language);
250 if (NULL != g_config_info->language) free(g_config_info->language);
251 g_config_info->language = strdup(lang);
254 /* Call all callbacks of client*/
255 iter = g_slist_nth(g_config_client_list, 0);
257 while (NULL != iter) {
258 temp_client = iter->data;
260 if (NULL != temp_client) {
261 if (NULL != temp_client->lang_cb) {
262 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
266 iter = g_slist_next(iter);
269 if (NULL != before_lang) {
275 /* silence detection changed */
276 g_config_info->silence_detection = silence;
278 /* Call all callbacks of client*/
279 iter = g_slist_nth(g_config_client_list, 0);
281 while (NULL != iter) {
282 temp_client = iter->data;
284 if (NULL != temp_client) {
285 if (NULL != temp_client->bool_cb) {
286 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
290 iter = g_slist_next(iter);
294 if (NULL != engine) free(engine);
295 if (NULL != setting) free(setting);
296 if (NULL != lang) free(lang);
298 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
301 SLOG(LOG_DEBUG, stt_tag(), "=====");
302 SLOG(LOG_DEBUG, stt_tag(), " ");
304 return ECORE_CALLBACK_PASS_ON;
307 int __stt_config_mgr_register_config_event()
309 /* get file notification handler */
315 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
320 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
323 g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
324 if (NULL == g_fd_handler_noti) {
325 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
332 int __stt_config_mgr_unregister_config_event()
334 /* delete inotify variable */
335 ecore_main_fd_handler_del(g_fd_handler_noti);
336 inotify_rm_watch(g_fd_noti, g_wd_noti);
342 int __stt_config_set_auto_language()
345 char candidate_lang[6] = {'\0', };
347 value = vconf_get_str(VCONFKEY_LANGSET);
349 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
353 strncpy(candidate_lang, value, 5);
356 /* Check current language */
357 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
358 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
361 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
364 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
365 /* stt default language change */
366 if (NULL == g_config_info->language) {
367 SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
371 char* before_lang = NULL;
372 if (0 != stt_parser_set_language(candidate_lang)) {
373 SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
377 before_lang = strdup(g_config_info->language);
379 free(g_config_info->language);
380 g_config_info->language = strdup(candidate_lang);
382 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
384 /* Call all callbacks of client*/
386 stt_config_client_s* temp_client = NULL;
388 iter = g_slist_nth(g_config_client_list, 0);
390 while (NULL != iter) {
391 temp_client = iter->data;
393 if (NULL != temp_client) {
394 if (NULL != temp_client->lang_cb) {
395 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
399 iter = g_slist_next(iter);
402 if (NULL != before_lang) {
406 /* Candidate language is not valid */
407 char* tmp_language = NULL;
408 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
409 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
413 if (NULL == tmp_language) {
414 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
418 if (0 != stt_parser_set_language(tmp_language)) {
420 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
424 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
426 /* Call all callbacks of client*/
428 stt_config_client_s* temp_client = NULL;
430 iter = g_slist_nth(g_config_client_list, 0);
432 while (NULL != iter) {
433 temp_client = iter->data;
435 if (NULL != temp_client) {
436 if (NULL != temp_client->lang_cb) {
437 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
441 iter = g_slist_next(iter);
444 if (NULL != g_config_info->language) {
445 free(g_config_info->language);
446 g_config_info->language = strdup(tmp_language);
455 void __stt_config_language_changed_cb(keynode_t *key, void *data)
457 if (true == g_config_info->auto_lang) {
458 /* Get voice input vconf key */
459 __stt_config_set_auto_language();
465 void __stt_config_release_client(int uid)
468 stt_config_client_s* temp_client = NULL;
470 if (0 < g_slist_length(g_config_client_list)) {
472 iter = g_slist_nth(g_config_client_list, 0);
474 while (NULL != iter) {
475 temp_client = iter->data;
477 if (NULL != temp_client) {
478 if (uid == temp_client->uid) {
479 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
486 iter = g_slist_next(iter);
490 if (0 < g_slist_length(g_config_client_list)) {
491 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
496 void __stt_config_release_engine()
499 stt_engine_info_s *engine_info = NULL;
501 if (0 < g_slist_length(g_engine_list)) {
503 /* Get a first item */
504 iter = g_slist_nth(g_engine_list, 0);
506 while (NULL != iter) {
507 engine_info = iter->data;
509 if (NULL != engine_info) {
510 g_engine_list = g_slist_remove(g_engine_list, engine_info);
512 stt_parser_free_engine_info(engine_info);
515 iter = g_slist_nth(g_engine_list, 0);
521 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
523 if (NULL == engine_id) {
524 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
525 return STT_CONFIG_ERROR_INVALID_PARAMETER;
529 stt_engine_info_s *engine_info = NULL;
531 if (0 >= g_slist_length(g_engine_list)) {
532 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
533 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
536 /* Get a first item */
537 iter = g_slist_nth(g_engine_list, 0);
539 while (NULL != iter) {
540 engine_info = iter->data;
542 if (NULL == engine_info) {
543 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
544 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
547 if (0 == strcmp(engine_id, engine_info->uuid)) {
548 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
549 return STT_CONFIG_ERROR_NONE;
552 iter = g_slist_next(iter);
555 /* Change default engine */
556 iter = g_slist_nth(g_engine_list, 0);
557 engine_info = iter->data;
558 if (NULL == engine_info) {
559 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
560 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
563 if (NULL != g_config_info->engine_id) {
564 free(g_config_info->engine_id);
565 g_config_info->engine_id = NULL;
567 if (NULL != g_config_info->setting) {
568 free(g_config_info->setting);
569 g_config_info->setting = NULL;
572 if (NULL != engine_info->uuid) {
573 g_config_info->engine_id = strdup(engine_info->uuid);
576 if (NULL != engine_info->setting) {
577 g_config_info->setting = strdup(engine_info->setting);
581 GSList *iter_lang = NULL;
583 bool is_valid_lang = false;
585 if (0 >= g_slist_length(engine_info->languages)) {
586 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
587 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
590 /* Get a first item */
591 iter_lang = g_slist_nth(engine_info->languages, 0);
593 while (NULL != iter_lang) {
594 /*Get handle data from list*/
595 lang = iter_lang->data;
597 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
599 if (0 == strcmp(lang, g_config_info->language)) {
600 /* language is valid */
601 is_valid_lang = true;
607 iter_lang = g_slist_next(iter_lang);
610 if (false == is_valid_lang) {
611 iter_lang = g_slist_nth(engine_info->languages, 0);
612 if (NULL != iter_lang) {
613 lang = iter_lang->data;
615 if (NULL != g_config_info->language)
616 free(g_config_info->language);
617 g_config_info->language = strdup(lang);
623 if (false == engine_info->support_silence_detection) {
624 if (true == g_config_info->silence_detection)
625 g_config_info->silence_detection = false;
628 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
629 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
630 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
631 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
632 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
634 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
635 g_config_info->silence_detection)) {
636 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
637 return STT_CONFIG_ERROR_OPERATION_FAILED;
640 return STT_CONFIG_ERROR_NONE;
643 int stt_config_mgr_initialize(int uid)
647 stt_config_client_s* temp_client = NULL;
649 if (0 < g_slist_length(g_config_client_list)) {
651 iter = g_slist_nth(g_config_client_list, 0);
653 while (NULL != iter) {
654 get_uid = iter->data;
656 if (uid == *get_uid) {
657 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
661 iter = g_slist_next(iter);
664 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
665 if (NULL == temp_client) {
666 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
667 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
669 temp_client->uid = uid;
670 temp_client->bool_cb = NULL;
671 temp_client->engine_cb = NULL;
672 temp_client->lang_cb = NULL;
673 temp_client->user_data = NULL;
676 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
678 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
679 return STT_CONFIG_ERROR_NONE;
682 /* Get file name from default engine directory */
686 struct dirent *dirp = NULL;
688 g_engine_list = NULL;
690 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
691 dp = opendir(STT_DEFAULT_ENGINE_INFO);
694 ret = readdir_r(dp, &entry, &dirp);
696 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
701 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
704 stt_engine_info_s* info;
708 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
709 filepath = (char*)calloc(filesize, sizeof(char));
711 if (NULL != filepath) {
712 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
714 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
718 if (0 == stt_parser_get_engine_info(filepath, &info)) {
719 g_engine_list = g_slist_append(g_engine_list, info);
722 if (NULL != filepath)
725 } while (NULL != dirp);
729 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
732 __stt_config_mgr_print_engine_info();
734 if (0 != stt_parser_load_config(&g_config_info)) {
735 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
736 __stt_config_release_client(uid);
737 __stt_config_release_engine();
738 return STT_CONFIG_ERROR_OPERATION_FAILED;
741 /* Check whether engine id is valid */
742 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
743 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
744 __stt_config_release_client(uid);
745 __stt_config_release_engine();
746 stt_parser_unload_config(g_config_info);
747 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
750 if (true == g_config_info->auto_lang) {
751 /* Check language with display language */
752 __stt_config_set_auto_language();
754 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
755 /* Default language is not valid */
757 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
758 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
759 __stt_config_release_client(uid);
760 __stt_config_release_engine();
761 stt_parser_unload_config(g_config_info);
762 return STT_CONFIG_ERROR_OPERATION_FAILED;
765 if (NULL != tmp_language) {
766 if (NULL != g_config_info->language) {
767 free(g_config_info->language);
768 g_config_info->language = strdup(tmp_language);
776 /* print daemon config */
777 SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
778 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
779 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
780 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
781 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
782 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
783 SLOG(LOG_DEBUG, stt_tag(), "===================");
785 if (0 != __stt_config_mgr_register_config_event()) {
786 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
787 __stt_config_release_client(uid);
788 __stt_config_release_engine();
789 stt_parser_unload_config(g_config_info);
790 return STT_CONFIG_ERROR_OPERATION_FAILED;
793 /* Register to detect display language change */
794 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
796 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
797 if (NULL == temp_client) {
798 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
799 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
801 temp_client->uid = uid;
802 temp_client->bool_cb = NULL;
803 temp_client->engine_cb = NULL;
804 temp_client->lang_cb = NULL;
805 temp_client->user_data = NULL;
808 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
810 return STT_CONFIG_ERROR_NONE;
813 int stt_config_mgr_finalize(int uid)
816 stt_config_client_s* temp_client = NULL;
818 if (0 < g_slist_length(g_config_client_list)) {
820 iter = g_slist_nth(g_config_client_list, 0);
822 while (NULL != iter) {
823 temp_client = iter->data;
825 if (NULL != temp_client) {
826 if (uid == temp_client->uid) {
827 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
834 iter = g_slist_next(iter);
838 if (0 < g_slist_length(g_config_client_list)) {
839 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
840 return STT_CONFIG_ERROR_NONE;
843 stt_engine_info_s *engine_info = NULL;
845 if (0 < g_slist_length(g_engine_list)) {
847 /* Get a first item */
848 iter = g_slist_nth(g_engine_list, 0);
850 while (NULL != iter) {
851 engine_info = iter->data;
853 if (NULL != engine_info) {
854 g_engine_list = g_slist_remove(g_engine_list, engine_info);
856 stt_parser_free_engine_info(engine_info);
859 iter = g_slist_nth(g_engine_list, 0);
863 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
865 __stt_config_mgr_unregister_config_event();
867 if (NULL != g_config_info) {
868 stt_parser_unload_config(g_config_info);
869 g_config_info = NULL;
872 return STT_CONFIG_ERROR_NONE;
875 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)
878 stt_config_client_s* temp_client = NULL;
880 /* Call all callbacks of client*/
881 iter = g_slist_nth(g_config_client_list, 0);
883 while (NULL != iter) {
884 temp_client = iter->data;
886 if (NULL != temp_client) {
887 if (uid == temp_client->uid) {
888 temp_client->engine_cb = engine_cb;
889 temp_client->lang_cb = lang_cb;
890 temp_client->bool_cb = bool_cb;
891 temp_client->user_data = user_data;
895 iter = g_slist_next(iter);
898 return STT_CONFIG_ERROR_NONE;
901 int stt_config_mgr_unset_callback(int uid)
904 stt_config_client_s* temp_client = NULL;
906 /* Call all callbacks of client*/
907 iter = g_slist_nth(g_config_client_list, 0);
909 while (NULL != iter) {
910 temp_client = iter->data;
912 if (NULL != temp_client) {
913 if (uid == temp_client->uid) {
914 temp_client->engine_cb = NULL;
915 temp_client->lang_cb = NULL;
916 temp_client->bool_cb = NULL;
917 temp_client->user_data = NULL;
921 iter = g_slist_next(iter);
924 return STT_CONFIG_ERROR_NONE;
927 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
929 if (0 >= g_slist_length(g_config_client_list)) {
930 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
931 return STT_CONFIG_ERROR_INVALID_STATE;
934 if (NULL == callback) {
935 return STT_CONFIG_ERROR_INVALID_PARAMETER;
939 stt_engine_info_s *engine_info = NULL;
941 if (0 >= g_slist_length(g_engine_list)) {
942 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
943 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
946 /* Get a first item */
947 iter = g_slist_nth(g_engine_list, 0);
949 while (NULL != iter) {
950 engine_info = iter->data;
952 if (NULL == engine_info) {
953 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
954 return STT_CONFIG_ERROR_OPERATION_FAILED;
957 if (false == callback(engine_info->uuid, engine_info->name,
958 engine_info->setting, engine_info->support_silence_detection, user_data)) {
962 iter = g_slist_next(iter);
965 return STT_CONFIG_ERROR_NONE;
968 int stt_config_mgr_get_engine(char** engine)
970 if (0 >= g_slist_length(g_config_client_list)) {
971 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
972 return STT_CONFIG_ERROR_INVALID_STATE;
975 if (NULL == engine) {
976 return STT_CONFIG_ERROR_INVALID_PARAMETER;
979 if (NULL != g_config_info->engine_id) {
980 *engine = strdup(g_config_info->engine_id);
982 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
983 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
986 return STT_CONFIG_ERROR_NONE;
989 int stt_config_mgr_set_engine(const char* engine)
991 if (0 >= g_slist_length(g_config_client_list)) {
992 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
993 return STT_CONFIG_ERROR_INVALID_STATE;
996 if (NULL == g_config_info) {
997 return STT_CONFIG_ERROR_OPERATION_FAILED;
1000 if (NULL == engine || NULL == g_config_info->engine_id) {
1001 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1004 /* Check current engine id with new engine id */
1005 if (0 == strcmp(g_config_info->engine_id, engine)) {
1009 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1011 GSList *iter = NULL;
1012 stt_engine_info_s *engine_info = NULL;
1013 bool is_valid_engine = false;
1015 /* Get a first item */
1016 iter = g_slist_nth(g_engine_list, 0);
1018 while (NULL != iter) {
1019 engine_info = iter->data;
1021 if (NULL == engine_info) {
1022 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1023 iter = g_slist_next(iter);
1027 /* Check engine id is valid */
1028 if (0 != strcmp(engine, engine_info->uuid)) {
1029 iter = g_slist_next(iter);
1033 if (NULL != g_config_info->engine_id)
1034 free(g_config_info->engine_id);
1036 g_config_info->engine_id = strdup(engine);
1038 if (NULL != g_config_info->setting) {
1039 free(g_config_info->setting);
1042 if (NULL != engine_info->setting) {
1043 g_config_info->setting = strdup(engine_info->setting);
1045 g_config_info->setting = NULL;
1048 /* Engine is valid*/
1049 GSList *iter_lang = NULL;
1051 bool is_valid_lang = false;
1053 /* Get a first item */
1054 iter_lang = g_slist_nth(engine_info->languages, 0);
1056 while (NULL != iter_lang) {
1057 /*Get handle data from list*/
1058 lang = iter_lang->data;
1060 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1062 if (0 == strcmp(lang, g_config_info->language)) {
1063 /* language is valid */
1064 is_valid_lang = true;
1066 if (NULL != g_config_info->language) {
1067 free(g_config_info->language);
1069 g_config_info->language = strdup(lang);
1076 iter_lang = g_slist_next(iter_lang);
1079 if (false == is_valid_lang) {
1080 if (NULL != g_config_info->language) {
1081 free(g_config_info->language);
1083 iter_lang = g_slist_nth(engine_info->languages, 0);
1084 lang = iter_lang->data;
1086 g_config_info->language = strdup(lang);
1091 if (false == engine_info->support_silence_detection) {
1092 if (true == g_config_info->silence_detection)
1093 g_config_info->silence_detection = false;
1096 is_valid_engine = true;
1100 if (true == is_valid_engine) {
1101 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1102 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1103 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1104 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1105 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1107 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1108 g_config_info->silence_detection)) {
1109 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1110 return STT_CONFIG_ERROR_OPERATION_FAILED;
1113 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1114 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1120 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1122 if (0 >= g_slist_length(g_engine_list)) {
1123 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1124 return STT_CONFIG_ERROR_INVALID_STATE;
1127 if (NULL == agreement) {
1128 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1129 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1132 GSList *iter = NULL;
1133 stt_engine_info_s *engine_info = NULL;
1134 char* current_engine = NULL;
1136 if (NULL == engine) {
1137 current_engine = strdup(g_config_info->engine_id);
1138 if (NULL == current_engine) {
1139 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1140 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1143 current_engine = strdup(engine);
1144 if (NULL == current_engine) {
1145 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1146 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1150 /* Get a first item */
1151 iter = g_slist_nth(g_engine_list, 0);
1153 while (NULL != iter) {
1154 engine_info = iter->data;
1156 if (NULL == engine_info) {
1157 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1158 if (NULL != current_engine) free(current_engine);
1159 return STT_CONFIG_ERROR_OPERATION_FAILED;
1162 if (0 != strcmp(current_engine, engine_info->uuid)) {
1163 iter = g_slist_next(iter);
1167 if (NULL != engine_info->agreement) {
1168 *agreement = strdup(engine_info->agreement);
1170 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1175 if (NULL != current_engine) free(current_engine);
1177 return STT_CONFIG_ERROR_NONE;
1180 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1182 if (0 >= g_slist_length(g_config_client_list)) {
1183 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1184 return STT_CONFIG_ERROR_INVALID_STATE;
1187 if (0 >= g_slist_length(g_engine_list)) {
1188 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1189 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1192 GSList *iter = NULL;
1193 stt_engine_info_s *engine_info = NULL;
1195 /* Get a first item */
1196 iter = g_slist_nth(g_engine_list, 0);
1198 while (NULL != iter) {
1199 engine_info = iter->data;
1201 if (NULL == engine_info) {
1202 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1203 return STT_CONFIG_ERROR_OPERATION_FAILED;
1206 if (0 != strcmp(engine_id, engine_info->uuid)) {
1207 iter = g_slist_next(iter);
1211 GSList *iter_lang = NULL;
1214 /* Get a first item */
1215 iter_lang = g_slist_nth(engine_info->languages, 0);
1217 while (NULL != iter_lang) {
1218 /*Get handle data from list*/
1219 lang = iter_lang->data;
1221 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1223 if (false == callback(engine_info->uuid, lang, user_data))
1228 iter_lang = g_slist_next(iter_lang);
1233 return STT_CONFIG_ERROR_NONE;
1236 int stt_config_mgr_get_default_language(char** language)
1238 if (0 >= g_slist_length(g_config_client_list)) {
1239 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1240 return STT_CONFIG_ERROR_INVALID_STATE;
1243 if (NULL == language) {
1244 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1247 if (NULL != g_config_info->language) {
1248 *language = strdup(g_config_info->language);
1250 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1251 return STT_CONFIG_ERROR_OPERATION_FAILED;
1254 return STT_CONFIG_ERROR_NONE;
1257 int stt_config_mgr_set_default_language(const char* language)
1259 if (0 >= g_slist_length(g_config_client_list)) {
1260 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1261 return STT_CONFIG_ERROR_INVALID_STATE;
1264 if (NULL == language) {
1265 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1268 /* Check language is valid */
1269 if (NULL != g_config_info->language) {
1270 if (0 != stt_parser_set_language(language)) {
1271 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1272 return STT_CONFIG_ERROR_OPERATION_FAILED;
1274 free(g_config_info->language);
1275 g_config_info->language = strdup(language);
1277 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1278 return STT_CONFIG_ERROR_OPERATION_FAILED;
1281 return STT_CONFIG_ERROR_NONE;
1284 int stt_config_mgr_get_auto_language(bool* value)
1286 if (0 >= g_slist_length(g_config_client_list)) {
1287 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1288 return STT_CONFIG_ERROR_INVALID_STATE;
1291 if (NULL == value) {
1292 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1295 *value = g_config_info->auto_lang;
1297 return STT_CONFIG_ERROR_NONE;
1300 int stt_config_mgr_set_auto_language(bool value)
1302 if (0 >= g_slist_length(g_config_client_list)) {
1303 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1304 return STT_CONFIG_ERROR_INVALID_STATE;
1307 if (g_config_info->auto_lang != value) {
1308 /* Check language is valid */
1309 if (0 != stt_parser_set_auto_lang(value)) {
1310 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1311 return STT_CONFIG_ERROR_OPERATION_FAILED;
1313 g_config_info->auto_lang = value;
1315 if (true == g_config_info->auto_lang) {
1316 __stt_config_set_auto_language();
1320 return STT_CONFIG_ERROR_NONE;
1323 int stt_config_mgr_get_silence_detection(bool* value)
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;
1331 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1333 *value = g_config_info->silence_detection;
1335 return STT_CONFIG_ERROR_NONE;
1338 int stt_config_mgr_set_silence_detection(bool value)
1340 if (0 >= g_slist_length(g_config_client_list)) {
1341 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1342 return STT_CONFIG_ERROR_INVALID_STATE;
1345 if (0 != stt_parser_set_silence_detection(value)) {
1346 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1347 return STT_CONFIG_ERROR_OPERATION_FAILED;
1350 g_config_info->silence_detection = value;
1352 return STT_CONFIG_ERROR_NONE;
1355 bool stt_config_check_default_engine_is_valid(const char* engine)
1357 if (0 >= g_slist_length(g_config_client_list)) {
1358 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1362 if (NULL == engine) {
1366 if (0 >= g_slist_length(g_engine_list))
1369 GSList *iter = NULL;
1370 stt_engine_info_s *engine_info = NULL;
1372 /* Get a first item */
1373 iter = g_slist_nth(g_engine_list, 0);
1375 while (NULL != iter) {
1376 engine_info = iter->data;
1378 if (NULL != engine_info) {
1379 if (0 == strcmp(engine, engine_info->uuid)) {
1383 iter = g_slist_next(iter);
1389 bool stt_config_check_default_language_is_valid(const char* language)
1391 if (0 >= g_slist_length(g_config_client_list)) {
1392 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1396 if (NULL == language) {
1400 if (NULL == g_config_info->engine_id) {
1401 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1405 if (0 >= g_slist_length(g_engine_list))
1408 GSList *iter = NULL;
1409 stt_engine_info_s *engine_info = NULL;
1411 /* Get a first item */
1412 iter = g_slist_nth(g_engine_list, 0);
1414 while (NULL != iter) {
1415 engine_info = iter->data;
1417 if (NULL == engine_info) {
1418 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1419 iter = g_slist_next(iter);
1423 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1424 iter = g_slist_next(iter);
1428 GSList *iter_lang = NULL;
1431 /* Get a first item */
1432 iter_lang = g_slist_nth(engine_info->languages, 0);
1434 while (NULL != iter_lang) {
1435 lang = iter_lang->data;
1437 if (0 == strcmp(language, lang))
1441 iter_lang = g_slist_next(iter_lang);
1449 int __stt_config_mgr_print_engine_info()
1451 GSList *iter = NULL;
1452 stt_engine_info_s *engine_info = NULL;
1454 if (0 >= g_slist_length(g_engine_list)) {
1455 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1456 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1457 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1461 /* Get a first item */
1462 iter = g_slist_nth(g_engine_list, 0);
1464 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1467 while (NULL != iter) {
1468 engine_info = iter->data;
1470 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1471 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1472 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1473 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1474 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1476 SLOG(LOG_DEBUG, stt_tag(), " languages");
1477 GSList *iter_lang = NULL;
1479 if (g_slist_length(engine_info->languages) > 0) {
1480 /* Get a first item */
1481 iter_lang = g_slist_nth(engine_info->languages, 0);
1484 while (NULL != iter_lang) {
1485 /*Get handle data from list*/
1486 lang = iter_lang->data;
1488 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1491 iter_lang = g_slist_next(iter_lang);
1495 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1497 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1498 engine_info->support_silence_detection ? "true" : "false");
1499 iter = g_slist_next(iter);
1502 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1510 * time info functions
1512 static GSList* g_time_list = NULL;
1514 int stt_config_mgr_reset_time_info()
1516 /* Remove time info */
1517 GSList *iter = NULL;
1518 stt_result_time_info_s *data = NULL;
1520 /* Remove time info */
1521 iter = g_slist_nth(g_time_list, 0);
1522 while (NULL != iter) {
1525 g_time_list = g_slist_remove(g_time_list, data);
1527 if (NULL != data->text) {
1536 iter = g_slist_nth(g_time_list, 0);
1542 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1545 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1549 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1551 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1552 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1554 info->index = index;
1555 info->event = event;
1557 info->text = strdup(text);
1559 info->start_time = start_time;
1560 info->end_time = end_time;
1562 /* Add item to global list */
1563 g_time_list = g_slist_append(g_time_list, info);
1568 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1570 if (NULL == callback) {
1571 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1572 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1575 GSList* temp_time = NULL;
1577 ret = stt_parser_get_time_info(&temp_time);
1579 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1580 return STT_CONFIG_ERROR_OPERATION_FAILED;
1583 GSList *iter = NULL;
1584 stt_result_time_info_s *data = NULL;
1586 /* Get a first item */
1587 iter = g_slist_nth(temp_time, 0);
1588 while (NULL != iter) {
1591 if (false == callback(data->index, data->event, data->text,
1592 data->start_time, data->end_time, user_data)) {
1597 iter = g_slist_next(iter);
1600 /* Remove time info */
1601 iter = g_slist_nth(temp_time, 0);
1602 while (NULL != iter) {
1606 temp_time = g_slist_remove(temp_time, data);
1608 if (NULL != data->text) {
1617 iter = g_slist_nth(temp_time, 0);
1620 return STT_CONFIG_ERROR_NONE;
1623 int stt_config_mgr_save_time_info_file()
1625 if (0 == g_slist_length(g_time_list)) {
1626 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1627 return STT_CONFIG_ERROR_OPERATION_FAILED;
1631 ret = stt_parser_set_time_info(g_time_list);
1633 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1634 return STT_CONFIG_ERROR_OPERATION_FAILED;
1637 return STT_CONFIG_ERROR_NONE;
1640 int stt_config_mgr_remove_time_info_file()
1642 stt_parser_clear_time_info();
1644 return STT_CONFIG_ERROR_NONE;