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 && NULL != cur_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_INFO, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
 320         } else {
 321                 SLOG(LOG_INFO, 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_format(&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_INFO, 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_INFO, 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_INFO, 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                 return ret;
 784         }
 785
 786 #ifdef AUDIO_CREATE_ON_START
 787         /* Ready recorder */
 788         stte_audio_type_e atype;
 789         int rate;
 790         int channels;
 791
 792         ret = stt_engine_get_audio_format(&atype, &rate, &channels);
 793         if (0 != ret) {
 794                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio format : %s", g_engine_info->engine_name);
 795                 return ret;
 796         }
 797
 798         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Create recorder");
 799
 800         ret = sttd_recorder_create(atype, channels, rate);
 801         if (0 != ret) {
 802                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create format : %s", g_engine_info->engine_name);
 803                 return ret;
 804         }
 805 #endif
 806
 807 #if 0
 808         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder(%d)", uid);
 809
 810         ret = sttd_recorder_start(uid);
 811         if (0 != ret) {
 812                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 813                 return ret;
 814         }
 815
 816 #endif
 817
 818         return 0;
 819 }
 820
 821 int sttd_engine_agent_recognize_start_recorder(int uid)
 822 {
 823         if (NULL == g_engine_info) {
 824                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 825                 return STTD_ERROR_INVALID_PARAMETER;
 826         }
 827
 828         if (false == g_engine_info->is_loaded) {
 829                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 830                 return STTD_ERROR_OPERATION_FAILED;
 831         }
 832
 833         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 834
 835         int ret;
 836         ret = sttd_recorder_start(uid);
 837         if (0 != ret) {
 838                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 839                 stt_engine_recognize_cancel();
 840                 sttd_recorder_stop();
 841                 return ret;
 842         }
 843
 844         return 0;
 845 }
 846
 847 int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
 848 {
 849         if (NULL == g_engine_info) {
 850                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 851                 return STTD_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         if (false == g_engine_info->is_loaded) {
 855                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 856                 return STTD_ERROR_OPERATION_FAILED;
 857         }
 858
 859         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 860
 861         int ret;
 862         ret = sttd_recorder_start_file(uid, filepath);
 863         if (0 != ret) {
 864                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
 865                 stt_engine_recognize_cancel();
 866                 sttd_recorder_stop_file();
 867                 return ret;
 868         }
 869
 870         return 0;
 871 }
 872
 873 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
 874 {
 875         if (false == g_agent_init) {
 876                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 877                 return STTD_ERROR_OPERATION_FAILED;
 878         }
 879
 880         if (NULL == data || 0 == length) {
 881                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 882                 return STTD_ERROR_INVALID_PARAMETER;
 883         }
 884
 885         if (NULL == g_engine_info) {
 886                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 887                 return STTD_ERROR_INVALID_PARAMETER;
 888         }
 889
 890         if (false == g_engine_info->is_loaded) {
 891                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 892                 return STTD_ERROR_OPERATION_FAILED;
 893         }
 894
 895         int ret = stt_engine_set_recording_data(data, length);
 896         if (0 != ret) {
 897                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
 898         }
 899
 900         return ret;
 901 }
 902
 903 int sttd_engine_agent_recognize_stop_file()
 904 {
 905         if (false == g_agent_init) {
 906                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 907                 return STTD_ERROR_OPERATION_FAILED;
 908         }
 909
 910         if (NULL == g_engine_info) {
 911                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 912                 return STTD_ERROR_INVALID_PARAMETER;
 913         }
 914
 915         if (false == g_engine_info->is_loaded) {
 916                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 917                 return STTD_ERROR_OPERATION_FAILED;
 918         }
 919
 920         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 921         int ret;
 922         ret = sttd_recorder_stop_file();
 923         if (0 != ret) {
 924                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 925                 return ret;
 926         }
 927
 928 #ifdef AUDIO_CREATE_ON_START
 929         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
 930         if (0 != sttd_recorder_destroy())
 931                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 932 #endif
 933
 934         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
 935         return 0;
 936 }
 937
 938 int sttd_engine_agent_recognize_stop_recorder()
 939 {
 940         if (false == g_agent_init) {
 941                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 942                 return STTD_ERROR_OPERATION_FAILED;
 943         }
 944
 945         if (NULL == g_engine_info) {
 946                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 947                 return STTD_ERROR_INVALID_PARAMETER;
 948         }
 949
 950         if (false == g_engine_info->is_loaded) {
 951                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 952                 return STTD_ERROR_OPERATION_FAILED;
 953         }
 954
 955         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 956         int ret;
 957         ret = sttd_recorder_stop();
 958         if (0 != ret) {
 959                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
 960                 return ret;
 961         }
 962
 963 #ifdef AUDIO_CREATE_ON_START
 964         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 965         if (0 != sttd_recorder_destroy())
 966                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 967 #endif
 968
 969         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
 970         return 0;
 971 }
 972
 973 int sttd_engine_agent_recognize_stop_engine()
 974 {
 975         if (false == g_agent_init) {
 976                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 977                 return STTD_ERROR_OPERATION_FAILED;
 978         }
 979
 980         if (NULL == g_engine_info) {
 981                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
 982                 return STTD_ERROR_INVALID_PARAMETER;
 983         }
 984
 985         if (false == g_engine_info->is_loaded) {
 986                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 987                 return STTD_ERROR_OPERATION_FAILED;
 988         }
 989
 990         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop engine");
 991
 992         int ret;
 993         ret = stt_engine_recognize_stop();
 994         if (0 != ret) {
 995                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
 996                 return ret;
 997         }
 998
 999         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop engine");
1000
1001         return 0;
1002 }
1003
1004 int sttd_engine_agent_recognize_cancel()
1005 {
1006         if (false == g_agent_init) {
1007                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1008                 return STTD_ERROR_OPERATION_FAILED;
1009         }
1010
1011         if (NULL == g_engine_info) {
1012                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
1013                 return STTD_ERROR_INVALID_PARAMETER;
1014         }
1015
1016         if (false == g_engine_info->is_loaded) {
1017                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1018                 return STTD_ERROR_OPERATION_FAILED;
1019         }
1020
1021         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Cancel engine");
1022
1023         int ret;
1024         ret = stt_engine_recognize_cancel();
1025         if (0 != ret) {
1026                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1027                 return ret;
1028         }
1029
1030         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
1031
1032         ret = sttd_recorder_stop();
1033         if (0 != ret) {
1034                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
1035                 return ret;
1036         }
1037
1038 #ifdef AUDIO_CREATE_ON_START
1039         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
1040         if (0 != sttd_recorder_destroy())
1041                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1042 #endif
1043
1044         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Cancel recognition");
1045
1046         return 0;
1047 }
1048
1049
1050 /*
1051 * STT Engine Interfaces for configure
1052 */
1053
1054 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
1055 {
1056         if (false == g_agent_init) {
1057                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1058                 return STTD_ERROR_OPERATION_FAILED;
1059         }
1060
1061         if (NULL == engine_uuid) {
1062                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1063                 return STTD_ERROR_INVALID_PARAMETER;
1064         }
1065
1066         __log_enginelist();
1067
1068         if (NULL == g_engine_info) {
1069                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid");
1070                 return STTD_ERROR_ENGINE_NOT_FOUND;
1071         }
1072
1073         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
1074
1075         return 0;
1076 }
1077
1078 int sttd_engine_agent_set_default_language(const char* language)
1079 {
1080         if (false == g_agent_init) {
1081                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1082                 return STTD_ERROR_OPERATION_FAILED;
1083         }
1084
1085         if (NULL == language) {
1086                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1087                 return STTD_ERROR_INVALID_PARAMETER;
1088         }
1089
1090         if (NULL != g_default_language)
1091                 free(g_default_language);
1092
1093         g_default_language = strdup(language);
1094
1095         return 0;
1096 }
1097
1098 int sttd_engine_agent_set_silence_detection(bool value)
1099 {
1100         if (false == g_agent_init) {
1101                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1102                 return STTD_ERROR_OPERATION_FAILED;
1103         }
1104
1105         g_default_silence_detected = value;
1106
1107         return 0;
1108 }
1109
1110 int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
1111 {
1112         if (false == g_agent_init) {
1113                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1114                 return STTD_ERROR_OPERATION_FAILED;
1115         }
1116
1117         if (NULL == g_engine_info) {
1118                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of is not valid");
1119                 return STTD_ERROR_INVALID_PARAMETER;
1120         }
1121
1122         if (false == g_engine_info->is_loaded) {
1123                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1124                 return STTD_ERROR_OPERATION_FAILED;
1125         }
1126
1127         int ret;
1128         ret = stt_engine_check_app_agreed(appid, result);
1129         if (0 != ret) {
1130                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1131                 return ret;
1132         }
1133
1134
1135         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
1136         return 0;
1137 }
1138
1139 static void __recorder_destroy_by_error_result(void *data)
1140 {
1141         SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
1142         if (0 != sttd_recorder_destroy())
1143                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1144
1145         return;
1146 }
1147
1148 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
1149                  const char* msg, void* time_info, void *user_data)
1150 {
1151         int ret = -1;
1152
1153         if (false == g_agent_init) {
1154                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
1155                 return STTD_ERROR_OPERATION_FAILED;
1156         }
1157
1158         SLOG(LOG_INFO, TAG_STTD, "[Server] === Result time callback ===");
1159
1160         if (NULL != time_info) {
1161                 /* Get the time info */
1162                 ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
1163                 if (0 != ret) {
1164                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
1165                         return ret;
1166                 }
1167         }
1168
1169         SLOG(LOG_INFO, TAG_STTD, "[Server] ============================");
1170
1171         ret = g_result_cb(event, type, result, result_count, msg, user_data);
1172
1173 #ifdef AUDIO_CREATE_ON_START
1174         if (event == STTE_RESULT_EVENT_ERROR) {
1175                 ecore_main_loop_thread_safe_call_async(__recorder_destroy_by_error_result, NULL);
1176         }
1177 #endif
1178
1179         return ret;
1180 }
1181
1182 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
1183 {
1184         /* check uid */
1185         int uid = stt_client_get_current_recognition();
1186
1187         char* err_msg = NULL;
1188         int ret = STTD_ERROR_NONE;
1189
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
1200         if (NULL != err_msg) {
1201                 free(err_msg);
1202                 err_msg = NULL;
1203         }
1204
1205         ret = g_error_cb(error, msg);
1206
1207         return ret;
1208 }
1209
1210 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
1211 {
1212         int ret = STTD_ERROR_NONE;
1213         if (false == g_agent_init) {
1214                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
1215                 return STTD_ERROR_OPERATION_FAILED;
1216         }
1217
1218         ret = g_speech_status_cb(status, user_data);
1219         return ret;
1220 }
1221
1222 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
1223 {
1224         return g_result_time_cb(index, event, text, start_time, end_time, user_data);
1225 }
1226
1227 /* A function forging */
1228 int __log_enginelist()
1229 {
1230         if (NULL != g_engine_info) {
1231                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1232                 SLOG(LOG_DEBUG, TAG_STTD, "engine uuid : %s", g_engine_info->engine_uuid);
1233                 SLOG(LOG_DEBUG, TAG_STTD, "engine name : %s", g_engine_info->engine_name);
1234                 SLOG(LOG_DEBUG, TAG_STTD, "engine path : %s", g_engine_info->engine_path);
1235                 SLOG(LOG_DEBUG, TAG_STTD, "use network : %s", g_engine_info->use_network ? "true" : "false");
1236                 SLOG(LOG_DEBUG, TAG_STTD, "is loaded   : %s", g_engine_info->is_loaded ? "true" : "false");
1237                 if (NULL != g_engine_info->first_lang) {
1238                         SLOG(LOG_DEBUG, TAG_STTD, "default lang : %s", g_engine_info->first_lang);
1239                 }
1240                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1241         } else {
1242                 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1243                 SLOG(LOG_DEBUG, TAG_STTD, "     No engine");
1244                 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1245         }
1246
1247         return 0;
1248 }
1249
1250 int sttd_engine_agent_set_audio_type(const char* audio_type)
1251 {
1252         if (false == g_agent_init) {
1253                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1254                 return STTD_ERROR_OPERATION_FAILED;
1255         }
1256
1257         if (NULL == g_engine_info) {
1258                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of is not valid");
1259                 return STTD_ERROR_INVALID_PARAMETER;
1260         }
1261
1262         if (false == g_engine_info->is_loaded) {
1263                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1264                 return STTD_ERROR_OPERATION_FAILED;
1265         }
1266
1267         SLOG(LOG_INFO, TAG_STTD, "[Server Info] Set audio type(%s)", audio_type);
1268
1269         int ret;
1270         ret = stt_engine_set_audio_type(audio_type);
1271         if (0 != ret) {
1272                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set audio type error(%d)", ret);
1273         }
1274         return ret;
1275 }