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