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_CONFIG_FILE_NAME        "/ttsd_default.conf"
  24 #define NOTI_CONFIG_FILE_NAME           "/ttsd_noti.conf"
  25 #define SR_CONFIG_FILE_NAME             "/ttsd_sr.conf"
  26
  27 #define DEFAULT_ERROR_FILE_NAME         "/ttsd_default.err"
  28 #define NOTI_ERROR_FILE_NAME            "/ttsd_noti.err"
  29 #define SR_ERROR_FILE_NAME              "/ttsd_sr.err"
  30
  31 #define ENGINE_ID       "ENGINE_ID"
  32 #define VOICE           "VOICE"
  33 #define SPEED           "SPEED"
  34
  35 static char*    g_engine_id;
  36 static char*    g_language;
  37 static int      g_vc_type;
  38 static int      g_speed;
  39
  40 static char*    g_config_file;
  41
  42 static ttsd_config_lang_changed_cb g_callback;
  43
  44 void __system_language_changed_cb(runtime_info_key_e key, void *user_data)
  45 {
  46         if (RUNTIME_INFO_KEY_LANGUAGE == key) {
  47                 if (TTSD_MODE_NOTIFICATION == ttsd_get_mode() || TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
  48                         int ret = -1;
  49                         char *value;
  50
  51                         ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &value);
  52                         if (0 != ret) {
  53                                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to get system language : %d", ret);
  54                                 return;
  55                         } else {
  56                                 SLOG(LOG_DEBUG, get_tag(), "[Config] System language changed : %s", value);
  57                                 if (NULL != g_callback)
  58                                         g_callback(value, g_vc_type);
  59
  60                                 if (NULL != value)
  61                                         free(value);
  62                         }
  63                 }
  64         }
  65
  66         return;
  67 }
  68
  69 int __ttsd_config_save()
  70 {
  71         if (0 != access(g_config_file, R_OK|W_OK)) {
  72                 if (0 == ecore_file_mkpath(CONFIG_DIRECTORY)) {
  73                         SLOG(LOG_ERROR, get_tag(), "[Config ERROR ] Fail to create directory (%s)", CONFIG_DIRECTORY);
  74                         return -1;
  75                 }
  76
  77                 SLOG(LOG_WARN, get_tag(), "[Config] Create directory (%s)", CONFIG_DIRECTORY);
  78         }
  79
  80         FILE* config_fp;
  81         config_fp = fopen(g_config_file, "w+");
  82
  83         if (NULL == config_fp) {
  84                 /* make file and file default */
  85                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to open config (%s)", g_config_file);
  86                 return -1;
  87         }
  88
  89         SLOG(LOG_DEBUG, get_tag(), "[Config] Rewrite config file");
  90
  91         /* Write engine id */
  92         fprintf(config_fp, "%s %s\n", ENGINE_ID, g_engine_id);
  93
  94         /* Write voice */
  95         fprintf(config_fp, "%s %s %d\n", VOICE, g_language, g_vc_type);
  96
  97         /* Read speed */
  98         fprintf(config_fp, "%s %d\n", SPEED, g_speed);
  99
 100         fclose(config_fp);
 101
 102         return 0;
 103 }
 104
 105 int __ttsd_config_load()
 106 {
 107         FILE* config_fp;
 108         char buf_id[256] = {0};
 109         char buf_param[256] = {0};
 110         int int_param = 0;
 111         bool is_default_open = false;
 112
 113         config_fp = fopen(g_config_file, "r");
 114
 115         if (NULL == config_fp) {
 116                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Not open file(%s)", g_config_file);
 117
 118                 config_fp = fopen(CONFIG_DEFAULT, "r");
 119                 if (NULL == config_fp) {
 120                         SLOG(LOG_ERROR, get_tag(), "[Config WARNING] Not open original config file(%s)", CONFIG_DEFAULT);
 121                         return -1;
 122                 }
 123                 is_default_open = true;
 124         }
 125
 126         /* Read engine id */
 127         if (EOF == fscanf(config_fp, "%s %s", buf_id, buf_param)) {
 128                 fclose(config_fp);
 129                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (engine id)");
 130                 __ttsd_config_save();
 131                 return -1;
 132         } else {
 133                 if (0 == strncmp(ENGINE_ID, buf_id, strlen(ENGINE_ID))) {
 134                         g_engine_id = strdup(buf_param);
 135                 } else {
 136                         fclose(config_fp);
 137                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (engine id)");
 138                         __ttsd_config_save();
 139                         return -1;
 140                 }
 141         }
 142
 143         /* Read voice */
 144         if (EOF == fscanf(config_fp, "%s %s %d", buf_id, buf_param, &int_param)) {
 145                 fclose(config_fp);
 146                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (voice)");
 147                 __ttsd_config_save();
 148                 return -1;
 149         } else {
 150                 if (0 == strncmp(VOICE, buf_id, strlen(VOICE))) {
 151                         g_language = strdup(buf_param);
 152                         g_vc_type = int_param;
 153                 } else {
 154                         fclose(config_fp);
 155                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (voice)");
 156                         __ttsd_config_save();
 157                         return -1;
 158                 }
 159         }
 160
 161         /* Read speed */
 162         if (EOF == fscanf(config_fp, "%s %d", buf_id, &int_param)) {
 163                 fclose(config_fp);
 164                 SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to read config (speed)");
 165                 __ttsd_config_save();
 166                 return -1;
 167         } else {
 168                 if (0 == strncmp(SPEED, buf_id, strlen(SPEED))) {
 169                         g_speed = int_param;
 170                 } else {
 171                         fclose(config_fp);
 172                         SLOG(LOG_WARN, get_tag(), "[Config WARNING] Fail to load config (speed)");
 173                         __ttsd_config_save();
 174                         return -1;
 175                 }
 176         }
 177
 178         fclose(config_fp);
 179
 180         SLOG(LOG_DEBUG, get_tag(), "[Config] Load config : engine(%s), voice(%s,%d), speed(%d)",
 181                 g_engine_id, g_language, g_vc_type, g_speed);
 182
 183         if (true == is_default_open) {
 184                 if(0 == __ttsd_config_save()) {
 185                         SLOG(LOG_DEBUG, get_tag(), "[Config] Create config(%s)", g_config_file);
 186                 }
 187         }
 188
 189         return 0;
 190 }
 191
 192 int ttsd_config_initialize(ttsd_config_lang_changed_cb callback)
 193 {
 194         g_engine_id = NULL;
 195         g_language = NULL;
 196         g_vc_type = 1;
 197         g_speed = 3;
 198
 199         g_callback = callback;
 200
 201         if (TTSD_MODE_NOTIFICATION == ttsd_get_mode()) {
 202                 g_config_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(NOTI_CONFIG_FILE_NAME) + 1);
 203                 strcpy(g_config_file, CONFIG_DIRECTORY);
 204                 strcat(g_config_file, NOTI_CONFIG_FILE_NAME);
 205         } else if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
 206                 g_config_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(SR_CONFIG_FILE_NAME) + 1);
 207                 strcpy(g_config_file, CONFIG_DIRECTORY);
 208                 strcat(g_config_file, SR_CONFIG_FILE_NAME);
 209         } else {
 210                 g_config_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(DEFAULT_CONFIG_FILE_NAME) + 1);
 211                 strcpy(g_config_file, CONFIG_DIRECTORY);
 212                 strcat(g_config_file, DEFAULT_CONFIG_FILE_NAME);
 213         }
 214
 215         __ttsd_config_load();
 216
 217         /* Register system language changed callback */
 218         int ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE, __system_language_changed_cb, NULL);\r
 219         if (0 != ret) {
 220                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to register callback : %d", ret);
 221                 return TTSD_ERROR_OPERATION_FAILED;
 222         }
 223
 224         return 0;
 225 }
 226
 227 int ttsd_config_finalize()
 228 {
 229         __ttsd_config_save();
 230
 231         if (NULL != g_config_file) {
 232                 free(g_config_file);
 233         }
 234
 235         return 0;
 236 }
 237
 238 int ttsd_config_update_language()
 239 {
 240         if (TTSD_MODE_NOTIFICATION == ttsd_get_mode() || TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
 241                 int ret = -1;
 242                 char *value;
 243
 244                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &value);
 245                 if (0 != ret) {
 246                         SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to get system language : %d", ret);
 247                         return -1;
 248                 } else {
 249                         SLOG(LOG_DEBUG, get_tag(), "[Config] System language : %s", value);
 250
 251                         if (0 != strcmp(value, g_language)) {
 252                                 if (NULL != g_callback)
 253                                         g_callback(value, g_vc_type);
 254                         }
 255
 256                         if (NULL != value)
 257                                 free(value);
 258                 }
 259         }
 260
 261         return 0;
 262 }
 263
 264 int ttsd_config_get_default_engine(char** engine_id)
 265 {
 266         if (NULL == engine_id)
 267                 return -1;
 268
 269         *engine_id = strdup(g_engine_id);
 270         return 0;
 271 }
 272
 273 int ttsd_config_set_default_engine(const char* engine_id)
 274 {
 275         if (NULL == engine_id)
 276                 return -1;
 277
 278         if (NULL != g_engine_id)
 279                 free(g_engine_id);
 280
 281         g_engine_id = strdup(engine_id);
 282         __ttsd_config_save();
 283         return 0;
 284 }
 285
 286 int ttsd_config_get_default_voice(char** language, int* type)
 287 {
 288         if (NULL == language || NULL == type)
 289                 return -1;
 290
 291         *language = strdup(g_language);
 292         *type = g_vc_type;
 293
 294         return 0;
 295 }
 296
 297 int ttsd_config_set_default_voice(const char* language, int type)
 298 {
 299         if (NULL == language)
 300                 return -1;
 301
 302         if (NULL != g_language)
 303                 free(g_language);
 304
 305         g_language = strdup(language);
 306         g_vc_type = type;
 307
 308         __ttsd_config_save();
 309
 310         return 0;
 311 }
 312
 313 int ttsd_config_get_default_speed(int* speed)
 314 {
 315         if (NULL == speed)
 316                 return -1;
 317
 318         *speed = g_speed;
 319
 320         return 0;
 321 }
 322
 323 int ttsd_config_set_default_speed(int speed)
 324 {
 325         g_speed = speed;
 326         __ttsd_config_save();
 327         return 0;
 328 }
 329
 330 int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
 331                            const char* func, int line, const char* message)
 332 {
 333         char* err_file;
 334
 335         if (TTSD_MODE_NOTIFICATION == ttsd_get_mode()) {
 336                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(NOTI_ERROR_FILE_NAME) + 1);
 337                 strcpy(err_file, CONFIG_DIRECTORY);
 338                 strcat(err_file, NOTI_ERROR_FILE_NAME);
 339         } else if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
 340                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(SR_ERROR_FILE_NAME) + 1);
 341                 strcpy(err_file, CONFIG_DIRECTORY);
 342                 strcat(err_file, SR_ERROR_FILE_NAME);
 343         } else {
 344                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(DEFAULT_ERROR_FILE_NAME) + 1);
 345                 strcpy(err_file, CONFIG_DIRECTORY);
 346                 strcat(err_file, DEFAULT_ERROR_FILE_NAME);
 347         }
 348
 349         FILE* err_fp;
 350         err_fp = fopen(err_file, "w+");
 351         if (NULL == err_fp) {
 352                 SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to open error file (%s)", err_file);
 353                 return -1;
 354         }
 355         SLOG(LOG_DEBUG, get_tag(), "Save Error File (%s)", err_file);
 356
 357         /* func */
 358         if (NULL != func) {
 359                 fprintf(err_fp, "function - %s\n", func);
 360         }
 361
 362         /* line */
 363         fprintf(err_fp, "line - %d\n", line);
 364
 365         /* message */
 366         if (NULL != message) {
 367                 fprintf(err_fp, "message - %s\n", message);
 368         }
 369
 370         int ret;
 371         /* uid */
 372         fprintf(err_fp, "uid - %d\n", uid);
 373
 374         /* uttid */
 375         fprintf(err_fp, "uttid - %d\n", uttid);
 376
 377         /* lang */
 378         if (NULL != lang) {
 379                 fprintf(err_fp, "language - %s\n", lang);
 380         }
 381
 382         /* vctype */
 383         fprintf(err_fp, "vctype - %d\n", vctype);
 384
 385         /* text */
 386         if (NULL != text) {
 387                 fprintf(err_fp, "text - %s\n", text);
 388         }
 389
 390         /* get current engine */
 391         char *engine_id = NULL;
 392
 393         ret = ttsd_engine_setting_get_engine(&engine_id);
 394         if (0 != ret) {
 395                 SLOG(LOG_ERROR, get_tag(), "[ERROR] Fail to get current engine");
 396         } else {
 397                 fprintf(err_fp, "current engine - %s", engine_id);
 398         }
 399
 400         /* get data */
 401         ttsd_data_save_error_log(uid, err_fp);
 402
 403         fclose(err_fp);
 404
 405         return 0;
 406 }