2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
20 #include <sys/inotify.h>
23 #include "stt_config_mgr.h"
25 #include "stt_config_parser.h"
30 stt_config_engine_changed_cb engine_cb;
31 stt_config_lang_changed_cb lang_cb;
32 stt_config_bool_changed_cb bool_cb;
34 } stt_config_client_s;
37 extern const char* stt_tag();
39 static GSList* g_engine_list = NULL;
41 static GSList* g_config_client_list = NULL;
43 static stt_config_s* g_config_info;
45 static Ecore_Fd_Handler* g_fd_handler_noti = NULL;
49 int __stt_config_mgr_print_engine_info();
51 bool __stt_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
53 if (NULL == engine_id || NULL == language) {
54 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
59 stt_engine_info_s *engine_info = NULL;
61 if (0 >= g_slist_length(g_engine_list)) {
62 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
66 /* Get a first item */
67 iter = g_slist_nth(g_engine_list, 0);
69 while (NULL != iter) {
70 engine_info = iter->data;
72 if (NULL == engine_info) {
73 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
77 if (0 != strcmp(engine_id, engine_info->uuid)) {
78 iter = g_slist_next(iter);
82 GSList *iter_lang = NULL;
84 if (g_slist_length(engine_info->languages) > 0) {
85 /* Get a first item */
86 iter_lang = g_slist_nth(engine_info->languages, 0);
89 while (NULL != iter_lang) {
90 /*Get handle data from list*/
91 engine_lang = iter_lang->data;
93 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", i, engine_lang);
95 if (0 == strcmp(language, engine_lang)) {
100 iter_lang = g_slist_next(iter_lang);
110 int __stt_config_mgr_select_lang(const char* engine_id, char** language)
112 if (NULL == engine_id || NULL == language) {
113 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
118 stt_engine_info_s *engine_info = NULL;
120 if (0 >= g_slist_length(g_engine_list)) {
121 SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
125 /* Get a first item */
126 iter = g_slist_nth(g_engine_list, 0);
128 while (NULL != iter) {
129 engine_info = iter->data;
131 if (NULL == engine_info) {
132 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
136 if (0 != strcmp(engine_id, engine_info->uuid)) {
137 iter = g_slist_next(iter);
141 GSList *iter_lang = NULL;
142 char* engine_lang = NULL;
143 if (g_slist_length(engine_info->languages) > 0) {
144 /* Get a first item */
145 iter_lang = g_slist_nth(engine_info->languages, 0);
147 while (NULL != iter_lang) {
148 engine_lang = iter_lang->data;
149 if (NULL != engine_lang) {
150 /* Default language is STT_BASE_LANGUAGE */
151 if (0 == strcmp(STT_BASE_LANGUAGE, engine_lang)) {
152 *language = strdup(engine_lang);
153 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", (NULL == *language) ? "NULL" : *language);
158 iter_lang = g_slist_next(iter_lang);
161 /* Not support STT_BASE_LANGUAGE */
162 if (NULL != engine_lang) {
163 *language = strdup(engine_lang);
164 SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", (NULL == *language) ? "NULL" : *language);
174 Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
176 SLOG(LOG_DEBUG, stt_tag(), "===== Config changed callback event");
179 struct inotify_event event;
180 memset(&event, '\0', sizeof(struct inotify_event));
182 length = read(g_fd_noti, &event, sizeof(struct inotify_event));
184 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty Inotify event");
185 SLOG(LOG_DEBUG, stt_tag(), "=====");
186 SLOG(LOG_DEBUG, stt_tag(), " ");
187 return ECORE_CALLBACK_PASS_ON;
190 if (IN_MODIFY == event.mask) {
192 char* setting = NULL;
199 stt_config_client_s* temp_client = NULL;
201 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
202 return ECORE_CALLBACK_PASS_ON;
205 if (NULL != engine || NULL != setting) {
207 if (NULL != engine) {
208 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
209 g_config_info->engine_id = strdup(engine);
212 if (NULL != setting) {
213 if (NULL != g_config_info->setting) free(g_config_info->setting);
214 g_config_info->setting = strdup(setting);
218 if (NULL != g_config_info->language) free(g_config_info->language);
219 g_config_info->language = strdup(lang);
222 if (-1 != silence) g_config_info->silence_detection = silence;
224 if (-1 != credential) g_config_info->credential = credential;
226 /* Call all callbacks of client*/
227 iter = g_slist_nth(g_config_client_list, 0);
229 while (NULL != iter) {
230 temp_client = iter->data;
232 if (NULL != temp_client) {
233 if (NULL != temp_client->engine_cb) {
234 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
235 g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
239 iter = g_slist_next(iter);
243 if (-1 != auto_lang) {
244 g_config_info->auto_lang = auto_lang;
247 /* Only language changed */
248 if (NULL == engine && NULL != lang) {
249 char* before_lang = NULL;
250 before_lang = strdup(g_config_info->language);
253 if (NULL != g_config_info->language) free(g_config_info->language);
254 g_config_info->language = strdup(lang);
257 /* Call all callbacks of client*/
258 iter = g_slist_nth(g_config_client_list, 0);
260 while (NULL != iter) {
261 temp_client = iter->data;
263 if (NULL != temp_client) {
264 if (NULL != temp_client->lang_cb) {
265 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
269 iter = g_slist_next(iter);
272 if (NULL != before_lang) {
278 /* silence detection changed */
279 g_config_info->silence_detection = silence;
281 /* Call all callbacks of client*/
282 iter = g_slist_nth(g_config_client_list, 0);
284 while (NULL != iter) {
285 temp_client = iter->data;
287 if (NULL != temp_client) {
288 if (NULL != temp_client->bool_cb) {
289 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
293 iter = g_slist_next(iter);
297 if (NULL != engine) free(engine);
298 if (NULL != setting) free(setting);
299 if (NULL != lang) free(lang);
301 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Undefined event");
304 SLOG(LOG_DEBUG, stt_tag(), "=====");
305 SLOG(LOG_DEBUG, stt_tag(), " ");
307 return ECORE_CALLBACK_PASS_ON;
310 int __stt_config_mgr_register_config_event()
312 /* get file notification handler */
318 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail get inotify fd");
323 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
326 g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
327 if (NULL == g_fd_handler_noti) {
328 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
335 int __stt_config_mgr_unregister_config_event()
337 /* delete inotify variable */
338 ecore_main_fd_handler_del(g_fd_handler_noti);
339 inotify_rm_watch(g_fd_noti, g_wd_noti);
345 int __stt_config_set_auto_language()
348 char candidate_lang[6] = {'\0', };
350 value = vconf_get_str(VCONFKEY_LANGSET);
352 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
356 strncpy(candidate_lang, value, 5);
359 /* Check current config info */
360 if (NULL == g_config_info) {
361 SLOG(LOG_ERROR, stt_tag(), "Current config info is NULL");
362 return STT_CONFIG_ERROR_OPERATION_FAILED;
365 /* Check current language */
366 if (NULL == g_config_info->language) {
367 SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
368 return STT_CONFIG_ERROR_OPERATION_FAILED;
371 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
372 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
375 SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
378 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
379 char* before_lang = NULL;
380 if (0 != stt_parser_set_language(candidate_lang)) {
381 SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
385 before_lang = strdup(g_config_info->language);
387 free(g_config_info->language);
388 g_config_info->language = strdup(candidate_lang);
390 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
392 /* Call all callbacks of client*/
394 stt_config_client_s* temp_client = NULL;
396 iter = g_slist_nth(g_config_client_list, 0);
398 while (NULL != iter) {
399 temp_client = iter->data;
401 if (NULL != temp_client) {
402 if (NULL != temp_client->lang_cb) {
403 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
407 iter = g_slist_next(iter);
410 if (NULL != before_lang) {
414 /* Candidate language is not valid */
415 char* tmp_language = NULL;
416 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
417 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
421 if (NULL == tmp_language) {
422 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Selected language is NULL");
426 if (0 != stt_parser_set_language(tmp_language)) {
428 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save config");
432 SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
434 /* Call all callbacks of client*/
436 stt_config_client_s* temp_client = NULL;
438 iter = g_slist_nth(g_config_client_list, 0);
440 while (NULL != iter) {
441 temp_client = iter->data;
443 if (NULL != temp_client) {
444 if (NULL != temp_client->lang_cb) {
445 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
449 iter = g_slist_next(iter);
452 free(g_config_info->language);
453 g_config_info->language = strdup(tmp_language);
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);
564 SLOG(LOG_ERROR, stt_tag(), "Operation failed - false engine");
565 return STT_CONFIG_ERROR_OPERATION_FAILED;
568 engine_info = iter->data;
569 if (NULL == engine_info) {
570 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
571 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
574 if (NULL != g_config_info->engine_id) {
575 free(g_config_info->engine_id);
576 g_config_info->engine_id = NULL;
578 if (NULL != g_config_info->setting) {
579 free(g_config_info->setting);
580 g_config_info->setting = NULL;
583 if (NULL != engine_info->uuid) {
584 g_config_info->engine_id = strdup(engine_info->uuid);
587 if (NULL != engine_info->setting) {
588 g_config_info->setting = strdup(engine_info->setting);
592 GSList *iter_lang = NULL;
594 bool is_valid_lang = false;
596 if (0 >= g_slist_length(engine_info->languages)) {
597 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
598 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
601 /* Get a first item */
602 iter_lang = g_slist_nth(engine_info->languages, 0);
604 while (NULL != iter_lang) {
605 /*Get handle data from list*/
606 lang = iter_lang->data;
608 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
610 if (0 == strcmp(lang, g_config_info->language)) {
611 /* language is valid */
612 is_valid_lang = true;
618 iter_lang = g_slist_next(iter_lang);
621 if (false == is_valid_lang) {
622 iter_lang = g_slist_nth(engine_info->languages, 0);
623 if (NULL != iter_lang) {
624 lang = iter_lang->data;
626 if (NULL != g_config_info->language)
627 free(g_config_info->language);
628 g_config_info->language = strdup(lang);
634 if (false == engine_info->support_silence_detection) {
635 if (true == g_config_info->silence_detection)
636 g_config_info->silence_detection = false;
639 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
640 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
641 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
642 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
643 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
644 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
646 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
647 g_config_info->silence_detection, g_config_info->credential)) {
648 SLOG(LOG_ERROR, stt_tag(), "Fail to save config");
649 return STT_CONFIG_ERROR_OPERATION_FAILED;
652 return STT_CONFIG_ERROR_NONE;
655 int stt_config_mgr_initialize(int uid)
659 stt_config_client_s* temp_client = NULL;
661 if (0 < g_slist_length(g_config_client_list)) {
663 iter = g_slist_nth(g_config_client_list, 0);
665 while (NULL != iter) {
666 get_uid = iter->data;
668 if (uid == *get_uid) {
669 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
673 iter = g_slist_next(iter);
676 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
677 if (NULL == temp_client) {
678 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
679 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
681 temp_client->uid = uid;
682 temp_client->bool_cb = NULL;
683 temp_client->engine_cb = NULL;
684 temp_client->lang_cb = NULL;
685 temp_client->user_data = NULL;
688 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
690 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
691 return STT_CONFIG_ERROR_NONE;
694 /* Get file name from default engine directory */
698 struct dirent *dirp = NULL;
700 g_engine_list = NULL;
702 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
703 dp = opendir(STT_DEFAULT_ENGINE_INFO);
706 ret = readdir_r(dp, &entry, &dirp);
708 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
713 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
716 stt_engine_info_s* info;
720 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
721 filepath = (char*)calloc(filesize, sizeof(char));
723 if (NULL != filepath) {
724 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
726 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
730 if (0 == stt_parser_get_engine_info(filepath, &info)) {
731 g_engine_list = g_slist_append(g_engine_list, info);
734 if (NULL != filepath)
737 } while (NULL != dirp);
741 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
744 __stt_config_mgr_print_engine_info();
746 if (0 != stt_parser_load_config(&g_config_info)) {
747 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
748 __stt_config_release_client(uid);
749 __stt_config_release_engine();
750 return STT_CONFIG_ERROR_OPERATION_FAILED;
753 /* Check whether engine id is valid */
754 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
755 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
756 __stt_config_release_client(uid);
757 __stt_config_release_engine();
758 stt_parser_unload_config(g_config_info);
759 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
762 if (true == g_config_info->auto_lang) {
763 /* Check language with display language */
764 __stt_config_set_auto_language();
766 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
767 /* Default language is not valid */
769 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
770 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
771 __stt_config_release_client(uid);
772 __stt_config_release_engine();
773 stt_parser_unload_config(g_config_info);
774 return STT_CONFIG_ERROR_OPERATION_FAILED;
777 if (NULL != tmp_language) {
778 if (NULL != g_config_info->language) {
779 free(g_config_info->language);
780 g_config_info->language = strdup(tmp_language);
788 /* print daemon config */
789 SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
790 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
791 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
792 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
793 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
794 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
795 SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
796 SLOG(LOG_DEBUG, stt_tag(), "===================");
798 if (0 != __stt_config_mgr_register_config_event()) {
799 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
800 __stt_config_release_client(uid);
801 __stt_config_release_engine();
802 stt_parser_unload_config(g_config_info);
803 return STT_CONFIG_ERROR_OPERATION_FAILED;
806 /* Register to detect display language change */
807 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
809 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
810 if (NULL == temp_client) {
811 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
812 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
814 temp_client->uid = uid;
815 temp_client->bool_cb = NULL;
816 temp_client->engine_cb = NULL;
817 temp_client->lang_cb = NULL;
818 temp_client->user_data = NULL;
821 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
823 return STT_CONFIG_ERROR_NONE;
826 int stt_config_mgr_finalize(int uid)
829 stt_config_client_s* temp_client = NULL;
831 if (0 < g_slist_length(g_config_client_list)) {
833 iter = g_slist_nth(g_config_client_list, 0);
835 while (NULL != iter) {
836 temp_client = iter->data;
838 if (NULL != temp_client) {
839 if (uid == temp_client->uid) {
840 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
847 iter = g_slist_next(iter);
851 if (0 < g_slist_length(g_config_client_list)) {
852 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
853 return STT_CONFIG_ERROR_NONE;
856 stt_engine_info_s *engine_info = NULL;
858 if (0 < g_slist_length(g_engine_list)) {
860 /* Get a first item */
861 iter = g_slist_nth(g_engine_list, 0);
863 while (NULL != iter) {
864 engine_info = iter->data;
866 if (NULL != engine_info) {
867 g_engine_list = g_slist_remove(g_engine_list, engine_info);
869 stt_parser_free_engine_info(engine_info);
872 iter = g_slist_nth(g_engine_list, 0);
876 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
878 __stt_config_mgr_unregister_config_event();
880 if (NULL != g_config_info) {
881 stt_parser_unload_config(g_config_info);
882 g_config_info = NULL;
885 return STT_CONFIG_ERROR_NONE;
888 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)
891 stt_config_client_s* temp_client = NULL;
893 /* Call all callbacks of client*/
894 iter = g_slist_nth(g_config_client_list, 0);
896 while (NULL != iter) {
897 temp_client = iter->data;
899 if (NULL != temp_client) {
900 if (uid == temp_client->uid) {
901 temp_client->engine_cb = engine_cb;
902 temp_client->lang_cb = lang_cb;
903 temp_client->bool_cb = bool_cb;
904 temp_client->user_data = user_data;
908 iter = g_slist_next(iter);
911 return STT_CONFIG_ERROR_NONE;
914 int stt_config_mgr_unset_callback(int uid)
917 stt_config_client_s* temp_client = NULL;
919 /* Call all callbacks of client*/
920 iter = g_slist_nth(g_config_client_list, 0);
922 while (NULL != iter) {
923 temp_client = iter->data;
925 if (NULL != temp_client) {
926 if (uid == temp_client->uid) {
927 temp_client->engine_cb = NULL;
928 temp_client->lang_cb = NULL;
929 temp_client->bool_cb = NULL;
930 temp_client->user_data = NULL;
934 iter = g_slist_next(iter);
937 return STT_CONFIG_ERROR_NONE;
940 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
942 if (0 >= g_slist_length(g_config_client_list)) {
943 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
944 return STT_CONFIG_ERROR_INVALID_STATE;
947 if (NULL == callback) {
948 return STT_CONFIG_ERROR_INVALID_PARAMETER;
952 stt_engine_info_s *engine_info = NULL;
954 if (0 >= g_slist_length(g_engine_list)) {
955 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
956 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
959 /* Get a first item */
960 iter = g_slist_nth(g_engine_list, 0);
962 while (NULL != iter) {
963 engine_info = iter->data;
965 if (NULL == engine_info) {
966 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
967 return STT_CONFIG_ERROR_OPERATION_FAILED;
970 if (false == callback(engine_info->uuid, engine_info->name,
971 engine_info->setting, engine_info->support_silence_detection, user_data)) {
975 iter = g_slist_next(iter);
978 return STT_CONFIG_ERROR_NONE;
981 int stt_config_mgr_get_engine(char** engine)
983 if (0 >= g_slist_length(g_config_client_list)) {
984 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
985 return STT_CONFIG_ERROR_INVALID_STATE;
988 if (NULL == engine) {
989 return STT_CONFIG_ERROR_INVALID_PARAMETER;
992 if (NULL != g_config_info->engine_id) {
993 *engine = strdup(g_config_info->engine_id);
995 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
996 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
999 return STT_CONFIG_ERROR_NONE;
1002 int stt_config_mgr_set_engine(const char* engine)
1004 if (0 >= g_slist_length(g_config_client_list)) {
1005 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1006 return STT_CONFIG_ERROR_INVALID_STATE;
1009 if (NULL == g_config_info) {
1010 return STT_CONFIG_ERROR_OPERATION_FAILED;
1013 if (NULL == engine || NULL == g_config_info->engine_id) {
1014 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1017 /* Check current engine id with new engine id */
1018 if (0 == strcmp(g_config_info->engine_id, engine)) {
1022 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1024 GSList *iter = NULL;
1025 stt_engine_info_s *engine_info = NULL;
1026 bool is_valid_engine = false;
1028 /* Get a first item */
1029 iter = g_slist_nth(g_engine_list, 0);
1031 while (NULL != iter) {
1032 engine_info = iter->data;
1034 if (NULL == engine_info) {
1035 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1036 iter = g_slist_next(iter);
1040 /* Check engine id is valid */
1041 if (0 != strcmp(engine, engine_info->uuid)) {
1042 iter = g_slist_next(iter);
1046 if (NULL != g_config_info->engine_id)
1047 free(g_config_info->engine_id);
1049 g_config_info->engine_id = strdup(engine);
1051 if (NULL != g_config_info->setting) {
1052 free(g_config_info->setting);
1055 if (NULL != engine_info->setting) {
1056 g_config_info->setting = strdup(engine_info->setting);
1058 g_config_info->setting = NULL;
1061 /* Engine is valid*/
1062 GSList *iter_lang = NULL;
1064 bool is_valid_lang = false;
1066 /* Get a first item */
1067 iter_lang = g_slist_nth(engine_info->languages, 0);
1069 while (NULL != iter_lang) {
1070 /*Get handle data from list*/
1071 lang = iter_lang->data;
1073 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1074 if (NULL != lang && NULL != g_config_info->language) {
1075 if (0 == strcmp(lang, g_config_info->language)) {
1076 /* language is valid */
1077 is_valid_lang = true;
1079 free(g_config_info->language);
1080 g_config_info->language = strdup(lang);
1087 iter_lang = g_slist_next(iter_lang);
1090 if (false == is_valid_lang) {
1091 if (NULL != g_config_info->language) {
1092 free(g_config_info->language);
1093 g_config_info->language = NULL;
1095 iter_lang = g_slist_nth(engine_info->languages, 0);
1096 if (NULL == iter_lang) {
1097 SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
1101 lang = iter_lang->data;
1103 g_config_info->language = strdup(lang);
1108 if (false == engine_info->support_silence_detection) {
1109 if (true == g_config_info->silence_detection)
1110 g_config_info->silence_detection = false;
1113 if (false == engine_info->need_credential) {
1114 if (true == g_config_info->credential)
1115 g_config_info->credential = false;
1118 is_valid_engine = true;
1122 if (true == is_valid_engine) {
1123 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1124 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1125 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1126 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1127 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1128 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1130 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1131 g_config_info->silence_detection, g_config_info->credential)) {
1132 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1133 return STT_CONFIG_ERROR_OPERATION_FAILED;
1136 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1137 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1143 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1145 if (0 >= g_slist_length(g_engine_list)) {
1146 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1147 return STT_CONFIG_ERROR_INVALID_STATE;
1150 if (NULL == agreement) {
1151 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1152 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1155 GSList *iter = NULL;
1156 stt_engine_info_s *engine_info = NULL;
1157 char* current_engine = NULL;
1159 if (NULL == engine) {
1160 current_engine = strdup(g_config_info->engine_id);
1161 if (NULL == current_engine) {
1162 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1163 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1166 current_engine = strdup(engine);
1167 if (NULL == current_engine) {
1168 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1169 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1173 /* Get a first item */
1174 iter = g_slist_nth(g_engine_list, 0);
1176 while (NULL != iter) {
1177 engine_info = iter->data;
1179 if (NULL == engine_info) {
1180 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1181 if (NULL != current_engine) free(current_engine);
1182 return STT_CONFIG_ERROR_OPERATION_FAILED;
1185 if (0 != strcmp(current_engine, engine_info->uuid)) {
1186 iter = g_slist_next(iter);
1190 if (NULL != engine_info->agreement) {
1191 *agreement = strdup(engine_info->agreement);
1193 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1198 if (NULL != current_engine) free(current_engine);
1200 return STT_CONFIG_ERROR_NONE;
1203 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1205 if (0 >= g_slist_length(g_config_client_list)) {
1206 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1207 return STT_CONFIG_ERROR_INVALID_STATE;
1210 if (0 >= g_slist_length(g_engine_list)) {
1211 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1212 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1215 GSList *iter = NULL;
1216 stt_engine_info_s *engine_info = NULL;
1218 /* Get a first item */
1219 iter = g_slist_nth(g_engine_list, 0);
1221 while (NULL != iter) {
1222 engine_info = iter->data;
1224 if (NULL == engine_info) {
1225 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1226 return STT_CONFIG_ERROR_OPERATION_FAILED;
1229 if (0 != strcmp(engine_id, engine_info->uuid)) {
1230 iter = g_slist_next(iter);
1234 GSList *iter_lang = NULL;
1237 /* Get a first item */
1238 iter_lang = g_slist_nth(engine_info->languages, 0);
1240 while (NULL != iter_lang) {
1241 /*Get handle data from list*/
1242 lang = iter_lang->data;
1245 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1246 if (false == callback(engine_info->uuid, lang, user_data))
1251 iter_lang = g_slist_next(iter_lang);
1256 return STT_CONFIG_ERROR_NONE;
1259 int stt_config_mgr_get_default_language(char** language)
1261 if (0 >= g_slist_length(g_config_client_list)) {
1262 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1263 return STT_CONFIG_ERROR_INVALID_STATE;
1266 if (NULL == language) {
1267 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1270 if (NULL != g_config_info->language) {
1271 *language = strdup(g_config_info->language);
1273 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1274 return STT_CONFIG_ERROR_OPERATION_FAILED;
1277 return STT_CONFIG_ERROR_NONE;
1280 int stt_config_mgr_set_default_language(const char* language)
1282 if (0 >= g_slist_length(g_config_client_list)) {
1283 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1284 return STT_CONFIG_ERROR_INVALID_STATE;
1287 if (NULL == language) {
1288 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1291 /* Check language is valid */
1292 if (NULL != g_config_info->language) {
1293 if (0 != stt_parser_set_language(language)) {
1294 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1295 return STT_CONFIG_ERROR_OPERATION_FAILED;
1297 free(g_config_info->language);
1298 g_config_info->language = strdup(language);
1300 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1301 return STT_CONFIG_ERROR_OPERATION_FAILED;
1304 return STT_CONFIG_ERROR_NONE;
1307 int stt_config_mgr_get_auto_language(bool* value)
1309 if (0 >= g_slist_length(g_config_client_list)) {
1310 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1311 return STT_CONFIG_ERROR_INVALID_STATE;
1314 if (NULL == value) {
1315 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1318 *value = g_config_info->auto_lang;
1320 return STT_CONFIG_ERROR_NONE;
1323 int stt_config_mgr_set_auto_language(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;
1330 if (g_config_info->auto_lang != value) {
1331 /* Check language is valid */
1332 if (0 != stt_parser_set_auto_lang(value)) {
1333 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1334 return STT_CONFIG_ERROR_OPERATION_FAILED;
1336 g_config_info->auto_lang = value;
1338 if (true == g_config_info->auto_lang) {
1339 __stt_config_set_auto_language();
1343 return STT_CONFIG_ERROR_NONE;
1346 int stt_config_mgr_get_silence_detection(bool* value)
1348 if (0 >= g_slist_length(g_config_client_list)) {
1349 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1350 return STT_CONFIG_ERROR_INVALID_STATE;
1354 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1356 *value = g_config_info->silence_detection;
1358 return STT_CONFIG_ERROR_NONE;
1361 int stt_config_mgr_set_silence_detection(bool value)
1363 if (0 >= g_slist_length(g_config_client_list)) {
1364 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1365 return STT_CONFIG_ERROR_INVALID_STATE;
1368 if (0 != stt_parser_set_silence_detection(value)) {
1369 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1370 return STT_CONFIG_ERROR_OPERATION_FAILED;
1373 g_config_info->silence_detection = value;
1375 return STT_CONFIG_ERROR_NONE;
1378 bool stt_config_check_default_engine_is_valid(const char* engine)
1380 if (0 >= g_slist_length(g_config_client_list)) {
1381 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1385 if (NULL == engine) {
1389 if (0 >= g_slist_length(g_engine_list))
1392 GSList *iter = NULL;
1393 stt_engine_info_s *engine_info = NULL;
1395 /* Get a first item */
1396 iter = g_slist_nth(g_engine_list, 0);
1398 while (NULL != iter) {
1399 engine_info = iter->data;
1401 if (NULL != engine_info) {
1402 if (0 == strcmp(engine, engine_info->uuid)) {
1406 iter = g_slist_next(iter);
1412 bool stt_config_check_default_language_is_valid(const char* language)
1414 if (0 >= g_slist_length(g_config_client_list)) {
1415 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1419 if (NULL == language) {
1423 if (NULL == g_config_info->engine_id) {
1424 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1428 if (0 >= g_slist_length(g_engine_list))
1431 GSList *iter = NULL;
1432 stt_engine_info_s *engine_info = NULL;
1434 /* Get a first item */
1435 iter = g_slist_nth(g_engine_list, 0);
1437 while (NULL != iter) {
1438 engine_info = iter->data;
1440 if (NULL == engine_info) {
1441 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1442 iter = g_slist_next(iter);
1446 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1447 iter = g_slist_next(iter);
1451 GSList *iter_lang = NULL;
1454 /* Get a first item */
1455 iter_lang = g_slist_nth(engine_info->languages, 0);
1457 while (NULL != iter_lang) {
1458 lang = iter_lang->data;
1460 if (0 == strcmp(language, lang))
1464 iter_lang = g_slist_next(iter_lang);
1472 int __stt_config_mgr_print_engine_info()
1474 GSList *iter = NULL;
1475 stt_engine_info_s *engine_info = NULL;
1477 if (0 >= g_slist_length(g_engine_list)) {
1478 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1479 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1480 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1484 /* Get a first item */
1485 iter = g_slist_nth(g_engine_list, 0);
1487 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1490 while (NULL != iter) {
1491 engine_info = iter->data;
1493 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1494 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1495 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1496 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1497 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1499 SLOG(LOG_DEBUG, stt_tag(), " languages");
1500 GSList *iter_lang = NULL;
1502 if (g_slist_length(engine_info->languages) > 0) {
1503 /* Get a first item */
1504 iter_lang = g_slist_nth(engine_info->languages, 0);
1507 while (NULL != iter_lang) {
1508 /*Get handle data from list*/
1509 lang = iter_lang->data;
1511 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1514 iter_lang = g_slist_next(iter_lang);
1518 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1520 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1521 engine_info->support_silence_detection ? "true" : "false");
1522 iter = g_slist_next(iter);
1525 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1533 * time info functions
1535 static GSList* g_time_list = NULL;
1537 int stt_config_mgr_reset_time_info()
1539 /* Remove time info */
1540 GSList *iter = NULL;
1541 stt_result_time_info_s *data = NULL;
1543 /* Remove time info */
1544 iter = g_slist_nth(g_time_list, 0);
1545 while (NULL != iter) {
1548 g_time_list = g_slist_remove(g_time_list, data);
1550 if (NULL != data->text) {
1559 iter = g_slist_nth(g_time_list, 0);
1565 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1568 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1572 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1574 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1575 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1577 info->index = index;
1578 info->event = event;
1580 info->text = strdup(text);
1582 info->start_time = start_time;
1583 info->end_time = end_time;
1585 /* Add item to global list */
1586 g_time_list = g_slist_append(g_time_list, info);
1591 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1593 if (NULL == callback) {
1594 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1595 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1598 GSList* temp_time = NULL;
1600 ret = stt_parser_get_time_info(&temp_time);
1602 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1603 return STT_CONFIG_ERROR_OPERATION_FAILED;
1606 GSList *iter = NULL;
1607 stt_result_time_info_s *data = NULL;
1609 /* Get a first item */
1610 iter = g_slist_nth(temp_time, 0);
1611 while (NULL != iter) {
1614 if (false == callback(data->index, data->event, data->text,
1615 data->start_time, data->end_time, user_data)) {
1620 iter = g_slist_next(iter);
1623 /* Remove time info */
1624 iter = g_slist_nth(temp_time, 0);
1625 while (NULL != iter) {
1629 temp_time = g_slist_remove(temp_time, data);
1631 if (NULL != data->text) {
1640 iter = g_slist_nth(temp_time, 0);
1643 return STT_CONFIG_ERROR_NONE;
1646 int stt_config_mgr_save_time_info_file()
1648 if (0 == g_slist_length(g_time_list)) {
1649 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1650 return STT_CONFIG_ERROR_OPERATION_FAILED;
1654 ret = stt_parser_set_time_info(g_time_list);
1656 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1657 return STT_CONFIG_ERROR_OPERATION_FAILED;
1660 return STT_CONFIG_ERROR_NONE;
1663 int stt_config_mgr_remove_time_info_file()
1665 stt_parser_clear_time_info();
1667 return STT_CONFIG_ERROR_NONE;