2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include "vcd_client_data.h"
22 #include "vcd_config.h"
23 #include "vcd_engine_agent.h"
25 #include "vcd_recorder.h"
28 * Internal data structure
36 /* engine load info */
39 bool is_command_ready;
42 vcpe_funcs_s* pefuncs;
43 vcpd_funcs_s* pdfuncs;
45 int (*vcp_load_engine)(vcpd_funcs_s* pdfuncs, vcpe_funcs_s* pefuncs);
46 int (*vcp_unload_engine)();
49 typedef struct _vcengine_info {
60 /** vc engine agent init */
61 static bool g_agent_init;
64 static GList *g_engine_list;
66 /** current engine information */
67 static vcengine_s g_dynamic_engine;
69 static char* g_default_lang;
71 /** callback functions */
72 static result_callback g_result_cb = NULL;
74 static asr_result_callback g_asr_result_cb = NULL;
77 static pre_result_callback g_pre_result_cb = NULL;
79 static nlu_result_callback g_nlu_result_cb = NULL;
82 static error_callback g_error_cb = NULL;
84 bool __supported_language_cb(const char* language, void* user_data);
86 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* engine_setting, bool use_network, void* user_data);
88 bool __engine_setting_cb(const char* key, const char* value, void* user_data);
90 /** Free voice list */
91 void __free_language_list(GList* lang_list);
98 /** check engine id */
99 int __internal_check_engine_id(const char* engine_uuid);
101 /** update engine list */
102 int __internal_update_engine_list();
104 /** get engine info */
105 int __internal_get_engine_info(const char* filepath, vcengine_info_s** info);
107 int __log_enginelist();
110 * VCS Engine Agent Interfaces
112 //int vcd_engine_agent_init(pre_result_callback pre_result_cb, result_callback result_cb, nlu_result_callback nlu_result_cb, error_callback error_cb)
113 int vcd_engine_agent_init(asr_result_callback asr_result_cb, result_callback result_cb, error_callback error_cb)
115 if (/*NULL == pre_result_cb*/ NULL == asr_result_cb || NULL == result_cb /*|| NULL == nlu_result_cb*/ || NULL == error_cb) {
116 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Input parameter is NULL");
117 return VCD_ERROR_OPERATION_FAILED;
120 /* init dynamic engine */
121 g_dynamic_engine.engine_uuid = NULL;
122 g_dynamic_engine.engine_name = NULL;
123 g_dynamic_engine.engine_path = NULL;
125 g_dynamic_engine.is_set = false;
126 g_dynamic_engine.is_loaded = false;
127 g_dynamic_engine.handle = NULL;
128 g_dynamic_engine.is_command_ready = false;
129 g_dynamic_engine.pefuncs = (vcpe_funcs_s*)calloc(1, sizeof(vcpe_funcs_s));
130 g_dynamic_engine.pdfuncs = (vcpd_funcs_s*)calloc(1, sizeof(vcpd_funcs_s));
134 //g_pre_result_cb = pre_result_cb;
135 g_asr_result_cb = asr_result_cb;
136 g_result_cb = result_cb;
137 //g_nlu_result_cb = nlu_result_cb;
138 g_error_cb = error_cb;
140 if (0 != vcd_config_get_default_language(&g_default_lang)) {
141 SLOG(LOG_WARN, TAG_VCD, "[Server WARNING] There is No default voice in config");
142 /* Set default voice */
143 g_default_lang = strdup(VC_BASE_LANGUAGE);
146 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent Initialize");
151 int vcd_engine_agent_release()
153 if (false == g_agent_init) {
154 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
155 return VCD_ERROR_OPERATION_FAILED;
158 /* unload current engine */
159 vcd_engine_agent_unload_current_engine();
161 /* release engine list */
163 vcengine_s *data = NULL;
165 if (g_list_length(g_engine_list) > 0) {
166 /* Get a first item */
167 iter = g_list_first(g_engine_list);
169 while (NULL != iter) {
170 /* Get handle data from list */
172 iter = g_list_remove(iter, data);
175 if (NULL != data->engine_uuid) {
176 g_free(data->engine_uuid);
177 data->engine_uuid = NULL;
179 if (NULL != data->engine_name) {
180 g_free(data->engine_name);
181 data->engine_name = NULL;
183 if (NULL != data->engine_path) {
184 g_free(data->engine_path);
185 data->engine_path = NULL;
195 g_engine_list = NULL;
197 /* release current engine data */
198 if (NULL != g_dynamic_engine.pefuncs) {
199 free(g_dynamic_engine.pefuncs);
200 g_dynamic_engine.pefuncs = NULL;
202 if (NULL != g_dynamic_engine.pdfuncs) {
203 free(g_dynamic_engine.pdfuncs);
204 g_dynamic_engine.pdfuncs = NULL;
207 g_agent_init = false;
209 //g_pre_result_cb = NULL;
210 g_asr_result_cb = NULL;
212 //g_nlu_result_cb = NULL;
215 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine Agent release");
220 bool vcd_engine_is_available_engine()
222 if (true == g_dynamic_engine.is_loaded)
228 int vcd_engine_agent_initialize_current_engine()
230 /* check agent init */
231 if (false == g_agent_init) {
232 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
233 return VCD_ERROR_OPERATION_FAILED;
236 /* update engine list */
237 if (0 != __internal_update_engine_list()) {
238 SLOG(LOG_ERROR, TAG_VCD, "[engine agent] vcd_engine_agent_init : __internal_update_engine_list : no engine error");
239 return VCD_ERROR_ENGINE_NOT_FOUND;
242 /* check whether engine id is valid or not.*/
244 vcengine_info_s *dynamic_engine = NULL;
246 if (g_list_length(g_engine_list) > 0) {
248 iter = g_list_first(g_engine_list);
250 while (NULL != iter) {
251 /*Get handle data from list*/
252 dynamic_engine = iter->data;
253 if (NULL != dynamic_engine) {
258 iter = g_list_next(iter);
261 return VCD_ERROR_ENGINE_NOT_FOUND;
264 if (NULL == dynamic_engine) {
265 return VCD_ERROR_ENGINE_NOT_FOUND;
267 if (NULL != g_dynamic_engine.engine_uuid) {
268 /* set data from g_engine_list */
269 if (g_dynamic_engine.engine_uuid != NULL) g_free(g_dynamic_engine.engine_uuid);
270 if (g_dynamic_engine.engine_name != NULL) g_free(g_dynamic_engine.engine_name);
271 if (g_dynamic_engine.engine_path != NULL) g_free(g_dynamic_engine.engine_path);
274 g_dynamic_engine.engine_uuid = g_strdup(dynamic_engine->engine_uuid);
275 g_dynamic_engine.engine_name = g_strdup(dynamic_engine->engine_name);
276 g_dynamic_engine.engine_path = g_strdup(dynamic_engine->engine_path);
278 g_dynamic_engine.handle = NULL;
279 g_dynamic_engine.is_loaded = false;
280 g_dynamic_engine.is_set = true;
282 SLOG(LOG_DEBUG, TAG_VCD, "-----");
283 SLOG(LOG_DEBUG, TAG_VCD, " Dynamic engine uuid : %s", g_dynamic_engine.engine_uuid);
284 SLOG(LOG_DEBUG, TAG_VCD, " Dynamic engine name : %s", g_dynamic_engine.engine_name);
285 SLOG(LOG_DEBUG, TAG_VCD, " Dynamic engine path : %s", g_dynamic_engine.engine_path);
286 SLOG(LOG_DEBUG, TAG_VCD, "-----");
293 int __internal_check_engine_id(const char* engine_uuid)
295 if (NULL == engine_uuid) {
296 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
297 return VCD_ERROR_INVALID_PARAMETER;
301 vcengine_s *data = NULL;
303 if (0 < g_list_length(g_engine_list)) {
305 iter = g_list_first(g_engine_list);
307 while (NULL != iter) {
310 if (0 == strncmp(engine_uuid, data->engine_uuid, strlen(data->engine_uuid))) {
314 iter = g_list_next(iter);
321 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* engine_setting, bool use_network, void* user_data)
323 vcengine_info_s* temp = (vcengine_info_s*)user_data;
325 temp->engine_uuid = g_strdup(engine_uuid);
326 temp->engine_name = g_strdup(engine_name);
330 int __internal_get_engine_info(const char* filepath, vcengine_info_s** info)
332 if (NULL == filepath || NULL == info) {
333 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
334 return VCD_ERROR_INVALID_PARAMETER;
341 handle = dlopen(filepath, RTLD_LAZY);
343 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Invalid engine : %s", filepath);
344 if ((error = dlerror()) != NULL) {
345 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] %s", error);
350 /* link engine to daemon */
351 dlsym(handle, "vcp_load_engine");
352 if ((error = dlerror()) != NULL) {
353 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Invalid engine. Fail to open vcp_load_engine : %s", filepath);
358 dlsym(handle, "vcp_unload_engine");
359 if ((error = dlerror()) != NULL) {
360 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Invalid engine. Fail to open vcp_unload_engine : %s", filepath);
365 int (*get_engine_info)(vcpe_engine_info_cb callback, void* user_data);
367 get_engine_info = (int (*)(vcpe_engine_info_cb, void*))dlsym(handle, "vcp_get_engine_info");
368 if (NULL != (error = dlerror()) || NULL == get_engine_info) {
369 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent WARNING] Invalid engine. Fail to open vcp_get_engine_info : %s", filepath);
374 vcengine_info_s* temp;
375 temp = (vcengine_info_s*)calloc(1, sizeof(vcengine_info_s));
377 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to allocate memory");
379 return VCD_ERROR_OUT_OF_MEMORY;
382 /* get engine info */
383 if (0 != get_engine_info(__engine_info_cb, (void*)temp)) {
384 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to get engine info from engine");
393 temp->engine_path = g_strdup(filepath);
395 SLOG(LOG_DEBUG, TAG_VCD, "----- Valid Engine");
396 SLOG(LOG_DEBUG, TAG_VCD, "Engine uuid : %s", temp->engine_uuid);
397 SLOG(LOG_DEBUG, TAG_VCD, "Engine name : %s", temp->engine_name);
398 SLOG(LOG_DEBUG, TAG_VCD, "Engine path : %s", temp->engine_path);
399 SLOG(LOG_DEBUG, TAG_VCD, "-----");
400 SLOG(LOG_DEBUG, TAG_VCD, " ");
407 int __internal_update_engine_list()
409 /* relsease engine list */
411 vcengine_info_s *data = NULL;
413 if (0 < g_list_length(g_engine_list)) {
414 /* Get a first item */
415 iter = g_list_first(g_engine_list);
417 while (NULL != iter) {
418 /* Get handle data from list */
422 if (NULL != data->engine_uuid) g_free(data->engine_uuid);
423 if (NULL != data->engine_path) g_free(data->engine_path);
424 if (NULL != data->engine_name) g_free(data->engine_name);
426 data->engine_uuid = NULL;
427 data->engine_path = NULL;
428 data->engine_name = NULL;
433 g_engine_list = g_list_remove_link(g_engine_list, iter);
434 iter = g_list_first(g_engine_list);
438 /* Get file name from default engine directory */
440 struct dirent *dirp = NULL;
442 dp = opendir(VC_DEFAULT_ENGINE);
448 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
451 vcengine_info_s* info = NULL;
452 char* filepath = NULL;
455 filesize = strlen(VC_DEFAULT_ENGINE) + strlen(dirp->d_name) + 5;
456 filepath = (char*)calloc(filesize, sizeof(char));
458 if (NULL != filepath) {
459 snprintf(filepath, filesize, "%s/%s", VC_DEFAULT_ENGINE, dirp->d_name);
461 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Memory not enough!!");
465 /* get its info and update engine list */
466 if (0 == __internal_get_engine_info(filepath, &info)) {
467 /* add engine info to g_engine_list */
468 g_engine_list = g_list_append(g_engine_list, info);
471 if (NULL != filepath) {
476 } while (NULL != dirp);
480 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent WARNING] Fail to open default directory");
483 if (0 >= g_list_length(g_engine_list)) {
484 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] No Engine");
485 return VCD_ERROR_ENGINE_NOT_FOUND;
494 int __foreach_command(vcp_cmd_h vc_command, vcpd_foreach_command_cb callback, void* user_data)
496 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request foreach command from engine");
497 return vcd_client_foreach_command((client_foreach_command_cb)callback, user_data);
500 int __command_get_length(vcp_cmd_h vc_command)
502 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request command length from engine");
503 return vcd_client_get_length();
506 int __get_audio_type(char** audio_type)
508 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Request audio type");
510 return vcd_recorder_get(audio_type);
513 void __result_cb(vcp_result_event_e event, int* result_id, int count, const char* all_result, const char* non_fixed, const char* nlu_result, const char* msg, void *user_data)
515 SLOG(LOG_DEBUG, TAG_VCD, "[Engine agent] Event(%d), Count(%d) Text(%s) Nonfixed(%s) NLU result(%s) Msg(%s)", event, count, all_result, non_fixed, nlu_result, msg);
517 if (NULL != g_result_cb) {
518 g_result_cb(event, result_id, count, all_result, non_fixed, nlu_result, msg, user_data);
520 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent ERROR] Result callback function is NOT valid");
526 void __asr_result_cb(vcp_asr_result_event_e event, const char* asr_result, void *user_data)
528 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] ASR result - Event(%d), Result(%s)", event, asr_result);
530 if (NULL != g_asr_result_cb) {
531 g_asr_result_cb(event, asr_result, user_data);
533 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent ERROR] ASR result callback function is NOT valid");
539 void __error_cb(vcp_error_e error, const char* msg, void *user_data)
541 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent] ERROR(%d)", error);
543 if (NULL != g_error_cb) {
544 g_error_cb(error, msg, user_data);
546 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent ERROR] Error callback function is NOT vaild");
552 int __load_engine(vcengine_s* engine)
554 /* check whether current engine is loaded or not */
555 if (true == engine->is_loaded) {
556 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Engine has already been loaded ");
560 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Current engine path : %s", engine->engine_path);
564 engine->handle = dlopen(engine->engine_path, RTLD_LAZY);
566 if ((error = dlerror()) != NULL || !engine->handle) {
567 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to get engine handle");
568 return VCD_ERROR_OPERATION_FAILED;
571 engine->vcp_unload_engine = (int (*)())dlsym(engine->handle, "vcp_unload_engine");
572 if ((error = dlerror()) != NULL) {
573 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to link daemon to vcp_unload_engine()");
574 dlclose(engine->handle);
575 return VCD_ERROR_OPERATION_FAILED;
578 engine->vcp_load_engine = (int (*)(vcpd_funcs_s*, vcpe_funcs_s*))dlsym(engine->handle, "vcp_load_engine");
579 if (NULL != (error = dlerror()) || NULL == engine->vcp_load_engine) {
580 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to link daemon to vcp_load_engine()");
581 dlclose(engine->handle);
582 return VCD_ERROR_OPERATION_FAILED;
586 engine->pdfuncs->version = 1;
587 engine->pdfuncs->size = sizeof(vcpd_funcs_s);
589 engine->pdfuncs->foreach_command = __foreach_command;
590 engine->pdfuncs->get_command_count = __command_get_length;
591 engine->pdfuncs->get_audio_type = __get_audio_type;
593 if (0 != engine->vcp_load_engine(engine->pdfuncs, engine->pefuncs)) {
594 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail vcp_load_engine()");
595 dlclose(engine->handle);
596 return VCD_ERROR_OPERATION_FAILED;
599 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] engine info : version(%d), size(%d)", engine->pefuncs->version, engine->pefuncs->size);
601 /* engine error check */
602 if (engine->pefuncs->size != sizeof(vcpe_funcs_s)) {
603 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Engine is not valid");
604 return VCD_ERROR_OPERATION_FAILED;
607 /* Check all engine functions */
608 if (NULL == engine->pefuncs->initialize ||
609 NULL == engine->pefuncs->deinitialize ||
610 NULL == engine->pefuncs->get_recording_format ||
611 NULL == engine->pefuncs->foreach_langs ||
612 NULL == engine->pefuncs->is_lang_supported ||
613 NULL == engine->pefuncs->set_result_cb ||
614 NULL == engine->pefuncs->set_language ||
615 NULL == engine->pefuncs->set_commands ||
616 NULL == engine->pefuncs->unset_commands ||
617 NULL == engine->pefuncs->start ||
618 NULL == engine->pefuncs->set_recording ||
619 NULL == engine->pefuncs->stop ||
620 NULL == engine->pefuncs->cancel ||
621 NULL == engine->pefuncs->set_asr_result_cb ||
622 //NULL == engine->pefuncs->set_pre_result_cb ||
623 NULL == engine->pefuncs->set_error_cb ||
624 NULL == engine->pefuncs->set_domain ||
625 NULL == engine->pefuncs->get_nlu_base_info ||
626 //NULL == engine->pefuncs->set_nlu_result_cb ||
627 NULL == engine->pefuncs->set_private_data ||
628 NULL == engine->pefuncs->get_private_data ||
629 NULL == engine->pefuncs->process_text ||
630 NULL == engine->pefuncs->process_list_event ||
631 NULL == engine->pefuncs->process_haptic_event) {
632 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] The current engine is NOT valid");
633 return VCD_ERROR_OPERATION_FAILED;
636 /* initalize engine */
637 if (0 != engine->pefuncs->initialize()) {
638 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to initialize vc-engine");
639 return VCD_ERROR_OPERATION_FAILED;
642 if (0 != engine->pefuncs->set_result_cb(__result_cb, NULL)) {
643 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set result callback of vc-engine");
644 return VCD_ERROR_OPERATION_FAILED;
647 if (0 != engine->pefuncs->set_asr_result_cb(__asr_result_cb, NULL)) {
648 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set asr result callback of vc-engine");
649 return VCD_ERROR_OPERATION_FAILED;
652 if (0 != engine->pefuncs->set_error_cb(__error_cb, NULL)) {
653 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set error callback of vc-engine");
654 return VCD_ERROR_OPERATION_FAILED;
658 if (true == engine->pefuncs->is_lang_supported(g_default_lang)) {
659 if (0 != engine->pefuncs->set_language(g_default_lang)) {
660 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to load current engine");
661 return VCD_ERROR_OPERATION_FAILED;
663 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] The %s has been loaded !!!", engine->engine_name);
664 engine->is_loaded = true;
666 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent WARNING] This engine do not support default language : lang(%s)", g_default_lang);
667 engine->is_loaded = false;
673 int vcd_engine_agent_load_current_engine()
675 if (false == g_agent_init) {
676 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
677 return VCD_ERROR_OPERATION_FAILED;
680 if (true == g_dynamic_engine.is_set) {
681 if (0 != __load_engine(&g_dynamic_engine)) {
682 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to load dynamic engine");
684 /* need to initialize dynamic engine data */
685 g_dynamic_engine.is_loaded = false;
687 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Load dynamic engine");
694 int vcd_engine_agent_unload_current_engine()
696 if (false == g_agent_init) {
697 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized ");
698 return VCD_ERROR_OPERATION_FAILED;
701 if (true == g_dynamic_engine.is_set) {
702 /* unload dynamic engine */
703 if (true == g_dynamic_engine.is_loaded) {
704 /* shutdown engine */
705 g_dynamic_engine.pefuncs->deinitialize();
706 g_dynamic_engine.vcp_unload_engine();
707 dlclose(g_dynamic_engine.handle);
708 g_dynamic_engine.handle = NULL;
709 g_dynamic_engine.is_loaded = false;
717 * VCS Engine Interfaces for client
720 int vcd_engine_set_commands()
722 if (false == g_agent_init) {
723 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
724 return VCD_ERROR_OPERATION_FAILED;
729 if (true == g_dynamic_engine.is_loaded) {
730 /* Set dynamic command */
731 ret = g_dynamic_engine.pefuncs->set_commands((vcp_cmd_h)0);
733 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent ERROR] Fail to set command of dynamic engine : error(%d)", ret);
734 g_dynamic_engine.is_command_ready = false;
736 g_dynamic_engine.is_command_ready = true;
739 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] set command");
741 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Dynamic engine is not available");
747 int vcd_engine_recognize_start(bool silence)
749 if (false == g_agent_init) {
750 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
751 return VCD_ERROR_OPERATION_FAILED;
755 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] silence is %s", silence ? "true" : "false");
757 if (true == g_dynamic_engine.is_loaded && true == g_dynamic_engine.is_command_ready) {
758 ret = g_dynamic_engine.pefuncs->start(silence);
760 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent] Fail to start engine error(%d)", ret);
761 return VCD_ERROR_OPERATION_FAILED;
764 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Engine is not available (Cannot start)");
765 return VCD_ERROR_OPERATION_FAILED;
768 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent SUCCESS] Engine start");
772 int vcd_engine_recognize_audio(const void* data, unsigned int length, vcp_speech_detect_e* speech_detected)
774 if (false == g_agent_init) {
775 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
776 return VCD_ERROR_OPERATION_FAILED;
780 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
781 return VCD_ERROR_INVALID_PARAMETER;
786 if (true == g_dynamic_engine.is_loaded) {
787 ret = g_dynamic_engine.pefuncs->set_recording(data, length, speech_detected);
789 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set recording dynamic engine error(%d)", ret);
790 if (VCP_ERROR_OUT_OF_NETWORK == ret) {
791 return VCD_ERROR_TIMED_OUT;
793 return VCD_ERROR_OPERATION_FAILED;
800 int vcd_engine_recognize_stop()
802 if (false == g_agent_init) {
803 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
804 return VCD_ERROR_OPERATION_FAILED;
807 if (true == g_dynamic_engine.is_loaded) {
809 ret = g_dynamic_engine.pefuncs->stop();
811 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to stop dynamic engine error(%d)", ret);
812 return VCD_ERROR_OPERATION_FAILED;
815 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Dynamic engine is not recording state");
816 return VCD_ERROR_OPERATION_FAILED;
822 int vcd_engine_recognize_cancel()
824 if (false == g_agent_init) {
825 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
826 return VCD_ERROR_OPERATION_FAILED;
830 if (true == g_dynamic_engine.is_loaded) {
831 ret = g_dynamic_engine.pefuncs->cancel();
833 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to cancel dynamic engine error(%d)", ret);
834 return VCD_ERROR_OPERATION_FAILED;
841 int vcd_engine_set_domain(int pid, const char* domain)
843 if (false == g_agent_init) {
844 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
845 return VCD_ERROR_OPERATION_FAILED;
849 if (true == g_dynamic_engine.is_loaded) {
850 ret = g_dynamic_engine.pefuncs->set_domain(domain);
852 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set domain (%d)", ret);
853 return VCD_ERROR_OPERATION_FAILED;
860 int vcd_engine_get_nlu_base_info(int pid, const char* key, char** value)
863 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
864 return VCD_ERROR_INVALID_PARAMETER;
867 if (false == g_agent_init) {
868 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
869 return VCD_ERROR_OPERATION_FAILED;
873 if (true == g_dynamic_engine.is_loaded) {
874 ret = g_dynamic_engine.pefuncs->get_nlu_base_info(key, value);
876 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to get nlu base info (%d)", ret);
877 return VCD_ERROR_OPERATION_FAILED;
884 int vcd_engine_set_private_data(int pid, const char* key, const char* data)
886 if (false == g_agent_init) {
887 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
888 return VCD_ERROR_OPERATION_FAILED;
892 if (true == g_dynamic_engine.is_loaded) {
893 ret = g_dynamic_engine.pefuncs->set_private_data(key, data);
895 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to set private data (%d)", ret);
896 return VCD_ERROR_OPERATION_FAILED;
903 int vcd_engine_get_private_data(int pid, const char* key, char** data)
906 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
907 return VCD_ERROR_INVALID_PARAMETER;
910 if (false == g_agent_init) {
911 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
912 return VCD_ERROR_OPERATION_FAILED;
916 if (true == g_dynamic_engine.is_loaded) {
917 ret = g_dynamic_engine.pefuncs->get_private_data(key, data);
919 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to get private data (%d)", ret);
920 return VCD_ERROR_OPERATION_FAILED;
927 int vcd_engine_process_text(int pid, const char* text)
929 if (false == g_agent_init) {
930 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
931 return VCD_ERROR_OPERATION_FAILED;
935 if (true == g_dynamic_engine.is_loaded) {
936 ret = g_dynamic_engine.pefuncs->process_text(text);
938 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to process text (%d)", ret);
939 return VCD_ERROR_OPERATION_FAILED;
946 int vcd_engine_process_list_event(int pid, const char* event)
948 if (false == g_agent_init) {
949 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
950 return VCD_ERROR_OPERATION_FAILED;
954 if (true == g_dynamic_engine.is_loaded) {
955 ret = g_dynamic_engine.pefuncs->process_list_event(event);
957 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to process list event (%d)", ret);
958 return VCD_ERROR_OPERATION_FAILED;
965 int vcd_engine_process_haptic_event(int pid, const char* event)
967 if (false == g_agent_init) {
968 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
969 return VCD_ERROR_OPERATION_FAILED;
973 if (true == g_dynamic_engine.is_loaded) {
974 ret = g_dynamic_engine.pefuncs->process_haptic_event(event);
976 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Fail to process haptic event (%d)", ret);
977 return VCD_ERROR_OPERATION_FAILED;
985 * VCS Engine Interfaces for client and setting
988 int vcd_engine_get_audio_format(const char* audio_id, vcp_audio_type_e* types, int* rate, int* channels)
990 if (false == g_agent_init) {
991 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
992 return VCD_ERROR_OPERATION_FAILED;
995 if (true != g_dynamic_engine.is_loaded) {
996 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Engine is not loaded");
999 if (NULL == g_dynamic_engine.pefuncs->get_recording_format) {
1000 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] The function of engine is NULL!!");
1001 return VCD_ERROR_OPERATION_FAILED;
1004 int ret = g_dynamic_engine.pefuncs->get_recording_format(audio_id, types, rate, channels);
1006 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] get recording format(%d)", ret);
1007 return VCD_ERROR_OPERATION_FAILED;
1013 bool __supported_language_cb(const char* language, void* user_data)
1015 GList** lang_list = (GList**)user_data;
1017 if (NULL == language || NULL == lang_list) {
1018 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Input parameter is NULL in callback!!!!");
1022 SLOG(LOG_DEBUG, TAG_VCD, "-- Language(%s)", language);
1024 char* temp_lang = g_strdup(language);
1026 *lang_list = g_list_append(*lang_list, temp_lang);
1031 int vcd_engine_supported_langs(GList** lang_list)
1033 if (false == g_agent_init) {
1034 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
1035 return VCD_ERROR_OPERATION_FAILED;
1038 if (true != g_dynamic_engine.is_loaded) {
1039 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Engine is not loaded");
1042 if (NULL == g_dynamic_engine.pefuncs->foreach_langs) {
1043 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] The function of engine is NULL!!");
1044 return VCD_ERROR_OPERATION_FAILED;
1047 int ret = g_dynamic_engine.pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list);
1049 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] get language list error(%d)", ret);
1050 return VCD_ERROR_OPERATION_FAILED;
1057 int vcd_engine_get_current_language(char** lang)
1059 if (false == g_agent_init) {
1060 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
1061 return VCD_ERROR_OPERATION_FAILED;
1065 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
1066 return VCD_ERROR_INVALID_PARAMETER;
1069 /* get default language */
1070 *lang = g_strdup(g_default_lang);
1075 int vcd_engine_set_current_language(const char* language)
1077 if (false == g_agent_init) {
1078 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Not Initialized");
1079 return VCD_ERROR_OPERATION_FAILED;
1082 if (NULL == language) {
1083 SLOG(LOG_ERROR, TAG_VCD, "[Engine Agent ERROR] Invalid Parameter");
1084 return VCD_ERROR_INVALID_PARAMETER;
1089 if (true == g_dynamic_engine.is_loaded) {
1090 g_dynamic_engine.is_command_ready = false;
1092 ret = g_dynamic_engine.pefuncs->set_language(language);
1094 SLOG(LOG_WARN, TAG_VCD, "[Engine Agent] Fail to set language of dynamic engine error(%d, %s)", ret, language);
1097 SLOG(LOG_DEBUG, TAG_VCD, "[Engine Agent] Dynamic engine is not available (Cannot start)");
1103 void __free_language_list(GList* lang_list)
1108 /* if list have item */
1109 if (g_list_length(lang_list) > 0) {
1110 /* Get a first item */
1111 iter = g_list_first(lang_list);
1113 while (NULL != iter) {
1119 lang_list = g_list_remove_link(lang_list, iter);
1121 iter = g_list_first(lang_list);
1126 int __log_enginelist()
1129 vcengine_info_s *data = NULL;
1131 if (0 < g_list_length(g_engine_list)) {
1133 /* Get a first item */
1134 iter = g_list_first(g_engine_list);
1136 SLOG(LOG_DEBUG, TAG_VCD, "--------------- engine list -------------------");
1139 while (NULL != iter) {
1140 /* Get handle data from list */
1143 SLOG(LOG_DEBUG, TAG_VCD, "[%dth]", i);
1144 SLOG(LOG_DEBUG, TAG_VCD, " engine uuid : %s", data->engine_uuid);
1145 SLOG(LOG_DEBUG, TAG_VCD, " engine name : %s", data->engine_name);
1146 SLOG(LOG_DEBUG, TAG_VCD, " engine path : %s", data->engine_path);
1147 iter = g_list_next(iter);
1150 SLOG(LOG_DEBUG, TAG_VCD, "----------------------------------------------");
1152 SLOG(LOG_DEBUG, TAG_VCD, "-------------- engine list -------------------");
1153 SLOG(LOG_DEBUG, TAG_VCD, " No Engine in engine directory");
1154 SLOG(LOG_DEBUG, TAG_VCD, "----------------------------------------------");