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
  18 #include "stt_defs.h"
  19 #include "stt_engine.h"
  20 #include "sttd_main.h"
  21 #include "sttd_client_data.h"
  22 #include "sttd_config.h"
  23 #include "sttd_dbus.h"
  24 #include "sttd_recorder.h"
  25 #include "sttd_engine_agent.h"
  26
  27
  28 #define AUDIO_CREATE_ON_START
  29
  30 /*
  31 * Internal data structure
  32 */
  33
  34 typedef struct _sttengine_info {
  35         char*   engine_uuid;
  36         char*   engine_path;
  37         char*   engine_name;
  38         char*   engine_setting_path;
  39         bool    use_network;
  40
  41         bool    is_loaded;
  42
  43         /* engine base setting */
  44         char*   first_lang;
  45         bool    silence_detection;
  46         bool    support_silence_detection;
  47         bool    need_credential;
  48 } sttengine_info_s;
  49
  50 /** stt engine agent init */
  51 static bool     g_agent_init;
  52
  53 static sttengine_info_s* g_engine_info = NULL;
  54
  55 /** default engine info */
  56 static char*    g_default_language = NULL;
  57 static bool     g_default_silence_detected;
  58
  59 /** callback functions */
  60 static result_callback g_result_cb = NULL;
  61 static result_time_callback g_result_time_cb = NULL;
  62 static speech_status_callback g_speech_status_cb = NULL;
  63 static error_callback g_error_cb = NULL;
  64
  65 /** callback functions */
  66 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text,
  67                       long start_time, long end_time, void* user_data);
  68
  69 bool __supported_language_cb(const char* language, void* user_data);
  70
  71 /*
  72 * Internal Interfaces
  73 */
  74
  75 /** get engine info */
  76 int __internal_get_engine_info(stte_request_callback_s *callback, sttengine_info_s** info);
  77
  78 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_result_cb = NULL;
 182         g_speech_status_cb = NULL;
 183         g_error_cb = NULL;
 184         g_result_time_cb = NULL;
 185
 186         g_agent_init = false;
 187
 188         return 0;
 189 }
 190
 191 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         if (false == g_agent_init) {
 282                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 283                 return STTD_ERROR_OPERATION_FAILED;
 284         }
 285
 286         /* Get current engine info */
 287         sttengine_info_s* info;
 288         int ret = __internal_get_engine_info(callback, &info);
 289         if (0 != ret) {
 290                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info");
 291                 return ret;
 292         } else {
 293                 g_engine_info = info;
 294         }
 295
 296         __log_enginelist();
 297
 298         /* Set default engine */
 299         char* cur_engine_uuid = NULL;
 300         bool is_default_engine = false;
 301
 302         /* get current engine from config */
 303         if (0 == sttd_config_get_default_engine(&cur_engine_uuid)) {
 304                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid);
 305                 if (NULL != g_engine_info->engine_uuid) {
 306                         if (!strcmp(g_engine_info->engine_uuid, cur_engine_uuid)) {
 307                                 is_default_engine = true;
 308                         }
 309                 }
 310                 if (NULL != cur_engine_uuid) {
 311                         free(cur_engine_uuid);
 312                         cur_engine_uuid = NULL;
 313                 }
 314         } else {
 315                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is not current engine from config");
 316         }
 317
 318         if (false == is_default_engine) {
 319                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
 320         } else {
 321                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current engine is Default engine");
 322         }
 323
 324         /* Load engine */
 325         ret = stt_engine_load(g_engine_info->engine_path, callback);
 326         if (0 != ret) {
 327                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : path(%s)", g_engine_info->engine_path);
 328                 return ret;
 329         }
 330
 331         ret = stt_engine_initialize(false);
 332         if (0 != ret) {
 333                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : path(%s)", g_engine_info->engine_path);
 334                 return ret;
 335         }
 336
 337         ret = stt_engine_set_silence_detection(g_default_silence_detected);
 338         if (0 != ret) {
 339                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Not support silence detection");
 340                 g_engine_info->support_silence_detection = false;
 341         } else {
 342                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Silence detection : %s", g_default_silence_detected ? "true" : "false");
 343                 g_engine_info->support_silence_detection = true;
 344                 g_engine_info->silence_detection = g_default_silence_detected;
 345         }
 346
 347         /* Set first language */
 348         char* tmp_lang = NULL;
 349         ret = stt_engine_get_first_language(&tmp_lang);
 350         if (0 == ret && NULL != tmp_lang) {
 351                 g_engine_info->first_lang = strdup(tmp_lang);
 352                 free(tmp_lang);
 353         } else {
 354                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %s", g_engine_info->engine_name);
 355                 return ret;
 356         }
 357
 358 #ifndef AUDIO_CREATE_ON_START
 359         /* Ready recorder */
 360         stte_audio_type_e atype;
 361         int rate;
 362         int channels;
 363
 364         ret = stt_engine_get_audio_type(&atype, &rate, &channels);
 365         if (0 != ret) {
 366                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", g_engine_info->engine_name);
 367                 return ret;
 368         }
 369
 370         ret = sttd_recorder_create(atype, channels, rate);
 371         if (0 != ret) {
 372                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
 373                 return ret;
 374         }
 375 #endif
 376
 377         g_engine_info->is_loaded = true;
 378         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_engine_info->engine_name);
 379
 380         return 0;
 381 }
 382
 383 int sttd_engine_agent_unload_current_engine()
 384 {
 385         if (false == g_agent_init) {
 386                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized ");
 387                 return STTD_ERROR_OPERATION_FAILED;
 388         }
 389
 390         /* Remove client */
 391         __engine_agent_check_engine_unload();
 392
 393         return 0;
 394 }
 395
 396 bool sttd_engine_agent_is_default_engine()
 397 {
 398                 return true;
 399 }
 400
 401 int sttd_engine_agent_get_engine_list(GSList** engine_list)
 402 {
 403         if (false == g_agent_init) {
 404                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 405                 return STTD_ERROR_OPERATION_FAILED;
 406         }
 407
 408         SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------");
 409
 410         return 0;
 411 }
 412
 413 int sttd_engine_agent_get_current_engine(char** engine_uuid)
 414 {
 415         if (false == g_agent_init) {
 416                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 417                 return STTD_ERROR_OPERATION_FAILED;
 418         }
 419
 420         if (NULL == engine_uuid) {
 421                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid parameter");
 422                 return STTD_ERROR_INVALID_PARAMETER;
 423         }
 424
 425         if (NULL == g_engine_info) {
 426                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 427                 return STTD_ERROR_INVALID_PARAMETER;
 428         }
 429
 430         if (false == g_engine_info->is_loaded) {
 431                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 432                 return STTD_ERROR_OPERATION_FAILED;
 433         }
 434
 435         *engine_uuid = strdup(g_engine_info->engine_uuid);
 436
 437         return 0;
 438 }
 439
 440 bool sttd_engine_agent_need_network()
 441 {
 442         if (false == g_agent_init) {
 443                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 444                 return STTD_ERROR_OPERATION_FAILED;
 445         }
 446
 447         if (NULL != g_engine_info)
 448                 return g_engine_info->use_network;
 449
 450         return false;
 451 }
 452
 453 int sttd_engine_agent_supported_langs(GSList** lang_list)
 454 {
 455         if (false == g_agent_init) {
 456                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 457                 return STTD_ERROR_OPERATION_FAILED;
 458         }
 459
 460         if (NULL == lang_list) {
 461                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL");
 462                 return STTD_ERROR_INVALID_PARAMETER;
 463         }
 464
 465         if (NULL == g_engine_info) {
 466                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 467                 return STTD_ERROR_INVALID_PARAMETER;
 468         }
 469
 470         if (false == g_engine_info->is_loaded) {
 471                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 472                 return STTD_ERROR_OPERATION_FAILED;
 473         }
 474
 475         int ret = stt_engine_get_supported_langs(lang_list);
 476         if (0 != ret) {
 477                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret);
 478         }
 479
 480         return ret;
 481 }
 482
 483 int sttd_engine_agent_get_default_lang(char** lang)
 484 {
 485         if (false == g_agent_init) {
 486                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 487                 return STTD_ERROR_OPERATION_FAILED;
 488         }
 489
 490         if (NULL == lang) {
 491                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 492                 return STTD_ERROR_INVALID_PARAMETER;
 493         }
 494
 495         if (NULL == g_engine_info) {
 496                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 497                 return STTD_ERROR_INVALID_PARAMETER;
 498         }
 499
 500         if (false == g_engine_info->is_loaded) {
 501                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 502                 return STTD_ERROR_OPERATION_FAILED;
 503         }
 504
 505         /* get default language */
 506         bool is_valid = false;
 507         if (0 != stt_engine_is_valid_language(g_default_language, &is_valid)) {
 508                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
 509                 return STTD_ERROR_OPERATION_FAILED;
 510         }
 511
 512         if (true == is_valid) {
 513                 *lang = strdup(g_default_language);
 514         } else
 515                 *lang = strdup(g_engine_info->first_lang);
 516
 517         return 0;
 518 }
 519
 520 int sttd_engine_agent_set_private_data(const char* key, const char* data)
 521 {
 522         if (false == g_agent_init) {
 523                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 524                 return STTD_ERROR_OPERATION_FAILED;
 525         }
 526
 527         if (NULL == key || NULL == data) {
 528                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 529                 return STTD_ERROR_INVALID_PARAMETER;
 530         }
 531
 532         if (NULL == g_engine_info) {
 533                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 534                 return STTD_ERROR_INVALID_PARAMETER;
 535         }
 536
 537         if (false == g_engine_info->is_loaded) {
 538                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 539                 return STTD_ERROR_OPERATION_FAILED;
 540         }
 541
 542         /* set private data */
 543         int ret = -1;
 544         ret = stt_engine_set_private_data(key, data);
 545         if (0 != ret) {
 546                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set private data");
 547         }
 548
 549         return ret;
 550 }
 551
 552 int sttd_engine_agent_get_private_data(const char* key, char** data)
 553 {
 554         if (false == g_agent_init) {
 555                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 556                 return STTD_ERROR_OPERATION_FAILED;
 557         }
 558
 559         if (NULL == key || NULL == data) {
 560                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 561                 return STTD_ERROR_INVALID_PARAMETER;
 562         }
 563
 564         if (NULL == g_engine_info) {
 565                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 566                 return STTD_ERROR_INVALID_PARAMETER;
 567         }
 568
 569         if (false == g_engine_info->is_loaded) {
 570                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 571                 return STTD_ERROR_OPERATION_FAILED;
 572         }
 573
 574         /* get default language */
 575         int ret = -1;
 576         ret = stt_engine_get_private_data(key, data);
 577         if (0 != ret) {
 578                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get private data");
 579         }
 580
 581         return ret;
 582 }
 583
 584 int sttd_engine_agent_get_option_supported(bool* silence)
 585 {
 586         if (false == g_agent_init) {
 587                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 588                 return STTD_ERROR_OPERATION_FAILED;
 589         }
 590
 591         if (NULL == silence) {
 592                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 593                 return STTD_ERROR_INVALID_PARAMETER;
 594         }
 595
 596         if (NULL == g_engine_info) {
 597                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Engine is not valid");
 598                 return STTD_ERROR_INVALID_PARAMETER;
 599         }
 600
 601         if (false == g_engine_info->is_loaded) {
 602                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 603                 return STTD_ERROR_OPERATION_FAILED;
 604         }
 605
 606         bool temp = false;
 607         if (0 != stt_engine_support_silence(&temp)) {
 608                 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Fail to get support silence");
 609         }
 610
 611         *silence = g_engine_info->support_silence_detection;
 612         if (temp != *silence) {
 613                 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Metadata and Engine spec are different (engine:%d) (meta:%d)", temp, *silence);
 614         }
 615
 616         return 0;
 617 }
 618
 619 int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
 620 {
 621         if (false == g_agent_init) {
 622                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 623                 return STTD_ERROR_OPERATION_FAILED;
 624         }
 625
 626         if (NULL == credential) {
 627                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 628                 return STTD_ERROR_INVALID_PARAMETER;
 629         }
 630
 631         if (NULL == g_engine_info) {
 632                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
 633                 return STTD_ERROR_INVALID_PARAMETER;
 634         }
 635
 636         if (false == g_engine_info->is_loaded) {
 637                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 638                 return STTD_ERROR_OPERATION_FAILED;
 639         }
 640
 641         bool temp = false;
 642         int ret;
 643
 644         ret = stt_engine_need_app_credential(&temp);
 645         if (0 != ret) {
 646                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
 647                 return ret;
 648         }
 649
 650         *credential = temp;
 651         return 0;
 652 }
 653
 654 int sttd_engine_agent_is_recognition_type_supported(const char* type, bool* support)
 655 {
 656         if (false == g_agent_init) {
 657                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 658                 return STTD_ERROR_OPERATION_FAILED;
 659         }
 660
 661         if (NULL == type || NULL == support) {
 662                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 663                 return STTD_ERROR_INVALID_PARAMETER;
 664         }
 665
 666         if (NULL == g_engine_info) {
 667                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 668                 return STTD_ERROR_INVALID_PARAMETER;
 669         }
 670
 671         if (false == g_engine_info->is_loaded) {
 672                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 673                 return STTD_ERROR_OPERATION_FAILED;
 674         }
 675
 676         bool temp = false;
 677         int ret;
 678
 679         ret = stt_engine_support_recognition_type(type, &temp);
 680         if (0 != ret) {
 681                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
 682                 return ret;
 683         }
 684
 685         *support = temp;
 686
 687         return 0;
 688 }
 689
 690 /*
 691 * STT Engine Interfaces for client
 692 */
 693
 694 int __set_option(sttengine_info_s* engine, int silence)
 695 {
 696         if (NULL == engine)
 697                 return -1;
 698
 699         /* Check silence detection */
 700         if (engine->support_silence_detection) {
 701                 if (2 == silence) {
 702                         /* default option set */
 703                         if (g_default_silence_detected != engine->silence_detection) {
 704                                 if (0 != stt_engine_set_silence_detection(g_default_silence_detected)) {
 705                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false");
 706                                 } else {
 707                                         engine->silence_detection = g_default_silence_detected;
 708                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false");
 709                                 }
 710                         }
 711                 } else {
 712                         if (silence != engine->silence_detection) {
 713                                 if (0 != stt_engine_set_silence_detection(silence)) {
 714                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false");
 715                                 } else {
 716                                         engine->silence_detection = silence;
 717                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false");
 718                                 }
 719                         }
 720                 }
 721         }
 722
 723         return 0;
 724 }
 725
 726 int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
 727                                       int silence, const char* appid, const char* credential, void* user_param)
 728 {
 729         if (false == g_agent_init) {
 730                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 731                 return STTD_ERROR_OPERATION_FAILED;
 732         }
 733
 734         if (NULL == lang || NULL == recognition_type) {
 735                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 736                 return STTD_ERROR_INVALID_PARAMETER;
 737         }
 738
 739         if (NULL == g_engine_info) {
 740                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 741                 return STTD_ERROR_INVALID_PARAMETER;
 742         }
 743
 744         if (false == g_engine_info->is_loaded) {
 745                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 746                 return STTD_ERROR_OPERATION_FAILED;
 747         }
 748
 749         if (0 != __set_option(g_engine_info, silence)) {
 750                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options");
 751                 return STTD_ERROR_OPERATION_FAILED;
 752         }
 753
 754         SLOG(LOG_DEBUG, TAG_STTD, "g_default_language %s", g_default_language);
 755
 756         int ret;
 757         char* temp = NULL;
 758         if (0 == strncmp(lang, "default", strlen("default"))) {
 759                 bool is_valid = false;
 760                 ret = stt_engine_is_valid_language(g_default_language, &is_valid);
 761                 if (0 != ret) {
 762                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
 763                         return ret;
 764                 }
 765
 766                 if (true == is_valid) {
 767                         temp = strdup(g_default_language);
 768                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp);
 769                 } else {
 770                         temp = strdup(g_engine_info->first_lang);
 771                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp);
 772                 }
 773         } else {
 774                 temp = strdup(lang);
 775         }
 776
 777         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start engine");
 778
 779         ret = stt_engine_recognize_start(temp, recognition_type, appid, credential, user_param);
 780         if (NULL != temp)       free(temp);
 781         if (0 != ret) {
 782                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
 783                 sttd_recorder_destroy();
 784                 return ret;
 785         }
 786
 787 #ifdef AUDIO_CREATE_ON_START
 788         /* Ready recorder */
 789         stte_audio_type_e atype;
 790         int rate;
 791         int channels;
 792
 793         ret = stt_engine_get_audio_type(&atype, &rate, &channels);
 794         if (0 != ret) {
 795                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %s", g_engine_info->engine_name);
 796                 return ret;
 797         }
 798
 799         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder");
 800
 801         ret = sttd_recorder_create(atype, channels, rate);
 802         if (0 != ret) {
 803                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
 804                 return ret;
 805         }
 806 #endif
 807
 808 #if 0
 809         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder(%d)", uid);
 810
 811         ret = sttd_recorder_start(uid);
 812         if (0 != ret) {
 813                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 814                 return ret;
 815         }
 816
 817 #endif
 818
 819         return 0;
 820 }
 821
 822 int sttd_engine_agent_recognize_start_recorder(int uid)
 823 {
 824         if (NULL == g_engine_info) {
 825                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 826                 return STTD_ERROR_INVALID_PARAMETER;
 827         }
 828
 829         if (false == g_engine_info->is_loaded) {
 830                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 831                 return STTD_ERROR_OPERATION_FAILED;
 832         }
 833
 834         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
 835
 836         int ret;
 837         ret = sttd_recorder_start(uid);
 838         if (0 != ret) {
 839                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 840                 stt_engine_recognize_cancel();
 841                 sttd_recorder_stop();
 842                 return ret;
 843         }
 844
 845         return 0;
 846 }
 847
 848 int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
 849 {
 850         if (NULL == g_engine_info) {
 851                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 852                 return STTD_ERROR_INVALID_PARAMETER;
 853         }
 854
 855         if (false == g_engine_info->is_loaded) {
 856                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 857                 return STTD_ERROR_OPERATION_FAILED;
 858         }
 859
 860         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
 861
 862         int ret;
 863         ret = sttd_recorder_start_file(uid, filepath);
 864         if (0 != ret) {
 865                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 866                 stt_engine_recognize_cancel();
 867                 sttd_recorder_stop_file();
 868                 return ret;
 869         }
 870
 871         return 0;
 872 }
 873
 874 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
 875 {
 876         if (false == g_agent_init) {
 877                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 878                 return STTD_ERROR_OPERATION_FAILED;
 879         }
 880
 881         if (NULL == data || 0 == length) {
 882                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 883                 return STTD_ERROR_INVALID_PARAMETER;
 884         }
 885
 886         if (NULL == g_engine_info) {
 887                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 888                 return STTD_ERROR_INVALID_PARAMETER;
 889         }
 890
 891         if (false == g_engine_info->is_loaded) {
 892                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 893                 return STTD_ERROR_OPERATION_FAILED;
 894         }
 895
 896         int ret = stt_engine_set_recording_data(data, length);
 897         if (0 != ret) {
 898                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
 899         }
 900
 901         return ret;
 902 }
 903
 904 int sttd_engine_agent_recognize_stop_file()
 905 {
 906         if (false == g_agent_init) {
 907                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 908                 return STTD_ERROR_OPERATION_FAILED;
 909         }
 910
 911         if (NULL == g_engine_info) {
 912                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 913                 return STTD_ERROR_INVALID_PARAMETER;
 914         }
 915
 916         if (false == g_engine_info->is_loaded) {
 917                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 918                 return STTD_ERROR_OPERATION_FAILED;
 919         }
 920
 921         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
 922         int ret;
 923         ret = sttd_recorder_stop_file();
 924         if (0 != ret) {
 925                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 926                 return ret;
 927         }
 928
 929 #ifdef AUDIO_CREATE_ON_START
 930         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 931         if (0 != sttd_recorder_destroy())
 932                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 933 #endif
 934
 935         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
 936         return 0;
 937 }
 938
 939 int sttd_engine_agent_recognize_stop_recorder()
 940 {
 941         if (false == g_agent_init) {
 942                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 943                 return STTD_ERROR_OPERATION_FAILED;
 944         }
 945
 946         if (NULL == g_engine_info) {
 947                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 948                 return STTD_ERROR_INVALID_PARAMETER;
 949         }
 950
 951         if (false == g_engine_info->is_loaded) {
 952                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 953                 return STTD_ERROR_OPERATION_FAILED;
 954         }
 955
 956         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
 957         int ret;
 958         ret = sttd_recorder_stop();
 959         if (0 != ret) {
 960                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 961                 return ret;
 962         }
 963
 964 #ifdef AUDIO_CREATE_ON_START
 965         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 966         if (0 != sttd_recorder_destroy())
 967                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 968 #endif
 969
 970         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
 971         return 0;
 972 }
 973
 974 int sttd_engine_agent_recognize_stop_engine()
 975 {
 976         if (false == g_agent_init) {
 977                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 978                 return STTD_ERROR_OPERATION_FAILED;
 979         }
 980
 981         if (NULL == g_engine_info) {
 982                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 983                 return STTD_ERROR_INVALID_PARAMETER;
 984         }
 985
 986         if (false == g_engine_info->is_loaded) {
 987                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 988                 return STTD_ERROR_OPERATION_FAILED;
 989         }
 990
 991         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop engine");
 992
 993         int ret;
 994         ret = stt_engine_recognize_stop();
 995         if (0 != ret) {
 996                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
 997                 return ret;
 998         }
 999
1000         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine");
1001
1002         return 0;
1003 }
1004
1005 int sttd_engine_agent_recognize_cancel()
1006 {
1007         if (false == g_agent_init) {
1008                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1009                 return STTD_ERROR_OPERATION_FAILED;
1010         }
1011
1012         if (NULL == g_engine_info) {
1013                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
1014                 return STTD_ERROR_INVALID_PARAMETER;
1015         }
1016
1017         if (false == g_engine_info->is_loaded) {
1018                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1019                 return STTD_ERROR_OPERATION_FAILED;
1020         }
1021
1022         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Cancel engine");
1023
1024         int ret;
1025         ret = stt_engine_recognize_cancel();
1026         if (0 != ret) {
1027                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1028                 return ret;
1029         }
1030
1031         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
1032
1033         ret = sttd_recorder_stop();
1034         if (0 != ret) {
1035                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
1036                 return ret;
1037         }
1038
1039 #ifdef AUDIO_CREATE_ON_START
1040         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1041         if (0 != sttd_recorder_destroy())
1042                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1043 #endif
1044
1045         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Cancel recognition");
1046
1047         return 0;
1048 }
1049
1050
1051 /*
1052 * STT Engine Interfaces for configure
1053 */
1054
1055 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
1056 {
1057         if (false == g_agent_init) {
1058                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1059                 return STTD_ERROR_OPERATION_FAILED;
1060         }
1061
1062         if (NULL == engine_uuid) {
1063                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1064                 return STTD_ERROR_INVALID_PARAMETER;
1065         }
1066
1067         __log_enginelist();
1068
1069         if (NULL == g_engine_info) {
1070                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid");
1071                 return STTD_ERROR_ENGINE_NOT_FOUND;
1072         }
1073
1074         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
1075
1076         return 0;
1077 }
1078
1079 int sttd_engine_agent_set_default_language(const char* language)
1080 {
1081         if (false == g_agent_init) {
1082                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1083                 return STTD_ERROR_OPERATION_FAILED;
1084         }
1085
1086         if (NULL == language) {
1087                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1088                 return STTD_ERROR_INVALID_PARAMETER;
1089         }
1090
1091         if (NULL != g_default_language)
1092                 free(g_default_language);
1093
1094         g_default_language = strdup(language);
1095
1096         return 0;
1097 }
1098
1099 int sttd_engine_agent_set_silence_detection(bool value)
1100 {
1101         if (false == g_agent_init) {
1102                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1103                 return STTD_ERROR_OPERATION_FAILED;
1104         }
1105
1106         g_default_silence_detected = value;
1107
1108         return 0;
1109 }
1110
1111 int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
1112 {
1113         if (false == g_agent_init) {
1114                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1115                 return STTD_ERROR_OPERATION_FAILED;
1116         }
1117
1118         if (NULL == g_engine_info) {
1119                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of is not valid");
1120                 return STTD_ERROR_INVALID_PARAMETER;
1121         }
1122
1123         if (false == g_engine_info->is_loaded) {
1124                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1125                 return STTD_ERROR_OPERATION_FAILED;
1126         }
1127
1128         int ret;
1129         ret = stt_engine_check_app_agreed(appid, result);
1130         if (0 != ret) {
1131                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1132                 return ret;
1133         }
1134
1135
1136         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
1137         return 0;
1138 }
1139
1140 static void __recorder_destroy_by_error_result(void *data)
1141 {
1142         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1143         if (0 != sttd_recorder_destroy())
1144                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1145
1146         return;
1147 }
1148
1149 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
1150                  const char* msg, void* time_info, void *user_data)
1151 {
1152         int ret = -1;
1153
1154         if (false == g_agent_init) {
1155                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
1156                 return STTD_ERROR_OPERATION_FAILED;
1157         }
1158
1159         SLOG(LOG_DEBUG, TAG_STTD, "[Server] === Result time callback ===");
1160
1161         if (NULL != time_info) {
1162                 /* Get the time info */
1163                 ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
1164                 if (0 != ret) {
1165                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
1166                         return ret;
1167                 }
1168         }
1169
1170         SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================");
1171
1172         ret = g_result_cb(event, type, result, result_count, msg, user_data);
1173
1174 #ifdef AUDIO_CREATE_ON_START
1175         if (event == STTE_RESULT_EVENT_ERROR) {
1176                 ecore_main_loop_thread_safe_call_async(__recorder_destroy_by_error_result, NULL);
1177         }
1178 #endif
1179
1180         return ret;
1181 }
1182
1183 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
1184 {
1185         /* check uid */
1186         int uid = stt_client_get_current_recognition();
1187
1188         char* err_msg = NULL;
1189         int ret = STTD_ERROR_NONE;
1190
1191         if (NULL != msg) {
1192                 err_msg = strdup(msg);
1193         }
1194
1195         ret = sttdc_send_error_signal(uid, error, err_msg);
1196         if (0 != ret) {
1197                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info.");
1198
1199                 if (NULL != err_msg) {
1200                         free(err_msg);
1201                         err_msg = NULL;
1202                 }
1203
1204                 return ret;
1205         }
1206
1207         if (NULL != err_msg) {
1208                 free(err_msg);
1209                 err_msg = NULL;
1210         }
1211
1212         ret = g_error_cb(error, msg);
1213
1214         return ret;
1215 }
1216
1217 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
1218 {
1219         int ret = STTD_ERROR_NONE;
1220         if (false == g_agent_init) {
1221                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
1222                 return STTD_ERROR_OPERATION_FAILED;
1223         }
1224
1225         ret = g_speech_status_cb(status, user_data);
1226         return ret;
1227 }
1228
1229 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
1230 {
1231         return g_result_time_cb(index, event, text, start_time, end_time, user_data);
1232 }
1233
1234 /* A function forging */
1235 int __log_enginelist()
1236 {
1237         if (NULL != g_engine_info) {
1238                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1239                 SLOG(LOG_DEBUG, TAG_STTD, "engine uuid : %s", g_engine_info->engine_uuid);
1240                 SLOG(LOG_DEBUG, TAG_STTD, "engine name : %s", g_engine_info->engine_name);
1241                 SLOG(LOG_DEBUG, TAG_STTD, "engine path : %s", g_engine_info->engine_path);
1242                 SLOG(LOG_DEBUG, TAG_STTD, "use network : %s", g_engine_info->use_network ? "true" : "false");
1243                 SLOG(LOG_DEBUG, TAG_STTD, "is loaded   : %s", g_engine_info->is_loaded ? "true" : "false");
1244                 if (NULL != g_engine_info->first_lang) {
1245                         SLOG(LOG_DEBUG, TAG_STTD, "default lang : %s", g_engine_info->first_lang);
1246                 }
1247                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1248         } else {
1249                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1250                 SLOG(LOG_DEBUG, TAG_STTD, "     No engine");
1251                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1252         }
1253
1254         return 0;
1255 }