common/stt_engine.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <dlog.h>
  15 #include <dlfcn.h>
  16 #include <dirent.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdbool.h>
  20
  21 #include "stt_engine.h"
  22 #include "stt_defs.h"
  23 #include "stt_dlog.h"
  24
  25 #ifndef LOG_TAG_STT
  26 #define LOG_TAG_STT TAG_STTE
  27 #endif
  28
  29 /** Internal data structure **/
  30 typedef struct {
  31         char*   engine_path;
  32         stte_request_callback_s *callback;
  33 } sttengine_s;
  34
  35
  36 /** Static variables **/
  37 /* Stt engine */
  38 static sttengine_s *g_engine = NULL;
  39 static bool g_is_from_lib = false;
  40 static char* g_audio_type = NULL;
  41
  42 /* Callback functions */
  43 static stt_engine_result_cb g_result_cb = NULL;
  44 static stte_private_data_set_cb g_set_private_data_cb = NULL;
  45 static stte_private_data_requested_cb g_get_private_data_cb = NULL;
  46 static stte_audio_type_cb g_set_audio_type_cb = NULL;
  47 static void* g_set_audio_type_user_data = NULL;
  48
  49
  50 /** Static function **/
  51 static int __stt_set_engine_from(bool is_from_lib)
  52 {
  53         g_is_from_lib = is_from_lib;
  54         return 0;
  55 }
  56
  57 static bool __stt_get_engine_from(void)
  58 {
  59         return g_is_from_lib;
  60 }
  61
  62 static const char* __stt_get_engine_error_code(stte_error_e err)
  63 {
  64         switch (err) {
  65         case STTE_ERROR_NONE:                   return "STTE_ERROR_NONE";
  66         case STTE_ERROR_OUT_OF_MEMORY:          return "STTE_ERROR_OUT_OF_MEMORY";
  67         case STTE_ERROR_IO_ERROR:               return "STTE_ERROR_IO_ERROR";
  68         case STTE_ERROR_INVALID_PARAMETER:      return "STTE_ERROR_INVALID_PARAMETER";
  69         case STTE_ERROR_NETWORK_DOWN:           return "STTE_ERROR_NETWORK_DOWN";
  70         case STTE_ERROR_PERMISSION_DENIED:      return "STTE_ERROR_PERMISSION_DENIED";
  71         case STTE_ERROR_NOT_SUPPORTED:          return "STTE_ERROR_NOT_SUPPORTED";
  72         case STTE_ERROR_INVALID_STATE:          return "STTE_ERROR_INVALID_STATE";
  73         case STTE_ERROR_INVALID_LANGUAGE:       return "STTE_ERROR_INVALID_LANGUAGE";
  74         case STTE_ERROR_OPERATION_FAILED:       return "STTE_ERROR_OPERATION_FAILED";
  75         case STTE_ERROR_NOT_SUPPORTED_FEATURE:  return "STTE_ERROR_NOT_SUPPORTED_FEATURE";
  76         case STTE_ERROR_RECORDING_TIMED_OUT:    return "STTE_ERROR_RECORDING_TIMED_OUT";
  77         default:
  78                 return "Invalid error code";
  79         }
  80 }
  81
  82
  83 /** Public function **/
  84 /* Register engine id */
  85 int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
  86 {
  87         RETVM_IF(NULL == callback || NULL == filepath, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
  88
  89         /* allocation memory */
  90         if (NULL != g_engine) {
  91                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine is already loaded");
  92         } else {
  93                 g_engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
  94                 if (NULL == g_engine) {
  95                         SLOG(LOG_ERROR, TAG_STTE, "[ERROR] Fail to allocate memory");
  96                         return STTE_ERROR_OUT_OF_MEMORY;
  97                 }
  98
  99                 /* load engine */
 100                 g_engine->callback = callback;
 101                 g_engine->engine_path = strdup(filepath);
 102         }
 103
 104         SLOG(LOG_DEBUG, TAG_STTE, "[Engine Success] Load engine : version(%d)", g_engine->callback->version);
 105
 106         return 0;
 107 }
 108
 109 /* Unregister engine id */
 110 int stt_engine_unload()
 111 {
 112         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 113
 114         g_engine->callback = NULL;
 115
 116         if (NULL != g_engine->engine_path) {
 117                 free(g_engine->engine_path);
 118                 g_engine->engine_path = NULL;
 119         }
 120
 121         free(g_engine);
 122         g_engine = NULL;
 123
 124         return 0;
 125 }
 126
 127
 128 /* Initialize / Deinitialize */
 129 int stt_engine_initialize(bool is_from_lib)
 130 {
 131         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 132         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 133         RETVM_IF(NULL == g_engine->callback->initialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 134
 135         int ret;
 136         ret = __stt_set_engine_from(is_from_lib);
 137         if (0 != ret) {
 138                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set engine : %s", __stt_get_engine_error_code(ret));
 139                 return STTE_ERROR_OPERATION_FAILED;
 140         }
 141
 142         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to initialize");
 143
 144         ret = g_engine->callback->initialize();
 145         if (0 != ret) {
 146                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
 147         }
 148
 149         return ret;
 150 }
 151
 152 int stt_engine_deinitialize()
 153 {
 154         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 155         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 156         RETVM_IF(NULL == g_engine->callback->deinitialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 157
 158         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to deinitialize");
 159
 160         int ret;
 161         ret = g_engine->callback->deinitialize();
 162         if (0 != ret) {
 163                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
 164         }
 165
 166         return ret;
 167 }
 168
 169 static bool __supported_language_cb(const char* language, void* user_data)
 170 {
 171         GSList** lang_list = (GSList**)user_data;
 172
 173         if (NULL == language || NULL == lang_list) {
 174                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Input parameter is NULL in callback!!!!");
 175                 return false;
 176         }
 177
 178         char* temp_lang = g_strdup(language);
 179
 180         *lang_list = g_slist_append(*lang_list, temp_lang);
 181
 182         return true;
 183 }
 184
 185 /* Get option */
 186 int stt_engine_get_supported_langs(GSList** lang_list)
 187 {
 188         RETVM_IF(NULL == lang_list, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 189         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 190         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 191         RETVM_IF(NULL == g_engine->callback->foreach_langs, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 192
 193         int ret;
 194         ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
 195         if (0 != ret) {
 196                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
 197         }
 198
 199         return ret;
 200 }
 201
 202 int stt_engine_is_valid_language(const char* language, bool *is_valid)
 203 {
 204         RETVM_IF(NULL == language || NULL == is_valid, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 205         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 206         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 207         RETVM_IF(NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 208
 209         int ret = STTE_ERROR_NONE;
 210         ret = g_engine->callback->is_valid_lang(language, is_valid);
 211         if (0 != ret) {
 212                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to check valid language(%d)", ret);
 213         }
 214         return ret;
 215 }
 216
 217 int stt_engine_set_private_data(const char* key, const char* data)
 218 {
 219         RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 220
 221         int ret = STTE_ERROR_NONE;
 222         if (NULL != g_set_private_data_cb) {
 223                 ret = g_set_private_data_cb(key, data);
 224                 if (0 != ret) {
 225                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set private data(%d)", ret);
 226                 }
 227         }
 228
 229         return ret;
 230 }
 231
 232 int stt_engine_get_private_data(const char* key, char** data)
 233 {
 234         RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 235
 236         int ret = STTE_ERROR_NONE;
 237         char* temp = NULL;
 238         if (NULL != g_get_private_data_cb) {
 239                 ret = g_get_private_data_cb(key, &temp);
 240                 if (0 != ret) {
 241                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get private data(%d)", ret);
 242                         return ret;
 243                 }
 244         } else {
 245                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no private data function)");
 246         }
 247
 248         if (NULL == temp)
 249                 *data = strdup("NULL");
 250         else
 251                 *data = strdup(temp);
 252
 253         return STTE_ERROR_NONE;
 254 }
 255
 256 int stt_engine_get_first_language(char** language)
 257 {
 258         RETVM_IF(NULL == language, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 259         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 260         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 261         RETVM_IF(NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 262
 263         GSList* lang_list = NULL;
 264         int ret;
 265         ret = g_engine->callback->foreach_langs(__supported_language_cb, &lang_list);
 266         if (0 != ret) {
 267                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
 268                 return ret;
 269         }
 270
 271         GSList *iter = NULL;
 272
 273         iter = g_slist_nth(lang_list, 0);
 274         if (NULL != iter) {
 275                 char* data = iter->data;
 276
 277                 bool is_valid = false;
 278                 ret = g_engine->callback->is_valid_lang(data, &is_valid);
 279                 if (0 == ret && true == is_valid) {
 280                         *language = strdup(data);
 281                 } else {
 282                         ret = STTE_ERROR_OPERATION_FAILED;
 283                 }
 284         }
 285
 286         /* if list have item */
 287         if (g_slist_length(lang_list) > 0) {
 288                 /* Get a first item */
 289                 iter = g_slist_nth(lang_list, 0);
 290
 291                 while (NULL != iter) {
 292                         char* data = iter->data;
 293
 294                         if (NULL != data) {
 295                                 free(data);
 296                                 data = NULL;
 297                         }
 298
 299                         lang_list = g_slist_remove_link(lang_list, iter);
 300
 301                         iter = g_slist_nth(lang_list, 0);
 302                 }
 303         }
 304
 305         return ret;
 306 }
 307
 308 int stt_engine_support_silence(bool* support)
 309 {
 310         RETVM_IF(NULL == support, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 311         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 312         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 313         RETVM_IF(NULL == g_engine->callback->support_silence, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 314
 315         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support silence");
 316
 317         bool result;
 318         result = g_engine->callback->support_silence();
 319         *support = result;
 320
 321         return STTE_ERROR_NONE;
 322 }
 323
 324 int stt_engine_need_app_credential(bool* need)
 325 {
 326         RETVM_IF(NULL == need, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 327         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 328         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 329         RETVM_IF(NULL == g_engine->callback->need_app_credential, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 330
 331         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to need app credential");
 332
 333         bool result;
 334         result = g_engine->callback->need_app_credential();
 335         *need = result;
 336
 337         return STTE_ERROR_NONE;
 338 }
 339
 340 int stt_engine_support_recognition_type(const char* type, bool* support)
 341 {
 342         RETVM_IF(NULL == type || NULL == support, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 343         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 344         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 345         RETVM_IF(NULL == g_engine->callback->support_recognition_type, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 346
 347         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support recognition type, type(%s)", type);
 348
 349         int ret = STTE_ERROR_NONE;
 350         ret = g_engine->callback->support_recognition_type(type, support);
 351         if (0 != ret) {
 352                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get supporting recognition type(%d)", ret);
 353         }
 354         return ret;
 355 }
 356
 357 int stt_engine_get_audio_format(stte_audio_type_e* types, int* rate, int* channels)
 358 {
 359         RETVM_IF(NULL == types || NULL == rate || NULL == channels, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 360         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 361         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 362         RETVM_IF(NULL == g_engine->callback->get_audio_format, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 363
 364         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to get audio format");
 365
 366         int ret;
 367         ret = g_engine->callback->get_audio_format(types, rate, channels);
 368         if (0 != ret) {
 369                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
 370         }
 371
 372         return ret;
 373 }
 374
 375 /* Set option */
 376 int stt_engine_set_silence_detection(bool value)
 377 {
 378         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 379         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 380         RETVM_IF(NULL == g_engine->callback->set_silence_detection, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 381
 382         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to set silence detection(%d)", value);
 383
 384         int ret = g_engine->callback->set_silence_detection(value);
 385         if (STTE_ERROR_NOT_SUPPORTED_FEATURE == ret) {
 386                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Not support silence detection");
 387         } else if (0 != ret) {
 388                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set silence detection : %d", ret);
 389         }
 390         return ret;
 391 }
 392
 393 int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
 394 {
 395         RETVM_IF(NULL == is_agreed, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid parameter");
 396         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 397         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 398
 399         if (NULL == g_engine->callback->check_app_agreed) {
 400                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Not support app agreement. All app is available");
 401                 *is_agreed = true;
 402                 return 0;
 403         }
 404
 405         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to app agreed, appid(%s), is_agreed(%d)", appid, *is_agreed);
 406
 407         int ret = g_engine->callback->check_app_agreed(appid, is_agreed);
 408         if (0 != ret) {
 409                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
 410                 *is_agreed = false;
 411         }
 412
 413         return ret;
 414 }
 415
 416 /* Recognition */
 417 int stt_engine_recognize_start(const char* lang, const char* recognition_type, const char* appid, const char* credential, void* user_param)
 418 {
 419         RETVM_IF(NULL == lang || NULL == recognition_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 420         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 421         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 422         RETVM_IF(NULL == g_engine->callback->start, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 423
 424         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to start, lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
 425
 426         int ret = g_engine->callback->start(lang, recognition_type, appid, credential, user_param);
 427
 428         if (0 != ret) {
 429                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
 430                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
 431         }
 432
 433         return ret;
 434 }
 435
 436 int stt_engine_set_recording_data(const void* data, unsigned int length)
 437 {
 438         RETVM_IF(NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 439         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 440         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 441         RETVM_IF(NULL == g_engine->callback->set_recording, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 442
 443         int ret = g_engine->callback->set_recording(data, length);
 444         if (0 != ret) {
 445                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
 446         }
 447
 448         return ret;
 449 }
 450
 451 int stt_engine_recognize_stop()
 452 {
 453         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 454         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 455         RETVM_IF(NULL == g_engine->callback->stop, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 456
 457         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to stop");
 458
 459         int ret = g_engine->callback->stop();
 460         if (0 != ret) {
 461                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
 462         }
 463
 464         return ret;
 465 }
 466
 467 int stt_engine_recognize_cancel()
 468 {
 469         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 470         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 471         RETVM_IF(NULL == g_engine->callback->cancel, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 472
 473         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to cancel");
 474
 475         int ret = g_engine->callback->cancel();
 476         if (0 != ret) {
 477                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
 478         }
 479
 480         return ret;
 481 }
 482
 483 int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback, void* user_data)
 484 {
 485         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 486         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 487         RETVM_IF(NULL == g_engine->callback->foreach_result_time, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 488
 489         int ret = g_engine->callback->foreach_result_time(time_info, callback, user_data);
 490         if (0 != ret) {
 491                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
 492         }
 493
 494         return ret;
 495 }
 496
 497 int stt_engine_recognize_start_file(const char* lang, const char* recognition_type,
 498                                      const char* filepath, stte_audio_type_e audio_type, int sample_rate, void* user_param)
 499 {
 500         RETVM_IF(NULL == filepath || NULL == lang || NULL == recognition_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 501         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 502         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 503
 504 #ifdef __UNUSED_CODES__
 505         if (NULL == g_engine->callback->start_file) {
 506                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine API is invalid");
 507                 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
 508         }
 509
 510         int ret = g_engine->callback->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
 511         if (0 != ret) {
 512                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
 513         }
 514 #endif
 515         return 0;
 516 }
 517
 518 int stt_engine_recognize_cancel_file()
 519 {
 520         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 521         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 522
 523 #ifdef __UNUSED_CODES__
 524         if (NULL == g_engine->callback->cancel_file) {
 525                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine API is invalid");
 526                 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
 527         }
 528
 529         int ret = g_engine->callback->cancel_file();
 530         if (0 != ret) {
 531                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
 532         }
 533 #endif
 534         return 0;
 535 }
 536
 537 int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* user_data)
 538 {
 539         RETVM_IF(NULL == result_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 540
 541         g_result_cb = result_cb;
 542
 543         return 0;
 544 }
 545
 546 int stt_engine_get_recognition_result_cb(stt_engine_result_cb* result_cb)
 547 {
 548         RETVM_IF(NULL == result_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 549
 550         if (false == __stt_get_engine_from()) {
 551                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Engine is not loaded from file");
 552                 return STTE_ERROR_NOT_SUPPORTED;
 553         }
 554
 555         *result_cb = g_result_cb;
 556         return STTE_ERROR_NONE;
 557 }
 558
 559 int stt_engine_set_private_data_set_cb(stte_private_data_set_cb private_data_set_cb, void* user_data)
 560 {
 561         RETVM_IF(NULL == private_data_set_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 562
 563         g_set_private_data_cb = private_data_set_cb;
 564
 565         return 0;
 566 }
 567
 568 int stt_engine_set_private_data_requested_cb(stte_private_data_requested_cb private_data_requested_cb, void* user_data)
 569 {
 570         RETVM_IF(NULL == private_data_requested_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 571
 572         g_get_private_data_cb = private_data_requested_cb;
 573
 574         return 0;
 575 }
 576
 577 int stt_engine_get_audio_type(char** audio_type)
 578 {
 579         RETVM_IF(NULL == audio_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 580
 581         if (NULL != g_audio_type) {
 582                 *audio_type = strdup(g_audio_type);
 583                 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] get audio type(%s)", *audio_type);
 584         } else {
 585                 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] Audio type is null");
 586         }
 587
 588         return STTE_ERROR_NONE;
 589 }
 590
 591 int stt_engine_set_audio_type(const char* audio_type)
 592 {
 593         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] set audio type (%s)", audio_type);
 594
 595         if (NULL != g_audio_type && NULL != audio_type && 0 == strncmp(audio_type, g_audio_type, STT_MAX_TYPE_LENGTH)) {
 596                 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] Audio type is not changed(%s)", g_audio_type);
 597                 return STTE_ERROR_NONE;
 598         }
 599
 600         int ret = STTE_ERROR_NONE;
 601         if (NULL != g_set_audio_type_cb && NULL != audio_type) {
 602                 ret = g_set_audio_type_cb(audio_type, g_set_audio_type_user_data);
 603                 if (STTE_ERROR_NONE != ret) {
 604                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set audio type, ret(%d)", ret);
 605                 }
 606         } else {
 607                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no set audio function)");
 608         }
 609
 610         if (NULL != g_audio_type) {
 611                 free(g_audio_type);
 612                 g_audio_type = NULL;
 613         }
 614
 615         if (NULL != audio_type) {
 616                 g_audio_type = strdup(audio_type);
 617         }
 618
 619         return ret;
 620 }
 621
 622 int stt_engine_set_audio_type_set_cb(stte_audio_type_cb audio_type_set_cb, void* user_data)
 623 {
 624         RETVM_IF(NULL == audio_type_set_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 625
 626         g_set_audio_type_cb = audio_type_set_cb;
 627         g_set_audio_type_user_data = user_data;
 628
 629         return 0;
 630 }
 631
 632 int stt_engine_unset_audio_type_set_cb(void)
 633 {
 634         g_set_audio_type_cb = NULL;
 635         g_set_audio_type_user_data = NULL;
 636
 637         return 0;
 638 }