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);
1067 g_config_info->engine_id = NULL;
1070 g_config_info->engine_id = strdup(engine);
1072 if (NULL != g_config_info->setting) {
1073 free(g_config_info->setting);
1074 g_config_info->setting = NULL;
1077 if (NULL != engine_info->setting) {
1078 g_config_info->setting = strdup(engine_info->setting);
1080 g_config_info->setting = NULL;
1083 /* Engine is valid*/
1084 GSList *iter_lang = NULL;
1086 bool is_valid_lang = false;
1088 /* Get a first item */
1089 iter_lang = g_slist_nth(engine_info->languages, 0);
1091 while (NULL != iter_lang) {
1092 /*Get handle data from list*/
1093 lang = iter_lang->data;
1095 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1096 if (NULL != lang && NULL != g_config_info->language) {
1097 if (0 == strcmp(lang, g_config_info->language)) {
1098 /* language is valid */
1099 is_valid_lang = true;
1101 free(g_config_info->language);
1102 g_config_info->language = strdup(lang);
1109 iter_lang = g_slist_next(iter_lang);
1112 if (false == is_valid_lang) {
1113 if (NULL != g_config_info->language) {
1114 free(g_config_info->language);
1115 g_config_info->language = NULL;
1117 iter_lang = g_slist_nth(engine_info->languages, 0);
1118 if (NULL == iter_lang) {
1119 SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
1123 lang = iter_lang->data;
1125 g_config_info->language = strdup(lang);
1130 if (false == engine_info->support_silence_detection) {
1131 if (true == g_config_info->silence_detection)
1132 g_config_info->silence_detection = false;
1135 if (false == engine_info->need_credential) {
1136 if (true == g_config_info->credential)
1137 g_config_info->credential = false;
1140 is_valid_engine = true;
1144 if (true == is_valid_engine) {
1145 SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
1146 SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
1147 SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
1148 SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
1149 SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1150 SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
1152 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1153 g_config_info->silence_detection, g_config_info->credential)) {
1154 SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
1155 return STT_CONFIG_ERROR_OPERATION_FAILED;
1158 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine id is not valid");
1159 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1165 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1167 if (0 >= g_slist_length(g_engine_list)) {
1168 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1169 return STT_CONFIG_ERROR_INVALID_STATE;
1172 if (NULL == agreement) {
1173 SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
1174 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1177 GSList *iter = NULL;
1178 stt_engine_info_s *engine_info = NULL;
1179 char* current_engine = NULL;
1181 if (NULL == engine) {
1182 current_engine = strdup(g_config_info->engine_id);
1183 if (NULL == current_engine) {
1184 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1185 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1188 current_engine = strdup(engine);
1189 if (NULL == current_engine) {
1190 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1191 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1195 /* Get a first item */
1196 iter = g_slist_nth(g_engine_list, 0);
1198 while (NULL != iter) {
1199 engine_info = iter->data;
1201 if (NULL == engine_info) {
1202 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1203 if (NULL != current_engine) free(current_engine);
1204 return STT_CONFIG_ERROR_OPERATION_FAILED;
1207 if (0 != strcmp(current_engine, engine_info->uuid)) {
1208 iter = g_slist_next(iter);
1212 if (NULL != engine_info->agreement) {
1213 *agreement = strdup(engine_info->agreement);
1215 SLOG(LOG_WARN, stt_tag(), "[WARNING] engine agreement is not support");
1220 if (NULL != current_engine) free(current_engine);
1222 return STT_CONFIG_ERROR_NONE;
1225 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1227 if (0 >= g_slist_length(g_config_client_list)) {
1228 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1229 return STT_CONFIG_ERROR_INVALID_STATE;
1232 if (0 >= g_slist_length(g_engine_list)) {
1233 SLOG(LOG_ERROR, stt_tag(), "There is no engine");
1234 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1237 GSList *iter = NULL;
1238 stt_engine_info_s *engine_info = NULL;
1240 /* Get a first item */
1241 iter = g_slist_nth(g_engine_list, 0);
1243 while (NULL != iter) {
1244 engine_info = iter->data;
1246 if (NULL == engine_info) {
1247 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine info is NULL");
1248 return STT_CONFIG_ERROR_OPERATION_FAILED;
1251 if (0 != strcmp(engine_id, engine_info->uuid)) {
1252 iter = g_slist_next(iter);
1256 GSList *iter_lang = NULL;
1259 /* Get a first item */
1260 iter_lang = g_slist_nth(engine_info->languages, 0);
1262 while (NULL != iter_lang) {
1263 /*Get handle data from list*/
1264 lang = iter_lang->data;
1267 SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
1268 if (false == callback(engine_info->uuid, lang, user_data))
1273 iter_lang = g_slist_next(iter_lang);
1278 return STT_CONFIG_ERROR_NONE;
1281 int stt_config_mgr_get_default_language(char** language)
1283 if (0 >= g_slist_length(g_config_client_list)) {
1284 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1285 return STT_CONFIG_ERROR_INVALID_STATE;
1288 if (NULL == language) {
1289 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1292 if (NULL != g_config_info->language) {
1293 *language = strdup(g_config_info->language);
1295 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1296 return STT_CONFIG_ERROR_OPERATION_FAILED;
1299 return STT_CONFIG_ERROR_NONE;
1302 int stt_config_mgr_set_default_language(const char* language)
1304 if (0 >= g_slist_length(g_config_client_list)) {
1305 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1306 return STT_CONFIG_ERROR_INVALID_STATE;
1309 if (NULL == language) {
1310 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1313 /* Check language is valid */
1314 if (NULL != g_config_info->language) {
1315 if (0 != stt_parser_set_language(language)) {
1316 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1317 return STT_CONFIG_ERROR_OPERATION_FAILED;
1319 free(g_config_info->language);
1320 g_config_info->language = strdup(language);
1322 SLOG(LOG_ERROR, stt_tag(), " language is NULL");
1323 return STT_CONFIG_ERROR_OPERATION_FAILED;
1326 return STT_CONFIG_ERROR_NONE;
1329 int stt_config_mgr_get_auto_language(bool* value)
1331 if (0 >= g_slist_length(g_config_client_list)) {
1332 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1333 return STT_CONFIG_ERROR_INVALID_STATE;
1336 if (NULL == value) {
1337 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1340 *value = g_config_info->auto_lang;
1342 return STT_CONFIG_ERROR_NONE;
1345 int stt_config_mgr_set_auto_language(bool value)
1347 if (0 >= g_slist_length(g_config_client_list)) {
1348 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1349 return STT_CONFIG_ERROR_INVALID_STATE;
1352 if (g_config_info->auto_lang != value) {
1353 /* Check language is valid */
1354 if (0 != stt_parser_set_auto_lang(value)) {
1355 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1356 return STT_CONFIG_ERROR_OPERATION_FAILED;
1358 g_config_info->auto_lang = value;
1360 if (true == g_config_info->auto_lang) {
1361 __stt_config_set_auto_language();
1365 return STT_CONFIG_ERROR_NONE;
1368 int stt_config_mgr_get_silence_detection(bool* value)
1370 if (0 >= g_slist_length(g_config_client_list)) {
1371 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1372 return STT_CONFIG_ERROR_INVALID_STATE;
1376 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1378 *value = g_config_info->silence_detection;
1380 return STT_CONFIG_ERROR_NONE;
1383 int stt_config_mgr_set_silence_detection(bool value)
1385 if (0 >= g_slist_length(g_config_client_list)) {
1386 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1387 return STT_CONFIG_ERROR_INVALID_STATE;
1390 if (0 != stt_parser_set_silence_detection(value)) {
1391 SLOG(LOG_ERROR, stt_tag(), "Fail to save engine id");
1392 return STT_CONFIG_ERROR_OPERATION_FAILED;
1395 g_config_info->silence_detection = value;
1397 return STT_CONFIG_ERROR_NONE;
1400 bool stt_config_check_default_engine_is_valid(const char* engine)
1402 if (0 >= g_slist_length(g_config_client_list)) {
1403 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1407 if (NULL == engine) {
1411 if (0 >= g_slist_length(g_engine_list))
1414 GSList *iter = NULL;
1415 stt_engine_info_s *engine_info = NULL;
1417 /* Get a first item */
1418 iter = g_slist_nth(g_engine_list, 0);
1420 while (NULL != iter) {
1421 engine_info = iter->data;
1423 if (NULL != engine_info) {
1424 if (0 == strcmp(engine, engine_info->uuid)) {
1428 iter = g_slist_next(iter);
1434 bool stt_config_check_default_language_is_valid(const char* language)
1436 if (0 >= g_slist_length(g_config_client_list)) {
1437 SLOG(LOG_ERROR, stt_tag(), "Not initialized");
1441 if (NULL == language) {
1445 if (NULL == g_config_info->engine_id) {
1446 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default engine id is NULL");
1450 if (0 >= g_slist_length(g_engine_list))
1453 GSList *iter = NULL;
1454 stt_engine_info_s *engine_info = NULL;
1456 /* Get a first item */
1457 iter = g_slist_nth(g_engine_list, 0);
1459 while (NULL != iter) {
1460 engine_info = iter->data;
1462 if (NULL == engine_info) {
1463 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
1464 iter = g_slist_next(iter);
1468 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1469 iter = g_slist_next(iter);
1473 GSList *iter_lang = NULL;
1476 /* Get a first item */
1477 iter_lang = g_slist_nth(engine_info->languages, 0);
1479 while (NULL != iter_lang) {
1480 lang = iter_lang->data;
1482 if (0 == strcmp(language, lang))
1486 iter_lang = g_slist_next(iter_lang);
1494 int __stt_config_mgr_print_engine_info()
1496 GSList *iter = NULL;
1497 stt_engine_info_s *engine_info = NULL;
1499 if (0 >= g_slist_length(g_engine_list)) {
1500 SLOG(LOG_DEBUG, stt_tag(), "-------------- engine list -----------------");
1501 SLOG(LOG_DEBUG, stt_tag(), " No Engine in engine directory");
1502 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1506 /* Get a first item */
1507 iter = g_slist_nth(g_engine_list, 0);
1509 SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
1512 while (NULL != iter) {
1513 engine_info = iter->data;
1515 SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
1516 SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
1517 SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
1518 SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
1519 SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
1521 SLOG(LOG_DEBUG, stt_tag(), " languages");
1522 GSList *iter_lang = NULL;
1524 if (g_slist_length(engine_info->languages) > 0) {
1525 /* Get a first item */
1526 iter_lang = g_slist_nth(engine_info->languages, 0);
1529 while (NULL != iter_lang) {
1530 /*Get handle data from list*/
1531 lang = iter_lang->data;
1533 SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
1536 iter_lang = g_slist_next(iter_lang);
1540 SLOG(LOG_ERROR, stt_tag(), " language is NONE");
1542 SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
1543 engine_info->support_silence_detection ? "true" : "false");
1544 iter = g_slist_next(iter);
1547 SLOG(LOG_DEBUG, stt_tag(), "--------------------------------------------");
1555 * time info functions
1557 static GSList* g_time_list = NULL;
1559 int stt_config_mgr_reset_time_info()
1561 /* Remove time info */
1562 GSList *iter = NULL;
1563 stt_result_time_info_s *data = NULL;
1565 /* Remove time info */
1566 iter = g_slist_nth(g_time_list, 0);
1567 while (NULL != iter) {
1570 g_time_list = g_slist_remove(g_time_list, data);
1572 if (NULL != data->text) {
1581 iter = g_slist_nth(g_time_list, 0);
1587 int stt_config_mgr_add_time_info(int index, int event, const char* text, long start_time, long end_time)
1590 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
1594 stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
1596 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
1597 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
1599 info->index = index;
1600 info->event = event;
1602 info->text = strdup(text);
1604 info->start_time = start_time;
1605 info->end_time = end_time;
1607 /* Add item to global list */
1608 g_time_list = g_slist_append(g_time_list, info);
1613 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1615 if (NULL == callback) {
1616 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input paramter is NULL : callback function");
1617 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1620 GSList* temp_time = NULL;
1622 ret = stt_parser_get_time_info(&temp_time);
1624 SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
1625 return STT_CONFIG_ERROR_OPERATION_FAILED;
1628 GSList *iter = NULL;
1629 stt_result_time_info_s *data = NULL;
1631 /* Get a first item */
1632 iter = g_slist_nth(temp_time, 0);
1633 while (NULL != iter) {
1636 if (false == callback(data->index, data->event, data->text,
1637 data->start_time, data->end_time, user_data)) {
1642 iter = g_slist_next(iter);
1645 /* Remove time info */
1646 iter = g_slist_nth(temp_time, 0);
1647 while (NULL != iter) {
1651 temp_time = g_slist_remove(temp_time, data);
1653 if (NULL != data->text) {
1662 iter = g_slist_nth(temp_time, 0);
1665 return STT_CONFIG_ERROR_NONE;
1668 int stt_config_mgr_save_time_info_file()
1670 if (0 == g_slist_length(g_time_list)) {
1671 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
1672 return STT_CONFIG_ERROR_OPERATION_FAILED;
1676 ret = stt_parser_set_time_info(g_time_list);
1678 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to save time info : %d", ret);
1679 return STT_CONFIG_ERROR_OPERATION_FAILED;
1682 return STT_CONFIG_ERROR_NONE;
1685 int stt_config_mgr_remove_time_info_file()
1687 stt_parser_clear_time_info();
1689 return STT_CONFIG_ERROR_NONE;