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.
19 #include "stt_engine.h"
20 #include "sttd_main.h"
21 #include "sttd_client_data.h"
22 #include "sttd_config.h"
23 #include "sttd_dbus.h"
24 #include "sttd_recorder.h"
25 #include "sttd_engine_agent.h"
28 #define AUDIO_CREATE_ON_START
31 * Internal data structure
34 typedef struct _sttengine_info {
38 char* engine_setting_path;
43 /* engine base setting */
45 bool silence_detection;
46 bool support_silence_detection;
50 /** stt engine agent init */
51 static bool g_agent_init;
53 static sttengine_info_s* g_engine_info = NULL;
55 /** default engine info */
56 static char* g_default_language = NULL;
57 static bool g_default_silence_detected;
59 /** callback functions */
60 static result_callback g_result_cb = NULL;
61 static result_time_callback g_result_time_cb = NULL;
62 static speech_status_callback g_speech_status_cb = NULL;
63 static error_callback g_error_cb = NULL;
65 /** callback functions */
66 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text,
67 long start_time, long end_time, void* user_data);
69 bool __supported_language_cb(const char* language, void* user_data);
75 /** get engine info */
76 int __internal_get_engine_info(stte_request_callback_s *callback, sttengine_info_s** info);
78 int __log_enginelist();
81 * STT Engine Agent Interfaces
83 int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb,
84 speech_status_callback speech_status_cb, error_callback error_cb)
86 /* initialize static data */
87 if (NULL == result_cb || NULL == time_cb || NULL == speech_status_cb || NULL == error_cb) {
88 SLOG(LOG_ERROR, TAG_STTD, "[Engine agent ERROR] Invalid parameter");
89 return STTD_ERROR_INVALID_PARAMETER;
92 g_result_cb = result_cb;
93 g_result_time_cb = time_cb;
94 g_speech_status_cb = speech_status_cb;
95 g_error_cb = error_cb;
97 g_default_language = NULL;
99 if (0 != sttd_config_get_default_language(&(g_default_language))) {
100 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is No default voice in config");
101 /* Set default voice */
102 g_default_language = strdup("en_US");
104 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default language is %s", g_default_language);
108 if (0 != sttd_config_get_default_silence_detection(&temp)) {
109 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no silence detection in config");
110 g_default_silence_detected = true;
112 g_default_silence_detected = (bool)temp;
120 int __engine_agent_clear_engine(sttengine_info_s *engine)
122 if (NULL != engine) {
123 if (NULL != engine->engine_uuid) free(engine->engine_uuid);
124 if (NULL != engine->engine_path) free(engine->engine_path);
125 if (NULL != engine->engine_name) free(engine->engine_name);
126 if (NULL != engine->engine_setting_path)free(engine->engine_setting_path);
127 if (NULL != engine->first_lang) free(engine->first_lang);
136 int sttd_engine_agent_release()
138 if (NULL != g_engine_info) {
139 if (g_engine_info->is_loaded) {
140 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine");
142 if (0 != stt_engine_deinitialize()) {
143 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize");
146 if (0 != stt_engine_unload()) {
147 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine");
150 if (NULL != g_engine_info->engine_uuid) {
151 free(g_engine_info->engine_uuid);
152 g_engine_info->engine_uuid = NULL;
155 if (NULL != g_engine_info->engine_path) {
156 free(g_engine_info->engine_path);
157 g_engine_info->engine_path = NULL;
160 if (NULL != g_engine_info->engine_name) {
161 free(g_engine_info->engine_name);
162 g_engine_info->engine_name = NULL;
165 if (NULL != g_engine_info->engine_setting_path) {
166 free(g_engine_info->engine_setting_path);
167 g_engine_info->engine_setting_path = NULL;
170 if (NULL != g_engine_info->first_lang) {
171 free(g_engine_info->first_lang);
172 g_engine_info->first_lang = NULL;
175 g_engine_info->is_loaded = false;
178 __engine_agent_clear_engine(g_engine_info);
182 g_speech_status_cb = NULL;
184 g_result_time_cb = NULL;
186 g_agent_init = false;
191 int __internal_get_engine_info(stte_request_callback_s *callback, sttengine_info_s** info)
193 sttengine_info_s* temp;
194 temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s));
196 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] fail to allocate memory");
197 return STTD_ERROR_OUT_OF_MEMORY;
200 if (NULL == callback) {
201 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid engine");
203 return STTD_ERROR_ENGINE_NOT_FOUND;
206 if (NULL == callback->get_info) {
207 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid engine");
209 return STTD_ERROR_ENGINE_NOT_FOUND;
212 if (0 != callback->get_info(&(temp->engine_uuid), &(temp->engine_name), &(temp->engine_setting_path), &(temp->use_network))) {
213 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info");
215 return STTD_ERROR_ENGINE_NOT_FOUND;
218 /* todo - removed? */
219 temp->engine_path = strdup("empty");
220 temp->is_loaded = false;
222 SLOG(LOG_DEBUG, TAG_STTD, "----- Valid Engine");
223 SLOG(LOG_DEBUG, TAG_STTD, "Engine uuid : %s", (NULL == temp->engine_uuid) ? "NULL" : temp->engine_uuid);
224 SLOG(LOG_DEBUG, TAG_STTD, "Engine name : %s", (NULL == temp->engine_name) ? "NULL" : temp->engine_name);
225 SLOG(LOG_DEBUG, TAG_STTD, "Engine path : %s", (NULL == temp->engine_path) ? "NULL" : temp->engine_path);
226 SLOG(LOG_DEBUG, TAG_STTD, "Engine setting path : %s", (NULL == temp->engine_setting_path) ? "NULL" : temp->engine_setting_path);
227 SLOG(LOG_DEBUG, TAG_STTD, "Use network : %s", temp->use_network ? "true" : "false");
228 SLOG(LOG_DEBUG, TAG_STTD, "-----");
229 SLOG(LOG_DEBUG, TAG_STTD, " ");
233 return STTD_ERROR_NONE;
236 bool __is_engine(const char* filepath)
238 if (NULL == filepath) {
239 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No filepath");
243 if (NULL != g_engine_info) {
244 if (!strcmp(g_engine_info->engine_path, filepath)) {
252 int __engine_agent_check_engine_unload()
254 /* Check the count of client to use this engine */
255 if (NULL == g_engine_info) {
256 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No engine");
258 if (g_engine_info->is_loaded) {
260 #ifndef AUDIO_CREATE_ON_START
261 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
262 if (0 != sttd_recorder_destroy())
263 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
265 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine");
266 if (0 != stt_engine_deinitialize())
267 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine");
269 if (0 != stt_engine_unload())
270 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine");
272 g_engine_info->is_loaded = false;
279 int sttd_engine_agent_load_current_engine(stte_request_callback_s *callback)
281 if (false == g_agent_init) {
282 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
283 return STTD_ERROR_OPERATION_FAILED;
286 /* Get current engine info */
287 sttengine_info_s* info;
288 int ret = __internal_get_engine_info(callback, &info);
290 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info");
293 g_engine_info = info;
298 /* Set default engine */
299 char* cur_engine_uuid = NULL;
300 bool is_default_engine = false;
302 /* get current engine from config */
303 if (0 == sttd_config_get_default_engine(&cur_engine_uuid)) {
304 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid);
305 if (NULL != g_engine_info->engine_uuid && NULL != cur_engine_uuid) {
306 if (!strcmp(g_engine_info->engine_uuid, cur_engine_uuid)) {
307 is_default_engine = true;
310 if (NULL != cur_engine_uuid) {
311 free(cur_engine_uuid);
312 cur_engine_uuid = NULL;
315 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is not current engine from config");
318 if (false == is_default_engine) {
319 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
321 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is Default engine");
325 ret = stt_engine_load(g_engine_info->engine_path, callback);
327 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : path(%s)", g_engine_info->engine_path);
331 ret = stt_engine_initialize(false);
333 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : path(%s)", g_engine_info->engine_path);
337 ret = stt_engine_set_silence_detection(g_default_silence_detected);
339 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Not support silence detection");
340 g_engine_info->support_silence_detection = false;
342 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Silence detection : %s", g_default_silence_detected ? "true" : "false");
343 g_engine_info->support_silence_detection = true;
344 g_engine_info->silence_detection = g_default_silence_detected;
347 /* Set first language */
348 char* tmp_lang = NULL;
349 ret = stt_engine_get_first_language(&tmp_lang);
350 if (0 == ret && NULL != tmp_lang) {
351 g_engine_info->first_lang = strdup(tmp_lang);
354 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %s", g_engine_info->engine_name);
358 #ifndef AUDIO_CREATE_ON_START
360 stte_audio_type_e atype;
364 ret = stt_engine_get_audio_type(&atype, &rate, &channels);
366 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", g_engine_info->engine_name);
370 ret = sttd_recorder_create(atype, channels, rate);
372 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
377 g_engine_info->is_loaded = true;
378 SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_engine_info->engine_name);
383 int sttd_engine_agent_unload_current_engine()
385 if (false == g_agent_init) {
386 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized ");
387 return STTD_ERROR_OPERATION_FAILED;
391 __engine_agent_check_engine_unload();
396 bool sttd_engine_agent_is_default_engine()
401 int sttd_engine_agent_get_engine_list(GSList** engine_list)
403 if (false == g_agent_init) {
404 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
405 return STTD_ERROR_OPERATION_FAILED;
408 SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------");
413 int sttd_engine_agent_get_current_engine(char** engine_uuid)
415 if (false == g_agent_init) {
416 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
417 return STTD_ERROR_OPERATION_FAILED;
420 if (NULL == engine_uuid) {
421 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid parameter");
422 return STTD_ERROR_INVALID_PARAMETER;
425 if (NULL == g_engine_info) {
426 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
427 return STTD_ERROR_INVALID_PARAMETER;
430 if (false == g_engine_info->is_loaded) {
431 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
432 return STTD_ERROR_OPERATION_FAILED;
435 *engine_uuid = strdup(g_engine_info->engine_uuid);
440 bool sttd_engine_agent_need_network()
442 if (false == g_agent_init) {
443 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
444 return STTD_ERROR_OPERATION_FAILED;
447 if (NULL != g_engine_info)
448 return g_engine_info->use_network;
453 int sttd_engine_agent_supported_langs(GSList** lang_list)
455 if (false == g_agent_init) {
456 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
457 return STTD_ERROR_OPERATION_FAILED;
460 if (NULL == lang_list) {
461 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL");
462 return STTD_ERROR_INVALID_PARAMETER;
465 if (NULL == g_engine_info) {
466 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
467 return STTD_ERROR_INVALID_PARAMETER;
470 if (false == g_engine_info->is_loaded) {
471 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
472 return STTD_ERROR_OPERATION_FAILED;
475 int ret = stt_engine_get_supported_langs(lang_list);
477 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret);
483 int sttd_engine_agent_get_default_lang(char** lang)
485 if (false == g_agent_init) {
486 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
487 return STTD_ERROR_OPERATION_FAILED;
491 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
492 return STTD_ERROR_INVALID_PARAMETER;
495 if (NULL == g_engine_info) {
496 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
497 return STTD_ERROR_INVALID_PARAMETER;
500 if (false == g_engine_info->is_loaded) {
501 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
502 return STTD_ERROR_OPERATION_FAILED;
505 /* get default language */
506 bool is_valid = false;
507 if (0 != stt_engine_is_valid_language(g_default_language, &is_valid)) {
508 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
509 return STTD_ERROR_OPERATION_FAILED;
512 if (true == is_valid) {
513 *lang = strdup(g_default_language);
515 *lang = strdup(g_engine_info->first_lang);
520 int sttd_engine_agent_set_private_data(const char* key, const char* data)
522 if (false == g_agent_init) {
523 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
524 return STTD_ERROR_OPERATION_FAILED;
527 if (NULL == key || NULL == data) {
528 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
529 return STTD_ERROR_INVALID_PARAMETER;
532 if (NULL == g_engine_info) {
533 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
534 return STTD_ERROR_INVALID_PARAMETER;
537 if (false == g_engine_info->is_loaded) {
538 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
539 return STTD_ERROR_OPERATION_FAILED;
542 /* set private data */
544 ret = stt_engine_set_private_data(key, data);
546 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set private data");
552 int sttd_engine_agent_get_private_data(const char* key, char** data)
554 if (false == g_agent_init) {
555 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
556 return STTD_ERROR_OPERATION_FAILED;
559 if (NULL == key || NULL == data) {
560 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
561 return STTD_ERROR_INVALID_PARAMETER;
564 if (NULL == g_engine_info) {
565 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
566 return STTD_ERROR_INVALID_PARAMETER;
569 if (false == g_engine_info->is_loaded) {
570 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
571 return STTD_ERROR_OPERATION_FAILED;
574 /* get default language */
576 ret = stt_engine_get_private_data(key, data);
578 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get private data");
584 int sttd_engine_agent_get_option_supported(bool* silence)
586 if (false == g_agent_init) {
587 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
588 return STTD_ERROR_OPERATION_FAILED;
591 if (NULL == silence) {
592 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
593 return STTD_ERROR_INVALID_PARAMETER;
596 if (NULL == g_engine_info) {
597 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Engine is not valid");
598 return STTD_ERROR_INVALID_PARAMETER;
601 if (false == g_engine_info->is_loaded) {
602 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
603 return STTD_ERROR_OPERATION_FAILED;
607 if (0 != stt_engine_support_silence(&temp)) {
608 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Fail to get support silence");
611 *silence = g_engine_info->support_silence_detection;
612 if (temp != *silence) {
613 SLOG(LOG_WARN, TAG_STTD, "[WARNING] Metadata and Engine spec are different (engine:%d) (meta:%d)", temp, *silence);
619 int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
621 if (false == g_agent_init) {
622 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
623 return STTD_ERROR_OPERATION_FAILED;
626 if (NULL == credential) {
627 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
628 return STTD_ERROR_INVALID_PARAMETER;
631 if (NULL == g_engine_info) {
632 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
633 return STTD_ERROR_INVALID_PARAMETER;
636 if (false == g_engine_info->is_loaded) {
637 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
638 return STTD_ERROR_OPERATION_FAILED;
644 ret = stt_engine_need_app_credential(&temp);
646 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
654 int sttd_engine_agent_is_recognition_type_supported(const char* type, bool* support)
656 if (false == g_agent_init) {
657 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
658 return STTD_ERROR_OPERATION_FAILED;
661 if (NULL == type || NULL == support) {
662 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
663 return STTD_ERROR_INVALID_PARAMETER;
666 if (NULL == g_engine_info) {
667 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
668 return STTD_ERROR_INVALID_PARAMETER;
671 if (false == g_engine_info->is_loaded) {
672 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
673 return STTD_ERROR_OPERATION_FAILED;
679 ret = stt_engine_support_recognition_type(type, &temp);
681 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
691 * STT Engine Interfaces for client
694 int __set_option(sttengine_info_s* engine, int silence)
699 /* Check silence detection */
700 if (engine->support_silence_detection) {
702 /* default option set */
703 // if (g_default_silence_detected != engine->silence_detection) {
704 if (0 != stt_engine_set_silence_detection(g_default_silence_detected)) {
705 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false");
707 engine->silence_detection = g_default_silence_detected;
708 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false");
712 if (silence != engine->silence_detection) {
713 if (0 != stt_engine_set_silence_detection(silence)) {
714 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false");
716 engine->silence_detection = silence;
717 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false");
726 int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
727 int silence, const char* appid, const char* credential, void* user_param)
729 if (false == g_agent_init) {
730 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
731 return STTD_ERROR_OPERATION_FAILED;
734 if (NULL == lang || NULL == recognition_type) {
735 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
736 return STTD_ERROR_INVALID_PARAMETER;
739 if (NULL == g_engine_info) {
740 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
741 return STTD_ERROR_INVALID_PARAMETER;
744 if (false == g_engine_info->is_loaded) {
745 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
746 return STTD_ERROR_OPERATION_FAILED;
749 if (0 != __set_option(g_engine_info, silence)) {
750 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options");
751 return STTD_ERROR_OPERATION_FAILED;
754 SLOG(LOG_INFO, TAG_STTD, "g_default_language %s", g_default_language);
758 if (0 == strncmp(lang, "default", strlen("default"))) {
759 bool is_valid = false;
760 ret = stt_engine_is_valid_language(g_default_language, &is_valid);
762 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
766 if (true == is_valid) {
767 temp = strdup(g_default_language);
768 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp);
770 temp = strdup(g_engine_info->first_lang);
771 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp);
777 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start engine");
779 ret = stt_engine_recognize_start(temp, recognition_type, appid, credential, user_param);
780 if (NULL != temp) free(temp);
782 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
786 #ifdef AUDIO_CREATE_ON_START
788 stte_audio_type_e atype;
792 ret = stt_engine_get_audio_type(&atype, &rate, &channels);
794 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %s", g_engine_info->engine_name);
798 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Create recorder");
800 ret = sttd_recorder_create(atype, channels, rate);
802 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
808 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder(%d)", uid);
810 ret = sttd_recorder_start(uid);
812 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
821 int sttd_engine_agent_recognize_start_recorder(int uid)
823 if (NULL == g_engine_info) {
824 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
825 return STTD_ERROR_INVALID_PARAMETER;
828 if (false == g_engine_info->is_loaded) {
829 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
830 return STTD_ERROR_OPERATION_FAILED;
833 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
836 ret = sttd_recorder_start(uid);
838 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
839 stt_engine_recognize_cancel();
840 sttd_recorder_stop();
847 int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
849 if (NULL == g_engine_info) {
850 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
851 return STTD_ERROR_INVALID_PARAMETER;
854 if (false == g_engine_info->is_loaded) {
855 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
856 return STTD_ERROR_OPERATION_FAILED;
859 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
862 ret = sttd_recorder_start_file(uid, filepath);
864 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
865 stt_engine_recognize_cancel();
866 sttd_recorder_stop_file();
873 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
875 if (false == g_agent_init) {
876 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
877 return STTD_ERROR_OPERATION_FAILED;
880 if (NULL == data || 0 == length) {
881 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
882 return STTD_ERROR_INVALID_PARAMETER;
885 if (NULL == g_engine_info) {
886 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
887 return STTD_ERROR_INVALID_PARAMETER;
890 if (false == g_engine_info->is_loaded) {
891 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
892 return STTD_ERROR_OPERATION_FAILED;
895 int ret = stt_engine_set_recording_data(data, length);
897 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
903 int sttd_engine_agent_recognize_stop_file()
905 if (false == g_agent_init) {
906 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
907 return STTD_ERROR_OPERATION_FAILED;
910 if (NULL == g_engine_info) {
911 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
912 return STTD_ERROR_INVALID_PARAMETER;
915 if (false == g_engine_info->is_loaded) {
916 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
917 return STTD_ERROR_OPERATION_FAILED;
920 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
922 ret = sttd_recorder_stop_file();
924 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
928 #ifdef AUDIO_CREATE_ON_START
929 SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
930 if (0 != sttd_recorder_destroy())
931 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
934 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
938 int sttd_engine_agent_recognize_stop_recorder()
940 if (false == g_agent_init) {
941 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
942 return STTD_ERROR_OPERATION_FAILED;
945 if (NULL == g_engine_info) {
946 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
947 return STTD_ERROR_INVALID_PARAMETER;
950 if (false == g_engine_info->is_loaded) {
951 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
952 return STTD_ERROR_OPERATION_FAILED;
955 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
957 ret = sttd_recorder_stop();
959 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
963 #ifdef AUDIO_CREATE_ON_START
964 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
965 if (0 != sttd_recorder_destroy())
966 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
969 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
973 int sttd_engine_agent_recognize_stop_engine()
975 if (false == g_agent_init) {
976 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
977 return STTD_ERROR_OPERATION_FAILED;
980 if (NULL == g_engine_info) {
981 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
982 return STTD_ERROR_INVALID_PARAMETER;
985 if (false == g_engine_info->is_loaded) {
986 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
987 return STTD_ERROR_OPERATION_FAILED;
990 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop engine");
993 ret = stt_engine_recognize_stop();
995 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
999 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop engine");
1004 int sttd_engine_agent_recognize_cancel()
1006 if (false == g_agent_init) {
1007 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1008 return STTD_ERROR_OPERATION_FAILED;
1011 if (NULL == g_engine_info) {
1012 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
1013 return STTD_ERROR_INVALID_PARAMETER;
1016 if (false == g_engine_info->is_loaded) {
1017 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1018 return STTD_ERROR_OPERATION_FAILED;
1021 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Cancel engine");
1024 ret = stt_engine_recognize_cancel();
1026 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1030 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
1032 ret = sttd_recorder_stop();
1034 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
1038 #ifdef AUDIO_CREATE_ON_START
1039 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
1040 if (0 != sttd_recorder_destroy())
1041 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1044 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Cancel recognition");
1051 * STT Engine Interfaces for configure
1054 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
1056 if (false == g_agent_init) {
1057 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1058 return STTD_ERROR_OPERATION_FAILED;
1061 if (NULL == engine_uuid) {
1062 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1063 return STTD_ERROR_INVALID_PARAMETER;
1068 if (NULL == g_engine_info) {
1069 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid");
1070 return STTD_ERROR_ENGINE_NOT_FOUND;
1073 SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
1078 int sttd_engine_agent_set_default_language(const char* language)
1080 if (false == g_agent_init) {
1081 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1082 return STTD_ERROR_OPERATION_FAILED;
1085 if (NULL == language) {
1086 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1087 return STTD_ERROR_INVALID_PARAMETER;
1090 if (NULL != g_default_language)
1091 free(g_default_language);
1093 g_default_language = strdup(language);
1098 int sttd_engine_agent_set_silence_detection(bool value)
1100 if (false == g_agent_init) {
1101 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1102 return STTD_ERROR_OPERATION_FAILED;
1105 g_default_silence_detected = value;
1110 int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
1112 if (false == g_agent_init) {
1113 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1114 return STTD_ERROR_OPERATION_FAILED;
1117 if (NULL == g_engine_info) {
1118 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of is not valid");
1119 return STTD_ERROR_INVALID_PARAMETER;
1122 if (false == g_engine_info->is_loaded) {
1123 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1124 return STTD_ERROR_OPERATION_FAILED;
1128 ret = stt_engine_check_app_agreed(appid, result);
1130 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1135 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
1139 static void __recorder_destroy_by_error_result(void *data)
1141 SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
1142 if (0 != sttd_recorder_destroy())
1143 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1148 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
1149 const char* msg, void* time_info, void *user_data)
1153 if (false == g_agent_init) {
1154 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
1155 return STTD_ERROR_OPERATION_FAILED;
1158 SLOG(LOG_INFO, TAG_STTD, "[Server] === Result time callback ===");
1160 if (NULL != time_info) {
1161 /* Get the time info */
1162 ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
1164 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
1169 SLOG(LOG_INFO, TAG_STTD, "[Server] ============================");
1171 ret = g_result_cb(event, type, result, result_count, msg, user_data);
1173 #ifdef AUDIO_CREATE_ON_START
1174 if (event == STTE_RESULT_EVENT_ERROR) {
1175 ecore_main_loop_thread_safe_call_async(__recorder_destroy_by_error_result, NULL);
1182 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
1185 int uid = stt_client_get_current_recognition();
1187 char* err_msg = NULL;
1188 int ret = STTD_ERROR_NONE;
1192 err_msg = strdup(msg);
1195 ret = sttdc_send_error_signal(uid, error, err_msg);
1197 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info.");
1200 if (NULL != err_msg) {
1205 ret = g_error_cb(error, msg);
1210 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
1212 int ret = STTD_ERROR_NONE;
1213 if (false == g_agent_init) {
1214 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
1215 return STTD_ERROR_OPERATION_FAILED;
1218 ret = g_speech_status_cb(status, user_data);
1222 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
1224 return g_result_time_cb(index, event, text, start_time, end_time, user_data);
1227 /* A function forging */
1228 int __log_enginelist()
1230 if (NULL != g_engine_info) {
1231 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1232 SLOG(LOG_DEBUG, TAG_STTD, "engine uuid : %s", g_engine_info->engine_uuid);
1233 SLOG(LOG_DEBUG, TAG_STTD, "engine name : %s", g_engine_info->engine_name);
1234 SLOG(LOG_DEBUG, TAG_STTD, "engine path : %s", g_engine_info->engine_path);
1235 SLOG(LOG_DEBUG, TAG_STTD, "use network : %s", g_engine_info->use_network ? "true" : "false");
1236 SLOG(LOG_DEBUG, TAG_STTD, "is loaded : %s", g_engine_info->is_loaded ? "true" : "false");
1237 if (NULL != g_engine_info->first_lang) {
1238 SLOG(LOG_DEBUG, TAG_STTD, "default lang : %s", g_engine_info->first_lang);
1240 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1242 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1243 SLOG(LOG_DEBUG, TAG_STTD, " No engine");
1244 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");