server/ttsd_config.c

   1 /*
   2 *  Copyright (c) 2012, 2013 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.
  12 */
  13
  14 #include <Ecore_File.h>
  15 #include <runtime_info.h>
  16 #include "ttsd_main.h"
  17 #include "ttsd_config.h"
  18 #include "ttsd_engine_agent.h"
  19 #include "ttsd_data.h"
  20
  21 #define CONFIG_DEFAULT                  BASE_DIRECTORY_DEFAULT"/ttsd.conf"
  22
  23 #define DEFAULT_ERROR_FILE_NAME         CONFIG_DIRECTORY"/ttsd_default.err"
  24
  25 #define ENGINE_ID       "ENGINE_ID"
  26 #define VOICE           "VOICE"
  27 #define SPEED           "SPEED"
  28
  29 static char*    g_engine_id;
  30 static char*    g_language;
  31 static int      g_vc_type;
  32 static int      g_speed;
  33
  34 static ttsd_config_changed_cb g_callback;
  35
  36 int __ttsd_config_save()
  37 {
  38         if (0 != access(DEFAULT_CONFIG_FILE_NAME, R_OK|W_OK)) {
  39                 if (0 == ecore_file_mkpath(CONFIG_DIRECTORY)) {
  40                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to create directory (%s)", CONFIG_DIRECTORY);
  41                 } else {
  42                         SLOG(LOG_DEBUG, get_tag(), "[Config] Create directory (%s)", CONFIG_DIRECTORY);
  43                 }
  44         }
  45
  46         FILE* config_fp;
  47         config_fp = fopen(DEFAULT_CONFIG_FILE_NAME, "w+");
  48
  49         if (NULL == config_fp) {
  50                 /* make file and file default */
  51                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to open config (%s)", DEFAULT_CONFIG_FILE_NAME);
  52                 return -1;
  53         }
  54
  55         SLOG(LOG_DEBUG, get_tag(), "[Config] Rewrite config file");
  56
  57         /* Write engine id */
  58         fprintf(config_fp, "%s %s\n", ENGINE_ID, g_engine_id);
  59
  60         /* Write voice */
  61         fprintf(config_fp, "%s %s %d\n", VOICE, g_language, g_vc_type);
  62
  63         /* Read speed */
  64         fprintf(config_fp, "%s %d\n", SPEED, g_speed);
  65
  66         fclose(config_fp);
  67
  68         return 0;
  69 }
  70
  71 int __ttsd_config_load()
  72 {
  73         FILE* config_fp;
  74         char buf_id[256] = {0};
  75         char buf_param[256] = {0};
  76         int int_param = 0;
  77         bool is_default_open = false;
  78
  79         config_fp = fopen(DEFAULT_CONFIG_FILE_NAME, "r");
  80
  81         if (NULL == config_fp) {
  82                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Not open file(%s)", DEFAULT_CONFIG_FILE_NAME);
  83
  84                 config_fp = fopen(CONFIG_DEFAULT, "r");
  85                 if (NULL == config_fp) {
  86                         SLOG(LOG_ERROR, get_tag(), "[Config WARNING] Not open original config file(%s)", CONFIG_DEFAULT);
  87                         return -1;
  88                 }
  89                 is_default_open = true;
  90         }
  91
  92         /* Read engine id */
  93         if (EOF == fscanf(config_fp, "%s %s", buf_id, buf_param)) {
  94                 fclose(config_fp);
  95                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (engine id)");
  96                 __ttsd_config_save();
  97                 return -1;
  98         } else {
  99                 if (0 == strncmp(ENGINE_ID, buf_id, strlen(ENGINE_ID))) {
 100                         g_engine_id = strdup(buf_param);
 101                 } else {
 102                         fclose(config_fp);
 103                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (engine id)");
 104                         __ttsd_config_save();
 105                         return -1;
 106                 }
 107         }
 108
 109         /* Read voice */
 110         if (EOF == fscanf(config_fp, "%s %s %d", buf_id, buf_param, &int_param)) {
 111                 fclose(config_fp);
 112                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (voice)");
 113                 __ttsd_config_save();
 114                 return -1;
 115         } else {
 116                 if (0 == strncmp(VOICE, buf_id, strlen(VOICE))) {
 117                         g_language = strdup(buf_param);
 118                         g_vc_type = int_param;
 119                 } else {
 120                         fclose(config_fp);
 121                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (voice)");
 122                         __ttsd_config_save();
 123                         return -1;
 124                 }
 125         }
 126
 127         /* Read speed */
 128         if (EOF == fscanf(config_fp, "%s %d", buf_id, &int_param)) {
 129                 fclose(config_fp);
 130                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (speed)");
 131                 __ttsd_config_save();
 132                 return -1;
 133         } else {
 134                 if (0 == strncmp(SPEED, buf_id, strlen(SPEED))) {
 135                         g_speed = int_param;
 136                 } else {
 137                         fclose(config_fp);
 138                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (speed)");
 139                         __ttsd_config_save();
 140                         return -1;
 141                 }
 142         }
 143
 144         fclose(config_fp);
 145
 146         SLOG(LOG_DEBUG, get_tag(), "[Config] Load config : engine(%s), voice(%s,%d), speed(%d)",
 147                 g_engine_id, g_language, g_vc_type, g_speed);
 148
 149         if (true == is_default_open) {
 150                 if(0 == __ttsd_config_save()) {
 151                         SLOG(LOG_DEBUG, get_tag(), "[Config] Create config(%s)", DEFAULT_CONFIG_FILE_NAME);
 152                 }
 153         }
 154
 155         return 0;
 156 }
 157
 158 int ttsd_config_initialize(ttsd_config_changed_cb callback)
 159 {
 160         g_engine_id = NULL;
 161         g_language = NULL;
 162         g_vc_type = 1;
 163         g_speed = 3;
 164
 165         g_callback = callback;
 166
 167         ecore_file_mkpath(CONFIG_DIRECTORY);
 168
 169         __ttsd_config_load();
 170
 171         return 0;
 172 }
 173
 174 int ttsd_config_finalize()
 175 {
 176         __ttsd_config_save();
 177
 178         if (NULL != g_language) {
 179                 free(g_language);
 180         }
 181
 182         if (NULL != g_engine_id) {
 183                 free(g_engine_id);
 184         }
 185
 186         return 0;
 187 }
 188
 189 int ttsd_config_update_language()
 190 {
 191         /* no work in default mode */
 192         return 0;
 193 }
 194
 195 int ttsd_config_get_default_engine(char** engine_id)
 196 {
 197         if (NULL == engine_id)
 198                 return -1;
 199
 200         if (NULL != g_engine_id) {
 201                 *engine_id = strdup(g_engine_id);
 202         } else {
 203                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Current engine id is NULL");
 204                 return -1;
 205         }
 206
 207         return 0;
 208 }
 209
 210 int ttsd_config_set_default_engine(const char* engine_id)
 211 {
 212         if (NULL == engine_id)
 213                 return -1;
 214
 215         if (NULL != g_engine_id)
 216                 free(g_engine_id);
 217
 218         g_engine_id = strdup(engine_id);
 219
 220         __ttsd_config_save();
 221         return 0;
 222 }
 223
 224 int ttsd_config_get_default_voice(char** language, int* type)
 225 {
 226         if (NULL == language || NULL == type)
 227                 return -1;
 228
 229         if (NULL != g_language) {
 230                 *language = strdup(g_language);
 231                 *type = g_vc_type;
 232         } else {
 233                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Current language is NULL");
 234                 return -1;
 235         }
 236
 237         return 0;
 238 }
 239
 240 int ttsd_config_set_default_voice(const char* language, int type)
 241 {
 242         if (NULL == language)
 243                 return -1;
 244
 245         if (NULL != g_language)
 246                 free(g_language);
 247
 248         g_language = strdup(language);
 249         g_vc_type = type;
 250
 251         __ttsd_config_save();
 252         return 0;
 253 }
 254
 255 int ttsd_config_get_default_speed(int* speed)
 256 {
 257         if (NULL == speed)
 258                 return -1;
 259
 260         *speed = g_speed;
 261
 262         return 0;
 263 }
 264
 265 int ttsd_config_set_default_speed(int speed)
 266 {
 267         g_speed = speed;
 268
 269         __ttsd_config_save();
 270         return 0;
 271 }
 272
 273 int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
 274                            const char* func, int line, const char* message)
 275 {
 276         FILE* err_fp;
 277         err_fp = fopen(DEFAULT_ERROR_FILE_NAME, "a");
 278         if (NULL == err_fp) {
 279                 SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to open error file (%s)", DEFAULT_ERROR_FILE_NAME);
 280                 return -1;
 281         }
 282         SLOG(LOG_DEBUG, get_tag(), "Save Error File (%s)", DEFAULT_ERROR_FILE_NAME);
 283
 284         /* func */
 285         if (NULL != func) {
 286                 fprintf(err_fp, "function - %s\n", func);
 287         }
 288
 289         /* line */
 290         fprintf(err_fp, "line - %d\n", line);
 291
 292         /* message */
 293         if (NULL != message) {
 294                 fprintf(err_fp, "message - %s\n", message);
 295         }
 296
 297         int ret;
 298         /* uid */
 299         fprintf(err_fp, "uid - %d\n", uid);
 300
 301         /* uttid */
 302         fprintf(err_fp, "uttid - %d\n", uttid);
 303
 304         /* lang */
 305         if (NULL != lang) {
 306                 fprintf(err_fp, "language - %s\n", lang);
 307         }
 308
 309         /* vctype */
 310         fprintf(err_fp, "vctype - %d\n", vctype);
 311
 312         /* text */
 313         if (NULL != text) {
 314                 fprintf(err_fp, "text - %s\n", text);
 315         }
 316
 317         /* get current engine */
 318         char *engine_id = NULL;
 319
 320         ret = ttsd_engine_setting_get_engine(&engine_id);
 321         if (0 != ret) {
 322                 SLOG(LOG_ERROR, get_tag(), "[ERROR] Fail to get current engine");
 323         } else {
 324                 fprintf(err_fp, "current engine - %s", engine_id);
 325         }
 326
 327         /* get data */
 328         ttsd_data_save_error_log(uid, err_fp);
 329
 330         fclose(err_fp);
 331
 332         return 0;
 333 }