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;
199 stt_config_client_s* temp_client = NULL;
201 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
202 return ECORE_CALLBACK_PASS_ON;
205 if (NULL != engine || NULL != setting) {
207 if (NULL != engine) {
208 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
209 g_config_info->engine_id = strdup(engine);
212 if (NULL != setting) {
213 if (NULL != g_config_info->setting) free(g_config_info->setting);
214 g_config_info->setting = strdup(setting);
218 if (NULL != g_config_info->language) free(g_config_info->language);
219 g_config_info->language = strdup(lang);
222 if (-1 != silence) g_config_info->silence_detection = silence;
224 if (-1 != credential) g_config_info->credential = credential;
226 /* Call all callbacks of client*/
227 iter = g_slist_nth(g_config_client_list, 0);
229 while (NULL != iter) {
230 temp_client = iter->data;
232 if (NULL != temp_client) {
233 if (NULL != temp_client->engine_cb) {
234 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
235 g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
239 iter = g_slist_next(iter);
243 if (-1 != auto_lang) {
244 g_config_info->auto_lang = auto_lang;
247 /* Only language changed */
248 if (NULL == engine && NULL != lang) {
249 char* before_lang = NULL;
250 before_lang = strdup(g_config_info->language);
253 if (NULL != g_config_info->language) free(g_config_info->language);
254 g_config_info->language = strdup(lang);
257 /* Call all callbacks of client*/
258 iter = g_slist_nth(g_config_client_list, 0);
260 while (NULL != iter) {
261 temp_client = iter->data;
263 if (NULL != temp_client) {
264 if (NULL != temp_client->lang_cb) {
265 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
269 iter = g_slist_next(iter);
272 if (NULL != before_lang) {
278 /* silence detection changed */
279 g_config_info->silence_detection = silence;
281 /* Call all callbacks of client*/
282 iter = g_slist_nth(g_config_client_list, 0);
284 while (NULL != iter) {
285 temp_client = iter->data;
287 if (NULL != temp_client) {
288 if (NULL != temp_client->bool_cb) {
289 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
293 iter = g_slist_next(iter);
297 if (NULL != engine) free(engine);
298 if (NULL != setting) free(setting);
299 if (NULL != lang) free(lang);
301 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
304 SLOG(LOG_DEBUG, stt_tag(), "=====");
305 SLOG(LOG_DEBUG, stt_tag(), " ");
307 return ECORE_CALLBACK_PASS_ON;
310 int __stt_config_mgr_register_config_event()
312 /* get file notification handler */
318 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
323 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
326 g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
327 if (NULL == g_fd_handler_noti) {
328 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
335 int __stt_config_mgr_unregister_config_event()
337 /* delete inotify variable */
338 ecore_main_fd_handler_del(g_fd_handler_noti);
339 inotify_rm_watch(g_fd_noti, g_wd_noti);
345 int __stt_config_set_auto_language()
348 char candidate_lang[6] = {'\0', };
350 value = vconf_get_str(VCONFKEY_LANGSET);
352 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
356 strncpy(candidate_lang, value, 5);
359 /* Check current config info */
360 if (NULL == g_config_info) {
361 SLOG(LOG_ERROR, stt_tag(), "Current config info is NULL");
362 return STT_CONFIG_ERROR_OPERATION_FAILED;
365 /* Check current language */
366 if (NULL == g_config_info->language) {
367 SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
368 return STT_CONFIG_ERROR_OPERATION_FAILED;
371 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
372 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
375 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
378 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
379 char* before_lang = NULL;
380 if (0 != stt_parser_set_language(candidate_lang)) {
381 SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
385 before_lang = strdup(g_config_info->language);
387 free(g_config_info->language);
388 g_config_info->language = strdup(candidate_lang);
390 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
392 /* Call all callbacks of client*/
394 stt_config_client_s* temp_client = NULL;
396 iter = g_slist_nth(g_config_client_list, 0);
398 while (NULL != iter) {
399 temp_client = iter->data;
401 if (NULL != temp_client) {
402 if (NULL != temp_client->lang_cb) {
403 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
407 iter = g_slist_next(iter);
410 if (NULL != before_lang) {
414 /* Candidate language is not valid */
415 char* tmp_language = NULL;
416 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
417 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
421 if (NULL == tmp_language) {
422 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
426 if (0 != stt_parser_set_language(tmp_language)) {
428 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
432 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
434 /* Call all callbacks of client*/
436 stt_config_client_s* temp_client = NULL;
438 iter = g_slist_nth(g_config_client_list, 0);
440 while (NULL != iter) {
441 temp_client = iter->data;
443 if (NULL != temp_client) {
444 if (NULL != temp_client->lang_cb) {
445 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
449 iter = g_slist_next(iter);
452 free(g_config_info->language);
453 g_config_info->language = strdup(tmp_language);
461 void __stt_config_language_changed_cb(keynode_t *key, void *data)
463 if (true == g_config_info->auto_lang) {
464 /* Get voice input vconf key */
465 __stt_config_set_auto_language();
471 void __stt_config_release_client(int uid)
474 stt_config_client_s* temp_client = NULL;
476 if (0 < g_slist_length(g_config_client_list)) {
478 iter = g_slist_nth(g_config_client_list, 0);
480 while (NULL != iter) {
481 temp_client = iter->data;
483 if (NULL != temp_client) {
484 if (uid == temp_client->uid) {
485 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
492 iter = g_slist_next(iter);
496 if (0 < g_slist_length(g_config_client_list)) {
497 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
502 void __stt_config_release_engine()
505 stt_engine_info_s *engine_info = NULL;
507 if (0 < g_slist_length(g_engine_list)) {
509 /* Get a first item */
510 iter = g_slist_nth(g_engine_list, 0);
512 while (NULL != iter) {
513 engine_info = iter->data;
515 if (NULL != engine_info) {
516 g_engine_list = g_slist_remove(g_engine_list, engine_info);
518 stt_parser_free_engine_info(engine_info);
521 iter = g_slist_nth(g_engine_list, 0);
527 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
529 if (NULL == engine_id) {
530 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
531 return STT_CONFIG_ERROR_INVALID_PARAMETER;
535 stt_engine_info_s *engine_info = NULL;
537 if (0 >= g_slist_length(g_engine_list)) {
538 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
539 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
542 /* Get a first item */
543 iter = g_slist_nth(g_engine_list, 0);
545 while (NULL != iter) {
546 engine_info = iter->data;
548 if (NULL == engine_info) {
549 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
550 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
553 if (0 == strcmp(engine_id, engine_info->uuid)) {
554 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
555 return STT_CONFIG_ERROR_NONE;
558 iter = g_slist_next(iter);
561 /* Change default engine */
562 iter = g_slist_nth(g_engine_list, 0);
563 engine_info = iter->data;
564 if (NULL == engine_info) {
565 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
566 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
569 if (NULL != g_config_info->engine_id) {
570 free(g_config_info->engine_id);
571 g_config_info->engine_id = NULL;
573 if (NULL != g_config_info->setting) {
574 free(g_config_info->setting);
575 g_config_info->setting = NULL;
578 if (NULL != engine_info->uuid) {
579 g_config_info->engine_id = strdup(engine_info->uuid);
582 if (NULL != engine_info->setting) {
583 g_config_info->setting = strdup(engine_info->setting);
587 GSList *iter_lang = NULL;
589 bool is_valid_lang = false;
591 if (0 >= g_slist_length(engine_info->languages)) {
592 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
593 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
596 /* Get a first item */
597 iter_lang = g_slist_nth(engine_info->languages, 0);
599 while (NULL != iter_lang) {
600 /*Get handle data from list*/
601 lang = iter_lang->data;
603 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
605 if (0 == strcmp(lang, g_config_info->language)) {
606 /* language is valid */
607 is_valid_lang = true;
613 iter_lang = g_slist_next(iter_lang);
616 if (false == is_valid_lang) {
617 iter_lang = g_slist_nth(engine_info->languages, 0);
618 if (NULL != iter_lang) {
619 lang = iter_lang->data;
621 if (NULL != g_config_info->language)
622 free(g_config_info->language);
623 g_config_info->language = strdup(lang);
629 if (false == engine_info->support_silence_detection) {
630 if (true == g_config_info->silence_detection)
631 g_config_info->silence_detection = false;
634 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
635 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
636 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
637 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
638 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
639 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
641 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
642 g_config_info->silence_detection, g_config_info->credential)) {
643 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
644 return STT_CONFIG_ERROR_OPERATION_FAILED;
647 return STT_CONFIG_ERROR_NONE;
650 int stt_config_mgr_initialize(int uid)
654 stt_config_client_s* temp_client = NULL;
656 if (0 < g_slist_length(g_config_client_list)) {
658 iter = g_slist_nth(g_config_client_list, 0);
660 while (NULL != iter) {
661 get_uid = iter->data;
663 if (uid == *get_uid) {
664 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
668 iter = g_slist_next(iter);
671 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
672 if (NULL == temp_client) {
673 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
674 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
676 temp_client->uid = uid;
677 temp_client->bool_cb = NULL;
678 temp_client->engine_cb = NULL;
679 temp_client->lang_cb = NULL;
680 temp_client->user_data = NULL;
683 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
685 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
686 return STT_CONFIG_ERROR_NONE;
689 /* Get file name from default engine directory */
693 struct dirent *dirp = NULL;
695 g_engine_list = NULL;
697 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
698 dp = opendir(STT_DEFAULT_ENGINE_INFO);
701 ret = readdir_r(dp, &entry, &dirp);
703 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
708 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
711 stt_engine_info_s* info;
715 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
716 filepath = (char*)calloc(filesize, sizeof(char));
718 if (NULL != filepath) {
719 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
721 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
725 if (0 == stt_parser_get_engine_info(filepath, &info)) {
726 g_engine_list = g_slist_append(g_engine_list, info);
729 if (NULL != filepath)
732 } while (NULL != dirp);
736 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
739 __stt_config_mgr_print_engine_info();
741 if (0 != stt_parser_load_config(&g_config_info)) {
742 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
743 __stt_config_release_client(uid);
744 __stt_config_release_engine();
745 return STT_CONFIG_ERROR_OPERATION_FAILED;
748 /* Check whether engine id is valid */
749 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
750 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
751 __stt_config_release_client(uid);
752 __stt_config_release_engine();
753 stt_parser_unload_config(g_config_info);
754 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
757 if (true == g_config_info->auto_lang) {
758 /* Check language with display language */
759 __stt_config_set_auto_language();
761 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
762 /* Default language is not valid */
764 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
765 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
766 __stt_config_release_client(uid);
767 __stt_config_release_engine();
768 stt_parser_unload_config(g_config_info);
769 return STT_CONFIG_ERROR_OPERATION_FAILED;
772 if (NULL != tmp_language) {
773 if (NULL != g_config_info->language) {
774 free(g_config_info->language);
775 g_config_info->language = strdup(tmp_language);
783 /* print daemon config */
784 SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
785 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
786 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
787 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
788 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
789 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
790 SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
791 SLOG(LOG_DEBUG, stt_tag(), "===================");
793 if (0 != __stt_config_mgr_register_config_event()) {
794 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
795 __stt_config_release_client(uid);
796 __stt_config_release_engine();
797 stt_parser_unload_config(g_config_info);
798 return STT_CONFIG_ERROR_OPERATION_FAILED;
801 /* Register to detect display language change */
802 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
804 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
805 if (NULL == temp_client) {
806 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
807 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
809 temp_client->uid = uid;
810 temp_client->bool_cb = NULL;
811 temp_client->engine_cb = NULL;
812 temp_client->lang_cb = NULL;
813 temp_client->user_data = NULL;
816 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
818 return STT_CONFIG_ERROR_NONE;
821 int stt_config_mgr_finalize(int uid)
824 stt_config_client_s* temp_client = NULL;
826 if (0 < g_slist_length(g_config_client_list)) {
828 iter = g_slist_nth(g_config_client_list, 0);
830 while (NULL != iter) {
831 temp_client = iter->data;
833 if (NULL != temp_client) {
834 if (uid == temp_client->uid) {
835 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
842 iter = g_slist_next(iter);
846 if (0 < g_slist_length(g_config_client_list)) {
847 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
848 return STT_CONFIG_ERROR_NONE;
851 stt_engine_info_s *engine_info = NULL;
853 if (0 < g_slist_length(g_engine_list)) {
855 /* Get a first item */
856 iter = g_slist_nth(g_engine_list, 0);
858 while (NULL != iter) {
859 engine_info = iter->data;
861 if (NULL != engine_info) {
862 g_engine_list = g_slist_remove(g_engine_list, engine_info);
864 stt_parser_free_engine_info(engine_info);
867 iter = g_slist_nth(g_engine_list, 0);
871 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
873 __stt_config_mgr_unregister_config_event();
875 if (NULL != g_config_info) {
876 stt_parser_unload_config(g_config_info);
877 g_config_info = NULL;
880 return STT_CONFIG_ERROR_NONE;
883 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)
886 stt_config_client_s* temp_client = NULL;
888 /* Call all callbacks of client*/
889 iter = g_slist_nth(g_config_client_list, 0);
891 while (NULL != iter) {
892 temp_client = iter->data;
894 if (NULL != temp_client) {
895 if (uid == temp_client->uid) {
896 temp_client->engine_cb = engine_cb;
897 temp_client->lang_cb = lang_cb;
898 temp_client->bool_cb = bool_cb;
899 temp_client->user_data = user_data;
903 iter = g_slist_next(iter);
906 return STT_CONFIG_ERROR_NONE;
909 int stt_config_mgr_unset_callback(int uid)
912 stt_config_client_s* temp_client = NULL;
914 /* Call all callbacks of client*/
915 iter = g_slist_nth(g_config_client_list, 0);
917 while (NULL != iter) {
918 temp_client = iter->data;
920 if (NULL != temp_client) {
921 if (uid == temp_client->uid) {
922 temp_client->engine_cb = NULL;
923 temp_client->lang_cb = NULL;
924 temp_client->bool_cb = NULL;
925 temp_client->user_data = NULL;
929 iter = g_slist_next(iter);
932 return STT_CONFIG_ERROR_NONE;
935 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
937 if (0 >= g_slist_length(g_config_client_list)) {
938 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
939 return STT_CONFIG_ERROR_INVALID_STATE;
942 if (NULL == callback) {
943 return STT_CONFIG_ERROR_INVALID_PARAMETER;
947 stt_engine_info_s *engine_info = NULL;
949 if (0 >= g_slist_length(g_engine_list)) {
950 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
951 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
954 /* Get a first item */
955 iter = g_slist_nth(g_engine_list, 0);
957 while (NULL != iter) {
958 engine_info = iter->data;
960 if (NULL == engine_info) {
961 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
962 return STT_CONFIG_ERROR_OPERATION_FAILED;
965 if (false == callback(engine_info->uuid, engine_info->name,
966 engine_info->setting, engine_info->support_silence_detection, user_data)) {
970 iter = g_slist_next(iter);
973 return STT_CONFIG_ERROR_NONE;
976 int stt_config_mgr_get_engine(char** engine)
978 if (0 >= g_slist_length(g_config_client_list)) {
979 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
980 return STT_CONFIG_ERROR_INVALID_STATE;
983 if (NULL == engine) {
984 return STT_CONFIG_ERROR_INVALID_PARAMETER;
987 if (NULL != g_config_info->engine_id) {
988 *engine = strdup(g_config_info->engine_id);
990 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
991 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
994 return STT_CONFIG_ERROR_NONE;
997 int stt_config_mgr_set_engine(const char* engine)
999 if (0 >= g_slist_length(g_config_client_list)) {
1000 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1001 return STT_CONFIG_ERROR_INVALID_STATE;
1004 if (NULL == g_config_info) {
1005 return STT_CONFIG_ERROR_OPERATION_FAILED;
1008 if (NULL == engine || NULL == g_config_info->engine_id) {
1009 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1012 /* Check current engine id with new engine id */
1013 if (0 == strcmp(g_config_info->engine_id, engine)) {
1017 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1019 GSList *iter = NULL;
1020 stt_engine_info_s *engine_info = NULL;
1021 bool is_valid_engine = false;
1023 /* Get a first item */
1024 iter = g_slist_nth(g_engine_list, 0);
1026 while (NULL != iter) {
1027 engine_info = iter->data;
1029 if (NULL == engine_info) {
1030 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1031 iter = g_slist_next(iter);
1035 /* Check engine id is valid */
1036 if (0 != strcmp(engine, engine_info->uuid)) {
1037 iter = g_slist_next(iter);
1041 if (NULL != g_config_info->engine_id)
1042 free(g_config_info->engine_id);
1044 g_config_info->engine_id = strdup(engine);
1046 if (NULL != g_config_info->setting) {
1047 free(g_config_info->setting);
1050 if (NULL != engine_info->setting) {
1051 g_config_info->setting = strdup(engine_info->setting);
1053 g_config_info->setting = NULL;
1056 /* Engine is valid*/
1057 GSList *iter_lang = NULL;
1059 bool is_valid_lang = false;
1061 /* Get a first item */
1062 iter_lang = g_slist_nth(engine_info->languages, 0);
1064 while (NULL != iter_lang) {
1065 /*Get handle data from list*/
1066 lang = iter_lang->data;
1068 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1069 if (NULL != lang && NULL != g_config_info->language) {
1070 if (0 == strcmp(lang, g_config_info->language)) {
1071 /* language is valid */
1072 is_valid_lang = true;
1074 free(g_config_info->language);
1075 g_config_info->language = strdup(lang);
1082 iter_lang = g_slist_next(iter_lang);
1085 if (false == is_valid_lang) {
1086 if (NULL != g_config_info->language) {
1087 free(g_config_info->language);
1089 iter_lang = g_slist_nth(engine_info->languages, 0);
1090 lang = iter_lang->data;
1092 g_config_info->language = strdup(lang);
1097 if (false == engine_info->support_silence_detection) {
1098 if (true == g_config_info->silence_detection)
1099 g_config_info->silence_detection = false;
1102 if (false == engine_info->need_credential) {
1103 if (true == g_config_info->credential)
1104 g_config_info->credential = false;
1107 is_valid_engine = true;
1111 if (true == is_valid_engine) {
1112 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1113 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1114 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1115 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1116 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1117 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1119 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1120 g_config_info->silence_detection, g_config_info->credential)) {
1121 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1122 return STT_CONFIG_ERROR_OPERATION_FAILED;
1125 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1126 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1132 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1134 if (0 >= g_slist_length(g_engine_list)) {
1135 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1136 return STT_CONFIG_ERROR_INVALID_STATE;
1139 if (NULL == agreement) {
1140 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1141 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1144 GSList *iter = NULL;
1145 stt_engine_info_s *engine_info = NULL;
1146 char* current_engine = NULL;
1148 if (NULL == engine) {
1149 current_engine = strdup(g_config_info->engine_id);
1150 if (NULL == current_engine) {
1151 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1152 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1155 current_engine = strdup(engine);
1156 if (NULL == current_engine) {
1157 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1158 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1162 /* Get a first item */
1163 iter = g_slist_nth(g_engine_list, 0);
1165 while (NULL != iter) {
1166 engine_info = iter->data;
1168 if (NULL == engine_info) {
1169 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1170 if (NULL != current_engine) free(current_engine);
1171 return STT_CONFIG_ERROR_OPERATION_FAILED;
1174 if (0 != strcmp(current_engine, engine_info->uuid)) {
1175 iter = g_slist_next(iter);
1179 if (NULL != engine_info->agreement) {
1180 *agreement = strdup(engine_info->agreement);
1182 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1187 if (NULL != current_engine) free(current_engine);
1189 return STT_CONFIG_ERROR_NONE;
1192 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1194 if (0 >= g_slist_length(g_config_client_list)) {
1195 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1196 return STT_CONFIG_ERROR_INVALID_STATE;
1199 if (0 >= g_slist_length(g_engine_list)) {
1200 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1201 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1204 GSList *iter = NULL;
1205 stt_engine_info_s *engine_info = NULL;
1207 /* Get a first item */
1208 iter = g_slist_nth(g_engine_list, 0);
1210 while (NULL != iter) {
1211 engine_info = iter->data;
1213 if (NULL == engine_info) {
1214 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1215 return STT_CONFIG_ERROR_OPERATION_FAILED;
1218 if (0 != strcmp(engine_id, engine_info->uuid)) {
1219 iter = g_slist_next(iter);
1223 GSList *iter_lang = NULL;
1226 /* Get a first item */
1227 iter_lang = g_slist_nth(engine_info->languages, 0);
1229 while (NULL != iter_lang) {
1230 /*Get handle data from list*/
1231 lang = iter_lang->data;
1233 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1235 if (false == callback(engine_info->uuid, lang, user_data))
1240 iter_lang = g_slist_next(iter_lang);
1245 return STT_CONFIG_ERROR_NONE;
1248 int stt_config_mgr_get_default_language(char** language)
1250 if (0 >= g_slist_length(g_config_client_list)) {
1251 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1252 return STT_CONFIG_ERROR_INVALID_STATE;
1255 if (NULL == language) {
1256 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1259 if (NULL != g_config_info->language) {
1260 *language = strdup(g_config_info->language);
1262 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1263 return STT_CONFIG_ERROR_OPERATION_FAILED;
1266 return STT_CONFIG_ERROR_NONE;
1269 int stt_config_mgr_set_default_language(const char* language)
1271 if (0 >= g_slist_length(g_config_client_list)) {
1272 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1273 return STT_CONFIG_ERROR_INVALID_STATE;
1276 if (NULL == language) {
1277 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1280 /* Check language is valid */
1281 if (NULL != g_config_info->language) {
1282 if (0 != stt_parser_set_language(language)) {
1283 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1284 return STT_CONFIG_ERROR_OPERATION_FAILED;
1286 free(g_config_info->language);
1287 g_config_info->language = strdup(language);
1289 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1290 return STT_CONFIG_ERROR_OPERATION_FAILED;
1293 return STT_CONFIG_ERROR_NONE;
1296 int stt_config_mgr_get_auto_language(bool* value)
1298 if (0 >= g_slist_length(g_config_client_list)) {
1299 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1300 return STT_CONFIG_ERROR_INVALID_STATE;
1303 if (NULL == value) {
1304 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1307 *value = g_config_info->auto_lang;
1309 return STT_CONFIG_ERROR_NONE;
1312 int stt_config_mgr_set_auto_language(bool value)
1314 if (0 >= g_slist_length(g_config_client_list)) {
1315 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1316 return STT_CONFIG_ERROR_INVALID_STATE;
1319 if (g_config_info->auto_lang != value) {
1320 /* Check language is valid */
1321 if (0 != stt_parser_set_auto_lang(value)) {
1322 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1323 return STT_CONFIG_ERROR_OPERATION_FAILED;
1325 g_config_info->auto_lang = value;
1327 if (true == g_config_info->auto_lang) {
1328 __stt_config_set_auto_language();
1332 return STT_CONFIG_ERROR_NONE;
1335 int stt_config_mgr_get_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;
1343 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1345 *value = g_config_info->silence_detection;
1347 return STT_CONFIG_ERROR_NONE;
1350 int stt_config_mgr_set_silence_detection(bool value)
1352 if (0 >= g_slist_length(g_config_client_list)) {
1353 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1354 return STT_CONFIG_ERROR_INVALID_STATE;
1357 if (0 != stt_parser_set_silence_detection(value)) {
1358 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1359 return STT_CONFIG_ERROR_OPERATION_FAILED;
1362 g_config_info->silence_detection = value;
1364 return STT_CONFIG_ERROR_NONE;
1367 bool stt_config_check_default_engine_is_valid(const char* engine)
1369 if (0 >= g_slist_length(g_config_client_list)) {
1370 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1374 if (NULL == engine) {
1378 if (0 >= g_slist_length(g_engine_list))
1381 GSList *iter = NULL;
1382 stt_engine_info_s *engine_info = NULL;
1384 /* Get a first item */
1385 iter = g_slist_nth(g_engine_list, 0);
1387 while (NULL != iter) {
1388 engine_info = iter->data;
1390 if (NULL != engine_info) {
1391 if (0 == strcmp(engine, engine_info->uuid)) {
1395 iter = g_slist_next(iter);
1401 bool stt_config_check_default_language_is_valid(const char* language)
1403 if (0 >= g_slist_length(g_config_client_list)) {
1404 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1408 if (NULL == language) {
1412 if (NULL == g_config_info->engine_id) {
1413 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1417 if (0 >= g_slist_length(g_engine_list))
1420 GSList *iter = NULL;
1421 stt_engine_info_s *engine_info = NULL;
1423 /* Get a first item */
1424 iter = g_slist_nth(g_engine_list, 0);
1426 while (NULL != iter) {
1427 engine_info = iter->data;
1429 if (NULL == engine_info) {
1430 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1431 iter = g_slist_next(iter);
1435 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1436 iter = g_slist_next(iter);
1440 GSList *iter_lang = NULL;
1443 /* Get a first item */
1444 iter_lang = g_slist_nth(engine_info->languages, 0);
1446 while (NULL != iter_lang) {
1447 lang = iter_lang->data;
1449 if (0 == strcmp(language, lang))
1453 iter_lang = g_slist_next(iter_lang);
1461 int __stt_config_mgr_print_engine_info()
1463 GSList *iter = NULL;
1464 stt_engine_info_s *engine_info = NULL;
1466 if (0 >= g_slist_length(g_engine_list)) {
1467 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1468 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1469 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1473 /* Get a first item */
1474 iter = g_slist_nth(g_engine_list, 0);
1476 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1479 while (NULL != iter) {
1480 engine_info = iter->data;
1482 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1483 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1484 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1485 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1486 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1488 SLOG(LOG_DEBUG, stt_tag(), " languages");
1489 GSList *iter_lang = NULL;
1491 if (g_slist_length(engine_info->languages) > 0) {
1492 /* Get a first item */
1493 iter_lang = g_slist_nth(engine_info->languages, 0);
1496 while (NULL != iter_lang) {
1497 /*Get handle data from list*/
1498 lang = iter_lang->data;
1500 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1503 iter_lang = g_slist_next(iter_lang);
1507 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1509 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1510 engine_info->support_silence_detection ? "true" : "false");
1511 iter = g_slist_next(iter);
1514 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1522 * time info functions
1524 static GSList* g_time_list = NULL;
1526 int stt_config_mgr_reset_time_info()
1528 /* Remove time info */
1529 GSList *iter = NULL;
1530 stt_result_time_info_s *data = NULL;
1532 /* Remove time info */
1533 iter = g_slist_nth(g_time_list, 0);
1534 while (NULL != iter) {
1537 g_time_list = g_slist_remove(g_time_list, data);
1539 if (NULL != data->text) {
1548 iter = g_slist_nth(g_time_list, 0);
1554 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1557 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1561 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1563 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1564 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1566 info->index = index;
1567 info->event = event;
1569 info->text = strdup(text);
1571 info->start_time = start_time;
1572 info->end_time = end_time;
1574 /* Add item to global list */
1575 g_time_list = g_slist_append(g_time_list, info);
1580 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1582 if (NULL == callback) {
1583 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1584 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1587 GSList* temp_time = NULL;
1589 ret = stt_parser_get_time_info(&temp_time);
1591 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1592 return STT_CONFIG_ERROR_OPERATION_FAILED;
1595 GSList *iter = NULL;
1596 stt_result_time_info_s *data = NULL;
1598 /* Get a first item */
1599 iter = g_slist_nth(temp_time, 0);
1600 while (NULL != iter) {
1603 if (false == callback(data->index, data->event, data->text,
1604 data->start_time, data->end_time, user_data)) {
1609 iter = g_slist_next(iter);
1612 /* Remove time info */
1613 iter = g_slist_nth(temp_time, 0);
1614 while (NULL != iter) {
1618 temp_time = g_slist_remove(temp_time, data);
1620 if (NULL != data->text) {
1629 iter = g_slist_nth(temp_time, 0);
1632 return STT_CONFIG_ERROR_NONE;
1635 int stt_config_mgr_save_time_info_file()
1637 if (0 == g_slist_length(g_time_list)) {
1638 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1639 return STT_CONFIG_ERROR_OPERATION_FAILED;
1643 ret = stt_parser_set_time_info(g_time_list);
1645 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1646 return STT_CONFIG_ERROR_OPERATION_FAILED;
1649 return STT_CONFIG_ERROR_NONE;
1652 int stt_config_mgr_remove_time_info_file()
1654 stt_parser_clear_time_info();
1656 return STT_CONFIG_ERROR_NONE;