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.
21 #include "stt_engine.h"
22 #include "sttd_engine_agent.h"
25 * Internal data structure
30 stte_request_callback_s *callback;
33 extern const char* stt_tag();
36 static sttengine_s *g_engine = NULL;
38 static bool g_is_from_lib = false;
40 /** callback functions */
41 static stt_engine_result_cb g_result_cb = NULL;
42 static stte_private_data_set_cb g_set_private_data_cb = NULL;
43 static stte_private_data_requested_cb g_get_private_data_cb = NULL;
46 static int __stt_set_engine_from(bool is_from_lib)
48 g_is_from_lib = is_from_lib;
52 static bool __stt_get_engine_from(void)
57 static const char* __stt_get_engine_error_code(stte_error_e err)
60 case STTE_ERROR_NONE: return "STTE_ERROR_NONE";
61 case STTE_ERROR_OUT_OF_MEMORY: return "STTE_ERROR_OUT_OF_MEMORY";
62 case STTE_ERROR_IO_ERROR: return "STTE_ERROR_IO_ERROR";
63 case STTE_ERROR_INVALID_PARAMETER: return "STTE_ERROR_INVALID_PARAMETER";
64 case STTE_ERROR_NETWORK_DOWN: return "STTE_ERROR_NETWORK_DOWN";
65 case STTE_ERROR_PERMISSION_DENIED: return "STTE_ERROR_PERMISSION_DENIED";
66 case STTE_ERROR_NOT_SUPPORTED: return "STTE_ERROR_NOT_SUPPORTED";
67 case STTE_ERROR_INVALID_STATE: return "STTE_ERROR_INVALID_STATE";
68 case STTE_ERROR_INVALID_LANGUAGE: return "STTE_ERROR_INVALID_LANGUAGE";
69 case STTE_ERROR_OPERATION_FAILED: return "STTE_ERROR_OPERATION_FAILED";
70 case STTE_ERROR_NOT_SUPPORTED_FEATURE: return "STTE_ERROR_NOT_SUPPORTED_FEATURE";
71 case STTE_ERROR_RECORDING_TIMED_OUT: return "STTE_ERROR_RECORDING_TIMED_OUT";
73 return "Invalid error code";
77 /* Register engine id */
78 int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
80 if (NULL == callback || NULL == filepath) {
81 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
82 return STTE_ERROR_INVALID_PARAMETER;
85 /* allocation memory */
86 if (NULL != g_engine) {
87 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine is already loaded");
89 g_engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
90 if (NULL == g_engine) {
91 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
92 return STTE_ERROR_OUT_OF_MEMORY;
96 g_engine->callback = callback;
97 g_engine->engine_path = strdup(filepath);
100 SLOG(LOG_DEBUG, stt_tag(), "[Engine Success] Load engine : version(%d)", g_engine->callback->version);
105 /* Unregister engine id */
106 int stt_engine_unload()
108 if (NULL == g_engine) {
109 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
110 return STTE_ERROR_OPERATION_FAILED;
113 g_engine->callback = NULL;
115 if (NULL != g_engine->engine_path) {
116 free(g_engine->engine_path);
117 g_engine->engine_path = NULL;
127 /* Initialize / Deinitialize */
128 int stt_engine_initialize(bool is_from_lib)
130 if (NULL == g_engine) {
131 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
132 return STTE_ERROR_OPERATION_FAILED;
135 if (NULL == g_engine->callback) {
136 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
137 return STTE_ERROR_OPERATION_FAILED;
140 if (NULL == g_engine->callback->initialize) {
141 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
142 return STTE_ERROR_OPERATION_FAILED;
146 ret = __stt_set_engine_from(is_from_lib);
148 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set engine : %s", __stt_get_engine_error_code(ret));
149 return STTE_ERROR_OPERATION_FAILED;
152 ret = g_engine->callback->initialize();
154 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
160 int stt_engine_deinitialize()
162 if (NULL == g_engine) {
163 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
164 return STTE_ERROR_OPERATION_FAILED;
167 if (NULL == g_engine->callback) {
168 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
169 return STTE_ERROR_OPERATION_FAILED;
172 if (NULL == g_engine->callback->deinitialize) {
173 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
174 return STTE_ERROR_OPERATION_FAILED;
178 ret = g_engine->callback->deinitialize();
180 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
186 static bool __supported_language_cb(const char* language, void* user_data)
188 GSList** lang_list = (GSList**)user_data;
190 if (NULL == language || NULL == lang_list) {
191 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Input parameter is NULL in callback!!!!");
195 char* temp_lang = g_strdup(language);
197 *lang_list = g_slist_append(*lang_list, temp_lang);
203 int stt_engine_get_supported_langs(GSList** lang_list)
205 if (NULL == lang_list) {
206 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
207 return STTE_ERROR_INVALID_PARAMETER;
210 if (NULL == g_engine) {
211 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
212 return STTE_ERROR_OPERATION_FAILED;
215 if (NULL == g_engine->callback) {
216 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
217 return STTE_ERROR_OPERATION_FAILED;
220 if (NULL == g_engine->callback->foreach_langs) {
221 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
222 return STTE_ERROR_OPERATION_FAILED;
226 ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
228 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
234 int stt_engine_is_valid_language(const char* language, bool *is_valid)
236 if (NULL == language || NULL == is_valid) {
237 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
238 return STTE_ERROR_INVALID_PARAMETER;
241 if (NULL == g_engine) {
242 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
243 return STTE_ERROR_OPERATION_FAILED;
246 if (NULL == g_engine->callback) {
247 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
248 return STTE_ERROR_OPERATION_FAILED;
251 if (NULL == g_engine->callback->is_valid_lang) {
252 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
253 return STTE_ERROR_OPERATION_FAILED;
256 int ret = STTE_ERROR_NONE;
257 ret = g_engine->callback->is_valid_lang(language, is_valid);
259 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to check valid language(%d)", ret);
264 int stt_engine_set_private_data(const char* key, const char* data)
266 if (NULL == key || NULL == data) {
267 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
268 return STTE_ERROR_INVALID_PARAMETER;
271 int ret = STTE_ERROR_NONE;
272 if (NULL != g_set_private_data_cb) {
273 ret = g_set_private_data_cb(key, data);
275 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set private data(%d)", ret);
282 int stt_engine_get_private_data(const char* key, char** data)
284 if (NULL == key || NULL == data) {
285 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
286 return STTE_ERROR_INVALID_PARAMETER;
289 int ret = STTE_ERROR_NONE;
291 if (NULL != g_get_private_data_cb) {
292 ret = g_get_private_data_cb(key, &temp);
294 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get private data(%d)", ret);
298 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] There's no private data function)");
302 *data = strdup("NULL");
304 *data = strdup(temp);
306 return STTE_ERROR_NONE;
309 int stt_engine_get_first_language(char** language)
311 if (NULL == language) {
312 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
313 return STTE_ERROR_INVALID_PARAMETER;
316 if (NULL == g_engine) {
317 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
318 return STTE_ERROR_OPERATION_FAILED;
321 if (NULL == g_engine->callback) {
322 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
323 return STTE_ERROR_OPERATION_FAILED;
326 if (NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang) {
327 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
328 return STTE_ERROR_OPERATION_FAILED;
331 GSList* lang_list = NULL;
333 ret = g_engine->callback->foreach_langs(__supported_language_cb, &lang_list);
335 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
342 iter = g_slist_nth(lang_list, 0);
346 bool is_valid = false;
347 ret = g_engine->callback->is_valid_lang(data, &is_valid);
348 if (0 == ret && true == is_valid) {
349 *language = strdup(data);
351 ret = STTE_ERROR_OPERATION_FAILED;
355 /* if list have item */
356 if (g_slist_length(lang_list) > 0) {
357 /* Get a first item */
358 iter = g_slist_nth(lang_list, 0);
360 while (NULL != iter) {
366 lang_list = g_slist_remove_link(lang_list, iter);
368 iter = g_slist_nth(lang_list, 0);
375 int stt_engine_support_silence(bool* support)
377 if (NULL == support) {
378 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
379 return STTE_ERROR_INVALID_PARAMETER;
382 if (NULL == g_engine) {
383 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
384 return STTE_ERROR_OPERATION_FAILED;
387 if (NULL == g_engine->callback) {
388 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
389 return STTE_ERROR_OPERATION_FAILED;
392 if (NULL == g_engine->callback->support_silence) {
393 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
394 return STTE_ERROR_OPERATION_FAILED;
398 result = g_engine->callback->support_silence();
401 return STTE_ERROR_NONE;
404 int stt_engine_need_app_credential(bool* need)
407 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
408 return STTE_ERROR_INVALID_PARAMETER;
411 if (NULL == g_engine) {
412 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
413 return STTE_ERROR_OPERATION_FAILED;
416 if (NULL == g_engine->callback) {
417 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
418 return STTE_ERROR_OPERATION_FAILED;
421 if (NULL == g_engine->callback->need_app_credential) {
422 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
423 return STTE_ERROR_OPERATION_FAILED;
427 result = g_engine->callback->need_app_credential();
430 return STTE_ERROR_NONE;
433 int stt_engine_support_recognition_type(const char* type, bool* support)
435 if (NULL == type || NULL == support) {
436 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
437 return STTE_ERROR_INVALID_PARAMETER;
440 if (NULL == g_engine) {
441 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
442 return STTE_ERROR_OPERATION_FAILED;
445 if (NULL == g_engine->callback) {
446 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
447 return STTE_ERROR_OPERATION_FAILED;
450 if (NULL == g_engine->callback->support_recognition_type) {
451 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR} Invalid engine");
452 return STTE_ERROR_OPERATION_FAILED;
455 int ret = STTE_ERROR_NONE;
456 ret = g_engine->callback->support_recognition_type(type, support);
458 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get supporting recognition type(%d)", ret);
463 int stt_engine_get_audio_type(stte_audio_type_e* types, int* rate, int* channels)
465 if (NULL == types || NULL == rate || NULL == channels) {
466 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
467 return STTE_ERROR_INVALID_PARAMETER;
470 if (NULL == g_engine) {
471 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
472 return STTE_ERROR_OPERATION_FAILED;
475 if (NULL == g_engine->callback) {
476 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
477 return STTE_ERROR_OPERATION_FAILED;
480 if (NULL == g_engine->callback->get_audio_format) {
481 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
482 return STTE_ERROR_OPERATION_FAILED;
486 ret = g_engine->callback->get_audio_format(types, rate, channels);
488 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
495 int stt_engine_set_silence_detection(bool value)
497 if (NULL == g_engine) {
498 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
499 return STTE_ERROR_OPERATION_FAILED;
502 if (NULL == g_engine->callback) {
503 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
504 return STTE_ERROR_OPERATION_FAILED;
507 if (NULL == g_engine->callback->set_silence_detection) {
508 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
509 return STTE_ERROR_OPERATION_FAILED;
512 int ret = g_engine->callback->set_silence_detection(value);
513 if (STTE_ERROR_NOT_SUPPORTED_FEATURE == ret) {
514 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support silence detection");
515 } else if (0 != ret) {
516 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set silence detection : %d", ret);
521 int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
523 if (NULL == is_agreed) {
524 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
525 return STTE_ERROR_INVALID_PARAMETER;
528 if (NULL == g_engine) {
529 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
530 return STTE_ERROR_OPERATION_FAILED;
533 if (NULL == g_engine->callback) {
534 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
535 return STTE_ERROR_OPERATION_FAILED;
538 if (NULL == g_engine->callback->check_app_agreed) {
539 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support app agreement. All app is available");
544 int ret = g_engine->callback->check_app_agreed(appid, is_agreed);
546 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
554 int stt_engine_recognize_start(const char* lang, const char* recognition_type, const char* appid, const char* credential, void* user_param)
556 if (NULL == lang || NULL == recognition_type) {
557 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
558 return STTE_ERROR_INVALID_PARAMETER;
561 if (NULL == g_engine) {
562 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
563 return STTE_ERROR_OPERATION_FAILED;
566 if (NULL == g_engine->callback) {
567 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
568 return STTE_ERROR_OPERATION_FAILED;
571 if (NULL == g_engine->callback->start) {
572 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
573 return STTE_ERROR_OPERATION_FAILED;
576 int ret = g_engine->callback->start(lang, recognition_type, appid, credential, user_param);
579 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
580 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
586 int stt_engine_set_recording_data(const void* data, unsigned int length)
589 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
590 return STTE_ERROR_INVALID_PARAMETER;
593 if (NULL == g_engine) {
594 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
595 return STTE_ERROR_OPERATION_FAILED;
598 if (NULL == g_engine->callback) {
599 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
600 return STTE_ERROR_OPERATION_FAILED;
603 if (NULL == g_engine->callback->set_recording) {
604 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
605 return STTE_ERROR_OPERATION_FAILED;
608 int ret = g_engine->callback->set_recording(data, length);
610 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
616 int stt_engine_recognize_stop()
618 if (NULL == g_engine) {
619 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
620 return STTE_ERROR_OPERATION_FAILED;
623 if (NULL == g_engine->callback) {
624 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
625 return STTE_ERROR_OPERATION_FAILED;
628 if (NULL == g_engine->callback->stop) {
629 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
630 return STTE_ERROR_OPERATION_FAILED;
633 int ret = g_engine->callback->stop();
635 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
641 int stt_engine_recognize_cancel()
643 if (NULL == g_engine) {
644 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
645 return STTE_ERROR_OPERATION_FAILED;
648 if (NULL == g_engine->callback) {
649 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
650 return STTE_ERROR_OPERATION_FAILED;
653 if (NULL == g_engine->callback->cancel) {
654 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
655 return STTE_ERROR_OPERATION_FAILED;
658 int ret = g_engine->callback->cancel();
660 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
666 int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback, void* user_data)
668 if (NULL == g_engine) {
669 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
670 return STTE_ERROR_OPERATION_FAILED;
673 if (NULL == g_engine->callback) {
674 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
675 return STTE_ERROR_OPERATION_FAILED;
678 if (NULL == g_engine->callback->foreach_result_time) {
679 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
680 return STTE_ERROR_OPERATION_FAILED;
683 int ret = g_engine->callback->foreach_result_time(time_info, callback, user_data);
685 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
691 int stt_engine_recognize_start_file(const char* lang, const char* recognition_type,
692 const char* filepath, stte_audio_type_e audio_type, int sample_rate, void* user_param)
694 if (NULL == filepath || NULL == lang || NULL == recognition_type) {
695 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
696 return STTE_ERROR_INVALID_PARAMETER;
699 if (NULL == g_engine) {
700 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
701 return STTE_ERROR_OPERATION_FAILED;
704 if (NULL == g_engine->callback) {
705 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
706 return STTE_ERROR_OPERATION_FAILED;
709 #ifdef __UNUSED_CODES__
710 if (NULL == g_engine->callback->start_file) {
711 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
712 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
715 int ret = g_engine->callback->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
717 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
723 int stt_engine_recognize_cancel_file()
725 if (NULL == g_engine) {
726 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
727 return STTE_ERROR_OPERATION_FAILED;
730 if (NULL == g_engine->callback) {
731 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
732 return STTE_ERROR_OPERATION_FAILED;
735 #ifdef __UNUSED_CODES__
736 if (NULL == g_engine->callback->cancel_file) {
737 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
738 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
741 int ret = g_engine->callback->cancel_file();
743 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
749 int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* user_data)
751 if (NULL == result_cb) {
752 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
753 return STTE_ERROR_INVALID_PARAMETER;
756 g_result_cb = result_cb;
761 int stt_engine_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
762 const char* msg, void* time_info, void* user_data)
764 if (NULL == type || NULL == result) {
765 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
768 int ret = STTE_ERROR_NONE;
769 if (false == __stt_get_engine_from()) {
770 ret = sttd_engine_agent_send_result(event, type, result, result_count, msg, time_info, user_data);
772 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send result");
775 g_result_cb(event, type, result, result_count, msg, time_info, user_data);
780 int stt_engine_send_error(stte_error_e error, const char* msg)
783 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
786 int ret = STTE_ERROR_NONE;
787 ret = sttd_engine_agent_send_error(error, msg);
789 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send error info");
794 int stt_engine_send_speech_status(stte_speech_status_e status, void* user_data)
796 int ret = STTE_ERROR_NONE;
797 ret = sttd_engine_agent_send_speech_status(status, user_data);
799 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send speech status");
804 int stt_engine_set_private_data_set_cb(stte_private_data_set_cb private_data_set_cb, void* user_data)
806 if (NULL == private_data_set_cb) {
807 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
808 return STTE_ERROR_INVALID_PARAMETER;
811 g_set_private_data_cb = private_data_set_cb;
816 int stt_engine_set_private_data_requested_cb(stte_private_data_requested_cb private_data_requested_cb, void* user_data)
818 if (NULL == private_data_requested_cb) {
819 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
820 return STTE_ERROR_INVALID_PARAMETER;
823 g_get_private_data_cb = private_data_requested_cb;