client/stt_setting.c

   1 /*
   2 *  Copyright (c) 2011-2016 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 <dirent.h>
  15 #include <Ecore.h>
  16 #include <libxml/parser.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20
  21 #include "stt_config_mgr.h"
  22 #include "stt_main.h"
  23 #include "stt_setting.h"
  24
  25
  26 static stt_setting_state_e g_state = STT_SETTING_STATE_NONE;
  27
  28 static stt_setting_supported_engine_cb g_engine_cb;
  29 static void* g_user_data;
  30
  31 static stt_setting_config_changed_cb g_config_changed_cb;
  32 static void* g_config_changed_user_data;
  33
  34 static stt_setting_engine_changed_cb g_engine_changed_cb;
  35 static void* g_engine_changed_user_data;
  36
  37 void __config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, bool support_silence, bool need_credential, void* user_data)
  38 {
  39         if (NULL != engine_id)  SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
  40         if (NULL != setting)    SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
  41         if (NULL != language)   SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
  42         SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
  43
  44         if (NULL != g_config_changed_cb)
  45                 g_engine_changed_cb(g_config_changed_user_data);
  46 }
  47
  48 void __config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
  49 {
  50         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Lang changed : lang(%s)", current_language);
  51
  52         if (NULL != g_config_changed_cb)
  53                 g_config_changed_cb(g_config_changed_user_data);
  54 }
  55
  56 void __config_bool_changed_cb(stt_config_type_e type, bool bool_value, void* user_data)
  57 {
  58         SECURE_SLOG(LOG_DEBUG, TAG_STTC, " type(%d) bool(%s)", type, bool_value ? "on" : "off");
  59
  60         if (NULL != g_config_changed_cb)
  61                 g_config_changed_cb(g_config_changed_user_data);
  62 }
  63
  64 int stt_setting_initialize(void)
  65 {
  66         SLOG(LOG_DEBUG, TAG_STTC, "===== Initialize STT Setting");
  67
  68         if (STT_SETTING_STATE_READY == g_state) {
  69                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] STT Setting has already been initialized. ");
  70                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
  71                 SLOG(LOG_DEBUG, TAG_STTC, " ");
  72                 return STT_SETTING_ERROR_NONE;
  73         }
  74
  75         int ret = stt_config_mgr_initialize(getpid());
  76         if (0 != ret) {
  77                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize config manager : %d", ret);
  78                 return STT_SETTING_ERROR_OPERATION_FAILED;
  79         }
  80
  81         ret = stt_config_mgr_set_callback(getpid(), __config_engine_changed_cb, __config_lang_changed_cb, __config_bool_changed_cb, NULL);
  82         if (0 != ret) {
  83                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %d", ret);
  84                 return STT_SETTING_ERROR_OPERATION_FAILED;
  85         }
  86
  87         g_state = STT_SETTING_STATE_READY;
  88
  89         g_engine_changed_cb = NULL;
  90         g_engine_changed_user_data = NULL;
  91
  92         g_config_changed_cb = NULL;
  93         g_config_changed_user_data = NULL;
  94
  95         SLOG(LOG_DEBUG, TAG_STTC, "=====");
  96         SLOG(LOG_DEBUG, TAG_STTC, " ");
  97
  98         return STT_SETTING_ERROR_NONE;
  99 }
 100
 101 int stt_setting_finalize()
 102 {
 103         SLOG(LOG_DEBUG, TAG_STTC, "===== Finalize STT Setting");
 104
 105         stt_config_mgr_finalize(getpid());
 106
 107         g_state = STT_SETTING_STATE_NONE;
 108
 109         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 110         SLOG(LOG_DEBUG, TAG_STTC, " ");
 111
 112         return STT_SETTING_ERROR_NONE;
 113 }
 114
 115 bool __config_mgr_get_engine_list(const char* engine_id, const char* engine_name, const char* setting, bool support_silence, void* user_data)
 116 {
 117         return g_engine_cb(engine_id, engine_name, setting, g_user_data);
 118 }
 119
 120 int stt_setting_foreach_supported_engines(stt_setting_supported_engine_cb callback, void* user_data)
 121 {
 122         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach supported engines");
 123
 124         if (STT_SETTING_STATE_NONE == g_state) {
 125                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 126                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 127                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 128                 return STT_SETTING_ERROR_INVALID_STATE;
 129         }
 130
 131         if (NULL == callback) {
 132                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
 133                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 134                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 135                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 136         }
 137
 138         g_engine_cb = callback;
 139         g_user_data = user_data;
 140
 141         int ret = stt_config_mgr_get_engine_list(__config_mgr_get_engine_list, NULL);
 142         if (0 != ret) {
 143                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 144         } else {
 145                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach supported engines");
 146         }
 147
 148         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 149         SLOG(LOG_DEBUG, TAG_STTC, " ");
 150
 151         return ret;
 152 }
 153
 154 int stt_setting_get_engine(char** engine_id)
 155 {
 156         SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
 157
 158         if (STT_SETTING_STATE_NONE == g_state) {
 159                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 160                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 161                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 162                 return STT_SETTING_ERROR_INVALID_STATE;
 163         }
 164
 165         if (NULL == engine_id) {
 166                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine id is NULL");
 167                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 168                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 169                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 170         }
 171
 172         int ret = stt_config_mgr_get_engine(engine_id);
 173         if (0 != ret) {
 174                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 175         } else {
 176                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get current engine");
 177         }
 178
 179         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 180         SLOG(LOG_DEBUG, TAG_STTC, " ");
 181
 182         return ret;
 183 }
 184
 185 int stt_setting_set_engine(const char* engine_id)
 186 {
 187         SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
 188
 189         if (STT_SETTING_STATE_NONE == g_state) {
 190                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 191                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 192                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 193                 return STT_SETTING_ERROR_INVALID_STATE;
 194         }
 195
 196         if (NULL == engine_id) {
 197                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Engine id is NULL");
 198                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 199                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 200                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 201         }
 202
 203         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "New engine id : %s", engine_id);
 204
 205         int ret = stt_config_mgr_set_engine(engine_id);
 206         if (0 != ret) {
 207                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 208         } else {
 209                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set current engine");
 210         }
 211
 212         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 213         SLOG(LOG_DEBUG, TAG_STTC, " ");
 214
 215         return ret;
 216 }
 217
 218 int stt_setting_foreach_supported_languages(stt_setting_supported_language_cb callback, void* user_data)
 219 {
 220         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach supported languages");
 221
 222         if (STT_SETTING_STATE_NONE == g_state) {
 223                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 224                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 225                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 226                 return STT_SETTING_ERROR_INVALID_STATE;
 227         }
 228
 229         if (NULL == callback) {
 230                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Param is NULL");
 231                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 232                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 233                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 234         }
 235
 236         char* current_engine;
 237         int ret = stt_config_mgr_get_engine(&current_engine);
 238         if (0 != ret) {
 239                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get current engine : %d", ret);
 240                 return -1;
 241         }
 242
 243         ret = stt_config_mgr_get_language_list(current_engine, (stt_config_supported_langauge_cb)callback, user_data);
 244
 245         if (NULL != current_engine)
 246                 free(current_engine);
 247
 248         if (0 != ret) {
 249                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 250         } else {
 251                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Foreach supported languages");
 252         }
 253
 254         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 255         SLOG(LOG_DEBUG, TAG_STTC, " ");
 256
 257         return ret;
 258 }
 259
 260 int stt_setting_get_default_language(char** language)
 261 {
 262         SLOG(LOG_DEBUG, TAG_STTC, "===== Get default language");
 263
 264         if (STT_SETTING_STATE_NONE == g_state) {
 265                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 266                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 267                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 268                 return STT_SETTING_ERROR_INVALID_STATE;
 269         }
 270
 271         if (NULL == language) {
 272                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 273                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 274                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 275                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 276         }
 277
 278         int ret = stt_config_mgr_get_default_language(language);
 279         if (0 != ret) {
 280                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 281         } else {
 282                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Default language : %s", *language);
 283         }
 284
 285         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 286         SLOG(LOG_DEBUG, TAG_STTC, " ");
 287
 288         return ret;
 289 }
 290
 291 int stt_setting_set_default_language(const char* language)
 292 {
 293         SLOG(LOG_DEBUG, TAG_STTC, "===== Set default language");
 294
 295         if (STT_SETTING_STATE_NONE == g_state) {
 296                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 297                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 298                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 299                 return STT_SETTING_ERROR_INVALID_STATE;
 300         }
 301
 302         if (NULL == language) {
 303                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 304                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 305                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 306                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 307         }
 308
 309         int ret = stt_config_mgr_set_default_language(language);
 310         if (0 != ret) {
 311                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 312         } else {
 313                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set default language : %s", language);
 314         }
 315
 316         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 317         SLOG(LOG_DEBUG, TAG_STTC, " ");
 318
 319         return ret;
 320 }
 321
 322 int stt_setting_set_auto_language(bool value)
 323 {
 324         SLOG(LOG_DEBUG, TAG_STTC, "===== Set auto voice");
 325
 326         if (STT_SETTING_STATE_NONE == g_state) {
 327                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 328                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 329                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 330                 return STT_SETTING_ERROR_INVALID_STATE;
 331         }
 332
 333         if (value != true && value != false) {
 334                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value");
 335                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 336                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 337                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 338         }
 339
 340         int ret = stt_config_mgr_set_auto_language(value);
 341         if (0 != ret) {
 342                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 343         } else {
 344                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set auto language (%s)", value ? "on" : "off");
 345         }
 346
 347         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 348         SLOG(LOG_DEBUG, TAG_STTC, " ");
 349
 350         return ret;
 351 }
 352
 353 int stt_setting_get_auto_language(bool* value)
 354 {
 355         SLOG(LOG_DEBUG, TAG_STTC, "===== Get auto language");
 356
 357         if (STT_SETTING_STATE_NONE == g_state) {
 358                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Not initialized");
 359                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 360                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 361                 return STT_SETTING_ERROR_INVALID_STATE;
 362         }
 363
 364         if (NULL == value) {
 365                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Param is NULL");
 366                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 367                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 368                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 369         }
 370
 371         int ret = stt_config_mgr_get_auto_language(value);
 372         if (0 != ret) {
 373                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result : %d", ret);
 374         } else {
 375                 /* Copy value */
 376                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get auto language (%s)", *value ? "true" : "false");
 377         }
 378
 379         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 380         SLOG(LOG_DEBUG, TAG_STTC, " ");
 381
 382         return 0;
 383 }
 384
 385 int stt_setting_get_silence_detection(bool* value)
 386 {
 387         SLOG(LOG_DEBUG, TAG_STTC, "===== Get silence detection");
 388
 389         if (STT_SETTING_STATE_NONE == g_state) {
 390                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 391                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 392                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 393                 return STT_SETTING_ERROR_INVALID_STATE;
 394         }
 395
 396         if (NULL == value) {
 397                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] param is NULL");
 398                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 399                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 400                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 401         }
 402
 403         int ret = stt_config_mgr_get_silence_detection(value);
 404         if (0 != ret) {
 405                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 406         } else {
 407                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Get silence detection(%s)", *value ? "true" : "false");
 408         }
 409
 410         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 411         SLOG(LOG_DEBUG, TAG_STTC, " ");
 412
 413         return ret;
 414 }
 415
 416 int stt_setting_set_silence_detection(bool value)
 417 {
 418         SLOG(LOG_DEBUG, TAG_STTC, "===== Set silence detection");
 419
 420         if (STT_SETTING_STATE_NONE == g_state) {
 421                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] not initialized");
 422                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 423                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 424                 return STT_SETTING_ERROR_INVALID_STATE;
 425         }
 426
 427         int ret = stt_config_mgr_set_silence_detection(value);
 428         if (0 != ret) {
 429                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result (%d)", ret);
 430         } else {
 431                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set silence detection(%s)", value ? "true" : "false");
 432         }
 433
 434         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 435         SLOG(LOG_DEBUG, TAG_STTC, " ");
 436
 437         return ret;
 438 }
 439
 440 int stt_setting_set_engine_changed_cb(stt_setting_engine_changed_cb callback, void* user_data)
 441 {
 442         if (NULL == callback) {
 443                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input param is NULL");
 444                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 445         }
 446
 447         g_engine_changed_cb = callback;
 448         g_engine_changed_user_data = user_data;
 449
 450         return STT_SETTING_ERROR_NONE;
 451 }
 452
 453 int stt_setting_unset_engine_changed_cb()
 454 {
 455         g_engine_changed_cb = NULL;
 456         g_engine_changed_user_data = NULL;
 457
 458         return STT_SETTING_ERROR_NONE;
 459 }
 460
 461 int stt_setting_set_config_changed_cb(stt_setting_config_changed_cb callback, void* user_data)
 462 {
 463         if (NULL == callback) {
 464                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input param is NULL");
 465                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 466         }
 467
 468         g_config_changed_cb = callback;
 469         g_config_changed_user_data = user_data;
 470
 471         return STT_SETTING_ERROR_NONE;
 472 }
 473
 474 int stt_setting_unset_config_changed_cb()
 475 {
 476         g_config_changed_cb = NULL;
 477         g_config_changed_user_data = NULL;
 478
 479         return STT_SETTING_ERROR_NONE;
 480 }