server/ttsd_config_sr.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 <vconf-internal-keys.h>
  16 #include <vconf.h>
  17 #include <runtime_info.h>
  18 #include "ttsd_main.h"
  19 #include "ttsd_config.h"
  20 #include "ttsd_engine_agent.h"
  21 #include "ttsd_data.h"
  22
  23 #define CONFIG_DEFAULT                  BASE_DIRECTORY_DEFAULT"/ttsd.conf"
  24 #define SR_ERROR_FILE_NAME              CONFIG_DIRECTORY"/ttsd_sr.err"
  25
  26 #define ENGINE_ID       "ENGINE_ID"
  27
  28 static char*    g_engine_id;
  29 static char*    g_language;
  30 static int      g_vc_type;
  31 static int      g_speed;
  32
  33 static ttsd_config_lang_changed_cb g_lang_cb;
  34 static ttsd_config_speed_changed_cb g_speed_cb;
  35
  36 void __sr_system_language_changed_cb(runtime_info_key_e key, void *user_data)
  37 {
  38         if (RUNTIME_INFO_KEY_LANGUAGE == key) {
  39                 if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
  40                         int ret = -1;
  41                         char *value;
  42
  43                         ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &value);
  44                         if (0 != ret) {
  45                                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to get system language : %d", ret);
  46                                 return;
  47                         } else {
  48                                 SLOG(LOG_DEBUG, get_tag(), "[Config] System language changed : %s", value);
  49                                 if (NULL != g_lang_cb)
  50                                         g_lang_cb(value, g_vc_type);
  51
  52                                 if (NULL != value)
  53                                         free(value);
  54                         }
  55                 }
  56         }
  57
  58         return;
  59 }
  60
  61 void __sr_speech_rate_changed_cb(keynode_t *key, void *data)
  62 {
  63         char buf[255];
  64         sprintf(buf, "%s", vconf_keynode_get_name(key));
  65
  66         if (!strcmp(buf, VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE)) {
  67                 int temp_speech_rate = vconf_keynode_get_int(key);
  68
  69                 temp_speech_rate ++;
  70                 if (g_speed != temp_speech_rate) {
  71                         SLOG(LOG_DEBUG, get_tag(), "[Config] Speech rate changed : current(%d), previous(%d)",
  72                                 temp_speech_rate, g_speed);
  73                         g_speed = temp_speech_rate;
  74
  75                         if (NULL != g_speed_cb)
  76                                 g_speed_cb(g_speed);
  77                 }
  78         }
  79 }
  80
  81 int ttsd_config_initialize(ttsd_config_lang_changed_cb lang_cb, ttsd_config_speed_changed_cb speed_cb)
  82 {
  83         int ret = -1;
  84         char* value = NULL;
  85         FILE* config_fp;
  86         char buf_id[256] = {0};
  87         char buf_param[256] = {0};
  88
  89         g_engine_id = NULL;
  90         g_language = NULL;
  91         g_vc_type = 2;
  92         g_speed = 3;
  93
  94         g_lang_cb = lang_cb;
  95         g_speed_cb = speed_cb;
  96
  97         ecore_file_mkpath(CONFIG_DIRECTORY);
  98
  99         /* Get default engine id */
 100         config_fp = fopen(CONFIG_DEFAULT, "r");
 101         if (NULL == config_fp) {
 102                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Not open original config file(%s)", CONFIG_DEFAULT);
 103                 return -1;
 104         }
 105
 106         /* Read engine id */
 107         if (EOF == fscanf(config_fp, "%s %s", buf_id, buf_param)) {
 108                 fclose(config_fp);
 109                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to read config (engine id)");
 110                 return -1;
 111         }
 112
 113         fclose(config_fp);
 114
 115         /* Get display language */
 116         ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &value);
 117         if (0 != ret || NULL == value) {
 118                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to get system language : %d", ret);
 119                 return -1;
 120         } else {
 121                 SLOG(LOG_DEBUG, get_tag(), "[Config] System language changed : %s", value);
 122
 123                 g_language = strdup(value);
 124
 125                 if (NULL != value)
 126                         free(value);
 127         }
 128
 129         /* Register system language changed callback */
 130         ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE, __sr_system_language_changed_cb, NULL);
 131         if (0 != ret) {
 132                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to register callback : %d", ret);
 133                 return TTSD_ERROR_OPERATION_FAILED;
 134         }
 135
 136         /* Get speech rate */
 137         ret = vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, &g_speed);
 138
 139         /**
 140         * vconf key value scope
 141         * 0 : Very slow
 142         * 1 : Slow
 143         * 2 : Normal
 144         * 3 : Fast
 145         * 4 : Very fast
 146         */
 147         /* vconf key value is between 0 ~ 4 but tts speech rate value is between 1 ~ 5 */
 148         g_speed ++;
 149         SLOG(LOG_DEBUG, get_tag(), "[Config] Current speech rate : %d", g_speed);
 150
 151         /* register callback function */
 152         vconf_notify_key_changed (VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, __sr_speech_rate_changed_cb, NULL);
 153
 154         return 0;
 155 }
 156
 157 int ttsd_config_finalize()
 158 {
 159         vconf_ignore_key_changed (VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, __sr_speech_rate_changed_cb);
 160
 161         if (NULL != g_language) {
 162                 free(g_language);
 163         }
 164
 165         if (NULL != g_engine_id) {
 166                 free(g_engine_id);
 167         }
 168
 169         return 0;
 170 }
 171
 172 int ttsd_config_update_language()
 173 {
 174         if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
 175                 int ret = -1;
 176                 char *value;
 177
 178                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &value);
 179                 if (0 != ret) {
 180                         SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Fail to get system language : %d", ret);
 181                         return -1;
 182                 } else {
 183                         if (NULL == value) {
 184                                 SLOG(LOG_ERROR, get_tag(), "[Config] Fail to get system language");
 185                                 return -1;
 186                         } else {
 187                                 SLOG(LOG_DEBUG, get_tag(), "[Config] System language : %s", value);
 188
 189                                 if (0 != strcmp(value, g_language)) {
 190                                         if (NULL != g_lang_cb)
 191                                                 g_lang_cb(value, g_vc_type);
 192                                 }
 193
 194                                 free(value);
 195                         }
 196                 }
 197         }
 198
 199         return 0;
 200 }
 201
 202 int ttsd_config_get_default_engine(char** engine_id)
 203 {
 204         if (NULL == engine_id)
 205                 return -1;
 206
 207         if (NULL != g_engine_id) {
 208                 *engine_id = strdup(g_engine_id);
 209         } else {
 210                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Current engine id is NULL");
 211                 return -1;
 212         }
 213         return 0;
 214 }
 215
 216 int ttsd_config_set_default_engine(const char* engine_id)
 217 {
 218         /* Not available in screen mode */
 219         return 0;
 220 }
 221
 222 int ttsd_config_get_default_voice(char** language, int* type)
 223 {
 224         if (NULL == language || NULL == type)
 225                 return -1;
 226
 227         if (NULL != g_language) {
 228                 *language = strdup(g_language);
 229                 *type = g_vc_type;
 230         } else {
 231                 SLOG(LOG_ERROR, get_tag(), "[Config ERROR] Current language is NULL");
 232                 return -1;
 233         }
 234         return 0;
 235 }
 236
 237 int ttsd_config_set_default_voice(const char* language, int type)
 238 {
 239         /* Not available in screen mode */
 240         return 0;
 241 }
 242
 243 int ttsd_config_get_default_speed(int* speed)
 244 {
 245         if (NULL == speed)
 246                 return -1;
 247
 248         *speed = g_speed;
 249
 250         return 0;
 251 }
 252
 253 int ttsd_config_set_default_speed(int speed)
 254 {
 255         /* Not available in screen mode */
 256         return 0;
 257 }
 258
 259 int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
 260                            const char* func, int line, const char* message)
 261 {
 262         FILE* err_fp;
 263         err_fp = fopen(SR_ERROR_FILE_NAME, "a");
 264         if (NULL == err_fp) {
 265                 SLOG(LOG_WARN, get_tag(), "[WARNING] Fail to open error file (%s)", SR_ERROR_FILE_NAME);
 266                 return -1;
 267         }
 268         SLOG(LOG_DEBUG, get_tag(), "Save Error File (%s)", SR_ERROR_FILE_NAME);
 269
 270         /* func */
 271         if (NULL != func) {
 272                 fprintf(err_fp, "function - %s\n", func);
 273         }
 274
 275         /* line */
 276         fprintf(err_fp, "line - %d\n", line);
 277
 278         /* message */
 279         if (NULL != message) {
 280                 fprintf(err_fp, "message - %s\n", message);
 281         }
 282
 283         int ret;
 284         /* uid */
 285         fprintf(err_fp, "uid - %d\n", uid);
 286
 287         /* uttid */
 288         fprintf(err_fp, "uttid - %d\n", uttid);
 289
 290         /* lang */
 291         if (NULL != lang) {
 292                 fprintf(err_fp, "language - %s\n", lang);
 293         }
 294
 295         /* vctype */
 296         fprintf(err_fp, "vctype - %d\n", vctype);
 297
 298         /* text */
 299         if (NULL != text) {
 300                 fprintf(err_fp, "text - %s\n", text);
 301         }
 302
 303         /* get current engine */
 304         char *engine_id = NULL;
 305
 306         ret = ttsd_engine_setting_get_engine(&engine_id);
 307         if (0 != ret) {
 308                 SLOG(LOG_ERROR, get_tag(), "[ERROR] Fail to get current engine");
 309         } else {
 310                 fprintf(err_fp, "current engine - %s", engine_id);
 311         }
 312
 313         /* get data */
 314         ttsd_data_save_error_log(uid, err_fp);
 315
 316         fclose(err_fp);
 317
 318         return 0;
 319 }