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,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder = nullptr);

    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,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder = nullptr);

    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,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricsRecorder);

    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();

    bool executeSendDiscoveryEvents(
        const std::unordered_map<std::string, std::string>& addOrUpdateEndpointsToSend,
        const std::unordered_map<std::string, std::string>& deleteEndpointsToSend);

    bool isEndpointDeduplicated(const avsCommon::sdkInterfaces::endpoints::EndpointIdentifier& endpointId);

    std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;

    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::unordered_map<
        avsCommon::sdkInterfaces::endpoints::EndpointIdentifier,
        avsCommon::utils::Optional<avsCommon::avs::AVSDiscoveryEndpointAttributes::Registration>>
        m_endpointRegistrations;

    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_