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 SLOG(LOG_DEBUG, tts_tag(), " ");
344 return ECORE_CALLBACK_DONE;
347 if (IN_CLOSE_WRITE == event.mask) {
348 /* check config changed state */
350 char* setting = NULL;
352 bool auto_voice = g_config_info->auto_voice;
354 int speech_rate = -1;
358 tts_config_client_s* temp_client = NULL;
360 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
361 return ECORE_CALLBACK_PASS_ON;
364 if (NULL != engine || NULL != setting) {
365 if (NULL != engine) {
366 memset(g_engine_id, '\0', sizeof(g_engine_id));
367 g_config_info->engine_id = g_engine_id;
368 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
370 if (NULL != setting) {
371 memset(g_setting, '\0', sizeof(g_setting));
372 g_config_info->setting = g_setting;
373 strncpy(g_config_info->setting, setting, sizeof(g_setting) - 1);
376 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
378 /* Call all callbacks of client*/
379 iter = g_slist_nth(g_config_client_list, 0);
381 while (NULL != iter) {
382 temp_client = iter->data;
384 if (NULL != temp_client) {
385 if (NULL != temp_client->engine_cb) {
386 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
387 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
388 g_config_info->language, g_config_info->type,
389 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
393 iter = g_slist_next(iter);
397 if (auto_voice != g_config_info->auto_voice) {
398 g_config_info->auto_voice = auto_voice;
401 if (NULL != lang || -1 != voice_type) {
402 char* before_lang = NULL;
405 before_lang = strdup(g_config_info->language);
406 before_type = g_config_info->type;
409 memset(g_language, '\0', sizeof(g_language));
410 g_config_info->language = g_language;
411 strncpy(g_config_info->language, lang, sizeof(g_language) - 1);
413 if (-1 != voice_type) {
414 g_config_info->type = voice_type;
417 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
419 /* Call all callbacks of client*/
420 iter = g_slist_nth(g_config_client_list, 0);
422 while (NULL != iter) {
423 temp_client = iter->data;
425 if (NULL != temp_client) {
426 if (NULL != temp_client->voice_cb) {
427 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
428 temp_client->voice_cb(before_lang, before_type,
429 g_config_info->language, g_config_info->type,
430 g_config_info->auto_voice, temp_client->user_data);
434 iter = g_slist_next(iter);
437 if (NULL != before_lang) {
443 if (-1 != speech_rate) {
444 g_config_info->speech_rate = speech_rate;
446 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
448 /* Call all callbacks of client*/
449 iter = g_slist_nth(g_config_client_list, 0);
451 while (NULL != iter) {
452 temp_client = iter->data;
454 if (NULL != temp_client) {
455 if (NULL != temp_client->speech_cb) {
456 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
457 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
461 iter = g_slist_next(iter);
466 g_config_info->pitch = pitch;
468 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
470 /* Call all callbacks of client*/
471 iter = g_slist_nth(g_config_client_list, 0);
473 while (NULL != iter) {
474 temp_client = iter->data;
476 if (NULL != temp_client) {
477 if (NULL != temp_client->pitch_cb) {
478 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
479 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
483 iter = g_slist_next(iter);
487 if (NULL != engine) {
491 if (NULL != setting) {
500 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
503 SLOG(LOG_DEBUG, tts_tag(), "=====");
504 SLOG(LOG_DEBUG, tts_tag(), " ");
506 return ECORE_CALLBACK_PASS_ON;
509 int __tts_config_mgr_register_config_event()
511 /* get file notification handler */
517 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
520 g_config_fd_noti = fd;
522 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE);
523 g_config_wd_noti = wd;
525 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
526 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
527 if (NULL == g_config_fd_handler_noti) {
528 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
532 /* Set non-blocking mode of file */
534 value = fcntl(fd, F_GETFL, 0);
537 if (0 > fcntl(fd, F_SETFL, value)) {
538 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
544 int __tts_config_mgr_unregister_config_event()
546 /* delete inotify variable */
547 ecore_main_fd_handler_del(g_config_fd_handler_noti);
548 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
549 close(g_config_fd_noti);
554 int __tts_config_set_auto_language()
557 value = vconf_get_str(TTS_LANGSET_KEY);
559 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
563 char temp_lang[6] = {'\0', };
564 strncpy(temp_lang, value, 5);
568 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
569 /* tts default voice change */
570 if (NULL == g_config_info->language) {
571 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
575 char* before_lang = NULL;
578 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
579 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
583 before_lang = strdup(g_config_info->language);
584 before_type = g_config_info->type;
586 memset(g_language, '\0', sizeof(g_language));
587 g_config_info->language = g_language;
588 strncpy(g_config_info->language, temp_lang, sizeof(g_language) - 1);
590 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
591 g_config_info->language, g_config_info->type);
594 tts_config_client_s* temp_client = NULL;
596 /* Call all callbacks of client*/
597 iter = g_slist_nth(g_config_client_list, 0);
599 while (NULL != iter) {
600 temp_client = iter->data;
602 if (NULL != temp_client) {
603 if (NULL != temp_client->voice_cb) {
604 temp_client->voice_cb(before_lang, before_type,
605 g_config_info->language, g_config_info->type,
606 g_config_info->auto_voice, temp_client->user_data);
610 iter = g_slist_next(iter);
613 if (NULL != before_lang) {
618 /* Display language is not valid */
619 char* tmp_language = NULL;
621 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
622 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
626 if (NULL == tmp_language) {
627 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
631 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
632 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
636 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
637 tmp_language, tmp_type);
640 tts_config_client_s* temp_client = NULL;
642 /* Call all callbacks of client*/
643 iter = g_slist_nth(g_config_client_list, 0);
645 while (NULL != iter) {
646 temp_client = iter->data;
648 if (NULL != temp_client) {
649 if (NULL != temp_client->voice_cb) {
650 temp_client->voice_cb(g_config_info->language, g_config_info->type,
651 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
655 iter = g_slist_next(iter);
659 memset(g_language, '\0', sizeof(g_language));
660 g_config_info->language = g_language;
661 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
663 g_config_info->type = tmp_type;
672 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
674 if (true == g_config_info->auto_voice) {
675 __tts_config_set_auto_language();
681 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
685 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
687 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
692 tts_config_client_s* temp_client = NULL;
694 /* Call all callbacks of client*/
695 iter = g_slist_nth(g_config_client_list, 0);
697 while (NULL != iter) {
698 temp_client = iter->data;
700 if (NULL != temp_client) {
701 if (NULL != temp_client->screen_cb) {
702 temp_client->screen_cb((bool)screen_reader);
706 iter = g_slist_next(iter);
710 int __tts_config_release_client(int uid)
713 tts_config_client_s* temp_client = NULL;
715 if (0 < g_slist_length(g_config_client_list)) {
717 iter = g_slist_nth(g_config_client_list, 0);
719 while (NULL != iter) {
720 temp_client = iter->data;
722 if (NULL != temp_client) {
723 if (uid == temp_client->uid) {
724 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
731 iter = g_slist_next(iter);
735 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
737 return g_slist_length(g_config_client_list);
740 void __tts_config_release_engine()
743 tts_engine_info_s *engine_info = NULL;
745 if (0 < g_slist_length(g_engine_list)) {
747 /* Get a first item */
748 iter = g_slist_nth(g_engine_list, 0);
750 while (NULL != iter) {
751 engine_info = iter->data;
753 if (NULL != engine_info) {
754 g_engine_list = g_slist_remove(g_engine_list, engine_info);
756 tts_parser_free_engine_info(engine_info);
759 iter = g_slist_nth(g_engine_list, 0);
766 int __tts_config_mgr_get_engine_info()
771 struct dirent *dirp = NULL;
773 char filepath[512] = {'\0',};
775 tts_engine_info_s* info = NULL;
777 __tts_config_release_engine();
778 g_engine_list = NULL;
779 __tts_config_mgr_unregister_engine_config_updated_event();
781 /* Copy default info directory to download directory */
782 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
784 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
787 ret = readdir_r(dp, &entry, &dirp);
789 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
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, tts_tag(), "[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, tts_tag(), "[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, tts_tag(), "[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, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
829 ret = readdir_r(dp, &entry, &dirp);
831 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
836 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
839 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
840 if (filesize >= 512) {
841 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
846 memset(filepath, '\0', 512);
847 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
849 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
851 if (0 == tts_parser_get_engine_info(filepath, &info)) {
852 g_engine_list = g_slist_append(g_engine_list, info);
853 if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
854 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
858 } while (NULL != dirp);
863 if (0 >= g_slist_length(g_engine_list)) {
864 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
871 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
873 SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
875 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
876 int dir_fd = ino->dir_fd;
879 struct inotify_event event;
880 memset(&event, '\0', sizeof(struct inotify_event));
882 length = read(dir_fd, &event, sizeof(struct inotify_event));
884 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
885 SLOG(LOG_DEBUG, tts_tag(), "=====");
886 SLOG(LOG_DEBUG, tts_tag(), " ");
887 return ECORE_CALLBACK_DONE;
890 if (IN_CLOSE_WRITE == event.mask) {
891 int ret = __tts_config_mgr_get_engine_info();
893 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
895 __tts_config_mgr_print_engine_info();
896 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
897 if (false == support) {
898 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
899 char* temp_lang = NULL;
901 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
903 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
906 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
908 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
910 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
912 if (NULL != temp_lang) {
919 tts_config_client_s* temp_client = NULL;
920 /* Call all callbacks of client*/
921 iter = g_slist_nth(g_config_client_list, 0);
923 while (NULL != iter) {
924 temp_client = iter->data;
926 if (NULL != temp_client) {
927 if (NULL != temp_client->engine_cb) {
928 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
929 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
930 g_config_info->language, g_config_info->type,
931 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
935 iter = g_slist_next(iter);
938 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
941 SLOG(LOG_DEBUG, tts_tag(), "=====");
942 SLOG(LOG_DEBUG, tts_tag(), " ");
944 return ECORE_CALLBACK_PASS_ON;
947 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
950 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Path is NULL");
954 /* For engine directory monitoring */
955 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
957 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
961 ino->dir_fd = inotify_init();
962 if (ino->dir_fd < 0) {
963 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
970 ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
971 SLOG(LOG_DEBUG, tts_tag(), "Add inotify watch(%s)", path);
972 if (ino->dir_wd < 0) {
973 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
979 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);
980 if (NULL == ino->dir_fd_handler) {
981 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
987 /* Set non-blocking mode of file */
989 value = fcntl(ino->dir_fd, F_GETFL, 0);
992 if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
993 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
996 g_ino_list = g_list_append(g_ino_list, ino);
1001 static int __tts_config_mgr_unregister_engine_config_updated_event()
1003 /* delete all inotify variable */
1004 if (0 < g_list_length(g_ino_list)) {
1006 iter = g_list_first(g_ino_list);
1008 while (NULL != iter) {
1009 tts_engine_inotify_s *tmp = iter->data;
1012 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1013 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1020 g_ino_list = g_list_remove_link(g_ino_list, iter);
1022 iter = g_list_first(g_ino_list);
1029 int tts_config_mgr_initialize(int uid)
1031 GSList *iter = NULL;
1033 tts_config_client_s* temp_client = NULL;
1036 if (0 < g_slist_length(g_config_client_list)) {
1038 iter = g_slist_nth(g_config_client_list, 0);
1040 while (NULL != iter) {
1041 get_uid = iter->data;
1043 if (uid == *get_uid) {
1044 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
1048 iter = g_slist_next(iter);
1051 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1052 if (NULL == temp_client) {
1053 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1054 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1056 temp_client->uid = uid;
1058 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1060 SECURE_SLOG(LOG_WARN, tts_tag(), "[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, tts_tag(), "[ERROR] Fail to allocate memory");
1066 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1068 temp_client->uid = uid;
1070 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1073 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1074 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1075 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1076 __tts_config_release_client(uid);
1077 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1079 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
1083 if (0 != access(TTS_HOME, F_OK)) {
1084 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1085 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_HOME);
1086 __tts_config_release_client(uid);
1087 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1089 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_HOME);
1093 if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1094 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1095 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1096 __tts_config_release_client(uid);
1097 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1099 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1103 if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1104 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1105 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1106 __tts_config_release_client(uid);
1107 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1109 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1113 if (0 != __tts_config_mgr_get_engine_info()) {
1114 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1115 __tts_config_release_client(uid);
1116 __tts_config_release_engine();
1117 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1120 __tts_config_mgr_print_engine_info();
1122 if (0 != tts_parser_load_config(&g_config_info)) {
1123 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1124 __tts_config_release_client(uid);
1125 __tts_config_release_engine();
1126 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1129 /* Check whether engine id is valid */
1130 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1131 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1132 __tts_config_release_client(uid);
1133 __tts_config_release_engine();
1134 tts_parser_unload_config(g_config_info);
1135 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1138 if (true == g_config_info->auto_voice) {
1139 /* Check language with display language */
1140 __tts_config_set_auto_language();
1142 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1143 /* Default language is not valid */
1144 char* tmp_language = NULL;
1146 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1147 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1148 __tts_config_release_client(uid);
1149 __tts_config_release_engine();
1150 tts_parser_unload_config(g_config_info);
1151 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1154 if (NULL != tmp_language) {
1155 memset(g_language, '\0', sizeof(g_language));
1156 g_config_info->language = g_language;
1157 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
1159 g_config_info->type = tmp_type;
1162 tmp_language = NULL;
1164 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1165 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1166 __tts_config_release_client(uid);
1167 __tts_config_release_engine();
1168 tts_parser_unload_config(g_config_info);
1169 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1175 /* print daemon config */
1176 SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1177 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1178 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1179 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1180 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1181 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1182 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1183 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1184 SLOG(LOG_DEBUG, tts_tag(), "=================");
1186 if (0 != __tts_config_mgr_register_config_event()) {
1187 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1188 __tts_config_release_client(uid);
1189 __tts_config_release_engine();
1190 tts_parser_unload_config(g_config_info);
1191 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1194 /* Register to detect display language change */
1195 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1196 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1198 /* For engine directory monitoring */
1199 //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1200 // SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1201 // __tts_config_release_client(uid);
1202 // __tts_config_release_engine();
1203 // tts_parser_unload_config(g_config_info);
1204 // __tts_config_mgr_unregister_config_event();
1205 // return TTS_CONFIG_ERROR_OPERATION_FAILED;
1211 int tts_config_mgr_finalize(int uid)
1213 if (0 < __tts_config_release_client(uid)) {
1217 tts_config_mgr_unset_callback(uid);
1219 __tts_config_release_engine();
1221 tts_parser_unload_config(g_config_info);
1223 __tts_config_mgr_unregister_engine_config_updated_event();
1225 __tts_config_mgr_unregister_config_event();
1227 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1228 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1233 int tts_config_mgr_set_callback(int uid,
1234 tts_config_engine_changed_cb engine_cb,
1235 tts_config_voice_changed_cb voice_cb,
1236 tts_config_speech_rate_changed_cb speech_cb,
1237 tts_config_pitch_changed_cb pitch_cb,
1240 GSList *iter = NULL;
1241 tts_config_client_s* temp_client = NULL;
1243 /* Call all callbacks of client*/
1244 iter = g_slist_nth(g_config_client_list, 0);
1246 while (NULL != iter) {
1247 temp_client = iter->data;
1249 if (NULL != temp_client) {
1250 if (uid == temp_client->uid) {
1251 temp_client->engine_cb = engine_cb;
1252 temp_client->voice_cb = voice_cb;
1253 temp_client->speech_cb = speech_cb;
1254 temp_client->pitch_cb = pitch_cb;
1255 temp_client->user_data = user_data;
1259 iter = g_slist_next(iter);
1264 int tts_config_mgr_unset_callback(int uid)
1266 GSList *iter = NULL;
1267 tts_config_client_s* temp_client = NULL;
1269 /* Call all callbacks of client*/
1270 iter = g_slist_nth(g_config_client_list, 0);
1272 while (NULL != iter) {
1273 temp_client = iter->data;
1275 if (NULL != temp_client) {
1276 if (uid == temp_client->uid) {
1277 temp_client->engine_cb = NULL;
1278 temp_client->voice_cb = NULL;
1279 temp_client->speech_cb = NULL;
1280 temp_client->pitch_cb = NULL;
1281 temp_client->user_data = NULL;
1285 iter = g_slist_next(iter);
1291 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1293 if (NULL == callback) {
1294 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1295 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1298 GSList *iter = NULL;
1299 tts_config_client_s* temp_client = NULL;
1301 /* Call all callbacks of client*/
1302 iter = g_slist_nth(g_config_client_list, 0);
1304 while (NULL != iter) {
1305 temp_client = iter->data;
1307 if (NULL != temp_client) {
1308 if (uid == temp_client->uid) {
1309 temp_client->screen_cb = callback;
1313 iter = g_slist_next(iter);
1318 int tts_config_unset_screen_reader_callback(int uid)
1320 GSList *iter = NULL;
1321 tts_config_client_s* temp_client = NULL;
1323 /* Call all callbacks of client*/
1324 iter = g_slist_nth(g_config_client_list, 0);
1326 while (NULL != iter) {
1327 temp_client = iter->data;
1329 if (NULL != temp_client) {
1330 if (uid == temp_client->uid) {
1331 temp_client->screen_cb = NULL;
1335 iter = g_slist_next(iter);
1341 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1343 if (0 >= g_slist_length(g_config_client_list)) {
1344 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1345 return TTS_CONFIG_ERROR_INVALID_STATE;
1348 GSList *iter = NULL;
1349 tts_engine_info_s *engine_info = NULL;
1351 if (0 >= g_slist_length(g_engine_list)) {
1352 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1353 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1356 /* Get a first item */
1357 iter = g_slist_nth(g_engine_list, 0);
1359 while (NULL != iter) {
1360 engine_info = iter->data;
1362 if (NULL != engine_info) {
1363 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1368 iter = g_slist_next(iter);
1374 int tts_config_mgr_get_engine(char** engine)
1376 if (0 >= g_slist_length(g_config_client_list)) {
1377 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1378 return TTS_CONFIG_ERROR_INVALID_STATE;
1381 if (NULL == engine) {
1382 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1383 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1386 if (NULL != g_config_info->engine_id) {
1387 /* Check engine id is valid */
1388 GSList *iter = NULL;
1389 tts_engine_info_s *engine_info = NULL;
1391 if (0 >= g_slist_length(g_engine_list)) {
1392 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1393 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1396 /* Get a first item */
1397 iter = g_slist_nth(g_engine_list, 0);
1399 while (NULL != iter) {
1400 engine_info = iter->data;
1402 if (NULL != engine_info) {
1403 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1404 *engine = strdup(g_config_info->engine_id);
1408 iter = g_slist_next(iter);
1411 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1413 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1416 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1419 int __tts_set_buxtonkey(const char* engine)
1422 struct buxton_client * bux_cli;
1423 struct buxton_layer * bux_layer;
1424 struct buxton_value * bux_val;
1426 int ret = buxton_open(&bux_cli, NULL, NULL);
1428 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1429 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1431 bux_layer = buxton_create_layer("system");
1432 if (NULL == bux_layer) {
1433 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
1434 buxton_close(bux_cli);
1435 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1437 bux_val = buxton_value_create_string(engine);
1438 if (NULL == bux_val) {
1439 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1440 buxton_free_layer(bux_layer);
1441 buxton_close(bux_cli);
1442 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1444 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1447 ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1449 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1450 buxton_value_free(bux_val);
1451 buxton_free_layer(bux_layer);
1452 buxton_close(bux_cli);
1458 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1460 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1463 buxton_value_free(bux_val);
1464 buxton_free_layer(bux_layer);
1465 buxton_close(bux_cli);
1471 return TTS_CONFIG_ERROR_NONE;
1474 int tts_config_mgr_set_engine(const char* engine)
1476 if (0 >= g_slist_length(g_config_client_list)) {
1477 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1478 return TTS_CONFIG_ERROR_INVALID_STATE;
1482 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1484 /* Check current engine id with new engine id */
1485 if (0 == strcmp(g_config_info->engine_id, engine))
1488 if (0 >= g_slist_length(g_engine_list)) {
1489 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1490 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1493 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1495 int ret = __tts_set_buxtonkey(engine);
1497 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] set_buxtonkey Fail!!");
1501 GSList *iter = NULL;
1502 tts_engine_info_s *engine_info = NULL;
1503 bool is_valid_engine = false;
1505 /* Get a first item */
1506 iter = g_slist_nth(g_engine_list, 0);
1508 while (NULL != iter) {
1509 engine_info = iter->data;
1511 if (NULL == engine_info) {
1512 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1513 iter = g_slist_next(iter);
1517 /* Check engine id is valid */
1518 if (0 != strcmp(engine, engine_info->uuid)) {
1519 iter = g_slist_next(iter);
1523 memset(g_engine_id, '\0', sizeof(g_engine_id));
1524 g_config_info->engine_id = g_engine_id;
1525 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
1527 if (NULL != engine_info->setting) {
1528 memset(g_setting, '\0', sizeof(g_setting));
1529 g_config_info->setting = g_setting;
1530 strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
1533 /* Engine is valid*/
1534 GSList *iter_voice = NULL;
1535 tts_config_voice_s* voice = NULL;
1536 bool is_valid_voice = false;
1538 /* Get a first item */
1539 iter_voice = g_slist_nth(engine_info->voices, 0);
1541 while (NULL != iter_voice) {
1542 /*Get handle data from list*/
1543 voice = iter_voice->data;
1545 if (NULL != voice) {
1546 if (NULL == voice->language)
1548 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1550 if (0 == strcmp(voice->language, g_config_info->language)) {
1551 if (voice->type == g_config_info->type) {
1552 /* language is valid */
1553 is_valid_voice = true;
1554 g_config_info->type = voice->type;
1561 iter_voice = g_slist_next(iter_voice);
1564 if (false == is_valid_voice) {
1565 memset(g_language, '\0', sizeof(g_language));
1566 g_config_info->language = g_language;
1568 iter_voice = g_slist_nth(engine_info->voices, 0);
1569 if (NULL != iter_voice) {
1570 voice = iter_voice->data;
1571 if (NULL != voice) {
1572 if (NULL != voice->language)
1573 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
1575 g_config_info->type = voice->type;
1580 is_valid_engine = true;
1584 if (true == is_valid_engine) {
1585 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1586 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1587 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1588 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1589 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1591 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1592 g_config_info->language, g_config_info->type)) {
1593 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1594 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1597 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1598 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1604 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1606 if (0 >= g_slist_length(g_config_client_list)) {
1607 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1608 return TTS_CONFIG_ERROR_INVALID_STATE;
1611 if (0 >= g_slist_length(g_engine_list)) {
1612 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1613 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1616 GSList *iter = NULL;
1617 tts_engine_info_s *engine_info = NULL;
1619 /* Get a first item */
1620 iter = g_slist_nth(g_engine_list, 0);
1622 while (NULL != iter) {
1623 engine_info = iter->data;
1625 if (NULL == engine_info) {
1626 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1627 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1630 if (0 != strcmp(engine_id, engine_info->uuid)) {
1631 iter = g_slist_next(iter);
1635 GSList *iter_voice = NULL;
1636 tts_config_voice_s* voice = NULL;
1638 /* Get a first item */
1639 iter_voice = g_slist_nth(engine_info->voices, 0);
1641 while (NULL != iter_voice) {
1642 /*Get handle data from list*/
1643 voice = iter_voice->data;
1645 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1646 if (NULL != voice->language) {
1647 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1652 iter_voice = g_slist_next(iter_voice);
1660 int tts_config_mgr_get_voice(char** language, int* type)
1662 if (0 >= g_slist_length(g_config_client_list)) {
1663 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1664 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1667 if (0 >= g_slist_length(g_engine_list)) {
1668 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1669 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1672 if (NULL == language || NULL == type)
1673 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1675 if (0 != strlen(g_config_info->language)) {
1676 *language = strdup(g_config_info->language);
1677 *type = g_config_info->type;
1679 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1680 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1686 int tts_config_mgr_set_voice(const char* language, int type)
1688 if (0 >= g_slist_length(g_config_client_list)) {
1689 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1690 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1693 if (NULL == language) {
1694 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1695 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1698 if (0 >= g_slist_length(g_engine_list)) {
1699 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1700 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1703 /* Check language is valid */
1704 if (0 != tts_parser_set_voice(language, type)) {
1705 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1706 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1708 memset(g_language, '\0', sizeof(g_language));
1709 g_config_info->language = g_language;
1710 strncpy(g_config_info->language, language, sizeof(g_language) - 1);
1712 g_config_info->type = type;
1717 int tts_config_mgr_get_auto_voice(bool* value)
1719 if (0 >= g_slist_length(g_config_client_list)) {
1720 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1721 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1725 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1727 *value = g_config_info->auto_voice;
1732 int tts_config_mgr_set_auto_voice(bool value)
1734 if (0 >= g_slist_length(g_config_client_list)) {
1735 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1736 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1739 if (g_config_info->auto_voice != value) {
1740 /* Check language is valid */
1741 if (0 != tts_parser_set_auto_voice(value)) {
1742 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1743 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1745 g_config_info->auto_voice = value;
1747 if (true == g_config_info->auto_voice) {
1748 __tts_config_set_auto_language();
1755 int tts_config_mgr_get_speech_rate(int* value)
1757 if (0 >= g_slist_length(g_config_client_list)) {
1758 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1759 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1762 if (NULL == value) {
1763 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1766 *value = g_config_info->speech_rate;
1771 int tts_config_mgr_set_speech_rate(int value)
1773 if (0 >= g_slist_length(g_config_client_list)) {
1774 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1775 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1778 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1779 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1780 if (0 != tts_parser_set_speech_rate(value)) {
1781 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1782 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1785 g_config_info->speech_rate = value;
1787 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1793 int tts_config_mgr_get_pitch(int* value)
1795 if (0 >= g_slist_length(g_config_client_list)) {
1796 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1797 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1800 if (NULL == value) {
1801 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1804 GSList *iter = NULL;
1805 tts_engine_info_s *engine_info = NULL;
1807 if (0 >= g_slist_length(g_engine_list)) {
1808 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1809 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1812 /* Get a first item */
1813 iter = g_slist_nth(g_engine_list, 0);
1815 while (NULL != iter) {
1816 engine_info = iter->data;
1818 if (NULL == engine_info) {
1819 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1820 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1823 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1824 iter = g_slist_next(iter);
1828 if (false == engine_info->pitch_support) {
1829 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1835 *value = g_config_info->pitch;
1840 int tts_config_mgr_set_pitch(int value)
1842 if (0 >= g_slist_length(g_config_client_list)) {
1843 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1847 GSList *iter = NULL;
1848 tts_engine_info_s *engine_info = NULL;
1850 if (0 >= g_slist_length(g_engine_list)) {
1851 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1852 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1855 /* Get a first item */
1856 iter = g_slist_nth(g_engine_list, 0);
1858 while (NULL != iter) {
1859 engine_info = iter->data;
1861 if (NULL == engine_info) {
1862 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1863 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1866 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1867 iter = g_slist_next(iter);
1871 if (false == engine_info->pitch_support) {
1872 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1878 if (0 != tts_parser_set_pitch(value)) {
1879 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1880 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1883 g_config_info->pitch = value;
1888 bool tts_config_check_default_engine_is_valid(const char* engine)
1890 if (0 >= g_slist_length(g_config_client_list)) {
1891 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1898 if (0 >= g_slist_length(g_engine_list))
1901 GSList *iter = NULL;
1902 tts_engine_info_s *engine_info = NULL;
1904 /* Get a first item */
1905 iter = g_slist_nth(g_engine_list, 0);
1907 while (NULL != iter) {
1908 engine_info = iter->data;
1910 if (NULL != engine_info) {
1911 if (0 == strcmp(engine, engine_info->uuid)) {
1915 iter = g_slist_next(iter);
1921 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1923 if (0 >= g_slist_length(g_config_client_list)) {
1924 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1928 if (NULL == language)
1931 if (0 == strlen(g_config_info->engine_id)) {
1932 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1936 if (0 >= g_slist_length(g_engine_list))
1939 GSList *iter = NULL;
1940 tts_engine_info_s *engine_info = NULL;
1942 /* Get a first item */
1943 iter = g_slist_nth(g_engine_list, 0);
1945 while (NULL != iter) {
1946 engine_info = iter->data;
1948 if (NULL == engine_info) {
1949 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1950 iter = g_slist_next(iter);
1954 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1955 iter = g_slist_next(iter);
1959 GSList *iter_voice = NULL;
1960 tts_config_voice_s* voice = NULL;
1962 /* Get a first item */
1963 iter_voice = g_slist_nth(engine_info->voices, 0);
1965 while (NULL != iter_voice) {
1966 voice = iter_voice->data;
1968 if (0 == strcmp(language, voice->language) && voice->type == type)
1972 iter_voice = g_slist_next(iter_voice);
1982 int __tts_config_mgr_print_engine_info()
1984 GSList *iter = NULL;
1985 tts_engine_info_s *engine_info = NULL;
1987 if (0 >= g_slist_length(g_engine_list)) {
1988 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1989 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1990 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1994 /* Get a first item */
1995 iter = g_slist_nth(g_engine_list, 0);
1997 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
2000 while (NULL != iter) {
2001 engine_info = iter->data;
2003 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
2004 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
2005 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
2006 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
2008 SLOG(LOG_DEBUG, tts_tag(), " Voices");
2009 GSList *iter_voice = NULL;
2010 tts_config_voice_s* voice = NULL;
2012 if (g_slist_length(engine_info->voices) > 0) {
2013 /* Get a first item */
2014 iter_voice = g_slist_nth(engine_info->voices, 0);
2017 while (NULL != iter_voice) {
2018 /*Get handle data from list*/
2019 voice = iter_voice->data;
2021 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2024 iter_voice = g_slist_next(iter_voice);
2028 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
2030 iter = g_slist_next(iter);
2033 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");