server/sttd_engine_agent.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
  15 #include <dlfcn.h>
  16 #include <dirent.h>
  17 #include <stdatomic.h>
  18
  19 #include "stt_defs.h"
  20 #include "stt_engine.h"
  21 #include "sttd_main.h"
  22 #include "sttd_client_data.h"
  23 #include "sttd_config.h"
  24 #include "sttd_dbus.h"
  25 #include "sttd_recorder.h"
  26 #include "sttd_engine_agent.h"
  27 #include "stt_dlog.h"
  28
  29
  30 #define AUDIO_CREATE_ON_START
  31
  32 /*
  33 * Internal data structure
  34 */
  35
  36 typedef struct _sttengine_info {
  37         char*   engine_uuid;
  38         char*   engine_path;
  39         char*   engine_name;
  40         char*   engine_setting_path;
  41         bool    use_network;
  42
  43         bool    is_loaded;
  44
  45         /* engine base setting */
  46         char*   first_lang;
  47         bool    silence_detection;
  48         bool    support_silence_detection;
  49         bool    need_credential;
  50 } sttengine_info_s;
  51
  52 /** stt engine agent init */
  53 static atomic_bool g_agent_init;
  54
  55 static sttengine_info_s* g_engine_info = NULL;
  56
  57 /** default engine info */
  58 static char*    g_default_language = NULL;
  59 static bool     g_default_silence_detected;
  60
  61 /** callback functions */
  62 static _Atomic result_callback g_result_cb = NULL;
  63 static _Atomic result_time_callback g_result_time_cb = NULL;
  64 static _Atomic speech_status_callback g_speech_status_cb = NULL;
  65 static _Atomic error_callback g_error_cb = NULL;
  66
  67 /** callback functions */
  68 static bool __result_time_cb(int index, stte_result_time_event_e event, const char* text,
  69                       long start_time, long end_time, void* user_data);
  70
  71 /*
  72 * Internal Interfaces
  73 */
  74
  75 /** get engine info */
  76 static int __internal_get_engine_info(stte_request_callback_s *callback, sttengine_info_s** info);
  77
  78 static int __log_enginelist();
  79
  80 /*
  81 * STT Engine Agent Interfaces
  82 */
  83 int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb,
  84                            speech_status_callback speech_status_cb, error_callback error_cb)
  85 {
  86         /* initialize static data */
  87         if (NULL == result_cb || NULL == time_cb || NULL == speech_status_cb || NULL == error_cb) {
  88                 SLOG(LOG_ERROR, TAG_STTD, "[Engine agent ERROR] Invalid parameter");
  89                 return STTD_ERROR_INVALID_PARAMETER;
  90         }
  91
  92         g_result_cb = result_cb;
  93         g_result_time_cb = time_cb;
  94         g_speech_status_cb = speech_status_cb;
  95         g_error_cb = error_cb;
  96
  97         g_default_language = NULL;
  98
  99         if (0 != sttd_config_get_default_language(&(g_default_language))) {
 100                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is No default voice in config");
 101                 /* Set default voice */
 102                 g_default_language = strdup("en_US");
 103         } else {
 104                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default language is %s", g_default_language);
 105         }
 106
 107         int temp;
 108         if (0 != sttd_config_get_default_silence_detection(&temp)) {
 109                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no silence detection in config");
 110                 g_default_silence_detected = true;
 111         } else {
 112                 g_default_silence_detected = (bool)temp;
 113         }
 114
 115         g_agent_init = true;
 116
 117         return 0;
 118 }
 119
 120 int __engine_agent_clear_engine(sttengine_info_s *engine)
 121 {
 122         if (NULL != engine) {
 123                 if (NULL != engine->engine_uuid)        free(engine->engine_uuid);
 124                 if (NULL != engine->engine_path)        free(engine->engine_path);
 125                 if (NULL != engine->engine_name)        free(engine->engine_name);
 126                 if (NULL != engine->engine_setting_path)free(engine->engine_setting_path);
 127                 if (NULL != engine->first_lang)         free(engine->first_lang);
 128
 129                 free(engine);
 130                 engine = NULL;
 131         }
 132
 133         return 0;
 134 }
 135
 136 int sttd_engine_agent_release()
 137 {
 138         if (NULL != g_engine_info) {
 139                 if (g_engine_info->is_loaded) {
 140                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine");
 141
 142                         if (0 != stt_engine_deinitialize()) {
 143                                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize");
 144                         }
 145
 146                         if (0 != stt_engine_unload()) {
 147                                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine");
 148                         }
 149
 150                         if (NULL != g_engine_info->engine_uuid) {
 151                                 free(g_engine_info->engine_uuid);
 152                                 g_engine_info->engine_uuid = NULL;
 153                         }
 154
 155                         if (NULL != g_engine_info->engine_path) {
 156                                 free(g_engine_info->engine_path);
 157                                 g_engine_info->engine_path = NULL;
 158                         }
 159
 160                         if (NULL != g_engine_info->engine_name) {
 161                                 free(g_engine_info->engine_name);
 162                                 g_engine_info->engine_name = NULL;
 163                         }
 164
 165                         if (NULL != g_engine_info->engine_setting_path) {
 166                                 free(g_engine_info->engine_setting_path);
 167                                 g_engine_info->engine_setting_path = NULL;
 168                         }
 169
 170                         if (NULL != g_engine_info->first_lang) {
 171                                 free(g_engine_info->first_lang);
 172                                 g_engine_info->first_lang = NULL;
 173                         }
 174
 175                         g_engine_info->is_loaded = false;
 176                 }
 177
 178                 __engine_agent_clear_engine(g_engine_info);
 179         }
 180
 181         g_agent_init = false;
 182
 183         g_result_cb = NULL;
 184         g_speech_status_cb = NULL;
 185         g_error_cb = NULL;
 186         g_result_time_cb = NULL;
 187
 188         return 0;
 189 }
 190
 191 static int __internal_get_engine_info(stte_request_callback_s *callback, sttengine_info_s** info)
 192 {
 193         sttengine_info_s* temp;
 194         temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s));
 195         if (NULL == temp) {
 196                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] fail to allocate memory");
 197                 return STTD_ERROR_OUT_OF_MEMORY;
 198         }
 199
 200         if (NULL == callback) {
 201                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid engine");
 202                 free(temp);
 203                 return STTD_ERROR_ENGINE_NOT_FOUND;
 204         }
 205
 206         if (NULL == callback->get_info) {
 207                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid engine");
 208                 free(temp);
 209                 return STTD_ERROR_ENGINE_NOT_FOUND;
 210         }
 211
 212         if (0 != callback->get_info(&(temp->engine_uuid), &(temp->engine_name), &(temp->engine_setting_path), &(temp->use_network))) {
 213                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info");
 214                 free(temp);
 215                 return STTD_ERROR_ENGINE_NOT_FOUND;
 216         }
 217
 218         /* todo - removed? */
 219         temp->engine_path = strdup("empty");
 220         temp->is_loaded = false;
 221
 222         SLOG(LOG_DEBUG, TAG_STTD, "----- Valid Engine");
 223         SLOG(LOG_DEBUG, TAG_STTD, "Engine uuid : %s", (NULL == temp->engine_uuid) ? "NULL" : temp->engine_uuid);
 224         SLOG(LOG_DEBUG, TAG_STTD, "Engine name : %s", (NULL == temp->engine_name) ? "NULL" : temp->engine_name);
 225         SLOG(LOG_DEBUG, TAG_STTD, "Engine path : %s", (NULL == temp->engine_path) ? "NULL" : temp->engine_path);
 226         SLOG(LOG_DEBUG, TAG_STTD, "Engine setting path : %s", (NULL == temp->engine_setting_path) ? "NULL" : temp->engine_setting_path);
 227         SLOG(LOG_DEBUG, TAG_STTD, "Use network : %s", temp->use_network ? "true" : "false");
 228         SLOG(LOG_DEBUG, TAG_STTD, "-----");
 229         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 230
 231         *info = temp;
 232
 233         return STTD_ERROR_NONE;
 234 }
 235
 236 bool __is_engine(const char* filepath)
 237 {
 238         if (NULL == filepath) {
 239                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No filepath");
 240                 return false;
 241         }
 242
 243         if (NULL != g_engine_info) {
 244                 if (!strcmp(g_engine_info->engine_path, filepath)) {
 245                         return true;
 246                 }
 247         }
 248
 249         return false;
 250 }
 251
 252 int __engine_agent_check_engine_unload()
 253 {
 254         /* Check the count of client to use this engine */
 255         if (NULL == g_engine_info) {
 256                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No engine");
 257         } else {
 258                 if (g_engine_info->is_loaded) {
 259                         /* unload engine */
 260 #ifndef AUDIO_CREATE_ON_START
 261                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 262                         if (0 != sttd_recorder_destroy())
 263                                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 264 #endif
 265                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine");
 266                         if (0 != stt_engine_deinitialize())
 267                                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine");
 268
 269                         if (0 != stt_engine_unload())
 270                                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine");
 271
 272                         g_engine_info->is_loaded = false;
 273                 }
 274         }
 275
 276         return 0;
 277 }
 278
 279 int sttd_engine_agent_load_current_engine(stte_request_callback_s *callback)
 280 {
 281         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 282
 283         /* Get current engine info */
 284         sttengine_info_s* info;
 285         int ret = __internal_get_engine_info(callback, &info);
 286         if (0 != ret) {
 287                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info");
 288                 return ret;
 289         } else {
 290                 g_engine_info = info;
 291         }
 292
 293         __log_enginelist();
 294
 295         /* Set default engine */
 296         char* cur_engine_uuid = NULL;
 297         bool is_default_engine = false;
 298
 299         /* get current engine from config */
 300         if (0 == sttd_config_get_default_engine(&cur_engine_uuid)) {
 301                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid);
 302                 if (NULL != g_engine_info->engine_uuid && NULL != cur_engine_uuid) {
 303                         if (!strcmp(g_engine_info->engine_uuid, cur_engine_uuid)) {
 304                                 is_default_engine = true;
 305                         }
 306                 }
 307                 if (NULL != cur_engine_uuid) {
 308                         free(cur_engine_uuid);
 309                         cur_engine_uuid = NULL;
 310                 }
 311         } else {
 312                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is not current engine from config");
 313         }
 314
 315         if (false == is_default_engine) {
 316                 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
 317         } else {
 318                 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is Default engine");
 319         }
 320
 321         /* Load engine */
 322         ret = stt_engine_load(g_engine_info->engine_path, callback);
 323         if (0 != ret) {
 324                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : path(%s)", g_engine_info->engine_path);
 325                 return ret;
 326         }
 327
 328         ret = stt_engine_initialize(false);
 329         if (0 != ret) {
 330                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : path(%s)", g_engine_info->engine_path);
 331                 return ret;
 332         }
 333
 334         ret = stt_engine_set_silence_detection(g_default_silence_detected);
 335         if (0 != ret) {
 336                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Not support silence detection");
 337                 g_engine_info->support_silence_detection = false;
 338         } else {
 339                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Silence detection : %s", g_default_silence_detected ? "true" : "false");
 340                 g_engine_info->support_silence_detection = true;
 341                 g_engine_info->silence_detection = g_default_silence_detected;
 342         }
 343
 344         /* Set first language */
 345         char* tmp_lang = NULL;
 346         ret = stt_engine_get_first_language(&tmp_lang);
 347         if (0 == ret && NULL != tmp_lang) {
 348                 g_engine_info->first_lang = strdup(tmp_lang);
 349                 free(tmp_lang);
 350         } else {
 351                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %s", g_engine_info->engine_name);
 352                 return ret;
 353         }
 354
 355 #ifndef AUDIO_CREATE_ON_START
 356         /* Ready recorder */
 357         stte_audio_type_e atype;
 358         int rate;
 359         int channels;
 360
 361         ret = stt_engine_get_audio_format(&atype, &rate, &channels);
 362         if (0 != ret) {
 363                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", g_engine_info->engine_name);
 364                 return ret;
 365         }
 366
 367         ret = sttd_recorder_create(atype, channels, rate);
 368         if (0 != ret) {
 369                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
 370                 return ret;
 371         }
 372 #endif
 373
 374         g_engine_info->is_loaded = true;
 375         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_engine_info->engine_name);
 376
 377         return 0;
 378 }
 379
 380 int sttd_engine_agent_unload_current_engine()
 381 {
 382         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 383
 384         /* Remove client */
 385         __engine_agent_check_engine_unload();
 386
 387         return 0;
 388 }
 389
 390 bool sttd_engine_agent_is_default_engine()
 391 {
 392                 return true;
 393 }
 394
 395 int sttd_engine_agent_get_engine_list(GSList** engine_list)
 396 {
 397         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 398
 399         SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------");
 400
 401         return 0;
 402 }
 403
 404 static int __sttd_engine_agent_check_precondition()
 405 {
 406         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 407         RETVM_IF(NULL == g_engine_info, STTD_ERROR_INVALID_PARAMETER, "[Engine Agent ERROR] The engine is not valid");
 408         RETVM_IF(false == g_engine_info->is_loaded, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not loaded engine");
 409         return STTD_ERROR_NONE;
 410 }
 411
 412 int sttd_engine_agent_get_current_engine(char** engine_uuid)
 413 {
 414         RETVM_IF(NULL == engine_uuid, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Invalid parameter");
 415         int tmp = __sttd_engine_agent_check_precondition();
 416         if (STTD_ERROR_NONE != tmp)
 417                 return tmp;
 418
 419         *engine_uuid = strdup(g_engine_info->engine_uuid);
 420
 421         return 0;
 422 }
 423
 424 bool sttd_engine_agent_need_network()
 425 {
 426         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 427         if (NULL != g_engine_info)
 428                 return g_engine_info->use_network;
 429
 430         return false;
 431 }
 432
 433 int sttd_engine_agent_supported_langs(GSList** lang_list)
 434 {
 435         RETVM_IF(NULL == lang_list, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 436         int tmp = __sttd_engine_agent_check_precondition();
 437         if (STTD_ERROR_NONE != tmp)
 438                 return tmp;
 439
 440         int ret = stt_engine_get_supported_langs(lang_list);
 441         if (0 != ret) {
 442                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret);
 443         }
 444
 445         return ret;
 446 }
 447
 448 int sttd_engine_agent_get_default_lang(char** lang)
 449 {
 450         RETVM_IF(NULL == lang, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 451         int tmp = __sttd_engine_agent_check_precondition();
 452         if (STTD_ERROR_NONE != tmp)
 453                 return tmp;
 454
 455         /* get default language */
 456         bool is_valid = false;
 457         if (0 != stt_engine_is_valid_language(g_default_language, &is_valid)) {
 458                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
 459                 return STTD_ERROR_OPERATION_FAILED;
 460         }
 461
 462         if (true == is_valid) {
 463                 *lang = strdup(g_default_language);
 464         } else
 465                 *lang = strdup(g_engine_info->first_lang);
 466
 467         return 0;
 468 }
 469
 470 int sttd_engine_agent_set_private_data(const char* key, const char* data)
 471 {
 472         RETVM_IF(NULL == key || NULL == data, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 473         int tmp = __sttd_engine_agent_check_precondition();
 474         if (STTD_ERROR_NONE != tmp)
 475                 return tmp;
 476
 477         /* set private data */
 478         int ret = -1;
 479         ret = stt_engine_set_private_data(key, data);
 480         if (0 != ret) {
 481                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set private data");
 482         }
 483
 484         return ret;
 485 }
 486
 487 int sttd_engine_agent_get_private_data(const char* key, char** data)
 488 {
 489         RETVM_IF(NULL == key || NULL == data, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 490         int tmp = __sttd_engine_agent_check_precondition();
 491         if (STTD_ERROR_NONE != tmp)
 492                 return tmp;
 493
 494         /* get default language */
 495         int ret = -1;
 496         ret = stt_engine_get_private_data(key, data);
 497         if (0 != ret) {
 498                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get private data");
 499         }
 500
 501         return ret;
 502 }
 503
 504 int sttd_engine_agent_get_option_supported(bool* silence)
 505 {
 506         RETVM_IF(NULL == silence, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 507         int tmp = __sttd_engine_agent_check_precondition();
 508         if (STTD_ERROR_NONE != tmp)
 509                 return tmp;
 510
 511         bool temp = false;
 512         if (0 != stt_engine_support_silence(&temp)) {
 513                 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Fail to get support silence");
 514         }
 515
 516         *silence = g_engine_info->support_silence_detection;
 517         if (temp != *silence) {
 518                 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Metadata and Engine spec are different (engine:%d) (meta:%d)", temp, *silence);
 519         }
 520
 521         return 0;
 522 }
 523
 524 int sttd_engine_agent_is_credential_needed(unsigned int uid, bool* credential)
 525 {
 526         RETVM_IF(NULL == credential, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 527         int tmp = __sttd_engine_agent_check_precondition();
 528         if (STTD_ERROR_NONE != tmp)
 529                 return tmp;
 530
 531         bool temp = false;
 532         int ret;
 533
 534         ret = stt_engine_need_app_credential(&temp);
 535         if (0 != ret) {
 536                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
 537                 return ret;
 538         }
 539
 540         *credential = temp;
 541         return 0;
 542 }
 543
 544 int sttd_engine_agent_is_recognition_type_supported(const char* type, bool* support)
 545 {
 546         RETVM_IF(NULL == type || NULL == support, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 547         int tmp = __sttd_engine_agent_check_precondition();
 548         if (STTD_ERROR_NONE != tmp)
 549                 return tmp;
 550
 551         bool temp = false;
 552         int ret;
 553
 554         ret = stt_engine_support_recognition_type(type, &temp);
 555         if (0 != ret) {
 556                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
 557                 return ret;
 558         }
 559
 560         *support = temp;
 561
 562         return 0;
 563 }
 564
 565 /*
 566 * STT Engine Interfaces for client
 567 */
 568
 569 int __set_option(sttengine_info_s* engine, int silence)
 570 {
 571         if (NULL == engine)
 572                 return -1;
 573
 574         /* Check silence detection */
 575         if (engine->support_silence_detection) {
 576                 if (2 == silence) {
 577                         /* default option set */
 578 //                      if (g_default_silence_detected != engine->silence_detection) {
 579                                 if (0 != stt_engine_set_silence_detection(g_default_silence_detected)) {
 580                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false");
 581                                 } else {
 582                                         engine->silence_detection = g_default_silence_detected;
 583                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false");
 584                                 }
 585 //                      }
 586                 } else {
 587                         if (silence != engine->silence_detection) {
 588                                 if (0 != stt_engine_set_silence_detection(silence)) {
 589                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false");
 590                                 } else {
 591                                         engine->silence_detection = silence;
 592                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false");
 593                                 }
 594                         }
 595                 }
 596         }
 597
 598         return 0;
 599 }
 600
 601 int sttd_engine_agent_recognize_start_engine(unsigned int uid, const char* lang, const char* recognition_type,
 602                                       int silence, const char* appid, const char* credential, void* user_param)
 603 {
 604         RETVM_IF(NULL == lang || NULL == recognition_type, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 605         int tmp = __sttd_engine_agent_check_precondition();
 606         if (STTD_ERROR_NONE != tmp)
 607                 return tmp;
 608
 609         if (0 != __set_option(g_engine_info, silence)) {
 610                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options");
 611                 return STTD_ERROR_OPERATION_FAILED;
 612         }
 613
 614         SLOG(LOG_INFO, TAG_STTD, "g_default_language %s", g_default_language);
 615
 616         int ret;
 617         char* temp = NULL;
 618         if (0 == strncmp(lang, "default", strlen("default"))) {
 619                 bool is_valid = false;
 620                 ret = stt_engine_is_valid_language(g_default_language, &is_valid);
 621                 if (0 != ret) {
 622                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
 623                         return ret;
 624                 }
 625
 626                 if (true == is_valid) {
 627                         temp = strdup(g_default_language);
 628                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp);
 629                 } else {
 630                         temp = strdup(g_engine_info->first_lang);
 631                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp);
 632                 }
 633         } else {
 634                 temp = strdup(lang);
 635         }
 636
 637         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start engine");
 638
 639         ret = stt_engine_recognize_start(temp, recognition_type, appid, credential, user_param);
 640         if (NULL != temp)       free(temp);
 641         if (0 != ret) {
 642                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
 643                 return ret;
 644         }
 645
 646 #ifdef AUDIO_CREATE_ON_START
 647         /* Ready recorder */
 648         stte_audio_type_e atype;
 649         int rate;
 650         int channels;
 651
 652         ret = stt_engine_get_audio_format(&atype, &rate, &channels);
 653         if (0 != ret) {
 654                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio format : %s", g_engine_info->engine_name);
 655                 return ret;
 656         }
 657
 658         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Create recorder");
 659
 660         ret = sttd_recorder_create(atype, channels, rate);
 661         if (0 != ret) {
 662                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create format : %s", g_engine_info->engine_name);
 663                 return ret;
 664         }
 665 #endif
 666
 667 #if 0
 668         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder(%d)", uid);
 669
 670         ret = sttd_recorder_start(uid);
 671         if (0 != ret) {
 672                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 673                 return ret;
 674         }
 675
 676 #endif
 677
 678         return 0;
 679 }
 680
 681 int sttd_engine_agent_recognize_start_recorder(unsigned int uid, const char* appid)
 682 {
 683         int tmp = __sttd_engine_agent_check_precondition();
 684         if (STTD_ERROR_NONE != tmp)
 685                 return tmp;
 686
 687         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 688
 689         int ret;
 690         ret = sttd_recorder_start(uid, appid);
 691         if (0 != ret) {
 692                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 693                 stt_engine_recognize_cancel();
 694                 sttd_recorder_stop();
 695                 return ret;
 696         }
 697
 698         return 0;
 699 }
 700
 701 int sttd_engine_agent_recognize_start_file(unsigned int uid, const char* filepath)
 702 {
 703         int tmp = __sttd_engine_agent_check_precondition();
 704         if (STTD_ERROR_NONE != tmp)
 705                 return tmp;
 706
 707         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 708
 709         int ret;
 710         ret = sttd_recorder_start_file(uid, filepath);
 711         if (0 != ret) {
 712                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 713                 stt_engine_recognize_cancel();
 714                 sttd_recorder_stop_file();
 715                 return ret;
 716         }
 717
 718         return 0;
 719 }
 720
 721 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
 722 {
 723         RETVM_IF(NULL == data || 0 == length, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 724         int tmp = __sttd_engine_agent_check_precondition();
 725         if (STTD_ERROR_NONE != tmp)
 726                 return tmp;
 727
 728         int ret = stt_engine_set_recording_data(data, length);
 729         if (0 != ret) {
 730                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
 731         }
 732
 733         return ret;
 734 }
 735
 736 int sttd_engine_agent_recognize_stop_file()
 737 {
 738         int tmp = __sttd_engine_agent_check_precondition();
 739         if (STTD_ERROR_NONE != tmp)
 740                 return tmp;
 741
 742         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 743         int ret;
 744         ret = sttd_recorder_stop_file();
 745         if (0 != ret) {
 746                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 747                 return ret;
 748         }
 749
 750 #ifdef AUDIO_CREATE_ON_START
 751         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
 752         if (0 != sttd_recorder_destroy())
 753                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 754 #endif
 755
 756         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
 757         return 0;
 758 }
 759
 760 int sttd_engine_agent_recognize_stop_recorder()
 761 {
 762         int tmp = __sttd_engine_agent_check_precondition();
 763         if (STTD_ERROR_NONE != tmp)
 764                 return tmp;
 765
 766         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 767         int ret;
 768         ret = sttd_recorder_stop();
 769         if (0 != ret) {
 770                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 771                 return ret;
 772         }
 773
 774 #ifdef AUDIO_CREATE_ON_START
 775         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 776         if (0 != sttd_recorder_destroy())
 777                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 778 #endif
 779
 780         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
 781         return 0;
 782 }
 783
 784 int sttd_engine_agent_recognize_stop_engine()
 785 {
 786         int tmp = __sttd_engine_agent_check_precondition();
 787         if (STTD_ERROR_NONE != tmp)
 788                 return tmp;
 789
 790         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop engine");
 791
 792         int ret;
 793         ret = stt_engine_recognize_stop();
 794         if (0 != ret) {
 795                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
 796                 return ret;
 797         }
 798
 799         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop engine");
 800
 801         return 0;
 802 }
 803
 804 int sttd_engine_agent_recognize_cancel()
 805 {
 806         int tmp = __sttd_engine_agent_check_precondition();
 807         if (STTD_ERROR_NONE != tmp)
 808                 return tmp;
 809
 810         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Cancel engine");
 811
 812         int ret;
 813         ret = stt_engine_recognize_cancel();
 814         if (0 != ret) {
 815                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
 816                 return ret;
 817         }
 818
 819         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 820
 821         ret = sttd_recorder_stop();
 822         if (0 != ret) {
 823                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 824                 return ret;
 825         }
 826
 827 #ifdef AUDIO_CREATE_ON_START
 828         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
 829         if (0 != sttd_recorder_destroy())
 830                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 831 #endif
 832
 833         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Cancel recognition");
 834
 835         return 0;
 836 }
 837
 838
 839 /*
 840 * STT Engine Interfaces for configure
 841 */
 842
 843 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
 844 {
 845         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 846         RETVM_IF(NULL == engine_uuid, STTD_ERROR_INVALID_PARAMETER, "[Engine Agent ERROR] Invalid Parameter");
 847
 848         __log_enginelist();
 849
 850         RETVM_IF(NULL == g_engine_info, STTD_ERROR_INVALID_PARAMETER, "[Engine Agent ERROR] The Default engine is not valid");
 851
 852         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
 853
 854         return 0;
 855 }
 856
 857 int sttd_engine_agent_set_default_language(const char* language)
 858 {
 859         RETVM_IF(NULL == language, STTD_ERROR_INVALID_PARAMETER,  "[Engine Agent ERROR] Input parameter");
 860         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 861
 862         if (NULL != g_default_language)
 863                 free(g_default_language);
 864
 865         g_default_language = strdup(language);
 866
 867         return 0;
 868 }
 869
 870 int sttd_engine_agent_set_silence_detection(bool value)
 871 {
 872         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 873
 874         g_default_silence_detected = value;
 875
 876         return 0;
 877 }
 878
 879 int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
 880 {
 881         int tmp = __sttd_engine_agent_check_precondition();
 882         if (STTD_ERROR_NONE != tmp)
 883                 return tmp;
 884
 885         int ret;
 886         ret = stt_engine_check_app_agreed(appid, result);
 887         if (0 != ret) {
 888                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
 889                 return ret;
 890         }
 891
 892
 893         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
 894         return 0;
 895 }
 896
 897 static void __recorder_destroy_by_error_result(void *data)
 898 {
 899         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
 900         if (0 != sttd_recorder_destroy())
 901                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 902
 903         return;
 904 }
 905
 906 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
 907                  const char* msg, void* time_info, void *user_data)
 908 {
 909         int ret = -1;
 910         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 911
 912         SLOG(LOG_INFO, TAG_STTD, "[Server] === Result time callback ===");
 913
 914         if (NULL != time_info) {
 915                 /* Get the time info */
 916                 ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
 917                 if (0 != ret) {
 918                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
 919                         return ret;
 920                 }
 921         }
 922
 923         SLOG(LOG_INFO, TAG_STTD, "[Server] ============================");
 924
 925         RETVM_IF(NULL == g_result_cb, STTD_ERROR_OPERATION_FAILED, "[Server ERROR] Callback is not set.");
 926
 927         ret = g_result_cb(event, type, result, result_count, msg, user_data);
 928
 929 #ifdef AUDIO_CREATE_ON_START
 930         if (event == STTE_RESULT_EVENT_ERROR) {
 931                 ecore_main_loop_thread_safe_call_async(__recorder_destroy_by_error_result, NULL);
 932         }
 933 #endif
 934
 935         return ret;
 936 }
 937
 938 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
 939 {
 940         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 941
 942         /* check uid */
 943         unsigned int uid = stt_client_get_current_recognition();
 944
 945         int ret = sttdc_send_error_signal(uid, error, msg);
 946         if (0 != ret) {
 947                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info. (%d/%s)", ret, get_error_message(ret));
 948         }
 949
 950         RETVM_IF(NULL == g_error_cb, STTD_ERROR_OPERATION_FAILED, "[Server ERROR] Callback is not set.");
 951
 952         return g_error_cb(error, msg);
 953 }
 954
 955 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
 956 {
 957         RETVM_IF(false == g_agent_init, STTD_ERROR_OPERATION_FAILED, "[Engine Agent ERROR] Not Initialized");
 958         RETVM_IF(NULL == g_speech_status_cb, STTD_ERROR_OPERATION_FAILED, "[Server ERROR] Callback is not set.");
 959
 960         return g_speech_status_cb(status, user_data);
 961 }
 962
 963 static bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
 964 {
 965         RETVM_IF(false == g_agent_init, false, "[Engine Agent ERROR] Not Initialized");
 966         RETVM_IF(NULL == g_result_time_cb, false, "[Server ERROR] Callback is not set.");
 967
 968         return g_result_time_cb(index, event, text, start_time, end_time, user_data);
 969 }
 970
 971 /* A function forging */
 972 static int __log_enginelist()
 973 {
 974         if (NULL != g_engine_info) {
 975                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
 976                 SLOG(LOG_DEBUG, TAG_STTD, "engine uuid : %s", g_engine_info->engine_uuid);
 977                 SLOG(LOG_DEBUG, TAG_STTD, "engine name : %s", g_engine_info->engine_name);
 978                 SLOG(LOG_DEBUG, TAG_STTD, "engine path : %s", g_engine_info->engine_path);
 979                 SLOG(LOG_DEBUG, TAG_STTD, "use network : %s", g_engine_info->use_network ? "true" : "false");
 980                 SLOG(LOG_DEBUG, TAG_STTD, "is loaded   : %s", g_engine_info->is_loaded ? "true" : "false");
 981                 if (NULL != g_engine_info->first_lang) {
 982                         SLOG(LOG_DEBUG, TAG_STTD, "default lang : %s", g_engine_info->first_lang);
 983                 }
 984                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
 985         } else {
 986                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
 987                 SLOG(LOG_DEBUG, TAG_STTD, "     No engine");
 988                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
 989         }
 990
 991         return 0;
 992 }
 993
 994 int sttd_engine_agent_get_audio_type(char** audio_type)
 995 {
 996         int tmp = __sttd_engine_agent_check_precondition();
 997         if (STTD_ERROR_NONE != tmp)
 998                 return tmp;
 999
1000         SLOG(LOG_INFO, TAG_STTD, "[Server Info] Get audio type");
1001
1002         int ret = stt_engine_get_audio_type(audio_type);
1003         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent] get audio type(%s). ret(%d)", *audio_type, ret);
1004
1005         return ret;
1006 }
1007
1008 int sttd_engine_agent_set_audio_type(const char* audio_type)
1009 {
1010         int tmp = __sttd_engine_agent_check_precondition();
1011         if (STTD_ERROR_NONE != tmp)
1012                 return tmp;
1013
1014         SLOG(LOG_INFO, TAG_STTD, "[Server Info] Set audio type(%s)", audio_type);
1015
1016         int ret = stt_engine_set_audio_type(audio_type);
1017         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent] set audio type(%d)", ret);
1018
1019         return ret;
1020 }