server/sttd_engine_agent.c

   1 /*
   2 *  Copyright (c) 2011-2014 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_recorder.h"
  24 #include "sttd_engine_agent.h"
  25
  26
  27 #define AUDIO_CREATE_ON_START
  28
  29 /*
  30 * Internal data structure
  31 */
  32
  33 typedef struct {
  34         int     uid;
  35         int     engine_id;
  36         bool    use_default_engine;
  37 } sttengine_client_s;
  38
  39 typedef struct _sttengine_info {
  40         int     engine_id;
  41
  42         char*   engine_uuid;
  43         char*   engine_path;
  44         char*   engine_name;
  45         char*   engine_setting_path;
  46         bool    use_network;
  47
  48         bool    is_loaded;
  49
  50         /* engine base setting */
  51         char*   first_lang;
  52         bool    silence_detection;
  53         bool    support_silence_detection;
  54         bool    need_credential;
  55 } sttengine_info_s;
  56
  57 /** stt engine agent init */
  58 static bool     g_agent_init;
  59
  60 /** list */
  61 static GSList*  g_engine_client_list;
  62 static GSList*  g_engine_list;
  63
  64 /** default engine info */
  65 static int      g_default_engine_id;
  66 static char*    g_default_language;
  67 static bool     g_default_silence_detected;
  68
  69 static int      g_engine_id_count;
  70
  71 /** current engine id */
  72 static int      g_recording_engine_id;
  73
  74 /** callback functions */
  75 static result_callback g_result_cb;
  76 static result_time_callback g_result_time_cb;
  77 static silence_dectection_callback g_silence_cb;
  78
  79
  80 /** callback functions */
  81 void __result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count,
  82                  const char* msg, void* time_info, void *user_data);
  83
  84 bool __result_time_cb(int index, sttp_result_time_event_e event, const char* text,
  85                       long start_time, long end_time, void* user_data);
  86
  87 void __detect_silence_cb(sttp_silence_type_e type, void* user_data);
  88
  89 bool __supported_language_cb(const char* language, void* user_data);
  90
  91 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
  92                       bool use_network, void* user_data);
  93
  94 /*
  95 * Internal Interfaces
  96 */
  97
  98 /** get engine info */
  99 int __internal_get_engine_info(const char* filepath, sttengine_info_s** info);
 100
 101 int __log_enginelist();
 102
 103 /*
 104 * STT Engine Agent Interfaces
 105 */
 106 int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb,
 107                            silence_dectection_callback silence_cb)
 108 {
 109         /* initialize static data */
 110         if (NULL == result_cb || NULL == time_cb || NULL == silence_cb) {
 111                 SLOG(LOG_ERROR, TAG_STTD, "[Engine agent ERROR] Invalid parameter");
 112                 return STTD_ERROR_INVALID_PARAMETER;
 113         }
 114
 115         g_result_cb = result_cb;
 116         g_result_time_cb = time_cb;
 117         g_silence_cb = silence_cb;
 118
 119         g_default_engine_id = -1;
 120         g_default_language = NULL;
 121         g_engine_id_count = 1;
 122         g_recording_engine_id = -1;
 123
 124         if (0 != sttd_config_get_default_language(&(g_default_language))) {
 125                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is No default voice in config");
 126                 /* Set default voice */
 127                 g_default_language = strdup("en_US");
 128         } else {
 129                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default language is %s", g_default_language);
 130         }
 131
 132         int temp;
 133         if (0 != sttd_config_get_default_silence_detection(&temp)) {
 134                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no silence detection in config");
 135                 g_default_silence_detected = true;
 136         } else {
 137                 g_default_silence_detected = (bool)temp;
 138         }
 139
 140         g_agent_init = false;
 141
 142         return 0;
 143 }
 144
 145 int __engine_agent_clear_engine(sttengine_info_s *engine)
 146 {
 147         if (NULL != engine) {
 148                 if (NULL != engine->engine_uuid)        free(engine->engine_uuid);
 149                 if (NULL != engine->engine_path)        free(engine->engine_path);
 150                 if (NULL != engine->engine_name)        free(engine->engine_name);
 151                 if (NULL != engine->engine_setting_path)free(engine->engine_setting_path);
 152                 if (NULL != engine->first_lang)         free(engine->first_lang);
 153
 154                 free(engine);
 155         }
 156
 157         return 0;
 158 }
 159
 160 int sttd_engine_agent_release()
 161 {
 162         /* Release client list */
 163         GSList *iter = NULL;
 164         sttengine_client_s *client = NULL;
 165
 166         if (g_slist_length(g_engine_client_list) > 0) {
 167                 /* Get a first item */
 168                 iter = g_slist_nth(g_engine_client_list, 0);
 169
 170                 while (NULL != iter) {
 171                         /* Get handle data from list */
 172                         client = iter->data;
 173                         g_engine_client_list = g_slist_remove_link(g_engine_client_list, iter);
 174
 175                         if (NULL != client)
 176                                 free(client);
 177
 178                         iter = g_slist_nth(g_engine_client_list, 0);
 179                 }
 180         }
 181
 182         g_slist_free(g_engine_client_list);
 183
 184         /* Release engine list */
 185         sttengine_info_s *engine = NULL;
 186
 187         if (0 < g_slist_length(g_engine_list)) {
 188                 /* Get a first item */
 189                 iter = g_slist_nth(g_engine_list, 0);
 190
 191                 while (NULL != iter) {
 192                         /* Get handle data from list */
 193                         engine = iter->data;
 194                         g_engine_list = g_slist_remove_link(g_engine_list, iter);
 195
 196                         /* Check engine unload */
 197                         if (engine->is_loaded) {
 198                                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine id(%d)", engine->engine_id);
 199
 200                                 if (0 != stt_engine_deinitialize(engine->engine_id))
 201                                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id);
 202
 203                                 if (0 != stt_engine_unload(engine->engine_id))
 204                                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id);
 205
 206                                 engine->is_loaded = false;
 207                         }
 208
 209                         __engine_agent_clear_engine(engine);
 210
 211                         iter = g_slist_nth(g_engine_list, 0);
 212                 }
 213         }
 214
 215         g_result_cb = NULL;
 216         g_silence_cb = NULL;
 217
 218         g_agent_init = false;
 219         g_default_engine_id = -1;
 220
 221         return 0;
 222 }
 223
 224 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
 225                       bool use_network, void* user_data)
 226 {
 227         sttengine_info_s* temp = (sttengine_info_s*)user_data;
 228
 229         temp->engine_uuid = g_strdup(engine_uuid);
 230         temp->engine_name = g_strdup(engine_name);
 231         temp->engine_setting_path = g_strdup(setting_ug_name);
 232         temp->use_network = use_network;
 233 }
 234
 235 int __internal_get_engine_info(const char* filepath, sttengine_info_s** info)
 236 {
 237         if (NULL == filepath || NULL == info) {
 238                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 239                 return STTD_ERROR_INVALID_PARAMETER;
 240         }
 241
 242         /* load engine */
 243         char *error;
 244         void* handle;
 245
 246         handle = dlopen(filepath, RTLD_LAZY);
 247
 248         if (!handle) {
 249                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine : %s, error(%s)", filepath, (NULL == dlerror()) ? "NULL" : dlerror());
 250                 return STTD_ERROR_ENGINE_NOT_FOUND;
 251         }
 252
 253         /* link engine to daemon */
 254         dlsym(handle, "sttp_load_engine");
 255         if ((error = dlerror()) != NULL) {
 256                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error);
 257                 dlclose(handle);
 258                 return STTD_ERROR_ENGINE_NOT_FOUND;
 259         }
 260
 261         dlsym(handle, "sttp_unload_engine");
 262         if ((error = dlerror()) != NULL) {
 263                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_unload_engine : %s", error);
 264                 dlclose(handle);
 265                 return STTD_ERROR_ENGINE_NOT_FOUND;
 266         }
 267
 268         int (*get_engine_info)(sttpe_engine_info_cb callback, void* user_data);
 269
 270         get_engine_info = (int (*)(sttpe_engine_info_cb, void*))dlsym(handle, "sttp_get_engine_info");
 271         if ((error = dlerror()) != NULL || NULL == get_engine_info) {
 272                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error);
 273                 dlclose(handle);
 274                 return STTD_ERROR_ENGINE_NOT_FOUND;
 275         }
 276
 277         sttengine_info_s* temp;
 278         temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s));
 279         if (NULL == temp) {
 280                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory");
 281                 dlclose(handle);
 282                 return STTD_ERROR_OUT_OF_MEMORY;
 283         }
 284
 285         /* get engine info */
 286         if (0 != get_engine_info(__engine_info_cb, (void*)temp)) {
 287                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info from engine");
 288                 dlclose(handle);
 289                 free(temp);
 290                 return STTD_ERROR_ENGINE_NOT_FOUND;
 291         }
 292
 293         /* close engine */
 294         dlclose(handle);
 295
 296         temp->engine_id = g_engine_id_count;
 297         g_engine_id_count++;
 298
 299         temp->engine_path = g_strdup(filepath);
 300         temp->is_loaded = false;
 301
 302         SLOG(LOG_DEBUG, TAG_STTD, "----- Valid Engine");
 303         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine id : %d", temp->engine_id);
 304         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine uuid : %s", temp->engine_uuid);
 305         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine name : %s", temp->engine_name);
 306         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine path : %s", temp->engine_path);
 307         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine setting path : %s", temp->engine_setting_path);
 308         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Use network : %s", temp->use_network ? "true" : "false");
 309         SLOG(LOG_DEBUG, TAG_STTD, "-----");
 310         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 311
 312         *info = temp;
 313
 314         return STTD_ERROR_NONE;
 315 }
 316
 317 bool __is_engine(const char* filepath)
 318 {
 319         GSList *iter = NULL;
 320         sttengine_info_s *engine = NULL;
 321
 322         if (0 < g_slist_length(g_engine_list)) {
 323                 /* Get a first item */
 324                 iter = g_slist_nth(g_engine_list, 0);
 325
 326                 while (NULL != iter) {
 327                         /* Get handle data from list */
 328                         engine = iter->data;
 329
 330                         if (0 == strcmp(engine->engine_path, filepath)) {
 331                                 return true;
 332                         }
 333
 334                         iter = g_slist_next(iter);
 335                 }
 336         }
 337
 338         return false;
 339 }
 340
 341 int sttd_engine_agent_initialize_engine_list()
 342 {
 343         /* Get file name from default engine directory */
 344         DIR *dp = NULL;
 345         int ret = -1;
 346         struct dirent entry;
 347         struct dirent *dirp = NULL;
 348
 349         dp  = opendir(STT_DEFAULT_ENGINE);
 350         if (NULL != dp) {
 351                 do {
 352                         ret = readdir_r(dp, &entry, &dirp);
 353                         if (0 != ret) {
 354                                 SLOG(LOG_ERROR, TAG_STTD, "[File ERROR] Fail to read directory");
 355                                 break;
 356                         }
 357
 358                         if (NULL != dirp) {
 359                                 sttengine_info_s* info;
 360                                 char* filepath;
 361                                 int filesize;
 362
 363                                 filesize = strlen(STT_DEFAULT_ENGINE) + strlen(dirp->d_name) + 5;
 364                                 filepath = (char*)calloc(filesize, sizeof(char));
 365
 366                                 if (NULL != filepath) {
 367                                         snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE, dirp->d_name);
 368                                 } else {
 369                                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Memory not enough!!");
 370                                         continue;
 371                                 }
 372
 373                                 if (false  == __is_engine(filepath)) {
 374                                         /* get its info and update engine list */
 375                                         if (0 == __internal_get_engine_info(filepath, &info)) {
 376                                                 /* add engine info to g_engine_list */
 377                                                 g_engine_list = g_slist_append(g_engine_list, info);
 378                                         }
 379                                 }
 380
 381                                 if (NULL != filepath)
 382                                         free(filepath);
 383                         }
 384                 } while (NULL != dirp);
 385
 386                 closedir(dp);
 387         } else {
 388                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Fail to open default directory");
 389         }
 390
 391         if (0 >= g_slist_length(g_engine_list)) {
 392                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No Engine");
 393                 return STTD_ERROR_ENGINE_NOT_FOUND;
 394         }
 395
 396         __log_enginelist();
 397
 398         /* Set default engine */
 399         GSList *iter = NULL;
 400         sttengine_info_s *engine = NULL;
 401         char* cur_engine_uuid = NULL;
 402         bool is_default_engine = false;
 403
 404         /* get current engine from config */
 405         if (0 == sttd_config_get_default_engine(&cur_engine_uuid)) {
 406                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid);
 407
 408                 if (0 < g_slist_length(g_engine_list)) {
 409                         /* Get a first item */
 410                         iter = g_slist_nth(g_engine_list, 0);
 411
 412                         while (NULL != iter) {
 413                                 /* Get handle data from list */
 414                                 engine = iter->data;
 415
 416                                 if (0 == strcmp(engine->engine_uuid, cur_engine_uuid)) {
 417                                         is_default_engine = true;
 418                                         g_default_engine_id = engine->engine_id;
 419                                         break;
 420                                 }
 421
 422                                 iter = g_slist_next(iter);
 423                         }
 424                 }
 425
 426                 if (cur_engine_uuid != NULL)
 427                         free(cur_engine_uuid);
 428         } else {
 429                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is not current engine from config");
 430         }
 431
 432         if (false == is_default_engine) {
 433                 if (0 < g_slist_length(g_engine_list)) {
 434                         /* Get a first item */
 435                         iter = g_slist_nth(g_engine_list, 0);
 436
 437                         /* Get handle data from list */
 438                         engine = iter->data;
 439
 440                         if (NULL != engine) {
 441                                 is_default_engine = true;
 442                                 g_default_engine_id = engine->engine_id;
 443                         }
 444                 }
 445         }
 446
 447         if (NULL != engine) {
 448                 if (NULL != engine->engine_uuid) {
 449                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine Id(%d) uuid(%s)", engine->engine_id, engine->engine_uuid);
 450
 451                         if (false == is_default_engine) {
 452                                 if (0 != sttd_config_set_default_engine(engine->engine_uuid))
 453                                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set default engine ");
 454                         }
 455                 }
 456         } else {
 457                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is NULL");
 458                 return STTD_ERROR_ENGINE_NOT_FOUND;
 459         }
 460
 461         g_agent_init = true;
 462
 463         return 0;
 464 }
 465
 466 sttengine_info_s* __engine_agent_get_engine_by_id(int engine_id)
 467 {
 468         GSList *iter = NULL;
 469         sttengine_info_s *data = NULL;
 470
 471         iter = g_slist_nth(g_engine_list, 0);
 472
 473         while (NULL != iter) {
 474
 475                 data = iter->data;
 476
 477                 if (data->engine_id == engine_id)
 478                         return data;
 479
 480                 iter = g_slist_next(iter);
 481         }
 482
 483         return NULL;
 484 }
 485
 486 sttengine_info_s* __engine_agent_get_engine_by_uuid(const char* engine_uuid)
 487 {
 488         GSList *iter = NULL;
 489         sttengine_info_s *data = NULL;
 490
 491         iter = g_slist_nth(g_engine_list, 0);
 492
 493         while (NULL != iter) {
 494
 495                 data = iter->data;
 496
 497                 if (0 == strcmp(data->engine_uuid, engine_uuid))
 498                         return data;
 499
 500                 iter = g_slist_next(iter);
 501         }
 502
 503         return NULL;
 504 }
 505
 506 sttengine_client_s* __engine_agent_get_client(int uid)
 507 {
 508         GSList *iter = NULL;
 509         sttengine_client_s *data = NULL;
 510
 511         if (0 < g_slist_length(g_engine_client_list)) {
 512                 iter = g_slist_nth(g_engine_client_list, 0);
 513
 514                 while (NULL != iter) {
 515                         /* Get handle data from list */
 516                         data = iter->data;
 517
 518                         if (uid == data->uid)
 519                                 return data;
 520
 521                         iter = g_slist_next(iter);
 522                 }
 523         }
 524
 525         return NULL;
 526 }
 527
 528 sttengine_info_s* __engine_agent_get_engine_by_uid(int uid)
 529 {
 530         sttengine_client_s *data;
 531
 532         data = __engine_agent_get_client(uid);
 533         if (NULL != data)
 534                 return __engine_agent_get_engine_by_id(data->engine_id);
 535
 536         return NULL;
 537 }
 538
 539 int __engine_agent_check_engine_unload(int engine_id)
 540 {
 541         /* Check the count of client to use this engine */
 542         GSList *iter = NULL;
 543         int client_count = 0;
 544         sttengine_client_s *data = NULL;
 545
 546         if (0 < g_slist_length(g_engine_client_list)) {
 547                 iter = g_slist_nth(g_engine_client_list, 0);
 548
 549                 while (NULL != iter) {
 550                         /* Get handle data from list */
 551                         data = iter->data;
 552
 553                         if (data->engine_id == engine_id)
 554                                 client_count++;
 555
 556                         iter = g_slist_next(iter);
 557                 }
 558         }
 559
 560         if (0 == client_count) {
 561                 sttengine_info_s* engine = NULL;
 562                 engine = __engine_agent_get_engine_by_id(engine_id);
 563                 if (NULL == engine) {
 564                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine from client(%d)", engine_id);
 565                 } else {
 566                         if (engine->is_loaded) {
 567                                 /* unload engine */
 568 #ifndef AUDIO_CREATE_ON_START
 569                                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
 570                                 if (0 != sttd_recorder_destroy(engine->engine_id))
 571                                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id);
 572 #endif
 573                                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine id(%d)", engine_id);
 574                                 if (0 != stt_engine_deinitialize(engine->engine_id))
 575                                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id);
 576
 577                                 if (0 != stt_engine_unload(engine->engine_id))
 578                                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id);
 579
 580                                 engine->is_loaded = false;
 581                         }
 582                 }
 583         }
 584
 585         return 0;
 586 }
 587
 588 int sttd_engine_agent_load_current_engine(int uid, const char* engine_uuid)
 589 {
 590         if (false == g_agent_init) {
 591                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 592                 return STTD_ERROR_OPERATION_FAILED;
 593         }
 594
 595         sttengine_client_s* client = NULL;
 596         sttengine_info_s* engine = NULL;
 597         int before_engine = -1;
 598
 599         client = __engine_agent_get_client(uid);
 600
 601         if (NULL == client) {
 602                 client = (sttengine_client_s*)calloc(1, sizeof(sttengine_client_s));
 603                 if (NULL == client) {
 604                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory");
 605                         return STTD_ERROR_OUT_OF_MEMORY;
 606                 }
 607
 608                 /* initialize */
 609                 client->uid = uid;
 610                 client->engine_id = -1;
 611
 612                 g_engine_client_list = g_slist_append(g_engine_client_list, client);
 613
 614                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Registered client(%d)", uid);
 615         }
 616
 617         if (NULL == engine_uuid) {
 618                 /* Set default engine */
 619                 engine = __engine_agent_get_engine_by_id(g_default_engine_id);
 620
 621                 if (NULL == engine) {
 622                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get default engine : %d", g_default_engine_id);
 623                         return STTD_ERROR_OPERATION_FAILED;
 624                 }
 625                 before_engine = client->engine_id;
 626
 627                 client->engine_id = engine->engine_id;
 628                 client->use_default_engine = true;
 629         } else {
 630                 /* Set engine by uid */
 631                 engine = __engine_agent_get_engine_by_uuid(engine_uuid);
 632
 633                 if (NULL == engine) {
 634                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine : %s", engine_uuid);
 635                         return STTD_ERROR_OPERATION_FAILED;
 636                 }
 637                 before_engine = client->engine_id;
 638
 639                 client->engine_id = engine->engine_id;
 640                 client->use_default_engine = false;
 641         }
 642
 643         if (-1 != before_engine) {
 644                 /* Unload engine if reference count is 0 */
 645                 __engine_agent_check_engine_unload(before_engine);
 646         }
 647
 648         if (true == engine->is_loaded) {
 649                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine] engine id(%d) is already loaded", engine->engine_id);
 650                 return 0;
 651         }
 652
 653         /* Load engine */
 654         int ret;
 655         ret = stt_engine_load(engine->engine_id, engine->engine_path);
 656         if (0 != ret) {
 657                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
 658                 return ret;
 659         }
 660
 661         ret = stt_engine_initialize(engine->engine_id, __result_cb, __detect_silence_cb);
 662         if (0 != ret) {
 663                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
 664                 return ret;
 665         }
 666
 667         ret = stt_engine_set_silence_detection(engine->engine_id, g_default_silence_detected);
 668         if (0 != ret) {
 669                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Not support silence detection");
 670                 engine->support_silence_detection = false;
 671         } else {
 672                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Silence detection : %s", g_default_silence_detected ? "true" : "false");
 673                 engine->support_silence_detection = true;
 674                 engine->silence_detection = g_default_silence_detected;
 675         }
 676
 677         /* Set first language */
 678         char* tmp_lang = NULL;
 679         ret = stt_engine_get_first_language(engine->engine_id, &tmp_lang);
 680         if (0 == ret && NULL != tmp_lang) {
 681                 engine->first_lang = strdup(tmp_lang);
 682                 free(tmp_lang);
 683         } else {
 684                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %d %s", engine->engine_id, engine->engine_name);
 685                 return ret;
 686         }
 687
 688 #ifndef AUDIO_CREATE_ON_START
 689         /* Ready recorder */
 690         sttp_audio_type_e atype;
 691         int rate;
 692         int channels;
 693
 694         ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels);
 695         if (0 != ret) {
 696                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name);
 697                 return ret;
 698         }
 699
 700         ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate);
 701         if (0 != ret) {
 702                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name);
 703                 return ret;
 704         }
 705 #endif
 706
 707         engine->is_loaded = true;
 708         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] The %s(%d) has been loaded !!!", engine->engine_name, engine->engine_id);
 709
 710         return 0;
 711 }
 712
 713 int sttd_engine_agent_unload_current_engine(int uid)
 714 {
 715         if (false == g_agent_init) {
 716                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized ");
 717                 return STTD_ERROR_OPERATION_FAILED;
 718         }
 719
 720         /* Remove client */
 721         int engine_id = -1;
 722
 723         GSList *iter = NULL;
 724         sttengine_client_s *data = NULL;
 725
 726         if (0 < g_slist_length(g_engine_client_list)) {
 727                 iter = g_slist_nth(g_engine_client_list, 0);
 728
 729                 while (NULL != iter) {
 730                         /* Get handle data from list */
 731                         data = iter->data;
 732
 733                         if (NULL != data) {
 734                                 if (uid == data->uid) {
 735                                         g_engine_client_list = g_slist_remove_link(g_engine_client_list, iter);
 736                                         engine_id = data->engine_id;
 737                                         free(data);
 738                                         break;
 739                                 }
 740                         }
 741
 742                         iter = g_slist_next(iter);
 743                 }
 744         }
 745
 746         if (-1 != engine_id) {
 747                 __engine_agent_check_engine_unload(engine_id);
 748         }
 749
 750         return 0;
 751 }
 752
 753 bool sttd_engine_agent_is_default_engine()
 754 {
 755         if (g_default_engine_id > 0)
 756                 return true;
 757
 758         return false;
 759 }
 760
 761 int sttd_engine_agent_get_engine_list(GSList** engine_list)
 762 {
 763         if (false == g_agent_init) {
 764                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 765                 return STTD_ERROR_OPERATION_FAILED;
 766         }
 767
 768         GSList *iter = NULL;
 769         sttengine_info_s *data = NULL;
 770
 771         iter = g_slist_nth(g_engine_list, 0);
 772
 773         SLOG(LOG_DEBUG, TAG_STTD, "----- [Engine Agent] engine list -----");
 774
 775         while (NULL != iter) {
 776                 engine_s* temp_engine;
 777
 778                 temp_engine = (engine_s*)calloc(1, sizeof(engine_s));
 779                 if (NULL == temp_engine) {
 780                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory");
 781                         return STTD_ERROR_OUT_OF_MEMORY;
 782                 }
 783
 784                 data = iter->data;
 785
 786                 temp_engine->engine_id = strdup(data->engine_uuid);
 787                 temp_engine->engine_name = strdup(data->engine_name);
 788                 temp_engine->ug_name = strdup(data->engine_setting_path);
 789
 790                 *engine_list = g_slist_append(*engine_list, temp_engine);
 791
 792                 iter = g_slist_next(iter);
 793
 794                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, " -- Engine id(%s)", temp_engine->engine_id);
 795                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "    Engine name(%s)", temp_engine->engine_name);
 796                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "    Engine ug name(%s)", temp_engine->ug_name);
 797         }
 798
 799         SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------");
 800
 801         return 0;
 802 }
 803
 804 int sttd_engine_agent_get_current_engine(int uid, char** engine_uuid)
 805 {
 806         if (false == g_agent_init) {
 807                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 808                 return STTD_ERROR_OPERATION_FAILED;
 809         }
 810
 811         if (NULL == engine_uuid) {
 812                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid parameter");
 813                 return STTD_ERROR_INVALID_PARAMETER;
 814         }
 815
 816         sttengine_info_s* engine;
 817         engine = __engine_agent_get_engine_by_uid(uid);
 818
 819         if (NULL == engine) {
 820                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
 821                 return STTD_ERROR_INVALID_PARAMETER;
 822         }
 823
 824         if (false == engine->is_loaded) {
 825                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 826                 return STTD_ERROR_OPERATION_FAILED;
 827         }
 828
 829         *engine_uuid = strdup(engine->engine_uuid);
 830
 831         return 0;
 832 }
 833
 834 bool sttd_engine_agent_need_network(int uid)
 835 {
 836         if (false == g_agent_init) {
 837                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 838                 return STTD_ERROR_OPERATION_FAILED;
 839         }
 840
 841         sttengine_info_s* engine;
 842         engine = __engine_agent_get_engine_by_uid(uid);
 843
 844         if (NULL != engine)
 845                 return engine->use_network;
 846
 847         return false;
 848 }
 849
 850 int sttd_engine_agent_supported_langs(int uid, GSList** lang_list)
 851 {
 852         if (false == g_agent_init) {
 853                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 854                 return STTD_ERROR_OPERATION_FAILED;
 855         }
 856
 857         if (NULL == lang_list) {
 858                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL");
 859                 return STTD_ERROR_INVALID_PARAMETER;
 860         }
 861
 862         sttengine_info_s* engine = NULL;
 863         engine = __engine_agent_get_engine_by_uid(uid);
 864
 865         if (NULL == engine) {
 866                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
 867                 return STTD_ERROR_INVALID_PARAMETER;
 868         }
 869
 870         if (false == engine->is_loaded) {
 871                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 872                 return STTD_ERROR_OPERATION_FAILED;
 873         }
 874
 875         int ret = stt_engine_get_supported_langs(engine->engine_id, lang_list);
 876         if (0 != ret) {
 877                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret);
 878                 return ret;
 879         }
 880
 881         return 0;
 882 }
 883
 884 int sttd_engine_agent_get_default_lang(int uid, char** lang)
 885 {
 886         if (false == g_agent_init) {
 887                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 888                 return STTD_ERROR_OPERATION_FAILED;
 889         }
 890
 891         if (NULL == lang) {
 892                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 893                 return STTD_ERROR_INVALID_PARAMETER;
 894         }
 895
 896         sttengine_info_s* engine = NULL;
 897         engine = __engine_agent_get_engine_by_uid(uid);
 898
 899         if (NULL == engine) {
 900                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
 901                 return STTD_ERROR_INVALID_PARAMETER;
 902         }
 903
 904         if (false == engine->is_loaded) {
 905                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 906                 return STTD_ERROR_OPERATION_FAILED;
 907         }
 908
 909         /* get default language */
 910         bool is_valid = false;
 911         int ret = -1;
 912         ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid);
 913         if (0 != ret) {
 914                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
 915                 return ret;
 916         }
 917
 918         if (true == is_valid) {
 919                 *lang = strdup(g_default_language);
 920         } else
 921                 *lang = strdup(engine->first_lang);
 922
 923         return 0;
 924 }
 925
 926 int sttd_engine_agent_set_private_data(int uid, const char* key, const char* data)
 927 {
 928         if (false == g_agent_init) {
 929                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 930                 return STTD_ERROR_OPERATION_FAILED;
 931         }
 932
 933         if (NULL == key || NULL == data) {
 934                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 935                 return STTD_ERROR_INVALID_PARAMETER;
 936         }
 937
 938         sttengine_info_s* engine = NULL;
 939         engine = __engine_agent_get_engine_by_uid(uid);
 940
 941         if (NULL == engine) {
 942                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
 943                 return STTD_ERROR_INVALID_PARAMETER;
 944         }
 945
 946         if (false == engine->is_loaded) {
 947                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 948                 return STTD_ERROR_OPERATION_FAILED;
 949         }
 950
 951         /* set private data */
 952         int ret = -1;
 953         ret = stt_engine_set_private_data(engine->engine_id, key, data);
 954         if (0 != ret) {
 955                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set private data");
 956                 return ret;
 957         }
 958
 959         return 0;
 960 }
 961
 962 int sttd_engine_agent_get_private_data(int uid, const char* key, char** data)
 963 {
 964         if (false == g_agent_init) {
 965                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
 966                 return STTD_ERROR_OPERATION_FAILED;
 967         }
 968
 969         if (NULL == key || NULL == data) {
 970                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
 971                 return STTD_ERROR_INVALID_PARAMETER;
 972         }
 973
 974         sttengine_info_s* engine = NULL;
 975         engine = __engine_agent_get_engine_by_uid(uid);
 976
 977         if (NULL == engine) {
 978                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
 979                 return STTD_ERROR_INVALID_PARAMETER;
 980         }
 981
 982         if (false == engine->is_loaded) {
 983                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
 984                 return STTD_ERROR_OPERATION_FAILED;
 985         }
 986
 987         /* get default language */
 988         int ret = -1;
 989         ret = stt_engine_get_private_data(engine->engine_id, key, data);
 990         if (0 != ret) {
 991                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get private data");
 992                 return ret;
 993         }
 994
 995         return 0;
 996 }
 997
 998 int sttd_engine_agent_get_option_supported(int uid, bool* silence)
 999 {
1000         if (false == g_agent_init) {
1001                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1002                 return STTD_ERROR_OPERATION_FAILED;
1003         }
1004
1005         if (NULL == silence) {
1006                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1007                 return STTD_ERROR_INVALID_PARAMETER;
1008         }
1009
1010         sttengine_info_s* engine = NULL;
1011         engine = __engine_agent_get_engine_by_uid(uid);
1012
1013         if (NULL == engine) {
1014                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
1015                 return STTD_ERROR_INVALID_PARAMETER;
1016         }
1017
1018         if (false == engine->is_loaded) {
1019                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1020                 return STTD_ERROR_OPERATION_FAILED;
1021         }
1022
1023         *silence = engine->support_silence_detection;
1024
1025         return 0;
1026 }
1027
1028 int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
1029 {
1030         if (false == g_agent_init) {
1031                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1032                 return STTD_ERROR_OPERATION_FAILED;
1033         }
1034
1035         if (NULL == credential) {
1036                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1037                 return STTD_ERROR_INVALID_PARAMETER;
1038         }
1039
1040         sttengine_info_s* engine = NULL;
1041         engine = __engine_agent_get_engine_by_uid(uid);
1042
1043         if (NULL == engine) {
1044                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
1045                 return STTD_ERROR_INVALID_PARAMETER;
1046         }
1047
1048         if (false == engine->is_loaded) {
1049                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1050                 return STTD_ERROR_OPERATION_FAILED;
1051         }
1052
1053         bool temp = false;
1054         int ret;
1055
1056         ret = stt_engine_need_app_credential(engine->engine_id, &temp);
1057         if (0 != ret) {
1058                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
1059                 return ret;
1060         }
1061
1062         *credential = temp;
1063         return 0;
1064 }
1065
1066 int sttd_engine_agent_is_recognition_type_supported(int uid, const char* type, bool* support)
1067 {
1068         if (false == g_agent_init) {
1069                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1070                 return STTD_ERROR_OPERATION_FAILED;
1071         }
1072
1073         if (NULL == type || NULL == support) {
1074                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1075                 return STTD_ERROR_INVALID_PARAMETER;
1076         }
1077
1078         sttengine_info_s* engine = NULL;
1079         engine = __engine_agent_get_engine_by_uid(uid);
1080
1081         if (NULL == engine) {
1082                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1083                 return STTD_ERROR_INVALID_PARAMETER;
1084         }
1085
1086         if (false == engine->is_loaded) {
1087                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1088                 return STTD_ERROR_OPERATION_FAILED;
1089         }
1090
1091         bool temp = false;
1092         int ret;
1093
1094         ret = stt_engine_support_recognition_type(engine->engine_id, type, &temp);
1095         if (0 != ret) {
1096                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
1097                 return ret;
1098         }
1099
1100         *support = temp;
1101
1102         return 0;
1103 }
1104
1105 /*
1106 * STT Engine Interfaces for client
1107 */
1108
1109 int __set_option(sttengine_info_s* engine, int silence)
1110 {
1111         if (NULL == engine)
1112                 return -1;
1113
1114         /* Check silence detection */
1115         if (engine->support_silence_detection) {
1116                 if (2 == silence) {
1117                         /* default option set */
1118                         if (g_default_silence_detected != engine->silence_detection) {
1119                                 if (0 != stt_engine_set_silence_detection(engine->engine_id, g_default_silence_detected)) {
1120                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false");
1121                                 } else {
1122                                         engine->silence_detection = g_default_silence_detected;
1123                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false");
1124                                 }
1125                         }
1126                 } else {
1127                         if (silence != engine->silence_detection) {
1128                                 if (0 != stt_engine_set_silence_detection(engine->engine_id, silence)) {
1129                                         SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false");
1130                                 } else {
1131                                         engine->silence_detection = silence;
1132                                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false");
1133                                 }
1134                         }
1135                 }
1136         }
1137
1138         return 0;
1139 }
1140
1141 int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
1142                                       int silence, const char* credential, void* user_param)
1143 {
1144         if (false == g_agent_init) {
1145                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1146                 return STTD_ERROR_OPERATION_FAILED;
1147         }
1148
1149         if (NULL == lang || NULL == recognition_type) {
1150                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1151                 return STTD_ERROR_INVALID_PARAMETER;
1152         }
1153
1154         sttengine_info_s* engine = NULL;
1155         engine = __engine_agent_get_engine_by_uid(uid);
1156
1157         if (NULL == engine) {
1158                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1159                 return STTD_ERROR_INVALID_PARAMETER;
1160         }
1161
1162         if (false == engine->is_loaded) {
1163                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1164                 return STTD_ERROR_OPERATION_FAILED;
1165         }
1166
1167         if (0 != __set_option(engine, silence)) {
1168                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options");
1169                 return STTD_ERROR_OPERATION_FAILED;
1170         }
1171
1172         SLOG(LOG_DEBUG, TAG_STTD, "g_default_language %s", g_default_language);
1173
1174         int ret;
1175         char* temp = NULL;
1176         if (0 == strncmp(lang, "default", strlen("default"))) {
1177                 bool is_valid = false;
1178                 ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid);
1179                 if (0 != ret) {
1180                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
1181                         return ret;
1182                 }
1183
1184                 if (true == is_valid) {
1185                         temp = strdup(g_default_language);
1186                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp);
1187                 } else {
1188                         temp = strdup(engine->first_lang);
1189                         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp);
1190                 }
1191         } else {
1192                 temp = strdup(lang);
1193         }
1194
1195         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start engine");
1196
1197         ret = stt_engine_recognize_start(engine->engine_id, temp, recognition_type, credential, user_param);
1198         if (NULL != temp)       free(temp);
1199         if (0 != ret) {
1200                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
1201                 sttd_recorder_destroy(engine->engine_id);
1202                 return ret;
1203         }
1204
1205 #ifdef AUDIO_CREATE_ON_START
1206         /* Ready recorder */
1207         sttp_audio_type_e atype;
1208         int rate;
1209         int channels;
1210
1211         ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels);
1212         if (0 != ret) {
1213                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name);
1214                 return ret;
1215         }
1216
1217         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder");
1218
1219         ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate);
1220         if (0 != ret) {
1221                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name);
1222                 return ret;
1223         }
1224 #endif
1225
1226 #if 0
1227         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
1228
1229         ret = sttd_recorder_start(engine->engine_id);
1230         if (0 != ret) {
1231                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
1232                 return ret;
1233         }
1234
1235         g_recording_engine_id = engine->engine_id;
1236         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] g_recording_engine_id : %d", g_recording_engine_id);
1237 #endif
1238
1239         return 0;
1240 }
1241
1242 int sttd_engine_agent_recognize_start_recorder(int uid)
1243 {
1244         sttengine_info_s* engine = NULL;
1245         engine = __engine_agent_get_engine_by_uid(uid);
1246
1247         if (NULL == engine) {
1248                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1249                 return STTD_ERROR_INVALID_PARAMETER;
1250         }
1251
1252         if (false == engine->is_loaded) {
1253                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1254                 return STTD_ERROR_OPERATION_FAILED;
1255         }
1256
1257         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
1258
1259         int ret;
1260         ret = sttd_recorder_start(engine->engine_id);
1261         if (0 != ret) {
1262                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
1263                 stt_engine_recognize_cancel(engine->engine_id);
1264                 sttd_recorder_stop(engine->engine_id);
1265                 return ret;
1266         }
1267
1268         g_recording_engine_id = engine->engine_id;
1269         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] g_recording_engine_id : %d", g_recording_engine_id);
1270
1271         return 0;
1272 }
1273
1274 int sttd_engine_agent_set_recording_data(int uid, const void* data, unsigned int length)
1275 {
1276         if (false == g_agent_init) {
1277                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1278                 return STTD_ERROR_OPERATION_FAILED;
1279         }
1280
1281         if (NULL == data || 0 == length) {
1282                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1283                 return STTD_ERROR_INVALID_PARAMETER;
1284         }
1285
1286         sttengine_info_s* engine = NULL;
1287         engine = __engine_agent_get_engine_by_uid(uid);
1288
1289         if (NULL == engine) {
1290                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1291                 return STTD_ERROR_INVALID_PARAMETER;
1292         }
1293
1294         if (false == engine->is_loaded) {
1295                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1296                 return STTD_ERROR_OPERATION_FAILED;
1297         }
1298
1299         int ret = stt_engine_set_recording_data(engine->engine_id, data, length);
1300         if (0 != ret) {
1301                 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
1302                 return ret;
1303         }
1304
1305         return 0;
1306 }
1307
1308 int sttd_engine_agent_recognize_stop_recorder(int uid)
1309 {
1310         if (false == g_agent_init) {
1311                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1312                 return STTD_ERROR_OPERATION_FAILED;
1313         }
1314
1315         sttengine_info_s* engine = NULL;
1316         engine = __engine_agent_get_engine_by_uid(uid);
1317
1318         if (NULL == engine) {
1319                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1320                 return STTD_ERROR_INVALID_PARAMETER;
1321         }
1322
1323         if (false == engine->is_loaded) {
1324                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1325                 return STTD_ERROR_OPERATION_FAILED;
1326         }
1327
1328         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
1329         int ret;
1330         ret = sttd_recorder_stop(engine->engine_id);
1331         if (0 != ret) {
1332                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
1333                 return ret;
1334         }
1335
1336 #ifdef AUDIO_CREATE_ON_START
1337         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1338         if (0 != sttd_recorder_destroy(engine->engine_id))
1339                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id);
1340 #endif
1341
1342         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
1343         return 0;
1344 }
1345
1346 int sttd_engine_agent_recognize_stop_engine(int uid)
1347 {
1348         if (false == g_agent_init) {
1349                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1350                 return STTD_ERROR_OPERATION_FAILED;
1351         }
1352
1353         sttengine_info_s* engine = NULL;
1354         engine = __engine_agent_get_engine_by_uid(uid);
1355
1356         if (NULL == engine) {
1357                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1358                 return STTD_ERROR_INVALID_PARAMETER;
1359         }
1360
1361         if (false == engine->is_loaded) {
1362                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1363                 return STTD_ERROR_OPERATION_FAILED;
1364         }
1365
1366         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop engine");
1367
1368         int ret;
1369         ret = stt_engine_recognize_stop(engine->engine_id);
1370         if (0 != ret) {
1371                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
1372                 return ret;
1373         }
1374
1375         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine");
1376
1377         return 0;
1378 }
1379
1380 int sttd_engine_agent_recognize_cancel(int uid)
1381 {
1382         if (false == g_agent_init) {
1383                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1384                 return STTD_ERROR_OPERATION_FAILED;
1385         }
1386
1387         sttengine_info_s* engine = NULL;
1388         engine = __engine_agent_get_engine_by_uid(uid);
1389
1390         if (NULL == engine) {
1391                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1392                 return STTD_ERROR_INVALID_PARAMETER;
1393         }
1394
1395         if (false == engine->is_loaded) {
1396                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1397                 return STTD_ERROR_OPERATION_FAILED;
1398         }
1399
1400         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Cancel engine");
1401
1402         int ret;
1403         ret = stt_engine_recognize_cancel(engine->engine_id);
1404         if (0 != ret) {
1405                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1406                 return ret;
1407         }
1408
1409         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
1410
1411         ret = sttd_recorder_stop(engine->engine_id);
1412         if (0 != ret) {
1413                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
1414                 return ret;
1415         }
1416
1417 #ifdef AUDIO_CREATE_ON_START
1418         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1419         if (0 != sttd_recorder_destroy(engine->engine_id))
1420                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id);
1421 #endif
1422
1423         g_recording_engine_id = -1;
1424
1425         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Cancel recognition");
1426
1427         return 0;
1428 }
1429
1430
1431 /*
1432 * STT Engine Interfaces for configure
1433 */
1434
1435 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
1436 {
1437         if (false == g_agent_init) {
1438                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1439                 return STTD_ERROR_OPERATION_FAILED;
1440         }
1441
1442         if (NULL == engine_uuid) {
1443                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1444                 return STTD_ERROR_INVALID_PARAMETER;
1445         }
1446
1447         __log_enginelist();
1448
1449         sttengine_info_s* engine;
1450         engine = __engine_agent_get_engine_by_uuid(engine_uuid);
1451         if (NULL == engine) {
1452                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid");
1453                 return STTD_ERROR_ENGINE_NOT_FOUND;
1454         }
1455
1456         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine id(%d) engine uuid(%s)", engine->engine_id, engine->engine_uuid);
1457
1458         g_default_engine_id = engine->engine_id;
1459
1460         /* Update default engine of client */
1461         GSList *iter = NULL;
1462         sttengine_client_s *data = NULL;
1463
1464         if (0 < g_slist_length(g_engine_client_list)) {
1465                 iter = g_slist_nth(g_engine_client_list, 0);
1466
1467                 while (NULL != iter) {
1468                         /* Get handle data from list */
1469                         data = iter->data;
1470
1471                         if (true == data->use_default_engine) {
1472                                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] uid(%d) change engine from id(%d) to id(%d)",
1473                                         data->uid, data->engine_id, engine->engine_id);
1474
1475                                 if (0 != sttd_engine_agent_load_current_engine(data->uid, NULL)) {
1476                                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load current engine : uid(%d)", data->uid);
1477                                 }
1478                         }
1479
1480                         iter = g_slist_next(iter);
1481                 }
1482         }
1483
1484         return 0;
1485 }
1486
1487 int sttd_engine_agent_set_default_language(const char* language)
1488 {
1489         if (false == g_agent_init) {
1490                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1491                 return STTD_ERROR_OPERATION_FAILED;
1492         }
1493
1494         if (NULL == language) {
1495                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1496                 return STTD_ERROR_INVALID_PARAMETER;
1497         }
1498
1499         if (NULL != g_default_language)
1500                 free(g_default_language);
1501
1502         g_default_language = strdup(language);
1503
1504         return 0;
1505 }
1506
1507 int sttd_engine_agent_set_silence_detection(bool value)
1508 {
1509         if (false == g_agent_init) {
1510                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1511                 return STTD_ERROR_OPERATION_FAILED;
1512         }
1513
1514         g_default_silence_detected = value;
1515
1516         return 0;
1517 }
1518
1519 int sttd_engine_agent_check_app_agreed(int uid, const char* appid, bool* result)
1520 {
1521         if (false == g_agent_init) {
1522                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1523                 return STTD_ERROR_OPERATION_FAILED;
1524         }
1525
1526         sttengine_info_s* engine = NULL;
1527         engine = __engine_agent_get_engine_by_uid(uid);
1528
1529         if (NULL == engine) {
1530                 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid);
1531                 return STTD_ERROR_INVALID_PARAMETER;
1532         }
1533
1534         if (false == engine->is_loaded) {
1535                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1536                 return STTD_ERROR_OPERATION_FAILED;
1537         }
1538
1539         int ret;
1540         ret = stt_engine_check_app_agreed(engine->engine_id, appid, result);
1541         if (0 != ret) {
1542                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1543                 return ret;
1544         }
1545
1546
1547         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
1548         return 0;
1549 }
1550
1551 static void __recorder_destroy(void* data)
1552 {
1553         sttp_result_event_e event = (sttp_result_event_e)data;
1554
1555         SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder by ecore_thread_safe func");
1556
1557         if (0 != sttd_recorder_destroy(g_recording_engine_id)) {
1558                 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", g_recording_engine_id);
1559         }
1560
1561         if (event == STTP_RESULT_EVENT_FINAL_RESULT || event == STTP_RESULT_EVENT_ERROR) {
1562                 g_recording_engine_id = -1;
1563         }
1564 }
1565
1566
1567 /*
1568 * STT Engine Callback Functions                                                                                 `                                 *
1569 */
1570
1571 void __result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count,
1572                  const char* msg, void* time_info, void *user_data)
1573 {
1574         if (false == g_agent_init) {
1575                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
1576                 return;
1577         }
1578
1579         SLOG(LOG_DEBUG, TAG_STTD, "[Server] === Result time callback ===");
1580
1581         if (NULL != time_info) {
1582                 /* Get the time info */
1583                 int ret = stt_engine_foreach_result_time(g_recording_engine_id, time_info, __result_time_cb, NULL);
1584                 if (0 != ret) {
1585                         SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
1586                 }
1587         }
1588
1589         SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================");
1590
1591         g_result_cb(event, type, data, data_count, msg, user_data);
1592
1593 #ifdef AUDIO_CREATE_ON_START
1594         if (event == STTP_RESULT_EVENT_ERROR) {
1595 #if 1
1596                 ecore_main_loop_thread_safe_call_async(__recorder_destroy, (void*)event);
1597 #else
1598                 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1599                 if (0 != sttd_recorder_destroy(g_recording_engine_id))
1600                         SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", g_recording_engine_id);
1601 #endif
1602         }
1603 #endif
1604
1605 #ifndef AUDIO_CREATE_ON_START
1606         if (event == STTP_RESULT_EVENT_FINAL_RESULT || event == STTP_RESULT_EVENT_ERROR) {
1607                 g_recording_engine_id = -1;
1608         }
1609 #endif
1610         return;
1611 }
1612
1613 bool __result_time_cb(int index, sttp_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
1614 {
1615         return g_result_time_cb(index, event, text, start_time, end_time, user_data);
1616 }
1617
1618 void __detect_silence_cb(sttp_silence_type_e type, void* user_data)
1619 {
1620         if (false == g_agent_init) {
1621                 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
1622                 return;
1623         }
1624
1625         g_silence_cb(type, user_data);
1626         return;
1627 }
1628
1629 /* A function forging */
1630 int __log_enginelist()
1631 {
1632         GSList *iter = NULL;
1633         sttengine_info_s *data = NULL;
1634
1635         if (0 < g_slist_length(g_engine_list)) {
1636
1637                 /* Get a first item */
1638                 iter = g_slist_nth(g_engine_list, 0);
1639
1640                 SLOG(LOG_DEBUG, TAG_STTD, "--------------- engine list -------------------");
1641
1642                 int i = 1;
1643                 while (NULL != iter) {
1644                         /* Get handle data from list */
1645                         data = iter->data;
1646
1647                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[%dth]", i);
1648                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  engine uuid : %s", data->engine_uuid);
1649                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  engine name : %s", data->engine_name);
1650                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  engine path : %s", data->engine_path);
1651                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  use network : %s", data->use_network ? "true" : "false");
1652                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  is loaded : %s", data->is_loaded ? "true" : "false");
1653                         if (NULL != data->first_lang)
1654                                 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "  default lang : %s", data->first_lang);
1655
1656                         iter = g_slist_next(iter);
1657                         i++;
1658                 }
1659                 SLOG(LOG_DEBUG, TAG_STTD, "----------------------------------------------");
1660         } else {
1661                 SLOG(LOG_DEBUG, TAG_STTD, "-------------- engine list -------------------");
1662                 SLOG(LOG_DEBUG, TAG_STTD, "  No Engine in engine directory");
1663                 SLOG(LOG_DEBUG, TAG_STTD, "----------------------------------------------");
1664         }
1665
1666         return 0;
1667 }