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
  41 /* Callback functions */
  42 static stt_engine_result_cb g_result_cb = NULL;
  43 static stte_private_data_set_cb g_set_private_data_cb = NULL;
  44 static stte_private_data_requested_cb g_get_private_data_cb = NULL;
  45 static stte_audio_type_cb g_set_audio_type_cb = NULL;
  46 static void* g_set_audio_type_user_data = NULL;
  47
  48
  49 /** Static function **/
  50 static int __stt_set_engine_from(bool is_from_lib)
  51 {
  52         g_is_from_lib = is_from_lib;
  53         return 0;
  54 }
  55
  56 static bool __stt_get_engine_from(void)
  57 {
  58         return g_is_from_lib;
  59 }
  60
  61 static const char* __stt_get_engine_error_code(stte_error_e err)
  62 {
  63         switch (err) {
  64         case STTE_ERROR_NONE:                   return "STTE_ERROR_NONE";
  65         case STTE_ERROR_OUT_OF_MEMORY:          return "STTE_ERROR_OUT_OF_MEMORY";
  66         case STTE_ERROR_IO_ERROR:               return "STTE_ERROR_IO_ERROR";
  67         case STTE_ERROR_INVALID_PARAMETER:      return "STTE_ERROR_INVALID_PARAMETER";
  68         case STTE_ERROR_NETWORK_DOWN:           return "STTE_ERROR_NETWORK_DOWN";
  69         case STTE_ERROR_PERMISSION_DENIED:      return "STTE_ERROR_PERMISSION_DENIED";
  70         case STTE_ERROR_NOT_SUPPORTED:          return "STTE_ERROR_NOT_SUPPORTED";
  71         case STTE_ERROR_INVALID_STATE:          return "STTE_ERROR_INVALID_STATE";
  72         case STTE_ERROR_INVALID_LANGUAGE:       return "STTE_ERROR_INVALID_LANGUAGE";
  73         case STTE_ERROR_OPERATION_FAILED:       return "STTE_ERROR_OPERATION_FAILED";
  74         case STTE_ERROR_NOT_SUPPORTED_FEATURE:  return "STTE_ERROR_NOT_SUPPORTED_FEATURE";
  75         case STTE_ERROR_RECORDING_TIMED_OUT:    return "STTE_ERROR_RECORDING_TIMED_OUT";
  76         default:
  77                 return "Invalid error code";
  78         }
  79 }
  80
  81
  82 /** Public function **/
  83 /* Register engine id */
  84 int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
  85 {
  86         RETVM_IF(NULL == callback || NULL == filepath, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
  87
  88         /* allocation memory */
  89         if (NULL != g_engine) {
  90                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine is already loaded");
  91         } else {
  92                 g_engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
  93                 if (NULL == g_engine) {
  94                         SLOG(LOG_ERROR, TAG_STTE, "[ERROR] Fail to allocate memory");
  95                         return STTE_ERROR_OUT_OF_MEMORY;
  96                 }
  97
  98                 /* load engine */
  99                 g_engine->callback = callback;
 100                 g_engine->engine_path = strdup(filepath);
 101         }
 102
 103         SLOG(LOG_DEBUG, TAG_STTE, "[Engine Success] Load engine : version(%d)", g_engine->callback->version);
 104
 105         return 0;
 106 }
 107
 108 /* Unregister engine id */
 109 int stt_engine_unload()
 110 {
 111         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 112
 113         g_engine->callback = NULL;
 114
 115         if (NULL != g_engine->engine_path) {
 116                 free(g_engine->engine_path);
 117                 g_engine->engine_path = NULL;
 118         }
 119
 120         free(g_engine);
 121         g_engine = NULL;
 122
 123         return 0;
 124 }
 125
 126
 127 /* Initialize / Deinitialize */
 128 int stt_engine_initialize(bool is_from_lib)
 129 {
 130         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 131         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 132         RETVM_IF(NULL == g_engine->callback->initialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 133
 134         int ret;
 135         ret = __stt_set_engine_from(is_from_lib);
 136         if (0 != ret) {
 137                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set engine : %s", __stt_get_engine_error_code(ret));
 138                 return STTE_ERROR_OPERATION_FAILED;
 139         }
 140
 141         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to initialize");
 142
 143         ret = g_engine->callback->initialize();
 144         if (0 != ret) {
 145                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
 146         }
 147
 148         return ret;
 149 }
 150
 151 int stt_engine_deinitialize()
 152 {
 153         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 154         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 155         RETVM_IF(NULL == g_engine->callback->deinitialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 156
 157         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to deinitialize");
 158
 159         int ret;
 160         ret = g_engine->callback->deinitialize();
 161         if (0 != ret) {
 162                 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
 163         }
 164
 165         return ret;
 166 }
 167
 168 static bool __supported_language_cb(const char* language, void* user_data)
 169 {
 170         GSList** lang_list = (GSList**)user_data;
 171
 172         if (NULL == language || NULL == lang_list) {
 173                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Input parameter is NULL in callback!!!!");
 174                 return false;
 175         }
 176
 177         char* temp_lang = g_strdup(language);
 178
 179         *lang_list = g_slist_append(*lang_list, temp_lang);
 180
 181         return true;
 182 }
 183
 184 /* Get option */
 185 int stt_engine_get_supported_langs(GSList** lang_list)
 186 {
 187         RETVM_IF(NULL == lang_list, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 188         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 189         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 190         RETVM_IF(NULL == g_engine->callback->foreach_langs, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 191
 192         int ret;
 193         ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
 194         if (0 != ret) {
 195                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
 196         }
 197
 198         return ret;
 199 }
 200
 201 int stt_engine_is_valid_language(const char* language, bool *is_valid)
 202 {
 203         RETVM_IF(NULL == language || NULL == is_valid, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 204         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 205         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 206         RETVM_IF(NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 207
 208         int ret = STTE_ERROR_NONE;
 209         ret = g_engine->callback->is_valid_lang(language, is_valid);
 210         if (0 != ret) {
 211                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to check valid language(%d)", ret);
 212         }
 213         return ret;
 214 }
 215
 216 int stt_engine_set_private_data(const char* key, const char* data)
 217 {
 218         RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 219
 220         int ret = STTE_ERROR_NONE;
 221         if (NULL != g_set_private_data_cb) {
 222                 ret = g_set_private_data_cb(key, data);
 223                 if (0 != ret) {
 224                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set private data(%d)", ret);
 225                 }
 226         }
 227
 228         return ret;
 229 }
 230
 231 int stt_engine_get_private_data(const char* key, char** data)
 232 {
 233         RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 234
 235         int ret = STTE_ERROR_NONE;
 236         char* temp = NULL;
 237         if (NULL != g_get_private_data_cb) {
 238                 ret = g_get_private_data_cb(key, &temp);
 239                 if (0 != ret) {
 240                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get private data(%d)", ret);
 241                         return ret;
 242                 }
 243         } else {
 244                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no private data function)");
 245         }
 246
 247         if (NULL == temp)
 248                 *data = strdup("NULL");
 249         else
 250                 *data = strdup(temp);
 251
 252         return STTE_ERROR_NONE;
 253 }
 254
 255 int stt_engine_get_first_language(char** language)
 256 {
 257         RETVM_IF(NULL == language, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 258         RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 259         RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 260         RETVM_IF(NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 261
 262         GSList* lang_list = NULL;
 263         int ret;
 264         ret = g_engine->callback->foreach_langs(__supported_language_cb, &lang_list);
 265         if (0 != ret) {
 266                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
 267                 return ret;
 268         }
 269
 270         GSList *iter = NULL;
 271         char* data = NULL;
 272
 273         iter = g_slist_nth(lang_list, 0);
 274         if (NULL != iter) {
 275                 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                         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_set_audio_type(const char* audio_type)
 578 {
 579         RETVM_IF(NULL == audio_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 580
 581         SLOG(LOG_INFO, TAG_STTE, "[Engine Info] set audio type (%s)", audio_type);
 582
 583         int ret = STTE_ERROR_NONE;
 584         if (NULL != g_set_audio_type_cb) {
 585                 ret = g_set_audio_type_cb(audio_type, g_set_audio_type_user_data);
 586                 if (0 != ret) {
 587                         SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set audio type, ret(%d)", ret);
 588                 }
 589         } else {
 590                 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no set audio function)");
 591         }
 592
 593         return ret;
 594 }
 595
 596 int stt_engine_set_audio_type_set_cb(stte_audio_type_cb audio_type_set_cb, void* user_data)
 597 {
 598         RETVM_IF(NULL == audio_type_set_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 599
 600         g_set_audio_type_cb = audio_type_set_cb;
 601         g_set_audio_type_user_data = user_data;
 602
 603         return 0;
 604 }
 605
 606 int stt_engine_unset_audio_type_set_cb(void)
 607 {
 608         g_set_audio_type_cb = NULL;
 609         g_set_audio_type_user_data = NULL;
 610
 611         return 0;
 612 }