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>
24 #include "stt_config_mgr.h"
26 #include "stt_config_parser.h"
31 stt_config_engine_changed_cb engine_cb;
32 stt_config_lang_changed_cb lang_cb;
33 stt_config_bool_changed_cb bool_cb;
35 } stt_config_client_s;
38 static GSList* g_engine_list = NULL;
40 static GSList* g_config_client_list = NULL;
42 static stt_config_s* g_config_info;
44 static Ecore_Fd_Handler* g_fd_handler_noti = NULL;
48 int __stt_config_mgr_print_engine_info();
50 bool __stt_config_mgr_check_lang_is_valid(const char* engine_id, const char* language)
52 if (NULL == engine_id || NULL == language) {
53 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Input parameter is NULL");
57 if (0 >= g_slist_length(g_engine_list)) {
58 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] There is no engine!!");
62 /* Get a first item */
63 GSList *iter = g_slist_nth(g_engine_list, 0);
64 while (NULL != iter) {
65 stt_engine_info_s *engine_info = iter->data;
67 if (NULL == engine_info) {
68 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Engine info is NULL");
72 if (0 != strcmp(engine_id, engine_info->uuid)) {
73 iter = g_slist_next(iter);
77 if (g_slist_length(engine_info->languages) > 0) {
78 /* Get a first item */
79 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
82 while (NULL != iter_lang) {
83 /*Get handle data from list*/
84 char* engine_lang = iter_lang->data;
86 SLOG(LOG_DEBUG, TAG_STTCONFIG, " [%dth] %s", i, engine_lang);
88 if (0 == strcmp(language, engine_lang)) {
93 iter_lang = g_slist_next(iter_lang);
103 int __stt_config_mgr_select_lang(const char* engine_id, char** language)
105 if (NULL == engine_id || NULL == language) {
106 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Input parameter is NULL");
107 return STT_CONFIG_ERROR_INVALID_PARAMETER;
110 if (0 >= g_slist_length(g_engine_list)) {
111 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] There is no engine!!");
112 return STT_CONFIG_ERROR_OPERATION_FAILED;
115 /* Get a first item */
116 GSList *iter = g_slist_nth(g_engine_list, 0);
117 while (NULL != iter) {
118 stt_engine_info_s *engine_info = iter->data;
120 if (NULL == engine_info) {
121 SLOG(LOG_ERROR, TAG_STTCONFIG, "engine info is NULL");
122 iter = g_slist_next(iter);
126 if (0 != strcmp(engine_id, engine_info->uuid)) {
127 iter = g_slist_next(iter);
131 if (NULL == engine_info->default_lang) {
132 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Default language of the engine info is NULL");
133 return STT_CONFIG_ERROR_INVALID_LANGUAGE;
136 *language = strdup(engine_info->default_lang);
138 if (NULL != *language) {
139 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Selected language : %s", *language);
140 return STT_CONFIG_ERROR_NONE;
144 return STT_CONFIG_ERROR_OPERATION_FAILED;
147 Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
149 SLOG(LOG_DEBUG, TAG_STTCONFIG, "===== Config changed callback event");
152 struct inotify_event event;
153 memset(&event, '\0', sizeof(struct inotify_event));
155 length = read(g_fd_noti, &event, sizeof(struct inotify_event));
157 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Empty Inotify event"); //LCOV_EXCL_LINE
158 SLOG(LOG_DEBUG, TAG_STTCONFIG, "====="); //LCOV_EXCL_LINE
159 SLOG(LOG_DEBUG, TAG_STTCONFIG, " "); //LCOV_EXCL_LINE
160 return ECORE_CALLBACK_PASS_ON; //LCOV_EXCL_LINE
163 if (IN_MODIFY == event.mask) {
165 char* setting = NULL;
171 if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
172 return ECORE_CALLBACK_PASS_ON;
175 if (NULL != engine || NULL != setting) {
177 if (NULL != engine) {
178 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
179 g_config_info->engine_id = strdup(engine);
182 if (NULL != setting) {
183 if (NULL != g_config_info->setting) free(g_config_info->setting);
184 g_config_info->setting = strdup(setting);
188 if (NULL != g_config_info->language) free(g_config_info->language);
189 g_config_info->language = strdup(lang);
192 if (-1 != silence) g_config_info->silence_detection = silence;
194 if (-1 != credential) g_config_info->credential = credential;
196 /* Call all callbacks of client*/
197 GSList *iter = g_slist_nth(g_config_client_list, 0);
199 while (NULL != iter) {
200 stt_config_client_s *temp_client = iter->data;
202 if (NULL != temp_client) {
203 if (NULL != temp_client->engine_cb) {
204 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
205 g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
209 iter = g_slist_next(iter);
213 if (-1 != auto_lang) {
214 g_config_info->auto_lang = auto_lang;
217 /* Only language changed */
218 if (NULL == engine && NULL != lang) {
219 char* before_lang = NULL;
220 before_lang = strdup(g_config_info->language);
223 if (NULL != g_config_info->language) free(g_config_info->language);
224 g_config_info->language = strdup(lang);
227 /* Call all callbacks of client*/
228 GSList *iter = g_slist_nth(g_config_client_list, 0);
229 while (NULL != iter) {
230 stt_config_client_s *temp_client = iter->data;
232 if (NULL != temp_client) {
233 if (NULL != temp_client->lang_cb) {
234 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
238 iter = g_slist_next(iter);
241 if (NULL != before_lang) {
247 /* silence detection changed */
248 g_config_info->silence_detection = silence;
250 /* Call all callbacks of client*/
251 GSList *iter = g_slist_nth(g_config_client_list, 0);
252 while (NULL != iter) {
253 stt_config_client_s *temp_client = iter->data;
255 if (NULL != temp_client) {
256 if (NULL != temp_client->bool_cb) {
257 temp_client->bool_cb(STT_CONFIG_TYPE_OPTION_SILENCE_DETECTION, silence, temp_client->user_data);
261 iter = g_slist_next(iter);
265 if (NULL != engine) free(engine);
266 if (NULL != setting) free(setting);
267 if (NULL != lang) free(lang);
269 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Undefined event"); //LCOV_EXCL_LINE
272 SLOG(LOG_DEBUG, TAG_STTCONFIG, "=====");
273 SLOG(LOG_DEBUG, TAG_STTCONFIG, " ");
275 return ECORE_CALLBACK_PASS_ON;
278 int __stt_config_mgr_register_config_event()
280 /* get file notification handler */
286 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail get inotify fd"); //LCOV_EXCL_LINE
287 return -1; //LCOV_EXCL_LINE
291 wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
294 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);
295 if (NULL == g_fd_handler_noti) {
296 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to get handler_noti"); //LCOV_EXCL_LINE
297 return -1; //LCOV_EXCL_LINE
303 int __stt_config_mgr_unregister_config_event()
305 /* delete inotify variable */
306 ecore_main_fd_handler_del(g_fd_handler_noti);
307 inotify_rm_watch(g_fd_noti, g_wd_noti);
313 int __stt_config_set_auto_language()
316 char candidate_lang[6] = {'\0', };
318 value = vconf_get_str(VCONFKEY_LANGSET);
320 SLOG(LOG_ERROR, TAG_STTCONFIG, "[Config ERROR] Fail to get display language"); //LCOV_EXCL_LINE
324 strncpy(candidate_lang, value, 5);
327 /* Check current config info */
328 if (NULL == g_config_info) {
329 SLOG(LOG_ERROR, TAG_STTCONFIG, "Current config info is NULL"); //LCOV_EXCL_LINE
330 return STT_CONFIG_ERROR_OPERATION_FAILED;
333 /* Check current language */
334 if (NULL == g_config_info->language) {
335 SLOG(LOG_ERROR, TAG_STTCONFIG, "Current config language is NULL"); //LCOV_EXCL_LINE
336 return STT_CONFIG_ERROR_OPERATION_FAILED;
339 if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
340 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
343 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Display language : %s", candidate_lang); //LCOV_EXCL_LINE
346 if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
347 char* before_lang = NULL;
348 if (0 != stt_parser_set_language(candidate_lang)) {
349 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to save default language");
353 before_lang = strdup(g_config_info->language);
355 free(g_config_info->language);
356 g_config_info->language = strdup(candidate_lang);
358 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Language is auto. Set default language(%s)", g_config_info->language);
360 /* Call all callbacks of client*/
361 GSList *iter = g_slist_nth(g_config_client_list, 0);
362 while (NULL != iter) {
363 stt_config_client_s *temp_client = iter->data;
365 if (NULL != temp_client) {
366 if (NULL != temp_client->lang_cb) {
367 temp_client->lang_cb(before_lang, g_config_info->language, temp_client->user_data);
371 iter = g_slist_next(iter);
374 if (NULL != before_lang) {
379 /* Candidate language is not valid */
380 char* tmp_language = NULL;
381 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
382 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to select language");
386 if (NULL == tmp_language) {
387 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Selected language is NULL");
391 if (0 != stt_parser_set_language(tmp_language)) {
394 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to save config");
398 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
400 /* Call all callbacks of client*/
401 GSList *iter = g_slist_nth(g_config_client_list, 0);
402 while (NULL != iter) {
403 stt_config_client_s *temp_client = iter->data;
405 if (NULL != temp_client) {
406 if (NULL != temp_client->lang_cb) {
407 temp_client->lang_cb(g_config_info->language, tmp_language, temp_client->user_data);
411 iter = g_slist_next(iter);
414 free(g_config_info->language);
415 g_config_info->language = strdup(tmp_language);
424 void __stt_config_language_changed_cb(keynode_t *key, void *data)
426 if (true == g_config_info->auto_lang) {
427 /* Get voice input vconf key */
428 __stt_config_set_auto_language();
434 void __stt_config_release_client(unsigned int uid)
436 if (0 < g_slist_length(g_config_client_list)) {
438 GSList *iter = g_slist_nth(g_config_client_list, 0);
439 while (NULL != iter) {
440 stt_config_client_s *temp_client = iter->data;
442 if (NULL != temp_client) {
443 if (uid == temp_client->uid) {
444 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
451 iter = g_slist_next(iter);
455 if (0 < g_slist_length(g_config_client_list)) {
456 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Client count (%d)", g_slist_length(g_config_client_list));
461 void __stt_config_release_engine()
463 if (0 < g_slist_length(g_engine_list)) {
464 /* Get a first item */
465 GSList *iter = g_slist_nth(g_engine_list, 0);
466 while (NULL != iter) {
467 stt_engine_info_s *engine_info = iter->data;
469 if (NULL != engine_info) {
470 g_engine_list = g_slist_remove(g_engine_list, engine_info);
472 stt_parser_free_engine_info(engine_info);
475 iter = g_slist_nth(g_engine_list, 0);
481 int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
483 if (NULL == engine_id) {
484 SLOG(LOG_ERROR, TAG_STTCONFIG, "Input parameter is NULL"); //LCOV_EXCL_LINE
485 return STT_CONFIG_ERROR_INVALID_PARAMETER;
489 stt_engine_info_s *engine_info = NULL;
491 if (0 >= g_slist_length(g_engine_list)) {
492 SLOG(LOG_ERROR, TAG_STTCONFIG, "There is no engine!!"); //LCOV_EXCL_LINE
493 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
496 /* Get a first item */
497 iter = g_slist_nth(g_engine_list, 0);
499 while (NULL != iter) {
500 engine_info = iter->data;
502 if (NULL == engine_info) {
503 SLOG(LOG_ERROR, TAG_STTCONFIG, "engine info is NULL"); //LCOV_EXCL_LINE
504 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
507 if (0 == strcmp(engine_id, engine_info->uuid)) {
508 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Default engine is valid : %s", engine_id);
509 return STT_CONFIG_ERROR_NONE;
512 iter = g_slist_next(iter);
515 /* Change default engine */
516 iter = g_slist_nth(g_engine_list, 0);
518 SLOG(LOG_ERROR, TAG_STTCONFIG, "Operation failed - false engine"); //LCOV_EXCL_LINE
519 return STT_CONFIG_ERROR_OPERATION_FAILED;
522 engine_info = iter->data;
523 if (NULL == engine_info) {
524 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Engine info is NULL"); //LCOV_EXCL_LINE
525 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
528 if (NULL != g_config_info->engine_id) {
529 free(g_config_info->engine_id);
530 g_config_info->engine_id = NULL;
532 if (NULL != g_config_info->setting) {
533 free(g_config_info->setting);
534 g_config_info->setting = NULL;
537 if (NULL != engine_info->uuid) {
538 g_config_info->engine_id = strdup(engine_info->uuid);
541 if (NULL != engine_info->setting) {
542 g_config_info->setting = strdup(engine_info->setting);
546 bool is_valid_lang = false;
548 if (0 >= g_slist_length(engine_info->languages)) {
549 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Empty supported language"); //LCOV_EXCL_LINE
550 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
553 /* Get a first item */
554 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
555 while (NULL != iter_lang) {
556 /*Get handle data from list*/
557 char *lang = iter_lang->data;
559 SLOG(LOG_DEBUG, TAG_STTCONFIG, " %s", lang);
561 if (0 == strcmp(lang, g_config_info->language)) {
562 /* language is valid */
563 is_valid_lang = true;
569 iter_lang = g_slist_next(iter_lang);
572 if (false == is_valid_lang) {
573 iter_lang = g_slist_nth(engine_info->languages, 0);
574 if (NULL != iter_lang) {
575 char *lang = iter_lang->data;
577 if (NULL != g_config_info->language)
578 free(g_config_info->language);
579 g_config_info->language = strdup(lang);
585 if (false == engine_info->support_silence_detection) {
586 if (true == g_config_info->silence_detection)
587 g_config_info->silence_detection = false;
591 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Engine changed");
592 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Engine : %s", g_config_info->engine_id);
593 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Setting : %s", g_config_info->setting);
594 SLOG(LOG_DEBUG, TAG_STTCONFIG, " language : %s", g_config_info->language);
595 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
596 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Credential : %s", g_config_info->credential ? "true" : "false");
599 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
600 g_config_info->silence_detection, g_config_info->credential)) {
601 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to save config"); //LCOV_EXCL_LINE
602 return STT_CONFIG_ERROR_OPERATION_FAILED;
605 return STT_CONFIG_ERROR_NONE;
608 static void __get_engine_list(const char* directory)
611 struct dirent *dirp = NULL;
613 if (NULL == directory) {
614 SLOG(LOG_ERROR, TAG_STTCONFIG, "[Directory ERROR] Directory is NULL"); //LCOV_EXCL_LINE
617 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Directory DEBUG] Directory: %s", directory);
620 dp = opendir(directory);
626 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
629 stt_engine_info_s* info;
630 char* filepath = NULL;
633 filesize = strlen(directory) + strlen(dirp->d_name) + 5;
634 filepath = (char*)calloc(filesize, sizeof(char));
636 if (NULL != filepath) {
637 snprintf(filepath, filesize, "%s/%s", directory, dirp->d_name);
639 SLOG(LOG_ERROR, TAG_STTCONFIG, "[Config ERROR] Memory not enough!!"); //LCOV_EXCL_LINE
643 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[File DEBUG] File path: %s", filepath);
645 if (0 == stt_parser_get_engine_info(filepath, &info)) {
646 g_engine_list = g_slist_append(g_engine_list, info);
649 if (NULL != filepath) {
654 } while (NULL != dirp);
658 SLOG(LOG_WARN, TAG_STTCONFIG, "[Config WARNING] Fail to open directory");
664 int stt_config_mgr_initialize(unsigned int uid)
666 stt_config_client_s* new_client = NULL;
668 if (0 < g_slist_length(g_config_client_list)) {
670 GSList *iter = g_slist_nth(g_config_client_list, 0);
672 while (NULL != iter) {
673 stt_config_client_s* client = (stt_config_client_s*)iter->data;
675 if (NULL != client && uid == client->uid) {
676 SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] uid(%u) has already registered", uid);
677 return STT_CONFIG_ERROR_NONE;
680 iter = g_slist_next(iter);
683 new_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
684 if (NULL == new_client) {
685 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to allocate memory");
686 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
688 new_client->uid = uid;
689 new_client->bool_cb = NULL;
690 new_client->engine_cb = NULL;
691 new_client->lang_cb = NULL;
692 new_client->user_data = NULL;
695 g_config_client_list = g_slist_append(g_config_client_list, new_client);
697 SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
698 return STT_CONFIG_ERROR_NONE;
701 /* Make directories */
702 if (0 != access(STT_CONFIG_BASE, F_OK)) {
703 if (0 != mkdir(STT_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
704 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to make directory : %s", STT_CONFIG_BASE);
705 __stt_config_release_client(uid);
706 return STT_CONFIG_ERROR_OPERATION_FAILED;
708 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Success to make directory : %s", STT_CONFIG_BASE);
712 if (0 != access(STT_HOME, F_OK)) {
713 if (0 != mkdir(STT_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
714 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to make directory : %s", STT_HOME);
715 __stt_config_release_client(uid);
716 return STT_CONFIG_ERROR_OPERATION_FAILED;
718 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Success to make directory : %s", STT_HOME);
722 if (0 != access(STT_DOWNLOAD_BASE, F_OK)) {
723 if (0 != mkdir(STT_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
724 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_BASE);
725 __stt_config_release_client(uid);
726 return STT_CONFIG_ERROR_OPERATION_FAILED;
728 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Success to make directory : %s", STT_DOWNLOAD_BASE);
732 if (0 != access(STT_DOWNLOAD_ENGINE_INFO, F_OK)) {
733 if (0 != mkdir(STT_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
734 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
735 __stt_config_release_client(uid);
736 return STT_CONFIG_ERROR_OPERATION_FAILED;
738 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Success to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
743 /* Get file name from default engine directory */
744 g_engine_list = NULL;
746 SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
748 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[CONFIG] Get default engine list");
749 __get_engine_list(STT_DEFAULT_ENGINE_INFO);
750 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[CONFIG] Get download engine list");
751 __get_engine_list(STT_DOWNLOAD_ENGINE_INFO);
753 __stt_config_mgr_print_engine_info();
755 if (0 != stt_parser_load_config(&g_config_info)) {
756 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to parse configure information");
757 __stt_config_release_client(uid);
758 __stt_config_release_engine();
759 return STT_CONFIG_ERROR_OPERATION_FAILED;
762 /* Check whether engine id is valid */
763 if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
764 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to get default engine");
765 __stt_config_release_client(uid);
766 __stt_config_release_engine();
767 stt_parser_unload_config(g_config_info);
768 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
771 if (true == g_config_info->auto_lang) {
772 /* Check language with display language */
773 __stt_config_set_auto_language();
775 if (false == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language)) {
776 /* Default language is not valid */
778 if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
779 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to select language");
780 __stt_config_release_client(uid);
781 __stt_config_release_engine();
782 stt_parser_unload_config(g_config_info);
783 return STT_CONFIG_ERROR_OPERATION_FAILED;
786 if (NULL != tmp_language) {
787 if (NULL != g_config_info->language) {
788 free(g_config_info->language);
789 g_config_info->language = strdup(tmp_language);
797 /* print stt-service config */
798 SLOG(LOG_DEBUG, TAG_STTCONFIG, "== STT service config ==");
799 SLOG(LOG_DEBUG, TAG_STTCONFIG, " engine : %s", g_config_info->engine_id);
800 SLOG(LOG_DEBUG, TAG_STTCONFIG, " setting : %s", g_config_info->setting);
801 SLOG(LOG_DEBUG, TAG_STTCONFIG, " auto language : %s", g_config_info->auto_lang ? "on" : "off");
802 SLOG(LOG_DEBUG, TAG_STTCONFIG, " language : %s", g_config_info->language);
803 SLOG(LOG_DEBUG, TAG_STTCONFIG, " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
804 SLOG(LOG_DEBUG, TAG_STTCONFIG, " credential : %s", g_config_info->credential ? "true" : "false");
805 SLOG(LOG_DEBUG, TAG_STTCONFIG, "===================");
807 if (0 != __stt_config_mgr_register_config_event()) {
808 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to register config event");
809 __stt_config_release_client(uid);
810 __stt_config_release_engine();
811 stt_parser_unload_config(g_config_info);
812 return STT_CONFIG_ERROR_OPERATION_FAILED;
815 /* Register to detect display language change */
816 vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
818 new_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
819 if (NULL == new_client) {
820 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
821 return STT_CONFIG_ERROR_OUT_OF_MEMORY;
823 new_client->uid = uid;
824 new_client->bool_cb = NULL;
825 new_client->engine_cb = NULL;
826 new_client->lang_cb = NULL;
827 new_client->user_data = NULL;
830 g_config_client_list = g_slist_append(g_config_client_list, new_client);
832 return STT_CONFIG_ERROR_NONE;
835 int stt_config_mgr_finalize(unsigned int uid)
837 if (0 < g_slist_length(g_config_client_list)) {
839 GSList *iter = g_slist_nth(g_config_client_list, 0);
840 while (NULL != iter) {
841 stt_config_client_s *temp_client = iter->data;
843 if (NULL != temp_client) {
844 if (uid == temp_client->uid) {
845 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
852 iter = g_slist_next(iter);
856 if (0 < g_slist_length(g_config_client_list)) {
857 SLOG(LOG_DEBUG, TAG_STTCONFIG, "Client count (%d)", g_slist_length(g_config_client_list)); //LCOV_EXCL_LINE
858 return STT_CONFIG_ERROR_NONE;
861 if (0 < g_slist_length(g_engine_list)) {
862 /* Get a first item */
863 GSList *iter = g_slist_nth(g_engine_list, 0);
864 while (NULL != iter) {
865 stt_engine_info_s *engine_info = iter->data;
867 if (NULL != engine_info) {
868 g_engine_list = g_slist_remove(g_engine_list, engine_info);
870 stt_parser_free_engine_info(engine_info);
873 iter = g_slist_nth(g_engine_list, 0);
877 vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
879 __stt_config_mgr_unregister_config_event();
881 if (NULL != g_config_info) {
882 stt_parser_unload_config(g_config_info);
883 g_config_info = NULL;
886 return STT_CONFIG_ERROR_NONE;
889 int stt_config_mgr_set_callback(unsigned 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 /* Call all callbacks of client*/
892 GSList *iter = g_slist_nth(g_config_client_list, 0);
893 while (NULL != iter) {
894 stt_config_client_s *temp_client = iter->data;
896 if (NULL != temp_client) {
897 if (uid == temp_client->uid) {
898 temp_client->engine_cb = engine_cb;
899 temp_client->lang_cb = lang_cb;
900 temp_client->bool_cb = bool_cb;
901 temp_client->user_data = user_data;
905 iter = g_slist_next(iter);
908 return STT_CONFIG_ERROR_NONE;
912 int stt_config_mgr_unset_callback(unsigned int uid)
914 /* Call all callbacks of client*/
915 GSList *iter = g_slist_nth(g_config_client_list, 0);
916 while (NULL != iter) {
917 stt_config_client_s *temp_client = iter->data;
919 if (NULL != temp_client) {
920 if (uid == temp_client->uid) {
921 temp_client->engine_cb = NULL;
922 temp_client->lang_cb = NULL;
923 temp_client->bool_cb = NULL;
924 temp_client->user_data = NULL;
928 iter = g_slist_next(iter);
931 return STT_CONFIG_ERROR_NONE;
935 int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data)
937 if (0 >= g_slist_length(g_config_client_list)) {
938 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
939 return STT_CONFIG_ERROR_INVALID_STATE;
942 if (NULL == callback) {
943 return STT_CONFIG_ERROR_INVALID_PARAMETER;
946 if (0 >= g_slist_length(g_engine_list)) {
947 SLOG(LOG_WARN, TAG_STTCONFIG, "[ERROR] Engine list is NULL");
948 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
951 /* Get a first item */
952 GSList *iter = g_slist_nth(g_engine_list, 0);
953 while (NULL != iter) {
954 stt_engine_info_s *engine_info = iter->data;
956 if (NULL == engine_info) {
957 SLOG(LOG_ERROR, TAG_STTCONFIG, " Engine info is NULL");
958 return STT_CONFIG_ERROR_OPERATION_FAILED;
961 if (false == callback(engine_info->uuid, engine_info->name,
962 engine_info->setting, engine_info->support_silence_detection, user_data)) {
966 iter = g_slist_next(iter);
969 return STT_CONFIG_ERROR_NONE;
972 int stt_config_mgr_get_engine(char** engine)
974 if (0 >= g_slist_length(g_config_client_list)) {
975 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized"); //LCOV_EXCL_LINE
976 return STT_CONFIG_ERROR_INVALID_STATE;
979 if (NULL == engine) {
980 return STT_CONFIG_ERROR_INVALID_PARAMETER;
983 if (NULL != g_config_info->engine_id) {
984 *engine = strdup(g_config_info->engine_id);
986 SLOG(LOG_ERROR, TAG_STTCONFIG, " Engine id is NULL"); //LCOV_EXCL_LINE
988 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
991 return STT_CONFIG_ERROR_NONE;
995 int __stt_config_set_buxtonkey(const char* engine)
998 struct buxton_client * bux_cli;
999 struct buxton_layer * bux_layer;
1000 struct buxton_value * bux_val;
1002 int ret = buxton_open(&bux_cli, NULL, NULL);
1004 SLOG(LOG_ERROR, TAG_STTCONFIG, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
1005 return STT_CONFIG_ERROR_OPERATION_FAILED;
1007 bux_layer = buxton_create_layer("system");
1008 if (NULL == bux_layer) {
1009 SLOG(LOG_ERROR, TAG_STTCONFIG, "[DBUS-BUXTON2] buxton_create_layer FAIL");
1010 buxton_close(bux_cli);
1012 return STT_CONFIG_ERROR_OPERATION_FAILED;
1014 bux_val = buxton_value_create_string(engine);
1015 if (NULL == bux_val) {
1016 SLOG(LOG_ERROR, TAG_STTCONFIG, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1017 buxton_free_layer(bux_layer);
1018 buxton_close(bux_cli);
1021 return STT_CONFIG_ERROR_OPERATION_FAILED;
1023 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1026 ret = buxton_set_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, bux_val);
1028 SLOG(LOG_ERROR, TAG_STTCONFIG, "[DBUS-BUXTON2] Fail to set value sync, ret(%d)", ret);
1029 buxton_value_free(bux_val);
1030 buxton_free_layer(bux_layer);
1031 buxton_close(bux_cli);
1036 return STT_CONFIG_ERROR_OPERATION_FAILED;
1038 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync: %s", STT_ENGINE_DB_DEFAULT);
1040 buxton_value_free(bux_val);
1041 buxton_free_layer(bux_layer);
1042 buxton_close(bux_cli);
1048 return STT_CONFIG_ERROR_NONE;
1051 int stt_config_mgr_set_engine(const char* engine)
1053 if (0 >= g_slist_length(g_config_client_list)) {
1054 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1055 return STT_CONFIG_ERROR_INVALID_STATE;
1058 if (NULL == g_config_info) {
1059 return STT_CONFIG_ERROR_OPERATION_FAILED;
1062 if (NULL == engine || NULL == g_config_info->engine_id) {
1063 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1066 /* Check current engine id with new engine id */
1067 if (0 == strcmp(g_config_info->engine_id, engine)) {
1071 SLOG(LOG_DEBUG, TAG_STTCONFIG, "New engine id : %s", engine);
1073 int ret = __stt_config_set_buxtonkey(engine);
1075 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] set buxtonkey Failed!!!");
1079 bool is_valid_engine = false;
1081 /* Get a first item */
1082 GSList *iter = g_slist_nth(g_engine_list, 0);
1083 while (NULL != iter) {
1084 stt_engine_info_s *engine_info = iter->data;
1086 if (NULL == engine_info) {
1087 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Engine info is NULL");
1088 iter = g_slist_next(iter);
1092 /* Check engine id is valid */
1093 if (0 != strcmp(engine, engine_info->uuid)) {
1094 iter = g_slist_next(iter);
1098 if (NULL != g_config_info->engine_id) {
1099 free(g_config_info->engine_id);
1100 g_config_info->engine_id = NULL;
1103 g_config_info->engine_id = strdup(engine);
1105 if (NULL != g_config_info->setting) {
1106 free(g_config_info->setting);
1107 g_config_info->setting = NULL;
1110 if (NULL != engine_info->setting) {
1111 g_config_info->setting = strdup(engine_info->setting);
1113 g_config_info->setting = NULL;
1116 /* Engine is valid*/
1117 bool is_valid_lang = false;
1119 /* Get a first item */
1120 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
1121 while (NULL != iter_lang) {
1122 /*Get handle data from list*/
1123 char *lang = iter_lang->data;
1125 SLOG(LOG_DEBUG, TAG_STTCONFIG, " %s", lang);
1126 if (NULL != lang && NULL != g_config_info->language) {
1127 if (0 == strcmp(lang, g_config_info->language)) {
1128 /* language is valid */
1129 is_valid_lang = true;
1131 free(g_config_info->language);
1132 g_config_info->language = strdup(lang);
1139 iter_lang = g_slist_next(iter_lang);
1142 if (false == is_valid_lang) {
1143 if (NULL != g_config_info->language) {
1144 free(g_config_info->language);
1145 g_config_info->language = NULL;
1147 iter_lang = g_slist_nth(engine_info->languages, 0);
1148 if (NULL == iter_lang) {
1149 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to get default language");
1153 char *lang = iter_lang->data;
1154 g_config_info->language = strdup(lang);
1159 if (false == engine_info->support_silence_detection) {
1160 if (true == g_config_info->silence_detection)
1161 g_config_info->silence_detection = false;
1164 if (false == engine_info->need_credential) {
1165 if (true == g_config_info->credential)
1166 g_config_info->credential = false;
1169 is_valid_engine = true;
1173 if (true == is_valid_engine) {
1174 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[Config] Engine changed");
1175 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Engine : %s", g_config_info->engine_id);
1176 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Setting : %s", g_config_info->setting);
1177 SLOG(LOG_DEBUG, TAG_STTCONFIG, " language : %s", g_config_info->language);
1178 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
1179 SLOG(LOG_DEBUG, TAG_STTCONFIG, " Credential : %s", g_config_info->credential ? "true" : "false");
1181 if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
1182 g_config_info->silence_detection, g_config_info->credential)) {
1183 SLOG(LOG_ERROR, TAG_STTCONFIG, " Fail to save config");
1184 return STT_CONFIG_ERROR_OPERATION_FAILED;
1187 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Engine id is not valid");
1188 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1194 int stt_config_mgr_get_engine_agreement(const char* engine, char** agreement)
1196 if (0 >= g_slist_length(g_engine_list)) {
1197 SLOG(LOG_ERROR, TAG_STTCONFIG, "There is no engine");
1198 return STT_CONFIG_ERROR_INVALID_STATE;
1201 if (NULL == agreement) {
1202 SLOG(LOG_ERROR, TAG_STTCONFIG, "Input parameter is NULL");
1203 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1206 char* current_engine = NULL;
1207 if (NULL == engine) {
1208 current_engine = strdup(g_config_info->engine_id);
1209 if (NULL == current_engine) {
1210 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to allocate memory");
1211 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1214 current_engine = strdup(engine);
1215 if (NULL == current_engine) {
1216 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to allocate memory");
1217 return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
1221 /* Get a first item */
1222 GSList *iter = g_slist_nth(g_engine_list, 0);
1223 while (NULL != iter) {
1224 stt_engine_info_s *engine_info = iter->data;
1226 if (NULL == engine_info) {
1227 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] engine info is NULL");
1228 if (NULL != current_engine) free(current_engine);
1229 return STT_CONFIG_ERROR_OPERATION_FAILED;
1232 if (0 != strcmp(current_engine, engine_info->uuid)) {
1233 iter = g_slist_next(iter);
1237 if (NULL != engine_info->agreement) {
1238 *agreement = strdup(engine_info->agreement);
1240 SLOG(LOG_WARN, TAG_STTCONFIG, "[WARNING] engine agreement is not support");
1245 if (NULL != current_engine) free(current_engine);
1247 return STT_CONFIG_ERROR_NONE;
1251 int stt_config_mgr_get_language_list(const char* engine_id, stt_config_supported_langauge_cb callback, void* user_data)
1253 if (0 >= g_slist_length(g_config_client_list)) {
1254 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized"); //LCOV_EXCL_LINE
1255 return STT_CONFIG_ERROR_INVALID_STATE;
1258 if (0 >= g_slist_length(g_engine_list)) {
1259 SLOG(LOG_ERROR, TAG_STTCONFIG, "There is no engine"); //LCOV_EXCL_LINE
1260 return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
1263 /* Get a first item */
1264 GSList *iter = g_slist_nth(g_engine_list, 0);
1265 while (NULL != iter) {
1266 stt_engine_info_s *engine_info = iter->data;
1268 if (NULL == engine_info) {
1269 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] engine info is NULL"); //LCOV_EXCL_LINE
1270 return STT_CONFIG_ERROR_OPERATION_FAILED;
1273 if (0 != strcmp(engine_id, engine_info->uuid)) {
1274 iter = g_slist_next(iter);
1278 /* Get a first item */
1279 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
1280 while (NULL != iter_lang) {
1281 /*Get handle data from list*/
1282 char* lang = iter_lang->data;
1284 SLOG(LOG_DEBUG, TAG_STTCONFIG, " %s", lang);
1285 if (false == callback(engine_info->uuid, lang, user_data))
1290 iter_lang = g_slist_next(iter_lang);
1295 return STT_CONFIG_ERROR_NONE;
1298 int stt_config_mgr_get_default_language(char** language)
1300 if (0 >= g_slist_length(g_config_client_list)) {
1301 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized"); //LCOV_EXCL_LINE
1302 return STT_CONFIG_ERROR_INVALID_STATE;
1305 if (NULL == language) {
1306 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1309 if (NULL != g_config_info->language) {
1310 *language = strdup(g_config_info->language);
1312 SLOG(LOG_ERROR, TAG_STTCONFIG, " language is NULL"); //LCOV_EXCL_LINE
1313 return STT_CONFIG_ERROR_OPERATION_FAILED;
1316 return STT_CONFIG_ERROR_NONE;
1320 int stt_config_mgr_set_default_language(const char* language)
1322 if (0 >= g_slist_length(g_config_client_list)) {
1323 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1324 return STT_CONFIG_ERROR_INVALID_STATE;
1327 if (NULL == language) {
1328 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1331 /* Check language is valid */
1332 if (NULL != g_config_info->language) {
1333 if (0 != stt_parser_set_language(language)) {
1334 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to save engine id");
1335 return STT_CONFIG_ERROR_OPERATION_FAILED;
1337 free(g_config_info->language);
1338 g_config_info->language = strdup(language);
1340 SLOG(LOG_ERROR, TAG_STTCONFIG, " language is NULL");
1341 return STT_CONFIG_ERROR_OPERATION_FAILED;
1344 return STT_CONFIG_ERROR_NONE;
1347 int stt_config_mgr_get_auto_language(bool* value)
1349 if (0 >= g_slist_length(g_config_client_list)) {
1350 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1351 return STT_CONFIG_ERROR_INVALID_STATE;
1354 if (NULL == value) {
1355 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1358 *value = g_config_info->auto_lang;
1360 return STT_CONFIG_ERROR_NONE;
1363 int stt_config_mgr_set_auto_language(bool value)
1365 if (0 >= g_slist_length(g_config_client_list)) {
1366 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1367 return STT_CONFIG_ERROR_INVALID_STATE;
1370 if (g_config_info->auto_lang != value) {
1371 /* Check language is valid */
1372 if (0 != stt_parser_set_auto_lang(value)) {
1373 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to save engine id");
1374 return STT_CONFIG_ERROR_OPERATION_FAILED;
1376 g_config_info->auto_lang = value;
1378 if (true == g_config_info->auto_lang) {
1379 __stt_config_set_auto_language();
1383 return STT_CONFIG_ERROR_NONE;
1386 int stt_config_mgr_get_silence_detection(bool* value)
1388 if (0 >= g_slist_length(g_config_client_list)) {
1389 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1390 return STT_CONFIG_ERROR_INVALID_STATE;
1394 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1396 *value = g_config_info->silence_detection;
1398 return STT_CONFIG_ERROR_NONE;
1401 int stt_config_mgr_set_silence_detection(bool value)
1403 if (0 >= g_slist_length(g_config_client_list)) {
1404 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1405 return STT_CONFIG_ERROR_INVALID_STATE;
1408 if (0 != stt_parser_set_silence_detection(value)) {
1409 SLOG(LOG_ERROR, TAG_STTCONFIG, "Fail to save engine id");
1410 return STT_CONFIG_ERROR_OPERATION_FAILED;
1413 g_config_info->silence_detection = value;
1415 return STT_CONFIG_ERROR_NONE;
1418 bool stt_config_check_default_engine_is_valid(const char* engine)
1420 if (0 >= g_slist_length(g_config_client_list)) {
1421 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1425 if (NULL == engine) {
1429 if (0 >= g_slist_length(g_engine_list))
1432 /* Get a first item */
1433 GSList *iter = g_slist_nth(g_engine_list, 0);
1434 while (NULL != iter) {
1435 stt_engine_info_s *engine_info = iter->data;
1437 if (NULL != engine_info && NULL != engine_info->uuid) {
1438 if (0 == strcmp(engine, engine_info->uuid)) {
1442 iter = g_slist_next(iter);
1448 bool stt_config_check_default_language_is_valid(const char* language)
1450 if (0 >= g_slist_length(g_config_client_list)) {
1451 SLOG(LOG_ERROR, TAG_STTCONFIG, "Not initialized");
1455 if (NULL == language) {
1459 if (NULL == g_config_info->engine_id) {
1460 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Default engine id is NULL");
1464 if (0 >= g_slist_length(g_engine_list))
1467 /* Get a first item */
1468 GSList *iter = g_slist_nth(g_engine_list, 0);
1469 while (NULL != iter) {
1470 stt_engine_info_s *engine_info = iter->data;
1472 if (NULL == engine_info) {
1473 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Engine info is NULL");
1474 iter = g_slist_next(iter);
1478 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1479 iter = g_slist_next(iter);
1483 /* Get a first item */
1484 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
1485 while (NULL != iter_lang) {
1486 char* lang = iter_lang->data;
1488 if (0 == strcmp(language, lang))
1492 iter_lang = g_slist_next(iter_lang);
1501 int __stt_config_mgr_print_engine_info()
1503 if (0 >= g_slist_length(g_engine_list)) {
1504 SLOG(LOG_DEBUG, TAG_STTCONFIG, "-------------- engine list -----------------"); //LCOV_EXCL_LINE
1505 SLOG(LOG_DEBUG, TAG_STTCONFIG, " No Engine in engine directory"); //LCOV_EXCL_LINE
1506 SLOG(LOG_DEBUG, TAG_STTCONFIG, "--------------------------------------------"); //LCOV_EXCL_LINE
1510 SLOG(LOG_DEBUG, TAG_STTCONFIG, "--------------- engine list -----------------");
1511 /* Get a first item */
1513 GSList *iter = g_slist_nth(g_engine_list, 0);
1514 while (NULL != iter) {
1515 stt_engine_info_s *engine_info = iter->data;
1517 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[%dth]", i);
1518 SLOG(LOG_DEBUG, TAG_STTCONFIG, " name : %s", engine_info->name);
1519 SLOG(LOG_DEBUG, TAG_STTCONFIG, " id : %s", engine_info->uuid);
1520 SLOG(LOG_DEBUG, TAG_STTCONFIG, " setting : %s", engine_info->setting);
1521 SLOG(LOG_DEBUG, TAG_STTCONFIG, " agreement : %s", engine_info->agreement);
1523 SLOG(LOG_DEBUG, TAG_STTCONFIG, " languages");
1524 if (g_slist_length(engine_info->languages) > 0) {
1525 /* Get a first item */
1526 GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
1529 while (NULL != iter_lang) {
1530 /*Get handle data from list*/
1531 char* lang = iter_lang->data;
1533 SLOG(LOG_DEBUG, TAG_STTCONFIG, " [%dth] %s", j, lang);
1536 iter_lang = g_slist_next(iter_lang);
1540 SLOG(LOG_ERROR, TAG_STTCONFIG, " language is NONE"); //LCOV_EXCL_LINE
1542 SLOG(LOG_DEBUG, TAG_STTCONFIG, " silence support : %s",
1543 engine_info->support_silence_detection ? "true" : "false");
1544 iter = g_slist_next(iter);
1547 SLOG(LOG_DEBUG, TAG_STTCONFIG, "--------------------------------------------");
1555 * time info functions
1557 static GSList* g_time_list = NULL;
1560 int stt_config_mgr_reset_time_info()
1562 /* Remove time info */
1563 GSList *iter = g_slist_nth(g_time_list, 0);
1564 while (NULL != iter) {
1565 stt_result_time_info_s *data = iter->data;
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, TAG_STTCONFIG, "Invalid parameter : 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, TAG_STTCONFIG, "[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 SECURE_SLOG(LOG_DEBUG, TAG_STTCONFIG, "[DEBUG] inside stt_config_mgr_add_time_info: index(%d), text(%s), start time(%ld), end_time(%ld)", info->index, (NULL == info->text) ? "NULL" : info->text, info->start_time, info->end_time);
1606 /* Add item to global list */
1607 g_time_list = g_slist_append(g_time_list, info);
1609 SLOG(LOG_DEBUG, TAG_STTCONFIG, "[DEBUG] inside stt_config_mgr_add_time_info: g_time_list length(%d)", g_slist_length(g_time_list));
1615 int stt_config_mgr_foreach_time_info(stt_config_result_time_cb callback, void* user_data)
1617 if (NULL == callback) {
1618 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Input parameter is NULL : callback function"); //LCOV_EXCL_LINE
1619 return STT_CONFIG_ERROR_INVALID_PARAMETER;
1622 GSList* temp_time = NULL;
1624 ret = stt_parser_get_time_info(&temp_time);
1626 SLOG(LOG_WARN, TAG_STTCONFIG, "[WARNING] Fail to get time info : %d", ret); //LCOV_EXCL_LINE
1627 return STT_CONFIG_ERROR_NONE;
1630 GSList *iter = NULL;
1632 /* Get a first item */
1633 iter = g_slist_nth(temp_time, 0);
1634 while (NULL != iter) {
1635 stt_result_time_info_s *data = iter->data;
1637 if (false == callback(data->index, data->event, data->text,
1638 data->start_time, data->end_time, user_data)) {
1643 iter = g_slist_next(iter);
1646 /* Remove time info */
1647 iter = g_slist_nth(temp_time, 0);
1648 while (NULL != iter) {
1649 stt_result_time_info_s *data = iter->data;
1652 temp_time = g_slist_remove(temp_time, data);
1654 if (NULL != data->text) {
1663 iter = g_slist_nth(temp_time, 0);
1666 return STT_CONFIG_ERROR_NONE;
1670 int stt_config_mgr_save_time_info_file()
1672 if (0 == g_slist_length(g_time_list)) {
1673 SLOG(LOG_WARN, TAG_STTCONFIG, "[WARNING] There is no time info to save");
1674 return STT_CONFIG_ERROR_OPERATION_FAILED;
1678 ret = stt_parser_set_time_info(g_time_list);
1680 SLOG(LOG_ERROR, TAG_STTCONFIG, "[ERROR] Fail to save time info : %d", ret);
1681 return STT_CONFIG_ERROR_OPERATION_FAILED;
1684 return STT_CONFIG_ERROR_NONE;
1687 int stt_config_mgr_remove_time_info_file()
1689 stt_parser_clear_time_info();
1691 return STT_CONFIG_ERROR_NONE;