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 static GSList* g_engine_list = NULL;
41 static GSList* g_config_client_list = NULL;
43 static tts_config_s* g_config_info = NULL;
44 extern char g_engine_id[128];
45 extern char g_setting[128];
46 extern char g_language[128];
48 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
49 static int g_config_fd_noti;
50 static int g_config_wd_noti;
52 /* For engine directory monitoring */
54 Ecore_Fd_Handler* dir_fd_handler;
57 } tts_engine_inotify_s;
59 static GList* g_ino_list = NULL;
61 int __tts_config_mgr_print_engine_info();
62 static int __tts_config_mgr_register_engine_config_updated_event(const char* path);
63 static int __tts_config_mgr_unregister_engine_config_updated_event();
65 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
67 if (NULL == engine_id) {
68 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
73 tts_engine_info_s *engine_info = NULL;
75 if (0 >= g_slist_length(g_engine_list)) {
76 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
80 /* Get a first item */
81 iter = g_slist_nth(g_engine_list, 0);
83 while (NULL != iter) {
84 engine_info = iter->data;
86 if (NULL == engine_info) {
87 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
91 if (NULL != engine_info->uuid && 0 == strcmp(engine_id, engine_info->uuid)) {
92 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is valid : %s", engine_id);
96 iter = g_slist_next(iter);
99 /* Change default engine */
100 iter = g_slist_nth(g_engine_list, 0);
102 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine in list");
103 return TTS_CONFIG_ERROR_OPERATION_FAILED;
106 engine_info = iter->data;
107 if (NULL == g_config_info) {
108 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Invalid engine info in list");
109 return TTS_CONFIG_ERROR_OPERATION_FAILED;
112 if (NULL != engine_info->uuid) {
113 memset(g_engine_id, '\0', sizeof(g_engine_id));
114 g_config_info->engine_id = g_engine_id;
115 strncpy(g_config_info->engine_id, engine_info->uuid, sizeof(g_engine_id) - 1);
117 if (NULL != engine_info->setting) {
118 memset(g_setting, '\0', sizeof(g_setting));
119 g_config_info->setting = g_setting;
120 strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
123 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is changed : %s", g_config_info->engine_id);
125 /* Change is default voice */
126 GSList *iter_voice = NULL;
127 tts_config_voice_s* voice = NULL;
128 bool is_valid_voice = false;
130 /* Get a first item */
131 iter_voice = g_slist_nth(engine_info->voices, 0);
133 while (NULL != iter_voice) {
134 /*Get handle data from list*/
135 voice = iter_voice->data;
138 if (NULL != voice->language) {
139 if (0 == strcmp(voice->language, g_config_info->language)) {
140 if (voice->type == g_config_info->type) {
141 /* language is valid */
142 is_valid_voice = true;
144 memset(g_language, '\0', sizeof(g_language));
145 g_config_info->language = g_language;
146 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
148 g_config_info->type = voice->type;
150 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
157 iter_voice = g_slist_next(iter_voice);
160 if (false == is_valid_voice) {
161 /* Select first voice as default */
162 memset(g_language, '\0', sizeof(g_language));
163 g_config_info->language = g_language;
165 iter_voice = g_slist_nth(engine_info->voices, 0);
166 if (NULL == iter_voice) {
167 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice list");
168 return TTS_CONFIG_ERROR_OPERATION_FAILED;
170 voice = iter_voice->data;
172 if (NULL == voice || NULL == voice->language) {
173 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice info from list");
174 return TTS_CONFIG_ERROR_OPERATION_FAILED;
176 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
178 g_config_info->type = voice->type;
179 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
182 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language, g_config_info->type)) {
183 SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
184 return TTS_CONFIG_ERROR_OPERATION_FAILED;
190 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
192 if (NULL == engine_id || NULL == language) {
193 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
198 tts_engine_info_s *engine_info = NULL;
200 if (0 >= g_slist_length(g_engine_list)) {
201 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
205 /* Get a first item */
206 iter = g_slist_nth(g_engine_list, 0);
208 while (NULL != iter) {
209 engine_info = iter->data;
211 if (NULL == engine_info) {
212 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
216 if (0 != strcmp(engine_id, engine_info->uuid)) {
217 iter = g_slist_next(iter);
221 GSList *iter_voice = NULL;
222 tts_config_voice_s* voice = NULL;
224 if (g_slist_length(engine_info->voices) <= 0) {
225 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no voice : %s", engine_info->uuid);
226 iter = g_slist_next(iter);
230 /* Get a first item */
231 iter_voice = g_slist_nth(engine_info->voices, 0);
234 while (NULL != iter_voice) {
235 /*Get handle data from list*/
236 voice = iter_voice->data;
239 if (0 == strcmp(language, voice->language)) {
240 if (type == voice->type) {
247 iter_voice = g_slist_next(iter_voice);
257 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
259 if (NULL == engine_id || NULL == language) {
260 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
265 tts_engine_info_s *engine_info = NULL;
267 if (0 >= g_slist_length(g_engine_list)) {
268 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
272 /* Get a first item */
273 iter = g_slist_nth(g_engine_list, 0);
275 while (NULL != iter) {
276 engine_info = iter->data;
278 if (NULL == engine_info) {
279 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
283 if (0 != strcmp(engine_id, engine_info->uuid)) {
284 iter = g_slist_next(iter);
288 GSList *iter_voice = NULL;
289 tts_config_voice_s* voice = NULL;
291 if (g_slist_length(engine_info->voices) <= 0) {
292 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no voice : %s", engine_info->uuid);
296 /* Get a first item */
297 iter_voice = g_slist_nth(engine_info->voices, 0);
299 while (NULL != iter_voice) {
300 voice = iter_voice->data;
302 /* Default language */
303 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
304 *language = strdup(voice->language);
307 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
311 iter_voice = g_slist_next(iter_voice);
314 /* Not support base language */
316 *language = strdup(voice->language);
319 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
328 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
330 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Config changed callback event");
333 struct inotify_event event;
334 memset(&event, '\0', sizeof(struct inotify_event));
336 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
338 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty Inotify event");
339 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
340 return ECORE_CALLBACK_DONE;
343 if (IN_CLOSE_WRITE == event.mask) {
344 /* check config changed state */
346 char* setting = NULL;
348 bool auto_voice = g_config_info->auto_voice;
350 int speech_rate = -1;
354 tts_config_client_s* temp_client = NULL;
356 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
357 return ECORE_CALLBACK_PASS_ON;
360 if (NULL != engine || NULL != setting) {
361 if (NULL != engine) {
362 memset(g_engine_id, '\0', sizeof(g_engine_id));
363 g_config_info->engine_id = g_engine_id;
364 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
366 if (NULL != setting) {
367 memset(g_setting, '\0', sizeof(g_setting));
368 g_config_info->setting = g_setting;
369 strncpy(g_config_info->setting, setting, sizeof(g_setting) - 1);
372 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", g_config_info->engine_id);
374 /* Call all callbacks of client*/
375 iter = g_slist_nth(g_config_client_list, 0);
377 while (NULL != iter) {
378 temp_client = iter->data;
380 if (NULL != temp_client) {
381 if (NULL != temp_client->engine_cb) {
382 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
383 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
384 g_config_info->language, g_config_info->type,
385 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
389 iter = g_slist_next(iter);
393 if (auto_voice != g_config_info->auto_voice) {
394 g_config_info->auto_voice = auto_voice;
397 if (NULL != lang || -1 != voice_type) {
398 char* before_lang = NULL;
401 before_lang = strdup(g_config_info->language);
402 before_type = g_config_info->type;
405 memset(g_language, '\0', sizeof(g_language));
406 g_config_info->language = g_language;
407 strncpy(g_config_info->language, lang, sizeof(g_language) - 1);
409 if (-1 != voice_type) {
410 g_config_info->type = voice_type;
413 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
415 /* Call all callbacks of client*/
416 iter = g_slist_nth(g_config_client_list, 0);
418 while (NULL != iter) {
419 temp_client = iter->data;
421 if (NULL != temp_client) {
422 if (NULL != temp_client->voice_cb) {
423 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%d)", temp_client->uid);
424 temp_client->voice_cb(before_lang, before_type,
425 g_config_info->language, g_config_info->type,
426 g_config_info->auto_voice, temp_client->user_data);
430 iter = g_slist_next(iter);
433 if (NULL != before_lang) {
439 if (-1 != speech_rate) {
440 g_config_info->speech_rate = speech_rate;
442 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate change(%d)", g_config_info->speech_rate);
444 /* Call all callbacks of client*/
445 iter = g_slist_nth(g_config_client_list, 0);
447 while (NULL != iter) {
448 temp_client = iter->data;
450 if (NULL != temp_client) {
451 if (NULL != temp_client->speech_cb) {
452 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate changed callback : uid(%d)", temp_client->uid);
453 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
457 iter = g_slist_next(iter);
462 g_config_info->pitch = pitch;
464 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "pitch change(%d)", g_config_info->pitch);
466 /* Call all callbacks of client*/
467 iter = g_slist_nth(g_config_client_list, 0);
469 while (NULL != iter) {
470 temp_client = iter->data;
472 if (NULL != temp_client) {
473 if (NULL != temp_client->pitch_cb) {
474 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Pitch changed callback : uid(%d)", temp_client->uid);
475 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
479 iter = g_slist_next(iter);
483 if (NULL != engine) {
487 if (NULL != setting) {
495 } else if (IN_DELETE_SELF == event.mask) {
496 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] IN_DELETE_SELF event");
498 tts_parser_unload_config(g_config_info);
500 tts_parser_load_config(&g_config_info);
502 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event (0x%x)", event.mask);
505 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
507 return ECORE_CALLBACK_PASS_ON;
510 int __tts_config_mgr_register_config_event()
512 /* get file notification handler */
518 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail get inotify fd");
521 g_config_fd_noti = fd;
523 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE|IN_DELETE_SELF);
524 g_config_wd_noti = wd;
526 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
527 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
528 if (NULL == g_config_fd_handler_noti) {
529 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get handler_noti");
533 /* Set non-blocking mode of file */
535 value = fcntl(fd, F_GETFL, 0);
538 if (0 > fcntl(fd, F_SETFL, value)) {
539 SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
545 int __tts_config_mgr_unregister_config_event()
547 /* delete inotify variable */
548 ecore_main_fd_handler_del(g_config_fd_handler_noti);
549 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
550 close(g_config_fd_noti);
555 int __tts_config_set_auto_language()
558 value = vconf_get_str(TTS_LANGSET_KEY);
560 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get display language");
564 char temp_lang[6] = {'\0', };
565 strncpy(temp_lang, value, 5);
569 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
570 /* tts default voice change */
571 if (NULL == g_config_info->language) {
572 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Current config language is NULL");
576 char* before_lang = NULL;
579 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
580 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
584 before_lang = strdup(g_config_info->language);
585 before_type = g_config_info->type;
587 memset(g_language, '\0', sizeof(g_language));
588 g_config_info->language = g_language;
589 strncpy(g_config_info->language, temp_lang, sizeof(g_language) - 1);
591 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
592 g_config_info->language, g_config_info->type);
595 tts_config_client_s* temp_client = NULL;
597 /* Call all callbacks of client*/
598 iter = g_slist_nth(g_config_client_list, 0);
600 while (NULL != iter) {
601 temp_client = iter->data;
603 if (NULL != temp_client) {
604 if (NULL != temp_client->voice_cb) {
605 temp_client->voice_cb(before_lang, before_type,
606 g_config_info->language, g_config_info->type,
607 g_config_info->auto_voice, temp_client->user_data);
611 iter = g_slist_next(iter);
614 if (NULL != before_lang) {
619 /* Display language is not valid */
620 char* tmp_language = NULL;
622 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
623 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
627 if (NULL == tmp_language) {
628 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] language is NULL");
632 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
633 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
637 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
638 tmp_language, tmp_type);
641 tts_config_client_s* temp_client = NULL;
643 /* Call all callbacks of client*/
644 iter = g_slist_nth(g_config_client_list, 0);
646 while (NULL != iter) {
647 temp_client = iter->data;
649 if (NULL != temp_client) {
650 if (NULL != temp_client->voice_cb) {
651 temp_client->voice_cb(g_config_info->language, g_config_info->type,
652 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
656 iter = g_slist_next(iter);
660 memset(g_language, '\0', sizeof(g_language));
661 g_config_info->language = g_language;
662 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
664 g_config_info->type = tmp_type;
673 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
675 if (NULL == g_config_info) {
676 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Current config info is invalid.");
680 if (true == g_config_info->auto_voice) {
681 __tts_config_set_auto_language();
687 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
691 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
693 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get screen reader");
698 tts_config_client_s* temp_client = NULL;
700 /* Call all callbacks of client*/
701 iter = g_slist_nth(g_config_client_list, 0);
703 while (NULL != iter) {
704 temp_client = iter->data;
706 if (NULL != temp_client) {
707 if (NULL != temp_client->screen_cb) {
708 temp_client->screen_cb((bool)screen_reader);
712 iter = g_slist_next(iter);
716 int __tts_config_release_client(int uid)
719 tts_config_client_s* temp_client = NULL;
721 if (0 < g_slist_length(g_config_client_list)) {
723 iter = g_slist_nth(g_config_client_list, 0);
725 while (NULL != iter) {
726 temp_client = iter->data;
728 if (NULL != temp_client) {
729 if (uid == temp_client->uid) {
730 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
737 iter = g_slist_next(iter);
741 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Client count (%d)", g_slist_length(g_config_client_list));
743 return g_slist_length(g_config_client_list);
746 void __tts_config_release_engine()
749 tts_engine_info_s *engine_info = NULL;
751 if (0 < g_slist_length(g_engine_list)) {
753 /* Get a first item */
754 iter = g_slist_nth(g_engine_list, 0);
756 while (NULL != iter) {
757 engine_info = iter->data;
759 if (NULL != engine_info) {
760 g_engine_list = g_slist_remove(g_engine_list, engine_info);
762 tts_parser_free_engine_info(engine_info);
765 iter = g_slist_nth(g_engine_list, 0);
772 int __tts_config_mgr_get_engine_info()
775 struct dirent *dirp = NULL;
777 char filepath[512] = {'\0',};
779 tts_engine_info_s* info = NULL;
781 __tts_config_release_engine();
782 g_engine_list = NULL;
783 __tts_config_mgr_unregister_engine_config_updated_event();
785 /* Copy default info directory to download directory */
786 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
788 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
794 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
797 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
798 if (filesize >= 512) {
799 SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
804 memset(filepath, '\0', 512);
805 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
807 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
809 char dest[512] = {'\0',};
810 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
812 if (0 != access(dest, F_OK)) {
813 if (0 != tts_parser_copy_xml(filepath, dest)) {
814 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] Fail to copy engine info");
818 } while (NULL != dirp);
823 /* Get engine info from default engine directory */
824 dp = opendir(TTS_DOWNLOAD_ENGINE_INFO);
826 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
832 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
835 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
836 if (filesize >= 512) {
837 SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
842 memset(filepath, '\0', 512);
843 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
845 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
847 if (0 == tts_parser_get_engine_info(filepath, &info)) {
848 g_engine_list = g_slist_append(g_engine_list, info);
849 if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
850 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
854 } while (NULL != dirp);
859 if (0 >= g_slist_length(g_engine_list)) {
860 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine");
867 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
869 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Engine config updated callback event");
871 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
872 int dir_fd = ino->dir_fd;
875 struct inotify_event event;
876 memset(&event, '\0', sizeof(struct inotify_event));
878 length = read(dir_fd, &event, sizeof(struct inotify_event));
880 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty Inotify event");
881 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
882 return ECORE_CALLBACK_DONE;
885 if (IN_CLOSE_WRITE == event.mask) {
886 int ret = __tts_config_mgr_get_engine_info();
888 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info when config updated");
890 __tts_config_mgr_print_engine_info();
891 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
892 if (false == support) {
893 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[ERROR] Default voice is valid");
894 char* temp_lang = NULL;
896 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
898 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get voice");
901 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
903 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set voice");
905 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
907 if (NULL != temp_lang) {
914 tts_config_client_s* temp_client = NULL;
915 /* Call all callbacks of client*/
916 iter = g_slist_nth(g_config_client_list, 0);
918 while (NULL != iter) {
919 temp_client = iter->data;
921 if (NULL != temp_client) {
922 if (NULL != temp_client->engine_cb) {
923 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
924 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
925 g_config_info->language, g_config_info->type,
926 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
930 iter = g_slist_next(iter);
933 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event");
936 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
938 return ECORE_CALLBACK_PASS_ON;
941 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
944 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Path is NULL");
948 /* For engine directory monitoring */
949 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
951 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
955 ino->dir_fd = inotify_init();
956 if (ino->dir_fd < 0) {
957 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to init inotify");
964 ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
965 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Add inotify watch(%s)", path);
966 if (ino->dir_wd < 0) {
967 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add watch");
973 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);
974 if (NULL == ino->dir_fd_handler) {
975 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add fd handler");
981 /* Set non-blocking mode of file */
983 value = fcntl(ino->dir_fd, F_GETFL, 0);
986 if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
987 SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
990 g_ino_list = g_list_append(g_ino_list, ino);
995 static int __tts_config_mgr_unregister_engine_config_updated_event()
997 /* delete all inotify variable */
998 if (0 < g_list_length(g_ino_list)) {
1000 iter = g_list_first(g_ino_list);
1002 while (NULL != iter) {
1003 tts_engine_inotify_s *tmp = iter->data;
1006 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1007 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1014 g_ino_list = g_list_remove_link(g_ino_list, iter);
1016 iter = g_list_first(g_ino_list);
1023 int tts_config_mgr_initialize(int uid)
1025 GSList *iter = NULL;
1027 tts_config_client_s* temp_client = NULL;
1030 if (0 < g_slist_length(g_config_client_list)) {
1032 iter = g_slist_nth(g_config_client_list, 0);
1034 while (NULL != iter) {
1035 get_uid = iter->data;
1037 if (uid == *get_uid) {
1038 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] uid(%d) has already registered", uid);
1042 iter = g_slist_next(iter);
1045 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1046 if (NULL == temp_client) {
1047 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
1048 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1050 temp_client->uid = uid;
1051 temp_client->engine_cb = NULL;
1052 temp_client->voice_cb = NULL;
1053 temp_client->speech_cb = NULL;
1054 temp_client->pitch_cb = NULL;
1055 temp_client->screen_cb = NULL;
1056 temp_client->user_data = NULL;
1058 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1060 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%d) but config has already initialized", uid);
1063 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1064 if (NULL == temp_client) {
1065 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
1066 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1068 temp_client->uid = uid;
1069 temp_client->engine_cb = NULL;
1070 temp_client->voice_cb = NULL;
1071 temp_client->speech_cb = NULL;
1072 temp_client->pitch_cb = NULL;
1073 temp_client->screen_cb = NULL;
1074 temp_client->user_data = NULL;
1076 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1079 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1080 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1081 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1082 __tts_config_release_client(uid);
1083 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1085 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_CONFIG_BASE);
1089 if (0 != access(TTS_HOME, F_OK)) {
1090 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1091 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_HOME);
1092 __tts_config_release_client(uid);
1093 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1095 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_HOME);
1099 if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1100 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1101 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1102 __tts_config_release_client(uid);
1103 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1105 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1109 if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1110 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1111 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1112 __tts_config_release_client(uid);
1113 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1115 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1119 if (0 != __tts_config_mgr_get_engine_info()) {
1120 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info");
1121 __tts_config_release_client(uid);
1122 __tts_config_release_engine();
1123 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1126 __tts_config_mgr_print_engine_info();
1128 if (0 != tts_parser_load_config(&g_config_info)) {
1129 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to parse configure information");
1130 __tts_config_release_client(uid);
1131 __tts_config_release_engine();
1132 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1135 /* Check whether engine id is valid */
1136 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1137 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get default engine");
1138 __tts_config_release_client(uid);
1139 __tts_config_release_engine();
1140 tts_parser_unload_config(g_config_info);
1141 g_config_info = NULL;
1142 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1145 if (true == g_config_info->auto_voice) {
1146 /* Check language with display language */
1147 __tts_config_set_auto_language();
1149 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1150 /* Default language is not valid */
1151 char* tmp_language = NULL;
1153 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1154 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
1155 __tts_config_release_client(uid);
1156 __tts_config_release_engine();
1157 tts_parser_unload_config(g_config_info);
1158 g_config_info = NULL;
1159 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1162 if (NULL != tmp_language) {
1163 memset(g_language, '\0', sizeof(g_language));
1164 g_config_info->language = g_language;
1165 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
1167 g_config_info->type = tmp_type;
1170 tmp_language = NULL;
1172 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1173 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1174 __tts_config_release_client(uid);
1175 __tts_config_release_engine();
1176 tts_parser_unload_config(g_config_info);
1177 g_config_info = NULL;
1178 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1184 /* print daemon config */
1185 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ TTS config @@@");
1186 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " engine : %s", g_config_info->engine_id);
1187 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", g_config_info->setting);
1188 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1189 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " language : %s", g_config_info->language);
1190 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " voice type : %d", g_config_info->type);
1191 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " speech rate : %d", g_config_info->speech_rate);
1192 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " pitch : %d", g_config_info->pitch);
1193 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@@@");
1195 if (0 != __tts_config_mgr_register_config_event()) {
1196 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register config event");
1197 __tts_config_release_client(uid);
1198 __tts_config_release_engine();
1199 tts_parser_unload_config(g_config_info);
1200 g_config_info = NULL;
1201 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1204 /* Register to detect display language change */
1205 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1206 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1208 /* For engine directory monitoring */
1209 //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1210 // SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
1211 // __tts_config_release_client(uid);
1212 // __tts_config_release_engine();
1213 // tts_parser_unload_config(g_config_info);
1214 // __tts_config_mgr_unregister_config_event();
1215 // return TTS_CONFIG_ERROR_OPERATION_FAILED;
1221 int tts_config_mgr_finalize(int uid)
1223 if (0 < __tts_config_release_client(uid)) {
1227 tts_config_mgr_unset_callback(uid);
1229 __tts_config_release_engine();
1231 tts_parser_unload_config(g_config_info);
1232 g_config_info = NULL;
1234 __tts_config_mgr_unregister_engine_config_updated_event();
1236 __tts_config_mgr_unregister_config_event();
1238 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1239 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1244 int tts_config_mgr_set_callback(int uid,
1245 tts_config_engine_changed_cb engine_cb,
1246 tts_config_voice_changed_cb voice_cb,
1247 tts_config_speech_rate_changed_cb speech_cb,
1248 tts_config_pitch_changed_cb pitch_cb,
1251 GSList *iter = NULL;
1252 tts_config_client_s* temp_client = NULL;
1254 /* Call all callbacks of client*/
1255 iter = g_slist_nth(g_config_client_list, 0);
1257 while (NULL != iter) {
1258 temp_client = iter->data;
1260 if (NULL != temp_client) {
1261 if (uid == temp_client->uid) {
1262 temp_client->engine_cb = engine_cb;
1263 temp_client->voice_cb = voice_cb;
1264 temp_client->speech_cb = speech_cb;
1265 temp_client->pitch_cb = pitch_cb;
1266 temp_client->user_data = user_data;
1270 iter = g_slist_next(iter);
1275 int tts_config_mgr_unset_callback(int uid)
1277 GSList *iter = NULL;
1278 tts_config_client_s* temp_client = NULL;
1280 /* Call all callbacks of client*/
1281 iter = g_slist_nth(g_config_client_list, 0);
1283 while (NULL != iter) {
1284 temp_client = iter->data;
1286 if (NULL != temp_client) {
1287 if (uid == temp_client->uid) {
1288 temp_client->engine_cb = NULL;
1289 temp_client->voice_cb = NULL;
1290 temp_client->speech_cb = NULL;
1291 temp_client->pitch_cb = NULL;
1292 temp_client->user_data = NULL;
1296 iter = g_slist_next(iter);
1302 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1304 if (NULL == callback) {
1305 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
1306 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1309 GSList *iter = NULL;
1310 tts_config_client_s* temp_client = NULL;
1312 /* Call all callbacks of client*/
1313 iter = g_slist_nth(g_config_client_list, 0);
1315 while (NULL != iter) {
1316 temp_client = iter->data;
1318 if (NULL != temp_client) {
1319 if (uid == temp_client->uid) {
1320 temp_client->screen_cb = callback;
1324 iter = g_slist_next(iter);
1329 int tts_config_unset_screen_reader_callback(int uid)
1331 GSList *iter = NULL;
1332 tts_config_client_s* temp_client = NULL;
1334 /* Call all callbacks of client*/
1335 iter = g_slist_nth(g_config_client_list, 0);
1337 while (NULL != iter) {
1338 temp_client = iter->data;
1340 if (NULL != temp_client) {
1341 if (uid == temp_client->uid) {
1342 temp_client->screen_cb = NULL;
1346 iter = g_slist_next(iter);
1352 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1354 if (0 >= g_slist_length(g_config_client_list)) {
1355 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1356 return TTS_CONFIG_ERROR_INVALID_STATE;
1359 GSList *iter = NULL;
1360 tts_engine_info_s *engine_info = NULL;
1362 if (0 >= g_slist_length(g_engine_list)) {
1363 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
1364 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1367 /* Get a first item */
1368 iter = g_slist_nth(g_engine_list, 0);
1370 while (NULL != iter) {
1371 engine_info = iter->data;
1373 if (NULL != engine_info) {
1374 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1379 iter = g_slist_next(iter);
1385 int tts_config_mgr_get_engine(char** engine)
1387 if (0 >= g_slist_length(g_config_client_list)) {
1388 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1389 return TTS_CONFIG_ERROR_INVALID_STATE;
1392 if (NULL == engine) {
1393 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1394 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1397 if (NULL != g_config_info->engine_id) {
1398 /* Check engine id is valid */
1399 GSList *iter = NULL;
1400 tts_engine_info_s *engine_info = NULL;
1402 if (0 >= g_slist_length(g_engine_list)) {
1403 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1404 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1407 /* Get a first item */
1408 iter = g_slist_nth(g_engine_list, 0);
1410 while (NULL != iter) {
1411 engine_info = iter->data;
1413 if (NULL != engine_info) {
1414 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1415 *engine = strdup(g_config_info->engine_id);
1419 iter = g_slist_next(iter);
1422 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Current engine id is not valid");
1424 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine id is NULL");
1427 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1430 int __tts_set_buxtonkey(const char* engine)
1433 struct buxton_client * bux_cli;
1434 struct buxton_layer * bux_layer;
1435 struct buxton_value * bux_val;
1437 int ret = buxton_open(&bux_cli, NULL, NULL);
1439 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1440 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1442 bux_layer = buxton_create_layer("system");
1443 if (NULL == bux_layer) {
1444 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_create_layer FAIL");
1445 buxton_close(bux_cli);
1446 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1448 bux_val = buxton_value_create_string(engine);
1449 if (NULL == bux_val) {
1450 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1451 buxton_free_layer(bux_layer);
1452 buxton_close(bux_cli);
1453 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1455 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1458 ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1460 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1461 buxton_value_free(bux_val);
1462 buxton_free_layer(bux_layer);
1463 buxton_close(bux_cli);
1469 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1471 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1474 buxton_value_free(bux_val);
1475 buxton_free_layer(bux_layer);
1476 buxton_close(bux_cli);
1482 return TTS_CONFIG_ERROR_NONE;
1485 int tts_config_mgr_set_engine(const char* engine)
1487 if (0 >= g_slist_length(g_config_client_list)) {
1488 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1489 return TTS_CONFIG_ERROR_INVALID_STATE;
1493 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1495 /* Check current engine id with new engine id */
1496 if (0 == strcmp(g_config_info->engine_id, engine))
1499 if (0 >= g_slist_length(g_engine_list)) {
1500 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1501 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1504 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "New engine id : %s", engine);
1506 int ret = __tts_set_buxtonkey(engine);
1508 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] set_buxtonkey Fail!!");
1512 GSList *iter = NULL;
1513 tts_engine_info_s *engine_info = NULL;
1514 bool is_valid_engine = false;
1516 /* Get a first item */
1517 iter = g_slist_nth(g_engine_list, 0);
1519 while (NULL != iter) {
1520 engine_info = iter->data;
1522 if (NULL == engine_info) {
1523 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine info is NULL");
1524 iter = g_slist_next(iter);
1528 /* Check engine id is valid */
1529 if (0 != strcmp(engine, engine_info->uuid)) {
1530 iter = g_slist_next(iter);
1534 memset(g_engine_id, '\0', sizeof(g_engine_id));
1535 g_config_info->engine_id = g_engine_id;
1536 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
1538 if (NULL != engine_info->setting) {
1539 memset(g_setting, '\0', sizeof(g_setting));
1540 g_config_info->setting = g_setting;
1541 strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
1544 /* Engine is valid*/
1545 GSList *iter_voice = NULL;
1546 tts_config_voice_s* voice = NULL;
1547 bool is_valid_voice = false;
1549 /* Get a first item */
1550 iter_voice = g_slist_nth(engine_info->voices, 0);
1552 while (NULL != iter_voice) {
1553 /*Get handle data from list*/
1554 voice = iter_voice->data;
1556 if (NULL != voice) {
1557 if (NULL == voice->language)
1559 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " lang(%s) type(%d)", voice->language, voice->type);
1561 if (0 == strcmp(voice->language, g_config_info->language)) {
1562 if (voice->type == g_config_info->type) {
1563 /* language is valid */
1564 is_valid_voice = true;
1565 g_config_info->type = voice->type;
1572 iter_voice = g_slist_next(iter_voice);
1575 if (false == is_valid_voice) {
1576 memset(g_language, '\0', sizeof(g_language));
1577 g_config_info->language = g_language;
1579 iter_voice = g_slist_nth(engine_info->voices, 0);
1580 if (NULL != iter_voice) {
1581 voice = iter_voice->data;
1582 if (NULL != voice) {
1583 if (NULL != voice->language)
1584 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
1586 g_config_info->type = voice->type;
1591 is_valid_engine = true;
1595 if (true == is_valid_engine) {
1596 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Engine changed");
1597 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Engine : %s", g_config_info->engine_id);
1598 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Setting : %s", g_config_info->setting);
1599 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Language : %s", g_config_info->language);
1600 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Type : %d", g_config_info->type);
1602 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1603 g_config_info->language, g_config_info->type)) {
1604 SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
1605 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1608 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine id is not valid");
1609 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1615 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1617 if (0 >= g_slist_length(g_config_client_list)) {
1618 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1619 return TTS_CONFIG_ERROR_INVALID_STATE;
1622 if (0 >= g_slist_length(g_engine_list)) {
1623 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
1624 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1627 GSList *iter = NULL;
1628 tts_engine_info_s *engine_info = NULL;
1630 /* Get a first item */
1631 iter = g_slist_nth(g_engine_list, 0);
1633 while (NULL != iter) {
1634 engine_info = iter->data;
1636 if (NULL == engine_info) {
1637 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] engine info is NULL");
1638 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1641 if (0 != strcmp(engine_id, engine_info->uuid)) {
1642 iter = g_slist_next(iter);
1646 GSList *iter_voice = NULL;
1647 tts_config_voice_s* voice = NULL;
1649 /* Get a first item */
1650 iter_voice = g_slist_nth(engine_info->voices, 0);
1652 while (NULL != iter_voice) {
1653 /*Get handle data from list*/
1654 voice = iter_voice->data;
1656 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " lang(%s) type(%d)", voice->language, voice->type);
1657 if (NULL != voice->language) {
1658 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1663 iter_voice = g_slist_next(iter_voice);
1671 int tts_config_mgr_get_voice(char** language, int* type)
1673 if (0 >= g_slist_length(g_config_client_list)) {
1674 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1675 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1678 if (0 >= g_slist_length(g_engine_list)) {
1679 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
1680 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1683 if (NULL == language || NULL == type)
1684 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1686 if (0 != strlen(g_config_info->language)) {
1687 *language = strdup(g_config_info->language);
1688 *type = g_config_info->type;
1690 SLOG(LOG_ERROR, TAG_TTSCONFIG, "language is NULL");
1691 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1697 int tts_config_mgr_set_voice(const char* language, int type)
1699 if (0 >= g_slist_length(g_config_client_list)) {
1700 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1701 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1704 if (NULL == language) {
1705 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1706 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1709 if (0 >= g_slist_length(g_engine_list)) {
1710 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine");
1711 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1714 /* Check language is valid */
1715 if (0 != tts_parser_set_voice(language, type)) {
1716 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
1717 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1719 memset(g_language, '\0', sizeof(g_language));
1720 g_config_info->language = g_language;
1721 strncpy(g_config_info->language, language, sizeof(g_language) - 1);
1723 g_config_info->type = type;
1728 int tts_config_mgr_get_auto_voice(bool* value)
1730 if (0 >= g_slist_length(g_config_client_list)) {
1731 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1732 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1736 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1738 *value = g_config_info->auto_voice;
1743 int tts_config_mgr_set_auto_voice(bool value)
1745 if (0 >= g_slist_length(g_config_client_list)) {
1746 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1747 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1750 if (g_config_info->auto_voice != value) {
1751 /* Check language is valid */
1752 if (0 != tts_parser_set_auto_voice(value)) {
1753 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save auto voice option");
1754 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1756 g_config_info->auto_voice = value;
1758 if (true == g_config_info->auto_voice) {
1759 __tts_config_set_auto_language();
1766 int tts_config_mgr_get_speech_rate(int* value)
1768 if (0 >= g_slist_length(g_config_client_list)) {
1769 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1770 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1773 if (NULL == value) {
1774 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1777 *value = g_config_info->speech_rate;
1782 int tts_config_mgr_set_speech_rate(int value)
1784 if (0 >= g_slist_length(g_config_client_list)) {
1785 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1786 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1789 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1790 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set speech rate : %d", value);
1791 if (0 != tts_parser_set_speech_rate(value)) {
1792 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1793 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1796 g_config_info->speech_rate = value;
1798 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Speech rate is invalid : %d", value);
1804 int tts_config_mgr_get_pitch(int* value)
1806 if (0 >= g_slist_length(g_config_client_list)) {
1807 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1808 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1811 if (NULL == value) {
1812 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1815 GSList *iter = NULL;
1816 tts_engine_info_s *engine_info = NULL;
1818 if (0 >= g_slist_length(g_engine_list)) {
1819 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1820 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1823 /* Get a first item */
1824 iter = g_slist_nth(g_engine_list, 0);
1826 while (NULL != iter) {
1827 engine_info = iter->data;
1829 if (NULL == engine_info) {
1830 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
1831 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1834 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1835 iter = g_slist_next(iter);
1839 if (false == engine_info->pitch_support) {
1840 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1846 *value = g_config_info->pitch;
1851 int tts_config_mgr_set_pitch(int value)
1853 if (0 >= g_slist_length(g_config_client_list)) {
1854 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1858 GSList *iter = NULL;
1859 tts_engine_info_s *engine_info = NULL;
1861 if (0 >= g_slist_length(g_engine_list)) {
1862 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1863 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1866 /* Get a first item */
1867 iter = g_slist_nth(g_engine_list, 0);
1869 while (NULL != iter) {
1870 engine_info = iter->data;
1872 if (NULL == engine_info) {
1873 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
1874 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1877 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1878 iter = g_slist_next(iter);
1882 if (false == engine_info->pitch_support) {
1883 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1889 if (0 != tts_parser_set_pitch(value)) {
1890 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1891 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1894 g_config_info->pitch = value;
1899 bool tts_config_check_default_engine_is_valid(const char* engine)
1901 if (0 >= g_slist_length(g_config_client_list)) {
1902 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1909 if (0 >= g_slist_length(g_engine_list))
1912 GSList *iter = NULL;
1913 tts_engine_info_s *engine_info = NULL;
1915 /* Get a first item */
1916 iter = g_slist_nth(g_engine_list, 0);
1918 while (NULL != iter) {
1919 engine_info = iter->data;
1921 if (NULL != engine_info) {
1922 if (0 == strcmp(engine, engine_info->uuid)) {
1926 iter = g_slist_next(iter);
1932 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1934 if (0 >= g_slist_length(g_config_client_list)) {
1935 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1939 if (NULL == language)
1942 if (0 == strlen(g_config_info->engine_id)) {
1943 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Default engine id is NULL");
1947 if (0 >= g_slist_length(g_engine_list))
1950 GSList *iter = NULL;
1951 tts_engine_info_s *engine_info = NULL;
1953 /* Get a first item */
1954 iter = g_slist_nth(g_engine_list, 0);
1956 while (NULL != iter) {
1957 engine_info = iter->data;
1959 if (NULL == engine_info) {
1960 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine info is NULL");
1961 iter = g_slist_next(iter);
1965 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1966 iter = g_slist_next(iter);
1970 GSList *iter_voice = NULL;
1971 tts_config_voice_s* voice = NULL;
1973 /* Get a first item */
1974 iter_voice = g_slist_nth(engine_info->voices, 0);
1976 while (NULL != iter_voice) {
1977 voice = iter_voice->data;
1979 if (0 == strcmp(language, voice->language) && voice->type == type)
1983 iter_voice = g_slist_next(iter_voice);
1993 int __tts_config_mgr_print_engine_info()
1995 GSList *iter = NULL;
1996 tts_engine_info_s *engine_info = NULL;
1998 if (0 >= g_slist_length(g_engine_list)) {
1999 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "-------------- engine list -----------------");
2000 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " No Engine in engine directory");
2001 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2005 /* Get a first item */
2006 iter = g_slist_nth(g_engine_list, 0);
2008 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------- engine list -----------------");
2011 while (NULL != iter) {
2012 engine_info = iter->data;
2014 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[%dth]", i);
2015 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " name : %s", engine_info->name);
2016 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " id : %s", engine_info->uuid);
2017 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", engine_info->setting);
2019 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Voices");
2020 GSList *iter_voice = NULL;
2021 tts_config_voice_s* voice = NULL;
2023 if (g_slist_length(engine_info->voices) > 0) {
2024 /* Get a first item */
2025 iter_voice = g_slist_nth(engine_info->voices, 0);
2028 while (NULL != iter_voice) {
2029 /*Get handle data from list*/
2030 voice = iter_voice->data;
2032 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2035 iter_voice = g_slist_next(iter_voice);
2039 SLOG(LOG_ERROR, TAG_TTSCONFIG, " Voice is NONE");
2041 iter = g_slist_next(iter);
2044 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2049 int tts_config_mgr_get_max_text_size(unsigned int* size)
2051 if (0 >= g_slist_length(g_config_client_list)) {
2052 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
2053 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2057 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2060 GSList *iter = NULL;
2061 tts_engine_info_s *engine_info = NULL;
2063 if (0 >= g_slist_length(g_engine_list)) {
2064 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
2065 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
2068 /* Get a first item */
2069 iter = g_slist_nth(g_engine_list, 0);
2071 while (NULL != iter) {
2072 engine_info = iter->data;
2074 if (NULL == engine_info) {
2075 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2076 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2079 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
2080 iter = g_slist_next(iter);
2087 if (NULL == engine_info) {
2088 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2089 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2092 *size = engine_info->text_size;
2093 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);