Remove duplicated code

- Issue:
From tts_engine_agent.c and tts_config_parser.c, too many duplicated code was generated.

- Solution:
This patch makes new unit functions that encapsulate the duplicated code. These functions will
remove duplicated code.

Change-Id: I2b542061f2d5a694d3f786eefbf6447c507fb225
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/common/tts_config_parser.c b/common/tts_config_parser.c
index b081c9f..a0ba63e 100644 (file)
--- a/common/tts_config_parser.c
+++ b/common/tts_config_parser.c
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved 
+*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -337,7 +337,7 @@ int tts_parser_print_engine_info(tts_engine_info_s* engine_info)
                        /*Get handle data from list*/
                        temp_voice = iter->data;
 
-                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  [%dth] type(%d) lang(%s)", 
+                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  [%dth] type(%d) lang(%s)",
                                i, temp_voice->type, temp_voice->language);
 
                        /*Get next item*/
@@ -678,11 +678,10 @@ int tts_parser_copy_xml(const char* original, const char* destination)
        return 0;
 }
 
-int tts_parser_set_engine(const char* engine_id, const char* setting, const char* language, int type)
+static int __set_value_into_configuration(const char* key, const char* value)
 {
-       if (NULL == engine_id) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
-               return -1;
+       if(NULL == key || NULL == value) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Parameter is NULL");
        }
 
        xmlNodePtr cur = NULL;
@@ -704,359 +703,165 @@ int tts_parser_set_engine(const char* engine_id, const char* setting, const char
        }
 
        while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_ENGINE_ID)) {
-                       xmlNodeSetContent(cur, (const xmlChar *)engine_id);
-               }
+               if (0 == xmlStrcmp(cur->name, (const xmlChar *)key)) {
+                       xmlNodeSetContent(cur, (const xmlChar *)value);
 
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_LANGUAGE)) {
-                       xmlNodeSetContent(cur, (const xmlChar *)language);
+                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Set key(%s) : value(%s)", key, value);
+                       break;
                }
 
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_ENGINE_SETTING)) {
-                       xmlNodeSetContent(cur, (const xmlChar *)setting);
-               }
+               cur = cur->next;
+       }
 
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_VOICE_TYPE)) {
-                       switch (type) {
-                       case TTS_CONFIG_VOICE_TYPE_MALE:        xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_MALE);        break;
-                       case TTS_CONFIG_VOICE_TYPE_FEMALE:      xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_FEMALE);      break;
-                       case TTS_CONFIG_VOICE_TYPE_CHILD:       xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_CHILD);       break;
-                       default:                                xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_FEMALE);      break;
-                       }
-               }
+       return 0;
+}
 
-               cur = cur->next;
+static void __save_configuration(xmlDocPtr config_doc)
+{
+       if (0 != access(TTS_CONFIG, F_OK)) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
+               return;
        }
 
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
+       int ret = xmlSaveFile(TTS_CONFIG, config_doc);
+       if (0 > ret) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
+       } else {
+               static FILE* pFile;
+               pFile = fopen(TTS_CONFIG, "r");
+               int fd = -1;
+               if (NULL == pFile) {
+                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
                } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
+                       fd = fileno(pFile);
+                       fsync(fd);
+                       fclose(pFile);
+                       SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
                }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
        }
+}
 
-       return 0;
+static char* __convert_voice_type_into_char(tts_config_voice_type_e voice_type)
+{
+       switch (voice_type) {
+       case TTS_CONFIG_VOICE_TYPE_MALE:
+               return TTS_TAG_VOICE_TYPE_MALE;
+       case TTS_CONFIG_VOICE_TYPE_FEMALE:
+               return TTS_TAG_VOICE_TYPE_FEMALE;
+       case TTS_CONFIG_VOICE_TYPE_CHILD:
+               return TTS_TAG_VOICE_TYPE_CHILD;
+       default:
+               return TTS_TAG_VOICE_TYPE_FEMALE;
+       }
 }
 
-int tts_parser_set_voice(const char* language, int type)
+int tts_parser_set_engine(const char* engine_id, const char* setting, const char* language, int type)
 {
-       if (NULL == language) {
+       if (NULL == engine_id) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
                return -1;
        }
 
-       xmlNodePtr cur = NULL;
-       cur = xmlDocGetRootElement(g_config_doc);
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_ENGINE_ID, engine_id)) {
                return -1;
        }
 
-       if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_LANGUAGE, language)) {
                return -1;
        }
 
-       cur = cur->xmlChildrenNode;
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_ENGINE_SETTING, setting)) {
                return -1;
        }
 
-       while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_LANGUAGE)) {
-                       xmlNodeSetContent(cur, (const xmlChar *)language);
-               }
-
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_VOICE_TYPE)) {
-                       switch (type) {
-                       case TTS_CONFIG_VOICE_TYPE_MALE:        xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_MALE);        break;
-                       case TTS_CONFIG_VOICE_TYPE_FEMALE:      xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_FEMALE);      break;
-                       case TTS_CONFIG_VOICE_TYPE_CHILD:       xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_CHILD);       break;
-                       default:
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Invalid type : %d", type);
-                               xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_FEMALE);
-                               break;
-                       }
-               }
-
-               cur = cur->next;
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_VOICE_TYPE, __convert_voice_type_into_char(type))) {
+               return -1;
        }
 
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
+
        return 0;
 }
 
-int tts_parser_set_auto_voice(bool value)
+int tts_parser_set_voice(const char* language, int type)
 {
-       xmlNodePtr cur = NULL;
-       cur = xmlDocGetRootElement(g_config_doc);
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
+       if (NULL == language) {
+               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
                return -1;
        }
 
-       if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_LANGUAGE, language)) {
                return -1;
        }
 
-       cur = cur->xmlChildrenNode;
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_VOICE_TYPE, __convert_voice_type_into_char(type))) {
                return -1;
        }
 
-       while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_AUTO_VOICE)) {
-                       if (true == value) {
-                               xmlNodeSetContent(cur, (const xmlChar *)"on");
-                       } else if (false == value) {
-                               xmlNodeSetContent(cur, (const xmlChar *)"off");
-                       } else {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong value of auto voice");
-                               return -1;
-                       }
-                       break;
-               }
-               cur = cur->next;
-       }
-
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
 
        return 0;
 }
 
-int tts_parser_set_speech_rate(int value)
+int tts_parser_set_auto_voice(bool value)
 {
-       xmlNodePtr cur = NULL;
-       cur = xmlDocGetRootElement(g_config_doc);
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
-               return -1;
-       }
-
-       if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
-               return -1;
-       }
-
-       cur = cur->xmlChildrenNode;
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
+       char* temp = value ? "on" : "off";
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_AUTO_VOICE, temp)) {
                return -1;
        }
 
-       while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_SPEECH_RATE)) {
-                       char temp[10];
-                       memset(temp, '\0', 10);
-                       snprintf(temp, 10, "%d", value);
+       __save_configuration(g_config_doc);
 
-                       xmlNodeSetContent(cur, (const xmlChar *)temp);
+       return 0;
+}
 
-                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Set speech rate : %s", temp);
-                       break;
-               }
+int tts_parser_set_speech_rate(int value)
+{
+       char temp[10];
+       memset(temp, '\0', 10);
+       snprintf(temp, 10, "%d", value);
 
-               cur = cur->next;
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_SPEECH_RATE, temp)) {
+               return -1;
        }
 
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
 
        return 0;
 }
 
 int tts_parser_set_pitch(int value)
 {
-       xmlNodePtr cur = NULL;
-       cur = xmlDocGetRootElement(g_config_doc);
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
-               return -1;
-       }
+       char temp[10];
+       memset(temp, '\0', 10);
+       snprintf(temp, 10, "%d", value);
 
-       if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_PITCH, temp)) {
                return -1;
        }
 
-       cur = cur->xmlChildrenNode;
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
-               return -1;
-       }
-
-       while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_PITCH)) {
-                       char temp[10];
-                       memset(temp, '\0', 10);
-                       snprintf(temp, 10, "%d", value);
-                       xmlNodeSetContent(cur, (const xmlChar *)temp);
-                       break;
-               }
-
-               cur = cur->next;
-       }
-
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
 
        return 0;
 }
 
 int tts_parser_set_bg_volume_ratio(double value)
 {
-       xmlNodePtr cur = NULL;
-       cur = xmlDocGetRootElement(g_config_doc);
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
-               return -1;
-       }
+       char temp[10];
+       memset(temp, '\0', 10);
+       snprintf(temp, 10, "%lf", value);
 
-       if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
+       if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_BACKGROUND_VOLUME_RATIO, temp)) {
                return -1;
        }
 
-       cur = cur->xmlChildrenNode;
-       if (cur == NULL) {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty document");
-               return -1;
-       }
-
-       while (cur != NULL) {
-               if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_BACKGROUND_VOLUME_RATIO)) {
-                       char temp[10];
-                       memset(temp, '\0', 10);
-                       snprintf(temp, 10, "%lf", value);
-                       xmlNodeSetContent(cur, (const xmlChar *)temp);
-                       break;
-               }
-
-               cur = cur->next;
-       }
-
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : %d", ret);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
 
        return 0;
 }
 
-int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voice, char** language, int* voice_type, 
+int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voice, char** language, int* voice_type,
                                   int* speech_rate, int* pitch, double* bg_volume_ratio)
 {
        if (NULL == engine || NULL == setting || NULL == language || NULL == voice_type || NULL == speech_rate) {
@@ -1098,7 +903,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                return -1;
        }
 
-       if (xmlStrcmp(cur_new->name, (const xmlChar*)TTS_TAG_CONFIG_BASE_TAG) || 
+       if (xmlStrcmp(cur_new->name, (const xmlChar*)TTS_TAG_CONFIG_BASE_TAG) ||
        xmlStrcmp(cur_old->name, (const xmlChar*)TTS_TAG_CONFIG_BASE_TAG)) {
                SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] The wrong type, root node is NOT %s. doc(%p)", TTS_TAG_CONFIG_BASE_TAG, doc);
                xmlFreeDoc(doc);
@@ -1123,7 +928,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old engine id(%s), New engine(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old engine id(%s), New engine(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        if (NULL != *engine) {
                                                                free(*engine);
@@ -1147,7 +952,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old engine setting(%s), New engine setting(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old engine setting(%s), New engine setting(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        if (NULL != *setting) {
                                                                free(*setting);
@@ -1171,7 +976,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old auto voice (%s), New auto voice(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old auto voice (%s), New auto voice(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        if (0 == xmlStrcmp((const xmlChar*)"on", key_new)) {
                                                                *auto_voice = true;
@@ -1195,7 +1000,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old language(%s), New language(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old language(%s), New language(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        if (NULL != *language) {
                                                                free(*language);
@@ -1219,7 +1024,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old voice type(%s), New voice type(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old voice type(%s), New voice type(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        if (0 == xmlStrcmp(key_new, (const xmlChar *)TTS_TAG_VOICE_TYPE_FEMALE)) {
                                                                *voice_type = (int)TTS_CONFIG_VOICE_TYPE_FEMALE;
@@ -1247,7 +1052,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old speech rate(%s), New speech rate(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old speech rate(%s), New speech rate(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        *speech_rate = atoi((char*)key_new);
                                                }
@@ -1267,7 +1072,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old pitch(%s), New pitch(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old pitch(%s), New pitch(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        *pitch = atoi((char*)key_new);
                                                }
@@ -1287,7 +1092,7 @@ int tts_parser_find_config_changed(char** engine, char**setting, bool* auto_voic
                                        key_new = xmlNodeGetContent(cur_new);
                                        if (NULL != key_new) {
                                                if (0 != xmlStrcmp(key_old, key_new)) {
-                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old bg volume ratio(%s), New bg volume ratio(%s)", 
+                                                       SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Old bg volume ratio(%s), New bg volume ratio(%s)",
                                                                (char*)key_old, (char*)key_new);
                                                        *bg_volume_ratio = atof((char*)key_new);
                                                }
@@ -1334,27 +1139,7 @@ int tts_parser_reset()
                return -1;
        }
 
-       if (0 == access(TTS_CONFIG, F_OK)) {
-               int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
-               if (0 > ret) {
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save %s", TTS_CONFIG);
-               } else {
-                       static FILE* pFile;
-                       pFile = fopen(TTS_CONFIG, "r");
-                       int fd = -1;
-                       if (NULL == pFile) {
-                               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to open file %s", TTS_CONFIG);
-                       } else {
-                               fd = fileno(pFile);
-                               fsync(fd);
-                               fclose(pFile);
-                               SLOG(LOG_INFO, TAG_TTSCONFIG, "[DEBUG] Success to fsync %s", TTS_CONFIG);
-                       }
-                       SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Success to save %s", TTS_CONFIG);
-               }
-       } else {
-               SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to access to %s", TTS_CONFIG);
-       }
+       __save_configuration(g_config_doc);
 
        return 0;
 }

diff --git a/server/ttsd_engine_agent.c b/server/ttsd_engine_agent.c
index 8725ae2..cfb913d 100644 (file)
--- a/server/ttsd_engine_agent.c
+++ b/server/ttsd_engine_agent.c
@@ -578,7 +578,31 @@ bool ttsd_engine_select_valid_voice(const char* lang, int type, char** out_lang,
        return result;
 }
 
+static ttsvoice_s* __get_ttsvoice(const char* lang, const int vctype)
+{
+       GSList *iter = NULL;
+       ttsvoice_s* data = NULL;
 
+       iter = g_slist_nth(g_cur_voices, 0);
+       while (NULL != iter) {
+               /*Get handle data from list*/
+               data = iter->data;
+
+               if (NULL != data) {
+                       if (NULL != data->lang && 0 == strcmp(data->lang, lang) && data->type == vctype) {
+                               SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Find voice : default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
+                                       data->is_default, data->is_loaded,  data->client_ref_count, data->lang, data->type);
+                               break;
+                       }
+               }
+
+               /*Get next item*/
+               iter = g_slist_next(iter);
+               data = NULL;
+       }
+
+       return data;
+}
 
 int ttsd_engine_agent_set_default_voice(const char* language, int vctype)
 {
@@ -620,42 +644,22 @@ int ttsd_engine_agent_set_default_voice(const char* language, int vctype)
                return ret;
        }
 
-
-       GSList *iter = NULL;
-       ttsvoice_s* data = NULL;
-
        /* Update new default voice info */
-       iter = g_slist_nth(g_cur_voices, 0);
-       while (NULL != iter) {
-               /* Get handle data from list */
-               data = iter->data;
-
-               if (NULL == data) {
-                       SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Voice data is NULL");
-                       return TTSD_ERROR_OPERATION_FAILED;
-               }
-
-               if (NULL != data->lang) {
-               if (0 == strcmp(data->lang, language) && data->type == vctype) {
-                       data->is_default = true;
-                       if (0 == data->client_ref_count) {
-                               /* load voice */
-                                       ret = g_engine_info->callbacks->load_voice(data->lang, data->type);
-                                       if (0 == ret) {
-                                               SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
-                                                       data->lang, data->type);
-                                               data->is_loaded = true;
-                                       } else {
-                                               SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to load voice : lang(%s), type(%d), result(%s)",
-                                                       data->lang, data->type, __ttsd_get_engine_error_code(ret));
-                                       }
-                               }
+       ttsvoice_s* data = __get_ttsvoice(language, vctype);
+       if (NULL != data) {
+               data->is_default = true;
+               if (0 == data->client_ref_count) {
+                       /* load voice */
+                       ret = g_engine_info->callbacks->load_voice(data->lang, data->type);
+                       if (0 == ret) {
+                               SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
+                                       data->lang, data->type);
+                               data->is_loaded = true;
+                       } else {
+                               SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to load voice : lang(%s), type(%d), result(%s)",
+                                       data->lang, data->type, __ttsd_get_engine_error_code(ret));
                        }
-                       break;
                }
-
-               /*Get next item*/
-               iter = g_slist_next(iter);
        }
 
 #ifdef ENGINE_AGENT_DEBUG
@@ -663,35 +667,21 @@ int ttsd_engine_agent_set_default_voice(const char* language, int vctype)
 #endif
 
        /* Update old default voice info */
-       iter = g_slist_nth(g_cur_voices, 0);
-       while (NULL != iter) {
-               /*Get handle data from list*/
-               data = iter->data;
-
-               if (NULL == data) {
-                       SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Voice data is NULL");
-                       return TTSD_ERROR_OPERATION_FAILED;
-               }
-
-               if (0 == strcmp(data->lang, g_engine_info->default_lang) && data->type == g_engine_info->default_vctype) {
-                       data->is_default = false;
-                       if (0 == data->client_ref_count) {
-                               /* Unload voice */
-                               ret = g_engine_info->callbacks->unload_voice(data->lang, data->type);
-                               if (0 == ret) {
-                                       SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
-                                               data->lang, data->type);
-                                       data->is_loaded = false;
-                               } else {
-                                       SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to unload voice : lang(%s), type(%d), result(%s)",
-                                               data->lang, data->type, __ttsd_get_engine_error_code(ret));
-                               }
+       data = __get_ttsvoice(g_engine_info->default_lang, g_engine_info->default_vctype);
+       if (NULL != data) {
+               data->is_default = false;
+               if (0 == data->client_ref_count) {
+                       /* Unload voice */
+                       ret = g_engine_info->callbacks->unload_voice(data->lang, data->type);
+                       if (0 == ret) {
+                               SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
+                                       data->lang, data->type);
+                               data->is_loaded = false;
+                       } else {
+                               SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to unload voice : lang(%s), type(%d), result(%s)",
+                                       data->lang, data->type, __ttsd_get_engine_error_code(ret));
                        }
-                       break;
                }
-
-               /*Get next item*/
-               iter = g_slist_next(iter);
        }
 
        if (NULL != g_engine_info->default_lang) {
@@ -807,27 +797,7 @@ int ttsd_engine_load_voice(const char* lang, const int vctype)
 
        /* 1. Find voice info */
        int ret = -1;
-       GSList *iter = NULL;
-       ttsvoice_s* data = NULL;
-
-       iter = g_slist_nth(g_cur_voices, 0);
-       while (NULL != iter) {
-               /*Get handle data from list*/
-               data = iter->data;
-
-               if (NULL != data) {
-                       if (NULL != data->lang && 0 == strcmp(data->lang, lang) && data->type == vctype) {
-                               SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Find voice : default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
-                                        data->is_default, data->is_loaded,  data->client_ref_count, data->lang, data->type);
-                               break;
-                       }
-               }
-
-               /*Get next item*/
-               iter = g_slist_next(iter);
-               data = NULL;
-       }
-
+       ttsvoice_s* data = __get_ttsvoice(lang, vctype);
        if (NULL == data) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] This voice is not supported voice : lang(%s) type(%d)", lang, vctype);
                return TTSD_ERROR_OPERATION_FAILED;
@@ -881,27 +851,7 @@ int ttsd_engine_unload_voice(const char* lang, const int vctype)
 
        /* 1. Find voice info */
        int ret = -1;
-       GSList *iter = NULL;
-       ttsvoice_s* data = NULL;
-
-       iter = g_slist_nth(g_cur_voices, 0);
-       while (NULL != iter) {
-               /*Get handle data from list*/
-               data = iter->data;
-
-               if (NULL != data) {
-                       if (NULL != data->lang && 0 == strcmp(data->lang, lang) && data->type == vctype) {
-                               SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Find voice : default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
-                                        data->is_default, data->is_loaded,  data->client_ref_count, data->lang, data->type);
-                               break;
-                       }
-               }
-
-               /*Get next item*/
-               iter = g_slist_next(iter);
-               data = NULL;
-       }
-
+       ttsvoice_s* data = __get_ttsvoice(lang, vctype);
        if (NULL == data) {
                SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] This voice is not supported voice : lang(%s) type(%d)", lang, vctype);
                return TTSD_ERROR_OPERATION_FAILED;