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>
25 #include "tts_config_mgr.h"
26 #include "tts_config_parser.h"
31 tts_config_engine_changed_cb engine_cb;
32 tts_config_voice_changed_cb voice_cb;
33 tts_config_speech_rate_changed_cb speech_cb;
34 tts_config_screen_reader_changed_cb screen_cb;
35 tts_config_pitch_changed_cb pitch_cb;
37 } tts_config_client_s;
39 extern char* tts_tag();
41 static GSList* g_engine_list = NULL;
43 static GSList* g_config_client_list = NULL;
45 static tts_config_s* g_config_info = NULL;
46 extern char g_engine_id[128];
47 extern char g_setting[128];
48 extern char g_language[128];
50 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
51 static int g_config_fd_noti;
52 static int g_config_wd_noti;
54 /* For engine directory monitoring */
56 Ecore_Fd_Handler* dir_fd_handler;
59 } tts_engine_inotify_s;
61 static GList* g_ino_list = NULL;
63 int __tts_config_mgr_print_engine_info();
64 static int __tts_config_mgr_register_engine_config_updated_event(const char* path);
65 static int __tts_config_mgr_unregister_engine_config_updated_event();
67 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
69 if (NULL == engine_id) {
70 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
75 tts_engine_info_s *engine_info = NULL;
77 if (0 >= g_slist_length(g_engine_list)) {
78 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
82 /* Get a first item */
83 iter = g_slist_nth(g_engine_list, 0);
85 while (NULL != iter) {
86 engine_info = iter->data;
88 if (NULL == engine_info) {
89 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
93 if (NULL != engine_info->uuid && 0 == strcmp(engine_id, engine_info->uuid)) {
94 SLOG(LOG_DEBUG, tts_tag(), "Default engine is valid : %s", engine_id);
98 iter = g_slist_next(iter);
101 /* Change default engine */
102 iter = g_slist_nth(g_engine_list, 0);
104 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine in list");
105 return TTS_CONFIG_ERROR_OPERATION_FAILED;
108 engine_info = iter->data;
109 if (NULL == g_config_info) {
110 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid engine info in list");
111 return TTS_CONFIG_ERROR_OPERATION_FAILED;
114 if (NULL != engine_info->uuid) {
115 memset(g_engine_id, '\0', sizeof(g_engine_id));
116 g_config_info->engine_id = g_engine_id;
117 strncpy(g_config_info->engine_id, engine_info->uuid, sizeof(g_engine_id) - 1);
119 if (NULL != engine_info->setting) {
120 memset(g_setting, '\0', sizeof(g_setting));
121 g_config_info->setting = g_setting;
122 strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
125 SLOG(LOG_DEBUG, tts_tag(), "Default engine is changed : %s", g_config_info->engine_id);
127 /* Change is default voice */
128 GSList *iter_voice = NULL;
129 tts_config_voice_s* voice = NULL;
130 bool is_valid_voice = false;
132 /* Get a first item */
133 iter_voice = g_slist_nth(engine_info->voices, 0);
135 while (NULL != iter_voice) {
136 /*Get handle data from list*/
137 voice = iter_voice->data;
140 if (NULL != voice->language) {
141 if (0 == strcmp(voice->language, g_config_info->language)) {
142 if (voice->type == g_config_info->type) {
143 /* language is valid */
144 is_valid_voice = true;
146 memset(g_language, '\0', sizeof(g_language));
147 g_config_info->language = g_language;
148 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
150 g_config_info->type = voice->type;
152 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
159 iter_voice = g_slist_next(iter_voice);
162 if (false == is_valid_voice) {
163 /* Select first voice as default */
164 memset(g_language, '\0', sizeof(g_language));
165 g_config_info->language = g_language;
167 iter_voice = g_slist_nth(engine_info->voices, 0);
168 if (NULL == iter_voice) {
169 SLOG(LOG_ERROR, tts_tag(), "Fail to get voice list");
170 return TTS_CONFIG_ERROR_OPERATION_FAILED;
172 voice = iter_voice->data;
174 if (NULL == voice || NULL == voice->language) {
175 SLOG(LOG_ERROR, tts_tag(), "Fail to get voice info from list");
176 return TTS_CONFIG_ERROR_OPERATION_FAILED;
178 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
180 g_config_info->type = voice->type;
181 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
184 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
185 g_config_info->language, g_config_info->type)) {
186 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
187 return TTS_CONFIG_ERROR_OPERATION_FAILED;
193 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
195 if (NULL == engine_id || NULL == language) {
196 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
201 tts_engine_info_s *engine_info = NULL;
203 if (0 >= g_slist_length(g_engine_list)) {
204 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
208 /* Get a first item */
209 iter = g_slist_nth(g_engine_list, 0);
211 while (NULL != iter) {
212 engine_info = iter->data;
214 if (NULL == engine_info) {
215 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
219 if (0 != strcmp(engine_id, engine_info->uuid)) {
220 iter = g_slist_next(iter);
224 GSList *iter_voice = NULL;
225 tts_config_voice_s* voice = NULL;
227 if (g_slist_length(engine_info->voices) <= 0) {
228 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
229 iter = g_slist_next(iter);
233 /* Get a first item */
234 iter_voice = g_slist_nth(engine_info->voices, 0);
237 while (NULL != iter_voice) {
238 /*Get handle data from list*/
239 voice = iter_voice->data;
242 if (0 == strcmp(language, voice->language)) {
243 if (type == voice->type) {
250 iter_voice = g_slist_next(iter_voice);
260 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
262 if (NULL == engine_id || NULL == language) {
263 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
268 tts_engine_info_s *engine_info = NULL;
270 if (0 >= g_slist_length(g_engine_list)) {
271 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
275 /* Get a first item */
276 iter = g_slist_nth(g_engine_list, 0);
278 while (NULL != iter) {
279 engine_info = iter->data;
281 if (NULL == engine_info) {
282 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
286 if (0 != strcmp(engine_id, engine_info->uuid)) {
287 iter = g_slist_next(iter);
291 GSList *iter_voice = NULL;
292 tts_config_voice_s* voice = NULL;
294 if (g_slist_length(engine_info->voices) <= 0) {
295 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
299 /* Get a first item */
300 iter_voice = g_slist_nth(engine_info->voices, 0);
302 while (NULL != iter_voice) {
303 voice = iter_voice->data;
305 /* Default language */
306 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
307 *language = strdup(voice->language);
310 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
314 iter_voice = g_slist_next(iter_voice);
317 /* Not support base language */
319 *language = strdup(voice->language);
322 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
331 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
333 SLOG(LOG_DEBUG, tts_tag(), "@@@ Config changed callback event");
336 struct inotify_event event;
337 memset(&event, '\0', sizeof(struct inotify_event));
339 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
341 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
342 SLOG(LOG_DEBUG, tts_tag(), "@@@");
343 return ECORE_CALLBACK_DONE;
346 if (IN_CLOSE_WRITE == event.mask) {
347 /* check config changed state */
349 char* setting = NULL;
351 bool auto_voice = g_config_info->auto_voice;
353 int speech_rate = -1;
357 tts_config_client_s* temp_client = NULL;
359 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
360 return ECORE_CALLBACK_PASS_ON;
363 if (NULL != engine || NULL != setting) {
364 if (NULL != engine) {
365 memset(g_engine_id, '\0', sizeof(g_engine_id));
366 g_config_info->engine_id = g_engine_id;
367 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
369 if (NULL != setting) {
370 memset(g_setting, '\0', sizeof(g_setting));
371 g_config_info->setting = g_setting;
372 strncpy(g_config_info->setting, setting, sizeof(g_setting) - 1);
375 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
377 /* Call all callbacks of client*/
378 iter = g_slist_nth(g_config_client_list, 0);
380 while (NULL != iter) {
381 temp_client = iter->data;
383 if (NULL != temp_client) {
384 if (NULL != temp_client->engine_cb) {
385 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
386 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
387 g_config_info->language, g_config_info->type,
388 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
392 iter = g_slist_next(iter);
396 if (auto_voice != g_config_info->auto_voice) {
397 g_config_info->auto_voice = auto_voice;
400 if (NULL != lang || -1 != voice_type) {
401 char* before_lang = NULL;
404 before_lang = strdup(g_config_info->language);
405 before_type = g_config_info->type;
408 memset(g_language, '\0', sizeof(g_language));
409 g_config_info->language = g_language;
410 strncpy(g_config_info->language, lang, sizeof(g_language) - 1);
412 if (-1 != voice_type) {
413 g_config_info->type = voice_type;
416 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
418 /* Call all callbacks of client*/
419 iter = g_slist_nth(g_config_client_list, 0);
421 while (NULL != iter) {
422 temp_client = iter->data;
424 if (NULL != temp_client) {
425 if (NULL != temp_client->voice_cb) {
426 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
427 temp_client->voice_cb(before_lang, before_type,
428 g_config_info->language, g_config_info->type,
429 g_config_info->auto_voice, temp_client->user_data);
433 iter = g_slist_next(iter);
436 if (NULL != before_lang) {
442 if (-1 != speech_rate) {
443 g_config_info->speech_rate = speech_rate;
445 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
447 /* Call all callbacks of client*/
448 iter = g_slist_nth(g_config_client_list, 0);
450 while (NULL != iter) {
451 temp_client = iter->data;
453 if (NULL != temp_client) {
454 if (NULL != temp_client->speech_cb) {
455 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
456 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
460 iter = g_slist_next(iter);
465 g_config_info->pitch = pitch;
467 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
469 /* Call all callbacks of client*/
470 iter = g_slist_nth(g_config_client_list, 0);
472 while (NULL != iter) {
473 temp_client = iter->data;
475 if (NULL != temp_client) {
476 if (NULL != temp_client->pitch_cb) {
477 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
478 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
482 iter = g_slist_next(iter);
486 if (NULL != engine) {
490 if (NULL != setting) {
498 } else if (IN_DELETE_SELF == event.mask) {
499 SLOG(LOG_ERROR, tts_tag(), "[ERROR] IN_DELETE_SELF event");
501 tts_parser_unload_config(g_config_info);
503 tts_parser_load_config(&g_config_info);
505 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event (0x%x)", event.mask);
508 SLOG(LOG_DEBUG, tts_tag(), "@@@");
510 return ECORE_CALLBACK_PASS_ON;
513 int __tts_config_mgr_register_config_event()
515 /* get file notification handler */
521 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
524 g_config_fd_noti = fd;
526 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE|IN_DELETE_SELF);
527 g_config_wd_noti = wd;
529 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
530 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
531 if (NULL == g_config_fd_handler_noti) {
532 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
536 /* Set non-blocking mode of file */
538 value = fcntl(fd, F_GETFL, 0);
541 if (0 > fcntl(fd, F_SETFL, value)) {
542 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
548 int __tts_config_mgr_unregister_config_event()
550 /* delete inotify variable */
551 ecore_main_fd_handler_del(g_config_fd_handler_noti);
552 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
553 close(g_config_fd_noti);
558 int __tts_config_set_auto_language()
561 value = vconf_get_str(TTS_LANGSET_KEY);
563 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
567 char temp_lang[6] = {'\0', };
568 strncpy(temp_lang, value, 5);
572 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
573 /* tts default voice change */
574 if (NULL == g_config_info->language) {
575 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
579 char* before_lang = NULL;
582 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
583 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
587 before_lang = strdup(g_config_info->language);
588 before_type = g_config_info->type;
590 memset(g_language, '\0', sizeof(g_language));
591 g_config_info->language = g_language;
592 strncpy(g_config_info->language, temp_lang, sizeof(g_language) - 1);
594 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
595 g_config_info->language, g_config_info->type);
598 tts_config_client_s* temp_client = NULL;
600 /* Call all callbacks of client*/
601 iter = g_slist_nth(g_config_client_list, 0);
603 while (NULL != iter) {
604 temp_client = iter->data;
606 if (NULL != temp_client) {
607 if (NULL != temp_client->voice_cb) {
608 temp_client->voice_cb(before_lang, before_type,
609 g_config_info->language, g_config_info->type,
610 g_config_info->auto_voice, temp_client->user_data);
614 iter = g_slist_next(iter);
617 if (NULL != before_lang) {
622 /* Display language is not valid */
623 char* tmp_language = NULL;
625 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
626 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
630 if (NULL == tmp_language) {
631 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
635 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
636 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
640 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
641 tmp_language, tmp_type);
644 tts_config_client_s* temp_client = NULL;
646 /* Call all callbacks of client*/
647 iter = g_slist_nth(g_config_client_list, 0);
649 while (NULL != iter) {
650 temp_client = iter->data;
652 if (NULL != temp_client) {
653 if (NULL != temp_client->voice_cb) {
654 temp_client->voice_cb(g_config_info->language, g_config_info->type,
655 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
659 iter = g_slist_next(iter);
663 memset(g_language, '\0', sizeof(g_language));
664 g_config_info->language = g_language;
665 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
667 g_config_info->type = tmp_type;
676 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
678 if (true == g_config_info->auto_voice) {
679 __tts_config_set_auto_language();
685 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
689 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
691 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
696 tts_config_client_s* temp_client = NULL;
698 /* Call all callbacks of client*/
699 iter = g_slist_nth(g_config_client_list, 0);
701 while (NULL != iter) {
702 temp_client = iter->data;
704 if (NULL != temp_client) {
705 if (NULL != temp_client->screen_cb) {
706 temp_client->screen_cb((bool)screen_reader);
710 iter = g_slist_next(iter);
714 int __tts_config_release_client(int uid)
717 tts_config_client_s* temp_client = NULL;
719 if (0 < g_slist_length(g_config_client_list)) {
721 iter = g_slist_nth(g_config_client_list, 0);
723 while (NULL != iter) {
724 temp_client = iter->data;
726 if (NULL != temp_client) {
727 if (uid == temp_client->uid) {
728 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
735 iter = g_slist_next(iter);
739 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
741 return g_slist_length(g_config_client_list);
744 void __tts_config_release_engine()
747 tts_engine_info_s *engine_info = NULL;
749 if (0 < g_slist_length(g_engine_list)) {
751 /* Get a first item */
752 iter = g_slist_nth(g_engine_list, 0);
754 while (NULL != iter) {
755 engine_info = iter->data;
757 if (NULL != engine_info) {
758 g_engine_list = g_slist_remove(g_engine_list, engine_info);
760 tts_parser_free_engine_info(engine_info);
763 iter = g_slist_nth(g_engine_list, 0);
770 int __tts_config_mgr_get_engine_info()
773 struct dirent *dirp = NULL;
775 char filepath[512] = {'\0',};
777 tts_engine_info_s* info = NULL;
779 __tts_config_release_engine();
780 g_engine_list = NULL;
781 __tts_config_mgr_unregister_engine_config_updated_event();
783 /* Copy default info directory to download directory */
784 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
786 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
792 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
795 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
796 if (filesize >= 512) {
797 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
802 memset(filepath, '\0', 512);
803 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
805 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
807 char dest[512] = {'\0',};
808 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
810 if (0 != access(dest, F_OK)) {
811 if (0 != tts_parser_copy_xml(filepath, dest)) {
812 SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] Fail to copy engine info");
816 } while (NULL != dirp);
821 /* Get engine info from default engine directory */
822 dp = opendir(TTS_DOWNLOAD_ENGINE_INFO);
824 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
830 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
833 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
834 if (filesize >= 512) {
835 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
840 memset(filepath, '\0', 512);
841 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
843 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
845 if (0 == tts_parser_get_engine_info(filepath, &info)) {
846 g_engine_list = g_slist_append(g_engine_list, info);
847 if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
848 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
852 } while (NULL != dirp);
857 if (0 >= g_slist_length(g_engine_list)) {
858 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
865 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
867 SLOG(LOG_DEBUG, tts_tag(), "@@@ Engine config updated callback event");
869 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
870 int dir_fd = ino->dir_fd;
873 struct inotify_event event;
874 memset(&event, '\0', sizeof(struct inotify_event));
876 length = read(dir_fd, &event, sizeof(struct inotify_event));
878 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
879 SLOG(LOG_DEBUG, tts_tag(), "@@@");
880 return ECORE_CALLBACK_DONE;
883 if (IN_CLOSE_WRITE == event.mask) {
884 int ret = __tts_config_mgr_get_engine_info();
886 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
888 __tts_config_mgr_print_engine_info();
889 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
890 if (false == support) {
891 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
892 char* temp_lang = NULL;
894 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
896 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
899 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
901 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
903 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
905 if (NULL != temp_lang) {
912 tts_config_client_s* temp_client = NULL;
913 /* Call all callbacks of client*/
914 iter = g_slist_nth(g_config_client_list, 0);
916 while (NULL != iter) {
917 temp_client = iter->data;
919 if (NULL != temp_client) {
920 if (NULL != temp_client->engine_cb) {
921 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
922 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
923 g_config_info->language, g_config_info->type,
924 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
928 iter = g_slist_next(iter);
931 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
934 SLOG(LOG_DEBUG, tts_tag(), "@@@");
936 return ECORE_CALLBACK_PASS_ON;
939 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
942 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Path is NULL");
946 /* For engine directory monitoring */
947 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
949 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
953 ino->dir_fd = inotify_init();
954 if (ino->dir_fd < 0) {
955 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
962 ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
963 SLOG(LOG_DEBUG, tts_tag(), "Add inotify watch(%s)", path);
964 if (ino->dir_wd < 0) {
965 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
971 ino->dir_fd_handler = ecore_main_fd_handler_add(ino->dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)__tts_config_mgr_engine_config_inotify_event_callback, (void *)ino, NULL, NULL);
972 if (NULL == ino->dir_fd_handler) {
973 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
979 /* Set non-blocking mode of file */
981 value = fcntl(ino->dir_fd, F_GETFL, 0);
984 if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
985 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
988 g_ino_list = g_list_append(g_ino_list, ino);
993 static int __tts_config_mgr_unregister_engine_config_updated_event()
995 /* delete all inotify variable */
996 if (0 < g_list_length(g_ino_list)) {
998 iter = g_list_first(g_ino_list);
1000 while (NULL != iter) {
1001 tts_engine_inotify_s *tmp = iter->data;
1004 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1005 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1012 g_ino_list = g_list_remove_link(g_ino_list, iter);
1014 iter = g_list_first(g_ino_list);
1021 int tts_config_mgr_initialize(int uid)
1023 GSList *iter = NULL;
1025 tts_config_client_s* temp_client = NULL;
1028 if (0 < g_slist_length(g_config_client_list)) {
1030 iter = g_slist_nth(g_config_client_list, 0);
1032 while (NULL != iter) {
1033 get_uid = iter->data;
1035 if (uid == *get_uid) {
1036 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
1040 iter = g_slist_next(iter);
1043 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1044 if (NULL == temp_client) {
1045 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1046 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1048 temp_client->uid = uid;
1049 temp_client->engine_cb = NULL;
1050 temp_client->voice_cb = NULL;
1051 temp_client->speech_cb = NULL;
1052 temp_client->pitch_cb = NULL;
1053 temp_client->screen_cb = NULL;
1054 temp_client->user_data = NULL;
1056 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1058 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
1061 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1062 if (NULL == temp_client) {
1063 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1064 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1066 temp_client->uid = uid;
1067 temp_client->engine_cb = NULL;
1068 temp_client->voice_cb = NULL;
1069 temp_client->speech_cb = NULL;
1070 temp_client->pitch_cb = NULL;
1071 temp_client->screen_cb = NULL;
1072 temp_client->user_data = NULL;
1074 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1077 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1078 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1079 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1080 __tts_config_release_client(uid);
1081 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1083 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
1087 if (0 != access(TTS_HOME, F_OK)) {
1088 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1089 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_HOME);
1090 __tts_config_release_client(uid);
1091 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1093 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_HOME);
1097 if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1098 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1099 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1100 __tts_config_release_client(uid);
1101 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1103 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1107 if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1108 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1109 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1110 __tts_config_release_client(uid);
1111 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1113 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1117 if (0 != __tts_config_mgr_get_engine_info()) {
1118 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1119 __tts_config_release_client(uid);
1120 __tts_config_release_engine();
1121 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1124 __tts_config_mgr_print_engine_info();
1126 if (0 != tts_parser_load_config(&g_config_info)) {
1127 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1128 __tts_config_release_client(uid);
1129 __tts_config_release_engine();
1130 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1133 /* Check whether engine id is valid */
1134 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1135 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1136 __tts_config_release_client(uid);
1137 __tts_config_release_engine();
1138 tts_parser_unload_config(g_config_info);
1139 g_config_info = NULL;
1140 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1143 if (true == g_config_info->auto_voice) {
1144 /* Check language with display language */
1145 __tts_config_set_auto_language();
1147 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1148 /* Default language is not valid */
1149 char* tmp_language = NULL;
1151 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1152 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1153 __tts_config_release_client(uid);
1154 __tts_config_release_engine();
1155 tts_parser_unload_config(g_config_info);
1156 g_config_info = NULL;
1157 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1160 if (NULL != tmp_language) {
1161 memset(g_language, '\0', sizeof(g_language));
1162 g_config_info->language = g_language;
1163 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
1165 g_config_info->type = tmp_type;
1168 tmp_language = NULL;
1170 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1171 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1172 __tts_config_release_client(uid);
1173 __tts_config_release_engine();
1174 tts_parser_unload_config(g_config_info);
1175 g_config_info = NULL;
1176 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1182 /* print daemon config */
1183 SLOG(LOG_DEBUG, tts_tag(), "@@@ TTS config @@@");
1184 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1185 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1186 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1187 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1188 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1189 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1190 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1191 SLOG(LOG_DEBUG, tts_tag(), "@@@@@");
1193 if (0 != __tts_config_mgr_register_config_event()) {
1194 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1195 __tts_config_release_client(uid);
1196 __tts_config_release_engine();
1197 tts_parser_unload_config(g_config_info);
1198 g_config_info = NULL;
1199 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1202 /* Register to detect display language change */
1203 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1204 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1206 /* For engine directory monitoring */
1207 //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1208 // SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1209 // __tts_config_release_client(uid);
1210 // __tts_config_release_engine();
1211 // tts_parser_unload_config(g_config_info);
1212 // __tts_config_mgr_unregister_config_event();
1213 // return TTS_CONFIG_ERROR_OPERATION_FAILED;
1219 int tts_config_mgr_finalize(int uid)
1221 if (0 < __tts_config_release_client(uid)) {
1225 tts_config_mgr_unset_callback(uid);
1227 __tts_config_release_engine();
1229 tts_parser_unload_config(g_config_info);
1230 g_config_info = NULL;
1232 __tts_config_mgr_unregister_engine_config_updated_event();
1234 __tts_config_mgr_unregister_config_event();
1236 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1237 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1242 int tts_config_mgr_set_callback(int uid,
1243 tts_config_engine_changed_cb engine_cb,
1244 tts_config_voice_changed_cb voice_cb,
1245 tts_config_speech_rate_changed_cb speech_cb,
1246 tts_config_pitch_changed_cb pitch_cb,
1249 GSList *iter = NULL;
1250 tts_config_client_s* temp_client = NULL;
1252 /* Call all callbacks of client*/
1253 iter = g_slist_nth(g_config_client_list, 0);
1255 while (NULL != iter) {
1256 temp_client = iter->data;
1258 if (NULL != temp_client) {
1259 if (uid == temp_client->uid) {
1260 temp_client->engine_cb = engine_cb;
1261 temp_client->voice_cb = voice_cb;
1262 temp_client->speech_cb = speech_cb;
1263 temp_client->pitch_cb = pitch_cb;
1264 temp_client->user_data = user_data;
1268 iter = g_slist_next(iter);
1273 int tts_config_mgr_unset_callback(int uid)
1275 GSList *iter = NULL;
1276 tts_config_client_s* temp_client = NULL;
1278 /* Call all callbacks of client*/
1279 iter = g_slist_nth(g_config_client_list, 0);
1281 while (NULL != iter) {
1282 temp_client = iter->data;
1284 if (NULL != temp_client) {
1285 if (uid == temp_client->uid) {
1286 temp_client->engine_cb = NULL;
1287 temp_client->voice_cb = NULL;
1288 temp_client->speech_cb = NULL;
1289 temp_client->pitch_cb = NULL;
1290 temp_client->user_data = NULL;
1294 iter = g_slist_next(iter);
1300 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1302 if (NULL == callback) {
1303 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1304 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1307 GSList *iter = NULL;
1308 tts_config_client_s* temp_client = NULL;
1310 /* Call all callbacks of client*/
1311 iter = g_slist_nth(g_config_client_list, 0);
1313 while (NULL != iter) {
1314 temp_client = iter->data;
1316 if (NULL != temp_client) {
1317 if (uid == temp_client->uid) {
1318 temp_client->screen_cb = callback;
1322 iter = g_slist_next(iter);
1327 int tts_config_unset_screen_reader_callback(int uid)
1329 GSList *iter = NULL;
1330 tts_config_client_s* temp_client = NULL;
1332 /* Call all callbacks of client*/
1333 iter = g_slist_nth(g_config_client_list, 0);
1335 while (NULL != iter) {
1336 temp_client = iter->data;
1338 if (NULL != temp_client) {
1339 if (uid == temp_client->uid) {
1340 temp_client->screen_cb = NULL;
1344 iter = g_slist_next(iter);
1350 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1352 if (0 >= g_slist_length(g_config_client_list)) {
1353 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1354 return TTS_CONFIG_ERROR_INVALID_STATE;
1357 GSList *iter = NULL;
1358 tts_engine_info_s *engine_info = NULL;
1360 if (0 >= g_slist_length(g_engine_list)) {
1361 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1362 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1365 /* Get a first item */
1366 iter = g_slist_nth(g_engine_list, 0);
1368 while (NULL != iter) {
1369 engine_info = iter->data;
1371 if (NULL != engine_info) {
1372 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1377 iter = g_slist_next(iter);
1383 int tts_config_mgr_get_engine(char** engine)
1385 if (0 >= g_slist_length(g_config_client_list)) {
1386 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1387 return TTS_CONFIG_ERROR_INVALID_STATE;
1390 if (NULL == engine) {
1391 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1392 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1395 if (NULL != g_config_info->engine_id) {
1396 /* Check engine id is valid */
1397 GSList *iter = NULL;
1398 tts_engine_info_s *engine_info = NULL;
1400 if (0 >= g_slist_length(g_engine_list)) {
1401 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1402 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1405 /* Get a first item */
1406 iter = g_slist_nth(g_engine_list, 0);
1408 while (NULL != iter) {
1409 engine_info = iter->data;
1411 if (NULL != engine_info) {
1412 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1413 *engine = strdup(g_config_info->engine_id);
1417 iter = g_slist_next(iter);
1420 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1422 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1425 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1428 int __tts_set_buxtonkey(const char* engine)
1431 struct buxton_client * bux_cli;
1432 struct buxton_layer * bux_layer;
1433 struct buxton_value * bux_val;
1435 int ret = buxton_open(&bux_cli, NULL, NULL);
1437 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1438 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1440 bux_layer = buxton_create_layer("system");
1441 if (NULL == bux_layer) {
1442 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
1443 buxton_close(bux_cli);
1444 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1446 bux_val = buxton_value_create_string(engine);
1447 if (NULL == bux_val) {
1448 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1449 buxton_free_layer(bux_layer);
1450 buxton_close(bux_cli);
1451 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1453 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1456 ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1458 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1459 buxton_value_free(bux_val);
1460 buxton_free_layer(bux_layer);
1461 buxton_close(bux_cli);
1467 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1469 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1472 buxton_value_free(bux_val);
1473 buxton_free_layer(bux_layer);
1474 buxton_close(bux_cli);
1480 return TTS_CONFIG_ERROR_NONE;
1483 int tts_config_mgr_set_engine(const char* engine)
1485 if (0 >= g_slist_length(g_config_client_list)) {
1486 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1487 return TTS_CONFIG_ERROR_INVALID_STATE;
1491 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1493 /* Check current engine id with new engine id */
1494 if (0 == strcmp(g_config_info->engine_id, engine))
1497 if (0 >= g_slist_length(g_engine_list)) {
1498 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1499 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1502 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1504 int ret = __tts_set_buxtonkey(engine);
1506 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] set_buxtonkey Fail!!");
1510 GSList *iter = NULL;
1511 tts_engine_info_s *engine_info = NULL;
1512 bool is_valid_engine = false;
1514 /* Get a first item */
1515 iter = g_slist_nth(g_engine_list, 0);
1517 while (NULL != iter) {
1518 engine_info = iter->data;
1520 if (NULL == engine_info) {
1521 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1522 iter = g_slist_next(iter);
1526 /* Check engine id is valid */
1527 if (0 != strcmp(engine, engine_info->uuid)) {
1528 iter = g_slist_next(iter);
1532 memset(g_engine_id, '\0', sizeof(g_engine_id));
1533 g_config_info->engine_id = g_engine_id;
1534 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
1536 if (NULL != engine_info->setting) {
1537 memset(g_setting, '\0', sizeof(g_setting));
1538 g_config_info->setting = g_setting;
1539 strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
1542 /* Engine is valid*/
1543 GSList *iter_voice = NULL;
1544 tts_config_voice_s* voice = NULL;
1545 bool is_valid_voice = false;
1547 /* Get a first item */
1548 iter_voice = g_slist_nth(engine_info->voices, 0);
1550 while (NULL != iter_voice) {
1551 /*Get handle data from list*/
1552 voice = iter_voice->data;
1554 if (NULL != voice) {
1555 if (NULL == voice->language)
1557 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1559 if (0 == strcmp(voice->language, g_config_info->language)) {
1560 if (voice->type == g_config_info->type) {
1561 /* language is valid */
1562 is_valid_voice = true;
1563 g_config_info->type = voice->type;
1570 iter_voice = g_slist_next(iter_voice);
1573 if (false == is_valid_voice) {
1574 memset(g_language, '\0', sizeof(g_language));
1575 g_config_info->language = g_language;
1577 iter_voice = g_slist_nth(engine_info->voices, 0);
1578 if (NULL != iter_voice) {
1579 voice = iter_voice->data;
1580 if (NULL != voice) {
1581 if (NULL != voice->language)
1582 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
1584 g_config_info->type = voice->type;
1589 is_valid_engine = true;
1593 if (true == is_valid_engine) {
1594 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1595 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1596 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1597 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1598 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1600 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1601 g_config_info->language, g_config_info->type)) {
1602 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1603 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1606 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1607 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1613 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1615 if (0 >= g_slist_length(g_config_client_list)) {
1616 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1617 return TTS_CONFIG_ERROR_INVALID_STATE;
1620 if (0 >= g_slist_length(g_engine_list)) {
1621 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1622 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1625 GSList *iter = NULL;
1626 tts_engine_info_s *engine_info = NULL;
1628 /* Get a first item */
1629 iter = g_slist_nth(g_engine_list, 0);
1631 while (NULL != iter) {
1632 engine_info = iter->data;
1634 if (NULL == engine_info) {
1635 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1636 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1639 if (0 != strcmp(engine_id, engine_info->uuid)) {
1640 iter = g_slist_next(iter);
1644 GSList *iter_voice = NULL;
1645 tts_config_voice_s* voice = NULL;
1647 /* Get a first item */
1648 iter_voice = g_slist_nth(engine_info->voices, 0);
1650 while (NULL != iter_voice) {
1651 /*Get handle data from list*/
1652 voice = iter_voice->data;
1654 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1655 if (NULL != voice->language) {
1656 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1661 iter_voice = g_slist_next(iter_voice);
1669 int tts_config_mgr_get_voice(char** language, int* type)
1671 if (0 >= g_slist_length(g_config_client_list)) {
1672 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1673 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1676 if (0 >= g_slist_length(g_engine_list)) {
1677 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1678 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1681 if (NULL == language || NULL == type)
1682 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1684 if (0 != strlen(g_config_info->language)) {
1685 *language = strdup(g_config_info->language);
1686 *type = g_config_info->type;
1688 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1689 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1695 int tts_config_mgr_set_voice(const char* language, int type)
1697 if (0 >= g_slist_length(g_config_client_list)) {
1698 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1699 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1702 if (NULL == language) {
1703 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1704 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1707 if (0 >= g_slist_length(g_engine_list)) {
1708 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1709 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1712 /* Check language is valid */
1713 if (0 != tts_parser_set_voice(language, type)) {
1714 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1715 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1717 memset(g_language, '\0', sizeof(g_language));
1718 g_config_info->language = g_language;
1719 strncpy(g_config_info->language, language, sizeof(g_language) - 1);
1721 g_config_info->type = type;
1726 int tts_config_mgr_get_auto_voice(bool* value)
1728 if (0 >= g_slist_length(g_config_client_list)) {
1729 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1730 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1734 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1736 *value = g_config_info->auto_voice;
1741 int tts_config_mgr_set_auto_voice(bool value)
1743 if (0 >= g_slist_length(g_config_client_list)) {
1744 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1745 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1748 if (g_config_info->auto_voice != value) {
1749 /* Check language is valid */
1750 if (0 != tts_parser_set_auto_voice(value)) {
1751 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1752 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1754 g_config_info->auto_voice = value;
1756 if (true == g_config_info->auto_voice) {
1757 __tts_config_set_auto_language();
1764 int tts_config_mgr_get_speech_rate(int* value)
1766 if (0 >= g_slist_length(g_config_client_list)) {
1767 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1768 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1771 if (NULL == value) {
1772 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1775 *value = g_config_info->speech_rate;
1780 int tts_config_mgr_set_speech_rate(int value)
1782 if (0 >= g_slist_length(g_config_client_list)) {
1783 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1784 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1787 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1788 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1789 if (0 != tts_parser_set_speech_rate(value)) {
1790 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1791 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1794 g_config_info->speech_rate = value;
1796 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1802 int tts_config_mgr_get_pitch(int* value)
1804 if (0 >= g_slist_length(g_config_client_list)) {
1805 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1806 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1809 if (NULL == value) {
1810 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1813 GSList *iter = NULL;
1814 tts_engine_info_s *engine_info = NULL;
1816 if (0 >= g_slist_length(g_engine_list)) {
1817 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1818 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1821 /* Get a first item */
1822 iter = g_slist_nth(g_engine_list, 0);
1824 while (NULL != iter) {
1825 engine_info = iter->data;
1827 if (NULL == engine_info) {
1828 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1829 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1832 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1833 iter = g_slist_next(iter);
1837 if (false == engine_info->pitch_support) {
1838 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1844 *value = g_config_info->pitch;
1849 int tts_config_mgr_set_pitch(int value)
1851 if (0 >= g_slist_length(g_config_client_list)) {
1852 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1856 GSList *iter = NULL;
1857 tts_engine_info_s *engine_info = NULL;
1859 if (0 >= g_slist_length(g_engine_list)) {
1860 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1861 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1864 /* Get a first item */
1865 iter = g_slist_nth(g_engine_list, 0);
1867 while (NULL != iter) {
1868 engine_info = iter->data;
1870 if (NULL == engine_info) {
1871 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1872 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1875 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1876 iter = g_slist_next(iter);
1880 if (false == engine_info->pitch_support) {
1881 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1887 if (0 != tts_parser_set_pitch(value)) {
1888 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1889 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1892 g_config_info->pitch = value;
1897 bool tts_config_check_default_engine_is_valid(const char* engine)
1899 if (0 >= g_slist_length(g_config_client_list)) {
1900 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1907 if (0 >= g_slist_length(g_engine_list))
1910 GSList *iter = NULL;
1911 tts_engine_info_s *engine_info = NULL;
1913 /* Get a first item */
1914 iter = g_slist_nth(g_engine_list, 0);
1916 while (NULL != iter) {
1917 engine_info = iter->data;
1919 if (NULL != engine_info) {
1920 if (0 == strcmp(engine, engine_info->uuid)) {
1924 iter = g_slist_next(iter);
1930 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1932 if (0 >= g_slist_length(g_config_client_list)) {
1933 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1937 if (NULL == language)
1940 if (0 == strlen(g_config_info->engine_id)) {
1941 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1945 if (0 >= g_slist_length(g_engine_list))
1948 GSList *iter = NULL;
1949 tts_engine_info_s *engine_info = NULL;
1951 /* Get a first item */
1952 iter = g_slist_nth(g_engine_list, 0);
1954 while (NULL != iter) {
1955 engine_info = iter->data;
1957 if (NULL == engine_info) {
1958 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1959 iter = g_slist_next(iter);
1963 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1964 iter = g_slist_next(iter);
1968 GSList *iter_voice = NULL;
1969 tts_config_voice_s* voice = NULL;
1971 /* Get a first item */
1972 iter_voice = g_slist_nth(engine_info->voices, 0);
1974 while (NULL != iter_voice) {
1975 voice = iter_voice->data;
1977 if (0 == strcmp(language, voice->language) && voice->type == type)
1981 iter_voice = g_slist_next(iter_voice);
1991 int __tts_config_mgr_print_engine_info()
1993 GSList *iter = NULL;
1994 tts_engine_info_s *engine_info = NULL;
1996 if (0 >= g_slist_length(g_engine_list)) {
1997 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1998 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1999 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
2003 /* Get a first item */
2004 iter = g_slist_nth(g_engine_list, 0);
2006 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
2009 while (NULL != iter) {
2010 engine_info = iter->data;
2012 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
2013 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
2014 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
2015 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
2017 SLOG(LOG_DEBUG, tts_tag(), " Voices");
2018 GSList *iter_voice = NULL;
2019 tts_config_voice_s* voice = NULL;
2021 if (g_slist_length(engine_info->voices) > 0) {
2022 /* Get a first item */
2023 iter_voice = g_slist_nth(engine_info->voices, 0);
2026 while (NULL != iter_voice) {
2027 /*Get handle data from list*/
2028 voice = iter_voice->data;
2030 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2033 iter_voice = g_slist_next(iter_voice);
2037 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
2039 iter = g_slist_next(iter);
2042 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
2047 int tts_config_mgr_get_max_text_size(unsigned int* size)
2049 if (0 >= g_slist_length(g_config_client_list)) {
2050 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
2051 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2055 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2058 GSList *iter = NULL;
2059 tts_engine_info_s *engine_info = NULL;
2061 if (0 >= g_slist_length(g_engine_list)) {
2062 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
2063 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
2066 /* Get a first item */
2067 iter = g_slist_nth(g_engine_list, 0);
2069 while (NULL != iter) {
2070 engine_info = iter->data;
2072 if (NULL == engine_info) {
2073 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
2074 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2077 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
2078 iter = g_slist_next(iter);
2085 if (NULL == engine_info) {
2086 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
2087 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2090 *size = engine_info->text_size;
2091 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Max text size is %d.", *size);