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;
47 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
48 static int g_config_fd_noti;
49 static int g_config_wd_noti;
51 /* For engine directory monitoring */
53 Ecore_Fd_Handler* dir_fd_handler;
56 } tts_engine_inotify_s;
58 static GList* g_ino_list = NULL;
60 int __tts_config_mgr_print_engine_info();
61 static int __tts_config_mgr_register_engine_config_updated_event(const char* path);
62 static int __tts_config_mgr_unregister_engine_config_updated_event();
64 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
66 if (NULL == engine_id) {
67 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
72 tts_engine_info_s *engine_info = NULL;
74 if (0 >= g_slist_length(g_engine_list)) {
75 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
79 /* Get a first item */
80 iter = g_slist_nth(g_engine_list, 0);
82 while (NULL != iter) {
83 engine_info = iter->data;
85 if (NULL == engine_info) {
86 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
90 if (0 == strcmp(engine_id, engine_info->uuid)) {
91 SLOG(LOG_DEBUG, tts_tag(), "Default engine is valid : %s", engine_id);
95 iter = g_slist_next(iter);
98 /* Change default engine */
99 iter = g_slist_nth(g_engine_list, 0);
101 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine in list");
102 return TTS_CONFIG_ERROR_OPERATION_FAILED;
105 engine_info = iter->data;
106 if (NULL == g_config_info) {
107 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid engine info in list");
108 return TTS_CONFIG_ERROR_OPERATION_FAILED;
111 if (NULL != g_config_info->engine_id) free(g_config_info->engine_id);
112 if (NULL != g_config_info->setting) free(g_config_info->setting);
114 g_config_info->engine_id = strdup(engine_info->uuid);
115 g_config_info->setting = strdup(engine_info->setting);
117 SLOG(LOG_DEBUG, tts_tag(), "Default engine is changed : %s", g_config_info->engine_id);
119 /* Change is default voice */
120 GSList *iter_voice = NULL;
121 tts_config_voice_s* voice = NULL;
122 bool is_valid_voice = false;
124 /* Get a first item */
125 iter_voice = g_slist_nth(engine_info->voices, 0);
127 while (NULL != iter_voice) {
128 /*Get handle data from list*/
129 voice = iter_voice->data;
132 if (NULL != voice->language && NULL != g_config_info->language) {
133 if (0 == strcmp(voice->language, g_config_info->language)) {
134 if (voice->type == g_config_info->type) {
135 /* language is valid */
136 is_valid_voice = true;
138 free(g_config_info->language);
139 g_config_info->language = strdup(voice->language);
140 g_config_info->type = voice->type;
142 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
149 iter_voice = g_slist_next(iter_voice);
152 if (false == is_valid_voice) {
153 /* Select first voice as default */
154 if (NULL != g_config_info->language) {
155 free(g_config_info->language);
157 iter_voice = g_slist_nth(engine_info->voices, 0);
158 if (NULL == iter_voice) {
159 SLOG(LOG_ERROR, tts_tag(), "Fail to get voice list");
160 return TTS_CONFIG_ERROR_OPERATION_FAILED;
162 voice = iter_voice->data;
164 if (NULL == voice || NULL == voice->language) {
165 SLOG(LOG_ERROR, tts_tag(), "Fail to get voice info from list");
166 return TTS_CONFIG_ERROR_OPERATION_FAILED;
169 g_config_info->language = strdup(voice->language);
170 g_config_info->type = voice->type;
171 SLOG(LOG_DEBUG, tts_tag(), "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
175 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
176 g_config_info->language, g_config_info->type)) {
177 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
178 return TTS_CONFIG_ERROR_OPERATION_FAILED;
184 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
186 if (NULL == engine_id || NULL == language) {
187 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
192 tts_engine_info_s *engine_info = NULL;
194 if (0 >= g_slist_length(g_engine_list)) {
195 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
199 /* Get a first item */
200 iter = g_slist_nth(g_engine_list, 0);
202 while (NULL != iter) {
203 engine_info = iter->data;
205 if (NULL == engine_info) {
206 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
210 if (0 != strcmp(engine_id, engine_info->uuid)) {
211 iter = g_slist_next(iter);
215 GSList *iter_voice = NULL;
216 tts_config_voice_s* voice = NULL;
218 if (g_slist_length(engine_info->voices) <= 0) {
219 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
220 iter = g_slist_next(iter);
224 /* Get a first item */
225 iter_voice = g_slist_nth(engine_info->voices, 0);
228 while (NULL != iter_voice) {
229 /*Get handle data from list*/
230 voice = iter_voice->data;
233 if (0 == strcmp(language, voice->language)) {
234 if (type == voice->type) {
241 iter_voice = g_slist_next(iter_voice);
251 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
253 if (NULL == engine_id || NULL == language) {
254 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
259 tts_engine_info_s *engine_info = NULL;
261 if (0 >= g_slist_length(g_engine_list)) {
262 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
266 /* Get a first item */
267 iter = g_slist_nth(g_engine_list, 0);
269 while (NULL != iter) {
270 engine_info = iter->data;
272 if (NULL == engine_info) {
273 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
277 if (0 != strcmp(engine_id, engine_info->uuid)) {
278 iter = g_slist_next(iter);
282 GSList *iter_voice = NULL;
283 tts_config_voice_s* voice = NULL;
285 if (g_slist_length(engine_info->voices) <= 0) {
286 SLOG(LOG_ERROR, tts_tag(), "There is no voice : %s", engine_info->uuid);
290 /* Get a first item */
291 iter_voice = g_slist_nth(engine_info->voices, 0);
293 while (NULL != iter_voice) {
294 voice = iter_voice->data;
296 /* Default language */
297 if (0 == strcmp(TTS_BASE_LANGUAGE, voice->language)) {
298 *language = strdup(voice->language);
301 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
305 iter_voice = g_slist_next(iter_voice);
308 /* Not support base language */
310 *language = strdup(voice->language);
313 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Selected language(%s) type(%d)", *language, *type);
322 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
324 SLOG(LOG_DEBUG, tts_tag(), "===== Config changed callback event");
327 struct inotify_event event;
328 memset(&event, '\0', sizeof(struct inotify_event));
330 length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
332 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
333 SLOG(LOG_DEBUG, tts_tag(), "=====");
334 SLOG(LOG_DEBUG, tts_tag(), " ");
335 return ECORE_CALLBACK_DONE;
338 if (IN_CLOSE_WRITE == event.mask) {
339 /* check config changed state */
341 char* setting = NULL;
343 bool auto_voice = g_config_info->auto_voice;
345 int speech_rate = -1;
349 tts_config_client_s* temp_client = NULL;
351 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
352 return ECORE_CALLBACK_PASS_ON;
355 if (NULL != engine || NULL != setting) {
356 if (NULL != engine) {
357 if (NULL != g_config_info->engine_id)
358 free(g_config_info->engine_id);
360 g_config_info->engine_id = strdup(engine);
362 if (NULL != setting) {
363 if (NULL != g_config_info->setting)
364 free(g_config_info->setting);
366 g_config_info->setting = strdup(setting);
369 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
371 /* Call all callbacks of client*/
372 iter = g_slist_nth(g_config_client_list, 0);
374 while (NULL != iter) {
375 temp_client = iter->data;
377 if (NULL != temp_client) {
378 if (NULL != temp_client->engine_cb) {
379 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
380 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
381 g_config_info->language, g_config_info->type,
382 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
386 iter = g_slist_next(iter);
390 if (auto_voice != g_config_info->auto_voice) {
391 g_config_info->auto_voice = auto_voice;
394 if (NULL != lang || -1 != voice_type) {
395 char* before_lang = NULL;
398 before_lang = strdup(g_config_info->language);
399 before_type = g_config_info->type;
402 if (NULL != g_config_info->language)
403 free(g_config_info->language);
405 g_config_info->language = strdup(lang);
407 if (-1 != voice_type) {
408 g_config_info->type = voice_type;
411 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
413 /* Call all callbacks of client*/
414 iter = g_slist_nth(g_config_client_list, 0);
416 while (NULL != iter) {
417 temp_client = iter->data;
419 if (NULL != temp_client) {
420 if (NULL != temp_client->voice_cb) {
421 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
422 temp_client->voice_cb(before_lang, before_type,
423 g_config_info->language, g_config_info->type,
424 g_config_info->auto_voice, temp_client->user_data);
428 iter = g_slist_next(iter);
431 if (NULL != before_lang) {
436 if (-1 != speech_rate) {
437 g_config_info->speech_rate = speech_rate;
439 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
441 /* Call all callbacks of client*/
442 iter = g_slist_nth(g_config_client_list, 0);
444 while (NULL != iter) {
445 temp_client = iter->data;
447 if (NULL != temp_client) {
448 if (NULL != temp_client->speech_cb) {
449 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
450 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
454 iter = g_slist_next(iter);
459 g_config_info->pitch = pitch;
461 SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
463 /* Call all callbacks of client*/
464 iter = g_slist_nth(g_config_client_list, 0);
466 while (NULL != iter) {
467 temp_client = iter->data;
469 if (NULL != temp_client) {
470 if (NULL != temp_client->pitch_cb) {
471 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
472 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
476 iter = g_slist_next(iter);
480 if (NULL != engine) free(engine);
481 if (NULL != setting) free(setting);
482 if (NULL != lang) free(lang);
484 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
487 SLOG(LOG_DEBUG, tts_tag(), "=====");
488 SLOG(LOG_DEBUG, tts_tag(), " ");
490 return ECORE_CALLBACK_PASS_ON;
493 int __tts_config_mgr_register_config_event()
495 /* get file notification handler */
501 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail get inotify fd");
504 g_config_fd_noti = fd;
506 wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE);
507 g_config_wd_noti = wd;
509 g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
510 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
511 if (NULL == g_config_fd_handler_noti) {
512 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get handler_noti");
516 /* Set non-blocking mode of file */
518 value = fcntl(fd, F_GETFL, 0);
521 if (0 > fcntl(fd, F_SETFL, value)) {
522 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
528 int __tts_config_mgr_unregister_config_event()
530 /* delete inotify variable */
531 ecore_main_fd_handler_del(g_config_fd_handler_noti);
532 inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
533 close(g_config_fd_noti);
538 int __tts_config_set_auto_language()
541 value = vconf_get_str(TTS_LANGSET_KEY);
543 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
547 char temp_lang[6] = {'\0', };
548 strncpy(temp_lang, value, 5);
551 if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
552 /* tts default voice change */
553 if (NULL == g_config_info->language) {
554 SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
558 char* before_lang = NULL;
561 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
562 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
566 before_lang = strdup(g_config_info->language);
567 before_type = g_config_info->type;
569 free(g_config_info->language);
570 g_config_info->language = strdup(temp_lang);
572 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
573 g_config_info->language, g_config_info->type);
576 tts_config_client_s* temp_client = NULL;
578 /* Call all callbacks of client*/
579 iter = g_slist_nth(g_config_client_list, 0);
581 while (NULL != iter) {
582 temp_client = iter->data;
584 if (NULL != temp_client) {
585 if (NULL != temp_client->voice_cb) {
586 temp_client->voice_cb(before_lang, before_type,
587 g_config_info->language, g_config_info->type,
588 g_config_info->auto_voice, temp_client->user_data);
592 iter = g_slist_next(iter);
595 if (NULL != before_lang) {
599 /* Display language is not valid */
600 char* tmp_language = NULL;
602 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
603 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
607 if (NULL == tmp_language) {
608 SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
612 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
613 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
617 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
618 tmp_language, tmp_type);
621 tts_config_client_s* temp_client = NULL;
623 /* Call all callbacks of client*/
624 iter = g_slist_nth(g_config_client_list, 0);
626 while (NULL != iter) {
627 temp_client = iter->data;
629 if (NULL != temp_client) {
630 if (NULL != temp_client->voice_cb) {
631 temp_client->voice_cb(g_config_info->language, g_config_info->type,
632 tmp_language, tmp_type, g_config_info->auto_voice, temp_client->user_data);
636 iter = g_slist_next(iter);
639 if (NULL != g_config_info->language) {
640 free(g_config_info->language);
641 g_config_info->language = strdup(tmp_language);
644 g_config_info->type = tmp_type;
652 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
654 if (true == g_config_info->auto_voice) {
655 __tts_config_set_auto_language();
661 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
665 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
667 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
672 tts_config_client_s* temp_client = NULL;
674 /* Call all callbacks of client*/
675 iter = g_slist_nth(g_config_client_list, 0);
677 while (NULL != iter) {
678 temp_client = iter->data;
680 if (NULL != temp_client) {
681 if (NULL != temp_client->screen_cb) {
682 temp_client->screen_cb((bool)screen_reader);
686 iter = g_slist_next(iter);
690 int __tts_config_release_client(int uid)
693 tts_config_client_s* temp_client = NULL;
695 if (0 < g_slist_length(g_config_client_list)) {
697 iter = g_slist_nth(g_config_client_list, 0);
699 while (NULL != iter) {
700 temp_client = iter->data;
702 if (NULL != temp_client) {
703 if (uid == temp_client->uid) {
704 g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
711 iter = g_slist_next(iter);
715 SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
717 return g_slist_length(g_config_client_list);
720 void __tts_config_release_engine()
723 tts_engine_info_s *engine_info = NULL;
725 if (0 < g_slist_length(g_engine_list)) {
727 /* Get a first item */
728 iter = g_slist_nth(g_engine_list, 0);
730 while (NULL != iter) {
731 engine_info = iter->data;
733 if (NULL != engine_info) {
734 g_engine_list = g_slist_remove(g_engine_list, engine_info);
736 tts_parser_free_engine_info(engine_info);
739 iter = g_slist_nth(g_engine_list, 0);
746 int __tts_config_mgr_get_engine_info()
751 struct dirent *dirp = NULL;
753 char filepath[512] = {'\0',};
755 tts_engine_info_s* info = NULL;
757 __tts_config_release_engine();
758 g_engine_list = NULL;
759 __tts_config_mgr_unregister_engine_config_updated_event();
761 /* Copy default info directory to download directory */
762 dp = opendir(TTS_DEFAULT_ENGINE_INFO);
764 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
767 ret = readdir_r(dp, &entry, &dirp);
769 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
774 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
777 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
778 if (filesize >= 512) {
779 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
784 memset(filepath, '\0', 512);
785 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
787 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
789 char dest[512] = {'\0',};
790 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
792 if (0 != access(dest, F_OK)) {
793 if (0 != tts_parser_copy_xml(filepath, dest)) {
794 SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] Fail to copy engine info");
798 } while (NULL != dirp);
803 /* Get engine info from default engine directory */
804 dp = opendir(TTS_DOWNLOAD_ENGINE_INFO);
806 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
809 ret = readdir_r(dp, &entry, &dirp);
811 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
816 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
819 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
820 if (filesize >= 512) {
821 SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
826 memset(filepath, '\0', 512);
827 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
829 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
831 if (0 == tts_parser_get_engine_info(filepath, &info)) {
832 g_engine_list = g_slist_append(g_engine_list, info);
833 if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
834 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
838 } while (NULL != dirp);
843 if (0 >= g_slist_length(g_engine_list)) {
844 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
851 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
853 SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
855 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
856 int dir_fd = ino->dir_fd;
859 struct inotify_event event;
860 memset(&event, '\0', sizeof(struct inotify_event));
862 length = read(dir_fd, &event, sizeof(struct inotify_event));
864 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
865 SLOG(LOG_DEBUG, tts_tag(), "=====");
866 SLOG(LOG_DEBUG, tts_tag(), " ");
867 return ECORE_CALLBACK_DONE;
870 if (IN_CLOSE_WRITE == event.mask) {
871 int ret = __tts_config_mgr_get_engine_info();
873 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
875 __tts_config_mgr_print_engine_info();
876 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
877 if (false == support) {
878 SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
879 char* temp_lang = NULL;
881 ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
883 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
886 ret = tts_config_mgr_set_voice(temp_lang, temp_type);
888 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
890 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
892 if (NULL != temp_lang) free(temp_lang);
896 tts_config_client_s* temp_client = NULL;
897 /* Call all callbacks of client*/
898 iter = g_slist_nth(g_config_client_list, 0);
900 while (NULL != iter) {
901 temp_client = iter->data;
903 if (NULL != temp_client) {
904 if (NULL != temp_client->engine_cb) {
905 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
906 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
907 g_config_info->language, g_config_info->type,
908 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
912 iter = g_slist_next(iter);
915 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
918 SLOG(LOG_DEBUG, tts_tag(), "=====");
919 SLOG(LOG_DEBUG, tts_tag(), " ");
921 return ECORE_CALLBACK_PASS_ON;
924 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
927 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Path is NULL");
931 /* For engine directory monitoring */
932 tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
934 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
938 ino->dir_fd = inotify_init();
939 if (ino->dir_fd < 0) {
940 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
947 ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
948 SLOG(LOG_DEBUG, tts_tag(), "Add inotify watch(%s)", path);
949 if (ino->dir_wd < 0) {
950 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
956 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);
957 if (NULL == ino->dir_fd_handler) {
958 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
964 /* Set non-blocking mode of file */
966 value = fcntl(ino->dir_fd, F_GETFL, 0);
969 if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
970 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
973 g_ino_list = g_list_append(g_ino_list, ino);
978 static int __tts_config_mgr_unregister_engine_config_updated_event()
980 /* delete all inotify variable */
981 if (0 < g_list_length(g_ino_list)) {
983 iter = g_list_first(g_ino_list);
985 while (NULL != iter) {
986 tts_engine_inotify_s *tmp = iter->data;
989 ecore_main_fd_handler_del(tmp->dir_fd_handler);
990 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
996 g_ino_list = g_list_remove_link(g_ino_list, iter);
998 iter = g_list_first(g_ino_list);
1005 int tts_config_mgr_initialize(int uid)
1007 GSList *iter = NULL;
1009 tts_config_client_s* temp_client = NULL;
1012 if (0 < g_slist_length(g_config_client_list)) {
1014 iter = g_slist_nth(g_config_client_list, 0);
1016 while (NULL != iter) {
1017 get_uid = iter->data;
1019 if (uid == *get_uid) {
1020 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
1024 iter = g_slist_next(iter);
1027 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1028 if (NULL == temp_client) {
1029 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1030 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1032 temp_client->uid = uid;
1034 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1036 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
1039 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1040 if (NULL == temp_client) {
1041 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1042 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1044 temp_client->uid = uid;
1046 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1049 if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1050 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1051 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1052 __tts_config_release_client(uid);
1053 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1055 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
1059 if (0 != access(TTS_HOME, F_OK)) {
1060 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1061 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_HOME);
1062 __tts_config_release_client(uid);
1063 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1065 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_HOME);
1069 if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1070 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1071 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1072 __tts_config_release_client(uid);
1073 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1075 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1079 if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1080 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1081 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1082 __tts_config_release_client(uid);
1083 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1085 SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1089 if (0 != __tts_config_mgr_get_engine_info()) {
1090 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1091 __tts_config_release_client(uid);
1092 __tts_config_release_engine();
1093 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1096 __tts_config_mgr_print_engine_info();
1098 if (0 != tts_parser_load_config(&g_config_info)) {
1099 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1100 __tts_config_release_client(uid);
1101 __tts_config_release_engine();
1102 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1105 /* Check whether engine id is valid */
1106 if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1107 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1108 __tts_config_release_client(uid);
1109 __tts_config_release_engine();
1110 tts_parser_unload_config(g_config_info);
1111 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1114 if (true == g_config_info->auto_voice) {
1115 /* Check language with display language */
1116 __tts_config_set_auto_language();
1118 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1119 /* Default language is not valid */
1120 char* tmp_language = NULL;
1122 if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1123 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1124 __tts_config_release_client(uid);
1125 __tts_config_release_engine();
1126 tts_parser_unload_config(g_config_info);
1127 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1130 if (NULL != tmp_language) {
1131 if (NULL != g_config_info->language) {
1132 free(g_config_info->language);
1133 g_config_info->language = strdup(tmp_language);
1136 g_config_info->type = tmp_type;
1140 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1141 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1142 __tts_config_release_client(uid);
1143 __tts_config_release_engine();
1144 tts_parser_unload_config(g_config_info);
1145 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1151 /* print daemon config */
1152 SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1153 SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1154 SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1155 SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1156 SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1157 SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1158 SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1159 SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1160 SLOG(LOG_DEBUG, tts_tag(), "=================");
1162 if (0 != __tts_config_mgr_register_config_event()) {
1163 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1164 __tts_config_release_client(uid);
1165 __tts_config_release_engine();
1166 tts_parser_unload_config(g_config_info);
1167 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1170 /* Register to detect display language change */
1171 vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1172 vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1174 /* For engine directory monitoring */
1175 //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1176 // SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1177 // __tts_config_release_client(uid);
1178 // __tts_config_release_engine();
1179 // tts_parser_unload_config(g_config_info);
1180 // __tts_config_mgr_unregister_config_event();
1181 // return TTS_CONFIG_ERROR_OPERATION_FAILED;
1187 int tts_config_mgr_finalize(int uid)
1189 if (0 < __tts_config_release_client(uid)) {
1193 tts_config_mgr_unset_callback(uid);
1195 __tts_config_release_engine();
1197 tts_parser_unload_config(g_config_info);
1199 __tts_config_mgr_unregister_engine_config_updated_event();
1201 __tts_config_mgr_unregister_config_event();
1203 vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1204 vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1209 int tts_config_mgr_set_callback(int uid,
1210 tts_config_engine_changed_cb engine_cb,
1211 tts_config_voice_changed_cb voice_cb,
1212 tts_config_speech_rate_changed_cb speech_cb,
1213 tts_config_pitch_changed_cb pitch_cb,
1216 GSList *iter = NULL;
1217 tts_config_client_s* temp_client = NULL;
1219 /* Call all callbacks of client*/
1220 iter = g_slist_nth(g_config_client_list, 0);
1222 while (NULL != iter) {
1223 temp_client = iter->data;
1225 if (NULL != temp_client) {
1226 if (uid == temp_client->uid) {
1227 temp_client->engine_cb = engine_cb;
1228 temp_client->voice_cb = voice_cb;
1229 temp_client->speech_cb = speech_cb;
1230 temp_client->pitch_cb = pitch_cb;
1231 temp_client->user_data = user_data;
1235 iter = g_slist_next(iter);
1240 int tts_config_mgr_unset_callback(int uid)
1242 GSList *iter = NULL;
1243 tts_config_client_s* temp_client = NULL;
1245 /* Call all callbacks of client*/
1246 iter = g_slist_nth(g_config_client_list, 0);
1248 while (NULL != iter) {
1249 temp_client = iter->data;
1251 if (NULL != temp_client) {
1252 if (uid == temp_client->uid) {
1253 temp_client->engine_cb = NULL;
1254 temp_client->voice_cb = NULL;
1255 temp_client->speech_cb = NULL;
1256 temp_client->pitch_cb = NULL;
1257 temp_client->user_data = NULL;
1261 iter = g_slist_next(iter);
1267 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1269 if (NULL == callback) {
1270 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1271 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1274 GSList *iter = NULL;
1275 tts_config_client_s* temp_client = NULL;
1277 /* Call all callbacks of client*/
1278 iter = g_slist_nth(g_config_client_list, 0);
1280 while (NULL != iter) {
1281 temp_client = iter->data;
1283 if (NULL != temp_client) {
1284 if (uid == temp_client->uid) {
1285 temp_client->screen_cb = callback;
1289 iter = g_slist_next(iter);
1294 int tts_config_unset_screen_reader_callback(int uid)
1296 GSList *iter = NULL;
1297 tts_config_client_s* temp_client = NULL;
1299 /* Call all callbacks of client*/
1300 iter = g_slist_nth(g_config_client_list, 0);
1302 while (NULL != iter) {
1303 temp_client = iter->data;
1305 if (NULL != temp_client) {
1306 if (uid == temp_client->uid) {
1307 temp_client->screen_cb = NULL;
1311 iter = g_slist_next(iter);
1317 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1319 if (0 >= g_slist_length(g_config_client_list)) {
1320 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1321 return TTS_CONFIG_ERROR_INVALID_STATE;
1324 GSList *iter = NULL;
1325 tts_engine_info_s *engine_info = NULL;
1327 if (0 >= g_slist_length(g_engine_list)) {
1328 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1329 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1332 /* Get a first item */
1333 iter = g_slist_nth(g_engine_list, 0);
1335 while (NULL != iter) {
1336 engine_info = iter->data;
1338 if (NULL != engine_info) {
1339 if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1344 iter = g_slist_next(iter);
1350 int tts_config_mgr_get_engine(char** engine)
1352 if (0 >= g_slist_length(g_config_client_list)) {
1353 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1354 return TTS_CONFIG_ERROR_INVALID_STATE;
1357 if (NULL == engine) {
1358 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1359 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1362 if (NULL != g_config_info->engine_id) {
1363 /* Check engine id is valid */
1364 GSList *iter = NULL;
1365 tts_engine_info_s *engine_info = NULL;
1367 if (0 >= g_slist_length(g_engine_list)) {
1368 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1369 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1372 /* Get a first item */
1373 iter = g_slist_nth(g_engine_list, 0);
1375 while (NULL != iter) {
1376 engine_info = iter->data;
1378 if (NULL != engine_info) {
1379 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1380 *engine = strdup(g_config_info->engine_id);
1384 iter = g_slist_next(iter);
1387 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1389 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1392 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1395 int __tts_set_buxtonkey(const char* engine)
1398 struct buxton_client * bux_cli;
1399 struct buxton_layer * bux_layer;
1400 struct buxton_value * bux_val;
1402 int ret = buxton_open(&bux_cli, NULL, NULL);
1404 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1405 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1407 bux_layer = buxton_create_layer("system");
1408 if (NULL == bux_layer) {
1409 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
1410 buxton_close(bux_cli);
1411 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1413 bux_val = buxton_value_create_string(engine);
1414 if (NULL == bux_val) {
1415 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1416 buxton_free_layer(bux_layer);
1417 buxton_close(bux_cli);
1418 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1420 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1423 ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1425 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1426 buxton_value_free(bux_val);
1427 buxton_free_layer(bux_layer);
1428 buxton_close(bux_cli);
1434 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1436 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1439 buxton_value_free(bux_val);
1440 buxton_free_layer(bux_layer);
1441 buxton_close(bux_cli);
1447 return TTS_CONFIG_ERROR_NONE;
1450 int tts_config_mgr_set_engine(const char* engine)
1452 if (0 >= g_slist_length(g_config_client_list)) {
1453 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1454 return TTS_CONFIG_ERROR_INVALID_STATE;
1458 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1460 /* Check current engine id with new engine id */
1461 if (NULL != g_config_info->engine_id) {
1462 if (0 == strcmp(g_config_info->engine_id, engine))
1466 if (0 >= g_slist_length(g_engine_list)) {
1467 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1468 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1471 SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1473 int ret = __tts_set_buxtonkey(engine);
1475 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] set_buxtonkey Fail!!");
1479 GSList *iter = NULL;
1480 tts_engine_info_s *engine_info = NULL;
1481 bool is_valid_engine = false;
1483 /* Get a first item */
1484 iter = g_slist_nth(g_engine_list, 0);
1486 while (NULL != iter) {
1487 engine_info = iter->data;
1489 if (NULL == engine_info) {
1490 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1491 iter = g_slist_next(iter);
1495 /* Check engine id is valid */
1496 if (0 != strcmp(engine, engine_info->uuid)) {
1497 iter = g_slist_next(iter);
1501 if (NULL != g_config_info->engine_id)
1502 free(g_config_info->engine_id);
1504 g_config_info->engine_id = strdup(engine);
1506 if (NULL != g_config_info->setting) {
1507 free(g_config_info->setting);
1508 g_config_info->setting = NULL;
1511 if (NULL != engine_info->setting) {
1512 g_config_info->setting = strdup(engine_info->setting);
1515 /* Engine is valid*/
1516 GSList *iter_voice = NULL;
1517 tts_config_voice_s* voice = NULL;
1518 bool is_valid_voice = false;
1520 /* Get a first item */
1521 iter_voice = g_slist_nth(engine_info->voices, 0);
1523 while (NULL != iter_voice) {
1524 /*Get handle data from list*/
1525 voice = iter_voice->data;
1527 if (NULL != voice) {
1528 if (NULL == voice->language)
1530 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1532 if (0 == strcmp(voice->language, g_config_info->language)) {
1533 if (voice->type == g_config_info->type) {
1534 /* language is valid */
1535 is_valid_voice = true;
1536 g_config_info->type = voice->type;
1543 iter_voice = g_slist_next(iter_voice);
1546 if (false == is_valid_voice) {
1547 if (NULL != g_config_info->language) {
1548 free(g_config_info->language);
1550 iter_voice = g_slist_nth(engine_info->voices, 0);
1551 if (NULL != iter_voice) {
1552 voice = iter_voice->data;
1553 if (NULL != voice) {
1554 if (NULL != voice->language)
1555 g_config_info->language = strdup(voice->language);
1556 g_config_info->type = voice->type;
1562 is_valid_engine = true;
1566 if (true == is_valid_engine) {
1567 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1568 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Engine : %s", g_config_info->engine_id);
1569 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Setting : %s", g_config_info->setting);
1570 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Language : %s", g_config_info->language);
1571 SECURE_SLOG(LOG_DEBUG, tts_tag(), " Type : %d", g_config_info->type);
1573 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1574 g_config_info->language, g_config_info->type)) {
1575 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1576 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1579 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1580 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1586 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1588 if (0 >= g_slist_length(g_config_client_list)) {
1589 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1590 return TTS_CONFIG_ERROR_INVALID_STATE;
1593 if (0 >= g_slist_length(g_engine_list)) {
1594 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1595 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1598 GSList *iter = NULL;
1599 tts_engine_info_s *engine_info = NULL;
1601 /* Get a first item */
1602 iter = g_slist_nth(g_engine_list, 0);
1604 while (NULL != iter) {
1605 engine_info = iter->data;
1607 if (NULL == engine_info) {
1608 SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1609 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1612 if (0 != strcmp(engine_id, engine_info->uuid)) {
1613 iter = g_slist_next(iter);
1617 GSList *iter_voice = NULL;
1618 tts_config_voice_s* voice = NULL;
1620 /* Get a first item */
1621 iter_voice = g_slist_nth(engine_info->voices, 0);
1623 while (NULL != iter_voice) {
1624 /*Get handle data from list*/
1625 voice = iter_voice->data;
1627 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1628 if (NULL != voice->language) {
1629 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1634 iter_voice = g_slist_next(iter_voice);
1642 int tts_config_mgr_get_voice(char** language, int* type)
1644 if (0 >= g_slist_length(g_config_client_list)) {
1645 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1646 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1649 if (0 >= g_slist_length(g_engine_list)) {
1650 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1651 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1654 if (NULL == language || NULL == type)
1655 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1657 if (NULL != g_config_info->language) {
1658 *language = strdup(g_config_info->language);
1659 *type = g_config_info->type;
1661 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1662 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1668 int tts_config_mgr_set_voice(const char* language, int type)
1670 if (0 >= g_slist_length(g_config_client_list)) {
1671 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1672 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1675 if (NULL == language) {
1676 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1677 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
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 /* Check language is valid */
1686 if (NULL != g_config_info->language) {
1687 if (0 != tts_parser_set_voice(language, type)) {
1688 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1689 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1691 free(g_config_info->language);
1692 g_config_info->language = strdup(language);
1693 g_config_info->type = type;
1696 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1697 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1703 int tts_config_mgr_get_auto_voice(bool* value)
1705 if (0 >= g_slist_length(g_config_client_list)) {
1706 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1707 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1711 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1713 *value = g_config_info->auto_voice;
1718 int tts_config_mgr_set_auto_voice(bool value)
1720 if (0 >= g_slist_length(g_config_client_list)) {
1721 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1722 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1725 if (g_config_info->auto_voice != value) {
1726 /* Check language is valid */
1727 if (0 != tts_parser_set_auto_voice(value)) {
1728 SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1729 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1731 g_config_info->auto_voice = value;
1733 if (true == g_config_info->auto_voice) {
1734 __tts_config_set_auto_language();
1741 int tts_config_mgr_get_speech_rate(int* value)
1743 if (0 >= g_slist_length(g_config_client_list)) {
1744 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1745 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1748 if (NULL == value) {
1749 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1752 *value = g_config_info->speech_rate;
1757 int tts_config_mgr_set_speech_rate(int value)
1759 if (0 >= g_slist_length(g_config_client_list)) {
1760 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1761 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1764 if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1765 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1766 if (0 != tts_parser_set_speech_rate(value)) {
1767 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1768 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1771 g_config_info->speech_rate = value;
1773 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1779 int tts_config_mgr_get_pitch(int* value)
1781 if (0 >= g_slist_length(g_config_client_list)) {
1782 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1783 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1786 if (NULL == value) {
1787 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1790 GSList *iter = NULL;
1791 tts_engine_info_s *engine_info = NULL;
1793 if (0 >= g_slist_length(g_engine_list)) {
1794 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1795 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1798 /* Get a first item */
1799 iter = g_slist_nth(g_engine_list, 0);
1801 while (NULL != iter) {
1802 engine_info = iter->data;
1804 if (NULL == engine_info) {
1805 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1806 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1809 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1810 iter = g_slist_next(iter);
1814 if (false == engine_info->pitch_support) {
1815 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1821 *value = g_config_info->pitch;
1826 int tts_config_mgr_set_pitch(int value)
1828 if (0 >= g_slist_length(g_config_client_list)) {
1829 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1833 GSList *iter = NULL;
1834 tts_engine_info_s *engine_info = NULL;
1836 if (0 >= g_slist_length(g_engine_list)) {
1837 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1838 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1841 /* Get a first item */
1842 iter = g_slist_nth(g_engine_list, 0);
1844 while (NULL != iter) {
1845 engine_info = iter->data;
1847 if (NULL == engine_info) {
1848 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1849 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1852 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1853 iter = g_slist_next(iter);
1857 if (false == engine_info->pitch_support) {
1858 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1864 if (0 != tts_parser_set_pitch(value)) {
1865 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1866 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1869 g_config_info->pitch = value;
1874 bool tts_config_check_default_engine_is_valid(const char* engine)
1876 if (0 >= g_slist_length(g_config_client_list)) {
1877 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1884 if (0 >= g_slist_length(g_engine_list))
1887 GSList *iter = NULL;
1888 tts_engine_info_s *engine_info = NULL;
1890 /* Get a first item */
1891 iter = g_slist_nth(g_engine_list, 0);
1893 while (NULL != iter) {
1894 engine_info = iter->data;
1896 if (NULL != engine_info) {
1897 if (0 == strcmp(engine, engine_info->uuid)) {
1901 iter = g_slist_next(iter);
1907 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1909 if (0 >= g_slist_length(g_config_client_list)) {
1910 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1914 if (NULL == language)
1917 if (NULL == g_config_info->engine_id) {
1918 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1922 if (0 >= g_slist_length(g_engine_list))
1925 GSList *iter = NULL;
1926 tts_engine_info_s *engine_info = NULL;
1928 /* Get a first item */
1929 iter = g_slist_nth(g_engine_list, 0);
1931 while (NULL != iter) {
1932 engine_info = iter->data;
1934 if (NULL == engine_info) {
1935 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1936 iter = g_slist_next(iter);
1940 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1941 iter = g_slist_next(iter);
1945 GSList *iter_voice = NULL;
1946 tts_config_voice_s* voice = NULL;
1948 /* Get a first item */
1949 iter_voice = g_slist_nth(engine_info->voices, 0);
1951 while (NULL != iter_voice) {
1952 voice = iter_voice->data;
1954 if (0 == strcmp(language, voice->language) && voice->type == type)
1958 iter_voice = g_slist_next(iter_voice);
1968 int __tts_config_mgr_print_engine_info()
1970 GSList *iter = NULL;
1971 tts_engine_info_s *engine_info = NULL;
1973 if (0 >= g_slist_length(g_engine_list)) {
1974 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1975 SLOG(LOG_DEBUG, tts_tag(), " No Engine in engine directory");
1976 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1980 /* Get a first item */
1981 iter = g_slist_nth(g_engine_list, 0);
1983 SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
1986 while (NULL != iter) {
1987 engine_info = iter->data;
1989 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
1990 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
1991 SLOG(LOG_DEBUG, tts_tag(), " id : %s", engine_info->uuid);
1992 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
1994 SLOG(LOG_DEBUG, tts_tag(), " Voices");
1995 GSList *iter_voice = NULL;
1996 tts_config_voice_s* voice = NULL;
1998 if (g_slist_length(engine_info->voices) > 0) {
1999 /* Get a first item */
2000 iter_voice = g_slist_nth(engine_info->voices, 0);
2003 while (NULL != iter_voice) {
2004 /*Get handle data from list*/
2005 voice = iter_voice->data;
2007 SLOG(LOG_DEBUG, tts_tag(), " [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2010 iter_voice = g_slist_next(iter_voice);
2014 SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
2016 iter = g_slist_next(iter);
2019 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");