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.
21 #include <sys/inotify.h>
24 #include "tts_config_mgr.h"
25 #include "tts_config_parser.h"
30 tts_config_engine_changed_cb engine_cb;
31 tts_config_voice_changed_cb voice_cb;
32 tts_config_speech_rate_changed_cb speech_cb;
33 tts_config_screen_reader_changed_cb screen_cb;
34 tts_config_pitch_changed_cb pitch_cb;
36 } tts_config_client_s;
38 extern char* tts_tag();
40 static GSList* g_engine_list = NULL;
42 static GSList* g_config_client_list = NULL;
44 static tts_config_s* g_config_info;
46 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
47 static int g_config_fd_noti;
48 static int g_config_wd_noti;
50 /* For engine directory monitoring */
51 static Ecore_Fd_Handler* g_dir_fd_handler = NULL;
55 int __tts_config_mgr_print_engine_info();
57 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
59 if (NULL == engine_id) {
60 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
65 tts_engine_info_s *engine_info = NULL;
67 if (0 >= g_slist_length(g_engine_list)) {
68 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
72 /* Get a first item */
73 iter = g_slist_nth(g_engine_list, 0);
75 while (NULL != iter) {
76 engine_info = iter->data;
78 if (NULL == engine_info) {
79 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
83 if (0 == strcmp(engine_id, engine_info->uuid)) {
84 SLOG(LOG_DEBUG, tts_tag(), "Default engine is valid : %s", engine_id);
88 iter = g_slist_next(iter);
91 /* Change default engine */
92 iter = g_slist_nth(g_engine_list, 0);
93 engine_info = iter->data;
95 if (NULL == g_config_info) {
96 return TTS_CONFIG_ERROR_OPERATION_FAILED;
99 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
100 if (NULL != g_config_info->setting) free(g_config_info->setting);
102 g_config_info->engine_id = strdup(engine_info->uuid);
103 g_config_info->setting = strdup(engine_info->setting);
105 SLOG(LOG_DEBUG, tts_tag(), "Default engine is changed : %s", g_config_info->engine_id);
107 /* Change is default voice */
108 GSList *iter_voice = NULL;
109 tts_config_voice_s* voice = NULL;
110 bool is_valid_voice = false;
112 /* Get a first item */
113 iter_voice = g_slist_nth(engine_info->voices, 0);
115 while (NULL != iter_voice) {
116 /*Get handle data from list*/
117 voice = iter_voice->data;
120 if (NULL != voice->language && NULL != g_config_info->language) {
121 if (0 == strcmp(voice->language, g_config_info->language)) {
122 if (voice->type == g_config_info->type) {
123 /* language is valid */
124 is_valid_voice = true;
126 free(g_config_info->language);
127 g_config_info->language = strdup(voice->language);
128 g_config_info->type = voice->type;
130 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
137 iter_voice = g_slist_next(iter_voice);
140 if (false == is_valid_voice) {
141 /* Select first voice as default */
142 if (NULL != g_config_info->language) {
143 free(g_config_info->language);
145 iter_voice = g_slist_nth(engine_info->voices, 0);
146 voice = iter_voice->data;
148 g_config_info->language = strdup(voice->language);
149 g_config_info->type = voice->type;
150 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
154 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
155 g_config_info->language, g_config_info->type)) {
156 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
157 return TTS_CONFIG_ERROR_OPERATION_FAILED;
163 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
165 if (NULL == engine_id || NULL == language) {
166 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
171 tts_engine_info_s *engine_info = NULL;
173 if (0 >= g_slist_length(g_engine_list)) {
174 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
178 /* Get a first item */
179 iter = g_slist_nth(g_engine_list, 0);
181 while (NULL != iter) {
182 engine_info = iter->data;
184 if (NULL == engine_info) {
185 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
189 if (0 != strcmp(engine_id, engine_info->uuid)) {
190 iter = g_slist_next(iter);
194 GSList *iter_voice = NULL;
195 tts_config_voice_s* voice = NULL;
197 if (g_slist_length(engine_info->voices) <= 0) {
198 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
199 iter = g_slist_next(iter);
203 /* Get a first item */
204 iter_voice = g_slist_nth(engine_info->voices, 0);
207 while (NULL != iter_voice) {
208 /*Get handle data from list*/
209 voice = iter_voice->data;
212 if (0 == strcmp(language, voice->language)) {
213 if (type == voice->type) {
220 iter_voice = g_slist_next(iter_voice);
230 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
232 if (NULL == engine_id || NULL == language) {
233 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
238 tts_engine_info_s *engine_info = NULL;
240 if (0 >= g_slist_length(g_engine_list)) {
241 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
245 /* Get a first item */
246 iter = g_slist_nth(g_engine_list, 0);
248 while (NULL != iter) {
249 engine_info = iter->data;
251 if (NULL == engine_info) {
252 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
256 if (0 != strcmp(engine_id, engine_info->uuid)) {
257 iter = g_slist_next(iter);
261 GSList *iter_voice = NULL;
262 tts_config_voice_s* voice = NULL;
264 if (g_slist_length(engine_info->voices) <= 0) {
265 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
269 /* Get a first item */
270 iter_voice = g_slist_nth(engine_info->voices, 0);
272 while (NULL != iter_voice) {
273 voice = iter_voice->data;
275 /* Default language */
276 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
277 *language = strdup(voice->language);
280 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
284 iter_voice = g_slist_next(iter_voice);
287 /* Not support base language */
289 *language = strdup(voice->language);
292 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
301 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
303 SLOG(LOG_DEBUG, tts_tag(), "===== Config changed callback event");
306 struct inotify_event event;
307 memset(&event, '\0', sizeof(struct inotify_event));
309 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
311 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
312 SLOG(LOG_DEBUG, tts_tag(), "=====");
313 SLOG(LOG_DEBUG, tts_tag(), " ");
314 return ECORE_CALLBACK_DONE;
317 if (IN_CLOSE_WRITE == event.mask) {
318 /* check config changed state */
320 char* setting = NULL;
322 bool auto_voice = g_config_info->auto_voice;
324 int speech_rate = -1;
328 tts_config_client_s* temp_client = NULL;
330 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
331 return ECORE_CALLBACK_PASS_ON;
334 if (NULL != engine || NULL != setting) {
335 if (NULL != engine) {
336 if (NULL != g_config_info->engine_id)
337 free(g_config_info->engine_id);
339 g_config_info->engine_id = strdup(engine);
341 if (NULL != setting) {
342 if (NULL != g_config_info->setting)
343 free(g_config_info->setting);
345 g_config_info->setting = strdup(setting);
348 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
350 /* Call all callbacks of client*/
351 iter = g_slist_nth(g_config_client_list, 0);
353 while (NULL != iter) {
354 temp_client = iter->data;
356 if (NULL != temp_client) {
357 if (NULL != temp_client->engine_cb) {
358 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
359 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
360 g_config_info->language, g_config_info->type,
361 g_config_info->auto_voice, temp_client->user_data);
365 iter = g_slist_next(iter);
369 if (auto_voice != g_config_info->auto_voice) {
370 g_config_info->auto_voice = auto_voice;
373 if (NULL != lang || -1 != voice_type) {
374 char* before_lang = NULL;
377 before_lang = strdup(g_config_info->language);
378 before_type = g_config_info->type;
381 if (NULL != g_config_info->language)
382 free(g_config_info->language);
384 g_config_info->language = strdup(lang);
386 if (-1 != voice_type) {
387 g_config_info->type = voice_type;
390 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
392 /* Call all callbacks of client*/
393 iter = g_slist_nth(g_config_client_list, 0);
395 while (NULL != iter) {
396 temp_client = iter->data;
398 if (NULL != temp_client) {
399 if (NULL != temp_client->voice_cb) {
400 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
401 temp_client->voice_cb(before_lang, before_type,
402 g_config_info->language, g_config_info->type,
403 g_config_info->auto_voice, temp_client->user_data);
407 iter = g_slist_next(iter);
410 if (NULL != before_lang) {
415 if (-1 != speech_rate) {
416 g_config_info->speech_rate = speech_rate;
418 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
420 /* Call all callbacks of client*/
421 iter = g_slist_nth(g_config_client_list, 0);
423 while (NULL != iter) {
424 temp_client = iter->data;
426 if (NULL != temp_client) {
427 if (NULL != temp_client->speech_cb) {
428 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
429 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
433 iter = g_slist_next(iter);
438 g_config_info->pitch = pitch;
440 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
442 /* Call all callbacks of client*/
443 iter = g_slist_nth(g_config_client_list, 0);
445 while (NULL != iter) {
446 temp_client = iter->data;
448 if (NULL != temp_client) {
449 if (NULL != temp_client->pitch_cb) {
450 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
451 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
455 iter = g_slist_next(iter);
459 if (NULL != engine) free(engine);
460 if (NULL != setting) free(setting);
461 if (NULL != lang) free(lang);
463 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
466 SLOG(LOG_DEBUG, tts_tag(), "=====");
467 SLOG(LOG_DEBUG, tts_tag(), " ");
469 return ECORE_CALLBACK_PASS_ON;
472 int __tts_config_mgr_register_config_event()
474 /* get file notification handler */
480 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
483 g_config_fd_noti = fd;
485 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE);
486 g_config_wd_noti = wd;
488 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
489 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
490 if (NULL == g_config_fd_handler_noti) {
491 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
495 /* Set non-blocking mode of file */
497 value = fcntl(fd, F_GETFL, 0);
500 if (0 > fcntl(fd, F_SETFL, value)) {
501 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
507 int __tts_config_mgr_unregister_config_event()
509 /* delete inotify variable */
510 ecore_main_fd_handler_del(g_config_fd_handler_noti);
511 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
512 close(g_config_fd_noti);
517 int __tts_config_set_auto_language()
520 value = vconf_get_str(TTS_LANGSET_KEY);
522 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
526 char temp_lang[6] = {'\0', };
527 strncpy(temp_lang, value, 5);
530 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
531 /* tts default voice change */
532 if (NULL == g_config_info->language) {
533 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
537 char* before_lang = NULL;
540 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
541 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
545 before_lang = strdup(g_config_info->language);
546 before_type = g_config_info->type;
548 free(g_config_info->language);
549 g_config_info->language = strdup(temp_lang);
551 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
552 g_config_info->language, g_config_info->type);
555 tts_config_client_s* temp_client = NULL;
557 /* Call all callbacks of client*/
558 iter = g_slist_nth(g_config_client_list, 0);
560 while (NULL != iter) {
561 temp_client = iter->data;
563 if (NULL != temp_client) {
564 if (NULL != temp_client->voice_cb) {
565 temp_client->voice_cb(before_lang, before_type,
566 g_config_info->language, g_config_info->type,
567 g_config_info->auto_voice, temp_client->user_data);
571 iter = g_slist_next(iter);
574 if (NULL != before_lang) {
578 /* Display language is not valid */
579 char* tmp_language = NULL;
581 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
582 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
586 if (NULL == tmp_language) {
587 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
591 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
592 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
596 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
597 tmp_language, tmp_type);
600 tts_config_client_s* temp_client = NULL;
602 /* Call all callbacks of client*/
603 iter = g_slist_nth(g_config_client_list, 0);
605 while (NULL != iter) {
606 temp_client = iter->data;
608 if (NULL != temp_client) {
609 if (NULL != temp_client->voice_cb) {
610 temp_client->voice_cb(g_config_info->language, g_config_info->type,
611 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
615 iter = g_slist_next(iter);
618 if (NULL != g_config_info->language) {
619 free(g_config_info->language);
620 g_config_info->language = strdup(tmp_language);
623 g_config_info->type = tmp_type;
631 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
633 if (true == g_config_info->auto_voice) {
634 __tts_config_set_auto_language();
640 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
644 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
646 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
651 tts_config_client_s* temp_client = NULL;
653 /* Call all callbacks of client*/
654 iter = g_slist_nth(g_config_client_list, 0);
656 while (NULL != iter) {
657 temp_client = iter->data;
659 if (NULL != temp_client) {
660 if (NULL != temp_client->screen_cb) {
661 temp_client->screen_cb((bool)screen_reader);
665 iter = g_slist_next(iter);
669 int __tts_config_release_client(int uid)
672 tts_config_client_s* temp_client = NULL;
674 if (0 < g_slist_length(g_config_client_list)) {
676 iter = g_slist_nth(g_config_client_list, 0);
678 while (NULL != iter) {
679 temp_client = iter->data;
681 if (NULL != temp_client) {
682 if (uid == temp_client->uid) {
683 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
690 iter = g_slist_next(iter);
694 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
696 return g_slist_length(g_config_client_list);
699 void __tts_config_release_engine()
702 tts_engine_info_s *engine_info = NULL;
704 if (0 < g_slist_length(g_engine_list)) {
706 /* Get a first item */
707 iter = g_slist_nth(g_engine_list, 0);
709 while (NULL != iter) {
710 engine_info = iter->data;
712 if (NULL != engine_info) {
713 g_engine_list = g_slist_remove(g_engine_list, engine_info);
715 tts_parser_free_engine_info(engine_info);
718 iter = g_slist_nth(g_engine_list, 0);
725 int __tts_config_mgr_get_engine_info()
730 struct dirent *dirp = NULL;
732 char filepath[512] = {'\0',};
734 tts_engine_info_s* info = NULL;
736 g_engine_list = NULL;
738 /* Get engine info from default engine directory */
739 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
741 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DEFAULT_ENGINE_INFO);
744 ret = readdir_r(dp, &entry, &dirp);
746 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
751 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
752 if (filesize >= 512) {
753 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
758 memset(filepath, '\0', 512);
759 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
761 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
763 if (0 == tts_parser_get_engine_info(filepath, &info)) {
764 g_engine_list = g_slist_append(g_engine_list, info);
767 } while (NULL != dirp);
772 if (0 >= g_slist_length(g_engine_list)) {
773 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
780 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
782 SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
785 struct inotify_event event;
786 memset(&event, '\0', sizeof(struct inotify_event));
788 length = read(g_dir_fd, &event, sizeof(struct inotify_event));
790 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
791 SLOG(LOG_DEBUG, tts_tag(), "=====");
792 SLOG(LOG_DEBUG, tts_tag(), " ");
793 return ECORE_CALLBACK_DONE;
796 if (IN_CLOSE_WRITE == event.mask) {
797 int ret = __tts_config_mgr_get_engine_info();
799 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
801 __tts_config_mgr_print_engine_info();
802 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
803 if (false == support) {
804 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
805 char* temp_lang = NULL;
807 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
809 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
812 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
814 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
816 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
818 if (NULL != temp_lang) free(temp_lang);
821 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
824 SLOG(LOG_DEBUG, tts_tag(), "=====");
825 SLOG(LOG_DEBUG, tts_tag(), " ");
827 return ECORE_CALLBACK_PASS_ON;
830 static int __tts_config_mgr_register_engine_config_updated_event()
832 /* For engine directory monitoring */
833 g_dir_fd = inotify_init();
835 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
839 /* FIX_ME *//* It doesn't need check engine directory, because daemon will change engine-process */
840 g_dir_wd = inotify_add_watch(g_dir_fd, TTS_DEFAULT_ENGINE_INFO, IN_CLOSE_WRITE);
842 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
846 g_dir_fd_handler = ecore_main_fd_handler_add(g_dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)__tts_config_mgr_engine_config_inotify_event_callback, NULL, NULL, NULL);
847 if (NULL == g_dir_fd_handler) {
848 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
852 /* Set non-blocking mode of file */
854 value = fcntl(g_dir_fd, F_GETFL, 0);
857 if (0 > fcntl(g_dir_fd, F_SETFL, value)) {
858 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
864 static int __tts_config_mgr_unregister_engine_config_updated_event()
866 /* delete inotify variable */
867 ecore_main_fd_handler_del(g_dir_fd_handler);
868 inotify_rm_watch(g_dir_fd, g_dir_wd);
874 int tts_config_mgr_initialize(int uid)
878 tts_config_client_s* temp_client = NULL;
881 if (0 < g_slist_length(g_config_client_list)) {
883 iter = g_slist_nth(g_config_client_list, 0);
885 while (NULL != iter) {
886 get_uid = iter->data;
888 if (uid == *get_uid) {
889 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
893 iter = g_slist_next(iter);
896 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
897 if (NULL == temp_client) {
898 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
899 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
901 temp_client->uid = uid;
903 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
905 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
908 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
909 if (NULL == temp_client) {
910 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
911 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
913 temp_client->uid = uid;
915 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
918 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
919 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
920 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
923 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
927 if (0 != __tts_config_mgr_get_engine_info()) {
928 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
929 __tts_config_release_client(uid);
930 __tts_config_release_engine();
931 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
934 __tts_config_mgr_print_engine_info();
936 if (0 != tts_parser_load_config(&g_config_info)) {
937 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
938 __tts_config_release_client(uid);
939 __tts_config_release_engine();
940 return TTS_CONFIG_ERROR_OPERATION_FAILED;
943 /* Check whether engine id is valid */
944 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
945 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
946 __tts_config_release_client(uid);
947 __tts_config_release_engine();
948 tts_parser_unload_config(g_config_info);
949 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
952 if (true == g_config_info->auto_voice) {
953 /* Check language with display language */
954 __tts_config_set_auto_language();
956 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
957 /* Default language is not valid */
958 char* tmp_language = NULL;
960 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
961 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
962 __tts_config_release_client(uid);
963 __tts_config_release_engine();
964 tts_parser_unload_config(g_config_info);
965 return TTS_CONFIG_ERROR_OPERATION_FAILED;
968 if (NULL != tmp_language) {
969 if (NULL != g_config_info->language) {
970 free(g_config_info->language);
971 g_config_info->language = strdup(tmp_language);
974 g_config_info->type = tmp_type;
978 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
979 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
980 __tts_config_release_client(uid);
981 __tts_config_release_engine();
982 tts_parser_unload_config(g_config_info);
983 return TTS_CONFIG_ERROR_OPERATION_FAILED;
989 /* print daemon config */
990 SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
991 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
992 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
993 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
994 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
995 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
996 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
997 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
998 SLOG(LOG_DEBUG, tts_tag(), "=================");
1000 if (0 != __tts_config_mgr_register_config_event()) {
1001 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1002 __tts_config_release_client(uid);
1003 __tts_config_release_engine();
1004 tts_parser_unload_config(g_config_info);
1005 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1008 /* Register to detect display language change */
1009 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1010 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1012 /* For engine directory monitoring */
1013 if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1014 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1015 __tts_config_release_client(uid);
1016 __tts_config_release_engine();
1017 tts_parser_unload_config(g_config_info);
1018 __tts_config_mgr_unregister_config_event();
1019 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1025 int tts_config_mgr_finalize(int uid)
1027 if (0 < __tts_config_release_client(uid)) {
1031 tts_config_mgr_unset_callback(uid);
1033 __tts_config_release_engine();
1035 tts_parser_unload_config(g_config_info);
1037 __tts_config_mgr_unregister_engine_config_updated_event();
1039 __tts_config_mgr_unregister_config_event();
1041 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1042 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1047 int tts_config_mgr_set_callback(int uid,
1048 tts_config_engine_changed_cb engine_cb,
1049 tts_config_voice_changed_cb voice_cb,
1050 tts_config_speech_rate_changed_cb speech_cb,
1051 tts_config_pitch_changed_cb pitch_cb,
1054 GSList *iter = NULL;
1055 tts_config_client_s* temp_client = NULL;
1057 /* Call all callbacks of client*/
1058 iter = g_slist_nth(g_config_client_list, 0);
1060 while (NULL != iter) {
1061 temp_client = iter->data;
1063 if (NULL != temp_client) {
1064 if (uid == temp_client->uid) {
1065 temp_client->engine_cb = engine_cb;
1066 temp_client->voice_cb = voice_cb;
1067 temp_client->speech_cb = speech_cb;
1068 temp_client->pitch_cb = pitch_cb;
1069 temp_client->user_data = user_data;
1073 iter = g_slist_next(iter);
1078 int tts_config_mgr_unset_callback(int uid)
1080 GSList *iter = NULL;
1081 tts_config_client_s* temp_client = NULL;
1083 /* Call all callbacks of client*/
1084 iter = g_slist_nth(g_config_client_list, 0);
1086 while (NULL != iter) {
1087 temp_client = iter->data;
1089 if (NULL != temp_client) {
1090 if (uid == temp_client->uid) {
1091 temp_client->engine_cb = NULL;
1092 temp_client->voice_cb = NULL;
1093 temp_client->speech_cb = NULL;
1094 temp_client->pitch_cb = NULL;
1095 temp_client->user_data = NULL;
1099 iter = g_slist_next(iter);
1105 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1107 if (NULL == callback) {
1108 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1109 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1112 GSList *iter = NULL;
1113 tts_config_client_s* temp_client = NULL;
1115 /* Call all callbacks of client*/
1116 iter = g_slist_nth(g_config_client_list, 0);
1118 while (NULL != iter) {
1119 temp_client = iter->data;
1121 if (NULL != temp_client) {
1122 if (uid == temp_client->uid) {
1123 temp_client->screen_cb = callback;
1127 iter = g_slist_next(iter);
1132 int tts_config_unset_screen_reader_callback(int uid)
1134 GSList *iter = NULL;
1135 tts_config_client_s* temp_client = NULL;
1137 /* Call all callbacks of client*/
1138 iter = g_slist_nth(g_config_client_list, 0);
1140 while (NULL != iter) {
1141 temp_client = iter->data;
1143 if (NULL != temp_client) {
1144 if (uid == temp_client->uid) {
1145 temp_client->screen_cb = NULL;
1149 iter = g_slist_next(iter);
1155 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1157 if (0 >= g_slist_length(g_config_client_list)) {
1158 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1159 return TTS_CONFIG_ERROR_INVALID_STATE;
1162 GSList *iter = NULL;
1163 tts_engine_info_s *engine_info = NULL;
1165 if (0 >= g_slist_length(g_engine_list)) {
1166 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1167 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1170 /* Get a first item */
1171 iter = g_slist_nth(g_engine_list, 0);
1173 while (NULL != iter) {
1174 engine_info = iter->data;
1176 if (NULL != engine_info) {
1177 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1182 iter = g_slist_next(iter);
1188 int tts_config_mgr_get_engine(char** engine)
1190 if (0 >= g_slist_length(g_config_client_list)) {
1191 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1192 return TTS_CONFIG_ERROR_INVALID_STATE;
1195 if (NULL == engine) {
1196 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1197 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1200 if (NULL != g_config_info->engine_id) {
1201 /* Check engine id is valid */
1202 GSList *iter = NULL;
1203 tts_engine_info_s *engine_info = NULL;
1205 if (0 >= g_slist_length(g_engine_list)) {
1206 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1207 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1210 /* Get a first item */
1211 iter = g_slist_nth(g_engine_list, 0);
1213 while (NULL != iter) {
1214 engine_info = iter->data;
1216 if (NULL != engine_info) {
1217 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1218 *engine = strdup(g_config_info->engine_id);
1222 iter = g_slist_next(iter);
1225 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1227 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1230 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1233 int tts_config_mgr_set_engine(const char* engine)
1235 if (0 >= g_slist_length(g_config_client_list)) {
1236 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1237 return TTS_CONFIG_ERROR_INVALID_STATE;
1241 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1243 /* Check current engine id with new engine id */
1244 if (NULL != g_config_info->engine_id) {
1245 if (0 == strcmp(g_config_info->engine_id, engine))
1249 if (0 >= g_slist_length(g_engine_list)) {
1250 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1251 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1254 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1256 GSList *iter = NULL;
1257 tts_engine_info_s *engine_info = NULL;
1258 bool is_valid_engine = false;
1260 /* Get a first item */
1261 iter = g_slist_nth(g_engine_list, 0);
1263 while (NULL != iter) {
1264 engine_info = iter->data;
1266 if (NULL == engine_info) {
1267 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1268 iter = g_slist_next(iter);
1272 /* Check engine id is valid */
1273 if (0 != strcmp(engine, engine_info->uuid)) {
1274 iter = g_slist_next(iter);
1278 if (NULL != g_config_info->engine_id)
1279 free(g_config_info->engine_id);
1281 g_config_info->engine_id = strdup(engine);
1283 if (NULL != g_config_info->setting)
1284 free(g_config_info->setting);
1286 if (NULL != engine_info->setting)
1287 g_config_info->setting = strdup(engine_info->setting);
1289 /* Engine is valid*/
1290 GSList *iter_voice = NULL;
1291 tts_config_voice_s* voice = NULL;
1292 bool is_valid_voice = false;
1294 /* Get a first item */
1295 iter_voice = g_slist_nth(engine_info->voices, 0);
1297 while (NULL != iter_voice) {
1298 /*Get handle data from list*/
1299 voice = iter_voice->data;
1301 if (NULL != voice) {
1302 if (NULL == voice->language)
1304 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1306 if (0 == strcmp(voice->language, g_config_info->language)) {
1307 if (voice->type == g_config_info->type) {
1308 /* language is valid */
1309 is_valid_voice = true;
1310 g_config_info->type = voice->type;
1317 iter_voice = g_slist_next(iter_voice);
1320 if (false == is_valid_voice) {
1321 if (NULL != g_config_info->language) {
1322 free(g_config_info->language);
1324 iter_voice = g_slist_nth(engine_info->voices, 0);
1325 if (NULL != iter_voice) {
1326 voice = iter_voice->data;
1327 if (NULL != voice) {
1328 if (NULL != voice->language)
1329 g_config_info->language = strdup(voice->language);
1330 g_config_info->type = voice->type;
1336 is_valid_engine = true;
1340 if (true == is_valid_engine) {
1341 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1342 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1343 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1344 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1345 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1347 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1348 g_config_info->language, g_config_info->type)) {
1349 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1350 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1353 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1354 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1360 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1362 if (0 >= g_slist_length(g_config_client_list)) {
1363 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1364 return TTS_CONFIG_ERROR_INVALID_STATE;
1367 if (0 >= g_slist_length(g_engine_list)) {
1368 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1369 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1372 GSList *iter = NULL;
1373 tts_engine_info_s *engine_info = NULL;
1375 /* Get a first item */
1376 iter = g_slist_nth(g_engine_list, 0);
1378 while (NULL != iter) {
1379 engine_info = iter->data;
1381 if (NULL == engine_info) {
1382 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1383 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1386 if (0 != strcmp(engine_id, engine_info->uuid)) {
1387 iter = g_slist_next(iter);
1391 GSList *iter_voice = NULL;
1392 tts_config_voice_s* voice = NULL;
1394 /* Get a first item */
1395 iter_voice = g_slist_nth(engine_info->voices, 0);
1397 while (NULL != iter_voice) {
1398 /*Get handle data from list*/
1399 voice = iter_voice->data;
1401 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1402 if (NULL != voice->language) {
1403 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1408 iter_voice = g_slist_next(iter_voice);
1416 int tts_config_mgr_get_voice(char** language, int* type)
1418 if (0 >= g_slist_length(g_config_client_list)) {
1419 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1420 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1423 if (0 >= g_slist_length(g_engine_list)) {
1424 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1425 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1428 if (NULL == language || NULL == type)
1429 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1431 if (NULL != g_config_info->language) {
1432 *language = strdup(g_config_info->language);
1433 *type = g_config_info->type;
1435 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1436 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1442 int tts_config_mgr_set_voice(const char* language, int type)
1444 if (0 >= g_slist_length(g_config_client_list)) {
1445 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1446 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1449 if (NULL == language) {
1450 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1451 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1454 if (0 >= g_slist_length(g_engine_list)) {
1455 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1456 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1459 /* Check language is valid */
1460 if (NULL != g_config_info->language) {
1461 if (0 != tts_parser_set_voice(language, type)) {
1462 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1463 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1465 free(g_config_info->language);
1466 g_config_info->language = strdup(language);
1467 g_config_info->type = type;
1470 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1471 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1477 int tts_config_mgr_get_auto_voice(bool* value)
1479 if (0 >= g_slist_length(g_config_client_list)) {
1480 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1481 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1485 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1487 *value = g_config_info->auto_voice;
1492 int tts_config_mgr_set_auto_voice(bool value)
1494 if (0 >= g_slist_length(g_config_client_list)) {
1495 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1496 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1499 if (g_config_info->auto_voice != value) {
1500 /* Check language is valid */
1501 if (0 != tts_parser_set_auto_voice(value)) {
1502 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1503 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1505 g_config_info->auto_voice = value;
1507 if (true == g_config_info->auto_voice) {
1508 __tts_config_set_auto_language();
1515 int tts_config_mgr_get_speech_rate(int* value)
1517 if (0 >= g_slist_length(g_config_client_list)) {
1518 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1519 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1522 if (NULL == value) {
1523 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1526 *value = g_config_info->speech_rate;
1531 int tts_config_mgr_set_speech_rate(int value)
1533 if (0 >= g_slist_length(g_config_client_list)) {
1534 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1535 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1538 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1539 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1540 if (0 != tts_parser_set_speech_rate(value)) {
1541 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1542 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1545 g_config_info->speech_rate = value;
1547 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1553 int tts_config_mgr_get_pitch(int* value)
1555 if (0 >= g_slist_length(g_config_client_list)) {
1556 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1557 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1560 if (NULL == value) {
1561 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1564 GSList *iter = NULL;
1565 tts_engine_info_s *engine_info = NULL;
1567 if (0 >= g_slist_length(g_engine_list)) {
1568 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1569 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1572 /* Get a first item */
1573 iter = g_slist_nth(g_engine_list, 0);
1575 while (NULL != iter) {
1576 engine_info = iter->data;
1578 if (NULL == engine_info) {
1579 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1580 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1583 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1584 iter = g_slist_next(iter);
1588 if (false == engine_info->pitch_support) {
1589 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1595 *value = g_config_info->pitch;
1600 int tts_config_mgr_set_pitch(int value)
1602 if (0 >= g_slist_length(g_config_client_list)) {
1603 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1607 GSList *iter = NULL;
1608 tts_engine_info_s *engine_info = NULL;
1610 if (0 >= g_slist_length(g_engine_list)) {
1611 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1612 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1615 /* Get a first item */
1616 iter = g_slist_nth(g_engine_list, 0);
1618 while (NULL != iter) {
1619 engine_info = iter->data;
1621 if (NULL == engine_info) {
1622 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1623 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1626 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1627 iter = g_slist_next(iter);
1631 if (false == engine_info->pitch_support) {
1632 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1638 if (0 != tts_parser_set_pitch(value)) {
1639 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1640 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1643 g_config_info->pitch = value;
1648 bool tts_config_check_default_engine_is_valid(const char* engine)
1650 if (0 >= g_slist_length(g_config_client_list)) {
1651 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1658 if (0 >= g_slist_length(g_engine_list))
1661 GSList *iter = NULL;
1662 tts_engine_info_s *engine_info = NULL;
1664 /* Get a first item */
1665 iter = g_slist_nth(g_engine_list, 0);
1667 while (NULL != iter) {
1668 engine_info = iter->data;
1670 if (NULL != engine_info) {
1671 if (0 == strcmp(engine, engine_info->uuid)) {
1675 iter = g_slist_next(iter);
1681 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1683 if (0 >= g_slist_length(g_config_client_list)) {
1684 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1688 if (NULL == language)
1691 if (NULL == g_config_info->engine_id) {
1692 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1696 if (0 >= g_slist_length(g_engine_list))
1699 GSList *iter = NULL;
1700 tts_engine_info_s *engine_info = NULL;
1702 /* Get a first item */
1703 iter = g_slist_nth(g_engine_list, 0);
1705 while (NULL != iter) {
1706 engine_info = iter->data;
1708 if (NULL == engine_info) {
1709 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1710 iter = g_slist_next(iter);
1714 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1715 iter = g_slist_next(iter);
1719 GSList *iter_voice = NULL;
1720 tts_config_voice_s* voice = NULL;
1722 /* Get a first item */
1723 iter_voice = g_slist_nth(engine_info->voices, 0);
1725 while (NULL != iter_voice) {
1726 voice = iter_voice->data;
1728 if (0 == strcmp(language, voice->language) && voice->type == type)
1732 iter_voice = g_slist_next(iter_voice);
1742 int __tts_config_mgr_print_engine_info()
1744 GSList *iter = NULL;
1745 tts_engine_info_s *engine_info = NULL;
1747 if (0 >= g_slist_length(g_engine_list)) {
1748 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1749 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1750 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1754 /* Get a first item */
1755 iter = g_slist_nth(g_engine_list, 0);
1757 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
1760 while (NULL != iter) {
1761 engine_info = iter->data;
1763 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
1764 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
1765 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
1766 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
1768 SLOG(LOG_DEBUG, tts_tag(), " Voices");
1769 GSList *iter_voice = NULL;
1770 tts_config_voice_s* voice = NULL;
1772 if (g_slist_length(engine_info->voices) > 0) {
1773 /* Get a first item */
1774 iter_voice = g_slist_nth(engine_info->voices, 0);
1777 while (NULL != iter_voice) {
1778 /*Get handle data from list*/
1779 voice = iter_voice->data;
1781 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
1784 iter_voice = g_slist_next(iter_voice);
1788 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
1790 iter = g_slist_next(iter);
1793 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");