CapabilitiesDelegate.h

Go to the documentation of this file.

/*
 * Copyright 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 ALEXA_CLIENT_SDK_CAPABILITIESDELEGATE_INCLUDE_CAPABILITIESDELEGATE_CAPABILITIESDELEGATE_H_
#define ALEXA_CLIENT_SDK_CAPABILITIESDELEGATE_INCLUDE_CAPABILITIESDELEGATE_CAPABILITIESDELEGATE_H_
 
#include <unordered_map>
#include <memory>
#include <mutex>
#include <string>
 
#include "CapabilitiesDelegate/DiscoveryEventSender.h"
#include "CapabilitiesDelegate/Storage/CapabilitiesDelegateStorageInterface.h"
 
#include <acsdkAlexaEventProcessedNotifierInterfaces/AlexaEventProcessedNotifierInterface.h>
#include <acsdkPostConnectOperationProviderRegistrarInterfaces/PostConnectOperationProviderRegistrarInterface.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/AVS/AVSDiscoveryEndpointAttributes.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/SDKInterfaces/AuthDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ConnectionStatusObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h>
#include <AVSCommon/SDKInterfaces/PostConnectOperationProviderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <RegistrationManager/CustomerDataHandler.h>
#include <RegistrationManager/CustomerDataManagerInterface.h>
 
namespace alexaClientSDK {
namespace capabilitiesDelegate {
 
struct InProcessEndpointsToConfigMapStruct {
    std::unordered_map<std::string, std::string> pending;
 
    std::unordered_map<std::string, std::string> inFlight;
};
 
class CapabilitiesDelegate
        : public avsCommon::sdkInterfaces::CapabilitiesDelegateInterface
        , public avsCommon::utils::RequiresShutdown
        , public avsCommon::sdkInterfaces::PostConnectOperationProviderInterface
        , public DiscoveryStatusObserverInterface
        , public registrationManager::CustomerDataHandler
        , public std::enable_shared_from_this<CapabilitiesDelegate> {
public:
    static std::shared_ptr<CapabilitiesDelegateInterface> createCapabilitiesDelegateInterface(
        const std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface>& authDelegate,
        std::unique_ptr<storage::CapabilitiesDelegateStorageInterface> storage,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& customerDataManager,
        const std::shared_ptr<
            acsdkPostConnectOperationProviderRegistrarInterfaces::PostConnectOperationProviderRegistrarInterface>&
            providerRegistrar,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier,
        const std::shared_ptr<acsdkAlexaEventProcessedNotifierInterfaces::AlexaEventProcessedNotifierInterface>&
            alexaEventProcessedNotifier);
 
    static std::shared_ptr<CapabilitiesDelegate> create(
        const std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface>& authDelegate,
        const std::shared_ptr<storage::CapabilitiesDelegateStorageInterface>& storage,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& customerDataManager);
 
    bool addOrUpdateEndpoint(
        const avsCommon::avs::AVSDiscoveryEndpointAttributes& endpointAttributes,
        const std::vector<avsCommon::avs::CapabilityConfiguration>& capabilities) override;
 
    bool deleteEndpoint(
        const avsCommon::avs::AVSDiscoveryEndpointAttributes& endpointAttributes,
        const std::vector<avsCommon::avs::CapabilityConfiguration>& capabilities) override;
 
    void addCapabilitiesObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface> observer) override;
 
    void removeCapabilitiesObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface> observer) override;
 
    void invalidateCapabilities() override;
 
    void setMessageSender(
        const std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface>& messageSender) override;
 
    void onAlexaEventProcessedReceived(const std::string& eventCorrelationToken) override;
 
    void doShutdown() override;
 
    std::shared_ptr<avsCommon::sdkInterfaces::PostConnectOperationInterface> createPostConnectOperation() override;
 
    void onDiscoveryCompleted(
        const std::unordered_map<std::string, std::string>& addOrUpdateReportEndpoints,
        const std::unordered_map<std::string, std::string>& deleteReportEndpoints) override;
    void onDiscoveryFailure(avsCommon::sdkInterfaces::MessageRequestObserverInterface::Status status) override;
 
    void onAVSGatewayChanged(const std::string& avsGateway) override;
 
    void clearData() override;
 
    void onConnectionStatusChanged(const Status status, const ChangedReason reason) override;
 
    void setDiscoveryEventSender(const std::shared_ptr<DiscoveryEventSenderInterface>& discoveryEventSender);
 
private:
    CapabilitiesDelegate(
        const std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface>& authDelegate,
        const std::shared_ptr<storage::CapabilitiesDelegateStorageInterface>& storage,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& customerDataManager);
 
    bool init();
 
    std::string getAuthToken();
 
    void setCapabilitiesState(
        const avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface::State newState,
        const avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface::Error newError,
        const std::vector<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier>& addOrUpdateReportEndpoints,
        const std::vector<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier>& deleteReportEndpoints);
 
    bool updateEndpointConfigInStorage(
        const std::unordered_map<std::string, std::string>& addOrUpdateReportEndpoints,
        const std::unordered_map<std::string, std::string>& deleteReportEndpoints);
 
    void resetCurrentDiscoveryEventSender();
 
    void resetDiscoveryEventSender(const std::shared_ptr<DiscoveryEventSenderInterface>& sender);
 
    void executeSendPendingEndpoints();
 
    bool isShuttingDown();
 
    void addStaleEndpointsToPendingDeleteLocked(std::unordered_map<std::string, std::string>* storedEndpointConfig);
 
    void filterUnchangedPendingAddOrUpdateEndpointsLocked(
        std::unordered_map<std::string, std::string>* storedEndpointConfig);
 
    void moveInFlightEndpointsToPendingLocked();
 
    void moveInFlightEndpointsToPending();
 
    void moveInFlightEndpointsToRegisteredEndpoints();
 
    std::mutex m_observerMutex;
 
    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface>>
        m_capabilitiesObservers;
 
    avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface::State m_capabilitiesState;
 
    avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface::Error m_capabilitiesError;
 
    std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;
 
    std::shared_ptr<storage::CapabilitiesDelegateStorageInterface> m_capabilitiesDelegateStorage;
 
    std::mutex m_isConnectedMutex;
 
    bool m_isConnected;
 
    std::mutex m_endpointsMutex;
 
    InProcessEndpointsToConfigMapStruct m_addOrUpdateEndpoints;
 
    InProcessEndpointsToConfigMapStruct m_deleteEndpoints;
 
    std::unordered_map<std::string, std::string> m_endpoints;
 
    std::mutex m_currentDiscoveryEventSenderMutex;
 
    std::shared_ptr<DiscoveryEventSenderInterface> m_currentDiscoveryEventSender;
 
    std::mutex m_messageSenderMutex;
 
    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;
 
    std::mutex m_isShuttingDownMutex;
 
    bool m_isShuttingDown;
 
    avsCommon::utils::threading::Executor m_executor;
};
 
}  // namespace capabilitiesDelegate
}  // namespace alexaClientSDK
 
#endif  // ALEXA_CLIENT_SDK_CAPABILITIESDELEGATE_INCLUDE_CAPABILITIESDELEGATE_CAPABILITIESDELEGATE_H_