--- /dev/null
+/*
+* Copyright (c) 2022 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
+* http://www.apache.org/licenses/LICENSE-2.0
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+#include <stdexcept>
+#include <dlog.h>
+
+#include "vc_main.h"
+
+#include "VoiceControlEngineInfo.h"
+
+
+using namespace std;
+
+VoiceControlEngineInfo::VoiceControlEngineInfo(const std::string filePath)
+{
+ SLOG(LOG_INFO, TAG_VCCONFIG, "[Constructor] VoiceControlEngineInfo");
+
+ vc_engine_info_s *engine_info = nullptr;
+ if (0 != vc_parser_get_engine_info(filePath.c_str(), &engine_info) || engine_info == nullptr) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Fail to get engine info from path (%s)", filePath.c_str());
+ throw runtime_error("operation failed");
+ }
+
+ if (engine_info->name) {
+ __engineName = engine_info->name;
+ }
+ if (engine_info->uuid) {
+ __engineId = engine_info->uuid;
+ }
+ if (engine_info->setting) {
+ __settingPath = engine_info->setting;
+ }
+ if (engine_info->default_lang) {
+ __defaultLanguage = engine_info->default_lang;
+ }
+ __nonFixedSupported = engine_info->non_fixed_support;
+
+ GSList *iter = g_slist_nth(engine_info->languages, 0);
+ while (nullptr != iter) {
+ const char *language = static_cast<const char *>(iter->data);
+ if (language != nullptr) {
+ __supportedLanguages.push_back(language);
+ }
+
+ iter = g_slist_next(iter);
+ }
+
+ vc_parser_free_engine_info(engine_info);
+}
+
+VoiceControlEngineInfo::~VoiceControlEngineInfo()
+{
+ SLOG(LOG_INFO, TAG_VCCONFIG, "[Destructor] VoiceControlEngineInfo");
+}
+
+void VoiceControlEngineInfo::printOutEngine()
+{
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " name : %s", __engineName.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " id : %s", __engineId.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " setting : %s", __settingPath.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " default language : %s", __defaultLanguage.c_str());
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " languages :");
+
+ if (__supportedLanguages.size() == 0) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " language is NONE");
+ } else {
+ unsigned int index = 1;
+ for (auto language : __supportedLanguages) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " [%uth] %s", index, language.c_str());
+ index++;
+ }
+ }
+}
+
+bool VoiceControlEngineInfo::isLanguageValid(const std::string language)
+{
+ for (auto supportedLanguage : __supportedLanguages) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "Compare language(%s), Target(%s)", supportedLanguage.c_str(), language.c_str());
+ if (0 == supportedLanguage.compare(language)) {
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Language(%s) is valid", language.c_str());
+ return true;
+ }
+ }
+
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Language(%s) is not valid", language.c_str());
+ return false;
+}
+
+std::string VoiceControlEngineInfo::getEngineName()
+{
+ return __engineName;
+}
+
+std::string VoiceControlEngineInfo::getEngineId()
+{
+ return __engineId;
+}
+
+std::string VoiceControlEngineInfo::getSettingPath()
+{
+ return __settingPath;
+}
+
+std::string VoiceControlEngineInfo::getDefaultLanguage()
+{
+ return __defaultLanguage;
+}
+
+std::vector<std::string> VoiceControlEngineInfo::getSupportedLanguages()
+{
+ return __supportedLanguages;
+}
+
+bool VoiceControlEngineInfo::isNonFixedSupported()
+{
+ return __nonFixedSupported;
+}
+
--- /dev/null
+/*
+* Copyright (c) 2022 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
+* http://www.apache.org/licenses/LICENSE-2.0
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+#include "vc_main.h"
+
+#include "VoiceControlEngines.h"
+
+using namespace std;
+
+VoiceControlEngines::VoiceControlEngines()
+{
+ SLOG(LOG_INFO, TAG_VCCONFIG, "[Constructor] VoiceControlEngines");
+}
+
+VoiceControlEngines::~VoiceControlEngines()
+{
+ SLOG(LOG_INFO, TAG_VCCONFIG, "[Destructor] VoiceControlEngines");
+}
+
+void VoiceControlEngines::printOutEngineInfo()
+{
+ unique_lock<mutex> lock(__enginesMutex);
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "@ Engine list @");
+
+ if (0 == __engines.size()) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, " No Engine in engine directory");
+ } else {
+ unsigned int index = 0;
+ for (auto engineInfo : __engines) {
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "[%uth]", index);
+ engineInfo.printOutEngine();
+ }
+ }
+
+ SLOG(LOG_DEBUG, TAG_VCCONFIG, "@@@@");
+}
+
+void VoiceControlEngines::appendEngine(const std::string path)
+{
+ unique_lock<mutex> lock(__enginesMutex);
+
+ try {
+ VoiceControlEngineInfo engineInfo(path);
+ __engines.push_back(engineInfo);
+ } catch (runtime_error &error) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to append engine info from path(%s)", path.c_str());
+ throw error;
+ }
+}
+
+bool VoiceControlEngines::isEngineIdValid(const std::string engineId)
+{
+ if (engineId.empty()) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Engine ID is NULL");
+ return false;
+ }
+
+ unique_lock<mutex> lock(__enginesMutex);
+ bool isValid = (nullptr != findEngine(engineId));
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Engine Id(%s) is %svalid", engineId.c_str(), (isValid ? "" : "not "));
+ return isValid;
+}
+
+std::shared_ptr<VoiceControlEngineInfo> VoiceControlEngines::getEngineInfo(const std::string engineId)
+{
+ if (engineId.empty()) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Engine ID is NULL");
+ return nullptr;
+ }
+
+ unique_lock<mutex> lock(__enginesMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get engine info with ID(%s)", engineId.c_str());
+ auto engineInfo = findEngine(engineId);
+ if (engineInfo == nullptr) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Fail to found engine info");
+ return nullptr;
+ }
+
+ return make_shared<VoiceControlEngineInfo>(*engineInfo);
+}
+
+std::shared_ptr<VoiceControlEngineInfo> VoiceControlEngines::getFirstEngineInfo()
+{
+ unique_lock<mutex> lock(__enginesMutex);
+ if (__engines.size() == 0) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] There is no engine");
+ return nullptr;
+ }
+
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get first engine info. size(%u)", __engines.size());
+ return make_shared<VoiceControlEngineInfo>(__engines[0]);
+}
+
+VoiceControlEngineInfo *VoiceControlEngines::findEngine(const std::string engineId)
+{
+ if (engineId.empty()) {
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "[ERROR] Engine ID is NULL");
+ return nullptr;
+ }
+
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Find engine ID (%s)", engineId.c_str());
+ for (auto &engineInfo : __engines) {
+ if (0 == engineInfo.getEngineId().compare(engineId)) {
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Success to find engine (%s)", engineId.c_str());
+ return &engineInfo;
+ }
+ }
+
+ SLOG(LOG_ERROR, TAG_VCCONFIG, "There is no engine (%s)", engineId.c_str());
+ return nullptr;
+}
+
+std::vector<VoiceControlEngineInfo> VoiceControlEngines::getEngines()
+{
+ unique_lock<mutex> lock(__enginesMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Get engines. size(%u)", __engines.size());
+ return __engines;
+}
+
+bool VoiceControlEngines::isEngineEmpty()
+{
+ unique_lock<mutex> lock(__enginesMutex);
+ SLOG(LOG_INFO, TAG_VCCONFIG, "Length of engines (%u)", __engines.size());
+ return __engines.empty();
+}
+
#include <string>
#include "VoiceControlConfig.h"
+#include "VoiceControlEngines.h"
#include "vc_config_mgr.h"
#include "vc_config_parser.h"
static atomic<bool> g_config_mgr_initialized(false);
-static GSList* g_engine_list = NULL;
+static VoiceControlEngines *g_VoiceControlEngines = nullptr;
static GSList* g_config_client_list = NULL;
static int __vc_config_mgr_unregister_engine_config_updated_event();
static int __vc_config_mgr_set_default_language(const char* language);
-int __vc_config_mgr_print_engine_info();
int __vc_config_mgr_print_client_info();
static gint __compare_uid_in_client_list(gconstpointer a, gconstpointer b)
return result;
}
-static gint __compare_engine_id_in_engine_list(gconstpointer a, gconstpointer b)
-{
- const vc_engine_info_s *engine_info = static_cast<const vc_engine_info_s *>(a);
- const char *engine_id = static_cast<const char *>(b);
-
- if (NULL == engine_id) {
- return 1;
- }
-
- if (NULL == engine_info || NULL == engine_info->uuid) {
- return 1;
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "Compare engine(%s). Target(%s)", engine_info->uuid, engine_id);
- return strcmp(engine_info->uuid, engine_id);
-}
-
-static vc_engine_info_s *__find_engine_info(const char *engine_id)
-{
- GSList *target = g_slist_find_custom(g_engine_list, engine_id, __compare_engine_id_in_engine_list);
- vc_engine_info_s *result = NULL;
- if (NULL != target) {
- result = static_cast<vc_engine_info_s *>(target->data);
- }
-
- return result;
-}
-
-static gint __compare_language_in_languages_of_engine_info(gconstpointer a, gconstpointer b)
-{
- const char *language = static_cast<const char *>(a);
- const char *target_language = static_cast<const char *>(b);
-
- if (NULL == language || NULL == target_language) {
- return 1;
- }
-
- SLOG(LOG_DEBUG, vc_config_tag(), "Compare langauge(%s), Target(%s)", language, target_language);
- return strcmp(language, target_language);
-}
-
-static bool __is_language_valid(vc_engine_info_s *engine_info, const char *language)
-{
- if (NULL == engine_info || NULL == language) {
- return false;
- }
-
- GSList *target = g_slist_find_custom(engine_info->languages, language, __compare_language_in_languages_of_engine_info);
- return (NULL != target);
-}
-
static void __invoke_lang_cb_in_client_list(gpointer data, gpointer user_data)
{
vc_config_client_s* client_info = (vc_config_client_s*)data;
return VC_CONFIG_ERROR_INVALID_PARAMETER;
}
- if (0 >= g_slist_length(g_engine_list)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine!!");
- return VC_CONFIG_ERROR_OPERATION_FAILED;
- }
-
- if (NULL != __find_engine_info(engine_id)) {
+ if (g_VoiceControlEngines->isEngineIdValid(engine_id)) {
SLOG(LOG_DEBUG, vc_config_tag(), "Default engine is valid : %s", engine_id);
return VC_CONFIG_ERROR_NONE;
}
- GSList *iter = g_slist_nth(g_engine_list, 0);
- if (NULL == iter) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] No engine in list");
- return -1;
- }
-
- vc_engine_info_s *engine_info = static_cast<vc_engine_info_s *>(iter->data);
- if (NULL == engine_info) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Engine info is NULL");
- return -1;
- }
-
- if (NULL == engine_info->uuid) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Engine id is NULL");
- return -1;
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getFirstEngineInfo();
+ if (nullptr == engineInfo || engineInfo->getEngineId().empty()) {
+ SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no valid engine!!");
+ return VC_CONFIG_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, vc_config_tag(), "Default engine is changed : %s", engine_info->uuid);
- if (0 != vc_parser_set_engine(engine_info->uuid)) {
+ string engineId = engineInfo->getEngineId();
+ SLOG(LOG_DEBUG, vc_config_tag(), "Default engine is changed : %s", engineId.c_str());
+ if (0 != vc_parser_set_engine(engineId.c_str())) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to save config");
return -1;
}
- g_VoiceControlConfig->setEngineId(engine_info->uuid);
+ g_VoiceControlConfig->setEngineId(engineId.c_str());
return VC_ERROR_NONE;
}
return false;
}
- if (0 >= g_slist_length(g_engine_list)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine!!");
- return false;
- }
-
- vc_engine_info_s *engine_info = __find_engine_info(engine_id);
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(engine_id);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", engine_id);
return false;
}
- bool is_language_valid = __is_language_valid(engine_info, language);
+ bool is_language_valid = engineInfo->isLanguageValid(language);
SLOG(LOG_INFO, vc_config_tag(), "[INFO] Language(%s), is valid(%d)", language, (int)is_language_valid);
return is_language_valid;
return VC_ERROR_OPERATION_FAILED;
}
- if (0 >= g_slist_length(g_engine_list)) {
+ if (g_VoiceControlEngines->isEngineEmpty()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine!!");
return VC_ERROR_OPERATION_FAILED;
}
- vc_engine_info_s *engine_info = __find_engine_info(engine_id);
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(engine_id);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", engine_id);
return VC_ERROR_INVALID_PARAMETER;
}
- if (NULL == engine_info->default_lang) {
+ if (engineInfo->getDefaultLanguage().empty()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] default language of engine info is NULL");
return VC_CONFIG_ERROR_INVALID_LANGUAGE;
}
- *language = strdup(engine_info->default_lang);
+ *language = strdup(engineInfo->getDefaultLanguage().c_str());
if (NULL == *language) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to allocate memory");
return VC_CONFIG_ERROR_OUT_OF_MEMORY;
void __vc_config_release_engine()
{
- GSList *iter = NULL;
- vc_engine_info_s *engine_info = NULL;
-
- if (0 < g_slist_length(g_engine_list)) {
-
- /* Get a first item */
- iter = g_slist_nth(g_engine_list, 0);
-
- while (NULL != iter) {
- engine_info = static_cast<vc_engine_info_s *>(iter->data);
-
- if (NULL != engine_info) {
- g_engine_list = g_slist_remove(g_engine_list, engine_info);
-
- vc_parser_free_engine_info(engine_info);
- }
-
- iter = g_slist_nth(g_engine_list, 0);
- }
- }
-
- g_slist_free(g_engine_list);
- g_engine_list = nullptr;
+ delete g_VoiceControlEngines;
+ g_VoiceControlEngines = nullptr;
}
int __vc_config_mgr_get_engine_info()
char filepath[512] = {'\0',};
int filesize;
- vc_engine_info_s* info = NULL;
SLOG(LOG_DEBUG, vc_config_tag(), "[CONFIG] Release engine and Unregister engine config");
__vc_config_release_engine();
- g_engine_list = NULL;
+
+ g_VoiceControlEngines = new(nothrow) VoiceControlEngines();
+ if (g_VoiceControlEngines == nullptr) {
+ SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to allocate VoiceControlEngines");
+ return VC_CONFIG_ERROR_OUT_OF_MEMORY;
+ }
+
__vc_config_mgr_unregister_engine_config_updated_event();
SLOG(LOG_DEBUG, vc_config_tag(), "[CONFIG] default directory : %s", VC_DEFAULT_ENGINE_INFO);
SECURE_SLOG(LOG_DEBUG, vc_config_tag(), "[CONFIG] Filepath(%s)", filepath);
- if (0 == vc_parser_get_engine_info(filepath, &info)) {
- g_engine_list = g_slist_append(g_engine_list, info);
+ try {
+ g_VoiceControlEngines->appendEngine(filepath);
if (0 != __vc_config_mgr_register_engine_config_updated_event(filepath)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to register engine config updated event");
}
+ } catch (exception &error) {
+ SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get engine info from filepath(%s). (%s)", filepath, error.what());
}
}
} while (NULL != dirp);
closedir(dp);
}
- if (0 >= g_slist_length(g_engine_list)) {
+ if (g_VoiceControlEngines->isEngineEmpty()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] No engine");
return -1;
}
if (0 != ret) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get engine info when config updated");
}
- __vc_config_mgr_print_engine_info();
+
+ g_VoiceControlEngines->printOutEngineInfo();
string default_language = g_VoiceControlConfig->getCurrentLanguage();
bool is_language_valid = vc_config_check_default_language_is_valid(default_language.c_str());
if (false == is_language_valid) {
}
/* Get file name from default engine directory */
- __vc_config_release_engine();
-
if (0 != access(VC_CONFIG_BASE, F_OK)) {
if (0 != mkdir(VC_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to make directory : %s", VC_CONFIG_BASE);
return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
- __vc_config_mgr_print_engine_info();
+ g_VoiceControlEngines->printOutEngineInfo();
if (0 != __initialize_config_info()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to parse configure information");
return VC_CONFIG_ERROR_INVALID_PARAMETER;
}
- GSList *iter = NULL;
- vc_engine_info_s *engine_info = NULL;
-
- if (0 >= g_slist_length(g_engine_list)) {
+ if (g_VoiceControlEngines->isEngineEmpty()) {
SLOG(LOG_WARN, vc_config_tag(), "[ERROR] Engine list is NULL");
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
- /* Get a first item */
- iter = g_slist_nth(g_engine_list, 0);
-
- while (NULL != iter) {
- engine_info = static_cast<vc_engine_info_s *>(iter->data);
-
- if (NULL == engine_info) {
- SLOG(LOG_ERROR, vc_config_tag(), " Engine info is NULL");
- pthread_mutex_unlock(&vc_config_mgr_mutex);
- return VC_CONFIG_ERROR_OPERATION_FAILED;
+ auto engines = g_VoiceControlEngines->getEngines();
+ for (auto &engineInfo : engines) {
+ if (false == g_VoiceControlEngines->isEngineIdValid(engineInfo.getEngineId())) {
+ SLOG(LOG_WARN, vc_config_tag(), "Engine info is not valid. (%s)", engineInfo.getEngineId().c_str());
+ continue;
}
- if (false == callback(engine_info->name, engine_info->uuid, engine_info->setting, engine_info->default_lang, engine_info->non_fixed_support, user_data))
+ if (false == callback(engineInfo.getEngineName().c_str(), engineInfo.getEngineId().c_str(), engineInfo.getSettingPath().c_str(),
+ engineInfo.getDefaultLanguage().c_str(), engineInfo.isNonFixedSupported(), user_data)) {
+ SLOG(LOG_DEBUG, vc_config_tag(), "Callback returns false. (%s)", engineInfo.getEngineId().c_str());
break;
-
- iter = g_slist_next(iter);
+ }
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
/* Check current engine id with new engine id */
string default_engine_id = g_VoiceControlConfig->getEngineId();
if (0 == default_engine_id.compare(engine)) {
- SLOG(LOG_DEBUG, vc_config_tag(), "Engine is not changed : %s", engine);
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_NONE;
}
return ret;
}
- vc_engine_info_s *engine_info = __find_engine_info(engine);
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(engine);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", engine);
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_INVALID_PARAMETER;
/* Engine is valid*/
string default_language = g_VoiceControlConfig->getCurrentLanguage();
- bool is_language_valid = __is_language_valid(engine_info, default_language.c_str());
+ bool is_language_valid = engineInfo->isLanguageValid(default_language);
SLOG(LOG_ERROR, vc_config_tag(), "[INFO] Language(%s), is valid(%d)", default_language.c_str(), (int)is_language_valid);
- char* lang = NULL;
if (false == is_language_valid) {
- GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
- if (NULL == iter_lang || NULL == iter_lang->data) {
+ auto languages = engineInfo->getSupportedLanguages();
+ if (languages.empty()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Fail to get default language. Engine id(%s) is not valid", engine);
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_OPERATION_FAILED;
}
- lang = static_cast<char *>(iter_lang->data);
- g_VoiceControlConfig->setCurrentLanguage(lang);
+ g_VoiceControlConfig->setCurrentLanguage(languages[0].c_str());
}
SLOG(LOG_DEBUG, vc_config_tag(), "[Config] Engine changed");
return -1;
}
- if (0 >= g_slist_length(g_engine_list)) {
+ if (nullptr == callback) {
+ SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] Callback is null");
+ pthread_mutex_unlock(&vc_config_mgr_mutex);
+ return VC_CONFIG_ERROR_INVALID_PARAMETER;
+ }
+
+ if (g_VoiceControlEngines->isEngineEmpty()) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine");
pthread_mutex_unlock(&vc_config_mgr_mutex);
return -1;
}
string default_engine_id = g_VoiceControlConfig->getEngineId();
- vc_engine_info_s *engine_info = __find_engine_info(default_engine_id.c_str());
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(default_engine_id);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "Fail to find engine information : %s", default_engine_id.c_str());
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_NONE;
}
/* Get a first item */
- GSList *iter_lang = g_slist_nth(engine_info->languages, 0);
-
- while (NULL != iter_lang) {
- /*Get handle data from list*/
- char* lang = static_cast<char *>(iter_lang->data);
-
- SLOG(LOG_INFO, vc_config_tag(), "lang(%s)", lang);
- if (NULL != lang) {
- if (false == callback(lang, user_data))
- break;
+ auto languages = engineInfo->getSupportedLanguages();
+ for (auto &language : languages) {
+ SLOG(LOG_INFO, vc_config_tag(), "language (%s)", language.c_str());
+ if (language.empty()) {
+ SLOG(LOG_WARN, vc_config_tag(), "Language is not valid");
+ continue;
}
- /*Get next item*/
- iter_lang = g_slist_next(iter_lang);
+ if (false == callback(language.c_str(), user_data)) {
+ SLOG(LOG_DEBUG, vc_config_tag(), "Callback returns false (%s)", language.c_str());
+ break;
+ }
}
pthread_mutex_unlock(&vc_config_mgr_mutex);
return -1;
}
- if (0 >= g_slist_length(g_engine_list)) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine");
- pthread_mutex_unlock(&vc_config_mgr_mutex);
- return -1;
- }
-
string default_engine_id = g_VoiceControlConfig->getEngineId();
- vc_engine_info_s *engine_info = __find_engine_info(default_engine_id.c_str());
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(default_engine_id);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", default_engine_id.c_str());
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_CONFIG_ERROR_ENGINE_NOT_FOUND;
};
- *value = engine_info->non_fixed_support;
+ *value = engineInfo->isNonFixedSupported();
pthread_mutex_unlock(&vc_config_mgr_mutex);
return VC_ERROR_NONE;
return false;
}
- if (0 >= g_slist_length(g_engine_list)) {
- pthread_mutex_unlock(&vc_config_mgr_mutex);
- return false;
- }
-
- vc_engine_info_s *engine_info = __find_engine_info(engine);
- if (NULL == engine_info) {
- SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", engine);
- };
-
+ bool is_valid = g_VoiceControlEngines->isEngineIdValid(engine);
pthread_mutex_unlock(&vc_config_mgr_mutex);
- return (NULL != engine_info);
+ return is_valid;
}
bool vc_config_check_default_language_is_valid(const char* language)
return false;
}
- if (0 >= g_slist_length(g_engine_list)) {
- return false;
- }
-
-
string default_engine_id = g_VoiceControlConfig->getEngineId();
- vc_engine_info_s *engine_info = __find_engine_info(default_engine_id.c_str());
- if (NULL == engine_info) {
+ shared_ptr<VoiceControlEngineInfo> engineInfo = g_VoiceControlEngines->getEngineInfo(default_engine_id);
+ if (nullptr == engineInfo) {
SLOG(LOG_ERROR, vc_config_tag(), "[ERROR] There is no engine with id (%s)!!", default_engine_id.c_str());
return false;
};
- bool is_language_valid = __is_language_valid(engine_info, language);
+ bool is_language_valid = engineInfo->isLanguageValid(language);
SLOG(LOG_INFO, vc_config_tag(), "[INFO] Language(%s), is valid(%d)", language, (int)is_language_valid);
return is_language_valid;
return vc_parser_get_foreground(pid);
}
-int __vc_config_mgr_print_engine_info()
-{
- GSList *iter = NULL;
- vc_engine_info_s *engine_info = NULL;
-
- if (0 >= g_slist_length(g_engine_list)) {
- SLOG(LOG_DEBUG, vc_config_tag(), "@ engine list @");
- SLOG(LOG_DEBUG, vc_config_tag(), " No Engine in engine directory");
- SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
- return VC_ERROR_NONE;
- }
-
- /* Get a first item */
- iter = g_slist_nth(g_engine_list, 0);
-
- SLOG(LOG_DEBUG, vc_config_tag(), "@ engine list @");
-
- int i = 1;
- while (NULL != iter) {
- engine_info = static_cast<vc_engine_info_s *>(iter->data);
-
- SLOG(LOG_DEBUG, vc_config_tag(), "[%dth]", i);
- SLOG(LOG_DEBUG, vc_config_tag(), " name : %s", engine_info->name);
- SLOG(LOG_DEBUG, vc_config_tag(), " id : %s", engine_info->uuid);
-
-
- SLOG(LOG_DEBUG, vc_config_tag(), " languages");
- GSList *iter_lang = NULL;
- char* lang;
- if (g_slist_length(engine_info->languages) > 0) {
- /* Get a first item */
- iter_lang = g_slist_nth(engine_info->languages, 0);
-
- int j = 1;
- while (NULL != iter_lang) {
- /*Get handle data from list*/
- lang = static_cast<char *>(iter_lang->data);
-
- SLOG(LOG_DEBUG, vc_config_tag(), " [%dth] %s", j, lang);
-
- /*Get next item*/
- iter_lang = g_slist_next(iter_lang);
- j++;
- }
- } else {
- SLOG(LOG_DEBUG, vc_config_tag(), " language is NONE");
- }
- iter = g_slist_next(iter);
- i++;
- }
- SLOG(LOG_DEBUG, vc_config_tag(), "@@@@");
-
- return VC_ERROR_NONE;
-}
-
int __vc_config_mgr_print_client_info()
{
GSList *iter = NULL;