X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=server%2Fsttd_engine_agent.c;h=6429f04ac9ac015b9bf2bf9c3400eeab78a66e85;hb=refs%2Fchanges%2F39%2F77739%2F3;hp=89be6389e9612ef4d1f41bb03ff0ae45d41f6ef0;hpb=bcb8e123b4326b9f2923284f61681e0a727b5a82;p=platform%2Fcore%2Fuifw%2Fstt.git diff --git a/server/sttd_engine_agent.c b/server/sttd_engine_agent.c old mode 100755 new mode 100644 index 89be638..6429f04 --- a/server/sttd_engine_agent.c +++ b/server/sttd_engine_agent.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -15,109 +15,85 @@ #include #include +#include "stt_defs.h" +#include "stt_engine.h" #include "sttd_main.h" #include "sttd_client_data.h" #include "sttd_config.h" +#include "sttd_recorder.h" #include "sttd_engine_agent.h" +#define AUDIO_CREATE_ON_START + /* * Internal data structure */ typedef struct { - /* engine info */ - char* engine_uuid; - char* engine_name; - char* engine_path; - - /* engine load info */ - bool is_set; - bool is_loaded; - bool need_network; - bool support_silence_detection; - bool support_profanity_filter; - bool support_punctuation_override; - void *handle; - - /* engine base setting */ - char* default_lang; - bool profanity_filter; - bool punctuation_override; - bool silence_detection; - - sttpe_funcs_s* pefuncs; - sttpd_funcs_s* pdfuncs; - - int (*sttp_load_engine)(sttpd_funcs_s* pdfuncs, sttpe_funcs_s* pefuncs); - int (*sttp_unload_engine)(); -} sttengine_s; + int uid; + int engine_id; + bool use_default_engine; +} sttengine_client_s; typedef struct _sttengine_info { + int engine_id; + char* engine_uuid; char* engine_path; char* engine_name; - char* setting_ug_path; + char* engine_setting_path; bool use_network; - bool support_silence_detection; -} sttengine_info_s; + bool is_loaded; -/* -* static data -*/ + /* engine base setting */ + char* first_lang; + bool silence_detection; + bool support_silence_detection; + bool need_credential; +} sttengine_info_s; /** stt engine agent init */ -static bool g_agent_init; +static bool g_agent_init; -/** stt engine list */ -static GList *g_engine_list; +/** list */ +static GSList* g_engine_client_list; +static GSList* g_engine_list; -/** current engine infomation */ -static sttengine_s g_cur_engine; +/** default engine info */ +static int g_default_engine_id; +static char* g_default_language; +static bool g_default_silence_detected; -/** default option value */ -static bool g_default_profanity_filter; -static bool g_default_punctuation_override; -static bool g_default_silence_detected; +static int g_engine_id_count; + +/** current engine id */ +static int g_recording_engine_id; /** callback functions */ static result_callback g_result_cb; -static partial_result_callback g_partial_result_cb; +static result_time_callback g_result_time_cb; static silence_dectection_callback g_silence_cb; /** callback functions */ -void __result_cb(sttp_result_event_e event, const char* type, - const char** data, int data_count, const char* msg, void *user_data); +void __result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count, + const char* msg, void* time_info, void *user_data); -void __partial_result_cb(sttp_result_event_e event, const char* data, void *user_data); +bool __result_time_cb(int index, sttp_result_time_event_e event, const char* text, + long start_time, long end_time, void* user_data); -void __detect_silence_cb(void* user_data); +void __detect_silence_cb(sttp_silence_type_e type, void* user_data); bool __supported_language_cb(const char* language, void* user_data); -void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name, +void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name, bool use_network, void* user_data); -bool __engine_setting_cb(const char* key, const char* value, void* user_data); - -/** Free voice list */ -void __free_language_list(GList* lang_list); - - /* -* Internal Interfaces +* Internal Interfaces */ - -/** Set current engine */ -int __internal_set_current_engine(const char* engine_uuid); - -/** check engine id */ -int __internal_check_engine_id(const char* engine_uuid); - -/** update engine list */ -int __internal_update_engine_list(); /** get engine info */ int __internal_get_engine_info(const char* filepath, sttengine_info_s** info); @@ -127,242 +103,139 @@ int __log_enginelist(); /* * STT Engine Agent Interfaces */ -int sttd_engine_agent_init(result_callback result_cb, partial_result_callback partial_result_cb, silence_dectection_callback silence_cb) +int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb, + silence_dectection_callback silence_cb) { /* initialize static data */ - if (NULL == result_cb || NULL == silence_cb) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine agent ERROR] sttd_engine_agent_init : invalid parameter"); + if (NULL == result_cb || NULL == time_cb || NULL == silence_cb) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine agent ERROR] Invalid parameter"); return STTD_ERROR_INVALID_PARAMETER; } g_result_cb = result_cb; - g_partial_result_cb = partial_result_cb; + g_result_time_cb = time_cb; g_silence_cb = silence_cb; - g_cur_engine.engine_uuid = NULL; - g_cur_engine.engine_name = NULL; - g_cur_engine.engine_path = NULL; - - g_cur_engine.is_set = false; - g_cur_engine.handle = NULL; - g_cur_engine.pefuncs = (sttpe_funcs_s*)malloc( sizeof(sttpe_funcs_s) ); - g_cur_engine.pdfuncs = (sttpd_funcs_s*)malloc( sizeof(sttpd_funcs_s) ); + g_default_engine_id = -1; + g_default_language = NULL; + g_engine_id_count = 1; + g_recording_engine_id = -1; - g_agent_init = true; - - if (0 != sttd_config_get_default_language(&(g_cur_engine.default_lang))) { - SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is No default voice in config"); + if (0 != sttd_config_get_default_language(&(g_default_language))) { + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is No default voice in config"); /* Set default voice */ - g_cur_engine.default_lang = strdup("en_US"); + g_default_language = strdup("en_US"); + } else { + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default language is %s", g_default_language); } int temp; if (0 != sttd_config_get_default_silence_detection(&temp)) { - SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no silence detection in config"); + SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no silence detection in config"); g_default_silence_detected = true; } else { g_default_silence_detected = (bool)temp; } - if (0 != sttd_config_get_default_profanity_filter(&temp)) { - SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no profanity filter in config"); - g_default_profanity_filter = false; - } else { - g_default_profanity_filter = (bool)temp; - } - - if (0 != sttd_config_get_default_punctuation_override(&temp)) { - SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no punctuation override in config"); - g_default_punctuation_override = false; - } else { - g_default_punctuation_override = (bool)temp; - } - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Engine Agent Initialize"); + g_agent_init = false; return 0; } -int sttd_engine_agent_release() +int __engine_agent_clear_engine(sttengine_info_s *engine) { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - /* unload current engine */ - sttd_engine_agent_unload_current_engine(); - - /* release engine list */ - GList *iter = NULL; - sttengine_s *data = NULL; - - if (g_list_length(g_engine_list) > 0) { - /* Get a first item */ - iter = g_list_first(g_engine_list); + if (NULL != engine) { + if (NULL != engine->engine_uuid) free(engine->engine_uuid); + if (NULL != engine->engine_path) free(engine->engine_path); + if (NULL != engine->engine_name) free(engine->engine_name); + if (NULL != engine->engine_setting_path)free(engine->engine_setting_path); + if (NULL != engine->first_lang) free(engine->first_lang); - while (NULL != iter) { - /* Get handle data from list */ - data = iter->data; - dlclose(data->handle); - - iter = g_list_remove(iter, data); - } + free(engine); } - g_list_free(iter); - - /* release current engine data */ - if( NULL != g_cur_engine.pefuncs ) - free(g_cur_engine.pefuncs); - - if( NULL != g_cur_engine.pdfuncs ) - free(g_cur_engine.pdfuncs); - - g_result_cb = NULL; - g_silence_cb = NULL; - - g_agent_init = false; - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Engine Agent release"); - return 0; } -int sttd_engine_agent_initialize_current_engine() +int sttd_engine_agent_release() { - /* check agent init */ - if (false == g_agent_init ) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - /* update engine list */ - if (0 != __internal_update_engine_list()) { - SLOG(LOG_ERROR, TAG_STTD, "[engine agent] sttd_engine_agent_init : __internal_update_engine_list : no engine error"); - return STTD_ERROR_ENGINE_NOT_FOUND; - } + /* Release client list */ + GSList *iter = NULL; + sttengine_client_s *client = NULL; - /* get current engine from config */ - char* cur_engine_uuid = NULL; - bool is_get_engineid_from_config = false; + if (g_slist_length(g_engine_client_list) > 0) { + /* Get a first item */ + iter = g_slist_nth(g_engine_client_list, 0); - if (0 != sttd_config_get_default_engine(&cur_engine_uuid)) { + while (NULL != iter) { + /* Get handle data from list */ + client = iter->data; + g_engine_client_list = g_slist_remove_link(g_engine_client_list, iter); - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] There is not current engine from config"); + if (NULL != client) + free(client); - /* not set current engine */ - /* set system default engine */ - GList *iter = NULL; - if (0 < g_list_length(g_engine_list)) { - iter = g_list_first(g_engine_list); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[engine agent ERROR] sttd_engine_agent_initialize_current_engine() : no engine error"); - return -1; + iter = g_slist_nth(g_engine_client_list, 0); } - - sttengine_info_s *data = NULL; - data = iter->data; - - cur_engine_uuid = g_strdup(data->engine_uuid); - - is_get_engineid_from_config = false; - } else { - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid); - - is_get_engineid_from_config = true; } - /* check whether cur engine uuid is valid or not. */ - if (0 != __internal_check_engine_id(cur_engine_uuid)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] It is not valid engine id and find other engine id"); + g_slist_free(g_engine_client_list); - GList *iter = NULL; - if (0 < g_list_length(g_engine_list)) { - iter = g_list_first(g_engine_list); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_agent_initialize_current_engine() : no engine error"); - return -1; - } - - if (NULL != cur_engine_uuid) - free(cur_engine_uuid); - - sttengine_info_s *data = NULL; - data = iter->data; + /* Release engine list */ + sttengine_info_s *engine = NULL; - cur_engine_uuid = g_strdup(data->engine_uuid); - - is_get_engineid_from_config = false; - } + if (0 < g_slist_length(g_engine_list)) { + /* Get a first item */ + iter = g_slist_nth(g_engine_list, 0); - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current Engine Id : %s", cur_engine_uuid); + while (NULL != iter) { + /* Get handle data from list */ + engine = iter->data; + g_engine_list = g_slist_remove_link(g_engine_list, iter); - /* set current engine */ - if (0 != __internal_set_current_engine(cur_engine_uuid)) { - SLOG(LOG_ERROR, TAG_STTD, "[engine agent ERROR] __internal_set_current_engine : no engine error"); + /* Check engine unload */ + if (engine->is_loaded) { + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine id(%d)", engine->engine_id); - if( cur_engine_uuid != NULL) - free(cur_engine_uuid); + if (0 != stt_engine_deinitialize(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id); - return STTD_ERROR_ENGINE_NOT_FOUND; - } + if (0 != stt_engine_unload(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id); - if (false == is_get_engineid_from_config) { - if (0 != sttd_config_set_default_engine(cur_engine_uuid)) - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set default engine "); - } + engine->is_loaded = false; + } - if( cur_engine_uuid != NULL ) - free(cur_engine_uuid); + __engine_agent_clear_engine(engine); - return 0; -} - -int __internal_check_engine_id(const char* engine_uuid) -{ - if (NULL == engine_uuid) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; + iter = g_slist_nth(g_engine_list, 0); + } } - GList *iter = NULL; - sttengine_s *data = NULL; - - if (0 < g_list_length(g_engine_list)) { - /*Get a first item*/ - iter = g_list_first(g_engine_list); - - while (NULL != iter) { - data = iter->data; - - if (0 == strncmp(engine_uuid, data->engine_uuid, strlen(data->engine_uuid))) { - return 0; - } + g_result_cb = NULL; + g_silence_cb = NULL; - iter = g_list_next(iter); - } - } + g_agent_init = false; + g_default_engine_id = -1; - return -1; + return 0; } -void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name, +void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name, bool use_network, void* user_data) { - sttengine_info_s* temp = (sttengine_info_s*)user_data; + sttengine_info_s* temp = (sttengine_info_s*)user_data; temp->engine_uuid = g_strdup(engine_uuid); temp->engine_name = g_strdup(engine_name); - temp->setting_ug_path = g_strdup(setting_ug_name); + temp->engine_setting_path = g_strdup(setting_ug_name); temp->use_network = use_network; } - int __internal_get_engine_info(const char* filepath, sttengine_info_s** info) { if (NULL == filepath || NULL == info) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); return STTD_ERROR_INVALID_PARAMETER; } @@ -370,1486 +243,1413 @@ int __internal_get_engine_info(const char* filepath, sttengine_info_s** info) char *error; void* handle; - handle = dlopen (filepath, RTLD_LAZY); + handle = dlopen(filepath, RTLD_LAZY); if (!handle) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine : %s", filepath); - return -1; + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine : %s, error(%s)", filepath, (NULL == dlerror()) ? "NULL" : dlerror()); + return STTD_ERROR_ENGINE_NOT_FOUND; } /* link engine to daemon */ dlsym(handle, "sttp_load_engine"); if ((error = dlerror()) != NULL) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error); + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error); dlclose(handle); - return -1; + return STTD_ERROR_ENGINE_NOT_FOUND; } dlsym(handle, "sttp_unload_engine"); if ((error = dlerror()) != NULL) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_unload_engine : %s", error); + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine. Fail to open sttp_unload_engine : %s", error); dlclose(handle); - return -1; + return STTD_ERROR_ENGINE_NOT_FOUND; } int (*get_engine_info)(sttpe_engine_info_cb callback, void* user_data); get_engine_info = (int (*)(sttpe_engine_info_cb, void*))dlsym(handle, "sttp_get_engine_info"); if ((error = dlerror()) != NULL || NULL == get_engine_info) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error); + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error); dlclose(handle); - return -1; + return STTD_ERROR_ENGINE_NOT_FOUND; } sttengine_info_s* temp; - temp = (sttengine_info_s*)g_malloc0( sizeof(sttengine_info_s) ); + temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s)); + if (NULL == temp) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory"); + dlclose(handle); + return STTD_ERROR_OUT_OF_MEMORY; + } /* get engine info */ if (0 != get_engine_info(__engine_info_cb, (void*)temp)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info from engine"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine info from engine"); dlclose(handle); - g_free(temp); - return -1; + free(temp); + return STTD_ERROR_ENGINE_NOT_FOUND; } /* close engine */ dlclose(handle); + temp->engine_id = g_engine_id_count; + g_engine_id_count++; + temp->engine_path = g_strdup(filepath); + temp->is_loaded = false; SLOG(LOG_DEBUG, TAG_STTD, "----- Valid Engine"); - SLOG(LOG_DEBUG, TAG_STTD, "Engine uuid : %s", temp->engine_uuid); - SLOG(LOG_DEBUG, TAG_STTD, "Engine name : %s", temp->engine_name); - SLOG(LOG_DEBUG, TAG_STTD, "Setting ug path : %s", temp->setting_ug_path); - SLOG(LOG_DEBUG, TAG_STTD, "Engine path : %s", temp->engine_path); - SLOG(LOG_DEBUG, TAG_STTD, "Use network : %s", temp->use_network ? "true":"false"); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine id : %d", temp->engine_id); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine uuid : %s", temp->engine_uuid); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine name : %s", temp->engine_name); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine path : %s", temp->engine_path); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Engine setting path : %s", temp->engine_setting_path); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Use network : %s", temp->use_network ? "true" : "false"); SLOG(LOG_DEBUG, TAG_STTD, "-----"); SLOG(LOG_DEBUG, TAG_STTD, " "); *info = temp; - return 0; + return STTD_ERROR_NONE; } -int __internal_update_engine_list() +bool __is_engine(const char* filepath) { - /* relsease engine list */ - GList *iter = NULL; - sttengine_info_s *data = NULL; + GSList *iter = NULL; + sttengine_info_s *engine = NULL; - if (0 < g_list_length(g_engine_list)) { + if (0 < g_slist_length(g_engine_list)) { /* Get a first item */ - iter = g_list_first(g_engine_list); + iter = g_slist_nth(g_engine_list, 0); while (NULL != iter) { /* Get handle data from list */ - data = iter->data; + engine = iter->data; - if (NULL != data) { - if (NULL != data->engine_uuid) free(data->engine_uuid); - if (NULL != data->engine_path) free(data->engine_path); - if (NULL != data->engine_name) free(data->engine_name); - if (NULL != data->setting_ug_path) free(data->setting_ug_path); - - free(data); + if (0 == strcmp(engine->engine_path, filepath)) { + return true; } - g_engine_list = g_list_remove_link(g_engine_list, iter); - iter = g_list_first(g_engine_list); + iter = g_slist_next(iter); } } + return false; +} + +int sttd_engine_agent_initialize_engine_list() +{ /* Get file name from default engine directory */ - DIR *dp; - struct dirent *dirp; + DIR *dp = NULL; + int ret = -1; + struct dirent entry; + struct dirent *dirp = NULL; - dp = opendir(ENGINE_DIRECTORY_DEFAULT); + dp = opendir(STT_DEFAULT_ENGINE); if (NULL != dp) { - while (NULL != (dirp = readdir(dp))) { - sttengine_info_s* info; - char* filepath; - int filesize; - - filesize = strlen(ENGINE_DIRECTORY_DEFAULT) + strlen(dirp->d_name) + 5; - filepath = (char*) g_malloc0(sizeof(char) * filesize); - - if (NULL != filepath) { - strncpy(filepath, ENGINE_DIRECTORY_DEFAULT, strlen(ENGINE_DIRECTORY_DEFAULT) ); - strncat(filepath, "/", strlen("/") ); - strncat(filepath, dirp->d_name, strlen(dirp->d_name) ); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Memory not enough!!" ); - continue; + do { + ret = readdir_r(dp, &entry, &dirp); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[File ERROR] Fail to read directory"); + break; } - /* get its info and update engine list */ - if (0 == __internal_get_engine_info(filepath, &info)) { - /* add engine info to g_engine_list */ - g_engine_list = g_list_append(g_engine_list, info); - } + if (NULL != dirp) { + sttengine_info_s* info; + char* filepath; + int filesize; - if (NULL != filepath) - g_free(filepath); - } + filesize = strlen(STT_DEFAULT_ENGINE) + strlen(dirp->d_name) + 5; + filepath = (char*)calloc(filesize, sizeof(char)); - closedir(dp); - } else { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Fail to open default directory"); - } - - /* Get file name from downloadable engine directory */ - dp = opendir(ENGINE_DIRECTORY_DOWNLOAD); - if (NULL != dp) { - while (NULL != (dirp = readdir(dp))) { - sttengine_info_s* info; - char* filepath; - int filesize; - - filesize = strlen(ENGINE_DIRECTORY_DOWNLOAD) + strlen(dirp->d_name) + 5; - filepath = (char*) g_malloc0(sizeof(char) * filesize); - - if (NULL != filepath) { - strncpy(filepath, ENGINE_DIRECTORY_DOWNLOAD, strlen(ENGINE_DIRECTORY_DOWNLOAD) ); - strncat(filepath, "/", strlen("/") ); - strncat(filepath, dirp->d_name, strlen(dirp->d_name) ); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Memory not enough!!" ); - continue; - } + if (NULL != filepath) { + snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE, dirp->d_name); + } else { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Memory not enough!!"); + continue; + } - /* get its info and update engine list */ - if (0 == __internal_get_engine_info(filepath, &info)) { - /* add engine info to g_engine_list */ - g_engine_list = g_list_append(g_engine_list, info); - } + if (false == __is_engine(filepath)) { + /* get its info and update engine list */ + if (0 == __internal_get_engine_info(filepath, &info)) { + /* add engine info to g_engine_list */ + g_engine_list = g_slist_append(g_engine_list, info); + } + } - if (NULL != filepath) - g_free(filepath); - } + if (NULL != filepath) + free(filepath); + } + } while (NULL != dirp); closedir(dp); } else { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Fail to open downloadable directory"); + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Fail to open default directory"); } - if (0 >= g_list_length(g_engine_list)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No Engine"); - return STTD_ERROR_ENGINE_NOT_FOUND; + if (0 >= g_slist_length(g_engine_list)) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] No Engine"); + return STTD_ERROR_ENGINE_NOT_FOUND; } __log_enginelist(); - - return 0; -} -int __internal_set_current_engine(const char* engine_uuid) -{ - if (NULL == engine_uuid) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; - } + /* Set default engine */ + GSList *iter = NULL; + sttengine_info_s *engine = NULL; + char* cur_engine_uuid = NULL; + bool is_default_engine = false; - /* check whether engine id is valid or not.*/ - GList *iter = NULL; - sttengine_info_s *data = NULL; + /* get current engine from config */ + if (0 == sttd_config_get_default_engine(&cur_engine_uuid)) { + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] current engine from config : %s", cur_engine_uuid); - bool flag = false; - if (g_list_length(g_engine_list) > 0) { - /*Get a first item*/ - iter = g_list_first(g_engine_list); + if (0 < g_slist_length(g_engine_list)) { + /* Get a first item */ + iter = g_slist_nth(g_engine_list, 0); - while (NULL != iter) { - /*Get handle data from list*/ - data = iter->data; + while (NULL != iter) { + /* Get handle data from list */ + engine = iter->data; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] engine_uuid(%s) engine list->uuid(%s)", engine_uuid, data->engine_uuid); + if (0 == strcmp(engine->engine_uuid, cur_engine_uuid)) { + is_default_engine = true; + g_default_engine_id = engine->engine_id; + break; + } - if (0 == strncmp(data->engine_uuid, engine_uuid, strlen(engine_uuid))) { - flag = true; - break; + iter = g_slist_next(iter); } - - /*Get next item*/ - iter = g_list_next(iter); } - } - /* If current engine does not exist, return error */ - if (false == flag) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] __internal_set_current_engine : Cannot find engine id"); - return STTD_ERROR_INVALID_PARAMETER; + if (cur_engine_uuid != NULL) + free(cur_engine_uuid); } else { - if (NULL != g_cur_engine.engine_uuid) { - /*compare current engine uuid */ - if (0 == strncmp(g_cur_engine.engine_uuid, data->engine_uuid, strlen(engine_uuid))) { - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Check] stt engine has already been set"); - return 0; - } - } + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] There is not current engine from config"); } - /* set data from g_engine_list */ - if (g_cur_engine.engine_uuid != NULL) free(g_cur_engine.engine_uuid); - if (g_cur_engine.engine_name != NULL) free(g_cur_engine.engine_name); - if (g_cur_engine.engine_path != NULL) free(g_cur_engine.engine_path); + if (false == is_default_engine) { + if (0 < g_slist_length(g_engine_list)) { + /* Get a first item */ + iter = g_slist_nth(g_engine_list, 0); - g_cur_engine.engine_uuid = g_strdup(data->engine_uuid); - g_cur_engine.engine_name = g_strdup(data->engine_name); - g_cur_engine.engine_path = g_strdup(data->engine_path); + /* Get handle data from list */ + engine = iter->data; - g_cur_engine.handle = NULL; - g_cur_engine.is_loaded = false; - g_cur_engine.is_set = true; - g_cur_engine.need_network = data->use_network; + if (NULL != engine) { + is_default_engine = true; + g_default_engine_id = engine->engine_id; + } + } + } - g_cur_engine.profanity_filter = g_default_profanity_filter; - g_cur_engine.punctuation_override = g_default_punctuation_override; - g_cur_engine.silence_detection = g_default_silence_detected; + if (NULL != engine) { + if (NULL != engine->engine_uuid) { + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine Id(%d) uuid(%s)", engine->engine_id, engine->engine_uuid); - SLOG(LOG_DEBUG, TAG_STTD, "-----"); - SLOG(LOG_DEBUG, TAG_STTD, " Current engine uuid : %s", g_cur_engine.engine_uuid); - SLOG(LOG_DEBUG, TAG_STTD, " Current engine name : %s", g_cur_engine.engine_name); - SLOG(LOG_DEBUG, TAG_STTD, " Current engine path : %s", g_cur_engine.engine_path); - SLOG(LOG_DEBUG, TAG_STTD, "-----"); + if (false == is_default_engine) { + if (0 != sttd_config_set_default_engine(engine->engine_uuid)) + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set default engine "); + } + } + } else { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is NULL"); + return STTD_ERROR_ENGINE_NOT_FOUND; + } + + g_agent_init = true; return 0; } -int sttd_engine_agent_load_current_engine() +sttengine_info_s* __engine_agent_get_engine_by_id(int engine_id) { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_set) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_agent_load_current_engine : No Current Engine "); - return -1; - } - - /* check whether current engine is loaded or not */ - if (true == g_cur_engine.is_loaded) { - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] sttd_engine_agent_load_current_engine : Engine has already been loaded "); - return 0; - } - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current engine path : %s", g_cur_engine.engine_path); - - /* open engine */ - char *error; - g_cur_engine.handle = dlopen(g_cur_engine.engine_path, RTLD_LAZY); - - if (NULL != (error = dlerror()) || !g_cur_engine.handle) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine handle"); - return STTD_ERROR_OPERATION_FAILED; - } - - g_cur_engine.sttp_unload_engine = (int (*)())dlsym(g_cur_engine.handle, "sttp_unload_engine"); - if (NULL != (error = dlerror()) || NULL == g_cur_engine.sttp_unload_engine) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to link daemon to sttp_unload_engine() : %s", error); - return STTD_ERROR_OPERATION_FAILED; - } + GSList *iter = NULL; + sttengine_info_s *data = NULL; - g_cur_engine.sttp_load_engine = (int (*)(sttpd_funcs_s*, sttpe_funcs_s*) )dlsym(g_cur_engine.handle, "sttp_load_engine"); - if (NULL != (error = dlerror()) || NULL == g_cur_engine.sttp_load_engine) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to link daemon to sttp_load_engine() : %s", error); - return STTD_ERROR_OPERATION_FAILED; - } + iter = g_slist_nth(g_engine_list, 0); - /* load engine */ - g_cur_engine.pdfuncs->version = 1; - g_cur_engine.pdfuncs->size = sizeof(sttpd_funcs_s); + while (NULL != iter) { - if (0 != g_cur_engine.sttp_load_engine(g_cur_engine.pdfuncs, g_cur_engine.pefuncs)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail sttp_load_engine()"); - return STTD_ERROR_OPERATION_FAILED; - } + data = iter->data; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] engine info : version(%d), size(%d)",g_cur_engine.pefuncs->version, g_cur_engine.pefuncs->size); + if (data->engine_id == engine_id) + return data; - /* engine error check */ - if (g_cur_engine.pefuncs->size != sizeof(sttpe_funcs_s)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_agent_load_current_engine : engine is not valid"); - return STTD_ERROR_OPERATION_FAILED; + iter = g_slist_next(iter); } - /* initalize engine */ - if (0 != g_cur_engine.pefuncs->initialize(__result_cb, __partial_result_cb, __detect_silence_cb)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize stt-engine"); - return STTD_ERROR_OPERATION_FAILED; - } + return NULL; +} - /* set default setting */ - int ret = 0; +sttengine_info_s* __engine_agent_get_engine_by_uuid(const char* engine_uuid) +{ + GSList *iter = NULL; + sttengine_info_s *data = NULL; - if (NULL == g_cur_engine.pefuncs->set_profanity_filter) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_profanity_filter of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - - /* check and set profanity filter */ - ret = g_cur_engine.pefuncs->set_profanity_filter(g_cur_engine.profanity_filter); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent] Not support profanity filter"); - g_cur_engine.support_profanity_filter = false; - } else { - g_cur_engine.support_profanity_filter = true; - } - - /* check and set punctuation */ - if (NULL == g_cur_engine.pefuncs->set_punctuation) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_punctuation of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + iter = g_slist_nth(g_engine_list, 0); - ret = g_cur_engine.pefuncs->set_punctuation(g_cur_engine.punctuation_override); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Not support punctuation override"); - g_cur_engine.support_punctuation_override = false; - } else { - g_cur_engine.support_punctuation_override = true; - } + while (NULL != iter) { - /* check and set silence detection */ - if (NULL == g_cur_engine.pefuncs->set_silence_detection) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_silence_detection of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + data = iter->data; - ret = g_cur_engine.pefuncs->set_silence_detection(g_cur_engine.silence_detection); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Not support silence detection"); - g_cur_engine.support_silence_detection = false; - } else { - g_cur_engine.support_silence_detection = true; - } - - /* select default language */ - bool set_voice = false; - if (NULL != g_cur_engine.default_lang) { - if (NULL == g_cur_engine.pefuncs->is_valid_lang) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_default_lang of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + if (0 == strcmp(data->engine_uuid, engine_uuid)) + return data; - if (true == g_cur_engine.pefuncs->is_valid_lang(g_cur_engine.default_lang)) { - set_voice = true; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s)", g_cur_engine.default_lang); - } else { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Fail set origin default language : lang(%s)", g_cur_engine.default_lang); - } + iter = g_slist_next(iter); } - if (false == set_voice) { - if (NULL == g_cur_engine.pefuncs->foreach_langs) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] foreach_langs of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - - /* get language list */ - int ret; - GList* lang_list = NULL; - - ret = g_cur_engine.pefuncs->foreach_langs(__supported_language_cb, &lang_list); + return NULL; +} - if (0 == ret && 0 < g_list_length(lang_list)) { - GList *iter = NULL; - iter = g_list_first(lang_list); +sttengine_client_s* __engine_agent_get_client(int uid) +{ + GSList *iter = NULL; + sttengine_client_s *data = NULL; - if (NULL != iter) { - char* temp_lang = iter->data; + if (0 < g_slist_length(g_engine_client_list)) { + iter = g_slist_nth(g_engine_client_list, 0); - if (true != g_cur_engine.pefuncs->is_valid_lang(temp_lang)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail voice is NOT valid"); - return STTD_ERROR_OPERATION_FAILED; - } + while (NULL != iter) { + /* Get handle data from list */ + data = iter->data; - sttd_config_set_default_language(temp_lang); + if (uid == data->uid) + return data; - g_cur_engine.default_lang = g_strdup(temp_lang); - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Select default voice : lang(%s)", temp_lang); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail to get language list : result(%d)\n", ret); - return STTD_ERROR_OPERATION_FAILED; - } - - __free_language_list(lang_list); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail to get language list : result(%d)\n", ret); - return STTD_ERROR_OPERATION_FAILED; + iter = g_slist_next(iter); } + } - } - - g_cur_engine.is_loaded = true; - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_cur_engine.engine_name); - - return 0; + return NULL; } -int sttd_engine_agent_unload_current_engine() +sttengine_info_s* __engine_agent_get_engine_by_uid(int uid) { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized "); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_set) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_agent_unload_current_engine : No Current Engine "); - return -1; - } + sttengine_client_s *data; - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Current engine has already been unloaded "); - return 0; - } + data = __engine_agent_get_client(uid); + if (NULL != data) + return __engine_agent_get_engine_by_id(data->engine_id); - /* shutdown engine */ - if (NULL == g_cur_engine.pefuncs->deinitialize) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] shutdown of engine is NULL!!"); - } else { - g_cur_engine.pefuncs->deinitialize(); - } + return NULL; +} - /* unload engine */ - if (0 != g_cur_engine.sttp_unload_engine()) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to unload engine"); - } +int __engine_agent_check_engine_unload(int engine_id) +{ + /* Check the count of client to use this engine */ + GSList *iter = NULL; + int client_count = 0; + sttengine_client_s *data = NULL; - dlclose(g_cur_engine.handle); + if (0 < g_slist_length(g_engine_client_list)) { + iter = g_slist_nth(g_engine_client_list, 0); - /* reset current engine data */ - g_cur_engine.handle = NULL; - g_cur_engine.is_loaded = false; + while (NULL != iter) { + /* Get handle data from list */ + data = iter->data; - return 0; -} + if (data->engine_id == engine_id) + client_count++; -bool sttd_engine_agent_need_network() -{ - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized" ); - return STTD_ERROR_OPERATION_FAILED; + iter = g_slist_next(iter); + } } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (0 == client_count) { + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_id(engine_id); + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine from client(%d)", engine_id); + } else { + if (engine->is_loaded) { + /* unload engine */ +#ifndef AUDIO_CREATE_ON_START + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder"); + if (0 != sttd_recorder_destroy(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id); +#endif + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Unload engine id(%d)", engine_id); + if (0 != stt_engine_deinitialize(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id); + + if (0 != stt_engine_unload(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id); + + engine->is_loaded = false; + } + } } - return g_cur_engine.need_network; + return 0; } -int sttd_engine_get_option_supported(bool* silence, bool* profanity, bool* punctuation) +int sttd_engine_agent_load_current_engine(int uid, const char* engine_uuid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized" ); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (NULL == silence || NULL == profanity || NULL == punctuation) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; - } + sttengine_client_s* client = NULL; + sttengine_info_s* engine = NULL; + int before_engine = -1; - *silence = g_cur_engine.support_silence_detection; - *profanity = g_cur_engine.support_profanity_filter; - *punctuation = g_cur_engine.support_punctuation_override; + client = __engine_agent_get_client(uid); - return 0; -} + if (NULL == client) { + client = (sttengine_client_s*)calloc(1, sizeof(sttengine_client_s)); + if (NULL == client) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory"); + return STTD_ERROR_OUT_OF_MEMORY; + } -/* -* STT Engine Interfaces for client -*/ + /* initialize */ + client->uid = uid; + client->engine_id = -1; -int __set_option(int profanity, int punctuation, int silence) -{ - if (2 == profanity) { - /* Default selection */ - if (g_default_profanity_filter != g_cur_engine.profanity_filter) { - if (NULL != g_cur_engine.pefuncs->set_profanity_filter) { - if (0 != g_cur_engine.pefuncs->set_profanity_filter(g_default_profanity_filter)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set profanity filter"); - return STTD_ERROR_OPERATION_FAILED; - } - g_cur_engine.profanity_filter = g_default_profanity_filter; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set profanity filter : %s", g_cur_engine.profanity_filter ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] profanity_filter() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - } - } else { - /* Client selection */ - if (g_cur_engine.profanity_filter != profanity) { - if (NULL != g_cur_engine.pefuncs->set_profanity_filter) { - if (0 != g_cur_engine.pefuncs->set_profanity_filter((bool)profanity)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set profanity filter"); - return STTD_ERROR_OPERATION_FAILED; - } + g_engine_client_list = g_slist_append(g_engine_client_list, client); - g_cur_engine.profanity_filter = (bool)profanity; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set profanity filter : %s", g_cur_engine.profanity_filter ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] profanity_filter() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - } + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Registered client(%d)", uid); } - if (2 == punctuation) { - /* Default selection */ - if (g_default_punctuation_override != g_cur_engine.punctuation_override) { - if (NULL != g_cur_engine.pefuncs->set_punctuation) { - if (0 != g_cur_engine.pefuncs->set_punctuation(g_default_punctuation_override)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set punctuation override"); - return STTD_ERROR_OPERATION_FAILED; - } - g_cur_engine.punctuation_override = g_default_punctuation_override; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set punctuation override : %s", g_cur_engine.punctuation_override ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_punctuation() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - } - } else { - /* Client selection */ - if (g_cur_engine.punctuation_override != punctuation) { - if (NULL != g_cur_engine.pefuncs->set_punctuation) { - if (0 != g_cur_engine.pefuncs->set_punctuation((bool)punctuation)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set punctuation override"); - return STTD_ERROR_OPERATION_FAILED; - } + if (NULL == engine_uuid) { + /* Set default engine */ + engine = __engine_agent_get_engine_by_id(g_default_engine_id); - g_cur_engine.punctuation_override = (bool)punctuation; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set punctuation override : %s", g_cur_engine.punctuation_override ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_punctuation() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get default engine : %d", g_default_engine_id); + return STTD_ERROR_OPERATION_FAILED; } - } + before_engine = client->engine_id; - if (2 == silence) { - /* Default selection */ - if (g_default_silence_detected != g_cur_engine.silence_detection) { - if (NULL != g_cur_engine.pefuncs->set_silence_detection) { - if (0 != g_cur_engine.pefuncs->set_silence_detection(g_default_silence_detected)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection"); - return STTD_ERROR_OPERATION_FAILED; - } - g_cur_engine.silence_detection = g_default_silence_detected; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_cur_engine.silence_detection ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_silence() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } - } + client->engine_id = engine->engine_id; + client->use_default_engine = true; } else { - /* Client selection */ - if (g_cur_engine.silence_detection != silence) { - if (NULL != g_cur_engine.pefuncs->set_silence_detection) { - if (0 != g_cur_engine.pefuncs->set_silence_detection((bool)silence)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection"); - return STTD_ERROR_OPERATION_FAILED; - } + /* Set engine by uid */ + engine = __engine_agent_get_engine_by_uuid(engine_uuid); - g_cur_engine.silence_detection = (bool)silence; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_cur_engine.silence_detection ? "true" : "false"); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_silence() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get engine : %s", engine_uuid); + return STTD_ERROR_OPERATION_FAILED; } + before_engine = client->engine_id; + + client->engine_id = engine->engine_id; + client->use_default_engine = false; } - - return 0; -} -int sttd_engine_recognize_start(const char* lang, const char* recognition_type, - int profanity, int punctuation, int silence, void* user_param) -{ - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; + if (-1 != before_engine) { + /* Unload engine if reference count is 0 */ + __engine_agent_check_engine_unload(before_engine); } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (true == engine->is_loaded) { + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine] engine id(%d) is already loaded", engine->engine_id); + return 0; } - if (NULL == lang || NULL == recognition_type) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; + /* Load engine */ + int ret; + ret = stt_engine_load(engine->engine_id, engine->engine_path); + if (0 != ret) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : id(%d) path(%s)", engine->engine_id, engine->engine_path); + return ret; } - if (0 != __set_option(profanity, punctuation, silence)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options"); - return STTD_ERROR_OPERATION_FAILED; + ret = stt_engine_initialize(engine->engine_id, __result_cb, __detect_silence_cb); + if (0 != ret) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path); + return ret; } - if (NULL == g_cur_engine.pefuncs->start) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] start() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; + ret = stt_engine_set_silence_detection(engine->engine_id, g_default_silence_detected); + if (0 != ret) { + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] Not support silence detection"); + engine->support_silence_detection = false; + } else { + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Silence detection : %s", g_default_silence_detected ? "true" : "false"); + engine->support_silence_detection = true; + engine->silence_detection = g_default_silence_detected; } - char* temp; - if (0 == strncmp(lang, "default", strlen("default"))) { - temp = strdup(g_cur_engine.default_lang); + /* Set first language */ + char* tmp_lang = NULL; + ret = stt_engine_get_first_language(engine->engine_id, &tmp_lang); + if (0 == ret && NULL != tmp_lang) { + engine->first_lang = strdup(tmp_lang); + free(tmp_lang); } else { - temp = strdup(lang); + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %d %s", engine->engine_id, engine->engine_name); + return ret; } - int ret = g_cur_engine.pefuncs->start(temp, recognition_type, user_param); - free(temp); +#ifndef AUDIO_CREATE_ON_START + /* Ready recorder */ + sttp_audio_type_e atype; + int rate; + int channels; + ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels); if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_recognize_start : recognition start error(%d)", ret); - return STTD_ERROR_OPERATION_FAILED; + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name); + return ret; } - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] sttd_engine_recognize_start"); + ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate); + if (0 != ret) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name); + return ret; + } +#endif + + engine->is_loaded = true; + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] The %s(%d) has been loaded !!!", engine->engine_name, engine->engine_id); return 0; } -int sttd_engine_recognize_audio(const void* data, unsigned int length) +int sttd_engine_agent_unload_current_engine(int uid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized "); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == data) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; - } - - if (NULL == g_cur_engine.pefuncs->set_recording) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + /* Remove client */ + int engine_id = -1; - int ret = g_cur_engine.pefuncs->set_recording(data, length); - if (0 != ret) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret); - return ret; - } + GSList *iter = NULL; + sttengine_client_s *data = NULL; - return 0; -} + if (0 < g_slist_length(g_engine_client_list)) { + iter = g_slist_nth(g_engine_client_list, 0); -int sttd_engine_recognize_stop() -{ - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } + while (NULL != iter) { + /* Get handle data from list */ + data = iter->data; - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } + if (NULL != data) { + if (uid == data->uid) { + g_engine_client_list = g_slist_remove_link(g_engine_client_list, iter); + engine_id = data->engine_id; + free(data); + break; + } + } - if (NULL == g_cur_engine.pefuncs->stop) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; + iter = g_slist_next(iter); + } } - int ret = g_cur_engine.pefuncs->stop(); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret); - return STTD_ERROR_OPERATION_FAILED; + if (-1 != engine_id) { + __engine_agent_check_engine_unload(engine_id); } return 0; } -int sttd_engine_recognize_cancel() +bool sttd_engine_agent_is_default_engine() { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (NULL == g_cur_engine.pefuncs->cancel) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + if (g_default_engine_id > 0) + return true; - int ret = g_cur_engine.pefuncs->cancel(); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret); - return STTD_ERROR_OPERATION_FAILED; - } - - return 0; + return false; } -int sttd_engine_get_audio_format(sttp_audio_type_e* types, int* rate, int* channels) +int sttd_engine_agent_get_engine_list(GSList** engine_list) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } + GSList *iter = NULL; + sttengine_info_s *data = NULL; - if (NULL == g_cur_engine.pefuncs->get_audio_format) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + iter = g_slist_nth(g_engine_list, 0); - int ret = g_cur_engine.pefuncs->get_audio_format(types, rate, channels); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get audio format error(%d)", ret); - return STTD_ERROR_OPERATION_FAILED; - } + SLOG(LOG_DEBUG, TAG_STTD, "----- [Engine Agent] engine list -----"); - return 0; -} + while (NULL != iter) { + engine_s* temp_engine; + temp_engine = (engine_s*)calloc(1, sizeof(engine_s)); + if (NULL == temp_engine) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to allocate memory"); + return STTD_ERROR_OUT_OF_MEMORY; + } -/* -* STT Engine Interfaces for client and setting -*/ -bool __supported_language_cb(const char* language, void* user_data) -{ - GList** lang_list = (GList**)user_data; + data = iter->data; - if (NULL == language || NULL == lang_list) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL in callback!!!!"); - return false; - } + temp_engine->engine_id = strdup(data->engine_uuid); + temp_engine->engine_name = strdup(data->engine_name); + temp_engine->ug_name = strdup(data->engine_setting_path); + + *engine_list = g_slist_append(*engine_list, temp_engine); - SLOG(LOG_DEBUG, TAG_STTD, "-- Language(%s)", language); + iter = g_slist_next(iter); - char* temp_lang = g_strdup(language); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " -- Engine id(%s)", temp_engine->engine_id); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " Engine name(%s)", temp_engine->engine_name); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " Engine ug name(%s)", temp_engine->ug_name); + } - *lang_list = g_list_append(*lang_list, temp_lang); + SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------"); - return true; + return 0; } -int sttd_engine_supported_langs(GList** lang_list) +int sttd_engine_agent_get_current_engine(int uid, char** engine_uuid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == engine_uuid) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid parameter"); + return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == g_cur_engine.pefuncs->foreach_langs) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; + sttengine_info_s* engine; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; } - int ret = g_cur_engine.pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } + *engine_uuid = strdup(engine->engine_uuid); + return 0; } - -int sttd_engine_get_default_lang(char** lang) +bool sttd_engine_agent_need_network(int uid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } + sttengine_info_s* engine; + engine = __engine_agent_get_engine_by_uid(uid); - if (NULL == lang) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; - } - - /* get default language */ - *lang = g_strdup(g_cur_engine.default_lang); + if (NULL != engine) + return engine->use_network; - return 0; + return false; } -int sttd_engine_is_partial_result_supported(bool* partial_result) +int sttd_engine_agent_supported_langs(int uid, GSList** lang_list) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == lang_list) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL"); + return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == partial_result) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == g_cur_engine.pefuncs->support_partial_result) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - *partial_result = g_cur_engine.pefuncs->support_partial_result(); + int ret = stt_engine_get_supported_langs(engine->engine_id, lang_list); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret); + } - return 0; + return ret; } - -/* -* STT Engine Interfaces for setting -*/ - -int sttd_engine_setting_get_engine_list(GList** engine_list) +int sttd_engine_agent_get_default_lang(int uid, char** lang) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } - - /* update engine list */ - if (0 != __internal_update_engine_list()) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] sttd_engine_setting_get_engine_list : __internal_update_engine_list()"); - return -1; + if (NULL == lang) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; } - GList *iter = NULL; - sttengine_info_s *data = NULL; - - iter = g_list_first(g_engine_list); - - SLOG(LOG_DEBUG, TAG_STTD, "----- [Engine Agent] engine list -----"); - - while (NULL != iter) { - engine_s* temp_engine; - - temp_engine = (engine_s*)g_malloc0(sizeof(engine_s)); - - data = iter->data; - - temp_engine->engine_id = strdup(data->engine_uuid); - temp_engine->engine_name = strdup(data->engine_name); - temp_engine->ug_name = strdup(data->setting_ug_path); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); - *engine_list = g_list_append(*engine_list, temp_engine); + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } - iter = g_list_next(iter); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + return STTD_ERROR_OPERATION_FAILED; + } - SLOG(LOG_DEBUG, TAG_STTD, " -- engine id(%s) engine name(%s) ug name(%s) \n", - temp_engine->engine_id, temp_engine->engine_name, temp_engine->ug_name); + /* get default language */ + bool is_valid = false; + int ret = -1; + ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language"); + return ret; } - SLOG(LOG_DEBUG, TAG_STTD, "--------------------------------------"); + if (true == is_valid) { + *lang = strdup(g_default_language); + } else + *lang = strdup(engine->first_lang); return 0; } -int sttd_engine_setting_get_engine(char** engine_id) +int sttd_engine_agent_set_private_data(int uid, const char* key, const char* data) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized" ); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; + } + + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } + + if (false == engine->is_loaded) { SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_ENGINE_NOT_FOUND; + return STTD_ERROR_OPERATION_FAILED; } - *engine_id = strdup(g_cur_engine.engine_uuid); + /* set private data */ + int ret = -1; + ret = stt_engine_set_private_data(engine->engine_id, key, data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set private data"); + } - return 0; + return ret; } -int sttd_engine_setting_set_engine(const char* engine_id) +int sttd_engine_agent_get_private_data(int uid, const char* key, char** data) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == engine_id) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); return STTD_ERROR_INVALID_PARAMETER; } - /* compare current engine and new engine. */ - if (NULL != g_cur_engine.engine_uuid) { - if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(g_cur_engine.engine_uuid))) { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] New engine is the same as current engine"); - return 0; - } - } + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); - char* tmp_uuid = NULL; - tmp_uuid = g_strdup(g_cur_engine.engine_uuid); - if (NULL == tmp_uuid) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not enough memory!!"); - return STTD_ERROR_OUT_OF_MEMORY; + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; } - /* unload engine */ - if (0 != sttd_engine_agent_unload_current_engine()) - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to unload current engine"); - else - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] unload current engine"); - - /* change current engine */ - if (0 != __internal_set_current_engine(engine_id)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] __internal_set_current_engine : no engine error"); - - /* roll back to old current engine. */ - __internal_set_current_engine(tmp_uuid); - sttd_engine_agent_load_current_engine(); - - if (NULL != tmp_uuid) - free(tmp_uuid); - + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - if (0 != sttd_engine_agent_load_current_engine()) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load new engine"); + /* get default language */ + int ret = -1; + ret = stt_engine_get_private_data(engine->engine_id, key, data); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get private data"); + } - if (NULL != tmp_uuid) - free(tmp_uuid); + return ret; +} +int sttd_engine_agent_get_option_supported(int uid, bool* silence) +{ + if (false == g_agent_init) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] sttd_engine_setting_set_engine() : Load new engine"); + if (NULL == silence) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; + } - if( tmp_uuid != NULL ) - free(tmp_uuid); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } - /* set engine id to config */ - if (0 != sttd_config_set_default_engine(engine_id)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set engine id"); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + return STTD_ERROR_OPERATION_FAILED; } + *silence = engine->support_silence_detection; + return 0; } -int sttd_engine_setting_get_lang_list(char** engine_id, GList** lang_list) +int sttd_engine_agent_is_credential_needed(int uid, bool* credential) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == credential) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == lang_list || NULL == engine_id) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid); return STTD_ERROR_INVALID_PARAMETER; } - /* get language list from engine */ - int ret = sttd_engine_supported_langs(lang_list); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail get lang list (%d)", ret); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - *engine_id = strdup(g_cur_engine.engine_uuid); + bool temp = false; + int ret; + + ret = stt_engine_need_app_credential(engine->engine_id, &temp); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret); + return ret; + } + *credential = temp; return 0; } -int sttd_engine_setting_get_default_lang(char** language) +int sttd_engine_agent_is_recognition_type_supported(int uid, const char* type, bool* support) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == language) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + if (NULL == type || NULL == support) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); return STTD_ERROR_INVALID_PARAMETER; } - if (NULL != g_cur_engine.default_lang) { - *language = strdup(g_cur_engine.default_lang); - - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Get default lanaguae : language(%s)", *language); - } else { - if (NULL == g_cur_engine.pefuncs->foreach_langs) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] foreach_langs of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); - /* get language list */ - int ret; - GList* lang_list = NULL; + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } - ret = g_cur_engine.pefuncs->foreach_langs(__supported_language_cb, &lang_list); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + return STTD_ERROR_OPERATION_FAILED; + } - if (0 == ret && 0 < g_list_length(lang_list)) { - GList *iter = NULL; - iter = g_list_first(lang_list); + bool temp = false; + int ret; - if (NULL != iter) { - char* temp_lang = iter->data; + ret = stt_engine_support_recognition_type(engine->engine_id, type, &temp); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret); + return ret; + } - if (true != g_cur_engine.pefuncs->is_valid_lang(temp_lang)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail voice is NOT valid"); - return STTD_ERROR_OPERATION_FAILED; - } + *support = temp; - sttd_config_set_default_language(temp_lang); + return 0; +} - g_cur_engine.default_lang = g_strdup(temp_lang); +/* +* STT Engine Interfaces for client +*/ - *language = strdup(g_cur_engine.default_lang); +int __set_option(sttengine_info_s* engine, int silence) +{ + if (NULL == engine) + return -1; - SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] Select default voice : lang(%s)", temp_lang); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail to get language list : result(%d)\n", ret); - return STTD_ERROR_OPERATION_FAILED; + /* Check silence detection */ + if (engine->support_silence_detection) { + if (2 == silence) { + /* default option set */ + if (g_default_silence_detected != engine->silence_detection) { + if (0 != stt_engine_set_silence_detection(engine->engine_id, g_default_silence_detected)) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", g_default_silence_detected ? "true" : "false"); + } else { + engine->silence_detection = g_default_silence_detected; + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", g_default_silence_detected ? "true" : "false"); + } } - - __free_language_list(lang_list); } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine ERROR] Fail to get language list : result(%d)\n", ret); - return STTD_ERROR_OPERATION_FAILED; + if (silence != engine->silence_detection) { + if (0 != stt_engine_set_silence_detection(engine->engine_id, silence)) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection : %s", silence ? "true" : "false"); + } else { + engine->silence_detection = silence; + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Set silence detection : %s", silence ? "true" : "false"); + } + } } } - + return 0; } -int sttd_engine_setting_set_default_lang(const char* language) +int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type, + int silence, const char* credential, void* user_param) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + if (NULL == lang || NULL == recognition_type) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; + } + + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } + + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == g_cur_engine.pefuncs->is_valid_lang) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get_voice_list() of engine is NULL!!"); + if (0 != __set_option(engine, silence)) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set options"); return STTD_ERROR_OPERATION_FAILED; } - int ret = -1; - if(false == g_cur_engine.pefuncs->is_valid_lang(language)) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Language is NOT valid !!"); - return STTD_ERROR_INVALID_LANGUAGE; + SLOG(LOG_DEBUG, TAG_STTD, "g_default_language %s", g_default_language); + + int ret; + char* temp = NULL; + if (0 == strncmp(lang, "default", strlen("default"))) { + bool is_valid = false; + ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language"); + return ret; + } + + if (true == is_valid) { + temp = strdup(g_default_language); + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is %s", temp); + } else { + temp = strdup(engine->first_lang); + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent DEBUG] Default language is engine first lang : %s", temp); + } + } else { + temp = strdup(lang); + } + + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start engine"); + + ret = stt_engine_recognize_start(engine->engine_id, temp, recognition_type, credential, user_param); + if (NULL != temp) free(temp); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret); + sttd_recorder_destroy(engine->engine_id); + return ret; + } + +#ifdef AUDIO_CREATE_ON_START + /* Ready recorder */ + sttp_audio_type_e atype; + int rate; + int channels; + + ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels); + if (0 != ret) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name); + return ret; } - if (NULL != g_cur_engine.default_lang) - g_free(g_cur_engine.default_lang); + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder"); + + ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate); + if (0 != ret) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name); + return ret; + } +#endif - g_cur_engine.default_lang = strdup(language); +#if 0 + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder"); - ret = sttd_config_set_default_language(language); + ret = sttd_recorder_start(engine->engine_id); if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set default lang (%d)", ret); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret); + return ret; } + g_recording_engine_id = engine->engine_id; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] g_recording_engine_id : %d", g_recording_engine_id); +#endif + return 0; } -int sttd_engine_setting_get_profanity_filter(bool* value) +int sttd_engine_agent_recognize_start_recorder(int uid) { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == value) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder"); + + int ret; + ret = sttd_recorder_start(engine->engine_id); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret); + stt_engine_recognize_cancel(engine->engine_id); + sttd_recorder_stop(engine->engine_id); + return ret; } - *value = g_default_profanity_filter; + g_recording_engine_id = engine->engine_id; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] g_recording_engine_id : %d", g_recording_engine_id); return 0; } -int sttd_engine_setting_set_profanity_filter(bool value) +int sttd_engine_agent_set_recording_data(int uid, const void* data, unsigned int length) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == data || 0 == length) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == g_cur_engine.pefuncs->set_profanity_filter) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; } - int ret = g_cur_engine.pefuncs->set_profanity_filter(value); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail set profanity filter : result(%d)", ret); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - g_default_profanity_filter = value; - - ret = sttd_config_set_default_profanity_filter((int)value); + int ret = stt_engine_set_recording_data(engine->engine_id, data, length); if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set default lang (%d)", ret); + SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret); } - return 0; + return ret; } -int sttd_engine_setting_get_punctuation_override(bool* value) +int sttd_engine_agent_recognize_stop_recorder(int uid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } + + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == value) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder"); + int ret; + ret = sttd_recorder_stop(engine->engine_id); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret); + return ret; } - *value = g_default_punctuation_override; +#ifdef AUDIO_CREATE_ON_START + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder"); + if (0 != sttd_recorder_destroy(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id); +#endif + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder"); return 0; } -int sttd_engine_setting_set_punctuation_override(bool value) +int sttd_engine_agent_recognize_stop_engine(int uid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); - if (NULL == g_cur_engine.pefuncs->set_punctuation) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The function of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; } - int ret = g_cur_engine.pefuncs->set_punctuation(value); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail set punctuation override : result(%d)", ret); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - g_default_punctuation_override = value; - ret = sttd_config_set_default_punctuation_override((int)value); + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop engine"); + + int ret; + ret = stt_engine_recognize_stop(engine->engine_id); if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set punctuation override (%d)", ret); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret); + return ret; } + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine"); + return 0; } -int sttd_engine_setting_get_silence_detection(bool* value) +int sttd_engine_agent_recognize_cancel(int uid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); + + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); + return STTD_ERROR_INVALID_PARAMETER; + } + + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == value) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); - return STTD_ERROR_INVALID_PARAMETER; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Cancel engine"); + + int ret; + ret = stt_engine_recognize_cancel(engine->engine_id); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret); + return ret; + } + + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder"); + + ret = sttd_recorder_stop(engine->engine_id); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret); + return ret; } - *value = g_default_silence_detected; +#ifdef AUDIO_CREATE_ON_START + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder"); + if (0 != sttd_recorder_destroy(engine->engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", engine->engine_id); +#endif + + g_recording_engine_id = -1; + + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Cancel recognition"); return 0; } -int sttd_engine_setting_set_silence_detection(bool value) + +/* +* STT Engine Interfaces for configure +*/ + +int sttd_engine_agent_set_default_engine(const char* engine_uuid) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; + if (NULL == engine_uuid) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + return STTD_ERROR_INVALID_PARAMETER; } - int ret = g_cur_engine.pefuncs->set_silence_detection(value); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail set silence detection : result(%d)", ret); - return STTD_ERROR_OPERATION_FAILED; - } - - g_default_silence_detected = value; + __log_enginelist(); - ret = sttd_config_set_default_silence_detection((int)value); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to set silence detection (%d)", ret); + sttengine_info_s* engine; + engine = __engine_agent_get_engine_by_uuid(engine_uuid); + if (NULL == engine) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Default engine is not valid"); + return STTD_ERROR_ENGINE_NOT_FOUND; } - - return 0; -} -bool __engine_setting_cb(const char* key, const char* value, void* user_data) -{ - GList** engine_setting_list = (GList**)user_data; + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine id(%d) engine uuid(%s)", engine->engine_id, engine->engine_uuid); - if (NULL == engine_setting_list || NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL in engine setting callback!!!!"); - return false; - } + g_default_engine_id = engine->engine_id; + + /* Update default engine of client */ + GSList *iter = NULL; + sttengine_client_s *data = NULL; + + if (0 < g_slist_length(g_engine_client_list)) { + iter = g_slist_nth(g_engine_client_list, 0); - engine_setting_s* temp = g_malloc0(sizeof(engine_setting_s)); - temp->key = g_strdup(key); - temp->value = g_strdup(value); + while (NULL != iter) { + /* Get handle data from list */ + data = iter->data; + + if (true == data->use_default_engine) { + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] uid(%d) change engine from id(%d) to id(%d)", + data->uid, data->engine_id, engine->engine_id); - *engine_setting_list = g_list_append(*engine_setting_list, temp); + if (0 != sttd_engine_agent_load_current_engine(data->uid, NULL)) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load current engine : uid(%d)", data->uid); + } + } + + iter = g_slist_next(iter); + } + } - return true; + return 0; } -int sttd_engine_setting_get_engine_setting_info(char** engine_id, GList** setting_list) +int sttd_engine_agent_set_default_language(const char* language) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); - return STTD_ERROR_OPERATION_FAILED; - } - - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (NULL == setting_list) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Input parameter is NULL"); + if (NULL == language) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == g_cur_engine.pefuncs->foreach_engine_settings) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] foreach_engine_settings() of engine is NULL!!"); - return STTD_ERROR_OPERATION_FAILED; - } + if (NULL != g_default_language) + free(g_default_language); - /* get setting info and move setting info to input parameter */ - int result = 0; + g_default_language = strdup(language); - result = g_cur_engine.pefuncs->foreach_engine_settings(__engine_setting_cb, setting_list); + return 0; +} - if (0 == result && 0 < g_list_length(*setting_list)) { - *engine_id = strdup(g_cur_engine.engine_uuid); - } else { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] fail to get setting info : result(%d)\n", result); - result = STTD_ERROR_OPERATION_FAILED; +int sttd_engine_agent_set_silence_detection(bool value) +{ + if (false == g_agent_init) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + return STTD_ERROR_OPERATION_FAILED; } - return result; + g_default_silence_detected = value; + + return 0; } -int sttd_engine_setting_set_engine_setting(const char* key, const char* value) +int sttd_engine_agent_check_app_agreed(int uid, const char* appid, bool* result) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized"); return STTD_ERROR_OPERATION_FAILED; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); - return STTD_ERROR_OPERATION_FAILED; - } + sttengine_info_s* engine = NULL; + engine = __engine_agent_get_engine_by_uid(uid); - if (NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Invalid Parameter"); + if (NULL == engine) { + SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine of uid(%d) is not valid", uid); return STTD_ERROR_INVALID_PARAMETER; } - if (NULL == g_cur_engine.pefuncs->set_engine_setting) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] set_engine_setting() of engine is NULL!!"); + if (false == engine->is_loaded) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine"); return STTD_ERROR_OPERATION_FAILED; } - /* get setting info and move setting info to input parameter */ - int ret = g_cur_engine.pefuncs->set_engine_setting(key, value); + int ret; + ret = stt_engine_check_app_agreed(engine->engine_id, appid, result); if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail set setting info (%d) ", ret); - return STTD_ERROR_OPERATION_FAILED; + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret); + return ret; } + + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false"); return 0; } -/* -* STT Engine Callback Functions ` * -*/ - -void __result_cb(sttp_result_event_e event, const char* type, - const char** data, int data_count, const char* msg, void *user_data) +static void __recorder_destroy(void* data) { - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized"); - return; - } + sttp_result_event_e event = (sttp_result_event_e)data; - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not loaded engine"); - return; + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder by ecore_thread_safe func"); + + if (0 != sttd_recorder_destroy(g_recording_engine_id)) { + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", g_recording_engine_id); } - return g_result_cb(event, type, data, data_count, msg, user_data); + if (event == STTP_RESULT_EVENT_FINAL_RESULT || event == STTP_RESULT_EVENT_ERROR) { + g_recording_engine_id = -1; + } } -void __partial_result_cb(sttp_result_event_e event, const char* data, void *user_data) + +/* +* STT Engine Callback Functions ` * +*/ + +void __result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count, + const char* msg, void* time_info, void *user_data) { if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Partial Result Callback : Not Initialized"); + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized"); return; } - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Partial Result Callback : Not loaded engine"); - return; + SLOG(LOG_DEBUG, TAG_STTD, "[Server] === Result time callback ==="); + + if (NULL != time_info) { + /* Get the time info */ + int ret = stt_engine_foreach_result_time(g_recording_engine_id, time_info, __result_time_cb, NULL); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret); + } } - return g_partial_result_cb(event, data, user_data); -} + SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================"); -void __detect_silence_cb(void* user_data) -{ - if (false == g_agent_init) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized"); - return; - } + g_result_cb(event, type, data, data_count, msg, user_data); - if (false == g_cur_engine.is_loaded) { - SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not loaded engine"); - return; +#ifdef AUDIO_CREATE_ON_START + if (event == STTP_RESULT_EVENT_ERROR) { +#if 1 + ecore_main_loop_thread_safe_call_async(__recorder_destroy, (void*)event); +#else + SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder"); + if (0 != sttd_recorder_destroy(g_recording_engine_id)) + SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder(%d)", g_recording_engine_id); +#endif } +#endif - if (true == g_cur_engine.silence_detection) { - g_silence_cb(user_data); - } else { - SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Silence detection callback is blocked because option value is false."); +#ifndef AUDIO_CREATE_ON_START + if (event == STTP_RESULT_EVENT_FINAL_RESULT || event == STTP_RESULT_EVENT_ERROR) { + g_recording_engine_id = -1; } +#endif + return; } -void __free_language_list(GList* lang_list) +bool __result_time_cb(int index, sttp_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data) { - GList *iter = NULL; - char* data = NULL; - - /* if list have item */ - if (g_list_length(lang_list) > 0) { - /* Get a first item */ - iter = g_list_first(lang_list); - - while (NULL != iter) { - data = iter->data; - - if (NULL != data) - g_free(data); - - lang_list = g_list_remove_link(lang_list, iter); + return g_result_time_cb(index, event, text, start_time, end_time, user_data); +} - iter = g_list_first(lang_list); - } +void __detect_silence_cb(sttp_silence_type_e type, void* user_data) +{ + if (false == g_agent_init) { + SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized"); + return; } + + g_silence_cb(type, user_data); + return; } /* A function forging */ int __log_enginelist() { - GList *iter = NULL; + GSList *iter = NULL; sttengine_info_s *data = NULL; - if (0 < g_list_length(g_engine_list)) { + if (0 < g_slist_length(g_engine_list)) { /* Get a first item */ - iter = g_list_first(g_engine_list); + iter = g_slist_nth(g_engine_list, 0); SLOG(LOG_DEBUG, TAG_STTD, "--------------- engine list -------------------"); - int i = 1; + int i = 1; while (NULL != iter) { /* Get handle data from list */ data = iter->data; - SLOG(LOG_DEBUG, TAG_STTD, "[%dth]", i); - SLOG(LOG_DEBUG, TAG_STTD, " engine uuid : %s", data->engine_uuid); - SLOG(LOG_DEBUG, TAG_STTD, " engine name : %s", data->engine_name); - SLOG(LOG_DEBUG, TAG_STTD, " engine path : %s", data->engine_path); - SLOG(LOG_DEBUG, TAG_STTD, " setting ug path : %s", data->setting_ug_path); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[%dth]", i); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " engine uuid : %s", data->engine_uuid); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " engine name : %s", data->engine_name); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " engine path : %s", data->engine_path); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " use network : %s", data->use_network ? "true" : "false"); + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " is loaded : %s", data->is_loaded ? "true" : "false"); + if (NULL != data->first_lang) + SECURE_SLOG(LOG_DEBUG, TAG_STTD, " default lang : %s", data->first_lang); - iter = g_list_next(iter); + iter = g_slist_next(iter); i++; } SLOG(LOG_DEBUG, TAG_STTD, "----------------------------------------------"); @@ -1861,6 +1661,3 @@ int __log_enginelist() return 0; } - - -