2 * Copyright (c) 2011-2014 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;
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->engine_id) free(g_config_info->engine_id);
96 if (NULL != g_config_info->setting) free(g_config_info->setting);
98 g_config_info->engine_id = strdup(engine_info->uuid);
99 g_config_info->setting = strdup(engine_info->setting);
101 SLOG(LOG_DEBUG, tts_tag(), "Default engine is changed : %s", g_config_info->engine_id);
103 /* Change is default voice */
104 GSList *iter_voice = NULL;
105 tts_config_voice_s* voice = NULL;
106 bool is_valid_voice = false;
108 /* Get a first item */
109 iter_voice = g_slist_nth(engine_info->voices, 0);
111 while (NULL != iter_voice) {
112 /*Get handle data from list*/
113 voice = iter_voice->data;
115 if (NULL != voice && NULL != g_config_info) {
116 if (NULL != voice->language && NULL != g_config_info->language) {
117 if (0 == strcmp(voice->language, g_config_info->language)) {
118 if (voice->type == g_config_info->type) {
119 /* language is valid */
120 is_valid_voice = true;
122 free(g_config_info->language);
123 g_config_info->language = strdup(voice->language);
124 g_config_info->type = voice->type;
126 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
133 iter_voice = g_slist_next(iter_voice);
136 if (false == is_valid_voice) {
137 /* Select first voice as default */
138 if (NULL != g_config_info->language) {
139 free(g_config_info->language);
141 iter_voice = g_slist_nth(engine_info->voices, 0);
142 voice = iter_voice->data;
144 g_config_info->language = strdup(voice->language);
145 g_config_info->type = voice->type;
146 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
150 if ( 0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
151 g_config_info->language, g_config_info->type)) {
152 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
153 return TTS_CONFIG_ERROR_OPERATION_FAILED;
159 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
161 if (NULL == engine_id || NULL == language) {
162 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
167 tts_engine_info_s *engine_info = NULL;
169 if (0 >= g_slist_length(g_engine_list)) {
170 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
174 /* Get a first item */
175 iter = g_slist_nth(g_engine_list, 0);
177 while (NULL != iter) {
178 engine_info = iter->data;
180 if (NULL == engine_info) {
181 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
185 if (0 != strcmp(engine_id, engine_info->uuid)) {
186 iter = g_slist_next(iter);
190 GSList *iter_voice = NULL;
191 tts_config_voice_s* voice = NULL;
193 if (g_slist_length(engine_info->voices) <= 0) {
194 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
195 iter = g_slist_next(iter);
199 /* Get a first item */
200 iter_voice = g_slist_nth(engine_info->voices, 0);
203 while (NULL != iter_voice) {
204 /*Get handle data from list*/
205 voice = iter_voice->data;
208 if (0 == strcmp(language, voice->language)) {
209 if (type == voice->type) {
216 iter_voice = g_slist_next(iter_voice);
226 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
228 if (NULL == engine_id || NULL == language) {
229 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
234 tts_engine_info_s *engine_info = NULL;
236 if (0 >= g_slist_length(g_engine_list)) {
237 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
241 /* Get a first item */
242 iter = g_slist_nth(g_engine_list, 0);
244 while (NULL != iter) {
245 engine_info = iter->data;
247 if (NULL == engine_info) {
248 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
252 if (0 != strcmp(engine_id, engine_info->uuid)) {
253 iter = g_slist_next(iter);
257 GSList *iter_voice = NULL;
258 tts_config_voice_s* voice = NULL;
260 if (g_slist_length(engine_info->voices) <= 0) {
261 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
265 /* Get a first item */
266 iter_voice = g_slist_nth(engine_info->voices, 0);
268 while (NULL != iter_voice) {
269 voice = iter_voice->data;
271 /* Default language */
272 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
273 *language = strdup(voice->language);
276 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
280 iter_voice = g_slist_next(iter_voice);
283 /* Not support base language */
285 *language = strdup(voice->language);
288 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
297 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
299 SLOG(LOG_DEBUG, tts_tag(), "===== Config changed callback event");
302 struct inotify_event event;
303 memset(&event, '\0', sizeof(struct inotify_event));
305 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
307 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
308 SLOG(LOG_DEBUG, tts_tag(), "=====");
309 SLOG(LOG_DEBUG, tts_tag(), " ");
310 return ECORE_CALLBACK_DONE;
313 if (IN_CLOSE_WRITE == event.mask) {
314 /* check config changed state */
316 char* setting = NULL;
318 bool auto_voice = g_config_info->auto_voice;
320 int speech_rate = -1;
324 tts_config_client_s* temp_client = NULL;
326 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
327 return ECORE_CALLBACK_PASS_ON;
330 if (NULL != engine || NULL != setting) {
331 if (NULL != engine) {
332 if (NULL != g_config_info->engine_id)
333 free(g_config_info->engine_id);
335 g_config_info->engine_id = strdup(engine);
337 if (NULL != setting) {
338 if (NULL != g_config_info->setting)
339 free(g_config_info->setting);
341 g_config_info->setting = strdup(setting);
344 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
346 /* Call all callbacks of client*/
347 iter = g_slist_nth(g_config_client_list, 0);
349 while (NULL != iter) {
350 temp_client = iter->data;
352 if (NULL != temp_client) {
353 if (NULL != temp_client->engine_cb) {
354 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
355 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
356 g_config_info->language, g_config_info->type,
357 g_config_info->auto_voice, temp_client->user_data);
361 iter = g_slist_next(iter);
365 if (auto_voice != g_config_info->auto_voice) {
366 g_config_info->auto_voice = auto_voice;
369 if (NULL != lang || -1 != voice_type) {
370 char* before_lang = NULL;
373 before_lang = strdup(g_config_info->language);
374 before_type = g_config_info->type;
377 if (NULL != g_config_info->language)
378 free(g_config_info->language);
380 g_config_info->language = strdup(lang);
382 if (-1 != voice_type) {
383 g_config_info->type = voice_type;
386 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
388 /* Call all callbacks of client*/
389 iter = g_slist_nth(g_config_client_list, 0);
391 while (NULL != iter) {
392 temp_client = iter->data;
394 if (NULL != temp_client) {
395 if (NULL != temp_client->voice_cb) {
396 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
397 temp_client->voice_cb(before_lang, before_type,
398 g_config_info->language, g_config_info->type,
399 g_config_info->auto_voice, temp_client->user_data);
403 iter = g_slist_next(iter);
406 if (NULL != before_lang) {
411 if (-1 != speech_rate) {
412 g_config_info->speech_rate = speech_rate;
414 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
416 /* Call all callbacks of client*/
417 iter = g_slist_nth(g_config_client_list, 0);
419 while (NULL != iter) {
420 temp_client = iter->data;
422 if (NULL != temp_client) {
423 if (NULL != temp_client->speech_cb) {
424 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
425 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
429 iter = g_slist_next(iter);
434 g_config_info->pitch = pitch;
436 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
438 /* Call all callbacks of client*/
439 iter = g_slist_nth(g_config_client_list, 0);
441 while (NULL != iter) {
442 temp_client = iter->data;
444 if (NULL != temp_client) {
445 if (NULL != temp_client->pitch_cb) {
446 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
447 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
451 iter = g_slist_next(iter);
455 if (NULL != engine) free(engine);
456 if (NULL != setting) free(setting);
457 if (NULL != lang) free(lang);
459 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
462 SLOG(LOG_DEBUG, tts_tag(), "=====");
463 SLOG(LOG_DEBUG, tts_tag(), " ");
465 return ECORE_CALLBACK_PASS_ON;
468 int __tts_config_mgr_register_config_event()
470 /* get file notification handler */
476 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
479 g_config_fd_noti = fd;
481 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE);
482 g_config_wd_noti = wd;
484 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
485 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
486 if (NULL == g_config_fd_handler_noti) {
487 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
491 /* Set non-blocking mode of file */
493 value = fcntl(fd, F_GETFL, 0);
496 if (0 > fcntl(fd, F_SETFL, value)) {
497 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
503 int __tts_config_mgr_unregister_config_event()
505 /* delete inotify variable */
506 ecore_main_fd_handler_del(g_config_fd_handler_noti);
507 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
508 close(g_config_fd_noti);
513 int __tts_config_set_auto_language()
516 value = vconf_get_str(TTS_LANGSET_KEY);
518 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
522 char temp_lang[6] = {'\0', };
523 strncpy(temp_lang, value, 5);
526 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
527 /* tts default voice change */
528 if (NULL == g_config_info->language) {
529 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
533 char* before_lang = NULL;
536 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
537 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
541 before_lang = strdup(g_config_info->language);
542 before_type = g_config_info->type;
544 free(g_config_info->language);
545 g_config_info->language = strdup(temp_lang);
547 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
548 g_config_info->language, g_config_info->type);
551 tts_config_client_s* temp_client = NULL;
553 /* Call all callbacks of client*/
554 iter = g_slist_nth(g_config_client_list, 0);
556 while (NULL != iter) {
557 temp_client = iter->data;
559 if (NULL != temp_client) {
560 if (NULL != temp_client->voice_cb) {
561 temp_client->voice_cb(before_lang, before_type,
562 g_config_info->language, g_config_info->type,
563 g_config_info->auto_voice, temp_client->user_data);
567 iter = g_slist_next(iter);
570 if (NULL != before_lang) {
574 /* Display language is not valid */
575 char* tmp_language = NULL;
577 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
578 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
582 if (NULL == tmp_language) {
583 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
587 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
588 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
592 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
593 tmp_language, tmp_type);
596 tts_config_client_s* temp_client = NULL;
598 /* Call all callbacks of client*/
599 iter = g_slist_nth(g_config_client_list, 0);
601 while (NULL != iter) {
602 temp_client = iter->data;
604 if (NULL != temp_client) {
605 if (NULL != temp_client->voice_cb) {
606 temp_client->voice_cb(g_config_info->language, g_config_info->type,
607 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
611 iter = g_slist_next(iter);
614 if (NULL != g_config_info->language) {
615 free(g_config_info->language);
616 g_config_info->language = strdup(tmp_language);
619 g_config_info->type = tmp_type;
627 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
629 if (true == g_config_info->auto_voice) {
630 __tts_config_set_auto_language();
636 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
640 ret = vconf_get_int(TTS_ACCESSIBILITY_KEY, &screen_reader);
642 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
647 tts_config_client_s* temp_client = NULL;
649 /* Call all callbacks of client*/
650 iter = g_slist_nth(g_config_client_list, 0);
652 while (NULL != iter) {
653 temp_client = iter->data;
655 if (NULL != temp_client) {
656 if (NULL != temp_client->screen_cb) {
657 temp_client->screen_cb((bool)screen_reader);
661 iter = g_slist_next(iter);
665 int __tts_config_release_client(int uid)
668 tts_config_client_s* temp_client = NULL;
670 if (0 < g_slist_length(g_config_client_list)) {
672 iter = g_slist_nth(g_config_client_list, 0);
674 while (NULL != iter) {
675 temp_client = iter->data;
677 if (NULL != temp_client) {
678 if (uid == temp_client->uid) {
679 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
686 iter = g_slist_next(iter);
690 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
692 return g_slist_length(g_config_client_list);
695 void __tts_config_release_engine()
698 tts_engine_info_s *engine_info = NULL;
700 if (0 < g_slist_length(g_engine_list)) {
702 /* Get a first item */
703 iter = g_slist_nth(g_engine_list, 0);
705 while (NULL != iter) {
706 engine_info = iter->data;
708 if (NULL != engine_info) {
709 g_engine_list = g_slist_remove(g_engine_list, engine_info);
711 tts_parser_free_engine_info(engine_info);
714 iter = g_slist_nth(g_engine_list, 0);
721 int __tts_config_mgr_get_engine_info()
726 struct dirent *dirp = NULL;
728 char filepath[512] = {'\0',};
730 tts_engine_info_s* info = NULL;
732 g_engine_list = NULL;
734 /* Get engine info from default engine directory */
735 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
737 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DEFAULT_ENGINE_INFO);
740 ret = readdir_r(dp, &entry, &dirp);
742 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
747 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
748 if (filesize >= 512) {
749 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
754 memset(filepath, '\0', 512);
755 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
757 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
759 if (0 == tts_parser_get_engine_info(filepath, &info)) {
760 g_engine_list = g_slist_append(g_engine_list, info);
763 } while (NULL != dirp);
768 /* Get engine info from downloadable engine directory */
769 dp = opendir(TTS_DOWNLOAD_ENGINE_INFO);
771 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
774 ret = readdir_r(dp, &entry, &dirp);
776 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
781 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
782 if (filesize >= 512) {
783 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
788 memset(filepath, '\0', 512);
789 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
791 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
793 if (0 == tts_parser_get_engine_info(filepath, &info)) {
796 tts_engine_info_s *engine_info = NULL;
798 /* Get a first item */
799 iter = g_slist_nth(g_engine_list, 0);
801 while (NULL != iter) {
802 engine_info = iter->data;
804 if (NULL != engine_info) {
805 /* Remove old engine info */
806 if (0 == strncmp(engine_info->uuid, info->uuid, strlen(engine_info->uuid))) {
807 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Remove old engine : %s", engine_info->name);
808 g_engine_list = g_slist_remove(g_engine_list, engine_info);
809 tts_parser_free_engine_info(engine_info);
816 g_engine_list = g_slist_append(g_engine_list, info);
819 } while (NULL != dirp);
824 if (0 >= g_slist_length(g_engine_list)) {
825 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
832 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
834 SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
837 struct inotify_event event;
838 memset(&event, '\0', sizeof(struct inotify_event));
840 length = read(g_dir_fd, &event, sizeof(struct inotify_event));
842 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
843 SLOG(LOG_DEBUG, tts_tag(), "=====");
844 SLOG(LOG_DEBUG, tts_tag(), " ");
845 return ECORE_CALLBACK_DONE;
848 if (IN_CLOSE_WRITE == event.mask) {
849 int ret = __tts_config_mgr_get_engine_info();
851 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
853 __tts_config_mgr_print_engine_info();
854 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
855 if (false == support) {
856 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
857 char* temp_lang = NULL;
859 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
861 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
864 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
866 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
868 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
870 if (NULL != temp_lang) free(temp_lang);
873 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
876 SLOG(LOG_DEBUG, tts_tag(), "=====");
877 SLOG(LOG_DEBUG, tts_tag(), " ");
879 return ECORE_CALLBACK_PASS_ON;
882 static int __tts_config_mgr_register_engine_config_updated_event()
884 /* For engine directory monitoring */
885 g_dir_fd = inotify_init();
887 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
891 g_dir_wd = inotify_add_watch(g_dir_fd, TTS_OPT_BASE"/engine-info/", IN_CLOSE_WRITE);
893 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
897 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);
898 if (NULL == g_dir_fd_handler) {
899 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
903 /* Set non-blocking mode of file */
905 value = fcntl(g_dir_fd, F_GETFL, 0);
908 if (0 > fcntl(g_dir_fd, F_SETFL, value)) {
909 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
915 static int __tts_config_mgr_unregister_engine_config_updated_event()
917 /* delete inotify variable */
918 ecore_main_fd_handler_del(g_dir_fd_handler);
919 inotify_rm_watch(g_dir_fd, g_dir_wd);
925 int tts_config_mgr_initialize(int uid)
929 tts_config_client_s* temp_client = NULL;
932 if (0 < g_slist_length(g_config_client_list)) {
934 iter = g_slist_nth(g_config_client_list, 0);
936 while (NULL != iter) {
937 get_uid = iter->data;
939 if (uid == *get_uid) {
940 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
944 iter = g_slist_next(iter);
947 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
948 if (NULL == temp_client) {
949 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
950 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
952 temp_client->uid = uid;
954 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
956 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
959 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
960 if (NULL == temp_client) {
961 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
962 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
964 temp_client->uid = uid;
966 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
969 if (0 != __tts_config_mgr_get_engine_info()) {
970 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
971 __tts_config_release_client(uid);
972 __tts_config_release_engine();
973 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
976 __tts_config_mgr_print_engine_info();
978 if (0 != tts_parser_load_config(&g_config_info)) {
979 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
980 __tts_config_release_client(uid);
981 __tts_config_release_engine();
982 return TTS_CONFIG_ERROR_OPERATION_FAILED;
985 /* Check whether engine id is valid */
986 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
987 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
988 __tts_config_release_client(uid);
989 __tts_config_release_engine();
990 tts_parser_unload_config(g_config_info);
991 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
994 if (true == g_config_info->auto_voice) {
995 /* Check language with display language */
996 __tts_config_set_auto_language();
998 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
999 /* Default language is not valid */
1000 char* tmp_language = NULL;
1002 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1003 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1004 __tts_config_release_client(uid);
1005 __tts_config_release_engine();
1006 tts_parser_unload_config(g_config_info);
1007 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1010 if (NULL != tmp_language) {
1011 if (NULL != g_config_info->language) {
1012 free(g_config_info->language);
1013 g_config_info->language = strdup(tmp_language);
1016 g_config_info->type = tmp_type;
1020 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1021 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1022 __tts_config_release_client(uid);
1023 __tts_config_release_engine();
1024 tts_parser_unload_config(g_config_info);
1025 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1031 /* print daemon config */
1032 SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1033 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1034 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1035 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1036 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1037 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1038 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1039 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1040 SLOG(LOG_DEBUG, tts_tag(), "=================");
1042 if (0 != __tts_config_mgr_register_config_event()) {
1043 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1044 __tts_config_release_client(uid);
1045 __tts_config_release_engine();
1046 tts_parser_unload_config(g_config_info);
1047 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1050 /* Register to detect display language change */
1051 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1052 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1054 /* For engine directory monitoring */
1055 if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1056 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1057 __tts_config_release_client(uid);
1058 __tts_config_release_engine();
1059 tts_parser_unload_config(g_config_info);
1060 __tts_config_mgr_unregister_config_event();
1061 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1067 int tts_config_mgr_finalize(int uid)
1069 if (0 < __tts_config_release_client(uid)) {
1073 __tts_config_release_engine();
1075 tts_parser_unload_config(g_config_info);
1077 __tts_config_mgr_unregister_engine_config_updated_event();
1079 __tts_config_mgr_unregister_config_event();
1081 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1082 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1087 int tts_config_mgr_set_callback(int uid,
1088 tts_config_engine_changed_cb engine_cb,
1089 tts_config_voice_changed_cb voice_cb,
1090 tts_config_speech_rate_changed_cb speech_cb,
1091 tts_config_pitch_changed_cb pitch_cb,
1094 GSList *iter = NULL;
1095 tts_config_client_s* temp_client = NULL;
1097 /* Call all callbacks of client*/
1098 iter = g_slist_nth(g_config_client_list, 0);
1100 while (NULL != iter) {
1101 temp_client = iter->data;
1103 if (NULL != temp_client) {
1104 if (uid == temp_client->uid) {
1105 temp_client->engine_cb = engine_cb;
1106 temp_client->voice_cb = voice_cb;
1107 temp_client->speech_cb = speech_cb;
1108 temp_client->pitch_cb = pitch_cb;
1109 temp_client->user_data = user_data;
1113 iter = g_slist_next(iter);
1118 int tts_config_mgr_unset_callback(int uid)
1120 GSList *iter = NULL;
1121 tts_config_client_s* temp_client = NULL;
1123 /* Call all callbacks of client*/
1124 iter = g_slist_nth(g_config_client_list, 0);
1126 while (NULL != iter) {
1127 temp_client = iter->data;
1129 if (NULL != temp_client) {
1130 if (uid == temp_client->uid) {
1131 temp_client->engine_cb = NULL;
1132 temp_client->voice_cb = NULL;
1133 temp_client->speech_cb = NULL;
1134 temp_client->pitch_cb = NULL;
1135 temp_client->user_data = NULL;
1139 iter = g_slist_next(iter);
1145 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1147 if (NULL == callback) {
1148 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1149 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1152 GSList *iter = NULL;
1153 tts_config_client_s* temp_client = NULL;
1155 /* Call all callbacks of client*/
1156 iter = g_slist_nth(g_config_client_list, 0);
1158 while (NULL != iter) {
1159 temp_client = iter->data;
1161 if (NULL != temp_client) {
1162 if (uid == temp_client->uid) {
1163 temp_client->screen_cb = callback;
1167 iter = g_slist_next(iter);
1172 int tts_config_unset_screen_reader_callback(int uid)
1174 GSList *iter = NULL;
1175 tts_config_client_s* temp_client = NULL;
1177 /* Call all callbacks of client*/
1178 iter = g_slist_nth(g_config_client_list, 0);
1180 while (NULL != iter) {
1181 temp_client = iter->data;
1183 if (NULL != temp_client) {
1184 if (uid == temp_client->uid) {
1185 temp_client->screen_cb = NULL;
1189 iter = g_slist_next(iter);
1195 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1197 if (0 >= g_slist_length(g_config_client_list)) {
1198 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1199 return TTS_CONFIG_ERROR_INVALID_STATE;
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(), "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 (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1222 iter = g_slist_next(iter);
1228 int tts_config_mgr_get_engine(char** engine)
1230 if (0 >= g_slist_length(g_config_client_list)) {
1231 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1232 return TTS_CONFIG_ERROR_INVALID_STATE;
1235 if (NULL == engine) {
1236 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1237 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1240 if (NULL != g_config_info->engine_id) {
1241 /* Check engine id is valid */
1242 GSList *iter = NULL;
1243 tts_engine_info_s *engine_info = NULL;
1245 if (0 >= g_slist_length(g_engine_list)) {
1246 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1247 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1250 /* Get a first item */
1251 iter = g_slist_nth(g_engine_list, 0);
1253 while (NULL != iter) {
1254 engine_info = iter->data;
1256 if (NULL != engine_info) {
1257 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1258 *engine = strdup(g_config_info->engine_id);
1262 iter = g_slist_next(iter);
1265 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1267 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1270 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1273 int tts_config_mgr_set_engine(const char* engine)
1275 if (0 >= g_slist_length(g_config_client_list)) {
1276 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1277 return TTS_CONFIG_ERROR_INVALID_STATE;
1281 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1283 /* Check current engine id with new engine id */
1284 if (0 == strcmp(g_config_info->engine_id, engine))
1287 if (0 >= g_slist_length(g_engine_list)) {
1288 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1289 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1292 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1294 GSList *iter = NULL;
1295 tts_engine_info_s *engine_info = NULL;
1296 bool is_valid_engine = false;
1298 /* Get a first item */
1299 iter = g_slist_nth(g_engine_list, 0);
1301 while (NULL != iter) {
1302 engine_info = iter->data;
1304 if (NULL == engine_info) {
1305 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1306 iter = g_slist_next(iter);
1310 /* Check engine id is valid */
1311 if (0 != strcmp(engine, engine_info->uuid)) {
1312 iter = g_slist_next(iter);
1316 if (NULL != g_config_info->engine_id)
1317 free(g_config_info->engine_id);
1319 g_config_info->engine_id = strdup(engine);
1321 if (NULL != g_config_info->setting)
1322 free(g_config_info->setting);
1324 if (NULL != engine_info->setting)
1325 g_config_info->setting = strdup(engine_info->setting);
1327 /* Engine is valid*/
1328 GSList *iter_voice = NULL;
1329 tts_config_voice_s* voice = NULL;
1330 bool is_valid_voice = false;
1332 /* Get a first item */
1333 iter_voice = g_slist_nth(engine_info->voices, 0);
1335 while (NULL != iter_voice) {
1336 /*Get handle data from list*/
1337 voice = iter_voice->data;
1339 if (NULL != voice) {
1340 if (NULL == voice->language)
1342 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1344 if (0 == strcmp(voice->language, g_config_info->language)) {
1345 if (voice->type == g_config_info->type) {
1346 /* language is valid */
1347 is_valid_voice = true;
1349 if (NULL != g_config_info->language) {
1350 free(g_config_info->language);
1352 g_config_info->language = strdup(voice->language);
1353 g_config_info->type = voice->type;
1361 iter_voice = g_slist_next(iter_voice);
1364 if (false == is_valid_voice) {
1365 if (NULL != g_config_info->language) {
1366 free(g_config_info->language);
1368 iter_voice = g_slist_nth(engine_info->voices, 0);
1369 if (NULL != iter_voice) {
1370 voice = iter_voice->data;
1371 if (NULL != voice) {
1372 if (NULL != voice->language)
1373 g_config_info->language = strdup(voice->language);
1374 g_config_info->type = voice->type;
1380 is_valid_engine = true;
1384 if (true == is_valid_engine) {
1385 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1386 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1387 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1388 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1389 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1391 if ( 0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1392 g_config_info->language, g_config_info->type)) {
1393 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1394 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1397 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1398 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1404 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1406 if (0 >= g_slist_length(g_config_client_list)) {
1407 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1408 return TTS_CONFIG_ERROR_INVALID_STATE;
1411 if (0 >= g_slist_length(g_engine_list)) {
1412 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1413 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1416 GSList *iter = NULL;
1417 tts_engine_info_s *engine_info = NULL;
1419 /* Get a first item */
1420 iter = g_slist_nth(g_engine_list, 0);
1422 while (NULL != iter) {
1423 engine_info = iter->data;
1425 if (NULL == engine_info) {
1426 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1427 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1430 if (0 != strcmp(engine_id, engine_info->uuid)) {
1431 iter = g_slist_next(iter);
1435 GSList *iter_voice = NULL;
1436 tts_config_voice_s* voice = NULL;
1438 /* Get a first item */
1439 iter_voice = g_slist_nth(engine_info->voices, 0);
1441 while (NULL != iter_voice) {
1442 /*Get handle data from list*/
1443 voice = iter_voice->data;
1445 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1446 if (NULL != voice->language) {
1447 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1452 iter_voice = g_slist_next(iter_voice);
1460 int tts_config_mgr_get_voice(char** language, int* type)
1462 if (0 >= g_slist_length(g_config_client_list)) {
1463 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1464 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1467 if (0 >= g_slist_length(g_engine_list)) {
1468 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1469 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1472 if (NULL == language || NULL == type)
1473 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1475 if (NULL != g_config_info->language) {
1476 *language = strdup(g_config_info->language);
1477 *type = g_config_info->type;
1479 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1480 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1486 int tts_config_mgr_set_voice(const char* language, int type)
1488 if (0 >= g_slist_length(g_config_client_list)) {
1489 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1490 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1493 if (NULL == language) {
1494 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1495 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1498 if (0 >= g_slist_length(g_engine_list)) {
1499 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1500 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1503 /* Check language is valid */
1504 if (NULL != g_config_info->language) {
1505 if (0 != tts_parser_set_voice(language, type)) {
1506 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1507 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1509 free(g_config_info->language);
1510 g_config_info->language = strdup(language);
1511 g_config_info->type = type;
1514 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1515 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1521 int tts_config_mgr_get_auto_voice(bool* value)
1523 if (0 >= g_slist_length(g_config_client_list)) {
1524 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1525 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1529 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1531 *value = g_config_info->auto_voice;
1536 int tts_config_mgr_set_auto_voice(bool value)
1538 if (0 >= g_slist_length(g_config_client_list)) {
1539 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1540 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1543 if (g_config_info->auto_voice != value) {
1544 /* Check language is valid */
1545 if (0 != tts_parser_set_auto_voice(value)) {
1546 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1547 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1549 g_config_info->auto_voice = value;
1551 if (true == g_config_info->auto_voice) {
1552 __tts_config_set_auto_language();
1559 int tts_config_mgr_get_speech_rate(int* value)
1561 if (0 >= g_slist_length(g_config_client_list)) {
1562 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1563 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1566 if (NULL == value) {
1567 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1570 *value = g_config_info->speech_rate;
1575 int tts_config_mgr_set_speech_rate(int value)
1577 if (0 >= g_slist_length(g_config_client_list)) {
1578 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1579 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1582 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1583 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1584 if (0 != tts_parser_set_speech_rate(value)) {
1585 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1586 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1589 g_config_info->speech_rate = value;
1591 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1597 int tts_config_mgr_get_pitch(int* value)
1599 if (0 >= g_slist_length(g_config_client_list)) {
1600 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1601 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1604 if (NULL == value) {
1605 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1608 GSList *iter = NULL;
1609 tts_engine_info_s *engine_info = NULL;
1611 if (0 >= g_slist_length(g_engine_list)) {
1612 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1613 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1616 /* Get a first item */
1617 iter = g_slist_nth(g_engine_list, 0);
1619 while (NULL != iter) {
1620 engine_info = iter->data;
1622 if (NULL == engine_info) {
1623 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1624 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1627 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1628 iter = g_slist_next(iter);
1632 if (false == engine_info->pitch_support) {
1633 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1639 *value = g_config_info->pitch;
1644 int tts_config_mgr_set_pitch(int value)
1646 if (0 >= g_slist_length(g_config_client_list)) {
1647 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1651 GSList *iter = NULL;
1652 tts_engine_info_s *engine_info = NULL;
1654 if (0 >= g_slist_length(g_engine_list)) {
1655 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1656 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1659 /* Get a first item */
1660 iter = g_slist_nth(g_engine_list, 0);
1662 while (NULL != iter) {
1663 engine_info = iter->data;
1665 if (NULL == engine_info) {
1666 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1667 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1670 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1671 iter = g_slist_next(iter);
1675 if (false == engine_info->pitch_support) {
1676 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1682 if (0 != tts_parser_set_pitch(value)) {
1683 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1684 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1687 g_config_info->pitch = value;
1692 bool tts_config_check_default_engine_is_valid(const char* engine)
1694 if (0 >= g_slist_length(g_config_client_list)) {
1695 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1702 if (0 >= g_slist_length(g_engine_list))
1705 GSList *iter = NULL;
1706 tts_engine_info_s *engine_info = NULL;
1708 /* Get a first item */
1709 iter = g_slist_nth(g_engine_list, 0);
1711 while (NULL != iter) {
1712 engine_info = iter->data;
1714 if (NULL != engine_info) {
1715 if (0 == strcmp(engine, engine_info->uuid)) {
1719 iter = g_slist_next(iter);
1725 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1727 if (0 >= g_slist_length(g_config_client_list)) {
1728 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1732 if (NULL == language)
1735 if (NULL == g_config_info->engine_id) {
1736 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1740 if (0 >= g_slist_length(g_engine_list))
1743 GSList *iter = NULL;
1744 tts_engine_info_s *engine_info = NULL;
1746 /* Get a first item */
1747 iter = g_slist_nth(g_engine_list, 0);
1749 while (NULL != iter) {
1750 engine_info = iter->data;
1752 if (NULL == engine_info) {
1753 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1754 iter = g_slist_next(iter);
1758 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1759 iter = g_slist_next(iter);
1763 GSList *iter_voice = NULL;
1764 tts_config_voice_s* voice = NULL;
1766 /* Get a first item */
1767 iter_voice = g_slist_nth(engine_info->voices, 0);
1769 while (NULL != iter_voice) {
1770 voice = iter_voice->data;
1772 if (0 == strcmp(language, voice->language) && voice->type == type)
1776 iter_voice = g_slist_next(iter_voice);
1786 int __tts_config_mgr_print_engine_info()
1788 GSList *iter = NULL;
1789 tts_engine_info_s *engine_info = NULL;
1791 if (0 >= g_slist_length(g_engine_list)) {
1792 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1793 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1794 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1798 /* Get a first item */
1799 iter = g_slist_nth(g_engine_list, 0);
1801 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
1804 while (NULL != iter) {
1805 engine_info = iter->data;
1807 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
1808 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
1809 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
1810 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
1812 SLOG(LOG_DEBUG, tts_tag(), " Voices");
1813 GSList *iter_voice = NULL;
1814 tts_config_voice_s* voice = NULL;
1816 if (g_slist_length(engine_info->voices) > 0) {
1817 /* Get a first item */
1818 iter_voice = g_slist_nth(engine_info->voices, 0);
1821 while (NULL != iter_voice) {
1822 /*Get handle data from list*/
1823 voice = iter_voice->data;
1825 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
1828 iter_voice = g_slist_next(iter_voice);
1832 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
1834 iter = g_slist_next(iter);
1837 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");