2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
21 #include <sys/inotify.h>
24 #include "tts_config_mgr.h"
25 #include "tts_config_parser.h"
30 tts_config_engine_changed_cb engine_cb;
31 tts_config_voice_changed_cb voice_cb;
32 tts_config_speech_rate_changed_cb speech_cb;
33 tts_config_screen_reader_changed_cb screen_cb;
34 tts_config_pitch_changed_cb pitch_cb;
36 } tts_config_client_s;
38 extern char* tts_tag();
40 static GSList* g_engine_list = NULL;
42 static GSList* g_config_client_list = NULL;
44 static tts_config_s* g_config_info;
46 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
47 static int g_config_fd_noti;
48 static int g_config_wd_noti;
50 /* For engine directory monitoring */
52 Ecore_Fd_Handler* dir_fd_handler;
55 } tts_engine_inotify_s;
57 static GList* g_ino_list = NULL;
59 int __tts_config_mgr_print_engine_info();
60 static int __tts_config_mgr_register_engine_config_updated_event(const char* path);
61 static int __tts_config_mgr_unregister_engine_config_updated_event();
63 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
65 if (NULL == engine_id) {
66 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
71 tts_engine_info_s *engine_info = NULL;
73 if (0 >= g_slist_length(g_engine_list)) {
74 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
78 /* Get a first item */
79 iter = g_slist_nth(g_engine_list, 0);
81 while (NULL != iter) {
82 engine_info = iter->data;
84 if (NULL == engine_info) {
85 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
89 if (0 == strcmp(engine_id, engine_info->uuid)) {
90 SLOG(LOG_DEBUG, tts_tag(), "Default engine is valid : %s", engine_id);
94 iter = g_slist_next(iter);
97 /* Change default engine */
98 iter = g_slist_nth(g_engine_list, 0);
99 engine_info = iter->data;
101 if (NULL == g_config_info) {
102 return TTS_CONFIG_ERROR_OPERATION_FAILED;
105 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
106 if (NULL != g_config_info->setting) free(g_config_info->setting);
108 g_config_info->engine_id = strdup(engine_info->uuid);
109 g_config_info->setting = strdup(engine_info->setting);
111 SLOG(LOG_DEBUG, tts_tag(), "Default engine is changed : %s", g_config_info->engine_id);
113 /* Change is default voice */
114 GSList *iter_voice = NULL;
115 tts_config_voice_s* voice = NULL;
116 bool is_valid_voice = false;
118 /* Get a first item */
119 iter_voice = g_slist_nth(engine_info->voices, 0);
121 while (NULL != iter_voice) {
122 /*Get handle data from list*/
123 voice = iter_voice->data;
126 if (NULL != voice->language && NULL != g_config_info->language) {
127 if (0 == strcmp(voice->language, g_config_info->language)) {
128 if (voice->type == g_config_info->type) {
129 /* language is valid */
130 is_valid_voice = true;
132 free(g_config_info->language);
133 g_config_info->language = strdup(voice->language);
134 g_config_info->type = voice->type;
136 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
143 iter_voice = g_slist_next(iter_voice);
146 if (false == is_valid_voice) {
147 /* Select first voice as default */
148 if (NULL != g_config_info->language) {
149 free(g_config_info->language);
151 iter_voice = g_slist_nth(engine_info->voices, 0);
152 voice = iter_voice->data;
154 g_config_info->language = strdup(voice->language);
155 g_config_info->type = voice->type;
156 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
160 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
161 g_config_info->language, g_config_info->type)) {
162 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
163 return TTS_CONFIG_ERROR_OPERATION_FAILED;
169 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
171 if (NULL == engine_id || NULL == language) {
172 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
177 tts_engine_info_s *engine_info = NULL;
179 if (0 >= g_slist_length(g_engine_list)) {
180 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
184 /* Get a first item */
185 iter = g_slist_nth(g_engine_list, 0);
187 while (NULL != iter) {
188 engine_info = iter->data;
190 if (NULL == engine_info) {
191 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
195 if (0 != strcmp(engine_id, engine_info->uuid)) {
196 iter = g_slist_next(iter);
200 GSList *iter_voice = NULL;
201 tts_config_voice_s* voice = NULL;
203 if (g_slist_length(engine_info->voices) <= 0) {
204 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
205 iter = g_slist_next(iter);
209 /* Get a first item */
210 iter_voice = g_slist_nth(engine_info->voices, 0);
213 while (NULL != iter_voice) {
214 /*Get handle data from list*/
215 voice = iter_voice->data;
218 if (0 == strcmp(language, voice->language)) {
219 if (type == voice->type) {
226 iter_voice = g_slist_next(iter_voice);
236 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
238 if (NULL == engine_id || NULL == language) {
239 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
244 tts_engine_info_s *engine_info = NULL;
246 if (0 >= g_slist_length(g_engine_list)) {
247 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
251 /* Get a first item */
252 iter = g_slist_nth(g_engine_list, 0);
254 while (NULL != iter) {
255 engine_info = iter->data;
257 if (NULL == engine_info) {
258 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
262 if (0 != strcmp(engine_id, engine_info->uuid)) {
263 iter = g_slist_next(iter);
267 GSList *iter_voice = NULL;
268 tts_config_voice_s* voice = NULL;
270 if (g_slist_length(engine_info->voices) <= 0) {
271 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
275 /* Get a first item */
276 iter_voice = g_slist_nth(engine_info->voices, 0);
278 while (NULL != iter_voice) {
279 voice = iter_voice->data;
281 /* Default language */
282 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
283 *language = strdup(voice->language);
286 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
290 iter_voice = g_slist_next(iter_voice);
293 /* Not support base language */
295 *language = strdup(voice->language);
298 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
307 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
309 SLOG(LOG_DEBUG, tts_tag(), "===== Config changed callback event");
312 struct inotify_event event;
313 memset(&event, '\0', sizeof(struct inotify_event));
315 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
317 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
318 SLOG(LOG_DEBUG, tts_tag(), "=====");
319 SLOG(LOG_DEBUG, tts_tag(), " ");
320 return ECORE_CALLBACK_DONE;
323 if (IN_CLOSE_WRITE == event.mask) {
324 /* check config changed state */
326 char* setting = NULL;
328 bool auto_voice = g_config_info->auto_voice;
330 int speech_rate = -1;
334 tts_config_client_s* temp_client = NULL;
336 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
337 return ECORE_CALLBACK_PASS_ON;
340 if (NULL != engine || NULL != setting) {
341 if (NULL != engine) {
342 if (NULL != g_config_info->engine_id)
343 free(g_config_info->engine_id);
345 g_config_info->engine_id = strdup(engine);
347 if (NULL != setting) {
348 if (NULL != g_config_info->setting)
349 free(g_config_info->setting);
351 g_config_info->setting = strdup(setting);
354 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
356 /* Call all callbacks of client*/
357 iter = g_slist_nth(g_config_client_list, 0);
359 while (NULL != iter) {
360 temp_client = iter->data;
362 if (NULL != temp_client) {
363 if (NULL != temp_client->engine_cb) {
364 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
365 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
366 g_config_info->language, g_config_info->type,
367 g_config_info->auto_voice, temp_client->user_data);
371 iter = g_slist_next(iter);
375 if (auto_voice != g_config_info->auto_voice) {
376 g_config_info->auto_voice = auto_voice;
379 if (NULL != lang || -1 != voice_type) {
380 char* before_lang = NULL;
383 before_lang = strdup(g_config_info->language);
384 before_type = g_config_info->type;
387 if (NULL != g_config_info->language)
388 free(g_config_info->language);
390 g_config_info->language = strdup(lang);
392 if (-1 != voice_type) {
393 g_config_info->type = voice_type;
396 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
398 /* Call all callbacks of client*/
399 iter = g_slist_nth(g_config_client_list, 0);
401 while (NULL != iter) {
402 temp_client = iter->data;
404 if (NULL != temp_client) {
405 if (NULL != temp_client->voice_cb) {
406 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
407 temp_client->voice_cb(before_lang, before_type,
408 g_config_info->language, g_config_info->type,
409 g_config_info->auto_voice, temp_client->user_data);
413 iter = g_slist_next(iter);
416 if (NULL != before_lang) {
421 if (-1 != speech_rate) {
422 g_config_info->speech_rate = speech_rate;
424 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
426 /* Call all callbacks of client*/
427 iter = g_slist_nth(g_config_client_list, 0);
429 while (NULL != iter) {
430 temp_client = iter->data;
432 if (NULL != temp_client) {
433 if (NULL != temp_client->speech_cb) {
434 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
435 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
439 iter = g_slist_next(iter);
444 g_config_info->pitch = pitch;
446 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
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->pitch_cb) {
456 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
457 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
461 iter = g_slist_next(iter);
465 if (NULL != engine) free(engine);
466 if (NULL != setting) free(setting);
467 if (NULL != lang) free(lang);
469 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
472 SLOG(LOG_DEBUG, tts_tag(), "=====");
473 SLOG(LOG_DEBUG, tts_tag(), " ");
475 return ECORE_CALLBACK_PASS_ON;
478 int __tts_config_mgr_register_config_event()
480 /* get file notification handler */
486 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
489 g_config_fd_noti = fd;
491 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE);
492 g_config_wd_noti = wd;
494 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
495 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
496 if (NULL == g_config_fd_handler_noti) {
497 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
501 /* Set non-blocking mode of file */
503 value = fcntl(fd, F_GETFL, 0);
506 if (0 > fcntl(fd, F_SETFL, value)) {
507 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
513 int __tts_config_mgr_unregister_config_event()
515 /* delete inotify variable */
516 ecore_main_fd_handler_del(g_config_fd_handler_noti);
517 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
518 close(g_config_fd_noti);
523 int __tts_config_set_auto_language()
526 value = vconf_get_str(TTS_LANGSET_KEY);
528 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
532 char temp_lang[6] = {'\0', };
533 strncpy(temp_lang, value, 5);
536 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
537 /* tts default voice change */
538 if (NULL == g_config_info->language) {
539 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
543 char* before_lang = NULL;
546 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
547 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
551 before_lang = strdup(g_config_info->language);
552 before_type = g_config_info->type;
554 free(g_config_info->language);
555 g_config_info->language = strdup(temp_lang);
557 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
558 g_config_info->language, g_config_info->type);
561 tts_config_client_s* temp_client = NULL;
563 /* Call all callbacks of client*/
564 iter = g_slist_nth(g_config_client_list, 0);
566 while (NULL != iter) {
567 temp_client = iter->data;
569 if (NULL != temp_client) {
570 if (NULL != temp_client->voice_cb) {
571 temp_client->voice_cb(before_lang, before_type,
572 g_config_info->language, g_config_info->type,
573 g_config_info->auto_voice, temp_client->user_data);
577 iter = g_slist_next(iter);
580 if (NULL != before_lang) {
584 /* Display language is not valid */
585 char* tmp_language = NULL;
587 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
588 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
592 if (NULL == tmp_language) {
593 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
597 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
598 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
602 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
603 tmp_language, tmp_type);
606 tts_config_client_s* temp_client = NULL;
608 /* Call all callbacks of client*/
609 iter = g_slist_nth(g_config_client_list, 0);
611 while (NULL != iter) {
612 temp_client = iter->data;
614 if (NULL != temp_client) {
615 if (NULL != temp_client->voice_cb) {
616 temp_client->voice_cb(g_config_info->language, g_config_info->type,
617 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
621 iter = g_slist_next(iter);
624 if (NULL != g_config_info->language) {
625 free(g_config_info->language);
626 g_config_info->language = strdup(tmp_language);
629 g_config_info->type = tmp_type;
637 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
639 if (true == g_config_info->auto_voice) {
640 __tts_config_set_auto_language();
646 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
650 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
652 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
657 tts_config_client_s* temp_client = NULL;
659 /* Call all callbacks of client*/
660 iter = g_slist_nth(g_config_client_list, 0);
662 while (NULL != iter) {
663 temp_client = iter->data;
665 if (NULL != temp_client) {
666 if (NULL != temp_client->screen_cb) {
667 temp_client->screen_cb((bool)screen_reader);
671 iter = g_slist_next(iter);
675 int __tts_config_release_client(int uid)
678 tts_config_client_s* temp_client = NULL;
680 if (0 < g_slist_length(g_config_client_list)) {
682 iter = g_slist_nth(g_config_client_list, 0);
684 while (NULL != iter) {
685 temp_client = iter->data;
687 if (NULL != temp_client) {
688 if (uid == temp_client->uid) {
689 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
696 iter = g_slist_next(iter);
700 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
702 return g_slist_length(g_config_client_list);
705 void __tts_config_release_engine()
708 tts_engine_info_s *engine_info = NULL;
710 if (0 < g_slist_length(g_engine_list)) {
712 /* Get a first item */
713 iter = g_slist_nth(g_engine_list, 0);
715 while (NULL != iter) {
716 engine_info = iter->data;
718 if (NULL != engine_info) {
719 g_engine_list = g_slist_remove(g_engine_list, engine_info);
721 tts_parser_free_engine_info(engine_info);
724 iter = g_slist_nth(g_engine_list, 0);
731 int __tts_config_mgr_get_engine_info()
736 struct dirent *dirp = NULL;
738 char filepath[512] = {'\0',};
740 tts_engine_info_s* info = NULL;
742 __tts_config_release_engine();
743 g_engine_list = NULL;
744 __tts_config_mgr_unregister_engine_config_updated_event();
746 /* Copy default info directory to download directory */
747 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
749 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DEFAULT_ENGINE_INFO);
752 ret = readdir_r(dp, &entry, &dirp);
754 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
759 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
760 if (filesize >= 512) {
761 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
766 memset(filepath, '\0', 512);
767 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
769 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
771 char dest[512] = {'\0',};
772 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
774 if (0 != access(dest, F_OK)) {
775 if (0 != tts_parser_copy_xml(filepath, dest)) {
776 SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] Fail to copy engine info");
780 } while (NULL != dirp);
785 /* Get engine info from default engine directory */
786 dp = opendir(TTS_DOWNLOAD_ENGINE_INFO);
788 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DEFAULT_ENGINE_INFO);
791 ret = readdir_r(dp, &entry, &dirp);
793 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
798 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
799 if (filesize >= 512) {
800 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
805 memset(filepath, '\0', 512);
806 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
808 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
810 if (0 == tts_parser_get_engine_info(filepath, &info)) {
811 g_engine_list = g_slist_append(g_engine_list, info);
812 if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
813 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
817 } while (NULL != dirp);
822 if (0 >= g_slist_length(g_engine_list)) {
823 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
830 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
832 SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
834 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
835 int dir_fd = ino->dir_fd;
838 struct inotify_event event;
839 memset(&event, '\0', sizeof(struct inotify_event));
841 length = read(dir_fd, &event, sizeof(struct inotify_event));
843 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
844 SLOG(LOG_DEBUG, tts_tag(), "=====");
845 SLOG(LOG_DEBUG, tts_tag(), " ");
846 return ECORE_CALLBACK_DONE;
849 if (IN_CLOSE_WRITE == event.mask) {
850 int ret = __tts_config_mgr_get_engine_info();
852 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
854 __tts_config_mgr_print_engine_info();
855 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
856 if (false == support) {
857 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
858 char* temp_lang = NULL;
860 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
862 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
865 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
867 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
869 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
871 if (NULL != temp_lang) free(temp_lang);
875 tts_config_client_s* temp_client = NULL;
876 /* Call all callbacks of client*/
877 iter = g_slist_nth(g_config_client_list, 0);
879 while (NULL != iter) {
880 temp_client = iter->data;
882 if (NULL != temp_client) {
883 if (NULL != temp_client->engine_cb) {
884 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
885 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
886 g_config_info->language, g_config_info->type,
887 g_config_info->auto_voice, temp_client->user_data);
891 iter = g_slist_next(iter);
894 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
897 SLOG(LOG_DEBUG, tts_tag(), "=====");
898 SLOG(LOG_DEBUG, tts_tag(), " ");
900 return ECORE_CALLBACK_PASS_ON;
903 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
905 /* For engine directory monitoring */
906 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
908 ino->dir_fd = inotify_init();
909 if (ino->dir_fd < 0) {
910 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
914 /* FIX_ME *//* It doesn't need check engine directory, because daemon will change engine-process */
915 ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
916 SLOG(LOG_DEBUG, tts_tag(), "Add inotify watch(%s)", path);
917 if (ino->dir_wd < 0) {
918 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
922 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);
923 if (NULL == ino->dir_fd_handler) {
924 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
928 /* Set non-blocking mode of file */
930 value = fcntl(ino->dir_fd, F_GETFL, 0);
933 if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
934 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
937 g_ino_list = g_list_append(g_ino_list, ino);
942 static int __tts_config_mgr_unregister_engine_config_updated_event()
944 /* delete all inotify variable */
945 if (0 < g_list_length(g_ino_list)) {
947 iter = g_list_first(g_ino_list);
949 while (NULL != iter) {
950 tts_engine_inotify_s *tmp = iter->data;
953 ecore_main_fd_handler_del(tmp->dir_fd_handler);
954 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
960 g_ino_list = g_list_remove_link(g_ino_list, iter);
962 iter = g_list_first(g_ino_list);
969 int tts_config_mgr_initialize(int uid)
973 tts_config_client_s* temp_client = NULL;
976 if (0 < g_slist_length(g_config_client_list)) {
978 iter = g_slist_nth(g_config_client_list, 0);
980 while (NULL != iter) {
981 get_uid = iter->data;
983 if (uid == *get_uid) {
984 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
988 iter = g_slist_next(iter);
991 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
992 if (NULL == temp_client) {
993 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
994 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
996 temp_client->uid = uid;
998 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1000 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
1003 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1004 if (NULL == temp_client) {
1005 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1006 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1008 temp_client->uid = uid;
1010 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1013 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1014 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1015 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1018 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
1022 if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1023 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1024 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1027 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1031 if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1032 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1033 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1036 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1040 if (0 != __tts_config_mgr_get_engine_info()) {
1041 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1042 __tts_config_release_client(uid);
1043 __tts_config_release_engine();
1044 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1047 __tts_config_mgr_print_engine_info();
1049 if (0 != tts_parser_load_config(&g_config_info)) {
1050 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1051 __tts_config_release_client(uid);
1052 __tts_config_release_engine();
1053 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1056 /* Check whether engine id is valid */
1057 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1058 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1059 __tts_config_release_client(uid);
1060 __tts_config_release_engine();
1061 tts_parser_unload_config(g_config_info);
1062 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1065 if (true == g_config_info->auto_voice) {
1066 /* Check language with display language */
1067 __tts_config_set_auto_language();
1069 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1070 /* Default language is not valid */
1071 char* tmp_language = NULL;
1073 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1074 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1075 __tts_config_release_client(uid);
1076 __tts_config_release_engine();
1077 tts_parser_unload_config(g_config_info);
1078 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1081 if (NULL != tmp_language) {
1082 if (NULL != g_config_info->language) {
1083 free(g_config_info->language);
1084 g_config_info->language = strdup(tmp_language);
1087 g_config_info->type = tmp_type;
1091 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1092 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1093 __tts_config_release_client(uid);
1094 __tts_config_release_engine();
1095 tts_parser_unload_config(g_config_info);
1096 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1102 /* print daemon config */
1103 SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1104 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1105 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1106 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1107 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1108 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1109 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1110 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1111 SLOG(LOG_DEBUG, tts_tag(), "=================");
1113 if (0 != __tts_config_mgr_register_config_event()) {
1114 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1115 __tts_config_release_client(uid);
1116 __tts_config_release_engine();
1117 tts_parser_unload_config(g_config_info);
1118 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1121 /* Register to detect display language change */
1122 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1123 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1125 /* For engine directory monitoring */
1126 //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1127 // SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1128 // __tts_config_release_client(uid);
1129 // __tts_config_release_engine();
1130 // tts_parser_unload_config(g_config_info);
1131 // __tts_config_mgr_unregister_config_event();
1132 // return TTS_CONFIG_ERROR_OPERATION_FAILED;
1138 int tts_config_mgr_finalize(int uid)
1140 if (0 < __tts_config_release_client(uid)) {
1144 tts_config_mgr_unset_callback(uid);
1146 __tts_config_release_engine();
1148 tts_parser_unload_config(g_config_info);
1150 __tts_config_mgr_unregister_engine_config_updated_event();
1152 __tts_config_mgr_unregister_config_event();
1154 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1155 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1160 int tts_config_mgr_set_callback(int uid,
1161 tts_config_engine_changed_cb engine_cb,
1162 tts_config_voice_changed_cb voice_cb,
1163 tts_config_speech_rate_changed_cb speech_cb,
1164 tts_config_pitch_changed_cb pitch_cb,
1167 GSList *iter = NULL;
1168 tts_config_client_s* temp_client = NULL;
1170 /* Call all callbacks of client*/
1171 iter = g_slist_nth(g_config_client_list, 0);
1173 while (NULL != iter) {
1174 temp_client = iter->data;
1176 if (NULL != temp_client) {
1177 if (uid == temp_client->uid) {
1178 temp_client->engine_cb = engine_cb;
1179 temp_client->voice_cb = voice_cb;
1180 temp_client->speech_cb = speech_cb;
1181 temp_client->pitch_cb = pitch_cb;
1182 temp_client->user_data = user_data;
1186 iter = g_slist_next(iter);
1191 int tts_config_mgr_unset_callback(int uid)
1193 GSList *iter = NULL;
1194 tts_config_client_s* temp_client = NULL;
1196 /* Call all callbacks of client*/
1197 iter = g_slist_nth(g_config_client_list, 0);
1199 while (NULL != iter) {
1200 temp_client = iter->data;
1202 if (NULL != temp_client) {
1203 if (uid == temp_client->uid) {
1204 temp_client->engine_cb = NULL;
1205 temp_client->voice_cb = NULL;
1206 temp_client->speech_cb = NULL;
1207 temp_client->pitch_cb = NULL;
1208 temp_client->user_data = NULL;
1212 iter = g_slist_next(iter);
1218 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1220 if (NULL == callback) {
1221 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1222 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1225 GSList *iter = NULL;
1226 tts_config_client_s* temp_client = NULL;
1228 /* Call all callbacks of client*/
1229 iter = g_slist_nth(g_config_client_list, 0);
1231 while (NULL != iter) {
1232 temp_client = iter->data;
1234 if (NULL != temp_client) {
1235 if (uid == temp_client->uid) {
1236 temp_client->screen_cb = callback;
1240 iter = g_slist_next(iter);
1245 int tts_config_unset_screen_reader_callback(int uid)
1247 GSList *iter = NULL;
1248 tts_config_client_s* temp_client = NULL;
1250 /* Call all callbacks of client*/
1251 iter = g_slist_nth(g_config_client_list, 0);
1253 while (NULL != iter) {
1254 temp_client = iter->data;
1256 if (NULL != temp_client) {
1257 if (uid == temp_client->uid) {
1258 temp_client->screen_cb = NULL;
1262 iter = g_slist_next(iter);
1268 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1270 if (0 >= g_slist_length(g_config_client_list)) {
1271 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1272 return TTS_CONFIG_ERROR_INVALID_STATE;
1275 GSList *iter = NULL;
1276 tts_engine_info_s *engine_info = NULL;
1278 if (0 >= g_slist_length(g_engine_list)) {
1279 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1280 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1283 /* Get a first item */
1284 iter = g_slist_nth(g_engine_list, 0);
1286 while (NULL != iter) {
1287 engine_info = iter->data;
1289 if (NULL != engine_info) {
1290 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1295 iter = g_slist_next(iter);
1301 int tts_config_mgr_get_engine(char** engine)
1303 if (0 >= g_slist_length(g_config_client_list)) {
1304 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1305 return TTS_CONFIG_ERROR_INVALID_STATE;
1308 if (NULL == engine) {
1309 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1310 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1313 if (NULL != g_config_info->engine_id) {
1314 /* Check engine id is valid */
1315 GSList *iter = NULL;
1316 tts_engine_info_s *engine_info = NULL;
1318 if (0 >= g_slist_length(g_engine_list)) {
1319 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1320 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1323 /* Get a first item */
1324 iter = g_slist_nth(g_engine_list, 0);
1326 while (NULL != iter) {
1327 engine_info = iter->data;
1329 if (NULL != engine_info) {
1330 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1331 *engine = strdup(g_config_info->engine_id);
1335 iter = g_slist_next(iter);
1338 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1340 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1343 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1346 int tts_config_mgr_set_engine(const char* engine)
1348 if (0 >= g_slist_length(g_config_client_list)) {
1349 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1350 return TTS_CONFIG_ERROR_INVALID_STATE;
1354 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1356 /* Check current engine id with new engine id */
1357 if (NULL != g_config_info->engine_id) {
1358 if (0 == strcmp(g_config_info->engine_id, engine))
1362 if (0 >= g_slist_length(g_engine_list)) {
1363 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1364 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1367 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1369 GSList *iter = NULL;
1370 tts_engine_info_s *engine_info = NULL;
1371 bool is_valid_engine = false;
1373 /* Get a first item */
1374 iter = g_slist_nth(g_engine_list, 0);
1376 while (NULL != iter) {
1377 engine_info = iter->data;
1379 if (NULL == engine_info) {
1380 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1381 iter = g_slist_next(iter);
1385 /* Check engine id is valid */
1386 if (0 != strcmp(engine, engine_info->uuid)) {
1387 iter = g_slist_next(iter);
1391 if (NULL != g_config_info->engine_id)
1392 free(g_config_info->engine_id);
1394 g_config_info->engine_id = strdup(engine);
1396 if (NULL != g_config_info->setting)
1397 free(g_config_info->setting);
1399 if (NULL != engine_info->setting)
1400 g_config_info->setting = strdup(engine_info->setting);
1402 /* Engine is valid*/
1403 GSList *iter_voice = NULL;
1404 tts_config_voice_s* voice = NULL;
1405 bool is_valid_voice = false;
1407 /* Get a first item */
1408 iter_voice = g_slist_nth(engine_info->voices, 0);
1410 while (NULL != iter_voice) {
1411 /*Get handle data from list*/
1412 voice = iter_voice->data;
1414 if (NULL != voice) {
1415 if (NULL == voice->language)
1417 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1419 if (0 == strcmp(voice->language, g_config_info->language)) {
1420 if (voice->type == g_config_info->type) {
1421 /* language is valid */
1422 is_valid_voice = true;
1423 g_config_info->type = voice->type;
1430 iter_voice = g_slist_next(iter_voice);
1433 if (false == is_valid_voice) {
1434 if (NULL != g_config_info->language) {
1435 free(g_config_info->language);
1437 iter_voice = g_slist_nth(engine_info->voices, 0);
1438 if (NULL != iter_voice) {
1439 voice = iter_voice->data;
1440 if (NULL != voice) {
1441 if (NULL != voice->language)
1442 g_config_info->language = strdup(voice->language);
1443 g_config_info->type = voice->type;
1449 is_valid_engine = true;
1453 if (true == is_valid_engine) {
1454 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1455 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1456 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1457 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1458 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1460 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1461 g_config_info->language, g_config_info->type)) {
1462 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1463 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1466 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1467 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1473 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1475 if (0 >= g_slist_length(g_config_client_list)) {
1476 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1477 return TTS_CONFIG_ERROR_INVALID_STATE;
1480 if (0 >= g_slist_length(g_engine_list)) {
1481 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1482 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1485 GSList *iter = NULL;
1486 tts_engine_info_s *engine_info = NULL;
1488 /* Get a first item */
1489 iter = g_slist_nth(g_engine_list, 0);
1491 while (NULL != iter) {
1492 engine_info = iter->data;
1494 if (NULL == engine_info) {
1495 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1496 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1499 if (0 != strcmp(engine_id, engine_info->uuid)) {
1500 iter = g_slist_next(iter);
1504 GSList *iter_voice = NULL;
1505 tts_config_voice_s* voice = NULL;
1507 /* Get a first item */
1508 iter_voice = g_slist_nth(engine_info->voices, 0);
1510 while (NULL != iter_voice) {
1511 /*Get handle data from list*/
1512 voice = iter_voice->data;
1514 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1515 if (NULL != voice->language) {
1516 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1521 iter_voice = g_slist_next(iter_voice);
1529 int tts_config_mgr_get_voice(char** language, int* type)
1531 if (0 >= g_slist_length(g_config_client_list)) {
1532 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1533 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1536 if (0 >= g_slist_length(g_engine_list)) {
1537 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1538 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1541 if (NULL == language || NULL == type)
1542 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1544 if (NULL != g_config_info->language) {
1545 *language = strdup(g_config_info->language);
1546 *type = g_config_info->type;
1548 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1549 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1555 int tts_config_mgr_set_voice(const char* language, int type)
1557 if (0 >= g_slist_length(g_config_client_list)) {
1558 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1559 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1562 if (NULL == language) {
1563 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1564 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1567 if (0 >= g_slist_length(g_engine_list)) {
1568 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1569 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1572 /* Check language is valid */
1573 if (NULL != g_config_info->language) {
1574 if (0 != tts_parser_set_voice(language, type)) {
1575 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1576 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1578 free(g_config_info->language);
1579 g_config_info->language = strdup(language);
1580 g_config_info->type = type;
1583 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1584 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1590 int tts_config_mgr_get_auto_voice(bool* value)
1592 if (0 >= g_slist_length(g_config_client_list)) {
1593 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1594 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1598 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1600 *value = g_config_info->auto_voice;
1605 int tts_config_mgr_set_auto_voice(bool value)
1607 if (0 >= g_slist_length(g_config_client_list)) {
1608 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1609 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1612 if (g_config_info->auto_voice != value) {
1613 /* Check language is valid */
1614 if (0 != tts_parser_set_auto_voice(value)) {
1615 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1616 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1618 g_config_info->auto_voice = value;
1620 if (true == g_config_info->auto_voice) {
1621 __tts_config_set_auto_language();
1628 int tts_config_mgr_get_speech_rate(int* value)
1630 if (0 >= g_slist_length(g_config_client_list)) {
1631 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1632 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1635 if (NULL == value) {
1636 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1639 *value = g_config_info->speech_rate;
1644 int tts_config_mgr_set_speech_rate(int value)
1646 if (0 >= g_slist_length(g_config_client_list)) {
1647 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1648 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1651 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1652 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1653 if (0 != tts_parser_set_speech_rate(value)) {
1654 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1655 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1658 g_config_info->speech_rate = value;
1660 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1666 int tts_config_mgr_get_pitch(int* value)
1668 if (0 >= g_slist_length(g_config_client_list)) {
1669 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1670 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1673 if (NULL == value) {
1674 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1677 GSList *iter = NULL;
1678 tts_engine_info_s *engine_info = NULL;
1680 if (0 >= g_slist_length(g_engine_list)) {
1681 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1682 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1685 /* Get a first item */
1686 iter = g_slist_nth(g_engine_list, 0);
1688 while (NULL != iter) {
1689 engine_info = iter->data;
1691 if (NULL == engine_info) {
1692 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1693 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1696 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1697 iter = g_slist_next(iter);
1701 if (false == engine_info->pitch_support) {
1702 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1708 *value = g_config_info->pitch;
1713 int tts_config_mgr_set_pitch(int value)
1715 if (0 >= g_slist_length(g_config_client_list)) {
1716 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1720 GSList *iter = NULL;
1721 tts_engine_info_s *engine_info = NULL;
1723 if (0 >= g_slist_length(g_engine_list)) {
1724 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1725 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1728 /* Get a first item */
1729 iter = g_slist_nth(g_engine_list, 0);
1731 while (NULL != iter) {
1732 engine_info = iter->data;
1734 if (NULL == engine_info) {
1735 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1736 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1739 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1740 iter = g_slist_next(iter);
1744 if (false == engine_info->pitch_support) {
1745 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1751 if (0 != tts_parser_set_pitch(value)) {
1752 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1753 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1756 g_config_info->pitch = value;
1761 bool tts_config_check_default_engine_is_valid(const char* engine)
1763 if (0 >= g_slist_length(g_config_client_list)) {
1764 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1771 if (0 >= g_slist_length(g_engine_list))
1774 GSList *iter = NULL;
1775 tts_engine_info_s *engine_info = NULL;
1777 /* Get a first item */
1778 iter = g_slist_nth(g_engine_list, 0);
1780 while (NULL != iter) {
1781 engine_info = iter->data;
1783 if (NULL != engine_info) {
1784 if (0 == strcmp(engine, engine_info->uuid)) {
1788 iter = g_slist_next(iter);
1794 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1796 if (0 >= g_slist_length(g_config_client_list)) {
1797 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1801 if (NULL == language)
1804 if (NULL == g_config_info->engine_id) {
1805 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1809 if (0 >= g_slist_length(g_engine_list))
1812 GSList *iter = NULL;
1813 tts_engine_info_s *engine_info = NULL;
1815 /* Get a first item */
1816 iter = g_slist_nth(g_engine_list, 0);
1818 while (NULL != iter) {
1819 engine_info = iter->data;
1821 if (NULL == engine_info) {
1822 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1823 iter = g_slist_next(iter);
1827 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1828 iter = g_slist_next(iter);
1832 GSList *iter_voice = NULL;
1833 tts_config_voice_s* voice = NULL;
1835 /* Get a first item */
1836 iter_voice = g_slist_nth(engine_info->voices, 0);
1838 while (NULL != iter_voice) {
1839 voice = iter_voice->data;
1841 if (0 == strcmp(language, voice->language) && voice->type == type)
1845 iter_voice = g_slist_next(iter_voice);
1855 int __tts_config_mgr_print_engine_info()
1857 GSList *iter = NULL;
1858 tts_engine_info_s *engine_info = NULL;
1860 if (0 >= g_slist_length(g_engine_list)) {
1861 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1862 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1863 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1867 /* Get a first item */
1868 iter = g_slist_nth(g_engine_list, 0);
1870 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
1873 while (NULL != iter) {
1874 engine_info = iter->data;
1876 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
1877 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
1878 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
1879 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
1881 SLOG(LOG_DEBUG, tts_tag(), " Voices");
1882 GSList *iter_voice = NULL;
1883 tts_config_voice_s* voice = NULL;
1885 if (g_slist_length(engine_info->voices) > 0) {
1886 /* Get a first item */
1887 iter_voice = g_slist_nth(engine_info->voices, 0);
1890 while (NULL != iter_voice) {
1891 /*Get handle data from list*/
1892 voice = iter_voice->data;
1894 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
1897 iter_voice = g_slist_next(iter_voice);
1901 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
1903 iter = g_slist_next(iter);
1906 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");