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 SECURE_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 SECURE_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 SECURE_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 SECURE_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 SECURE_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));
495 void __stt_config_release_engine()
498 stt_engine_info_s *engine_info = NULL;
500 if (0 < g_slist_length(g_engine_list)) {
502 /* Get a first item */
503 iter = g_slist_nth(g_engine_list, 0);
505 while (NULL != iter) {
506 engine_info = iter->data;
508 if (NULL != engine_info) {
509 g_engine_list = g_slist_remove(g_engine_list, engine_info);
511 stt_parser_free_engine_info(engine_info);
514 iter = g_slist_nth(g_engine_list, 0);
519 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
521 if (NULL == engine_id) {
522 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
523 return STT_CONFIG_ERROR_INVALID_PARAMETER;
527 stt_engine_info_s *engine_info = NULL;
529 if (0 >= g_slist_length(g_engine_list)) {
530 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
531 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
534 /* Get a first item */
535 iter = g_slist_nth(g_engine_list, 0);
537 while (NULL != iter) {
538 engine_info = iter->data;
540 if (NULL == engine_info) {
541 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
542 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
545 if (0 == strcmp(engine_id, engine_info->uuid)) {
546 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
547 return STT_CONFIG_ERROR_NONE;
550 iter = g_slist_next(iter);
553 /* Change default engine */
554 iter = g_slist_nth(g_engine_list, 0);
555 engine_info = iter->data;
556 if (NULL == engine_info) {
557 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
558 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
561 if (NULL != g_config_info->engine_id) {
562 free(g_config_info->engine_id);
563 g_config_info->engine_id = NULL;
565 if (NULL != g_config_info->setting) {
566 free(g_config_info->setting);
567 g_config_info->setting = NULL;
570 if (NULL != engine_info->uuid) {
571 g_config_info->engine_id = strdup(engine_info->uuid);
574 if (NULL != engine_info->setting) {
575 g_config_info->setting = strdup(engine_info->setting);
579 GSList *iter_lang = NULL;
581 bool is_valid_lang = false;
583 if (0 >= g_slist_length(engine_info->languages)) {
584 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
585 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
588 /* Get a first item */
589 iter_lang = g_slist_nth(engine_info->languages, 0);
591 while (NULL != iter_lang) {
592 /*Get handle data from list*/
593 lang = iter_lang->data;
595 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
597 if (0 == strcmp(lang, g_config_info->language)) {
598 /* language is valid */
599 is_valid_lang = true;
605 iter_lang = g_slist_next(iter_lang);
608 if (false == is_valid_lang) {
609 iter_lang = g_slist_nth(engine_info->languages, 0);
610 if (NULL != iter_lang) {
611 lang = iter_lang->data;
613 if (NULL != g_config_info->language)
614 free(g_config_info->language);
615 g_config_info->language = strdup(lang);
621 if (false == engine_info->support_silence_detection) {
622 if (true == g_config_info->silence_detection)
623 g_config_info->silence_detection = false;
626 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
627 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
628 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
629 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
630 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
632 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
633 g_config_info->silence_detection)) {
634 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
635 return STT_CONFIG_ERROR_OPERATION_FAILED;
638 return STT_CONFIG_ERROR_NONE;
641 int stt_config_mgr_initialize(int uid)
645 stt_config_client_s* temp_client = NULL;
647 if (0 < g_slist_length(g_config_client_list)) {
649 iter = g_slist_nth(g_config_client_list, 0);
651 while (NULL != iter) {
652 get_uid = iter->data;
654 if (uid == *get_uid) {
655 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
659 iter = g_slist_next(iter);
662 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
663 if (NULL == temp_client) {
664 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
665 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
667 temp_client->uid = uid;
668 temp_client->bool_cb = NULL;
669 temp_client->engine_cb = NULL;
670 temp_client->lang_cb = NULL;
671 temp_client->user_data = NULL;
674 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
676 SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
677 return STT_CONFIG_ERROR_NONE;
680 /* Get file name from default engine directory */
684 struct dirent *dirp = NULL;
686 g_engine_list = NULL;
688 dp = opendir(STT_DEFAULT_ENGINE_INFO);
691 ret = readdir_r(dp, &entry, &dirp);
693 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
698 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
701 stt_engine_info_s* info;
705 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
706 filepath = (char*)calloc(filesize, sizeof(char));
708 if (NULL != filepath) {
709 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
711 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
715 if (0 == stt_parser_get_engine_info(filepath, &info)) {
716 g_engine_list = g_slist_append(g_engine_list, info);
719 if (NULL != filepath)
722 } while (NULL != dirp);
726 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
729 __stt_config_mgr_print_engine_info();
731 if (0 != stt_parser_load_config(&g_config_info)) {
732 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
733 __stt_config_release_client(uid);
734 __stt_config_release_engine();
735 return STT_CONFIG_ERROR_OPERATION_FAILED;
738 /* Check whether engine id is valid */
739 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
740 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
741 __stt_config_release_client(uid);
742 __stt_config_release_engine();
743 stt_parser_unload_config(g_config_info);
744 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
747 if (true == g_config_info->auto_lang) {
748 /* Check language with display language */
749 __stt_config_set_auto_language();
751 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
752 /* Default language is not valid */
754 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
755 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
756 __stt_config_release_client(uid);
757 __stt_config_release_engine();
758 stt_parser_unload_config(g_config_info);
759 return STT_CONFIG_ERROR_OPERATION_FAILED;
762 if (NULL != tmp_language) {
763 if (NULL != g_config_info->language) {
764 free(g_config_info->language);
765 g_config_info->language = strdup(tmp_language);
773 /* print daemon config */
774 SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
775 SECURE_SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
776 SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
777 SECURE_SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
778 SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
779 SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
780 SLOG(LOG_DEBUG, stt_tag(), "===================");
782 if (0 != __stt_config_mgr_register_config_event()) {
783 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
784 __stt_config_release_client(uid);
785 __stt_config_release_engine();
786 stt_parser_unload_config(g_config_info);
787 return STT_CONFIG_ERROR_OPERATION_FAILED;
790 /* Register to detect display language change */
791 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
793 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
794 if (NULL == temp_client) {
795 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
796 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
798 temp_client->uid = uid;
799 temp_client->bool_cb = NULL;
800 temp_client->engine_cb = NULL;
801 temp_client->lang_cb = NULL;
802 temp_client->user_data = NULL;
805 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
807 return STT_CONFIG_ERROR_NONE;
810 int stt_config_mgr_finalize(int uid)
813 stt_config_client_s* temp_client = NULL;
815 if (0 < g_slist_length(g_config_client_list)) {
817 iter = g_slist_nth(g_config_client_list, 0);
819 while (NULL != iter) {
820 temp_client = iter->data;
822 if (NULL != temp_client) {
823 if (uid == temp_client->uid) {
824 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
831 iter = g_slist_next(iter);
835 if (0 < g_slist_length(g_config_client_list)) {
836 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
837 return STT_CONFIG_ERROR_NONE;
840 stt_engine_info_s *engine_info = NULL;
842 if (0 < g_slist_length(g_engine_list)) {
844 /* Get a first item */
845 iter = g_slist_nth(g_engine_list, 0);
847 while (NULL != iter) {
848 engine_info = iter->data;
850 if (NULL != engine_info) {
851 g_engine_list = g_slist_remove(g_engine_list, engine_info);
853 stt_parser_free_engine_info(engine_info);
856 iter = g_slist_nth(g_engine_list, 0);
860 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
862 __stt_config_mgr_unregister_config_event();
864 if (NULL != g_config_info) {
865 stt_parser_unload_config(g_config_info);
866 g_config_info = NULL;
869 return STT_CONFIG_ERROR_NONE;
872 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)
875 stt_config_client_s* temp_client = NULL;
877 /* Call all callbacks of client*/
878 iter = g_slist_nth(g_config_client_list, 0);
880 while (NULL != iter) {
881 temp_client = iter->data;
883 if (NULL != temp_client) {
884 if (uid == temp_client->uid) {
885 temp_client->engine_cb = engine_cb;
886 temp_client->lang_cb = lang_cb;
887 temp_client->bool_cb = bool_cb;
888 temp_client->user_data = user_data;
892 iter = g_slist_next(iter);
895 return STT_CONFIG_ERROR_NONE;
898 int stt_config_mgr_unset_callback(int uid)
901 stt_config_client_s* temp_client = NULL;
903 /* Call all callbacks of client*/
904 iter = g_slist_nth(g_config_client_list, 0);
906 while (NULL != iter) {
907 temp_client = iter->data;
909 if (NULL != temp_client) {
910 if (uid == temp_client->uid) {
911 temp_client->engine_cb = NULL;
912 temp_client->lang_cb = NULL;
913 temp_client->bool_cb = NULL;
914 temp_client->user_data = NULL;
918 iter = g_slist_next(iter);
921 return STT_CONFIG_ERROR_NONE;
924 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
926 if (0 >= g_slist_length(g_config_client_list)) {
927 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
928 return STT_CONFIG_ERROR_INVALID_STATE;
931 if (NULL == callback) {
932 return STT_CONFIG_ERROR_INVALID_PARAMETER;
936 stt_engine_info_s *engine_info = NULL;
938 if (0 >= g_slist_length(g_engine_list)) {
939 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
940 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
943 /* Get a first item */
944 iter = g_slist_nth(g_engine_list, 0);
946 while (NULL != iter) {
947 engine_info = iter->data;
949 if (NULL == engine_info) {
950 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
951 return STT_CONFIG_ERROR_OPERATION_FAILED;
954 if (false == callback(engine_info->uuid, engine_info->name,
955 engine_info->setting, engine_info->support_silence_detection, user_data)) {
959 iter = g_slist_next(iter);
962 return STT_CONFIG_ERROR_NONE;
965 int stt_config_mgr_get_engine(char** engine)
967 if (0 >= g_slist_length(g_config_client_list)) {
968 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
969 return STT_CONFIG_ERROR_INVALID_STATE;
972 if (NULL == engine) {
973 return STT_CONFIG_ERROR_INVALID_PARAMETER;
976 if (NULL != g_config_info->engine_id) {
977 *engine = strdup(g_config_info->engine_id);
979 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
980 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
983 return STT_CONFIG_ERROR_NONE;
986 int stt_config_mgr_set_engine(const char* engine)
988 if (0 >= g_slist_length(g_config_client_list)) {
989 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
990 return STT_CONFIG_ERROR_INVALID_STATE;
993 if (NULL == g_config_info) {
994 return STT_CONFIG_ERROR_OPERATION_FAILED;
997 if (NULL == engine || NULL == g_config_info->engine_id) {
998 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1001 /* Check current engine id with new engine id */
1002 if (0 == strcmp(g_config_info->engine_id, engine)) {
1006 SECURE_SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1008 GSList *iter = NULL;
1009 stt_engine_info_s *engine_info = NULL;
1010 bool is_valid_engine = false;
1012 /* Get a first item */
1013 iter = g_slist_nth(g_engine_list, 0);
1015 while (NULL != iter) {
1016 engine_info = iter->data;
1018 if (NULL == engine_info) {
1019 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1020 iter = g_slist_next(iter);
1024 /* Check engine id is valid */
1025 if (0 != strcmp(engine, engine_info->uuid)) {
1026 iter = g_slist_next(iter);
1030 if (NULL != g_config_info->engine_id)
1031 free(g_config_info->engine_id);
1033 g_config_info->engine_id = strdup(engine);
1035 if (NULL != g_config_info->setting) {
1036 free(g_config_info->setting);
1039 if (NULL != engine_info->setting) {
1040 g_config_info->setting = strdup(engine_info->setting);
1042 g_config_info->setting = NULL;
1045 /* Engine is valid*/
1046 GSList *iter_lang = NULL;
1048 bool is_valid_lang = false;
1050 /* Get a first item */
1051 iter_lang = g_slist_nth(engine_info->languages, 0);
1053 while (NULL != iter_lang) {
1054 /*Get handle data from list*/
1055 lang = iter_lang->data;
1057 SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1059 if (0 == strcmp(lang, g_config_info->language)) {
1060 /* language is valid */
1061 is_valid_lang = true;
1063 if (NULL != g_config_info->language) {
1064 free(g_config_info->language);
1066 g_config_info->language = strdup(lang);
1073 iter_lang = g_slist_next(iter_lang);
1076 if (false == is_valid_lang) {
1077 if (NULL != g_config_info->language) {
1078 free(g_config_info->language);
1080 iter_lang = g_slist_nth(engine_info->languages, 0);
1081 lang = iter_lang->data;
1083 g_config_info->language = strdup(lang);
1088 if (false == engine_info->support_silence_detection) {
1089 if (true == g_config_info->silence_detection)
1090 g_config_info->silence_detection = false;
1093 is_valid_engine = true;
1097 if (true == is_valid_engine) {
1098 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1099 SECURE_SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1100 SECURE_SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1101 SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1102 SECURE_SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1104 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1105 g_config_info->silence_detection)) {
1106 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1107 return STT_CONFIG_ERROR_OPERATION_FAILED;
1110 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1111 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1117 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1119 if (0 >= g_slist_length(g_engine_list)) {
1120 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1121 return STT_CONFIG_ERROR_INVALID_STATE;
1124 if (NULL == agreement) {
1125 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1126 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1129 GSList *iter = NULL;
1130 stt_engine_info_s *engine_info = NULL;
1131 char* current_engine = NULL;
1133 if (NULL == engine) {
1134 current_engine = strdup(g_config_info->engine_id);
1135 if (NULL == current_engine) {
1136 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1137 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1140 current_engine = strdup(engine);
1141 if (NULL == current_engine) {
1142 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1143 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1147 /* Get a first item */
1148 iter = g_slist_nth(g_engine_list, 0);
1150 while (NULL != iter) {
1151 engine_info = iter->data;
1153 if (NULL == engine_info) {
1154 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1155 if (NULL != current_engine) free(current_engine);
1156 return STT_CONFIG_ERROR_OPERATION_FAILED;
1159 if (0 != strcmp(current_engine, engine_info->uuid)) {
1160 iter = g_slist_next(iter);
1164 if (NULL != engine_info->agreement) {
1165 *agreement = strdup(engine_info->agreement);
1167 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1172 if (NULL != current_engine) free(current_engine);
1174 return STT_CONFIG_ERROR_NONE;
1177 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1179 if (0 >= g_slist_length(g_config_client_list)) {
1180 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1181 return STT_CONFIG_ERROR_INVALID_STATE;
1184 if (0 >= g_slist_length(g_engine_list)) {
1185 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1186 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1189 GSList *iter = NULL;
1190 stt_engine_info_s *engine_info = NULL;
1192 /* Get a first item */
1193 iter = g_slist_nth(g_engine_list, 0);
1195 while (NULL != iter) {
1196 engine_info = iter->data;
1198 if (NULL == engine_info) {
1199 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1200 return STT_CONFIG_ERROR_OPERATION_FAILED;
1203 if (0 != strcmp(engine_id, engine_info->uuid)) {
1204 iter = g_slist_next(iter);
1208 GSList *iter_lang = NULL;
1211 /* Get a first item */
1212 iter_lang = g_slist_nth(engine_info->languages, 0);
1214 while (NULL != iter_lang) {
1215 /*Get handle data from list*/
1216 lang = iter_lang->data;
1218 SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1220 if (false == callback(engine_info->uuid, lang, user_data))
1225 iter_lang = g_slist_next(iter_lang);
1230 return STT_CONFIG_ERROR_NONE;
1233 int stt_config_mgr_get_default_language(char** language)
1235 if (0 >= g_slist_length(g_config_client_list)) {
1236 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1237 return STT_CONFIG_ERROR_INVALID_STATE;
1240 if (NULL == language) {
1241 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1244 if (NULL != g_config_info->language) {
1245 *language = strdup(g_config_info->language);
1247 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1248 return STT_CONFIG_ERROR_OPERATION_FAILED;
1251 return STT_CONFIG_ERROR_NONE;
1254 int stt_config_mgr_set_default_language(const char* language)
1256 if (0 >= g_slist_length(g_config_client_list)) {
1257 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1258 return STT_CONFIG_ERROR_INVALID_STATE;
1261 if (NULL == language) {
1262 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1265 /* Check language is valid */
1266 if (NULL != g_config_info->language) {
1267 if (0 != stt_parser_set_language(language)) {
1268 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1269 return STT_CONFIG_ERROR_OPERATION_FAILED;
1271 free(g_config_info->language);
1272 g_config_info->language = strdup(language);
1274 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1275 return STT_CONFIG_ERROR_OPERATION_FAILED;
1278 return STT_CONFIG_ERROR_NONE;
1281 int stt_config_mgr_get_auto_language(bool* value)
1283 if (0 >= g_slist_length(g_config_client_list)) {
1284 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1285 return STT_CONFIG_ERROR_INVALID_STATE;
1288 if (NULL == value) {
1289 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1292 *value = g_config_info->auto_lang;
1294 return STT_CONFIG_ERROR_NONE;
1297 int stt_config_mgr_set_auto_language(bool value)
1299 if (0 >= g_slist_length(g_config_client_list)) {
1300 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1301 return STT_CONFIG_ERROR_INVALID_STATE;
1304 if (g_config_info->auto_lang != value) {
1305 /* Check language is valid */
1306 if (0 != stt_parser_set_auto_lang(value)) {
1307 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1308 return STT_CONFIG_ERROR_OPERATION_FAILED;
1310 g_config_info->auto_lang = value;
1312 if (true == g_config_info->auto_lang) {
1313 __stt_config_set_auto_language();
1317 return STT_CONFIG_ERROR_NONE;
1320 int stt_config_mgr_get_silence_detection(bool* value)
1322 if (0 >= g_slist_length(g_config_client_list)) {
1323 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1324 return STT_CONFIG_ERROR_INVALID_STATE;
1328 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1330 *value = g_config_info->silence_detection;
1332 return STT_CONFIG_ERROR_NONE;
1335 int stt_config_mgr_set_silence_detection(bool value)
1337 if (0 >= g_slist_length(g_config_client_list)) {
1338 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1339 return STT_CONFIG_ERROR_INVALID_STATE;
1342 if (0 != stt_parser_set_silence_detection(value)) {
1343 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1344 return STT_CONFIG_ERROR_OPERATION_FAILED;
1347 g_config_info->silence_detection = value;
1349 return STT_CONFIG_ERROR_NONE;
1352 bool stt_config_check_default_engine_is_valid(const char* engine)
1354 if (0 >= g_slist_length(g_config_client_list)) {
1355 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1359 if (NULL == engine) {
1363 if (0 >= g_slist_length(g_engine_list))
1366 GSList *iter = NULL;
1367 stt_engine_info_s *engine_info = NULL;
1369 /* Get a first item */
1370 iter = g_slist_nth(g_engine_list, 0);
1372 while (NULL != iter) {
1373 engine_info = iter->data;
1375 if (NULL != engine_info) {
1376 if (0 == strcmp(engine, engine_info->uuid)) {
1380 iter = g_slist_next(iter);
1386 bool stt_config_check_default_language_is_valid(const char* language)
1388 if (0 >= g_slist_length(g_config_client_list)) {
1389 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1393 if (NULL == language) {
1397 if (NULL == g_config_info->engine_id) {
1398 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1402 if (0 >= g_slist_length(g_engine_list))
1405 GSList *iter = NULL;
1406 stt_engine_info_s *engine_info = NULL;
1408 /* Get a first item */
1409 iter = g_slist_nth(g_engine_list, 0);
1411 while (NULL != iter) {
1412 engine_info = iter->data;
1414 if (NULL == engine_info) {
1415 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1416 iter = g_slist_next(iter);
1420 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1421 iter = g_slist_next(iter);
1425 GSList *iter_lang = NULL;
1428 /* Get a first item */
1429 iter_lang = g_slist_nth(engine_info->languages, 0);
1431 while (NULL != iter_lang) {
1432 lang = iter_lang->data;
1434 if (0 == strcmp(language, lang))
1438 iter_lang = g_slist_next(iter_lang);
1446 int __stt_config_mgr_print_engine_info()
1448 GSList *iter = NULL;
1449 stt_engine_info_s *engine_info = NULL;
1451 if (0 >= g_slist_length(g_engine_list)) {
1452 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1453 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1454 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1458 /* Get a first item */
1459 iter = g_slist_nth(g_engine_list, 0);
1461 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1464 while (NULL != iter) {
1465 engine_info = iter->data;
1467 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1468 SECURE_SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1469 SECURE_SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1470 SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1471 SECURE_SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1473 SLOG(LOG_DEBUG, stt_tag(), " languages");
1474 GSList *iter_lang = NULL;
1476 if (g_slist_length(engine_info->languages) > 0) {
1477 /* Get a first item */
1478 iter_lang = g_slist_nth(engine_info->languages, 0);
1481 while (NULL != iter_lang) {
1482 /*Get handle data from list*/
1483 lang = iter_lang->data;
1485 SECURE_SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1488 iter_lang = g_slist_next(iter_lang);
1492 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1494 SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1495 engine_info->support_silence_detection ? "true" : "false");
1496 iter = g_slist_next(iter);
1499 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1507 * time info functions
1509 static GSList* g_time_list = NULL;
1511 int stt_config_mgr_reset_time_info()
1513 /* Remove time info */
1514 GSList *iter = NULL;
1515 stt_result_time_info_s *data = NULL;
1517 /* Remove time info */
1518 iter = g_slist_nth(g_time_list, 0);
1519 while (NULL != iter) {
1522 g_time_list = g_slist_remove(g_time_list, data);
1524 if (NULL == data->text) free(data->text);
1529 iter = g_slist_nth(g_time_list, 0);
1535 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1538 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1542 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1544 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1545 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1547 info->index = index;
1548 info->event = event;
1550 info->text = strdup(text);
1552 info->start_time = start_time;
1553 info->end_time = end_time;
1555 /* Add item to global list */
1556 g_time_list = g_slist_append(g_time_list, info);
1561 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1563 if (NULL == callback) {
1564 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1565 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1568 GSList* temp_time = NULL;
1570 ret = stt_parser_get_time_info(&temp_time);
1572 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1573 return STT_CONFIG_ERROR_OPERATION_FAILED;
1576 GSList *iter = NULL;
1577 stt_result_time_info_s *data = NULL;
1579 /* Get a first item */
1580 iter = g_slist_nth(temp_time, 0);
1581 while (NULL != iter) {
1584 if (false == callback(data->index, data->event, data->text,
1585 data->start_time, data->end_time, user_data)) {
1590 iter = g_slist_next(iter);
1593 /* Remove time info */
1594 iter = g_slist_nth(temp_time, 0);
1595 while (NULL != iter) {
1599 temp_time = g_slist_remove(temp_time, data);
1601 if (NULL == data->text) free(data->text);
1606 iter = g_slist_nth(temp_time, 0);
1609 return STT_CONFIG_ERROR_NONE;
1612 int stt_config_mgr_save_time_info_file()
1614 if (0 == g_slist_length(g_time_list)) {
1615 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1616 return STT_CONFIG_ERROR_OPERATION_FAILED;
1620 ret = stt_parser_set_time_info(g_time_list);
1622 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1623 return STT_CONFIG_ERROR_OPERATION_FAILED;
1626 return STT_CONFIG_ERROR_NONE;
1629 int stt_config_mgr_remove_time_info_file()
1631 stt_parser_clear_time_info();
1633 return STT_CONFIG_ERROR_NONE;