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);
462 void __stt_config_language_changed_cb(keynode_t *key, void *data)
464 if (true == g_config_info->auto_lang) {
465 /* Get voice input vconf key */
466 __stt_config_set_auto_language();
472 void __stt_config_release_client(int uid)
475 stt_config_client_s* temp_client = NULL;
477 if (0 < g_slist_length(g_config_client_list)) {
479 iter = g_slist_nth(g_config_client_list, 0);
481 while (NULL != iter) {
482 temp_client = iter->data;
484 if (NULL != temp_client) {
485 if (uid == temp_client->uid) {
486 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
493 iter = g_slist_next(iter);
497 if (0 < g_slist_length(g_config_client_list)) {
498 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
503 void __stt_config_release_engine()
506 stt_engine_info_s *engine_info = NULL;
508 if (0 < g_slist_length(g_engine_list)) {
510 /* Get a first item */
511 iter = g_slist_nth(g_engine_list, 0);
513 while (NULL != iter) {
514 engine_info = iter->data;
516 if (NULL != engine_info) {
517 g_engine_list = g_slist_remove(g_engine_list, engine_info);
519 stt_parser_free_engine_info(engine_info);
522 iter = g_slist_nth(g_engine_list, 0);
528 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
530 if (NULL == engine_id) {
531 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
532 return STT_CONFIG_ERROR_INVALID_PARAMETER;
536 stt_engine_info_s *engine_info = NULL;
538 if (0 >= g_slist_length(g_engine_list)) {
539 SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
540 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
543 /* Get a first item */
544 iter = g_slist_nth(g_engine_list, 0);
546 while (NULL != iter) {
547 engine_info = iter->data;
549 if (NULL == engine_info) {
550 SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
551 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
554 if (0 == strcmp(engine_id, engine_info->uuid)) {
555 SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
556 return STT_CONFIG_ERROR_NONE;
559 iter = g_slist_next(iter);
562 /* Change default engine */
563 iter = g_slist_nth(g_engine_list, 0);
565 SLOG(LOG_ERROR, stt_tag(), "Operation failed - false engine");
566 return STT_CONFIG_ERROR_OPERATION_FAILED;
569 engine_info = iter->data;
570 if (NULL == engine_info) {
571 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
572 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
575 if (NULL != g_config_info->engine_id) {
576 free(g_config_info->engine_id);
577 g_config_info->engine_id = NULL;
579 if (NULL != g_config_info->setting) {
580 free(g_config_info->setting);
581 g_config_info->setting = NULL;
584 if (NULL != engine_info->uuid) {
585 g_config_info->engine_id = strdup(engine_info->uuid);
588 if (NULL != engine_info->setting) {
589 g_config_info->setting = strdup(engine_info->setting);
593 GSList *iter_lang = NULL;
595 bool is_valid_lang = false;
597 if (0 >= g_slist_length(engine_info->languages)) {
598 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
599 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
602 /* Get a first item */
603 iter_lang = g_slist_nth(engine_info->languages, 0);
605 while (NULL != iter_lang) {
606 /*Get handle data from list*/
607 lang = iter_lang->data;
609 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
611 if (0 == strcmp(lang, g_config_info->language)) {
612 /* language is valid */
613 is_valid_lang = true;
619 iter_lang = g_slist_next(iter_lang);
622 if (false == is_valid_lang) {
623 iter_lang = g_slist_nth(engine_info->languages, 0);
624 if (NULL != iter_lang) {
625 lang = iter_lang->data;
627 if (NULL != g_config_info->language)
628 free(g_config_info->language);
629 g_config_info->language = strdup(lang);
635 if (false == engine_info->support_silence_detection) {
636 if (true == g_config_info->silence_detection)
637 g_config_info->silence_detection = false;
640 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
641 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
642 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
643 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
644 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
645 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
647 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
648 g_config_info->silence_detection, g_config_info->credential)) {
649 SLOG(LOG_ERROR, stt_tag(), "Fail to save config");
650 return STT_CONFIG_ERROR_OPERATION_FAILED;
653 return STT_CONFIG_ERROR_NONE;
656 static void __get_engine_list(const char* directory)
661 struct dirent *dirp = NULL;
663 if (NULL == directory) {
664 SLOG(LOG_ERROR, stt_tag(), "[Directory ERROR] Directory is NULL");
668 dp = opendir(directory);
671 ret = readdir_r(dp, &entry, &dirp);
673 SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
678 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
681 stt_engine_info_s* info;
682 char* filepath = NULL;
685 filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
686 filepath = (char*)calloc(filesize, sizeof(char));
688 if (NULL != filepath) {
689 snprintf(filepath, filesize, "%s/%s", directory, dirp->d_name);
691 SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
695 if (0 == stt_parser_get_engine_info(filepath, &info)) {
696 g_engine_list = g_slist_append(g_engine_list, info);
699 if (NULL != filepath) {
704 } while (NULL != dirp);
708 SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open directory");
714 int stt_config_mgr_initialize(int uid)
718 stt_config_client_s* temp_client = NULL;
720 if (0 < g_slist_length(g_config_client_list)) {
722 iter = g_slist_nth(g_config_client_list, 0);
724 while (NULL != iter) {
725 get_uid = iter->data;
727 if (uid == *get_uid) {
728 SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
732 iter = g_slist_next(iter);
735 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
736 if (NULL == temp_client) {
737 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
738 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
740 temp_client->uid = uid;
741 temp_client->bool_cb = NULL;
742 temp_client->engine_cb = NULL;
743 temp_client->lang_cb = NULL;
744 temp_client->user_data = NULL;
747 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
749 SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
750 return STT_CONFIG_ERROR_NONE;
753 /* Get file name from default engine directory */
754 g_engine_list = NULL;
756 SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
758 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get default engine list");
759 __get_engine_list(STT_DEFAULT_ENGINE_INFO);
760 SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get download engine list");
761 __get_engine_list(STT_DOWNLOAD_ENGINE_INFO);
763 __stt_config_mgr_print_engine_info();
765 if (0 != stt_parser_load_config(&g_config_info)) {
766 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
767 __stt_config_release_client(uid);
768 __stt_config_release_engine();
769 return STT_CONFIG_ERROR_OPERATION_FAILED;
772 /* Check whether engine id is valid */
773 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
774 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
775 __stt_config_release_client(uid);
776 __stt_config_release_engine();
777 stt_parser_unload_config(g_config_info);
778 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
781 if (true == g_config_info->auto_lang) {
782 /* Check language with display language */
783 __stt_config_set_auto_language();
785 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
786 /* Default language is not valid */
788 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
789 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
790 __stt_config_release_client(uid);
791 __stt_config_release_engine();
792 stt_parser_unload_config(g_config_info);
793 return STT_CONFIG_ERROR_OPERATION_FAILED;
796 if (NULL != tmp_language) {
797 if (NULL != g_config_info->language) {
798 free(g_config_info->language);
799 g_config_info->language = strdup(tmp_language);
807 /* print stt-service config */
808 SLOG(LOG_DEBUG, stt_tag(), "== STT service config ==");
809 SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
810 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
811 SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
812 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
813 SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
814 SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
815 SLOG(LOG_DEBUG, stt_tag(), "===================");
817 if (0 != __stt_config_mgr_register_config_event()) {
818 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
819 __stt_config_release_client(uid);
820 __stt_config_release_engine();
821 stt_parser_unload_config(g_config_info);
822 return STT_CONFIG_ERROR_OPERATION_FAILED;
825 /* Register to detect display language change */
826 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
828 temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
829 if (NULL == temp_client) {
830 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
831 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
833 temp_client->uid = uid;
834 temp_client->bool_cb = NULL;
835 temp_client->engine_cb = NULL;
836 temp_client->lang_cb = NULL;
837 temp_client->user_data = NULL;
840 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
842 return STT_CONFIG_ERROR_NONE;
845 int stt_config_mgr_finalize(int uid)
848 stt_config_client_s* temp_client = NULL;
850 if (0 < g_slist_length(g_config_client_list)) {
852 iter = g_slist_nth(g_config_client_list, 0);
854 while (NULL != iter) {
855 temp_client = iter->data;
857 if (NULL != temp_client) {
858 if (uid == temp_client->uid) {
859 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
866 iter = g_slist_next(iter);
870 if (0 < g_slist_length(g_config_client_list)) {
871 SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
872 return STT_CONFIG_ERROR_NONE;
875 stt_engine_info_s *engine_info = NULL;
877 if (0 < g_slist_length(g_engine_list)) {
879 /* Get a first item */
880 iter = g_slist_nth(g_engine_list, 0);
882 while (NULL != iter) {
883 engine_info = iter->data;
885 if (NULL != engine_info) {
886 g_engine_list = g_slist_remove(g_engine_list, engine_info);
888 stt_parser_free_engine_info(engine_info);
891 iter = g_slist_nth(g_engine_list, 0);
895 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
897 __stt_config_mgr_unregister_config_event();
899 if (NULL != g_config_info) {
900 stt_parser_unload_config(g_config_info);
901 g_config_info = NULL;
904 return STT_CONFIG_ERROR_NONE;
907 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)
910 stt_config_client_s* temp_client = NULL;
912 /* Call all callbacks of client*/
913 iter = g_slist_nth(g_config_client_list, 0);
915 while (NULL != iter) {
916 temp_client = iter->data;
918 if (NULL != temp_client) {
919 if (uid == temp_client->uid) {
920 temp_client->engine_cb = engine_cb;
921 temp_client->lang_cb = lang_cb;
922 temp_client->bool_cb = bool_cb;
923 temp_client->user_data = user_data;
927 iter = g_slist_next(iter);
930 return STT_CONFIG_ERROR_NONE;
933 int stt_config_mgr_unset_callback(int uid)
936 stt_config_client_s* temp_client = NULL;
938 /* Call all callbacks of client*/
939 iter = g_slist_nth(g_config_client_list, 0);
941 while (NULL != iter) {
942 temp_client = iter->data;
944 if (NULL != temp_client) {
945 if (uid == temp_client->uid) {
946 temp_client->engine_cb = NULL;
947 temp_client->lang_cb = NULL;
948 temp_client->bool_cb = NULL;
949 temp_client->user_data = NULL;
953 iter = g_slist_next(iter);
956 return STT_CONFIG_ERROR_NONE;
959 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
961 if (0 >= g_slist_length(g_config_client_list)) {
962 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
963 return STT_CONFIG_ERROR_INVALID_STATE;
966 if (NULL == callback) {
967 return STT_CONFIG_ERROR_INVALID_PARAMETER;
971 stt_engine_info_s *engine_info = NULL;
973 if (0 >= g_slist_length(g_engine_list)) {
974 SLOG(LOG_WARN, stt_tag(), "[ERROR] Engine list is NULL");
975 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
978 /* Get a first item */
979 iter = g_slist_nth(g_engine_list, 0);
981 while (NULL != iter) {
982 engine_info = iter->data;
984 if (NULL == engine_info) {
985 SLOG(LOG_ERROR, stt_tag(), " Engine info is NULL");
986 return STT_CONFIG_ERROR_OPERATION_FAILED;
989 if (false == callback(engine_info->uuid, engine_info->name,
990 engine_info->setting, engine_info->support_silence_detection, user_data)) {
994 iter = g_slist_next(iter);
997 return STT_CONFIG_ERROR_NONE;
1000 int stt_config_mgr_get_engine(char** engine)
1002 if (0 >= g_slist_length(g_config_client_list)) {
1003 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1004 return STT_CONFIG_ERROR_INVALID_STATE;
1007 if (NULL == engine) {
1008 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1011 if (NULL != g_config_info->engine_id) {
1012 *engine = strdup(g_config_info->engine_id);
1014 SLOG(LOG_ERROR, stt_tag(), " Engine id is NULL");
1015 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1018 return STT_CONFIG_ERROR_NONE;
1021 int stt_config_mgr_set_engine(const char* engine)
1023 if (0 >= g_slist_length(g_config_client_list)) {
1024 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1025 return STT_CONFIG_ERROR_INVALID_STATE;
1028 if (NULL == g_config_info) {
1029 return STT_CONFIG_ERROR_OPERATION_FAILED;
1032 if (NULL == engine || NULL == g_config_info->engine_id) {
1033 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1036 /* Check current engine id with new engine id */
1037 if (0 == strcmp(g_config_info->engine_id, engine)) {
1041 SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
1043 GSList *iter = NULL;
1044 stt_engine_info_s *engine_info = NULL;
1045 bool is_valid_engine = false;
1047 /* Get a first item */
1048 iter = g_slist_nth(g_engine_list, 0);
1050 while (NULL != iter) {
1051 engine_info = iter->data;
1053 if (NULL == engine_info) {
1054 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1055 iter = g_slist_next(iter);
1059 /* Check engine id is valid */
1060 if (0 != strcmp(engine, engine_info->uuid)) {
1061 iter = g_slist_next(iter);
1065 if (NULL != g_config_info->engine_id)
1066 free(g_config_info->engine_id);
1068 g_config_info->engine_id = strdup(engine);
1070 if (NULL != g_config_info->setting) {
1071 free(g_config_info->setting);
1074 if (NULL != engine_info->setting) {
1075 g_config_info->setting = strdup(engine_info->setting);
1077 g_config_info->setting = NULL;
1080 /* Engine is valid*/
1081 GSList *iter_lang = NULL;
1083 bool is_valid_lang = false;
1085 /* Get a first item */
1086 iter_lang = g_slist_nth(engine_info->languages, 0);
1088 while (NULL != iter_lang) {
1089 /*Get handle data from list*/
1090 lang = iter_lang->data;
1092 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1093 if (NULL != lang && NULL != g_config_info->language) {
1094 if (0 == strcmp(lang, g_config_info->language)) {
1095 /* language is valid */
1096 is_valid_lang = true;
1098 free(g_config_info->language);
1099 g_config_info->language = strdup(lang);
1106 iter_lang = g_slist_next(iter_lang);
1109 if (false == is_valid_lang) {
1110 if (NULL != g_config_info->language) {
1111 free(g_config_info->language);
1112 g_config_info->language = NULL;
1114 iter_lang = g_slist_nth(engine_info->languages, 0);
1115 if (NULL == iter_lang) {
1116 SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
1120 lang = iter_lang->data;
1122 g_config_info->language = strdup(lang);
1127 if (false == engine_info->support_silence_detection) {
1128 if (true == g_config_info->silence_detection)
1129 g_config_info->silence_detection = false;
1132 if (false == engine_info->need_credential) {
1133 if (true == g_config_info->credential)
1134 g_config_info->credential = false;
1137 is_valid_engine = true;
1141 if (true == is_valid_engine) {
1142 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1143 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1144 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1145 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1146 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1147 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1149 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1150 g_config_info->silence_detection, g_config_info->credential)) {
1151 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1152 return STT_CONFIG_ERROR_OPERATION_FAILED;
1155 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1156 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1162 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1164 if (0 >= g_slist_length(g_engine_list)) {
1165 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1166 return STT_CONFIG_ERROR_INVALID_STATE;
1169 if (NULL == agreement) {
1170 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1171 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1174 GSList *iter = NULL;
1175 stt_engine_info_s *engine_info = NULL;
1176 char* current_engine = NULL;
1178 if (NULL == engine) {
1179 current_engine = strdup(g_config_info->engine_id);
1180 if (NULL == current_engine) {
1181 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1182 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1185 current_engine = strdup(engine);
1186 if (NULL == current_engine) {
1187 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1188 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
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 if (NULL != current_engine) free(current_engine);
1201 return STT_CONFIG_ERROR_OPERATION_FAILED;
1204 if (0 != strcmp(current_engine, engine_info->uuid)) {
1205 iter = g_slist_next(iter);
1209 if (NULL != engine_info->agreement) {
1210 *agreement = strdup(engine_info->agreement);
1212 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1217 if (NULL != current_engine) free(current_engine);
1219 return STT_CONFIG_ERROR_NONE;
1222 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1224 if (0 >= g_slist_length(g_config_client_list)) {
1225 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1226 return STT_CONFIG_ERROR_INVALID_STATE;
1229 if (0 >= g_slist_length(g_engine_list)) {
1230 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1231 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1234 GSList *iter = NULL;
1235 stt_engine_info_s *engine_info = NULL;
1237 /* Get a first item */
1238 iter = g_slist_nth(g_engine_list, 0);
1240 while (NULL != iter) {
1241 engine_info = iter->data;
1243 if (NULL == engine_info) {
1244 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1245 return STT_CONFIG_ERROR_OPERATION_FAILED;
1248 if (0 != strcmp(engine_id, engine_info->uuid)) {
1249 iter = g_slist_next(iter);
1253 GSList *iter_lang = NULL;
1256 /* Get a first item */
1257 iter_lang = g_slist_nth(engine_info->languages, 0);
1259 while (NULL != iter_lang) {
1260 /*Get handle data from list*/
1261 lang = iter_lang->data;
1264 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1265 if (false == callback(engine_info->uuid, lang, user_data))
1270 iter_lang = g_slist_next(iter_lang);
1275 return STT_CONFIG_ERROR_NONE;
1278 int stt_config_mgr_get_default_language(char** language)
1280 if (0 >= g_slist_length(g_config_client_list)) {
1281 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1282 return STT_CONFIG_ERROR_INVALID_STATE;
1285 if (NULL == language) {
1286 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1289 if (NULL != g_config_info->language) {
1290 *language = strdup(g_config_info->language);
1292 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1293 return STT_CONFIG_ERROR_OPERATION_FAILED;
1296 return STT_CONFIG_ERROR_NONE;
1299 int stt_config_mgr_set_default_language(const char* language)
1301 if (0 >= g_slist_length(g_config_client_list)) {
1302 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1303 return STT_CONFIG_ERROR_INVALID_STATE;
1306 if (NULL == language) {
1307 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1310 /* Check language is valid */
1311 if (NULL != g_config_info->language) {
1312 if (0 != stt_parser_set_language(language)) {
1313 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1314 return STT_CONFIG_ERROR_OPERATION_FAILED;
1316 free(g_config_info->language);
1317 g_config_info->language = strdup(language);
1319 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1320 return STT_CONFIG_ERROR_OPERATION_FAILED;
1323 return STT_CONFIG_ERROR_NONE;
1326 int stt_config_mgr_get_auto_language(bool* value)
1328 if (0 >= g_slist_length(g_config_client_list)) {
1329 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1330 return STT_CONFIG_ERROR_INVALID_STATE;
1333 if (NULL == value) {
1334 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1337 *value = g_config_info->auto_lang;
1339 return STT_CONFIG_ERROR_NONE;
1342 int stt_config_mgr_set_auto_language(bool value)
1344 if (0 >= g_slist_length(g_config_client_list)) {
1345 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1346 return STT_CONFIG_ERROR_INVALID_STATE;
1349 if (g_config_info->auto_lang != value) {
1350 /* Check language is valid */
1351 if (0 != stt_parser_set_auto_lang(value)) {
1352 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1353 return STT_CONFIG_ERROR_OPERATION_FAILED;
1355 g_config_info->auto_lang = value;
1357 if (true == g_config_info->auto_lang) {
1358 __stt_config_set_auto_language();
1362 return STT_CONFIG_ERROR_NONE;
1365 int stt_config_mgr_get_silence_detection(bool* value)
1367 if (0 >= g_slist_length(g_config_client_list)) {
1368 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1369 return STT_CONFIG_ERROR_INVALID_STATE;
1373 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1375 *value = g_config_info->silence_detection;
1377 return STT_CONFIG_ERROR_NONE;
1380 int stt_config_mgr_set_silence_detection(bool value)
1382 if (0 >= g_slist_length(g_config_client_list)) {
1383 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1384 return STT_CONFIG_ERROR_INVALID_STATE;
1387 if (0 != stt_parser_set_silence_detection(value)) {
1388 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1389 return STT_CONFIG_ERROR_OPERATION_FAILED;
1392 g_config_info->silence_detection = value;
1394 return STT_CONFIG_ERROR_NONE;
1397 bool stt_config_check_default_engine_is_valid(const char* engine)
1399 if (0 >= g_slist_length(g_config_client_list)) {
1400 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1404 if (NULL == engine) {
1408 if (0 >= g_slist_length(g_engine_list))
1411 GSList *iter = NULL;
1412 stt_engine_info_s *engine_info = NULL;
1414 /* Get a first item */
1415 iter = g_slist_nth(g_engine_list, 0);
1417 while (NULL != iter) {
1418 engine_info = iter->data;
1420 if (NULL != engine_info) {
1421 if (0 == strcmp(engine, engine_info->uuid)) {
1425 iter = g_slist_next(iter);
1431 bool stt_config_check_default_language_is_valid(const char* language)
1433 if (0 >= g_slist_length(g_config_client_list)) {
1434 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1438 if (NULL == language) {
1442 if (NULL == g_config_info->engine_id) {
1443 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1447 if (0 >= g_slist_length(g_engine_list))
1450 GSList *iter = NULL;
1451 stt_engine_info_s *engine_info = NULL;
1453 /* Get a first item */
1454 iter = g_slist_nth(g_engine_list, 0);
1456 while (NULL != iter) {
1457 engine_info = iter->data;
1459 if (NULL == engine_info) {
1460 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1461 iter = g_slist_next(iter);
1465 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1466 iter = g_slist_next(iter);
1470 GSList *iter_lang = NULL;
1473 /* Get a first item */
1474 iter_lang = g_slist_nth(engine_info->languages, 0);
1476 while (NULL != iter_lang) {
1477 lang = iter_lang->data;
1479 if (0 == strcmp(language, lang))
1483 iter_lang = g_slist_next(iter_lang);
1491 int __stt_config_mgr_print_engine_info()
1493 GSList *iter = NULL;
1494 stt_engine_info_s *engine_info = NULL;
1496 if (0 >= g_slist_length(g_engine_list)) {
1497 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1498 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1499 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1503 /* Get a first item */
1504 iter = g_slist_nth(g_engine_list, 0);
1506 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1509 while (NULL != iter) {
1510 engine_info = iter->data;
1512 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1513 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1514 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1515 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1516 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1518 SLOG(LOG_DEBUG, stt_tag(), " languages");
1519 GSList *iter_lang = NULL;
1521 if (g_slist_length(engine_info->languages) > 0) {
1522 /* Get a first item */
1523 iter_lang = g_slist_nth(engine_info->languages, 0);
1526 while (NULL != iter_lang) {
1527 /*Get handle data from list*/
1528 lang = iter_lang->data;
1530 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1533 iter_lang = g_slist_next(iter_lang);
1537 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1539 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1540 engine_info->support_silence_detection ? "true" : "false");
1541 iter = g_slist_next(iter);
1544 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1552 * time info functions
1554 static GSList* g_time_list = NULL;
1556 int stt_config_mgr_reset_time_info()
1558 /* Remove time info */
1559 GSList *iter = NULL;
1560 stt_result_time_info_s *data = NULL;
1562 /* Remove time info */
1563 iter = g_slist_nth(g_time_list, 0);
1564 while (NULL != iter) {
1567 g_time_list = g_slist_remove(g_time_list, data);
1569 if (NULL != data->text) {
1578 iter = g_slist_nth(g_time_list, 0);
1584 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1587 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1591 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1593 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1594 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1596 info->index = index;
1597 info->event = event;
1599 info->text = strdup(text);
1601 info->start_time = start_time;
1602 info->end_time = end_time;
1604 /* Add item to global list */
1605 g_time_list = g_slist_append(g_time_list, info);
1610 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1612 if (NULL == callback) {
1613 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1614 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1617 GSList* temp_time = NULL;
1619 ret = stt_parser_get_time_info(&temp_time);
1621 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1622 return STT_CONFIG_ERROR_OPERATION_FAILED;
1625 GSList *iter = NULL;
1626 stt_result_time_info_s *data = NULL;
1628 /* Get a first item */
1629 iter = g_slist_nth(temp_time, 0);
1630 while (NULL != iter) {
1633 if (false == callback(data->index, data->event, data->text,
1634 data->start_time, data->end_time, user_data)) {
1639 iter = g_slist_next(iter);
1642 /* Remove time info */
1643 iter = g_slist_nth(temp_time, 0);
1644 while (NULL != iter) {
1648 temp_time = g_slist_remove(temp_time, data);
1650 if (NULL != data->text) {
1659 iter = g_slist_nth(temp_time, 0);
1662 return STT_CONFIG_ERROR_NONE;
1665 int stt_config_mgr_save_time_info_file()
1667 if (0 == g_slist_length(g_time_list)) {
1668 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1669 return STT_CONFIG_ERROR_OPERATION_FAILED;
1673 ret = stt_parser_set_time_info(g_time_list);
1675 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1676 return STT_CONFIG_ERROR_OPERATION_FAILED;
1679 return STT_CONFIG_ERROR_NONE;
1682 int stt_config_mgr_remove_time_info_file()
1684 stt_parser_clear_time_info();
1686 return STT_CONFIG_ERROR_NONE;