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) {
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_DEBUG, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
321 SLOG(LOG_DEBUG, 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_DEBUG, 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;
606 *silence = g_engine_info->support_silence_detection;
611 int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
613 if (false == g_agent_init) {
614 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
615 return STTD_ERROR_OPERATION_FAILED;
618 if (NULL == credential) {
619 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
620 return STTD_ERROR_INVALID_PARAMETER;
623 if (NULL == g_engine_info) {
624 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
625 return STTD_ERROR_INVALID_PARAMETER;
628 if (false == g_engine_info->is_loaded) {
629 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
630 return STTD_ERROR_OPERATION_FAILED;
636 ret = stt_engine_need_app_credential(&temp);
638 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
646 int sttd_engine_agent_is_recognition_type_supported(const char* type, bool* support)
648 if (false == g_agent_init) {
649 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
650 return STTD_ERROR_OPERATION_FAILED;
653 if (NULL == type || NULL == support) {
654 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
655 return STTD_ERROR_INVALID_PARAMETER;
658 if (NULL == g_engine_info) {
659 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
660 return STTD_ERROR_INVALID_PARAMETER;
663 if (false == g_engine_info->is_loaded) {
664 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
665 return STTD_ERROR_OPERATION_FAILED;
671 ret = stt_engine_support_recognition_type(type, &temp);
673 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
683 * STT Engine Interfaces for client
686 int __set_option(sttengine_info_s* engine, int silence)
691 /* Check silence detection */
692 if (engine->support_silence_detection) {
694 /* default option set */
695 if (g_default_silence_detected != engine->silence_detection) {
696 if (0 != stt_engine_set_silence_detection(g_default_silence_detected)) {
697 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false");
699 engine->silence_detection = g_default_silence_detected;
700 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false");
704 if (silence != engine->silence_detection) {
705 if (0 != stt_engine_set_silence_detection(silence)) {
706 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false");
708 engine->silence_detection = silence;
709 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false");
718 int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
719 int silence, const char* appid, const char* credential, void* user_param)
721 if (false == g_agent_init) {
722 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
723 return STTD_ERROR_OPERATION_FAILED;
726 if (NULL == lang || NULL == recognition_type) {
727 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
728 return STTD_ERROR_INVALID_PARAMETER;
731 if (NULL == g_engine_info) {
732 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
733 return STTD_ERROR_INVALID_PARAMETER;
736 if (false == g_engine_info->is_loaded) {
737 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
738 return STTD_ERROR_OPERATION_FAILED;
741 if (0 != __set_option(g_engine_info, silence)) {
742 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options");
743 return STTD_ERROR_OPERATION_FAILED;
746 SLOG(LOG_DEBUG, TAG_STTD, "g_default_language %s", g_default_language);
750 if (0 == strncmp(lang, "default", strlen("default"))) {
751 bool is_valid = false;
752 ret = stt_engine_is_valid_language(g_default_language, &is_valid);
754 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
758 if (true == is_valid) {
759 temp = strdup(g_default_language);
760 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp);
762 temp = strdup(g_engine_info->first_lang);
763 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp);
769 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start engine");
771 ret = stt_engine_recognize_start(temp, recognition_type, appid, credential, user_param);
772 if (NULL != temp) free(temp);
774 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
775 sttd_recorder_destroy();
779 #ifdef AUDIO_CREATE_ON_START
781 stte_audio_type_e atype;
785 ret = stt_engine_get_audio_type(&atype, &rate, &channels);
787 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %s", g_engine_info->engine_name);
791 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder");
793 ret = sttd_recorder_create(atype, channels, rate);
795 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %s", g_engine_info->engine_name);
801 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder(%d)", uid);
803 ret = sttd_recorder_start(uid);
805 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
814 int sttd_engine_agent_recognize_start_recorder(int uid)
816 if (NULL == g_engine_info) {
817 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
818 return STTD_ERROR_INVALID_PARAMETER;
821 if (false == g_engine_info->is_loaded) {
822 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
823 return STTD_ERROR_OPERATION_FAILED;
826 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
829 ret = sttd_recorder_start(uid);
831 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
832 stt_engine_recognize_cancel();
833 sttd_recorder_stop();
840 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
842 if (false == g_agent_init) {
843 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
844 return STTD_ERROR_OPERATION_FAILED;
847 if (NULL == data || 0 == length) {
848 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
849 return STTD_ERROR_INVALID_PARAMETER;
852 if (NULL == g_engine_info) {
853 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
854 return STTD_ERROR_INVALID_PARAMETER;
857 if (false == g_engine_info->is_loaded) {
858 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
859 return STTD_ERROR_OPERATION_FAILED;
862 int ret = stt_engine_set_recording_data(data, length);
864 SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
870 int sttd_engine_agent_recognize_stop_recorder()
872 if (false == g_agent_init) {
873 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
874 return STTD_ERROR_OPERATION_FAILED;
877 if (NULL == g_engine_info) {
878 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
879 return STTD_ERROR_INVALID_PARAMETER;
882 if (false == g_engine_info->is_loaded) {
883 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
884 return STTD_ERROR_OPERATION_FAILED;
887 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
889 ret = sttd_recorder_stop();
891 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
895 #ifdef AUDIO_CREATE_ON_START
896 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
897 if (0 != sttd_recorder_destroy())
898 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
901 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
905 int sttd_engine_agent_recognize_stop_engine()
907 if (false == g_agent_init) {
908 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
909 return STTD_ERROR_OPERATION_FAILED;
912 if (NULL == g_engine_info) {
913 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
914 return STTD_ERROR_INVALID_PARAMETER;
917 if (false == g_engine_info->is_loaded) {
918 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
919 return STTD_ERROR_OPERATION_FAILED;
922 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop engine");
925 ret = stt_engine_recognize_stop();
927 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
931 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine");
936 int sttd_engine_agent_recognize_cancel()
938 if (false == g_agent_init) {
939 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
940 return STTD_ERROR_OPERATION_FAILED;
943 if (NULL == g_engine_info) {
944 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
945 return STTD_ERROR_INVALID_PARAMETER;
948 if (false == g_engine_info->is_loaded) {
949 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
950 return STTD_ERROR_OPERATION_FAILED;
953 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Cancel engine");
956 ret = stt_engine_recognize_cancel();
958 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
962 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
964 ret = sttd_recorder_stop();
966 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
970 #ifdef AUDIO_CREATE_ON_START
971 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
972 if (0 != sttd_recorder_destroy())
973 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
976 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Cancel recognition");
983 * STT Engine Interfaces for configure
986 int sttd_engine_agent_set_default_engine(const char* engine_uuid)
988 if (false == g_agent_init) {
989 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
990 return STTD_ERROR_OPERATION_FAILED;
993 if (NULL == engine_uuid) {
994 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
995 return STTD_ERROR_INVALID_PARAMETER;
1000 if (NULL == g_engine_info) {
1001 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid");
1002 return STTD_ERROR_ENGINE_NOT_FOUND;
1005 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
1010 int sttd_engine_agent_set_default_language(const char* language)
1012 if (false == g_agent_init) {
1013 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1014 return STTD_ERROR_OPERATION_FAILED;
1017 if (NULL == language) {
1018 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter");
1019 return STTD_ERROR_INVALID_PARAMETER;
1022 if (NULL != g_default_language)
1023 free(g_default_language);
1025 g_default_language = strdup(language);
1030 int sttd_engine_agent_set_silence_detection(bool value)
1032 if (false == g_agent_init) {
1033 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1034 return STTD_ERROR_OPERATION_FAILED;
1037 g_default_silence_detected = value;
1042 int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
1044 if (false == g_agent_init) {
1045 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
1046 return STTD_ERROR_OPERATION_FAILED;
1049 if (NULL == g_engine_info) {
1050 SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of is not valid");
1051 return STTD_ERROR_INVALID_PARAMETER;
1054 if (false == g_engine_info->is_loaded) {
1055 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
1056 return STTD_ERROR_OPERATION_FAILED;
1060 ret = stt_engine_check_app_agreed(appid, result);
1062 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
1067 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
1071 static void __recorder_destroy_by_error_result(void *data)
1073 SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
1074 if (0 != sttd_recorder_destroy())
1075 SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
1080 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
1081 const char* msg, void* time_info, void *user_data)
1085 if (false == g_agent_init) {
1086 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
1087 return STTD_ERROR_OPERATION_FAILED;
1090 SLOG(LOG_DEBUG, TAG_STTD, "[Server] === Result time callback ===");
1092 if (NULL != time_info) {
1093 /* Get the time info */
1094 ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
1096 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
1101 SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================");
1103 ret = g_result_cb(event, type, result, result_count, msg, user_data);
1105 #ifdef AUDIO_CREATE_ON_START
1106 if (event == STTE_RESULT_EVENT_ERROR) {
1107 ecore_main_loop_thread_safe_call_async(__recorder_destroy_by_error_result, NULL);
1114 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
1117 int uid = stt_client_get_current_recognition();
1119 char* err_msg = NULL;
1120 int ret = STTD_ERROR_NONE;
1123 err_msg = strdup(msg);
1126 ret = sttdc_send_error_signal(uid, error, err_msg);
1128 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info.");
1130 if (NULL != err_msg) {
1138 if (NULL != err_msg) {
1143 ret = g_error_cb(error, msg);
1148 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
1150 int ret = STTD_ERROR_NONE;
1151 if (false == g_agent_init) {
1152 SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
1153 return STTD_ERROR_OPERATION_FAILED;
1156 ret = g_speech_status_cb(status, user_data);
1160 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
1162 return g_result_time_cb(index, event, text, start_time, end_time, user_data);
1165 /* A function forging */
1166 int __log_enginelist()
1168 if (NULL != g_engine_info) {
1169 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1170 SLOG(LOG_DEBUG, TAG_STTD, "engine uuid : %s", g_engine_info->engine_uuid);
1171 SLOG(LOG_DEBUG, TAG_STTD, "engine name : %s", g_engine_info->engine_name);
1172 SLOG(LOG_DEBUG, TAG_STTD, "engine path : %s", g_engine_info->engine_path);
1173 SLOG(LOG_DEBUG, TAG_STTD, "use network : %s", g_engine_info->use_network ? "true" : "false");
1174 SLOG(LOG_DEBUG, TAG_STTD, "is loaded : %s", g_engine_info->is_loaded ? "true" : "false");
1175 if (NULL != g_engine_info->first_lang) {
1176 SLOG(LOG_DEBUG, TAG_STTD, "default lang : %s", g_engine_info->first_lang);
1178 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");
1180 SLOG(LOG_DEBUG, TAG_STTD, "------------------ engine -----------------------");
1181 SLOG(LOG_DEBUG, TAG_STTD, " No engine");
1182 SLOG(LOG_DEBUG, TAG_STTD, "-------------------------------------------------");