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);
 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                         if (NULL == value) {
 250                                 SLOG(LOG_ERROR, get_tag(), "[Config] Fail to get system language");
 251                                 return -1;
 252                         } else {
 253                                 SLOG(LOG_DEBUG, get_tag(), "[Config] System language : %s", value);
 254
 255                                 if (0 != strcmp(value, g_language)) {
 256                                         if (NULL != g_callback)
 257                                                 g_callback(value, g_vc_type);
 258                                 }
 259
 260                                 free(value);
 261                         }
 262                 }
 263         }
 264
 265         return 0;
 266 }
 267
 268 int ttsd_config_get_default_engine(char** engine_id)
 269 {
 270         if (NULL == engine_id)
 271                 return -1;
 272
 273         *engine_id = strdup(g_engine_id);
 274         return 0;
 275 }
 276
 277 int ttsd_config_set_default_engine(const char* engine_id)
 278 {
 279         if (NULL == engine_id)
 280                 return -1;
 281
 282         if (NULL != g_engine_id)
 283                 free(g_engine_id);
 284
 285         g_engine_id = strdup(engine_id);
 286         __ttsd_config_save();
 287         return 0;
 288 }
 289
 290 int ttsd_config_get_default_voice(char** language, int* type)
 291 {
 292         if (NULL == language || NULL == type)
 293                 return -1;
 294
 295         *language = strdup(g_language);
 296         *type = g_vc_type;
 297
 298         return 0;
 299 }
 300
 301 int ttsd_config_set_default_voice(const char* language, int type)
 302 {
 303         if (NULL == language)
 304                 return -1;
 305
 306         if (NULL != g_language)
 307                 free(g_language);
 308
 309         g_language = strdup(language);
 310         g_vc_type = type;
 311
 312         __ttsd_config_save();
 313
 314         return 0;
 315 }
 316
 317 int ttsd_config_get_default_speed(int* speed)
 318 {
 319         if (NULL == speed)
 320                 return -1;
 321
 322         *speed = g_speed;
 323
 324         return 0;
 325 }
 326
 327 int ttsd_config_set_default_speed(int speed)
 328 {
 329         g_speed = speed;
 330         __ttsd_config_save();
 331         return 0;
 332 }
 333
 334 int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
 335                            const char* func, int line, const char* message)
 336 {
 337         char* err_file;
 338
 339         if (TTSD_MODE_NOTIFICATION == ttsd_get_mode()) {
 340                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(NOTI_ERROR_FILE_NAME) + 1);
 341                 if (NULL == err_file) {
 342                         SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to get error file name");
 343                         return -1;
 344                 }
 345                 strcpy(err_file, CONFIG_DIRECTORY);
 346                 strcat(err_file, NOTI_ERROR_FILE_NAME);
 347         } else if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
 348                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(SR_ERROR_FILE_NAME) + 1);
 349                 if (NULL == err_file) {
 350                         SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to get error file name");
 351                         return -1;
 352                 }
 353                 strcpy(err_file, CONFIG_DIRECTORY);
 354                 strcat(err_file, SR_ERROR_FILE_NAME);
 355         } else {
 356                 err_file = (char*)malloc(strlen(CONFIG_DIRECTORY) + strlen(DEFAULT_ERROR_FILE_NAME) + 1);
 357                 if (NULL == err_file) {
 358                         SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to get error file name");
 359                         return -1;
 360                 }
 361                 strcpy(err_file, CONFIG_DIRECTORY);
 362                 strcat(err_file, DEFAULT_ERROR_FILE_NAME);
 363         }
 364
 365         FILE* err_fp;
 366         err_fp = fopen(err_file, "w+");
 367         if (NULL == err_fp) {
 368                 SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to open error file (%s)", err_file);
 369                 free(err_file);
 370                 return -1;
 371         }
 372         SLOG(LOG_DEBUG, get_tag(), "Save Error File (%s)", err_file);
 373
 374         /* func */
 375         if (NULL != func) {
 376                 fprintf(err_fp, "function - %s\n", func);
 377         }
 378
 379         /* line */
 380         fprintf(err_fp, "line - %d\n", line);
 381
 382         /* message */
 383         if (NULL != message) {
 384                 fprintf(err_fp, "message - %s\n", message);
 385         }
 386
 387         int ret;
 388         /* uid */
 389         fprintf(err_fp, "uid - %d\n", uid);
 390
 391         /* uttid */
 392         fprintf(err_fp, "uttid - %d\n", uttid);
 393
 394         /* lang */
 395         if (NULL != lang) {
 396                 fprintf(err_fp, "language - %s\n", lang);
 397         }
 398
 399         /* vctype */
 400         fprintf(err_fp, "vctype - %d\n", vctype);
 401
 402         /* text */
 403         if (NULL != text) {
 404                 fprintf(err_fp, "text - %s\n", text);
 405         }
 406
 407         /* get current engine */
 408         char *engine_id = NULL;
 409
 410         ret = ttsd_engine_setting_get_engine(&engine_id);
 411         if (0 != ret) {
 412                 SLOG(LOG_ERROR, get_tag(), "[ERROR] Fail to get current engine");
 413         } else {
 414                 fprintf(err_fp, "current engine - %s", engine_id);
 415         }
 416
 417         /* get data */
 418         ttsd_data_save_error_log(uid, err_fp);
 419
 420         free(err_file);
 421
 422         fclose(err_fp);
 423
 424         return 0;
 425 }