diff options
Diffstat (limited to 'src/plugins')
73 files changed, 6520 insertions, 0 deletions
diff --git a/src/plugins/CMakeLists.txt b/src/plugins/CMakeLists.txt new file mode 100644 index 0000000..06ef7a4 --- /dev/null +++ b/src/plugins/CMakeLists.txt @@ -0,0 +1,182 @@ +########################################################################### +# Copyright 2017-2018 Amazon.com, Inc. or its affiliates. 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. +########################################################################### + +PROJECT_TARGET_ADD(vshl-api) + + set(CMAKE_CXX_STANDARD 11) + set(CMAKE_CXX_STANDARD_REQUIRED ON) + set(CMAKE_CXX_EXTENSIONS OFF) + + set(VSHL_LIB_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/VshlApi.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/VshlApi.h + + # Interfaces + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/afb/IAFBApi.h + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/capabilities/ICapability.h + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/utilities/events/IEventFilter.h + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/utilities/logging/ILogger.h + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/voiceagents/IVoiceAgent.h + ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/voiceagents/IVoiceAgentsChangeObserver.h + + # AFB + ${CMAKE_CURRENT_SOURCE_DIR}/afb/AFBApiImpl.h + ${CMAKE_CURRENT_SOURCE_DIR}/afb/AFBApiImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/afb/AFBRequestImpl.h + ${CMAKE_CURRENT_SOURCE_DIR}/afb/AFBRequestImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/afb/include/AFBEventImpl.h + ${CMAKE_CURRENT_SOURCE_DIR}/afb/src/AFBEventImpl.cpp + + # VoiceAgents + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/VoiceAgentsDataManager.h + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/VoiceAgentsDataManagerImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/VoiceAgentEventNames.h + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/include/VoiceAgent.h + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/src/VoiceAgentImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/include/VoiceAgentEventsHandler.h + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/src/VoiceAgentEventsHandler.cpp + + # Core + ${CMAKE_CURRENT_SOURCE_DIR}/core/VRRequestProcessor.h + ${CMAKE_CURRENT_SOURCE_DIR}/core/VRRequestProcessorImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/core/include/VRAgentsObserver.h + ${CMAKE_CURRENT_SOURCE_DIR}/core/src/VRAgentsObserverImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/core/include/VRRequest.h + ${CMAKE_CURRENT_SOURCE_DIR}/core/src/VRRequestImpl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/core/include/VRRequestProcessorDelegate.h + ${CMAKE_CURRENT_SOURCE_DIR}/core/src/VRRequestProcessorDelegateImpl.cpp + + #Capabilities + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/CapabilitiesFactory.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/CapabilitiesFactory.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/CapabilityMessagingService.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/CapabilityMessagingService.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/include/MessageChannel.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/src/MessageChannel.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/include/PublisherForwarder.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/src/PublisherForwarder.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/include/SubscriberForwarder.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/core/src/SubscriberForwarder.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/communication/include/PhoneControlMessages.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/communication/include/PhoneControlCapability.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/communication/src/PhoneControlCapability.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/navigation/include/NavigationMessages.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/navigation/include/NavigationCapability.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/navigation/src/NavigationCapability.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/guimetadata/include/GuiMetadataMessages.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/guimetadata/include/GuiMetadataCapability.h + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/guimetadata/src/GuiMetadataCapability.cpp + + #Utilities + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/events/EventRouter.h + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/events/EventRouter.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/logging/Logger.h + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/logging/Logger.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/uuid/UUIDGeneration.h + ${CMAKE_CURRENT_SOURCE_DIR}/utilities/uuid/UUIDGeneration.cpp + ) + + # Define targets + ADD_LIBRARY(${TARGET_NAME} MODULE + ${VSHL_LIB_SRC} + ) + + # VSHL plugin properties + SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES + LABELS "PLUGIN" + PREFIX "" + SUFFIX ".ctlso" + OUTPUT_NAME ${TARGET_NAME} + ) + + # Define target includes + TARGET_INCLUDE_DIRECTORIES(${TARGET_NAME} + PUBLIC ${GLIB_PKG_INCLUDE_DIRS} + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}" + PRIVATE "${CMAKE_SOURCE_DIR}/app-controller/ctl-lib" + ) + + # Library dependencies (include updates automatically) + TARGET_LINK_LIBRARIES(${TARGET_NAME} + afb-helpers + ${GLIB_PKG_LIBRARIES} + ${link_libraries} + ) + + option(ENABLE_UNIT_TESTS "Build unit tests or not" OFF) + if (ENABLE_UNIT_TESTS) + execute_process( + COMMAND "${CMAKE_CURRENT_SOURCE_DIR}/agreement.sh" + RESULT_VARIABLE AGREEMENT_RESULT + ) + message(STATUS "Agreement Result: ${AGREEMENT_RESULT}") + if (${AGREEMENT_RESULT} MATCHES "1") + message(FATAL_ERROR "User agreement not accepted. Quitting") + endif() + + include(cmake/gtest.cmake) + + set(VSHL_TEST_SRC ${VSHL_LIB_SRC}) + list(APPEND VSHL_TEST_SRC + # Main + ${CMAKE_CURRENT_SOURCE_DIR}/TestMain.cpp + + # Test common + ${CMAKE_CURRENT_SOURCE_DIR}/test/common/ConsoleLogger.h + ${CMAKE_CURRENT_SOURCE_DIR}/test/common/ConsoleLogger.cpp + + # Test Mocks + ${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/AFBApiMock.h + ${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/AFBEventMock.h + ${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/AFBRequestMock.h + ${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/CapabilityMock.h + ${CMAKE_CURRENT_SOURCE_DIR}/test/mocks/VoiceAgentsChangeObserverMock.h + + # Capabilities + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/test/CapabilityMessagingServiceTest.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/test/PublisherForwarderTest.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/capabilities/test/SubscriberForwarderTest.cpp + + # Core + ${CMAKE_CURRENT_SOURCE_DIR}/core/test/VRRequestTest.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/core/test/VRRequestProcessorTest.cpp + + # VoiceAgents + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/test/VoiceAgentTest.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/voiceagents/test/VoiceAgentsDataManagerTest.cpp + ) + + ADD_EXECUTABLE(${TARGET_NAME}_Test + ${VSHL_TEST_SRC} + ) + + TARGET_INCLUDE_DIRECTORIES(${TARGET_NAME}_Test + PUBLIC ${GLIB_PKG_INCLUDE_DIRS} + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}" + PRIVATE "${CMAKE_SOURCE_DIR}/app-controller/ctl-lib" + ) + + TARGET_LINK_LIBRARIES(${TARGET_NAME}_Test + afb-helpers + libgtest + libgmock + ${GLIB_PKG_LIBRARIES} + ${link_libraries} + ) + + ENABLE_TESTING() + ADD_TEST(VshlTest ${TARGET_NAME}_Test) + endif()
\ No newline at end of file diff --git a/src/plugins/TestMain.cpp b/src/plugins/TestMain.cpp new file mode 100644 index 0000000..d4fcbec --- /dev/null +++ b/src/plugins/TestMain.cpp @@ -0,0 +1,20 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "gtest/gtest.h" + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}
\ No newline at end of file diff --git a/src/plugins/VshlApi.cpp b/src/plugins/VshlApi.cpp new file mode 100644 index 0000000..f2c7b7c --- /dev/null +++ b/src/plugins/VshlApi.cpp @@ -0,0 +1,607 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "VshlApi.h" + +#include <list> + +#include "afb/AFBApiImpl.h" +#include "afb/AFBRequestImpl.h" +#include "capabilities/CapabilitiesFactory.h" +#include "capabilities/CapabilityMessagingService.h" +#include "core/VRRequestProcessor.h" +#include "utilities/events/EventRouter.h" +#include "utilities/logging/Logger.h" +#include "voiceagents/VoiceAgentEventNames.h" +#include "voiceagents/VoiceAgentsDataManager.h" + +#include "json.hpp" + +using namespace std; + +CTLP_CAPI_REGISTER("vshl-api"); + +static std::string TAG = "vshl::plugins::VshlAPI"; + +static std::string VA_JSON_ATTR_DEFAULT = "default"; +static std::string VA_JSON_ATTR_AGENTS = "agents"; +static std::string VA_JSON_ATTR_ID = "id"; +static std::string VA_JSON_ATTR_NAME = "name"; +static std::string VA_JSON_ATTR_API = "api"; +static std::string VA_JSON_ATTR_ACTIVE = "active"; +static std::string VA_JSON_ATTR_WWS = "wakewords"; +static std::string VA_JSON_ATTR_ACTIVE_WW = "activewakeword"; +static std::string VA_JSON_ATTR_DESCRIPTION = "description"; +static std::string VA_JSON_ATTR_VENDOR = "vendor"; + +static std::string STARTLISTENING_JSON_ATTR_REQUEST = "request_id"; + +static std::string EVENTS_JSON_ATTR_VA_ID = "va_id"; +static std::string EVENTS_JSON_ATTR_EVENTS = "events"; + +static std::string CAPABILITIES_JSON_ATTR_ACTION = "action"; +static std::string CAPABILITIES_JSON_ATTR_ACTIONS = "actions"; +static std::string CAPABILITIES_JSON_ATTR_PAYLOAD = "payload"; + +static std::shared_ptr<vshl::utilities::logging::Logger> sLogger; +static std::shared_ptr<vshl::common::interfaces::IAFBApi> sAfbApi; +static std::unique_ptr<vshl::capabilities::CapabilitiesFactory> sCapabilitiesFactory; +static std::unique_ptr<vshl::capabilities::CapabilityMessagingService> sCapabilityMessagingService; +static std::unique_ptr<vshl::core::VRRequestProcessor> sVRRequestProcessor; +static std::unique_ptr<vshl::voiceagents::VoiceAgentsDataManager> sVoiceAgentsDataManager; +static std::unique_ptr<vshl::utilities::events::EventRouter> sEventRouter; + +using json = nlohmann::json; +using Level = vshl::utilities::logging::Logger::Level; + +CTLP_ONLOAD(plugin, ret) { + if (plugin->api == nullptr) { + return -1; + } + + // Logger + sLogger = vshl::utilities::logging::Logger::create(plugin->api); + // sLogger->log(Level::INFO, TAG, "Vshl plugin loaded & initialized."); + + // AFB Wrapper + sAfbApi = vshl::afb::AFBApiImpl::create(plugin->api); + + // VRRequestProcessor + auto vrRequestProcessorDelegate = vshl::core::VRRequestProcessorDelegate::create(sLogger, sAfbApi); + sVRRequestProcessor = vshl::core::VRRequestProcessor::create(sLogger, vrRequestProcessorDelegate); + if (!sVRRequestProcessor) { + sLogger->log(Level::ERROR, TAG, "Failed to create VRRequestProcessor"); + return -1; + } + + // VoiceAgentDataManager + sVoiceAgentsDataManager = vshl::voiceagents::VoiceAgentsDataManager::create(sLogger, sAfbApi); + if (!sVoiceAgentsDataManager) { + sLogger->log(Level::ERROR, TAG, "Failed to create VoiceAgentsDataManager"); + return -1; + } + sVoiceAgentsDataManager->addVoiceAgentsChangeObserver(sVRRequestProcessor->getVoiceAgentsChangeObserver()); + + // EventRouter + sEventRouter = vshl::utilities::events::EventRouter::create(sLogger); + if (!sEventRouter) { + sLogger->log(Level::ERROR, TAG, "Failed to create EventRouter"); + return -1; + } + sEventRouter->addEventFilter(sVoiceAgentsDataManager->getEventFilter()); + + sCapabilitiesFactory = vshl::capabilities::CapabilitiesFactory::create(); + if (!sCapabilitiesFactory) { + sLogger->log(Level::ERROR, TAG, "Failed to create CapabilitiesFactory"); + return -1; + } + + sCapabilityMessagingService = vshl::capabilities::CapabilityMessagingService::create(sLogger, sAfbApi); + if (!sCapabilityMessagingService) { + sLogger->log(Level::ERROR, TAG, "Failed to create CapabilityMessagingService"); + return -1; + } + + return 0; +} + +CTLP_CAPI(onAuthStateEvent, source, argsJ, eventJ) { + if (sEventRouter == nullptr) { + return -1; + } + + string eventName = vshl::voiceagents::VSHL_EVENT_AUTH_STATE_EVENT; + json eventJson = json::parse(json_object_to_json_string(eventJ)); + if (eventJson.find(EVENTS_JSON_ATTR_VA_ID) == eventJson.end()) { + sLogger->log(Level::ERROR, TAG, "onAuthStateEvent: No voiceagent id found."); + return -1; + } + std::string voiceAgentId(eventJson[EVENTS_JSON_ATTR_VA_ID].get<string>()); + + if (!sEventRouter->handleIncomingEvent(eventName, voiceAgentId, json_object_to_json_string(eventJ))) { + sLogger->log(Level::ERROR, TAG, "onAuthStateEvent: Failed to handle."); + return -1; + } + + return 0; +} + +CTLP_CAPI(onConnectionStateEvent, source, argsJ, eventJ) { + if (sEventRouter == nullptr) { + return -1; + } + + string eventName = vshl::voiceagents::VSHL_EVENT_CONNECTION_STATE_EVENT; + json eventJson = json::parse(json_object_to_json_string(eventJ)); + if (eventJson.find(EVENTS_JSON_ATTR_VA_ID) == eventJson.end()) { + sLogger->log(Level::ERROR, TAG, "onConnectionStateEvent: No voiceagent id found."); + return -1; + } + std::string voiceAgentId(eventJson[EVENTS_JSON_ATTR_VA_ID].get<string>()); + + if (!sEventRouter->handleIncomingEvent(eventName, voiceAgentId, json_object_to_json_string(eventJ))) { + sLogger->log(Level::ERROR, TAG, "onConnectionStateEvent: Failed to handle."); + return -1; + } + + return 0; +} + +CTLP_CAPI(onDialogStateEvent, source, argsJ, eventJ) { + if (sEventRouter == nullptr) { + return -1; + } + + string eventName = vshl::voiceagents::VSHL_EVENT_DIALOG_STATE_EVENT; + json eventJson = json::parse(json_object_to_json_string(eventJ)); + if (eventJson.find(EVENTS_JSON_ATTR_VA_ID) == eventJson.end()) { + sLogger->log(Level::ERROR, TAG, "onDialogStateEvent: No voiceagent id found."); + return -1; + } + std::string voiceAgentId(eventJson[EVENTS_JSON_ATTR_VA_ID].get<string>()); + + if (!sEventRouter->handleIncomingEvent(eventName, voiceAgentId, json_object_to_json_string(eventJ))) { + sLogger->log(Level::ERROR, TAG, "onDialogStateEvent: Failed to handle."); + return -1; + } + + return 0; +} + +CTLP_CAPI(loadVoiceAgentsConfig, source, argsJ, eventJ) { + if (sVoiceAgentsDataManager == nullptr) { + sLogger->log(Level::WARNING, TAG, "loadVoiceAgentsConfig: Voice service not initialized."); + return -1; + } + + if (argsJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "loadVoiceAgentsConfig: No arguments supplied."); + return -1; + } + + json agentsConfigJson = json::parse(json_object_to_json_string(argsJ)); + if (agentsConfigJson.find(VA_JSON_ATTR_AGENTS) == agentsConfigJson.end()) { + sLogger->log(Level::ERROR, TAG, "loadVoiceAgentsConfig: No agents object found in agents json"); + return -1; + } + + json agentsJson = agentsConfigJson[VA_JSON_ATTR_AGENTS]; + for (auto agentIt = agentsJson.begin(); agentIt != agentsJson.end(); ++agentIt) { + json agentJson = *agentIt; + + if (agentJson.find(VA_JSON_ATTR_ID) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_ACTIVE) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_NAME) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_API) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_WWS) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_ACTIVE_WW) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_DESCRIPTION) == agentJson.end() || + agentJson.find(VA_JSON_ATTR_VENDOR) == agentJson.end()) { + std::stringstream error; + error << "loadVoiceAgentsConfig: One or more missing params in agent " + "config " + << agentJson.dump(); + sLogger->log(Level::WARNING, TAG, error.str().c_str()); + continue; + } + + std::string id(agentJson[VA_JSON_ATTR_ID].get<string>()); + std::string name(agentJson[VA_JSON_ATTR_NAME].get<string>()); + std::string api(agentJson[VA_JSON_ATTR_API].get<string>()); + std::string description(agentJson[VA_JSON_ATTR_DESCRIPTION].get<string>()); + std::string vendor(agentJson[VA_JSON_ATTR_VENDOR].get<string>()); + std::string activeWakeword(agentJson[VA_JSON_ATTR_ACTIVE_WW].get<string>()); + bool isActive(agentJson[VA_JSON_ATTR_ACTIVE].get<bool>()); + + shared_ptr<unordered_set<string>> wakewords = std::make_shared<unordered_set<string>>(); + json wakewordsJson = agentJson[VA_JSON_ATTR_WWS]; + for (auto wwIt = wakewordsJson.begin(); wwIt != wakewordsJson.end(); ++wwIt) { + wakewords->insert(wwIt->get<string>()); + } + + sVoiceAgentsDataManager->addNewVoiceAgent( + id, name, description, api, vendor, activeWakeword, isActive, wakewords); + } + + // Set the default agent. + if (agentsConfigJson.find(VA_JSON_ATTR_DEFAULT) == agentsConfigJson.end()) { + sLogger->log(Level::ERROR, TAG, "loadVoiceAgentsConfig: No default agent found in agents json"); + return -1; + } + std::string defaultAgentId(agentsConfigJson[VA_JSON_ATTR_DEFAULT].get<string>()); + sVoiceAgentsDataManager->setDefaultVoiceAgent(defaultAgentId); + + return 0; +} + +CTLP_CAPI(startListening, source, argsJ, eventJ) { + if (sVRRequestProcessor == nullptr) { + return -1; + } + + int result = 0; + string requestId = sVRRequestProcessor->startListening(); + + if (!requestId.empty()) { + json responseJson; + responseJson[STARTLISTENING_JSON_ATTR_REQUEST] = requestId; + AFB_ReqSuccess(source->request, json_tokener_parse(responseJson.dump().c_str()), NULL); + } else { + AFB_ReqFail(source->request, NULL, "Failed to startListening..."); + } + + return 0; +} + +CTLP_CAPI(cancelListening, source, argsJ, eventJ) { + return 0; +} + +CTLP_CAPI(enumerateVoiceAgents, source, argsJ, eventJ) { + if (sVoiceAgentsDataManager == nullptr) { + return -1; + } + + auto agents = sVoiceAgentsDataManager->getAllVoiceAgents(); + std::string defaultAgentId(sVoiceAgentsDataManager->getDefaultVoiceAgent()); + + json responseJson; + json agentsJson = json::array(); + + for (auto agent : agents) { + json agentJson; + agentJson[VA_JSON_ATTR_ID] = agent->getId(); + agentJson[VA_JSON_ATTR_NAME] = agent->getName(); + agentJson[VA_JSON_ATTR_DESCRIPTION] = agent->getDescription(); + agentJson[VA_JSON_ATTR_API] = agent->getApi(); + agentJson[VA_JSON_ATTR_VENDOR] = agent->getVendor(); + agentJson[VA_JSON_ATTR_ACTIVE] = agent->isActive(); + agentJson[VA_JSON_ATTR_ACTIVE_WW] = agent->getActiveWakeword(); + + auto wakewords = agent->getWakeWords(); + if (wakewords != nullptr) { + json wakewordsJson; + for (auto wakeword : *wakewords) { + wakewordsJson.push_back(wakeword); + } + agentJson[VA_JSON_ATTR_WWS] = wakewordsJson; + } + + agentsJson.push_back(agentJson); + } + + responseJson[VA_JSON_ATTR_AGENTS] = agentsJson; + responseJson[VA_JSON_ATTR_DEFAULT] = defaultAgentId; + + AFB_ReqSuccess(source->request, json_tokener_parse(responseJson.dump().c_str()), NULL); + + return 0; +} + +CTLP_CAPI(subscribe, source, argsJ, eventJ) { + if (sVoiceAgentsDataManager == nullptr) { + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "subscribe: No arguments supplied."); + return -1; + } + + json subscribeJson = json::parse(json_object_to_json_string(eventJ)); + if (subscribeJson.find(EVENTS_JSON_ATTR_VA_ID) == subscribeJson.end()) { + sLogger->log(Level::ERROR, TAG, "subscribe: No voiceagent id found in subscribe json"); + return -1; + } + std::string voiceAgentId(subscribeJson[EVENTS_JSON_ATTR_VA_ID].get<string>()); + + if (subscribeJson.find(EVENTS_JSON_ATTR_EVENTS) == subscribeJson.end()) { + sLogger->log(Level::ERROR, TAG, "subscribe: No events array found in subscribe json"); + return -1; + } + list<string> events(subscribeJson[EVENTS_JSON_ATTR_EVENTS].get<list<string>>()); + + // Subscribe this client for the listed events. + auto request = vshl::afb::AFBRequestImpl::create(source->request); + for (auto event : events) { + if (!sVoiceAgentsDataManager->subscribeToVshlEventFromVoiceAgent(*request, event, voiceAgentId)) { + sLogger->log(Level::ERROR, TAG, "subscribe: Failed to subscribe to event: " + event); + return -1; + } + } + + AFB_ReqSuccess(source->request, json_object_new_string("Subscription to events successfully completed."), NULL); + + return 0; +} + +CTLP_CAPI(setDefaultVoiceAgent, source, argsJ, eventJ) { + if (sVoiceAgentsDataManager == nullptr) { + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "setDefaultVoiceAgent: No arguments supplied."); + return -1; + } + + json jsonRequest = json::parse(json_object_to_json_string(eventJ)); + if (jsonRequest.find(VA_JSON_ATTR_ID) == jsonRequest.end()) { + sLogger->log(Level::ERROR, TAG, "setDefaultVoiceAgent: voice agent id not found in request json"); + return -1; + } + + std::string voiceAgentId(jsonRequest[VA_JSON_ATTR_ID].get<string>()); + if (!sVoiceAgentsDataManager->setDefaultVoiceAgent(voiceAgentId)) { + sLogger->log(Level::ERROR, TAG, "setDefaultVoiceAgent: Failed to set default agent"); + return -1; + } + + AFB_ReqSuccess(source->request, NULL, NULL); + return 0; +} + +CTLP_CAPI(guiMetadataSubscribe, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> guMetadataCapability = sCapabilitiesFactory->getGuiMetadata(); + if (!guMetadataCapability) { + sLogger->log( + Level::WARNING, + TAG, + "guimetadataSubscribe: Failed to " + "fetch guimetadata capability " + "object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "guimetadataSubscribe: No arguments supplied."); + return -1; + } + + json subscribeJson = json::parse(json_object_to_json_string(eventJ)); + if (subscribeJson.find(CAPABILITIES_JSON_ATTR_ACTIONS) == subscribeJson.end()) { + sLogger->log(Level::ERROR, TAG, "guimetadataSubscribe: No events array found in subscribe json"); + return -1; + } + list<string> events(subscribeJson[CAPABILITIES_JSON_ATTR_ACTIONS].get<list<string>>()); + + // SUbscribe this client for the guimetadata events. + auto request = vshl::afb::AFBRequestImpl::create(source->request); + for (auto event : events) { + if (!sCapabilityMessagingService->subscribe(*request, guMetadataCapability, event)) { + sLogger->log(Level::ERROR, TAG, "guimetadataSubscribe: Failed to subscribe to event: " + event); + return -1; + } + } + + AFB_ReqSuccess( + source->request, json_object_new_string("Subscription to guimetadata events successfully completed."), NULL); + return 0; +} + +CTLP_CAPI(guiMetadataPublish, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> guMetadataCapability = sCapabilitiesFactory->getGuiMetadata(); + if (!guMetadataCapability) { + sLogger->log( + Level::WARNING, + TAG, + "guimetadataPublish: Failed to fetch " + "guimetadata capability object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "guimetadataPublish: No arguments supplied."); + return -1; + } + + json publishJson = json::parse(json_object_to_json_string(eventJ)); + if (publishJson.find(CAPABILITIES_JSON_ATTR_ACTION) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "guimetadataPublish: No action found in publish json"); + return -1; + } + std::string action(publishJson[CAPABILITIES_JSON_ATTR_ACTION].get<string>()); + + if (publishJson.find(CAPABILITIES_JSON_ATTR_PAYLOAD) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "guimetadataPublish: No payload found in publish json"); + return -1; + } + std::string payload(publishJson[CAPABILITIES_JSON_ATTR_PAYLOAD].get<string>()); + + if (!sCapabilityMessagingService->publish(guMetadataCapability, action, payload)) { + sLogger->log(Level::ERROR, TAG, "guimetadataPublish: Failed to publish message: " + action); + return -1; + } + + AFB_ReqSuccess(source->request, json_object_new_string("Successfully published guimetadata messages."), NULL); + return 0; +} + +CTLP_CAPI(phonecontrolSubscribe, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> phoneControlCapability = sCapabilitiesFactory->getPhoneControl(); + if (!phoneControlCapability) { + sLogger->log(Level::WARNING, TAG, "phoneControlSubscribe: Failed to fetch phone control capability object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "phoneControlSubscribe: No arguments supplied."); + return -1; + } + + json subscribeJson = json::parse(json_object_to_json_string(eventJ)); + if (subscribeJson.find(CAPABILITIES_JSON_ATTR_ACTIONS) == subscribeJson.end()) { + sLogger->log(Level::ERROR, TAG, "phoneControlSubscribe: No events array found in subscribe json"); + return -1; + } + list<string> events(subscribeJson[CAPABILITIES_JSON_ATTR_ACTIONS].get<list<string>>()); + + // SUbscribe this client for the phone call control events. + auto request = vshl::afb::AFBRequestImpl::create(source->request); + for (auto event : events) { + if (!sCapabilityMessagingService->subscribe(*request, phoneControlCapability, event)) { + sLogger->log(Level::ERROR, TAG, "phoneControlSubscribe: Failed to subscribe to event: " + event); + return -1; + } + } + + AFB_ReqSuccess( + source->request, json_object_new_string("Subscription to phone control events successfully completed."), NULL); + return 0; +} + +CTLP_CAPI(phonecontrolPublish, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> phoneControlCapability = sCapabilitiesFactory->getPhoneControl(); + if (!phoneControlCapability) { + sLogger->log(Level::WARNING, TAG, "phoneControlPublish: Failed to fetch navigation capability object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "phoneControlPublish: No arguments supplied."); + return -1; + } + + json publishJson = json::parse(json_object_to_json_string(eventJ)); + if (publishJson.find(CAPABILITIES_JSON_ATTR_ACTION) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "phoneControlPublish: No action found in publish json"); + return -1; + } + std::string action(publishJson[CAPABILITIES_JSON_ATTR_ACTION].get<string>()); + + if (publishJson.find(CAPABILITIES_JSON_ATTR_PAYLOAD) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "phoneControlPublish: No payload found in publish json"); + return -1; + } + std::string payload(publishJson[CAPABILITIES_JSON_ATTR_PAYLOAD].get<string>()); + + if (!sCapabilityMessagingService->publish(phoneControlCapability, action, payload)) { + sLogger->log(Level::ERROR, TAG, "phoneControlPublish: Failed to publish message: " + action); + return -1; + } + + AFB_ReqSuccess(source->request, json_object_new_string("Successfully published phone control messages."), NULL); + return 0; +} + +CTLP_CAPI(navigationSubscribe, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> navigationCapability = sCapabilitiesFactory->getNavigation(); + if (!navigationCapability) { + sLogger->log(Level::WARNING, TAG, "navigationSubscribe: Failed to fetch navigation capability object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "navigationSubscribe: No arguments supplied."); + return -1; + } + + json subscribeJson = json::parse(json_object_to_json_string(eventJ)); + if (subscribeJson.find(CAPABILITIES_JSON_ATTR_ACTIONS) == subscribeJson.end()) { + sLogger->log(Level::ERROR, TAG, "navigationSubscribe: No events array found in subscribe json"); + return -1; + } + list<string> events(subscribeJson[CAPABILITIES_JSON_ATTR_ACTIONS].get<list<string>>()); + + // SUbscribe this client for the navigation events. + auto request = vshl::afb::AFBRequestImpl::create(source->request); + for (auto event : events) { + if (!sCapabilityMessagingService->subscribe(*request, navigationCapability, event)) { + sLogger->log(Level::ERROR, TAG, "navigationSubscribe: Failed to subscribe to event: " + event); + return -1; + } + } + + AFB_ReqSuccess( + source->request, json_object_new_string("Subscription to navigation events successfully completed."), NULL); + return 0; +} + +CTLP_CAPI(navigationPublish, source, argsJ, eventJ) { + if (sCapabilitiesFactory == nullptr || sCapabilityMessagingService == nullptr) { + return -1; + } + + shared_ptr<vshl::common::interfaces::ICapability> navigationCapability = sCapabilitiesFactory->getNavigation(); + if (!navigationCapability) { + sLogger->log(Level::WARNING, TAG, "navigationPublish: Failed to fetch navigation capability object."); + return -1; + } + + if (eventJ == nullptr) { + sLogger->log(Level::WARNING, TAG, "navigationPublish: No arguments supplied."); + return -1; + } + + json publishJson = json::parse(json_object_to_json_string(eventJ)); + if (publishJson.find(CAPABILITIES_JSON_ATTR_ACTION) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "navigationPublish: No action found in publish json"); + return -1; + } + std::string action(publishJson[CAPABILITIES_JSON_ATTR_ACTION].get<string>()); + + if (publishJson.find(CAPABILITIES_JSON_ATTR_PAYLOAD) == publishJson.end()) { + sLogger->log(Level::ERROR, TAG, "navigationPublish: No payload found in publish json"); + return -1; + } + std::string payload(publishJson[CAPABILITIES_JSON_ATTR_PAYLOAD].get<string>()); + + if (!sCapabilityMessagingService->publish(navigationCapability, action, payload)) { + sLogger->log(Level::ERROR, TAG, "navigationPublish: Failed to publish message: " + action); + return -1; + } + + AFB_ReqSuccess(source->request, json_object_new_string("Successfully published navigation messages."), NULL); + return 0; +} diff --git a/src/plugins/VshlApi.h b/src/plugins/VshlApi.h new file mode 100644 index 0000000..f228943 --- /dev/null +++ b/src/plugins/VshlApi.h @@ -0,0 +1,46 @@ +/* + * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_API_INCLUDE +#define VSHL_API_INCLUDE + +#include "ctl-plugin.h" + +#ifdef __cplusplus +extern "C" { +#endif + +CTLP_ONLOAD(plugin, ret); +CTLP_INIT(plugin, ret); +int onAuthStateEvent(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int onConnectionStateEvent(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int onDialogStateEvent(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int loadVoiceAgentsConfig(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int startListening(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int cancelListening(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int enumerateVoiceAgents(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int subscribe(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int setDefaultVoiceAgent(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int guiMetadataSubscribe(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int guiMetadataPublish(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int phonecontrolSubscribe(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int phonecontrolPublish(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int navigationSubscribe(CtlSourceT* source, json_object* argsJ, json_object* queryJ); +int navigationPublish(CtlSourceT* source, json_object* argsJ, json_object* queryJ); + +#ifdef __cplusplus +} +#endif + +#endif // VSHL_API_INCLUDE diff --git a/src/plugins/afb/AFBApiImpl.cpp b/src/plugins/afb/AFBApiImpl.cpp new file mode 100644 index 0000000..88d1e7e --- /dev/null +++ b/src/plugins/afb/AFBApiImpl.cpp @@ -0,0 +1,87 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "afb/AFBApiImpl.h" + +#include "afb/include/AFBEventImpl.h" +#include "utilities/logging/Logger.h" + +extern "C" { +#define AFB_BINDING_VERSION 3 +#define FREEIF(x) \ + if (!x) { \ + free(x); \ + } +#define BREAKIF(x) \ + if (x) { \ + result = false; \ + break; \ + } + +#include "afb-definitions.h" +} + +static std::string TAG = "vshl::afb::AFBApiImpl"; + +/** + * Specifies the severity level of a log message + */ +using Level = vshl::common::interfaces::ILogger::Level; +using namespace vshl::common::interfaces; +using namespace vshl::utilities::logging; + +namespace vshl { +namespace afb { + +std::unique_ptr<AFBApiImpl> AFBApiImpl::create(AFB_ApiT api) { + return std::unique_ptr<AFBApiImpl>(new AFBApiImpl(api)); +} + +AFBApiImpl::AFBApiImpl(AFB_ApiT api) : mApi(api), mLogger(Logger::create(api)) { +} + +AFBApiImpl::~AFBApiImpl() { +} + +std::shared_ptr<IAFBApi::IAFBEvent> AFBApiImpl::createEvent(const std::string& eventName) { + return AFBEventImpl::create(mLogger, mApi, eventName); +} + +int AFBApiImpl::callSync( + const std::string& api, + const std::string& verb, + struct json_object* request, + struct json_object** result, + std::string& error, + std::string& info) { + char* errorStr = NULL; + char* infoStr = NULL; + int rc = AFB_ApiSync(mApi, api.c_str(), verb.c_str(), request, result, &errorStr, &infoStr); + + if (errorStr) { + error = errorStr; + free(errorStr); + } + + if (infoStr) { + info = infoStr; + free(infoStr); + } + + return rc; +} + +} // namespace afb +} // namespace vshl diff --git a/src/plugins/afb/AFBApiImpl.h b/src/plugins/afb/AFBApiImpl.h new file mode 100644 index 0000000..74aa7ef --- /dev/null +++ b/src/plugins/afb/AFBApiImpl.h @@ -0,0 +1,61 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_AFB_AFBAPIIMPL_H_ +#define VSHL_AFB_AFBAPIIMPL_H_ + +#include <memory> + +extern "C" { +#include "ctl-plugin.h" +} + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace afb { + +class AFBApiImpl : public vshl::common::interfaces::IAFBApi { +public: + static std::unique_ptr<AFBApiImpl> create(AFB_ApiT api); + + ~AFBApiImpl(); + + std::shared_ptr<IAFBEvent> createEvent(const std::string& eventName) override; + + int callSync( + const std::string& api, + const std::string& verb, + struct json_object* request, + struct json_object** result, + std::string& error, + std::string& info) override; + +private: + AFBApiImpl(AFB_ApiT api); + + // AFB API Binding + AFB_ApiT mApi; + + // Logger + std::shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace afb +} // namespace vshl + +#endif // VSHL_AFB_AFBAPIIMPL_H_ diff --git a/src/plugins/afb/AFBRequestImpl.cpp b/src/plugins/afb/AFBRequestImpl.cpp new file mode 100644 index 0000000..8ec5691 --- /dev/null +++ b/src/plugins/afb/AFBRequestImpl.cpp @@ -0,0 +1,37 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "afb/AFBRequestImpl.h" + +extern "C" { +#include "afb-definitions.h" +} + +namespace vshl { +namespace afb { + +std::unique_ptr<AFBRequestImpl> AFBRequestImpl::create(AFB_ReqT afbRequest) { + return std::unique_ptr<AFBRequestImpl>(new AFBRequestImpl(afbRequest)); +} + +AFBRequestImpl::AFBRequestImpl(AFB_ReqT afbRequest) : mAfbRequest(afbRequest) { +} + +void* AFBRequestImpl::getNativeRequest() { + return mAfbRequest; +} + +} // namespace afb +} // namespace vshl diff --git a/src/plugins/afb/AFBRequestImpl.h b/src/plugins/afb/AFBRequestImpl.h new file mode 100644 index 0000000..2e6f3ab --- /dev/null +++ b/src/plugins/afb/AFBRequestImpl.h @@ -0,0 +1,49 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_AFB_AFBREQUESTIMPL_H_ +#define VSHL_AFB_AFBREQUESTIMPL_H_ + +#include <memory> + +extern "C" { +#include "ctl-plugin.h" +} + +#include "interfaces/afb/IAFBApi.h" + +namespace vshl { +namespace afb { + +/** + * AFB Request impl + */ +class AFBRequestImpl : public vshl::common::interfaces::IAFBRequest { +public: + static std::unique_ptr<AFBRequestImpl> create(AFB_ReqT afbRequest); + + // {@c IAFBRequest Implementation + void *getNativeRequest() override; + // @c IAFBRequest Implementation } + +private: + AFBRequestImpl(AFB_ReqT afbRequest); + + AFB_ReqT mAfbRequest; +}; + +} // namespace afb +} // namespace vshl + +#endif // VSHL_AFB_AFBREQUESTIMPL_H_ diff --git a/src/plugins/afb/include/AFBEventImpl.h b/src/plugins/afb/include/AFBEventImpl.h new file mode 100644 index 0000000..45f85f9 --- /dev/null +++ b/src/plugins/afb/include/AFBEventImpl.h @@ -0,0 +1,77 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_AFB_EVENT_H_ +#define VSHL_AFB_EVENT_H_ + +#include <memory> +#include <string> + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/logging/ILogger.h" + +extern "C" { +#include "ctl-plugin.h" +#include <json-c/json.h> +} + +using namespace std; + +namespace vshl { +namespace afb { +/* + * This class encapsulates AFB Event. + */ +class AFBEventImpl : public vshl::common::interfaces::IAFBApi::IAFBEvent { +public: + static unique_ptr<AFBEventImpl> + create(shared_ptr<vshl::common::interfaces::ILogger> logger, AFB_ApiT api, + const string &eventName); + + // Destructor + ~AFBEventImpl(); + + /// { @c IAFBEvent implementation + string getName() const override; + bool isValid() override; + int publishEvent(struct json_object *payload) override; + bool subscribe(vshl::common::interfaces::IAFBRequest &request) override; + bool unsubscribe(vshl::common::interfaces::IAFBRequest &request) override; + /// @c IAFBEvent implementation } + +private: + AFBEventImpl(shared_ptr<vshl::common::interfaces::ILogger> logger, + AFB_ApiT api, const string &eventName); + + // Make the event. This is a lazy make that happens + // usually during the subscribe stage. + void makeEventIfNeccessary(); + + // Binding API reference + AFB_ApiT mAfbApi; + + // AFB Event + afb_event_t mAfbEvent; + + // Event Name + string mEventName; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace afb +} // namespace vshl + +#endif // VSHL_AFB_EVENT_H_ diff --git a/src/plugins/afb/src/AFBEventImpl.cpp b/src/plugins/afb/src/AFBEventImpl.cpp new file mode 100644 index 0000000..e3c902d --- /dev/null +++ b/src/plugins/afb/src/AFBEventImpl.cpp @@ -0,0 +1,89 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "afb/include/AFBEventImpl.h" + +static string TAG = "vshl::afb::Event"; + +using Level = vshl::common::interfaces::ILogger::Level; +using namespace vshl::common::interfaces; + +namespace vshl { +namespace afb { + +unique_ptr<AFBEventImpl> AFBEventImpl::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + AFB_ApiT api, + const string& eventName) { + return unique_ptr<AFBEventImpl>(new AFBEventImpl(logger, api, eventName)); +} + +AFBEventImpl::AFBEventImpl( + shared_ptr<vshl::common::interfaces::ILogger> logger, + AFB_ApiT api, + const string& eventName) : + mLogger(logger), + mAfbApi(api), + mEventName(eventName), + mAfbEvent(nullptr) { +} + +AFBEventImpl::~AFBEventImpl() { +} + +string AFBEventImpl::getName() const { + return mEventName; +} + +bool AFBEventImpl::isValid() { + makeEventIfNeccessary(); + return afb_event_is_valid(mAfbEvent) == 1 ? true : false; +} + +bool AFBEventImpl::subscribe(IAFBRequest& requestInterface) { + makeEventIfNeccessary(); + auto request = static_cast<AFB_ReqT>(requestInterface.getNativeRequest()); + if (isValid() && afb_req_subscribe(request, mAfbEvent) == 0) { + return true; + } + + return false; +} + +bool AFBEventImpl::unsubscribe(IAFBRequest& requestInterface) { + makeEventIfNeccessary(); + auto request = static_cast<AFB_ReqT>(requestInterface.getNativeRequest()); + if (isValid() && afb_req_unsubscribe(request, mAfbEvent) == 0) { + return true; + } + + return false; +} + +int AFBEventImpl::publishEvent(struct json_object* payload) { + makeEventIfNeccessary(); + return afb_event_push(mAfbEvent, payload); +} + +void AFBEventImpl::makeEventIfNeccessary() { + if (mAfbEvent) { + return; + } + + mLogger->log(Level::NOTICE, TAG, "Creating VSHL event: " + mEventName); + mAfbEvent = afb_api_make_event(mAfbApi, mEventName.c_str()); +} + +} // namespace afb +} // namespace vshl diff --git a/src/plugins/agreement.sh b/src/plugins/agreement.sh new file mode 100755 index 0000000..2a8eb71 --- /dev/null +++ b/src/plugins/agreement.sh @@ -0,0 +1,43 @@ +#******************************************************************************** +# Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. +# A copy of the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file 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. +#********************************************************************************* + +agreement_check() { + cat << EOF + +******************************************************************************* +The scripts provided herein will retrieve several third-party libraries, +environments, and/or other software packages at build-time +("External Dependencies") from third-party sources. These are terms and +conditions that you need to agree to abide by if you choose to build the +External Dependencies. Licenses for the External Dependencies may be found at +README.md. If you do not agree with every term and condition +associated with the External Dependencies, enter “QUIT” in the command line +when prompted by the script. +******************************************************************************* + +EOF + + answer="dummy" + while [ ! -z $answer ]; do + read -p "Type \"QUIT\" to exit the script now, press ENTER to continue: " -r answer + if [ "$answer" = "QUIT" ]; then + exit 1 + fi + echo "" + done +} + +agreement_check +exit 0
\ No newline at end of file diff --git a/src/plugins/capabilities/CapabilitiesFactory.cpp b/src/plugins/capabilities/CapabilitiesFactory.cpp new file mode 100644 index 0000000..2f92519 --- /dev/null +++ b/src/plugins/capabilities/CapabilitiesFactory.cpp @@ -0,0 +1,57 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/CapabilitiesFactory.h" + +#include "capabilities/communication/include/PhoneControlCapability.h" +#include "capabilities/guimetadata/include/GuiMetadataCapability.h" +#include "capabilities/navigation/include/NavigationCapability.h" + +static string TAG = "vshl::core::CapabilitiesFactory"; + +using Level = vshl::utilities::logging::Logger::Level; + +namespace vshl { +namespace capabilities { + +// Create CapabilitiesFactory +std::unique_ptr<CapabilitiesFactory> CapabilitiesFactory::create() { + auto capabilitiesFactory = std::unique_ptr<CapabilitiesFactory>(new CapabilitiesFactory()); + return capabilitiesFactory; +} + +std::shared_ptr<common::interfaces::ICapability> CapabilitiesFactory::getGuiMetadata() { + if (!mGuiMetadata) { + mGuiMetadata = vshl::capabilities::guimetadata::GuiMetadata::create(); + } + return mGuiMetadata; +} + +std::shared_ptr<common::interfaces::ICapability> CapabilitiesFactory::getPhoneControl() { + if (!mPhoneControl) { + mPhoneControl = vshl::capabilities::phonecontrol::PhoneControl::create(); + } + return mPhoneControl; +} + +std::shared_ptr<common::interfaces::ICapability> CapabilitiesFactory::getNavigation() { + if (!mNavigation) { + mNavigation = vshl::capabilities::navigation::Navigation::create(); + } + return mNavigation; +} + +} // namespace capabilities +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/capabilities/CapabilitiesFactory.h b/src/plugins/capabilities/CapabilitiesFactory.h new file mode 100644 index 0000000..b73909b --- /dev/null +++ b/src/plugins/capabilities/CapabilitiesFactory.h @@ -0,0 +1,63 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_CAPABILITIESFACTORY_H_ +#define VSHL_CAPABILITIES_CAPABILITIESFACTORY_H_ + +#include <memory> + +#include "interfaces/capabilities/ICapability.h" +#include "utilities/logging/Logger.h" + +using namespace std; + +namespace vshl { +namespace capabilities { +/* + * Factory for creating different capability objects. + */ +class CapabilitiesFactory { +public: + // Create CapabilitiesFactory + static std::unique_ptr<CapabilitiesFactory> create(); + + // GUI Metadata capability + std::shared_ptr<common::interfaces::ICapability> getGuiMetadata(); + + // Phone call control capability + std::shared_ptr<common::interfaces::ICapability> getPhoneControl(); + + // Navigation capability + std::shared_ptr<common::interfaces::ICapability> getNavigation(); + + // Destructor + ~CapabilitiesFactory() = default; + +private: + // Constructor + CapabilitiesFactory() = default; + + // Capabilities + shared_ptr<vshl::common::interfaces::ICapability> mGuiMetadata; + shared_ptr<vshl::common::interfaces::ICapability> mPhoneControl; + shared_ptr<vshl::common::interfaces::ICapability> mNavigation; + + // Logger + unique_ptr<vshl::utilities::logging::Logger> mLogger; +}; + +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_CAPABILITIESFACTORY_H_ diff --git a/src/plugins/capabilities/CapabilityMessagingService.cpp b/src/plugins/capabilities/CapabilityMessagingService.cpp new file mode 100644 index 0000000..91b5f2b --- /dev/null +++ b/src/plugins/capabilities/CapabilityMessagingService.cpp @@ -0,0 +1,117 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/CapabilityMessagingService.h" + +#include "capabilities/core/include/PublisherForwarder.h" +#include "capabilities/core/include/SubscriberForwarder.h" + +static string TAG = "vshl::capabilities::CapabilityMessagingService"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace capabilities { + +// Create a CapabilityMessagingService. +unique_ptr<CapabilityMessagingService> CapabilityMessagingService::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) { + if (logger == nullptr) { + return nullptr; + } + + if (afbApi == nullptr) { + logger->log(Level::ERROR, TAG, "Failed to create CapabilityMessagingService: AFB API null"); + return nullptr; + } + + auto capabilityMessageService = + std::unique_ptr<CapabilityMessagingService>(new CapabilityMessagingService(logger, afbApi)); + return capabilityMessageService; +} + +CapabilityMessagingService::~CapabilityMessagingService() { + mMessageChannelsMap.clear(); +} + +CapabilityMessagingService::CapabilityMessagingService( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) : + mAfbApi(afbApi), + mLogger(logger) { +} + +// Subscribe to capability specific messages. +bool CapabilityMessagingService::subscribe( + vshl::common::interfaces::IAFBRequest& request, + shared_ptr<common::interfaces::ICapability> capability, + const string action) { + auto capabilityName = capability->getName(); + + if (capabilityName.empty()) { + mLogger->log(Level::ERROR, TAG, "Failed to subscribe to message. Invalid input."); + return false; + } + + auto messageChannel = getMessageChannel(capability); + return messageChannel->subscribe(request, action); +} + +// Publish capability messages. +bool CapabilityMessagingService::publish( + shared_ptr<common::interfaces::ICapability> capability, + const string action, + const string payload) { + auto capabilityName = capability->getName(); + + if (capabilityName.empty()) { + mLogger->log(Level::ERROR, TAG, "Failed to publish message. Invalid input."); + return false; + } + + auto messageChannelIt = mMessageChannelsMap.find(capabilityName); + if (messageChannelIt == mMessageChannelsMap.end()) { + mLogger->log( + Level::ERROR, + TAG, + "Failed to publish message. Message channel doesn't exist for capability " + capabilityName); + return false; + } + + return messageChannelIt->second->publish(action, payload); +} + +shared_ptr<vshl::capabilities::core::MessageChannel> CapabilityMessagingService::getMessageChannel( + shared_ptr<common::interfaces::ICapability> capability) { + auto capabilityName = capability->getName(); + + if (capabilityName.empty()) { + mLogger->log(Level::ERROR, TAG, "Failed to create message channel. Invalid input."); + return nullptr; + } + + auto messageChannelIt = mMessageChannelsMap.find(capabilityName); + if (messageChannelIt == mMessageChannelsMap.end()) { + mLogger->log(Level::INFO, TAG, "Creating new message channel for capability: " + capabilityName); + auto messageChannel = vshl::capabilities::core::MessageChannel::create(mLogger, mAfbApi, capability); + mMessageChannelsMap.insert(make_pair(capabilityName, messageChannel)); + return messageChannel; + } + + return messageChannelIt->second; +} + +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/CapabilityMessagingService.h b/src/plugins/capabilities/CapabilityMessagingService.h new file mode 100644 index 0000000..535e806 --- /dev/null +++ b/src/plugins/capabilities/CapabilityMessagingService.h @@ -0,0 +1,82 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_CAPABILITYMESSAGINGSERVICE_H_ +#define VSHL_CAPABILITIES_CAPABILITYMESSAGINGSERVICE_H_ + +#include <memory> +#include <string> +#include <unordered_map> + +#include "capabilities/core/include/MessageChannel.h" +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/capabilities/ICapability.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace capabilities { +/* + * This hosts service APIs that clients can use to subscribe and + * forward capability messages. Each capability has a name and + * direction (upstream/downstream). Upstream messages are from + * voiceagents to Apps and downstream messages are Apps to voiceagents. + * This class will use a factory to create publisher and subcribers for + * each capability and create assiociations between them. + */ +class CapabilityMessagingService { +public: + // Create a CapabilityMessagingService. + static std::unique_ptr<CapabilityMessagingService> + create(shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Subscribe to capability specific messages. + bool subscribe(vshl::common::interfaces::IAFBRequest &request, + shared_ptr<common::interfaces::ICapability> capability, + const string action); + + // Publish capability messages. + bool publish(shared_ptr<common::interfaces::ICapability> capability, + const string action, const string payload); + + // Destructor + ~CapabilityMessagingService(); + +private: + // Constructor + CapabilityMessagingService( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Binding API reference + shared_ptr<vshl::common::interfaces::IAFBApi> mAfbApi; + + // Create a message channel for the capability. + shared_ptr<vshl::capabilities::core::MessageChannel> + getMessageChannel(shared_ptr<common::interfaces::ICapability> capability); + + // Map of capabilities to message channels. + unordered_map<string, shared_ptr<vshl::capabilities::core::MessageChannel>> + mMessageChannelsMap; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_CAPABILITYMESSAGINGSERVICE_H_ diff --git a/src/plugins/capabilities/communication/include/PhoneControlCapability.h b/src/plugins/capabilities/communication/include/PhoneControlCapability.h new file mode 100644 index 0000000..55ada8d --- /dev/null +++ b/src/plugins/capabilities/communication/include/PhoneControlCapability.h @@ -0,0 +1,52 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_CAPABILITIES_PHONECONTROL_CAPABILITY_H_ +#define VSHL_CAPABILITIES_PHONECONTROL_CAPABILITY_H_ + +#include <memory> + +#include "interfaces/capabilities/ICapability.h" + +namespace vshl { +namespace capabilities { +namespace phonecontrol { + +/* + * PhoneControl capability. Calls are initiated in the endpoint. + */ +class PhoneControl : public common::interfaces::ICapability { +public: + // Create a PhoneControl. + static std::shared_ptr<PhoneControl> create(); + + ~PhoneControl() = default; + +protected: + string getName() const override; + + list<string> getUpstreamMessages() const override; + + list<string> getDownstreamMessages() const override; + +private: + PhoneControl() = default; +}; + +} // namespace phonecontrol +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_PHONECONTROL_CAPABILITY_H_ diff --git a/src/plugins/capabilities/communication/include/PhoneControlMessages.h b/src/plugins/capabilities/communication/include/PhoneControlMessages.h new file mode 100644 index 0000000..4c68455 --- /dev/null +++ b/src/plugins/capabilities/communication/include/PhoneControlMessages.h @@ -0,0 +1,128 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_PHONECONTROL_MESSAGES_H_ +#define VSHL_CAPABILITIES_PHONECONTROL_MESSAGES_H_ + +#include <list> +#include <string> + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace phonecontrol { + +static string NAME = "phonecontrol"; + +// Supported actions from VA -> Apps +/* Dial message sent from VA to app handling the calling. + * + * Payload + * { + * "callId": "{{STRING}}", + * "callee": { + * "details": "{{STRING}}", + * "defaultAddress": { + * "protocol": "{{STRING}}", + * "format": "{{STRING}}", + * "value": "{{STRING}}" + * }, + * "alternativeAddresses": [{ + * "protocol": "{{STRING}}", + * "format": "{{STRING}}", + * "value": {{STRING}} + * }] + * } + * } + * } + * + * callId (required): A unique identifier for the call + * callee (required): The destination of the outgoing call + * callee.details (optional): Descriptive information about the callee + * callee.defaultAddress (required): The default address to use for calling the callee + * callee.alternativeAddresses (optional): An array of alternate addresses for the existing callee + * address.protocol (required): The protocol for this address of the callee (e.g. PSTN, SIP, H323, etc.) + * address.format (optional): The format for this address of the callee (e.g. E.164, E.163, E.123, DIN5008, etc.) + * address.value (required): The address of the callee. + * + */ +static string PHONECONTROL_DIAL = "dial"; + +// Supported actions from Apps -> VA +/* + * App notifies the voiceagents of a change in connection state of a calling device. + * + * Payload + * { + * "state" : "{{STRING}}" // CONNECTED or DISCONNECTED + * } + */ +static string PHONECONTROL_CONNECTIONSTATE_CHANGED = "connection_state_changed"; +/* + * App notifies the voiceagents that call is activated + * + * callId must match the one that is sent by VA with DIAL message above. + * + * Payload + * { + * "callId" : "{{STRING}}" + * } + */ +static string PHONECONTROL_CALL_ACTIVATED = "call_activated"; +/* + * App notifies the voiceagents of an error in initiating or maintaining a + * call on a calling device + * + * callId must match the one that is sent by VA with DIAL message above. + * error: below status codes. + * 4xx: Validation failure for the input from the DIAL message + * 500: Internal error on the platform unrelated to the cellular network + * 503: Error on the platform related to the cellular network + * + * Payload + * { + * "callId" : "{{STRING}}" + * "error" : "{{STRING}}" + * } + */ +static string PHONECONTROL_CALL_FAILED = "call_failed"; +/* + * App notifies the voiceagents that call is terminated + * + * callId must match the one that is sent by VA with DIAL message above. + * + * Payload + * { + * "callId" : "{{STRING}}" + * } + */ +static string PHONECONTROL_CALL_TERMINATED = "call_terminated"; + +// List of actions that are delivered from VA -> Apps +static list<string> PHONECONTROL_UPSTREAM_ACTIONS = { + PHONECONTROL_DIAL, +}; + +// List of actions that are delivered from Apps -> VA +static list<string> PHONECONTROL_DOWNSTREAM_ACTIONS = {PHONECONTROL_CONNECTIONSTATE_CHANGED, + PHONECONTROL_CALL_ACTIVATED, + PHONECONTROL_CALL_FAILED, + PHONECONTROL_CALL_TERMINATED}; + +} // namespace phonecontrol +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_PHONECONTROL_MESSAGES_H_ diff --git a/src/plugins/capabilities/communication/src/PhoneControlCapability.cpp b/src/plugins/capabilities/communication/src/PhoneControlCapability.cpp new file mode 100644 index 0000000..6a74d5a --- /dev/null +++ b/src/plugins/capabilities/communication/src/PhoneControlCapability.cpp @@ -0,0 +1,42 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/communication/include/PhoneControlCapability.h" +#include "capabilities/communication/include/PhoneControlMessages.h" + +namespace vshl { +namespace capabilities { +namespace phonecontrol { + +// Create a phonecontrol. +shared_ptr<PhoneControl> PhoneControl::create() { + auto phonecontrol = std::shared_ptr<PhoneControl>(new PhoneControl()); + return phonecontrol; +} + +string PhoneControl::getName() const { + return NAME; +} + +list<string> PhoneControl::getUpstreamMessages() const { + return PHONECONTROL_UPSTREAM_ACTIONS; +} + +list<string> PhoneControl::getDownstreamMessages() const { + return PHONECONTROL_DOWNSTREAM_ACTIONS; +} + +} // namespace phonecontrol +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/core/include/MessageChannel.h b/src/plugins/capabilities/core/include/MessageChannel.h new file mode 100644 index 0000000..504e241 --- /dev/null +++ b/src/plugins/capabilities/core/include/MessageChannel.h @@ -0,0 +1,68 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_CORE_MESSAGECHANNEL_H_ +#define VSHL_CAPABILITIES_CORE_MESSAGECHANNEL_H_ + +#include <memory> + +#include "capabilities/core/include/PublisherForwarder.h" +#include "capabilities/core/include/SubscriberForwarder.h" +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/capabilities/ICapability.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace core { +/* + * MessageChannel has one end as publisher forwarder and the other end + * as subscriber forwarder. + */ +class MessageChannel { +public: + // Create a MessageChannel. + static std::shared_ptr<MessageChannel> + create(shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Sends the message + bool publish(const string action, const string payload); + + // Subscribe + bool subscribe(vshl::common::interfaces::IAFBRequest &request, + const string action); + + // Destructor + virtual ~MessageChannel() = default; + +private: + // Constructor + MessageChannel(shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Forwarders + shared_ptr<PublisherForwarder> mPublisherForwarder; + shared_ptr<SubscriberForwarder> mSubscriberForwarder; +}; + +} // namespace core +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_CORE_MESSAGECHANNEL_H_ diff --git a/src/plugins/capabilities/core/include/PublisherForwarder.h b/src/plugins/capabilities/core/include/PublisherForwarder.h new file mode 100644 index 0000000..9cc89b5 --- /dev/null +++ b/src/plugins/capabilities/core/include/PublisherForwarder.h @@ -0,0 +1,73 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_CORE_PUBLISHERFORWARDER_H_ +#define VSHL_CAPABILITIES_CORE_PUBLISHERFORWARDER_H_ + +#include <memory> + +#include "capabilities/core/include/SubscriberForwarder.h" + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/capabilities/ICapability.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace core { +/* + * This class is responsible for forwarding the messages to be published + * to subscriber forwarder. Subscriber forwarder will deliver the messages + * as AFB Events to all the subscribed clients. + * There is one PublisherForwarder and one SubscriberForwarder per capability. + */ +class PublisherForwarder { +public: + // Create a PublisherForwarder. + static std::shared_ptr<PublisherForwarder> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Connect a subscriber forwarder to this publisher forwarder + void setSubscriberForwarder(shared_ptr<SubscriberForwarder> subscriberForwarder); + + // Forward message to the subscriber forwarder + bool forwardMessage(const string action, const string payload); + + // Destructor + ~PublisherForwarder(); + +private: + // Constructor + PublisherForwarder( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Subscriber forwarder connected to this publisher forwarder. + shared_ptr<SubscriberForwarder> mSubscriberForwarder; + + // Capability + shared_ptr<vshl::common::interfaces::ICapability> mCapability; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace core +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_CORE_PUBLISHERFORWARDER_H_ diff --git a/src/plugins/capabilities/core/include/SubscriberForwarder.h b/src/plugins/capabilities/core/include/SubscriberForwarder.h new file mode 100644 index 0000000..94c04bf --- /dev/null +++ b/src/plugins/capabilities/core/include/SubscriberForwarder.h @@ -0,0 +1,84 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_CORE_SUBSCRIBERFORWARDER_H_ +#define VSHL_CAPABILITIES_CORE_SUBSCRIBERFORWARDER_H_ + +#include <memory> +#include <string> +#include <unordered_map> + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/capabilities/ICapability.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace core { +/* + * This class is responsible for forwarding the messages publishing + * to the actual clients using AFB. + */ +class SubscriberForwarder { +public: + // Create a SubscriberForwarder. + static std::shared_ptr<SubscriberForwarder> + create(shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Publish a capability message to the actual client. + bool forwardMessage(const string action, const string payload); + + // Subscribe + bool subscribe(vshl::common::interfaces::IAFBRequest &request, + const string action); + + // Destructor + ~SubscriberForwarder(); + +private: + // Constructor + SubscriberForwarder( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability); + + // Creates both upstream and downstream events + void createEvents(); + + // Binding API reference + shared_ptr<vshl::common::interfaces::IAFBApi> mAfbApi; + + // Capability + shared_ptr<vshl::common::interfaces::ICapability> mCapability; + + // Maps of capability action events to its corresponding Event object. + // Event name maps to Action Name + unordered_map<string, shared_ptr<common::interfaces::IAFBApi::IAFBEvent>> + mUpstreamEventsMap; + unordered_map<string, shared_ptr<common::interfaces::IAFBApi::IAFBEvent>> + mDownstreamEventsMap; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace core +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_CORE_SUBSCRIBERFORWARDER_H_ diff --git a/src/plugins/capabilities/core/src/MessageChannel.cpp b/src/plugins/capabilities/core/src/MessageChannel.cpp new file mode 100644 index 0000000..eaa1349 --- /dev/null +++ b/src/plugins/capabilities/core/src/MessageChannel.cpp @@ -0,0 +1,51 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/core/include/MessageChannel.h" + +namespace vshl { +namespace capabilities { +namespace core { + +// Create a MessageChannel. +std::shared_ptr<MessageChannel> MessageChannel::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> api, + shared_ptr<vshl::common::interfaces::ICapability> capability) { + auto messageChannel = std::shared_ptr<MessageChannel>(new MessageChannel(logger, api, capability)); + return messageChannel; +} + +MessageChannel::MessageChannel( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> api, + shared_ptr<vshl::common::interfaces::ICapability> capability) { + // Subscriber forwarder + mSubscriberForwarder = SubscriberForwarder::create(logger, api, capability); + // Publisher forwarder + mPublisherForwarder = PublisherForwarder::create(logger, capability); + mPublisherForwarder->setSubscriberForwarder(mSubscriberForwarder); +} + +bool MessageChannel::publish(const string action, const string payload) { + return mPublisherForwarder->forwardMessage(action, payload); +} + +bool MessageChannel::subscribe(vshl::common::interfaces::IAFBRequest& request, const string action) { + return mSubscriberForwarder->subscribe(request, action); +} + +} // namespace core +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/core/src/PublisherForwarder.cpp b/src/plugins/capabilities/core/src/PublisherForwarder.cpp new file mode 100644 index 0000000..81de6a0 --- /dev/null +++ b/src/plugins/capabilities/core/src/PublisherForwarder.cpp @@ -0,0 +1,69 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/core/include/PublisherForwarder.h" + +static string TAG = "vshl::capabilities::PublisherForwarder"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace capabilities { +namespace core { + +// Create a PublisherForwarder. +std::shared_ptr<PublisherForwarder> PublisherForwarder::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::ICapability> capability) { + if (logger == nullptr) { + return nullptr; + } + + if (capability == nullptr) { + logger->log(Level::ERROR, TAG, "Failed to create PublisherForwarder: Capability null"); + return nullptr; + } + + auto publisherForwarder = std::shared_ptr<PublisherForwarder>(new PublisherForwarder(logger, capability)); + return publisherForwarder; +} + +// Constructor +PublisherForwarder::PublisherForwarder( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::ICapability> capability) { + mCapability = capability; + mLogger = logger; +} + +// Destructor +PublisherForwarder::~PublisherForwarder() { +} + +void PublisherForwarder::setSubscriberForwarder(shared_ptr<SubscriberForwarder> subscriberForwarder) { + mSubscriberForwarder = subscriberForwarder; +} + +bool PublisherForwarder::forwardMessage(const string action, const string payload) { + if (!mSubscriberForwarder) { + mLogger->log(Level::ERROR, TAG, "Failed to forward message for capability: " + mCapability->getName()); + return false; + } + + return mSubscriberForwarder->forwardMessage(action, payload); +} + +} // namespace core +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/core/src/SubscriberForwarder.cpp b/src/plugins/capabilities/core/src/SubscriberForwarder.cpp new file mode 100644 index 0000000..ea42305 --- /dev/null +++ b/src/plugins/capabilities/core/src/SubscriberForwarder.cpp @@ -0,0 +1,139 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/core/include/SubscriberForwarder.h" + +static string TAG = "vshl::capabilities::SubscriberForwarder"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace capabilities { +namespace core { + +// Create a SubscriberForwarder. +std::shared_ptr<SubscriberForwarder> SubscriberForwarder::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability) { + if (logger == nullptr) { + return nullptr; + } + + if (afbApi == nullptr) { + logger->log(Level::ERROR, TAG, "Failed to create SubscriberForwarder: AFB API null"); + return nullptr; + } + + if (capability == nullptr) { + logger->log(Level::ERROR, TAG, "Failed to create SubscriberForwarder: Capability null"); + return nullptr; + } + + auto subscriberForwarder = + std::shared_ptr<SubscriberForwarder>(new SubscriberForwarder(logger, afbApi, capability)); + return subscriberForwarder; +} + +SubscriberForwarder::SubscriberForwarder( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + shared_ptr<vshl::common::interfaces::ICapability> capability) : + mAfbApi(afbApi), + mLogger(logger), + mCapability(capability) { + createEvents(); +} + +SubscriberForwarder::~SubscriberForwarder() { + mUpstreamEventsMap.clear(); + mDownstreamEventsMap.clear(); +} + +void SubscriberForwarder::createEvents() { + if (!mCapability) { + mLogger->log(Level::NOTICE, TAG, "Create Events failed. No capability assigned."); + return; + } + + // Upstream events + auto upstreamEvents = mCapability->getUpstreamMessages(); + for (auto upstreamEventName : upstreamEvents) { + auto it = mUpstreamEventsMap.find(upstreamEventName); + if (it == mUpstreamEventsMap.end() && mAfbApi) { + // create a new event and add it to the map. + shared_ptr<common::interfaces::IAFBApi::IAFBEvent> event = mAfbApi->createEvent(upstreamEventName); + if (event == nullptr) { + mLogger->log(Level::ERROR, TAG, "Failed to create upstream event: " + upstreamEventName); + } else { + mUpstreamEventsMap.insert(make_pair(upstreamEventName, event)); + } + } + } + + // Downstream events + auto downstreamEvents = mCapability->getDownstreamMessages(); + for (auto downstreamEventName : downstreamEvents) { + auto it = mDownstreamEventsMap.find(downstreamEventName); + if (it == mDownstreamEventsMap.end() && mAfbApi) { + // create a new event and add it to the map. + shared_ptr<common::interfaces::IAFBApi::IAFBEvent> event = mAfbApi->createEvent(downstreamEventName); + if (event == nullptr) { + mLogger->log(Level::ERROR, TAG, "Failed to create downstream event: " + downstreamEventName); + } else { + mDownstreamEventsMap.insert(make_pair(downstreamEventName, event)); + } + } + } +} + +bool SubscriberForwarder::forwardMessage(const string action, const string payload) { + auto upstreamEventIt = mUpstreamEventsMap.find(action); + if (upstreamEventIt != mUpstreamEventsMap.end()) { + mLogger->log(Level::NOTICE, TAG, "Publishing upstream event: " + action); + upstreamEventIt->second->publishEvent(json_object_new_string(payload.c_str())); + return true; + } + + auto downstreamEventIt = mDownstreamEventsMap.find(action); + if (downstreamEventIt != mDownstreamEventsMap.end()) { + mLogger->log(Level::NOTICE, TAG, "Publishing downstream event: " + action); + downstreamEventIt->second->publishEvent(json_object_new_string(payload.c_str())); + return true; + } + + mLogger->log(Level::NOTICE, TAG, "Failed to publish upstream event: " + action); + return false; +} + +bool SubscriberForwarder::subscribe(vshl::common::interfaces::IAFBRequest& request, const string action) { + auto upstreamEventIt = mUpstreamEventsMap.find(action); + if (upstreamEventIt != mUpstreamEventsMap.end()) { + mLogger->log(Level::NOTICE, TAG, "Subscribing to upstream event: " + action); + return upstreamEventIt->second->subscribe(request); + } + + auto downstreamEventIt = mDownstreamEventsMap.find(action); + if (downstreamEventIt != mDownstreamEventsMap.end()) { + mLogger->log(Level::NOTICE, TAG, "Subscribing to downstream event: " + action); + return downstreamEventIt->second->subscribe(request); + } + + mLogger->log(Level::NOTICE, TAG, "Failed to subscribe to upstream event: " + action); + return false; +} + +} // namespace core +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/guimetadata/include/GuiMetadataCapability.h b/src/plugins/capabilities/guimetadata/include/GuiMetadataCapability.h new file mode 100644 index 0000000..199f49a --- /dev/null +++ b/src/plugins/capabilities/guimetadata/include/GuiMetadataCapability.h @@ -0,0 +1,52 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_CAPABILITIES_GUIMETADATA_CAPABILITY_H_ +#define VSHL_CAPABILITIES_GUIMETADATA_CAPABILITY_H_ + +#include <memory> + +#include "interfaces/capabilities/ICapability.h" + +namespace vshl { +namespace capabilities { +namespace guimetadata { + +/* + * GuiMetadata capability + */ +class GuiMetadata : public common::interfaces::ICapability { +public: + // Create a GuiMetadata. + static std::shared_ptr<GuiMetadata> create(); + + ~GuiMetadata() = default; + +protected: + string getName() const override; + + list<string> getUpstreamMessages() const override; + + list<string> getDownstreamMessages() const override; + +private: + GuiMetadata() = default; +}; + +} // namespace guimetadata +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_GUIMETADATA_CAPABILITY_H_ diff --git a/src/plugins/capabilities/guimetadata/include/GuiMetadataMessages.h b/src/plugins/capabilities/guimetadata/include/GuiMetadataMessages.h new file mode 100644 index 0000000..783b401 --- /dev/null +++ b/src/plugins/capabilities/guimetadata/include/GuiMetadataMessages.h @@ -0,0 +1,50 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_GUIMETADATA_ACTIONS_H_ +#define VSHL_CAPABILITIES_GUIMETADATA_ACTIONS_H_ + +#include <list> +#include <string> + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace guimetadata { + +static string NAME = "guimetadata"; + +// Supported actions from VA -> Apps +static string GUIMETADATA_RENDER_TEMPLATE = "render_template"; +static string GUIMETADATA_CLEAR_TEMPLATE = "clear_template"; +static string GUIMETADATA_RENDER_PLAYER_INFO = "render_player_info"; +static string GUIMETADATA_CLEAR_PLAYER_INFO = "clear_player_info"; + +// Supported actions from Apps -> VA + +// List of actions that are delivered from VA -> Apps +static list<string> GUIMETADATA_UPSTREAM_ACTIONS = {GUIMETADATA_RENDER_TEMPLATE, + GUIMETADATA_CLEAR_TEMPLATE, + GUIMETADATA_RENDER_PLAYER_INFO, + GUIMETADATA_CLEAR_PLAYER_INFO}; + +// List of actions that are delivered from Apps -> VA +static list<string> GUIMETADATA_DOWNSTREAM_ACTIONS = {}; + +} // namespace guimetadata +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_GUIMETADATA_ACTIONS_H_ diff --git a/src/plugins/capabilities/guimetadata/src/GuiMetadataCapability.cpp b/src/plugins/capabilities/guimetadata/src/GuiMetadataCapability.cpp new file mode 100644 index 0000000..106fe99 --- /dev/null +++ b/src/plugins/capabilities/guimetadata/src/GuiMetadataCapability.cpp @@ -0,0 +1,42 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/guimetadata/include/GuiMetadataCapability.h" +#include "capabilities/guimetadata/include/GuiMetadataMessages.h" + +namespace vshl { +namespace capabilities { +namespace guimetadata { + +// Create a GuiMetadata. +shared_ptr<GuiMetadata> GuiMetadata::create() { + auto guiMetadata = std::shared_ptr<GuiMetadata>(new GuiMetadata()); + return guiMetadata; +} + +string GuiMetadata::getName() const { + return NAME; +} + +list<string> GuiMetadata::getUpstreamMessages() const { + return GUIMETADATA_UPSTREAM_ACTIONS; +} + +list<string> GuiMetadata::getDownstreamMessages() const { + return GUIMETADATA_DOWNSTREAM_ACTIONS; +} + +} // namespace guimetadata +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/navigation/include/NavigationCapability.h b/src/plugins/capabilities/navigation/include/NavigationCapability.h new file mode 100644 index 0000000..66109d5 --- /dev/null +++ b/src/plugins/capabilities/navigation/include/NavigationCapability.h @@ -0,0 +1,52 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_CAPABILITIES_NAVIGATION_CAPABILITY_H_ +#define VSHL_CAPABILITIES_NAVIGATION_CAPABILITY_H_ + +#include <memory> + +#include "interfaces/capabilities/ICapability.h" + +namespace vshl { +namespace capabilities { +namespace navigation { + +/* + * Navigation capability + */ +class Navigation : public common::interfaces::ICapability { +public: + // Create a Navigation. + static std::shared_ptr<Navigation> create(); + + ~Navigation() = default; + +protected: + string getName() const override; + + list<string> getUpstreamMessages() const override; + + list<string> getDownstreamMessages() const override; + +private: + Navigation() = default; +}; + +} // namespace navigation +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_NAVIGATION_CAPABILITY_H_ diff --git a/src/plugins/capabilities/navigation/include/NavigationMessages.h b/src/plugins/capabilities/navigation/include/NavigationMessages.h new file mode 100644 index 0000000..aed9b9e --- /dev/null +++ b/src/plugins/capabilities/navigation/include/NavigationMessages.h @@ -0,0 +1,48 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CAPABILITIES_NAVIGATION_ACTIONS_H_ +#define VSHL_CAPABILITIES_NAVIGATION_ACTIONS_H_ + +#include <list> +#include <string> + +using namespace std; + +namespace vshl { +namespace capabilities { +namespace navigation { + +static string NAME = "navigation"; + +// Supported actions from VA -> Apps +static string NAVIGATION_SET_DESTINATION = "set_destination"; +static string NAVIGATION_CANCEL = "cancel_navigation"; + +// Supported actions from Apps -> VA + +// List of actions that are delivered from VA -> Apps +static list<string> NAVIGATION_UPSTREAM_ACTIONS = { + NAVIGATION_SET_DESTINATION, + NAVIGATION_CANCEL, +}; + +// List of actions that are delivered from Apps -> VA +static list<string> NAVIGATION_DOWNSTREAM_ACTIONS = {}; + +} // namespace navigation +} // namespace capabilities +} // namespace vshl + +#endif // VSHL_CAPABILITIES_NAVIGATION_ACTIONS_H_ diff --git a/src/plugins/capabilities/navigation/src/NavigationCapability.cpp b/src/plugins/capabilities/navigation/src/NavigationCapability.cpp new file mode 100644 index 0000000..d4a5119 --- /dev/null +++ b/src/plugins/capabilities/navigation/src/NavigationCapability.cpp @@ -0,0 +1,42 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "capabilities/navigation/include/NavigationCapability.h" +#include "capabilities/navigation/include/NavigationMessages.h" + +namespace vshl { +namespace capabilities { +namespace navigation { + +// Create a Navigation. +shared_ptr<Navigation> Navigation::create() { + auto navigation = std::shared_ptr<Navigation>(new Navigation()); + return navigation; +} + +string Navigation::getName() const { + return NAME; +} + +list<string> Navigation::getUpstreamMessages() const { + return NAVIGATION_UPSTREAM_ACTIONS; +} + +list<string> Navigation::getDownstreamMessages() const { + return NAVIGATION_DOWNSTREAM_ACTIONS; +} + +} // namespace navigation +} // namespace capabilities +} // namespace vshl diff --git a/src/plugins/capabilities/test/CapabilityMessagingServiceTest.cpp b/src/plugins/capabilities/test/CapabilityMessagingServiceTest.cpp new file mode 100644 index 0000000..741a8aa --- /dev/null +++ b/src/plugins/capabilities/test/CapabilityMessagingServiceTest.cpp @@ -0,0 +1,96 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "capabilities/CapabilityMessagingService.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" +#include "test/mocks/AFBEventMock.h" +#include "test/mocks/AFBRequestMock.h" +#include "test/mocks/CapabilityMock.h" + +using namespace vshl::common::interfaces; +using namespace vshl::capabilities; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class CapabilityMessagingServiceTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::NiceMock<AFBApiMock>>(); + } + + std::shared_ptr<::testing::NiceMock<AFBApiMock>> mAfbApi; + std::shared_ptr<ConsoleLogger> mConsoleLogger; +}; + +TEST_F(CapabilityMessagingServiceTest, failsInitializationOnInvalidParams) { + auto service = CapabilityMessagingService::create(mConsoleLogger, nullptr); + ASSERT_EQ(service, nullptr); + + service = CapabilityMessagingService::create(nullptr, mAfbApi); + ASSERT_EQ(service, nullptr); +} + +TEST_F(CapabilityMessagingServiceTest, initializesSuccessfully) { + auto service = CapabilityMessagingService::create(mConsoleLogger, mAfbApi); + ASSERT_NE(service, nullptr); +} + +TEST_F(CapabilityMessagingServiceTest, canSubscribeAndPublishCapabilityEvents) { + auto service = CapabilityMessagingService::create(mConsoleLogger, mAfbApi); + + auto capability = std::make_shared<::testing::NiceMock<CapabilityMock>>(); + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + std::string capabilityName = "weather"; + + ON_CALL(*capability, getName()).WillByDefault(::testing::Return(capabilityName)); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + // We don't care if and how many times subscribe method is called on event. + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::NiceMock<AFBEventMock>()); + ON_CALL(*mockEvent, subscribe(::testing::_)).WillByDefault(::testing::Return(true)); + ON_CALL(*mockEvent, publishEvent(::testing::_)).WillByDefault(::testing::Return(true)); + auto eventCreator = [mockEvent](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + mockEvent->setName(eventName); + return mockEvent; + }; + + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(eventCreator)); + + auto request = std::make_shared<::testing::StrictMock<AFBRequestMock>>(); + std::string payload = "The answer to life the universe and everything = 42"; + + bool result = service->publish(capability, *upstreamEvents.begin(), payload); + ASSERT_FALSE(result); // Without subscribing to the event. Publish should fail. + + result = service->subscribe(*request, capability, *upstreamEvents.begin()); + ASSERT_TRUE(result); + + result = service->subscribe(*request, capability, *downstreamEvents.begin()); + ASSERT_TRUE(result); + + result = service->publish(capability, *downstreamEvents.begin(), payload); + ASSERT_TRUE(result); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/capabilities/test/PublisherForwarderTest.cpp b/src/plugins/capabilities/test/PublisherForwarderTest.cpp new file mode 100644 index 0000000..d0ba319 --- /dev/null +++ b/src/plugins/capabilities/test/PublisherForwarderTest.cpp @@ -0,0 +1,116 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "capabilities/core/include/PublisherForwarder.h" +#include "capabilities/core/include/SubscriberForwarder.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" +#include "test/mocks/AFBEventMock.h" +#include "test/mocks/CapabilityMock.h" + +using namespace vshl::common::interfaces; +using namespace vshl::capabilities::core; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class PublisherForwarderTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::StrictMock<AFBApiMock>>(); + + mEventCreatorFn = [](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + mockEvent->setName(eventName); + return mockEvent; + }; + } + + std::shared_ptr<SubscriberForwarder> createSubscriberForwarder( + std::shared_ptr<::testing::StrictMock<CapabilityMock>> capability) { + EXPECT_CALL(*capability, getUpstreamMessages()).Times(1); + EXPECT_CALL(*capability, getDownstreamMessages()).Times(1); + + return SubscriberForwarder::create(mConsoleLogger, mAfbApi, capability); + } + + std::shared_ptr<PublisherForwarder> createPublisherForwarder( + std::shared_ptr<::testing::StrictMock<CapabilityMock>> capability) { + return PublisherForwarder::create(mConsoleLogger, capability); + } + + std::shared_ptr<::testing::StrictMock<AFBApiMock>> mAfbApi; + std::shared_ptr<ConsoleLogger> mConsoleLogger; + std::function<std::shared_ptr<IAFBApi::IAFBEvent>(const std::string&)> mEventCreatorFn; + std::shared_ptr<::testing::StrictMock<AFBEventMock>> mAfbEventMock; +}; + +TEST_F(PublisherForwarderTest, failsInitializationOnInvalidParams) { + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + + auto forwarder = PublisherForwarder::create(mConsoleLogger, nullptr); + ASSERT_EQ(forwarder, nullptr); + + forwarder = PublisherForwarder::create(nullptr, capability); + ASSERT_EQ(forwarder, nullptr); +} + +TEST_F(PublisherForwarderTest, initializesCorrectly) { + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + auto forwarder = createPublisherForwarder(capability); + + ASSERT_NE(forwarder, nullptr); +} + +TEST_F(PublisherForwarderTest, canForwardMessages) { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + ON_CALL(*mockEvent, publishEvent(::testing::_)).WillByDefault(::testing::Return(true)); + EXPECT_CALL(*mockEvent, publishEvent(::testing::_)).Times(4); + auto eventCreator = [mockEvent](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + return mockEvent; + }; + + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(eventCreator)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto publisherForwarder = createPublisherForwarder(capability); + ASSERT_NE(publisherForwarder, nullptr); + + auto subscriberForwarder = createSubscriberForwarder(capability); + ASSERT_NE(subscriberForwarder, nullptr); + + std::string payload = "The answer to life the universe and everything = 42"; + publisherForwarder->setSubscriberForwarder(subscriberForwarder); + + auto itCapability = downstreamEvents.begin(); + ASSERT_TRUE(publisherForwarder->forwardMessage(*itCapability++, payload)); + ASSERT_TRUE(publisherForwarder->forwardMessage(*itCapability++, payload)); + itCapability = upstreamEvents.begin(); + ASSERT_TRUE(publisherForwarder->forwardMessage(*itCapability++, payload)); + ASSERT_TRUE(publisherForwarder->forwardMessage(*itCapability++, payload)); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/capabilities/test/SubscriberForwarderTest.cpp b/src/plugins/capabilities/test/SubscriberForwarderTest.cpp new file mode 100644 index 0000000..ff438df --- /dev/null +++ b/src/plugins/capabilities/test/SubscriberForwarderTest.cpp @@ -0,0 +1,262 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "capabilities/core/include/SubscriberForwarder.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" +#include "test/mocks/AFBEventMock.h" +#include "test/mocks/AFBRequestMock.h" +#include "test/mocks/CapabilityMock.h" + +using namespace vshl::common::interfaces; +using namespace vshl::capabilities::core; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class SubscriberForwarderTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::StrictMock<AFBApiMock>>(); + + mEventCreatorFn = [](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + mockEvent->setName(eventName); + return mockEvent; + }; + } + + std::shared_ptr<SubscriberForwarder> createSubscriberForwarder( + std::shared_ptr<::testing::StrictMock<CapabilityMock>> capability) { + EXPECT_CALL(*capability, getUpstreamMessages()).Times(1); + EXPECT_CALL(*capability, getDownstreamMessages()).Times(1); + + return SubscriberForwarder::create(mConsoleLogger, mAfbApi, capability); + } + + std::shared_ptr<::testing::StrictMock<AFBApiMock>> mAfbApi; + std::shared_ptr<ConsoleLogger> mConsoleLogger; + std::function<std::shared_ptr<IAFBApi::IAFBEvent>(const std::string&)> mEventCreatorFn; + std::shared_ptr<::testing::StrictMock<AFBEventMock>> mAfbEventMock; +}; + +TEST_F(SubscriberForwarderTest, failsInitializationOnInvalidParams) { + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + + auto forwarder = SubscriberForwarder::create(mConsoleLogger, mAfbApi, nullptr); + ASSERT_EQ(forwarder, nullptr); + + forwarder = SubscriberForwarder::create(mConsoleLogger, nullptr, capability); + ASSERT_EQ(forwarder, nullptr); + + forwarder = SubscriberForwarder::create(nullptr, mAfbApi, capability); + ASSERT_EQ(forwarder, nullptr); +} + +TEST_F(SubscriberForwarderTest, initializesCorrectly) { + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + auto forwarder = createSubscriberForwarder(capability); + + ASSERT_NE(forwarder, nullptr); +} + +TEST_F(SubscriberForwarderTest, createsEventsOnInitialization) { + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(mEventCreatorFn)); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto itCapability = upstreamEvents.begin(); + EXPECT_CALL(*mAfbApi, createEvent(*itCapability)).Times(1); + itCapability++; + EXPECT_CALL(*mAfbApi, createEvent(*itCapability)).Times(1); + + itCapability = downstreamEvents.begin(); + EXPECT_CALL(*mAfbApi, createEvent(*itCapability)).Times(1); + itCapability++; + EXPECT_CALL(*mAfbApi, createEvent(*itCapability)).Times(1); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); +} + +TEST_F(SubscriberForwarderTest, canNotSubscribeToNonExistentEvents) { + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(mEventCreatorFn)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto nonExistentEvents = std::list<std::string>({"non", "existent", "events"}); + auto itCapability = nonExistentEvents.begin(); + auto request = std::make_shared<::testing::StrictMock<AFBRequestMock>>(); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); +} + +TEST_F(SubscriberForwarderTest, canNotSubscribeOnEventCreationFailure) { + // Fail the event creation and return null event. + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Return(nullptr)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto itCapability = downstreamEvents.begin(); + auto request = std::make_shared<::testing::StrictMock<AFBRequestMock>>(); + std::string payload = "The answer to life the universe and everything = 42"; + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); + itCapability = upstreamEvents.begin(); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_FALSE(forwarder->subscribe(*request, *itCapability++)); +} + +TEST_F(SubscriberForwarderTest, canSubscribeToEvents) { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + ON_CALL(*mockEvent, subscribe(::testing::_)).WillByDefault(::testing::Return(true)); + EXPECT_CALL(*mockEvent, subscribe(::testing::_)).Times(4); + auto eventCreator = [mockEvent](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + return mockEvent; + }; + + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(eventCreator)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto itCapability = downstreamEvents.begin(); + auto request = std::make_shared<::testing::StrictMock<AFBRequestMock>>(); + ASSERT_TRUE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_TRUE(forwarder->subscribe(*request, *itCapability)); + itCapability = upstreamEvents.begin(); + ASSERT_TRUE(forwarder->subscribe(*request, *itCapability++)); + ASSERT_TRUE(forwarder->subscribe(*request, *itCapability)); +} + +TEST_F(SubscriberForwarderTest, canNotPublishNonExistentEvents) { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + EXPECT_CALL(*mockEvent, publishEvent(::testing::_)).Times(0); + auto eventCreator = [mockEvent](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + return mockEvent; + }; + + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(eventCreator)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto nonExistentEvents = std::list<std::string>({"non", "existent", "events"}); + auto itCapability = nonExistentEvents.begin(); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, "My-Payload")); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, "My-Payload")); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, "My-Payload")); +} + +TEST_F(SubscriberForwarderTest, canNotPublishOnEventCreationFailure) { + // Fail the event creation and return null event. + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Return(nullptr)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto itCapability = downstreamEvents.begin(); + std::string payload = "The answer to life the universe and everything = 42"; + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, payload)); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, payload)); + itCapability = upstreamEvents.begin(); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, payload)); + ASSERT_FALSE(forwarder->forwardMessage(*itCapability++, payload)); +} + +TEST_F(SubscriberForwarderTest, canPublishEvents) { + std::shared_ptr<AFBEventMock> mockEvent(new ::testing::StrictMock<AFBEventMock>()); + ON_CALL(*mockEvent, publishEvent(::testing::_)).WillByDefault(::testing::Return(true)); + EXPECT_CALL(*mockEvent, publishEvent(::testing::_)).Times(4); + auto eventCreator = [mockEvent](const std::string& eventName) -> std::shared_ptr<IAFBApi::IAFBEvent> { + return mockEvent; + }; + + ON_CALL(*mAfbApi, createEvent(::testing::_)).WillByDefault(::testing::Invoke(eventCreator)); + EXPECT_CALL(*mAfbApi, createEvent(::testing::_)).Times(4); + + std::list<std::string> upstreamEvents({"up-ev1", "up-ev2"}); + std::list<std::string> downstreamEvents({"down-ev1", "down-ev2"}); + + auto capability = std::make_shared<::testing::StrictMock<CapabilityMock>>(); + ON_CALL(*capability, getUpstreamMessages()).WillByDefault(::testing::Return(upstreamEvents)); + ON_CALL(*capability, getDownstreamMessages()).WillByDefault(::testing::Return(downstreamEvents)); + + auto forwarder = createSubscriberForwarder(capability); + ASSERT_NE(forwarder, nullptr); + + auto itCapability = downstreamEvents.begin(); + std::string payload = "The answer to life the universe and everything = 42"; + ASSERT_TRUE(forwarder->forwardMessage(*itCapability++, payload)); + ASSERT_TRUE(forwarder->forwardMessage(*itCapability++, payload)); + itCapability = upstreamEvents.begin(); + ASSERT_TRUE(forwarder->forwardMessage(*itCapability++, payload)); + ASSERT_TRUE(forwarder->forwardMessage(*itCapability++, payload)); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/cmake/gtest.cmake b/src/plugins/cmake/gtest.cmake new file mode 100644 index 0000000..def6559 --- /dev/null +++ b/src/plugins/cmake/gtest.cmake @@ -0,0 +1,44 @@ +# gtest + +find_package(Threads REQUIRED) + +# Enable ExternalProject CMake module +INCLUDE(ExternalProject) + +ExternalProject_Add( + gtest + URL https://github.com/google/googletest/archive/release-1.8.1.zip + SOURCE_DIR "${CMAKE_BINARY_DIR}/gtest-src" + BINARY_DIR "${CMAKE_BINARY_DIR}/gtest-build" + INSTALL_COMMAND "" + LOG_DOWNLOAD ON + LOG_CONFIGURE ON + LOG_BUILD ON +) + +# Get GTest source and binary directories from CMake project +ExternalProject_Get_Property(gtest source_dir binary_dir) + +# Create a libgtest target to be used as a dependency by test programs +ADD_LIBRARY(libgtest INTERFACE) +TARGET_INCLUDE_DIRECTORIES(libgtest + INTERFACE + ${source_dir}/googletest/include +) +TARGET_LINK_LIBRARIES(libgtest + INTERFACE + ${binary_dir}/googlemock/gtest/libgtest.a + ${CMAKE_THREAD_LIBS_INIT} +) + +# Create a libgmock target to be used as a dependency by test programs +ADD_LIBRARY(libgmock INTERFACE) +TARGET_INCLUDE_DIRECTORIES(libgmock + INTERFACE + ${source_dir}/googlemock/include +) +TARGET_LINK_LIBRARIES(libgmock + INTERFACE + ${binary_dir}/googlemock/libgmock.a + ${CMAKE_THREAD_LIBS_INIT} +)
\ No newline at end of file diff --git a/src/plugins/core/VRRequestProcessor.h b/src/plugins/core/VRRequestProcessor.h new file mode 100644 index 0000000..c349a19 --- /dev/null +++ b/src/plugins/core/VRRequestProcessor.h @@ -0,0 +1,75 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CORE_INCLUDE_VR_REQUESTPROCESSOR_H_ +#define VSHL_CORE_INCLUDE_VR_REQUESTPROCESSOR_H_ + +#include <memory> +#include <unordered_map> + +#include "core/include/VRRequest.h" +#include "core/include/VRRequestProcessorDelegate.h" +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/logging/ILogger.h" +#include "interfaces/voiceagents/IVoiceAgentsChangeObserver.h" + +using namespace std; + +namespace vshl { +namespace core { +/* + * This class is the entry point for all the voice recognition request + * creation and arbitration. + */ +class VRRequestProcessor { +public: + // Create a VRRequestProcessor. + static unique_ptr<VRRequestProcessor> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::core::VRRequestProcessorDelegate> delegate); + + // Triggers a voiceagent to start listening to user speech input. + // Returns the request ID. If start fails, then empty request ID + // is returned. + string startListening(); + + // Cancels all the active requests + void cancel(); + + // Returns the voiceagents observer that belongs to the core module. + shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> getVoiceAgentsChangeObserver() const; + + // Destructor + ~VRRequestProcessor(); + +private: + // Constructor + VRRequestProcessor( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::core::VRRequestProcessorDelegate> delegate); + + // Voiceagents observer + shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> mVoiceAgentsChangeObserver; + + // Request Processor Delegate + shared_ptr<vshl::core::VRRequestProcessorDelegate> mDelegate; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace core +} // namespace vshl + +#endif // VSHL_CORE_INCLUDE_VR_REQUESTPROCESSOR_H_ diff --git a/src/plugins/core/VRRequestProcessorImpl.cpp b/src/plugins/core/VRRequestProcessorImpl.cpp new file mode 100644 index 0000000..7441a7d --- /dev/null +++ b/src/plugins/core/VRRequestProcessorImpl.cpp @@ -0,0 +1,72 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "core/VRRequestProcessor.h" + +#include "core/include/VRAgentsObserver.h" + +static string TAG = "vshl::core::VRRequestProcessor"; + +using Level = vshl::utilities::logging::Logger::Level; + +namespace vshl { +namespace core { +// Create a VRRequestProcessor. +unique_ptr<VRRequestProcessor> VRRequestProcessor::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::core::VRRequestProcessorDelegate> delegate) { + auto processor = std::unique_ptr<VRRequestProcessor>(new VRRequestProcessor(logger, delegate)); + return processor; +} + +VRRequestProcessor::VRRequestProcessor( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::core::VRRequestProcessorDelegate> delegate) : + mLogger(logger), + mDelegate(delegate) { + mVoiceAgentsChangeObserver = VRAgentsObserver::create(mDelegate); +} + +VRRequestProcessor::~VRRequestProcessor() { + mDelegate->cancelAllRequests(); +} + +string VRRequestProcessor::startListening() { + // Currently start is simply going to send the request to + // the default voice agent as the wake word detection is not + // enabled. + shared_ptr<vshl::common::interfaces::IVoiceAgent> defaultVA = mDelegate->getDefaultVoiceAgent(); + if (!defaultVA) { + mLogger->log(Level::ERROR, TAG, "Failed to start. No default voiceagent found."); + return ""; + } + + // If the requests container is not empty, then clear the + // existing requests in flight and create a new request. + mDelegate->cancelAllRequests(); + return mDelegate->startRequestForVoiceAgent(defaultVA); +} + +void VRRequestProcessor::cancel() { + // Cancel all pending requests + mDelegate->cancelAllRequests(); +} + +shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> VRRequestProcessor::getVoiceAgentsChangeObserver() + const { + return mVoiceAgentsChangeObserver; +} + +} // namespace core +} // namespace vshl diff --git a/src/plugins/core/include/VRAgentsObserver.h b/src/plugins/core/include/VRAgentsObserver.h new file mode 100644 index 0000000..d4c0c7b --- /dev/null +++ b/src/plugins/core/include/VRAgentsObserver.h @@ -0,0 +1,67 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CORE_INCLUDE_VR_AGENTS_OBSERVER_H_ +#define VSHL_CORE_INCLUDE_VR_AGENTS_OBSERVER_H_ + +#include <memory> + +#include "core/include/VRRequestProcessorDelegate.h" +#include "interfaces/voiceagents/IVoiceAgentsChangeObserver.h" +#include "utilities/logging/Logger.h" + +using namespace std; + +namespace vshl { +namespace core { +/* + * This class will observe the changes to the voiceagents data and transfers + * the actual handling responsibility to its delegate. + */ +class VRAgentsObserver + : public vshl::common::interfaces::IVoiceAgentsChangeObserver { +public: + // Create a VRAgentsObserver. + static shared_ptr<VRAgentsObserver> + create(weak_ptr<VRRequestProcessorDelegate> delegate); + + ~VRAgentsObserver(); + +protected: + void OnDefaultVoiceAgentChanged( + shared_ptr<vshl::common::interfaces::IVoiceAgent> defaultVoiceAgent) + override; + void OnVoiceAgentAdded( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) override; + void OnVoiceAgentRemoved( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) override; + void OnVoiceAgentActiveWakeWordChanged( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) override; + void OnVoiceAgentActivated( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) override; + void OnVoiceAgentDeactivated( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) override; + +private: + // Constructor + VRAgentsObserver(weak_ptr<VRRequestProcessorDelegate> delegate); + + // Delegate that needs to be informed of the voiceagent data changes. + weak_ptr<VRRequestProcessorDelegate> mWeakDelegate; +}; + +} // namespace core +} // namespace vshl + +#endif // VSHL_CORE_INCLUDE_VR_AGENTS_OBSERVER_H_ diff --git a/src/plugins/core/include/VRRequest.h b/src/plugins/core/include/VRRequest.h new file mode 100644 index 0000000..522ec78 --- /dev/null +++ b/src/plugins/core/include/VRRequest.h @@ -0,0 +1,80 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CORE_INCLUDE_VR_REQUEST_H_ +#define VSHL_CORE_INCLUDE_VR_REQUEST_H_ + +#include <memory> + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/logging/ILogger.h" +#include "interfaces/voiceagents/IVoiceAgent.h" + +using namespace std; + +namespace vshl { +namespace core { +/* + * This class implements the notion of a Voice Recognition Request. + * Each VR Request is currently mapped to one voice agent. + */ +class VRRequest { +public: + // API Verbs + static std::string VA_VERB_STARTLISTENING; + static std::string VA_VERB_CANCEL; + + // Create a VRRequest. + static unique_ptr<VRRequest> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + string requestId, + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent); + + // Destructor + ~VRRequest(); + + // Invokes the underlying voiceagent's startlistening API. + // Returns true if started successfully. False otherwise. + bool startListening(); + + // Cancels the voice recognition in the unlerlying voiceagent. + // Returns true if canceled successfully. False otherwise. + bool cancel(); + +private: + // Constructor + VRRequest( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + const string requestId, + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent); + + // Binding API reference. + shared_ptr<vshl::common::interfaces::IAFBApi> mApi; + + // Voice agent associated with this request + shared_ptr<vshl::common::interfaces::IVoiceAgent> mVoiceAgent; + + // Request ID + string mRequestId; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace core +} // namespace vshl + +#endif // VSHL_CORE_INCLUDE_VR_REQUEST_H_ diff --git a/src/plugins/core/include/VRRequestProcessorDelegate.h b/src/plugins/core/include/VRRequestProcessorDelegate.h new file mode 100644 index 0000000..94b7304 --- /dev/null +++ b/src/plugins/core/include/VRRequestProcessorDelegate.h @@ -0,0 +1,88 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_CORE_INCLUDE_VR_REQUESTPROCESSORDELEGATE_H_ +#define VSHL_CORE_INCLUDE_VR_REQUESTPROCESSORDELEGATE_H_ + +#include <memory> +#include <unordered_map> + +#include "core/include/VRRequest.h" +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/logging/ILogger.h" +#include "interfaces/voiceagents/IVoiceAgent.h" +#include "utilities/uuid/UUIDGeneration.h" + +using namespace std; + +namespace vshl { +namespace core { +/* + * This is a delegate for VRRequestProcessor actions. + * The lifetime and dependencies of this object is managed + * by VRRequestProcessor. It plays the role of a Delegate in + * Delegate pattern and a one shop stop for most of the core + * module's state. + */ +class VRRequestProcessorDelegate { +public: + // create method + static shared_ptr<VRRequestProcessorDelegate> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Destructor + ~VRRequestProcessorDelegate(); + + // Set default voiceagent + void setDefaultVoiceAgent(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent); + + // Get the default voiceagent + shared_ptr<vshl::common::interfaces::IVoiceAgent> getDefaultVoiceAgent() const; + + // Add new request to the list and start processing it. + // New request is created and startListening on the + // voiceagent is called. + string startRequestForVoiceAgent(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent); + + // Cancel all requests + void cancelAllRequests(); + + // Get All outstanding requests + // Used only by Test + unordered_map<string, shared_ptr<VRRequest>> getAllRequests(); + +private: + // Constructor + VRRequestProcessorDelegate( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Binding API reference + shared_ptr<vshl::common::interfaces::IAFBApi> mApi; + + // Default voiceagent + shared_ptr<vshl::common::interfaces::IVoiceAgent> mDefaultVoiceAgent; + + // A map of voiceagent IDs and their respective VR Request objects. + unordered_map<string, shared_ptr<VRRequest>> mVRRequests; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace core +} // namespace vshl + +#endif // VSHL_CORE_INCLUDE_VR_REQUESTPROCESSORDELEGATE_H_ diff --git a/src/plugins/core/src/VRAgentsObserverImpl.cpp b/src/plugins/core/src/VRAgentsObserverImpl.cpp new file mode 100644 index 0000000..7ee4a7e --- /dev/null +++ b/src/plugins/core/src/VRAgentsObserverImpl.cpp @@ -0,0 +1,54 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "core/include/VRAgentsObserver.h" + +namespace vshl { +namespace core { + +shared_ptr<VRAgentsObserver> VRAgentsObserver::create(weak_ptr<VRRequestProcessorDelegate> delegate) { + auto observer = std::shared_ptr<VRAgentsObserver>(new VRAgentsObserver(delegate)); + return observer; +} + +VRAgentsObserver::VRAgentsObserver(weak_ptr<VRRequestProcessorDelegate> delegate) { + mWeakDelegate = delegate; +} + +VRAgentsObserver::~VRAgentsObserver() { +} + +void VRAgentsObserver::OnDefaultVoiceAgentChanged(shared_ptr<vshl::common::interfaces::IVoiceAgent> defaultVoiceAgent) { + if (auto delegate = mWeakDelegate.lock()) { + delegate->setDefaultVoiceAgent(defaultVoiceAgent); + } +} + +void VRAgentsObserver::OnVoiceAgentAdded(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { +} + +void VRAgentsObserver::OnVoiceAgentRemoved(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { +} + +void VRAgentsObserver::OnVoiceAgentActiveWakeWordChanged(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { + // Not Implemented +} + +void VRAgentsObserver::OnVoiceAgentActivated(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { +} + +void VRAgentsObserver::OnVoiceAgentDeactivated(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { +} +} // namespace core +} // namespace vshl diff --git a/src/plugins/core/src/VRRequestImpl.cpp b/src/plugins/core/src/VRRequestImpl.cpp new file mode 100644 index 0000000..00adf96 --- /dev/null +++ b/src/plugins/core/src/VRRequestImpl.cpp @@ -0,0 +1,92 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "core/include/VRRequest.h" + +#define FREEIF(x) \ + if (!x) { \ + free(x); \ + } +#define BREAKIF(x) \ + if (x) { \ + result = false; \ + break; \ + } + +static string TAG = "vshl::core::VRRequest"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace core { + +string VRRequest::VA_VERB_STARTLISTENING = "startListening"; +string VRRequest::VA_VERB_CANCEL = "cancel"; + +unique_ptr<VRRequest> VRRequest::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + const string requestId, + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { + if (logger == nullptr) { + return nullptr; + } + + if (afbApi == nullptr) { + logger->log(Level::ERROR, TAG, "Invalid AFB API"); + return nullptr; + } + + auto request = std::unique_ptr<VRRequest>(new VRRequest(logger, afbApi, requestId, voiceAgent)); + return request; +} + +VRRequest::VRRequest( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi, + string requestId, + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) : + mApi(afbApi), + mRequestId(requestId), + mVoiceAgent(voiceAgent), + mLogger(logger) { +} + +VRRequest::~VRRequest() { +} + +bool VRRequest::startListening() { + json_object* object = NULL; + std::string error, info; + bool result = true; + int rc = mApi->callSync(mVoiceAgent->getApi(), VA_VERB_STARTLISTENING, NULL, &object, error, info); + + FREEIF(object); + + return true; +} + +bool VRRequest::cancel() { + json_object* object = NULL; + std::string error, info; + bool result = true; + int rc = mApi->callSync(mVoiceAgent->getApi(), VA_VERB_CANCEL, NULL, &object, error, info); + + FREEIF(object); + + return true; +} + +} // namespace core +} // namespace vshl diff --git a/src/plugins/core/src/VRRequestProcessorDelegateImpl.cpp b/src/plugins/core/src/VRRequestProcessorDelegateImpl.cpp new file mode 100644 index 0000000..e20b22e --- /dev/null +++ b/src/plugins/core/src/VRRequestProcessorDelegateImpl.cpp @@ -0,0 +1,93 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "core/include/VRRequestProcessorDelegate.h" + +static string TAG = "vshl::core::VRRequestProcessorDelegate"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace core { +shared_ptr<VRRequestProcessorDelegate> VRRequestProcessorDelegate::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) { + auto delegate = std::shared_ptr<VRRequestProcessorDelegate>(new VRRequestProcessorDelegate(logger, afbApi)); + return delegate; +} + +VRRequestProcessorDelegate::VRRequestProcessorDelegate( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) : + mApi(afbApi), + mLogger(logger) { +} + +VRRequestProcessorDelegate::~VRRequestProcessorDelegate() { + mVRRequests.clear(); +} + +string VRRequestProcessorDelegate::startRequestForVoiceAgent( + shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { + if (!mApi) { + mLogger->log(Level::ERROR, TAG, "Failed to startRequestForVoiceAgent: " + voiceAgent->getId() + ", No API."); + return ""; + } + + // Generate a new request ID. + string newReqId = vshl::utilities::uuid::generateUUID(); + + // Create a new request and start listening. + shared_ptr<VRRequest> newRequest = VRRequest::create(mLogger, mApi, newReqId, voiceAgent); + + // mLogger->log(Level::DEBUG, TAG, "Starting request with ID: " + newReqId); + if (!newRequest->startListening()) { + mLogger->log(Level::ERROR, TAG, "Failed to start listening."); + return ""; + } + + // Insert only if its started successfully. + mVRRequests.insert(make_pair(voiceAgent->getId(), newRequest)); + + return newReqId; +} + +void VRRequestProcessorDelegate::cancelAllRequests() { + // Cancel Pending requests + if (!mVRRequests.empty()) { + auto vrRequestsIt = mVRRequests.begin(); + while (vrRequestsIt != mVRRequests.end()) { + if (!vrRequestsIt->second->cancel()) { + mLogger->log(Level::WARNING, TAG, "Failed to cancel request: " + vrRequestsIt->first); + } + vrRequestsIt++; + } + mVRRequests.clear(); + } +} + +unordered_map<string, shared_ptr<VRRequest>> VRRequestProcessorDelegate::getAllRequests() { + return mVRRequests; +} + +void VRRequestProcessorDelegate::setDefaultVoiceAgent(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent) { + mDefaultVoiceAgent = voiceAgent; +} + +shared_ptr<vshl::common::interfaces::IVoiceAgent> VRRequestProcessorDelegate::getDefaultVoiceAgent() const { + return mDefaultVoiceAgent; +} + +} // namespace core +} // namespace vshl diff --git a/src/plugins/core/test/VRRequestProcessorTest.cpp b/src/plugins/core/test/VRRequestProcessorTest.cpp new file mode 100644 index 0000000..c1a37df --- /dev/null +++ b/src/plugins/core/test/VRRequestProcessorTest.cpp @@ -0,0 +1,213 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "core/VRRequestProcessor.h" +#include "voiceagents/include/VoiceAgent.h" +#include "voiceagents/test/VoiceAgentsTestData.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" + +using namespace vshl::core; +using namespace vshl::voiceagents; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class VRRequestProcessorTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::StrictMock<AFBApiMock>>(); + + auto vaTestData = *(getVoiceAgentsTestData().begin()); + mVoiceAgent = VoiceAgent::create( + mConsoleLogger, + vaTestData.id, + vaTestData.name, + vaTestData.description, + vaTestData.api, + vaTestData.vendor, + vaTestData.activeWakeword, + vaTestData.isActive, + vaTestData.wakewords); + + mVRReqProcessorDelegate = VRRequestProcessorDelegate::create(mConsoleLogger, mAfbApi); + mVRRequestProcessor = VRRequestProcessor::create(mConsoleLogger, mVRReqProcessorDelegate); + } + + std::shared_ptr<::testing::StrictMock<AFBApiMock>> mAfbApi; + std::shared_ptr<ConsoleLogger> mConsoleLogger; + std::shared_ptr<VoiceAgent> mVoiceAgent; + + std::shared_ptr<VRRequestProcessorDelegate> mVRReqProcessorDelegate; + std::shared_ptr<VRRequestProcessor> mVRRequestProcessor; +}; + +TEST_F(VRRequestProcessorTest, initializesCorrectly) { + ASSERT_NE(mVRRequestProcessor, nullptr); +} + +TEST_F(VRRequestProcessorTest, startListeningFailsOnLackOfDefaultAgent) { + auto requestId = mVRRequestProcessor->startListening(); + ASSERT_EQ(requestId, ""); +} + +TEST_F(VRRequestProcessorTest, startListeningAndCancelWorks) { + mVRReqProcessorDelegate->setDefaultVoiceAgent(mVoiceAgent); + + { + ::testing::InSequence dummy; + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_STARTLISTENING, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_CANCEL, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + } + + mVRRequestProcessor->startListening(); + auto requests = mVRReqProcessorDelegate->getAllRequests(); + ASSERT_EQ(requests.size(), 1); + + mVRRequestProcessor->cancel(); + requests = mVRReqProcessorDelegate->getAllRequests(); + ASSERT_EQ(requests.size(), 0); +} + +TEST_F(VRRequestProcessorTest, requestIsCancelledOnObjectDestruction) { + auto delegate = VRRequestProcessorDelegate::create(mConsoleLogger, mAfbApi); + auto processor = VRRequestProcessor::create(mConsoleLogger, delegate); + + delegate->setDefaultVoiceAgent(mVoiceAgent); + + { + ::testing::InSequence dummy; + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_STARTLISTENING, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_CANCEL, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + } + + auto requestId = processor->startListening(); + ASSERT_NE(requestId, ""); + + auto requests = delegate->getAllRequests(); + ASSERT_EQ(requests.size(), 1); +} + +TEST_F(VRRequestProcessorTest, backToBackStartListeningCancelsEarlierRequest) { + mVRReqProcessorDelegate->setDefaultVoiceAgent(mVoiceAgent); + + { + ::testing::InSequence dummy; + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_STARTLISTENING, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_CANCEL, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_STARTLISTENING, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_CANCEL, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + } + + mVRRequestProcessor->startListening(); + auto requests = mVRReqProcessorDelegate->getAllRequests(); + ASSERT_EQ(requests.size(), 1); + + mVRRequestProcessor->startListening(); + requests = mVRReqProcessorDelegate->getAllRequests(); + ASSERT_EQ(requests.size(), 1); + + mVRRequestProcessor->cancel(); + requests = mVRReqProcessorDelegate->getAllRequests(); + ASSERT_EQ(requests.size(), 0); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/core/test/VRRequestTest.cpp b/src/plugins/core/test/VRRequestTest.cpp new file mode 100644 index 0000000..b1cd0a6 --- /dev/null +++ b/src/plugins/core/test/VRRequestTest.cpp @@ -0,0 +1,101 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "core/include/VRRequest.h" +#include "voiceagents/include/VoiceAgent.h" +#include "voiceagents/test/VoiceAgentsTestData.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" + +using namespace vshl::core; +using namespace vshl::voiceagents; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class VRRequestTest : public ::testing::Test { +protected: + void SetUp() override { + mRequestId = "Req-0001"; + + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::StrictMock<AFBApiMock>>(); + + auto vaTestData = *(getVoiceAgentsTestData().begin()); + mVoiceAgent = VoiceAgent::create( + mConsoleLogger, + vaTestData.id, + vaTestData.name, + vaTestData.description, + vaTestData.api, + vaTestData.vendor, + vaTestData.activeWakeword, + vaTestData.isActive, + vaTestData.wakewords); + + mVRRequest = VRRequest::create(mConsoleLogger, mAfbApi, mRequestId, mVoiceAgent); + } + + std::string mRequestId; + std::shared_ptr<::testing::StrictMock<AFBApiMock>> mAfbApi; + std::shared_ptr<ConsoleLogger> mConsoleLogger; + std::shared_ptr<VoiceAgent> mVoiceAgent; + + std::shared_ptr<VRRequest> mVRRequest; +}; + +TEST_F(VRRequestTest, initializesCorrectly) { + ASSERT_NE(mVRRequest, nullptr); +} + +TEST_F(VRRequestTest, failsCreationOnInvalidParams) { + auto vrRequest = VRRequest::create(mConsoleLogger, nullptr, mRequestId, mVoiceAgent); + ASSERT_EQ(vrRequest, nullptr); + + vrRequest = VRRequest::create(nullptr, mAfbApi, mRequestId, mVoiceAgent); + ASSERT_EQ(vrRequest, nullptr); +} + +TEST_F(VRRequestTest, startsListeningSuccessfully) { + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), + VRRequest::VA_VERB_STARTLISTENING, + ::testing::_, + ::testing::_, + ::testing::_, + ::testing::_)) + .Times(1); + + ASSERT_TRUE(mVRRequest->startListening()); +} + +TEST_F(VRRequestTest, cancelsSuccessfully) { + EXPECT_CALL( + *mAfbApi, + callSync( + mVoiceAgent->getApi(), VRRequest::VA_VERB_CANCEL, ::testing::_, ::testing::_, ::testing::_, ::testing::_)) + .Times(1); + + ASSERT_TRUE(mVRRequest->cancel()); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/interfaces/afb/IAFBApi.h b/src/plugins/interfaces/afb/IAFBApi.h new file mode 100644 index 0000000..cd98006 --- /dev/null +++ b/src/plugins/interfaces/afb/IAFBApi.h @@ -0,0 +1,98 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_COMMON_INTERFACES_AFBAPI_H_ +#define VSHL_COMMON_INTERFACES_AFBAPI_H_ + +#include <memory> +#include <string> + +#include <json-c/json_object.h> + +using namespace std; + +namespace vshl { +namespace common { +namespace interfaces { + +/** + * Interface to represent AFB Request. + */ +class IAFBRequest { +public: + /** + * Gets the native request object. + */ + virtual void* getNativeRequest() = 0; +}; + +/** + * Interface to encapsulate all AFB (AGL Application Framework Binding) + * functions. + */ +class IAFBApi { +public: + /** + * Interface to represent AFB Event + */ + class IAFBEvent { + public: + /** + * Gets human readable name of the event. + */ + virtual std::string getName() const = 0; + + /** + * Returns true if event is valid. False otherwise. + */ + virtual bool isValid() = 0; + + /** + * Publish event to all observers. + * + * @return The number of observers that received the event. + */ + virtual int publishEvent(struct json_object* payload) = 0; + + /** + * Subscribe to the event + * + * @c request Party interested in the event. + */ + virtual bool subscribe(IAFBRequest& request) = 0; + + /** + * Unsubscribe to the event + * + * @c request Party no longer interested in the event. + */ + virtual bool unsubscribe(IAFBRequest& request) = 0; + }; + + virtual std::shared_ptr<IAFBEvent> createEvent(const std::string& eventName) = 0; + + virtual int callSync( + const std::string& api, + const std::string& verb, + struct json_object* request, + struct json_object** result, + std::string& error, + std::string& info) = 0; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_AFBAPI_H_ diff --git a/src/plugins/interfaces/capabilities/ICapability.h b/src/plugins/interfaces/capabilities/ICapability.h new file mode 100644 index 0000000..4b134b7 --- /dev/null +++ b/src/plugins/interfaces/capabilities/ICapability.h @@ -0,0 +1,58 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_COMMON_INTERFACES_ICAPABILITY_H_ +#define VSHL_COMMON_INTERFACES_ICAPABILITY_H_ + +#include <list> +#include <string> + +using namespace std; + +namespace vshl { +namespace common { +namespace interfaces { + +/* + * This interface defines the structure for a specific voiceagent capability. + */ +class ICapability { +public: + /* + * Returns the capability's name. + */ + virtual string getName() const = 0; + + /* + * Returns the list of upstream messages. + */ + virtual list<string> getUpstreamMessages() const = 0; + + /* + * Returns the list of downstream messages + */ + virtual list<string> getDownstreamMessages() const = 0; + + /** + * Virtual destructor to assure proper cleanup of derived types. + */ + virtual ~ICapability() = default; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_ICAPABILITY_H_ diff --git a/src/plugins/interfaces/utilities/events/IEventFilter.h b/src/plugins/interfaces/utilities/events/IEventFilter.h new file mode 100644 index 0000000..33d8202 --- /dev/null +++ b/src/plugins/interfaces/utilities/events/IEventFilter.h @@ -0,0 +1,46 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_COMMON_INTERFACES_IEVENTFILTER_H_ +#define VSHL_COMMON_INTERFACES_IEVENTFILTER_H_ + +#include <string> + +using namespace std; + +namespace vshl { +namespace common { +namespace interfaces { +/* + * This is an abstract class that is responsible for filtering the events + * that are delivered to the high level voice service from apps or voiceagents. + */ +class IEventFilter { +public: + // Name of the event filter. + virtual string getName() = 0; + + // Every event filter needs to implement this method and + // return true if consuming the event or false otherwise. + virtual bool onIncomingEvent(const string eventName, const string voiceAgentId, const string payload) = 0; + + // Destructor + virtual ~IEventFilter() = default; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_IEVENTFILTER_H_ diff --git a/src/plugins/interfaces/utilities/logging/ILogger.h b/src/plugins/interfaces/utilities/logging/ILogger.h new file mode 100644 index 0000000..a2618bc --- /dev/null +++ b/src/plugins/interfaces/utilities/logging/ILogger.h @@ -0,0 +1,42 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_COMMON_INTERFACES_LOGGER_H_ +#define VSHL_COMMON_INTERFACES_LOGGER_H_ + +#include <string> + +namespace vshl { +namespace common { +namespace interfaces { + +class ILogger { +public: + enum Level { + DEBUG, + INFO, + WARNING, + ERROR, + NOTICE, + }; + + virtual void log(Level level, const std::string &tag, + const std::string &message) = 0; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_LOGGER_H_ diff --git a/src/plugins/interfaces/voiceagents/IVoiceAgent.h b/src/plugins/interfaces/voiceagents/IVoiceAgent.h new file mode 100644 index 0000000..367ad72 --- /dev/null +++ b/src/plugins/interfaces/voiceagents/IVoiceAgent.h @@ -0,0 +1,95 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_COMMON_INTERFACES_IVOICEAGENT_H_ +#define VSHL_COMMON_INTERFACES_IVOICEAGENT_H_ + +#include <memory> +#include <string> +#include <unordered_set> + +using namespace std; + +namespace vshl { +namespace common { +namespace interfaces { + +/* + * This interface define the structure for VoiceAgent Information. + * The implementation of this structure is owned by voiceagents module. + */ +class IVoiceAgent { +public: + /* + * Set the active wakeword for this voiceagent + */ + virtual bool setActiveWakeWord(const string &wakeword) = 0; + + /* + * Sets the activation state of this voiceagent + */ + virtual void setIsActive(bool active) = 0; + + /* + * Returns the voiceagent's ID. + */ + virtual string getId() const = 0; + + /* + * Returns the voiceagent's name. + */ + virtual string getName() const = 0; + + /* + * Returns the voiceagent's description. + */ + virtual string getDescription() const = 0; + + /* + * Returns the voiceagent's API. + */ + virtual string getApi() const = 0; + + /* + * Returns the voiceagent's vendor information/ + */ + virtual string getVendor() const = 0; + + /* + * Returns the list of wakewords mapped to the voiceagent. + */ + virtual shared_ptr<unordered_set<string>> getWakeWords() const = 0; + + /* + * Returns true if the voiceagent is active. False otherwise. + */ + virtual bool isActive() const = 0; + + /* + * Returns the active wakeword for the voiceagent. + */ + virtual string getActiveWakeword() const = 0; + + /** + * Virtual destructor to assure proper cleanup of derived types. + */ + virtual ~IVoiceAgent() = default; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_IVOICEAGENT_H_ diff --git a/src/plugins/interfaces/voiceagents/IVoiceAgentsChangeObserver.h b/src/plugins/interfaces/voiceagents/IVoiceAgentsChangeObserver.h new file mode 100644 index 0000000..e552ab5 --- /dev/null +++ b/src/plugins/interfaces/voiceagents/IVoiceAgentsChangeObserver.h @@ -0,0 +1,80 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ + +#ifndef VSHL_COMMON_INTERFACES_IVOICEAGENTSCHANGEOBSERVER_H_ +#define VSHL_COMMON_INTERFACES_IVOICEAGENTSCHANGEOBSERVER_H_ + +#include <memory> +#include <string> + +#include "interfaces/voiceagents/IVoiceAgent.h" + +using namespace std; + +namespace vshl { +namespace common { +namespace interfaces { + +/* + * This interface is used to observe changes to the voiceagents datastore. + * The voiceagents data store is contained in the voiceagents module. + */ +class IVoiceAgentsChangeObserver { +public: + /** + * This method notifies the observers that the default voiceagent selection + * has been updated. + */ + virtual void + OnDefaultVoiceAgentChanged(shared_ptr<IVoiceAgent> defaultVoiceAgent) = 0; + + /** + * This method notifies the observers that a new voiceagent has been added. + */ + virtual void OnVoiceAgentAdded(shared_ptr<IVoiceAgent> voiceAgent) = 0; + + /** + * This method notifies the observers that a voiceagent is removed. + */ + virtual void OnVoiceAgentRemoved(shared_ptr<IVoiceAgent> voiceAgent) = 0; + + /** + * This method notifies the observers that active wakeword for a voiceagent is + * updated. + */ + virtual void + OnVoiceAgentActiveWakeWordChanged(shared_ptr<IVoiceAgent> voiceAgent) = 0; + + /** + * This method notifies the observers that the voiceagent has been activated. + */ + virtual void OnVoiceAgentActivated(shared_ptr<IVoiceAgent> voiceAgent) = 0; + + /** + * This method notifies the observers that the voiceagent has been activated. + */ + virtual void OnVoiceAgentDeactivated(shared_ptr<IVoiceAgent> voiceAgent) = 0; + + /** + * Virtual destructor to assure proper cleanup of derived types. + */ + virtual ~IVoiceAgentsChangeObserver() = default; +}; + +} // namespace interfaces +} // namespace common +} // namespace vshl + +#endif // VSHL_COMMON_INTERFACES_IVOICEAGENTSCHANGEOBSERVER_H_ diff --git a/src/plugins/test/common/ConsoleLogger.cpp b/src/plugins/test/common/ConsoleLogger.cpp new file mode 100644 index 0000000..d4f9eef --- /dev/null +++ b/src/plugins/test/common/ConsoleLogger.cpp @@ -0,0 +1,31 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <iostream> + +#include "test/common/ConsoleLogger.h" + +namespace vshl { +namespace test { +namespace common { + +void ConsoleLogger::log(Level level, const std::string& tag, const std::string& message) { + string format_msg = "Tag: " + tag + ", message: " + message; + std::cout << format_msg << std::endl; +} + +} // namespace common +} // namespace test +} // namespace vshl diff --git a/src/plugins/test/common/ConsoleLogger.h b/src/plugins/test/common/ConsoleLogger.h new file mode 100644 index 0000000..11bc0d8 --- /dev/null +++ b/src/plugins/test/common/ConsoleLogger.h @@ -0,0 +1,37 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_COMMON_CONSOLE_LOGGER_H_ +#define VSHL_TEST_COMMON_CONSOLE_LOGGER_H_ + +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace test { +namespace common { + +class ConsoleLogger : public vshl::common::interfaces::ILogger { +public: + // ILogger interface + void log(Level level, const std::string &tag, + const std::string &message) override; +}; + +} // namespace common +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_COMMON_CONSOLE_LOGGER_H_ diff --git a/src/plugins/test/mocks/AFBApiMock.h b/src/plugins/test/mocks/AFBApiMock.h new file mode 100644 index 0000000..46e2e99 --- /dev/null +++ b/src/plugins/test/mocks/AFBApiMock.h @@ -0,0 +1,41 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_MOCKS_AFBAPIMOCK_H_ +#define VSHL_TEST_MOCKS_AFBAPIMOCK_H_ + +#include <gmock/gmock.h> + +#include "interfaces/afb/IAFBApi.h" + +namespace vshl { +namespace test { + +class AFBApiMock : public vshl::common::interfaces::IAFBApi { +public: + MOCK_METHOD1(createEvent, std::shared_ptr<IAFBEvent>(const std::string& eventName)); + MOCK_METHOD6( + callSync, + int(const std::string& api, + const std::string& verb, + struct json_object* request, + struct json_object** result, + std::string& error, + std::string& info)); +}; + +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_MOCKS_AFBAPIMOCK_H_
\ No newline at end of file diff --git a/src/plugins/test/mocks/AFBEventMock.h b/src/plugins/test/mocks/AFBEventMock.h new file mode 100644 index 0000000..3d78e9f --- /dev/null +++ b/src/plugins/test/mocks/AFBEventMock.h @@ -0,0 +1,47 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_MOCKS_AFBEVENTMOCK_H_ +#define VSHL_TEST_MOCKS_AFBEVENTMOCK_H_ + +#include <gmock/gmock.h> + +#include "interfaces/afb/IAFBApi.h" + +namespace vshl { +namespace test { + +class AFBEventMock : public vshl::common::interfaces::IAFBApi::IAFBEvent { +public: + void setName(const std::string& name) { + mName = name; + } + + std::string getName() const override { + return mName; + } + + MOCK_METHOD0(isValid, bool()); + MOCK_METHOD1(publishEvent, int(struct json_object* payload)); + MOCK_METHOD1(subscribe, bool(vshl::common::interfaces::IAFBRequest& request)); + MOCK_METHOD1(unsubscribe, bool(vshl::common::interfaces::IAFBRequest& request)); + +private: + std::string mName; +}; + +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_MOCKS_AFBEVENTMOCK_H_
\ No newline at end of file diff --git a/src/plugins/test/mocks/AFBRequestMock.h b/src/plugins/test/mocks/AFBRequestMock.h new file mode 100644 index 0000000..5557565 --- /dev/null +++ b/src/plugins/test/mocks/AFBRequestMock.h @@ -0,0 +1,33 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_MOCKS_AFBREQUESTMOCK_H_ +#define VSHL_TEST_MOCKS_AFBREQUESTMOCK_H_ + +#include <gmock/gmock.h> + +#include "interfaces/afb/IAFBApi.h" + +namespace vshl { +namespace test { + +class AFBRequestMock : public vshl::common::interfaces::IAFBRequest { +public: + MOCK_METHOD0(getNativeRequest, void*()); +}; + +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_MOCKS_AFBREQUESTMOCK_H_
\ No newline at end of file diff --git a/src/plugins/test/mocks/CapabilityMock.h b/src/plugins/test/mocks/CapabilityMock.h new file mode 100644 index 0000000..a2201df --- /dev/null +++ b/src/plugins/test/mocks/CapabilityMock.h @@ -0,0 +1,35 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_MOCKS_CAPABILITYMOCK_H_ +#define VSHL_TEST_MOCKS_CAPABILITYMOCK_H_ + +#include <gmock/gmock.h> + +#include "interfaces/capabilities/ICapability.h" + +namespace vshl { +namespace test { + +class CapabilityMock : public vshl::common::interfaces::ICapability { +public: + MOCK_CONST_METHOD0(getName, std::string()); + MOCK_CONST_METHOD0(getUpstreamMessages, std::list<std::string>()); + MOCK_CONST_METHOD0(getDownstreamMessages, std::list<std::string>()); +}; + +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_MOCKS_CAPABILITYMOCK_H_
\ No newline at end of file diff --git a/src/plugins/test/mocks/VoiceAgentsChangeObserverMock.h b/src/plugins/test/mocks/VoiceAgentsChangeObserverMock.h new file mode 100644 index 0000000..6edeea2 --- /dev/null +++ b/src/plugins/test/mocks/VoiceAgentsChangeObserverMock.h @@ -0,0 +1,38 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_TEST_MOCKS_VOICEAGENTSCHANGEOBSERVERMOCK_H_ +#define VSHL_TEST_MOCKS_VOICEAGENTSCHANGEOBSERVERMOCK_H_ + +#include <gmock/gmock.h> + +#include "interfaces/voiceagents/IVoiceAgentsChangeObserver.h" + +namespace vshl { +namespace test { + +class VoiceAgentsChangeObserverMock : public vshl::common::interfaces::IVoiceAgentsChangeObserver { +public: + MOCK_METHOD1(OnDefaultVoiceAgentChanged, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> defaultVoiceAgent)); + MOCK_METHOD1(OnVoiceAgentAdded, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent)); + MOCK_METHOD1(OnVoiceAgentRemoved, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent)); + MOCK_METHOD1(OnVoiceAgentActiveWakeWordChanged, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent)); + MOCK_METHOD1(OnVoiceAgentActivated, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent)); + MOCK_METHOD1(OnVoiceAgentDeactivated, void(shared_ptr<vshl::common::interfaces::IVoiceAgent> voiceAgent)); +}; + +} // namespace test +} // namespace vshl + +#endif // VSHL_TEST_MOCKS_VOICEAGENTSCHANGEOBSERVERMOCK_H_
\ No newline at end of file diff --git a/src/plugins/utilities/events/EventRouter.cpp b/src/plugins/utilities/events/EventRouter.cpp new file mode 100644 index 0000000..999c3dd --- /dev/null +++ b/src/plugins/utilities/events/EventRouter.cpp @@ -0,0 +1,68 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "utilities/events/EventRouter.h" + +static string TAG = "vshl::utilities::events::EventRouter"; + +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace utilities { +namespace events { + +unique_ptr<EventRouter> EventRouter::create(shared_ptr<vshl::common::interfaces::ILogger> logger) { + return std::unique_ptr<EventRouter>(new EventRouter(logger)); +} + +EventRouter::EventRouter(shared_ptr<vshl::common::interfaces::ILogger> logger) : mLogger(logger) { +} + +EventRouter::~EventRouter() { + mEventFilters.clear(); +} + +bool EventRouter::handleIncomingEvent(const string eventName, const string voiceAgentId, const string payload) { + for (auto eventFilter : mEventFilters) { + if (eventFilter->onIncomingEvent(eventName, voiceAgentId, payload)) { + return true; + } + } + + return false; +} + +bool EventRouter::addEventFilter(shared_ptr<vshl::common::interfaces::IEventFilter> filter) { + if (!filter) { + mLogger->log(Level::ERROR, TAG, "Failed to add event filter. Invalid arguments."); + return false; + } + + mEventFilters.insert(filter); + return true; +} + +bool EventRouter::removeEventFilter(shared_ptr<vshl::common::interfaces::IEventFilter> filter) { + if (!filter) { + mLogger->log(Level::ERROR, TAG, "Failed to add remove filter. Invalid arguments."); + return false; + } + + mEventFilters.erase(filter); + return true; +} + +} // namespace events +} // namespace utilities +} // namespace vshl diff --git a/src/plugins/utilities/events/EventRouter.h b/src/plugins/utilities/events/EventRouter.h new file mode 100644 index 0000000..fd7f0c2 --- /dev/null +++ b/src/plugins/utilities/events/EventRouter.h @@ -0,0 +1,66 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_UTILITIES_EVENTS_EVENTMANAGER_H_ +#define VSHL_UTILITIES_EVENTS_EVENTMANAGER_H_ + +#include <memory> +#include <string> +#include <unordered_set> + +#include "interfaces/utilities/events/IEventFilter.h" +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace utilities { +namespace events { +/* + * This class is responsible for routing incoming events to + * the appropriate event listener for consumption. + * Note: The listeners should implement the IEventFilter class. + */ +class EventRouter { +public: + static unique_ptr<EventRouter> create(shared_ptr<vshl::common::interfaces::ILogger> logger); + + // Destructor + ~EventRouter(); + + // Add event filter as listerner. + bool addEventFilter(shared_ptr<vshl::common::interfaces::IEventFilter> filter); + + // Remove event filter as listerner. + bool removeEventFilter(shared_ptr<vshl::common::interfaces::IEventFilter> filter); + + // This method is called by the controller for routing + // the event to appropriate listener. + bool handleIncomingEvent(const string eventName, const string voiceAgentId, const string payload); + +private: + EventRouter(shared_ptr<vshl::common::interfaces::ILogger> logger); + + // set of event filters. + unordered_set<shared_ptr<vshl::common::interfaces::IEventFilter>> mEventFilters; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace events +} // namespace utilities +} // namespace vshl + +#endif // VSHL_UTILITIES_EVENTS_EVENTROUTER_H_ diff --git a/src/plugins/utilities/logging/Logger.cpp b/src/plugins/utilities/logging/Logger.cpp new file mode 100644 index 0000000..6374e19 --- /dev/null +++ b/src/plugins/utilities/logging/Logger.cpp @@ -0,0 +1,56 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "utilities/logging/Logger.h" + +namespace vshl { +namespace utilities { +namespace logging { + +// Constructor +Logger::Logger(AFB_ApiT api) { + mApi = api; +} + +unique_ptr<Logger> Logger::create(AFB_ApiT api) { + auto logger = std::unique_ptr<Logger>(new Logger(api)); + return logger; +} + +void Logger::log(Level level, const std::string& tag, const std::string& message) { + string format_msg = "Tag: " + tag + ", message: " + message; + switch (level) { + case Level::NOTICE: + AFB_ApiNotice(mApi, format_msg.c_str()); + break; + case Level::WARNING: + AFB_ApiWarning(mApi, format_msg.c_str()); + break; + case Level::DEBUG: + AFB_ApiDebug(mApi, format_msg.c_str()); + break; + case Level::ERROR: + AFB_ApiError(mApi, format_msg.c_str()); + break; + case Level::INFO: + AFB_ApiInfo(mApi, format_msg.c_str()); + break; + default: + break; + } +} + +} // namespace logging +} // namespace utilities +} // namespace vshl diff --git a/src/plugins/utilities/logging/Logger.h b/src/plugins/utilities/logging/Logger.h new file mode 100644 index 0000000..79c89a5 --- /dev/null +++ b/src/plugins/utilities/logging/Logger.h @@ -0,0 +1,53 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_UTILITIES_LOGGING_LOGGER_H_ +#define VSHL_UTILITIES_LOGGING_LOGGER_H_ + +#include <memory> + +extern "C" { +#define AFB_BINDING_VERSION 3 +#include "afb-definitions.h" +#include "ctl-plugin.h" +}; + +#include "interfaces/utilities/logging/ILogger.h" + +using namespace std; + +namespace vshl { +namespace utilities { +namespace logging { + +class Logger : public vshl::common::interfaces::ILogger { +public: + static std::unique_ptr<Logger> create(AFB_ApiT api); + + // ILogger interface + void log(Level level, const std::string &tag, + const std::string &message) override; + +private: + Logger(AFB_ApiT api); + + // Binding API reference + AFB_ApiT mApi; +}; + +} // namespace logging +} // namespace utilities +} // namespace vshl + +#endif // VSHL_UTILITIES_LOGGING_LOGGER_H_ diff --git a/src/plugins/utilities/uuid/UUIDGeneration.cpp b/src/plugins/utilities/uuid/UUIDGeneration.cpp new file mode 100644 index 0000000..bb03fc6 --- /dev/null +++ b/src/plugins/utilities/uuid/UUIDGeneration.cpp @@ -0,0 +1,137 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +// This code is copied from https://github.com/alexa/avs-device-sdk/ +// Minor modifications are made to the original file. + +#include <random> +#include <chrono> +#include <sstream> +#include <iomanip> +#include <mutex> +#include <climits> +#include <algorithm> +#include <functional> + +#include "utilities/uuid/UUIDGeneration.h" + +namespace vshl { +namespace utilities { +namespace uuid { + +/// String to identify log entries originating from this file. +static const std::string TAG("UUIDGeneration"); + +/// The UUID version (Version 4), shifted into the correct position in the byte. +static const uint8_t UUID_VERSION_VALUE = 4 << 4; + +/// The UUID variant (Variant 1), shifted into the correct position in the byte. +static const size_t UUID_VARIANT_VALUE = 2 << 6; + +/// Separator used between UUID fields. +static const std::string SEPARATOR("-"); + +/// Number of bits in the replacement value. +static const size_t MAX_NUM_REPLACEMENT_BITS = CHAR_BIT; + +/// Number of bits in a hex digit. +static const size_t BITS_IN_HEX_DIGIT = 4; + +/** + * Randomly generate a string of hex digits. Before the conversion of hex to string, + * the function allows replacement of the bits of the first two generated hex digits. + * Replacement happens starting at the most significant, to the least significant bit. + * + * @param ibe A random number generator. + * @param numDigits The number of hex digits [0-9],[a-f] to generate. + * @param replacementBits The replacement value for up to the first two digits generated. + * @param numReplacementBits The number of bits of @c replacementBits to use. + * + * @return A hex string of length @c numDigits. + */ +static const std::string generateHexWithReplacement( + std::independent_bits_engine<std::default_random_engine, CHAR_BIT, uint8_t>& ibe, + unsigned int numDigits, + uint8_t replacementBits, + unsigned short numReplacementBits) { + if (numReplacementBits > MAX_NUM_REPLACEMENT_BITS) { + return ""; + } + + if (numReplacementBits > (numDigits * BITS_IN_HEX_DIGIT)) { + return ""; + } + + // Makes assumption that 1 digit = 4 bits. + std::vector<uint8_t> bytes(ceil(numDigits / 2.0)); + std::generate(bytes.begin(), bytes.end(), std::ref(ibe)); + + // Replace the specified number of bits from the first byte. + bytes.at(0) &= (0xff >> numReplacementBits); + replacementBits &= (0xff << (MAX_NUM_REPLACEMENT_BITS - numReplacementBits)); + bytes.at(0) |= replacementBits; + + std::ostringstream oss; + for (const auto& byte : bytes) { + oss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(byte); + } + + std::string bytesText = oss.str(); + // Remove the last digit for odd numDigits case. + bytesText.resize(numDigits); + + return bytesText; +} + +/** + * Randomly generate a string of hex digits. + * + * @param ibe A random number generator. + * @param numDigits The number of hex digits [0-9],[a-f] to generate. + * + * @return A hex string of length @c numDigits. + */ +static const std::string generateHex( + std::independent_bits_engine<std::default_random_engine, CHAR_BIT, uint8_t>& ibe, + unsigned int numDigits) { + return generateHexWithReplacement(ibe, numDigits, 0, 0); +} + +const std::string generateUUID() { + static bool seeded = false; + static std::independent_bits_engine<std::default_random_engine, CHAR_BIT, uint8_t> ibe; + static std::mutex mutex; + std::unique_lock<std::mutex> lock(mutex); + if (!seeded) { + std::random_device rd; + ibe.seed( + rd() + + std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()) + .count()); + seeded = true; + } + + std::ostringstream uuidText; + uuidText << generateHex(ibe, 8) << SEPARATOR << generateHex(ibe, 4) << SEPARATOR + << generateHexWithReplacement(ibe, 4, UUID_VERSION_VALUE, 4) << SEPARATOR + << generateHexWithReplacement(ibe, 4, UUID_VARIANT_VALUE, 2) << SEPARATOR << generateHex(ibe, 12); + + lock.unlock(); + + return uuidText.str(); +} + +} // namespace uuid +} // namespace utilities +} // namespace vshl diff --git a/src/plugins/utilities/uuid/UUIDGeneration.h b/src/plugins/utilities/uuid/UUIDGeneration.h new file mode 100644 index 0000000..7af9cb1 --- /dev/null +++ b/src/plugins/utilities/uuid/UUIDGeneration.h @@ -0,0 +1,42 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +// This code is copied from https://github.com/alexa/avs-device-sdk/ +// Minor modifications are made to the original file. + +#ifndef VSHL_UTILITIES_UUID_UUIDGENERATION_H_ +#define VSHL_UTILITIES_UUID_UUIDGENERATION_H_ + +#include <string> + +namespace vshl { +namespace utilities { +namespace uuid { + +/** + * Generates a variant 1, version 4 universally unique identifier (UUID) consisting of 32 hexadecimal digits. + * The UUID generated is of the format xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx where M indicates the version, and the two + * most significant bits of N indicates the variant. M is 0100 (binary) for version 4 and N is 10xx(binary) for + * variant 1. + * @see https://tools.ietf.org/html/rfc4122. + * + * @return A uuid as a string. + */ +const std::string generateUUID(); + +} // namespace uuid +} // namespace utilities +} // namespace vshl + +#endif // VSHL_UTILITIES_UUID_UUIDGENERATION_H_
\ No newline at end of file diff --git a/src/plugins/voiceagents/VoiceAgentEventNames.h b/src/plugins/voiceagents/VoiceAgentEventNames.h new file mode 100644 index 0000000..4575528 --- /dev/null +++ b/src/plugins/voiceagents/VoiceAgentEventNames.h @@ -0,0 +1,38 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTEVENTNAMES_H_ +#define VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTEVENTNAMES_H_ + +#include <list> +#include <string> + +using namespace std; + +namespace vshl { +namespace voiceagents { + +static string VSHL_EVENT_AUTH_STATE_EVENT = "voice_authstate_event"; +static string VSHL_EVENT_CONNECTION_STATE_EVENT = "voice_connectionstate_event"; +static string VSHL_EVENT_DIALOG_STATE_EVENT = "voice_dialogstate_event"; + +static list<string> VSHL_EVENTS = { + VSHL_EVENT_AUTH_STATE_EVENT, VSHL_EVENT_CONNECTION_STATE_EVENT, + VSHL_EVENT_DIALOG_STATE_EVENT, +}; + +} // namespace voiceagents +} // namespace vshl + +#endif // VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTEVENTNAMES_H_ diff --git a/src/plugins/voiceagents/VoiceAgentsDataManager.h b/src/plugins/voiceagents/VoiceAgentsDataManager.h new file mode 100644 index 0000000..a4c9143 --- /dev/null +++ b/src/plugins/voiceagents/VoiceAgentsDataManager.h @@ -0,0 +1,135 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTS_H_ +#define VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTS_H_ + +#include <memory> +#include <set> +#include <unordered_map> +#include <unordered_set> + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/events/IEventFilter.h" +#include "interfaces/utilities/logging/ILogger.h" +#include "interfaces/voiceagents/IVoiceAgent.h" +#include "interfaces/voiceagents/IVoiceAgentsChangeObserver.h" +#include "voiceagents/include/VoiceAgent.h" +#include "voiceagents/include/VoiceAgentEventsHandler.h" + +namespace vshl { +namespace voiceagents { +/* + * This class implements the data model for voiceagents. + * Supports add, remove and query operations on voiceagent data. + * Notifies the observers of the changes in the voiceagents data model. + */ +class VoiceAgentsDataManager { +public: + // Create a VoiceAgentsDataManager. + static std::unique_ptr<VoiceAgentsDataManager> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + /** + * Activates the list of voiceagents. + * + * @return Number of activated agents + */ + uint32_t activateVoiceAgents(const unordered_set<string>& activeVoiceAgentIds); + + /** + * Deactivates the list of voiceagents. + * + * @return Number of de-activated agents + */ + uint32_t deactivateVoiceAgents(const unordered_set<string>& inactiveVoiceAgentIds); + + // Sets the default voiceagent. + bool setDefaultVoiceAgent(const string& voiceAgentId); + + // Sets the default voiceagent. + std::string getDefaultVoiceAgent(); + + // Sets the active wakeword for the voiceagent. + bool setActiveWakeWord(const string& voiceAgentId, const string& wakeword); + + // Adds a new voiceagent to the cache and also persists the information in a + // database. + // This call would notify all the observers about the new voiceagent addition. + bool addNewVoiceAgent( + const string& id, + const string& name, + const string& description, + const string& api, + const string& vendor, + const string& activeWakeword, + const bool isActive, + const shared_ptr<unordered_set<string>> wakewords); + + // Removes the voiceagent from thecache and also from persistent database. + // This call would notify all the observers about the removal of the + // voiceagent. + bool removeVoiceAgent(const string& voiceAgentId); + + // Returns the set of all voice agents in @c VoiceAgentsDataManger cache + std::set<std::shared_ptr<vshl::common::interfaces::IVoiceAgent>> getAllVoiceAgents(); + + // Returns the event filter that belongs to the core module. + shared_ptr<vshl::common::interfaces::IEventFilter> getEventFilter() const; + + // Subscribe to an event coming from the voiceagent. + bool subscribeToVshlEventFromVoiceAgent( + vshl::common::interfaces::IAFBRequest& request, + const string eventName, + const string voiceagentId); + + // Adds a new voiceagent change observer. + bool addVoiceAgentsChangeObserver(shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> observer); + + // Removes the voiceagent change observer from the list. + bool removeVoiceAgentsChangeObserver(shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> observer); + + // Destructor + ~VoiceAgentsDataManager(); + +private: + // Constructor + VoiceAgentsDataManager( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Binding API reference + shared_ptr<vshl::common::interfaces::IAFBApi> mAfbApi; + + // A list of all the voiceagent change observers + unordered_set<shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver>> mVoiceAgentChangeObservers; + + // A map of voiceagents grouped by ID + unordered_map<string, shared_ptr<VoiceAgent>> mVoiceAgents; + + // Voiceagent event handler. + shared_ptr<VoiceAgentEventsHandler> mVoiceAgentEventsHandler; + + // Default voiceagent + string mDefaultVoiceAgentId; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace voiceagents +} // namespace vshl + +#endif // VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTS_H_ diff --git a/src/plugins/voiceagents/VoiceAgentsDataManagerImpl.cpp b/src/plugins/voiceagents/VoiceAgentsDataManagerImpl.cpp new file mode 100644 index 0000000..626a7fc --- /dev/null +++ b/src/plugins/voiceagents/VoiceAgentsDataManagerImpl.cpp @@ -0,0 +1,272 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "voiceagents/VoiceAgentsDataManager.h" + +#include "voiceagents/include/VoiceAgentEventsHandler.h" + +static string TAG = "vshl::voiceagents::VoiceAgentsDataManager"; + +/** + * Specifies the severity level of a log message + */ +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace voiceagents { + +std::unique_ptr<VoiceAgentsDataManager> VoiceAgentsDataManager::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) { + return std::unique_ptr<VoiceAgentsDataManager>(new VoiceAgentsDataManager(logger, afbApi)); +} + +// Constructor +VoiceAgentsDataManager::VoiceAgentsDataManager( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) : + mLogger(logger), + mAfbApi(afbApi) { + mVoiceAgentEventsHandler = VoiceAgentEventsHandler::create(mLogger, mAfbApi); +} + +// Destructor +VoiceAgentsDataManager::~VoiceAgentsDataManager() { + // Clear the observers + mVoiceAgentChangeObservers.clear(); + // Clear the voiceagents + mVoiceAgents.clear(); +} + +uint32_t VoiceAgentsDataManager::activateVoiceAgents(const unordered_set<string>& activeVoiceAgentIds) { + if (activeVoiceAgentIds.empty() || mVoiceAgents.empty()) { + mLogger->log(Level::ERROR, TAG, "Failed to activate voiceagents"); + return 0; + } + + uint32_t agentsActivated = 0; + for (auto voiceAgentId : activeVoiceAgentIds) { + auto voiceAgentIt = mVoiceAgents.find(voiceAgentId); + if (voiceAgentIt != mVoiceAgents.end()) { + // activate the voiceagent + ++agentsActivated; + if (!voiceAgentIt->second->isActive()) { + voiceAgentIt->second->setIsActive(true); + // Notify observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnVoiceAgentActivated(voiceAgentIt->second); + } + } + } + } + return agentsActivated; +} + +uint32_t VoiceAgentsDataManager::deactivateVoiceAgents(const unordered_set<string>& inactiveVoiceAgentIds) { + if (inactiveVoiceAgentIds.empty() || mVoiceAgents.empty()) { + mLogger->log(Level::ERROR, TAG, "Failed to deactivate voiceagents"); + return 0; + } + + uint32_t agentsDeactivated = 0; + for (auto voiceAgentId : inactiveVoiceAgentIds) { + auto voiceAgentIt = mVoiceAgents.find(voiceAgentId); + if (voiceAgentIt != mVoiceAgents.end()) { + ++agentsDeactivated; + if (voiceAgentIt->second->isActive()) { + // deactivate the voiceagent + voiceAgentIt->second->setIsActive(false); + // Notify observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnVoiceAgentDeactivated(voiceAgentIt->second); + } + } + } + } + + return agentsDeactivated; +} + +bool VoiceAgentsDataManager::setDefaultVoiceAgent(const string& voiceAgentId) { + if (mVoiceAgents.empty() || voiceAgentId.empty()) { + string message = string("Failed to set default voiceagent id: ") + voiceAgentId; + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + auto defaultVoiceAgentIt = mVoiceAgents.find(voiceAgentId); + + if (defaultVoiceAgentIt != mVoiceAgents.end()) { + if (mDefaultVoiceAgentId != voiceAgentId) { + // Notify observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnDefaultVoiceAgentChanged(defaultVoiceAgentIt->second); + } + } + mDefaultVoiceAgentId = voiceAgentId; + } else { + mLogger->log(Level::ERROR, TAG, "Can't set default agent. Invalid voice agent id:" + voiceAgentId); + return false; + } + + return true; +} + +std::string VoiceAgentsDataManager::getDefaultVoiceAgent() { + return mDefaultVoiceAgentId; +} + +bool VoiceAgentsDataManager::setActiveWakeWord(const string& voiceAgentId, const string& wakeword) { + if (mVoiceAgents.empty() || wakeword.empty()) { + string message = + string("Failed to set active wakeword: ") + wakeword + string(" for voiceagent id: ") + voiceAgentId; + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + auto voiceAgentIt = mVoiceAgents.find(voiceAgentId); + if (voiceAgentIt == mVoiceAgents.end()) { + return false; + } + + string oldWakeWord = voiceAgentIt->second->getActiveWakeword(); + if (oldWakeWord != wakeword) { + voiceAgentIt->second->setActiveWakeWord(wakeword); + // Notify observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnVoiceAgentActiveWakeWordChanged(voiceAgentIt->second); + } + } + + return true; +} + +bool VoiceAgentsDataManager::addNewVoiceAgent( + const string& id, + const string& name, + const string& description, + const string& api, + const string& vendor, + const string& activeWakeword, + const bool isActive, + const shared_ptr<unordered_set<string>> wakewords) { + shared_ptr<VoiceAgent> voiceAgent = + VoiceAgent::create(mLogger, id, name, description, api, vendor, activeWakeword, isActive, wakewords); + + if (voiceAgent.get() == nullptr || voiceAgent->getId().empty()) { + string message = string("Invalid Arguments: Failed to add new voiceagent"); + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + if (!mVoiceAgents.empty() && mVoiceAgents.find(voiceAgent->getId()) != mVoiceAgents.end()) { + string message = + string("Failed to add new voiceagent. Voiceagent: ") + voiceAgent->getId() + string(" already exists."); + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + mVoiceAgents.insert(make_pair(voiceAgent->getId(), voiceAgent)); + + // Notify the observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnVoiceAgentAdded(voiceAgent); + } + + // Create all vshl events for the voiceagent. + mVoiceAgentEventsHandler->createVshlEventsForVoiceAgent(voiceAgent->getId()); + + return true; +} + +bool VoiceAgentsDataManager::removeVoiceAgent(const string& voiceAgentId) { + if (mVoiceAgents.empty()) { + string message = string("Failed to remove voiceagent: ") + voiceAgentId + string(". Voiceagents data empty."); + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + auto voiceAgentIt = mVoiceAgents.find(voiceAgentId); + if (voiceAgentIt == mVoiceAgents.end()) { + string message = string("Failed to remove voiceagent: ") + voiceAgentId + string(". Doesn't exist."); + mLogger->log(Level::ERROR, TAG, message); + return false; + } + + auto voiceAgent = voiceAgentIt->second; + // Remove from the map + mVoiceAgents.erase(voiceAgentId); + // Notify the observers + for (auto observer : mVoiceAgentChangeObservers) { + observer->OnVoiceAgentRemoved(voiceAgent); + } + + // Remove all vshl events for the voiceagent. + mVoiceAgentEventsHandler->removeVshlEventsForVoiceAgent(voiceAgent->getId()); + + return true; +} + +std::set<std::shared_ptr<vshl::common::interfaces::IVoiceAgent>> VoiceAgentsDataManager::getAllVoiceAgents() { + std::set<std::shared_ptr<vshl::common::interfaces::IVoiceAgent>> voiceAgentsSet; + for (auto element : mVoiceAgents) { + voiceAgentsSet.insert(element.second); + } + + return voiceAgentsSet; +} + +// Returns the event filter that belongs to the core module. +shared_ptr<vshl::common::interfaces::IEventFilter> VoiceAgentsDataManager::getEventFilter() const { + return mVoiceAgentEventsHandler; +} + +bool VoiceAgentsDataManager::subscribeToVshlEventFromVoiceAgent( + vshl::common::interfaces::IAFBRequest& request, + const string eventName, + const string voiceAgentId) { + auto voiceAgentIt = mVoiceAgents.find(voiceAgentId); + if (voiceAgentIt == mVoiceAgents.end()) { + mLogger->log( + Level::ERROR, + TAG, + "\ + Failed to subscribe to VSHL events from voiceagent. VoiceAgent: " + + voiceAgentId + " doesn't exist."); + return false; + } + return mVoiceAgentEventsHandler->subscribeToVshlEventFromVoiceAgent(request, eventName, voiceAgentIt->second); +} + +bool VoiceAgentsDataManager::addVoiceAgentsChangeObserver( + shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> observer) { + if (!observer) { + return false; + } + + mVoiceAgentChangeObservers.insert(observer); + return true; +} + +bool VoiceAgentsDataManager::removeVoiceAgentsChangeObserver( + shared_ptr<vshl::common::interfaces::IVoiceAgentsChangeObserver> observer) { + if (!observer) { + return false; + } + + mVoiceAgentChangeObservers.erase(observer); + return true; +} +} // namespace voiceagents +} // namespace vshl diff --git a/src/plugins/voiceagents/include/VoiceAgent.h b/src/plugins/voiceagents/include/VoiceAgent.h new file mode 100644 index 0000000..4dd55d4 --- /dev/null +++ b/src/plugins/voiceagents/include/VoiceAgent.h @@ -0,0 +1,95 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_VOICEAGENTS_INCLUDE_VOICEAGENT_H_ +#define VSHL_VOICEAGENTS_INCLUDE_VOICEAGENT_H_ + +#include <memory> +#include <unordered_set> + +#include "interfaces/utilities/logging/ILogger.h" +#include "interfaces/voiceagents/IVoiceAgent.h" + +using namespace std; + +namespace vshl { +namespace voiceagents { +/* + * Default implementation of IVoiceAgent interface. + */ +class VoiceAgent : public vshl::common::interfaces::IVoiceAgent { +public: + // Creates @c VoiceAgent instance + static shared_ptr<VoiceAgent> + create(shared_ptr<vshl::common::interfaces::ILogger> logger, const string &id, + const string &name, const string &description, const string &api, + const string &vendor, const string &activeWakeword, + const bool isActive, + const shared_ptr<unordered_set<string>> wakewords); + + // Destructor + ~VoiceAgent(); + + // IVoiceAgent overriden methods + bool setActiveWakeWord(const string &wakeword) override; + void setIsActive(bool active) override; + string getId() const override; + string getName() const override; + string getDescription() const override; + string getApi() const override; + string getVendor() const override; + shared_ptr<unordered_set<string>> getWakeWords() const override; + bool isActive() const override; + string getActiveWakeword() const override; + +private: + // Constructor + VoiceAgent(shared_ptr<vshl::common::interfaces::ILogger> logger, + const string &id, const string &name, const string &description, + const string &api, const string &vendor, + const string &activeWakeword, const bool isActive, + const shared_ptr<unordered_set<string>> wakewords); + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; + + // Id + string mId; + + // Name + string mName; + + // Description + string mDescription; + + // API + string mApi; + + // Vendor + string mVendor; + + // Active wakeword + string mActiveWakeword; + + // Active ?? + bool mIsActive; + + // Wakewords + shared_ptr<unordered_set<string>> mWakewords; +}; + +} // namespace voiceagents +} // namespace vshl + +#endif // VSHL_VOICEAGENTS_INCLUDE_VOICEAGENT_H_ diff --git a/src/plugins/voiceagents/include/VoiceAgentEventsHandler.h b/src/plugins/voiceagents/include/VoiceAgentEventsHandler.h new file mode 100644 index 0000000..3c1ca6c --- /dev/null +++ b/src/plugins/voiceagents/include/VoiceAgentEventsHandler.h @@ -0,0 +1,95 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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. + */ +#ifndef VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTSTATE_EVENT_HANDLER_H_ +#define VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTSTATE_EVENT_HANDLER_H_ + +#include <algorithm> +#include <memory> +#include <unordered_map> + +#include "interfaces/afb/IAFBApi.h" +#include "interfaces/utilities/events/IEventFilter.h" +#include "interfaces/utilities/logging/ILogger.h" +#include "voiceagents/VoiceAgentEventNames.h" +#include "voiceagents/include/VoiceAgent.h" + +using namespace std; + +namespace vshl { +namespace voiceagents { +/* + * This class is reponsible for handling agent specific events + * subscription and delivery on behalf of the high level voice service. + * This class also listen to the incoming events from voice agents + * and implements propagation to application layer. + */ +class VoiceAgentEventsHandler : public vshl::common::interfaces::IEventFilter { +public: + // Create a VREventFilter. + static shared_ptr<VoiceAgentEventsHandler> create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Creates all the vshl events for a specific voiceagent id. + // For e.g if voiceagent is VA-001 then a new vshl event + // voice_authstate_event#VA-001 for auth state will be created. + // Please see VoiceAgentEventNames.h for all the event names. + void createVshlEventsForVoiceAgent(const string voiceAgentId); + + // Removes the events from its bookkeeping. + void removeVshlEventsForVoiceAgent(const string voiceAgentId); + + // Subscribe to a vshl event corresponding to a voiceagent. + bool subscribeToVshlEventFromVoiceAgent( + vshl::common::interfaces::IAFBRequest& request, + const string eventName, + const shared_ptr<VoiceAgent> voiceAgent); + + ~VoiceAgentEventsHandler(); + +protected: + string getName() override; + + // IEventFilter override + bool onIncomingEvent(const string eventName, const string voiceAgentId, const string payload) override; + +private: + // Constructor + VoiceAgentEventsHandler( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi); + + // Helper method to generate the event name with voiceagent Id + // concatenated. + string createEventNameWithVAId(string eventName, string voiceAgentId); + + // call subscribe verb on the voiceagent. True if subscription successful. + // False otherwise. + bool callSubscribeVerb(const shared_ptr<VoiceAgent> voiceAgent); + + // Binding API reference + shared_ptr<vshl::common::interfaces::IAFBApi> mAfbApi; + + // A map of VSHL event ID to its Event object + unordered_map<string, shared_ptr<common::interfaces::IAFBApi::IAFBEvent>> mEventsMap; + + // Logger + shared_ptr<vshl::common::interfaces::ILogger> mLogger; +}; + +} // namespace voiceagents +} // namespace vshl + +#endif // VSHL_VOICEAGENTS_INCLUDE_VOICEAGENTSTATE_EVENT_HANDLER_H_ diff --git a/src/plugins/voiceagents/src/VoiceAgentEventsHandler.cpp b/src/plugins/voiceagents/src/VoiceAgentEventsHandler.cpp new file mode 100644 index 0000000..4952721 --- /dev/null +++ b/src/plugins/voiceagents/src/VoiceAgentEventsHandler.cpp @@ -0,0 +1,139 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 "voiceagents/include/VoiceAgentEventsHandler.h" + +static string TAG = "vshl::voiceagents::VoiceAgentEventsHandler"; +static string VA_VERB_SUBSCRIBE = "subscribe"; + +using Level = vshl::common::interfaces::ILogger::Level; +using namespace vshl::common::interfaces; + +namespace vshl { +namespace voiceagents { + +shared_ptr<VoiceAgentEventsHandler> VoiceAgentEventsHandler::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) { + auto eventFilter = std::shared_ptr<VoiceAgentEventsHandler>(new VoiceAgentEventsHandler(logger, afbApi)); + return eventFilter; +} + +VoiceAgentEventsHandler::VoiceAgentEventsHandler( + shared_ptr<vshl::common::interfaces::ILogger> logger, + shared_ptr<vshl::common::interfaces::IAFBApi> afbApi) : + mAfbApi(afbApi), + mLogger(logger) { +} + +VoiceAgentEventsHandler::~VoiceAgentEventsHandler() { + mEventsMap.clear(); +} + +string VoiceAgentEventsHandler::getName() { + return TAG; +} + +void VoiceAgentEventsHandler::createVshlEventsForVoiceAgent(const string voiceAgentId) { + // Update the events map with all the VSHL Events. + for (auto eventName : VSHL_EVENTS) { + string eventNameWithVAId = createEventNameWithVAId(eventName, voiceAgentId); + auto it = mEventsMap.find(eventNameWithVAId); + if (it == mEventsMap.end() && mAfbApi) { + // create a new event and add it to the map. + shared_ptr<IAFBApi::IAFBEvent> event = mAfbApi->createEvent(eventNameWithVAId); + mEventsMap.insert(make_pair(eventNameWithVAId, event)); + } + } +} + +void VoiceAgentEventsHandler::removeVshlEventsForVoiceAgent(const string voiceAgentId) { + // Update the events map with all the VSHL Events. + for (auto eventName : VSHL_EVENTS) { + string eventNameWithVAId = createEventNameWithVAId(eventName, voiceAgentId); + auto it = mEventsMap.find(eventNameWithVAId); + if (it != mEventsMap.end()) { + mEventsMap.erase(it); + } + } +} + +bool VoiceAgentEventsHandler::subscribeToVshlEventFromVoiceAgent( + vshl::common::interfaces::IAFBRequest& request, + const string eventName, + const shared_ptr<VoiceAgent> voiceAgent) { + auto supportedEventsIt = find(VSHL_EVENTS.begin(), VSHL_EVENTS.end(), eventName); + if (supportedEventsIt == VSHL_EVENTS.end()) { + mLogger->log(Level::ERROR, TAG, "Event: " + eventName + " not a known event."); + return false; + } + + // Check if the entry for the voiceagent is present in the + // events map. If not then return false because the responsibility + // of adding to the map lies in the hands of AddVoiceAgent method. + string eventNameWithVAId = createEventNameWithVAId(eventName, voiceAgent->getId()); + auto createdEventsIt = mEventsMap.find(eventNameWithVAId); + if (createdEventsIt == mEventsMap.end()) { + mLogger->log(Level::ERROR, TAG, "Not able to subscribe. Event doesn't exist, " + eventNameWithVAId); + return false; + } + createdEventsIt->second->subscribe(request); + + if (!callSubscribeVerb(voiceAgent)) { + mLogger->log(Level::WARNING, TAG, "Failed to subscribe to voiceagent: " + voiceAgent->getId()); + } + + return true; +} + +// IEventFilter override. +bool VoiceAgentEventsHandler::onIncomingEvent(const string eventName, const string voiceAgentId, const string payload) { + string eventNameWithVAId = createEventNameWithVAId(eventName, voiceAgentId); + auto it = mEventsMap.find(eventNameWithVAId); + if (it != mEventsMap.end()) { + return it->second->publishEvent(json_object_new_string(payload.c_str())); + } + + return true; +} + +string VoiceAgentEventsHandler::createEventNameWithVAId(string eventName, string voiceAgentId) { + return eventName + "#" + voiceAgentId; +} + +bool VoiceAgentEventsHandler::callSubscribeVerb(const shared_ptr<VoiceAgent> voiceAgent) { + if (!voiceAgent) { + mLogger->log(Level::ERROR, TAG, "Failed to callSubscribeVerb. Invalid input parameter."); + return false; + } + + if (!mAfbApi) { + mLogger->log( + Level::ERROR, TAG, "Failed to callSubscribeVerb on voicegent: " + voiceAgent->getId() + ", No API."); + return false; + } + + // TODO(Naveen): Move to utilities. + json_object* object = NULL; + std::string error, info; + int rc = mAfbApi->callSync(voiceAgent->getApi(), VA_VERB_SUBSCRIBE, NULL, &object, error, info); + + if (object) { + free(object); + } + + return true; +} +} // namespace voiceagents +} // namespace vshl diff --git a/src/plugins/voiceagents/src/VoiceAgentImpl.cpp b/src/plugins/voiceagents/src/VoiceAgentImpl.cpp new file mode 100644 index 0000000..f2ef8a1 --- /dev/null +++ b/src/plugins/voiceagents/src/VoiceAgentImpl.cpp @@ -0,0 +1,126 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <sstream> + +#include "voiceagents/include/VoiceAgent.h" + +static string TAG = "vshl::voiceagents::VoiceAgent"; + +/** + * Specifies the severity level of a log message + */ +using Level = vshl::common::interfaces::ILogger::Level; + +namespace vshl { +namespace voiceagents { +// Creates @c VoiceAgent instance +shared_ptr<VoiceAgent> VoiceAgent::create( + shared_ptr<vshl::common::interfaces::ILogger> logger, + const string& id, + const string& name, + const string& description, + const string& api, + const string& vendor, + const string& activeWakeword, + const bool isActive, + const shared_ptr<unordered_set<string>> wakewords) { + if (wakewords == nullptr) { + logger->log(Level::ERROR, TAG, "Wakeword list null"); + return nullptr; + } + + auto voiceAgent = std::unique_ptr<VoiceAgent>( + new VoiceAgent(logger, id, name, description, api, vendor, activeWakeword, isActive, wakewords)); + if (!voiceAgent->setActiveWakeWord(activeWakeword)) { + return nullptr; + } + + return voiceAgent; +} + +VoiceAgent::VoiceAgent( + shared_ptr<vshl::common::interfaces::ILogger> logger, + const string& id, + const string& name, + const string& description, + const string& api, + const string& vendor, + const string& activeWakeword, + const bool isActive, + const shared_ptr<unordered_set<string>> wakewords) : + mLogger(logger), + mId(id), + mName(name), + mDescription(description), + mApi(api), + mVendor(vendor), + mActiveWakeword(activeWakeword), + mIsActive(isActive), + mWakewords(wakewords) { +} + +// Destructor +VoiceAgent::~VoiceAgent() { +} + +// Set the active wakeword for this voiceagent +bool VoiceAgent::setActiveWakeWord(const string& wakeword) { + if (mWakewords->find(wakeword) != mWakewords->end()) { + mActiveWakeword = wakeword; + return true; + } + + mLogger->log(Level::ERROR, TAG, "Wakeword: " + wakeword + " doesn't exist in wakeword list"); + return false; +} + +// Sets the activation state of this voiceagent +void VoiceAgent::setIsActive(bool active) { + mIsActive = active; +} + +string VoiceAgent::getId() const { + return mId; +} + +string VoiceAgent::getName() const { + return mName; +} + +string VoiceAgent::getDescription() const { + return mDescription; +} + +string VoiceAgent::getApi() const { + return mApi; +} + +string VoiceAgent::getVendor() const { + return mVendor; +} + +shared_ptr<unordered_set<string>> VoiceAgent::getWakeWords() const { + return mWakewords; +} + +bool VoiceAgent::isActive() const { + return mIsActive; +} + +string VoiceAgent::getActiveWakeword() const { + return mActiveWakeword; +} +} // namespace voiceagents +} // namespace vshl diff --git a/src/plugins/voiceagents/test/VoiceAgentTest.cpp b/src/plugins/voiceagents/test/VoiceAgentTest.cpp new file mode 100644 index 0000000..e5ad15e --- /dev/null +++ b/src/plugins/voiceagents/test/VoiceAgentTest.cpp @@ -0,0 +1,94 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "voiceagents/include/VoiceAgent.h" + +#include "voiceagents/test/VoiceAgentsTestData.h" +#include "test/common/ConsoleLogger.h" + +using namespace vshl::voiceagents; +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class VoiceAgentTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + + mVoiceAgentData = *(getVoiceAgentsTestData().begin()); + mVoiceAgent = VoiceAgent::create( + mConsoleLogger, + mVoiceAgentData.id, + mVoiceAgentData.name, + mVoiceAgentData.description, + mVoiceAgentData.api, + mVoiceAgentData.vendor, + mVoiceAgentData.activeWakeword, + mVoiceAgentData.isActive, + mVoiceAgentData.wakewords); + } + + std::shared_ptr<ConsoleLogger> mConsoleLogger; + std::shared_ptr<VoiceAgent> mVoiceAgent; + VoiceAgentTestData mVoiceAgentData; +}; + +TEST_F(VoiceAgentTest, InitializesCorrectly) { + ASSERT_NE(mVoiceAgent, nullptr); + ASSERT_EQ(mVoiceAgent->getId(), mVoiceAgentData.id); + ASSERT_EQ(mVoiceAgent->getName(), mVoiceAgentData.name); + ASSERT_EQ(mVoiceAgent->getDescription(), mVoiceAgentData.description); + ASSERT_EQ(mVoiceAgent->getApi(), mVoiceAgentData.api); + ASSERT_EQ(mVoiceAgent->getVendor(), mVoiceAgentData.vendor); + ASSERT_EQ(mVoiceAgent->getActiveWakeword(), mVoiceAgentData.activeWakeword); + ASSERT_EQ(mVoiceAgent->isActive(), mVoiceAgentData.isActive); + + std::unordered_set<std::string> wakeWords = *mVoiceAgentData.wakewords; + ASSERT_EQ(*(mVoiceAgent->getWakeWords()), wakeWords); +} + +TEST_F(VoiceAgentTest, FailsCreationOnNonExistentWakeword) { + std::string nonExistentWW = "non-existent"; + auto voiceAgent = VoiceAgent::create( + mConsoleLogger, + mVoiceAgentData.id, + mVoiceAgentData.name, + mVoiceAgentData.description, + mVoiceAgentData.api, + mVoiceAgentData.vendor, + nonExistentWW, + mVoiceAgentData.isActive, + mVoiceAgentData.wakewords); + ASSERT_EQ(voiceAgent, nullptr); +} + +TEST_F(VoiceAgentTest, SetsWakewordCorrectly) { + std::string wakeword = *(mVoiceAgentData.wakewords->begin()); + ASSERT_TRUE(mVoiceAgent->setActiveWakeWord(wakeword)); + ASSERT_EQ(mVoiceAgent->getActiveWakeword(), wakeword); +} + +TEST_F(VoiceAgentTest, FailsToSetNonExistentWakeword) { + std::string nonExistentWW = "non-existent"; + ASSERT_FALSE(mVoiceAgent->setActiveWakeWord(nonExistentWW)); + ASSERT_EQ(mVoiceAgent->getActiveWakeword(), mVoiceAgentData.activeWakeword); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/voiceagents/test/VoiceAgentsDataManagerTest.cpp b/src/plugins/voiceagents/test/VoiceAgentsDataManagerTest.cpp new file mode 100644 index 0000000..58c62ed --- /dev/null +++ b/src/plugins/voiceagents/test/VoiceAgentsDataManagerTest.cpp @@ -0,0 +1,294 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <gtest/gtest.h> + +#include "voiceagents/VoiceAgentsDataManager.h" + +#include "test/common/ConsoleLogger.h" +#include "test/mocks/AFBApiMock.h" +#include "test/mocks/VoiceAgentsChangeObserverMock.h" +#include "voiceagents/test/VoiceAgentsTestData.h" + +using namespace vshl::common::interfaces; +using namespace vshl::voiceagents; + +using namespace vshl::test::common; + +namespace vshl { +namespace test { + +class VoiceAgentDataManagerTest : public ::testing::Test { +protected: + void SetUp() override { + mConsoleLogger = std::make_shared<ConsoleLogger>(); + mAfbApi = std::make_shared<::testing::NiceMock<AFBApiMock>>(); + mVADataManager = VoiceAgentsDataManager::create(mConsoleLogger, mAfbApi); + + mAgentsChangeObserver = std::make_shared< + ::testing::StrictMock<VoiceAgentsChangeObserverMock>>(); + mVADataManager->addVoiceAgentsChangeObserver(mAgentsChangeObserver); + + mVoiceAgentsData = getVoiceAgentsTestData(); + } + + void TearDown() override { + mVADataManager->removeVoiceAgentsChangeObserver(mAgentsChangeObserver); + } + + static bool addVoiceAgent(VoiceAgentsDataManager &mgr, + VoiceAgentTestData &data) { + return mgr.addNewVoiceAgent(data.id, data.name, data.description, data.api, + data.vendor, data.activeWakeword, data.isActive, + data.wakewords); + } + + static bool isEqual(const VoiceAgentTestData &lhs, const IVoiceAgent &rhs) { + return lhs.id == rhs.getId() && lhs.name == rhs.getName() && + lhs.description == rhs.getDescription() && lhs.api == rhs.getApi() && + lhs.vendor == rhs.getVendor() && + lhs.activeWakeword == rhs.getActiveWakeword() && + lhs.isActive == rhs.isActive() && + *lhs.wakewords == *rhs.getWakeWords(); + } + + static std::shared_ptr<IVoiceAgent> + findVoiceAgent(std::set<std::shared_ptr<IVoiceAgent>> &voiceAgents, + std::string &vaId) { + for (auto va : voiceAgents) { + if (va->getId() == vaId) + return va; + } + + return nullptr; + } + + std::shared_ptr<ConsoleLogger> mConsoleLogger; + + // It is a NiceMock because we don't want gtest to produce warnings about non + // interesting calls. + // The non interesting calls like createEvent is internal implementation + // detail for many of the + // tests in this class, and hence suppression of these warnings with NiceMock. + std::shared_ptr<::testing::NiceMock<AFBApiMock>> mAfbApi; + + // It is a StrictMock because we want to fail the test for all non interesting + // calls. + std::shared_ptr<::testing::StrictMock<VoiceAgentsChangeObserverMock>> + mAgentsChangeObserver; + + std::vector<VoiceAgentTestData> mVoiceAgentsData; + std::unique_ptr<VoiceAgentsDataManager> mVADataManager; +}; + +TEST_F(VoiceAgentDataManagerTest, InitializesCorrectly) { + ASSERT_NE(mVADataManager, nullptr); + ASSERT_EQ(mVADataManager->getAllVoiceAgents().size(), 0); + ASSERT_EQ(mVADataManager->getDefaultVoiceAgent(), std::string()); +} + +TEST_F(VoiceAgentDataManagerTest, addingVoiceAgentWithSameIdFails) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(1); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_FALSE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + + auto allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 1); +} + +TEST_F(VoiceAgentDataManagerTest, + addingVoiceAgentWithNonExistentActiveWakewordFails) { + auto voiceAgetData = mVoiceAgentsData[0]; + voiceAgetData.activeWakeword = "non-existent"; + ASSERT_FALSE(addVoiceAgent(*mVADataManager, voiceAgetData)); + + auto allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 0); +} + +TEST_F(VoiceAgentDataManagerTest, canAddNewVoiceAgents) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + + auto allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 1); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 2); + + for (auto va : allVoiceAgents) { + bool voiceAgentFound = false; + for (auto vaData : mVoiceAgentsData) { + if (isEqual(vaData, *va)) { + voiceAgentFound = true; + break; + } + } + ASSERT_TRUE(voiceAgentFound); + } +} + +TEST_F(VoiceAgentDataManagerTest, removingUnknonwVoiceAgentFails) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(1); + + ASSERT_FALSE(mVADataManager->removeVoiceAgent("non-existent-vaid")); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_FALSE(mVADataManager->removeVoiceAgent("non-existent-vaid")); +} + +TEST_F(VoiceAgentDataManagerTest, canRemoveVoiceAgents) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentRemoved(::testing::_)) + .Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + auto allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 2); + + ASSERT_TRUE(mVADataManager->removeVoiceAgent(mVoiceAgentsData[0].id)); + + allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 1); + + ASSERT_TRUE(mVADataManager->removeVoiceAgent(mVoiceAgentsData[1].id)); + + allVoiceAgents = mVADataManager->getAllVoiceAgents(); + ASSERT_EQ(allVoiceAgents.size(), 0); +} + +TEST_F(VoiceAgentDataManagerTest, activatingNonExistentVoiceAgentsFails) { + uint32_t result = mVADataManager->activateVoiceAgents({"non", "existent"}); + ASSERT_EQ(result, 0); + + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + result = mVADataManager->activateVoiceAgents({"non", "existent"}); + ASSERT_EQ(result, 0); +} + +TEST_F(VoiceAgentDataManagerTest, deactivatingNonExistentVoiceAgentsFails) { + uint32_t result = mVADataManager->deactivateVoiceAgents({"non", "existent"}); + ASSERT_EQ(result, 0); + + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + result = mVADataManager->deactivateVoiceAgents({"non", "existent"}); + ASSERT_EQ(result, 0); +} + +TEST_F(VoiceAgentDataManagerTest, canActivateDeactivateVoiceAgents) { + { + ::testing::InSequence dummy; + + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)) + .Times(2); + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentDeactivated(::testing::_)) + .Times(1); + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentActivated(::testing::_)) + .Times(1); + } + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + std::string vaId = mVoiceAgentsData[0].id; + + auto allVA = mVADataManager->getAllVoiceAgents(); + auto voiceAgent = findVoiceAgent(allVA, vaId); + ASSERT_NE(voiceAgent, nullptr); + ASSERT_TRUE(voiceAgent->isActive()); + + uint32_t result = + mVADataManager->deactivateVoiceAgents({"non-existent", vaId}); + ASSERT_EQ(result, 1); + ASSERT_FALSE(voiceAgent->isActive()); + + // Try de-activating already de-activated agent + result = mVADataManager->deactivateVoiceAgents({vaId}); + ASSERT_EQ(result, 1); + ASSERT_FALSE(voiceAgent->isActive()); + + result = mVADataManager->activateVoiceAgents({"non-existent", vaId}); + ASSERT_EQ(result, 1); + ASSERT_TRUE(voiceAgent->isActive()); + + // Try activating already activated agent + result = mVADataManager->activateVoiceAgents({vaId}); + ASSERT_EQ(result, 1); + ASSERT_TRUE(voiceAgent->isActive()); +} + +TEST_F(VoiceAgentDataManagerTest, + NoDefaultAgentIsReturnedWhenNoDefaultAgentIsSet) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + std::string defaultAgentId = mVADataManager->getDefaultVoiceAgent(); + ASSERT_EQ(defaultAgentId, ""); +} + +TEST_F(VoiceAgentDataManagerTest, DefaultAgentCanBeSet) { + EXPECT_CALL(*mAgentsChangeObserver, OnVoiceAgentAdded(::testing::_)).Times(2); + + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[0])); + ASSERT_TRUE(addVoiceAgent(*mVADataManager, mVoiceAgentsData[1])); + + auto allAgents = mVADataManager->getAllVoiceAgents(); + std::string vaId1 = mVoiceAgentsData[1].id; + std::string vaId2 = mVoiceAgentsData[0].id; + auto va1 = findVoiceAgent(allAgents, vaId1); + auto va2 = findVoiceAgent(allAgents, vaId2); + + { + ::testing::InSequence dummy; + + EXPECT_CALL(*mAgentsChangeObserver, OnDefaultVoiceAgentChanged(va1)) + .Times(1); + EXPECT_CALL(*mAgentsChangeObserver, OnDefaultVoiceAgentChanged(va2)) + .Times(1); + } + + ASSERT_TRUE(mVADataManager->setDefaultVoiceAgent(vaId1)); + ASSERT_EQ(mVADataManager->getDefaultVoiceAgent(), vaId1); + + ASSERT_TRUE(mVADataManager->setDefaultVoiceAgent(vaId2)); + ASSERT_EQ(mVADataManager->getDefaultVoiceAgent(), vaId2); + + ASSERT_FALSE(mVADataManager->setDefaultVoiceAgent("non-existent")); + ASSERT_EQ(mVADataManager->getDefaultVoiceAgent(), vaId2); + + // Setting default agent to already default agent shouldn't result in extra + // callback to OnDefaultVoiceAgentChanged + ASSERT_TRUE(mVADataManager->setDefaultVoiceAgent(vaId2)); + ASSERT_EQ(mVADataManager->getDefaultVoiceAgent(), vaId2); +} + +} // namespace test +} // namespace vshl
\ No newline at end of file diff --git a/src/plugins/voiceagents/test/VoiceAgentsTestData.h b/src/plugins/voiceagents/test/VoiceAgentsTestData.h new file mode 100644 index 0000000..ced068f --- /dev/null +++ b/src/plugins/voiceagents/test/VoiceAgentsTestData.h @@ -0,0 +1,67 @@ +/* + * Copyright 2018-2019 Amazon.com, Inc. or its affiliates. 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. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0/ + * + * or in the "license" file accompanying this file. This file 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 <memory> +#include <string> +#include <unordered_set> +#include <vector> + +namespace vshl { +namespace test { + +typedef std::shared_ptr<std::unordered_set<std::string>> WakeWords; + +struct VoiceAgentTestData { + std::string id; + std::string name; + std::string description; + std::string api; + std::string vendor; + std::string activeWakeword; + bool isActive; + WakeWords wakewords; +}; + +static std::vector<VoiceAgentTestData> getVoiceAgentsTestData() { + std::vector<VoiceAgentTestData> voiceAgentsTestData{ + { + "VA-001", // Id + "Foundation", // Name + "Voice Agent For Galactic Empire", // Description + "api-1", // API + "Asimov", // Vendor + "Hari Seldon", // Active Wakeword + true, // Is Active + std::shared_ptr<std::unordered_set<std::string>>( + new std::unordered_set<std::string>{"Hari Seldon", "Cleon I ", "Eto Demerzel"}) // Wake Words + }, + { + "VA-002", // Id + "Betelgeuse", // Name + "Voice Agent For Galaxy hopper", // Description + "api-2", // API + "Douglas Adams", // Vendor + "Ford Prefect", // Active Wakeword + true, // Is Active + std::shared_ptr<std::unordered_set<std::string>>( + new std::unordered_set<std::string>{"Ford Prefect", "Zaphod Beeblebrox"}) // Wake Words + }, + }; + + return voiceAgentsTestData; +} + +} // namespace test +} // namespace vshl |