EndpointRegistrationManager.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_ENDPOINTS_INCLUDE_ENDPOINTS_ENDPOINTREGISTRATIONMANAGER_H_
#define ALEXA_CLIENT_SDK_ENDPOINTS_INCLUDE_ENDPOINTS_ENDPOINTREGISTRATIONMANAGER_H_

#include <functional>
#include <future>
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <utility>

#include <AVSCommon/SDKInterfaces/AVSConnectionManagerInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/DirectiveHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/DirectiveSequencerInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointRegistrationManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointRegistrationObserverInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/RequiresShutdown.h>

namespace alexaClientSDK {
namespace endpoints {

class EndpointRegistrationManager
        : public avsCommon::sdkInterfaces::endpoints::EndpointRegistrationManagerInterface
        , public avsCommon::utils::RequiresShutdown {
public:
    using EndpointIdentifier = avsCommon::sdkInterfaces::endpoints::EndpointIdentifier;
    using EndpointInterface = avsCommon::sdkInterfaces::endpoints::EndpointInterface;
    using EndpointModificationData = avsCommon::sdkInterfaces::endpoints::EndpointModificationData;
    using EndpointRegistrationObserverInterface =
        avsCommon::sdkInterfaces::endpoints::EndpointRegistrationObserverInterface;

    ~EndpointRegistrationManager();

    static std::unique_ptr<EndpointRegistrationManager> create(
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface> directiveSequencer,
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> capabilitiesDelegate,
        const EndpointIdentifier& defaultEndpointId);

    void waitForPendingRegistrationsToEnqueue();

    std::future<RegistrationResult> registerEndpoint(std::shared_ptr<EndpointInterface> endpoint) override;
    std::future<UpdateResult> updateEndpoint(
        const EndpointIdentifier& endpointId,
        const std::shared_ptr<EndpointModificationData>& endpointModificationData) override;
    std::future<DeregistrationResult> deregisterEndpoint(const EndpointIdentifier& endpointId) override;
    void addObserver(std::shared_ptr<EndpointRegistrationObserverInterface> observer) override;
    void removeObserver(const std::shared_ptr<EndpointRegistrationObserverInterface>& observer) override;

protected:
    void doShutdown() override;

private:
    using PendingRegistration = std::pair<std::shared_ptr<EndpointInterface>, std::promise<RegistrationResult>>;

    using PendingDeregistration = std::pair<std::shared_ptr<EndpointInterface>, std::promise<DeregistrationResult>>;

    using PendingUpdate = std::pair<std::shared_ptr<EndpointInterface>, std::promise<UpdateResult>>;

    class CapabilityRegistrationProxy : public avsCommon::sdkInterfaces::CapabilitiesDelegateObserverInterface {
    public:
        void setCallback(
            std::function<void(
                const std::pair<CapabilitiesDelegateObserverInterface::State, std::vector<EndpointIdentifier>>&
                    addedOrUpdatedEndpoints,
                const std::pair<CapabilitiesDelegateObserverInterface::State, std::vector<EndpointIdentifier>>&
                    deletedEndpoints)> callback);

        void onCapabilitiesStateChange(
            State newState,
            Error newError,
            const std::vector<EndpointIdentifier>& addedOrUpdatedEndpointIds,
            const std::vector<EndpointIdentifier>& deletedEndpointIds) override;
    private:
        // The function callback.
        std::function<void(
            const std::pair<CapabilitiesDelegateObserverInterface::State, std::vector<EndpointIdentifier>>&
                addedOrUpdatedEndpoints,
            const std::pair<CapabilitiesDelegateObserverInterface::State, std::vector<EndpointIdentifier>>&
                deletedEndpoints)>
            m_callback;
    };

    EndpointRegistrationManager(
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface> directiveSequencer,
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> capabilitiesDelegate,
        const EndpointIdentifier& defaultEndpointId);

    void executeRegisterEndpoint(const std::shared_ptr<EndpointInterface>& endpoint);

    void executeUpdateEndpoint(
        const std::shared_ptr<EndpointInterface>& endpoint,
        const std::shared_ptr<EndpointModificationData>& endpointModificationData);

    void executeDeregisterEndpoint(const std::shared_ptr<EndpointInterface>& endpoint);

    bool addCapabilities(
        const std::shared_ptr<EndpointInterface>& endpoint,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>>* handlersAdded);

    bool addCapability(
        const std::shared_ptr<EndpointInterface>& endpoint,
        const std::pair<
            avsCommon::avs::CapabilityConfiguration,
            std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>> capability,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>>* handlersAdded);

    bool addCapabilities(const std::shared_ptr<EndpointInterface>& endpoint);

    bool removeCapabilities(
        const std::shared_ptr<EndpointInterface>& endpoint,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>>* handlersRemoved);

    bool removeCapability(
        const std::shared_ptr<EndpointInterface>& endpoint,
        const std::pair<
            avsCommon::avs::CapabilityConfiguration,
            std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>> capability,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerInterface>>* handlersRemoved);

    bool removeCapabilities(const std::shared_ptr<EndpointInterface>& endpoint);

    void updateAddedOrUpdatedEndpoints(
        const std::pair<CapabilityRegistrationProxy::State, std::vector<EndpointIdentifier>>& addedOrUpdatedEndpoints);

    void removeDeletedEndpoints(
        const std::pair<CapabilityRegistrationProxy::State, std::vector<EndpointIdentifier>>& deletedEndpoints);

    void onCapabilityRegistrationStatusChanged(
        const std::pair<CapabilityRegistrationProxy::State, std::vector<EndpointIdentifier>>& addedOrUpdatedEndpoints,
        const std::pair<CapabilityRegistrationProxy::State, std::vector<EndpointIdentifier>>& deletedEndpoints);

    mutable std::mutex m_observersMutex;

    std::list<std::shared_ptr<EndpointRegistrationObserverInterface>> m_observers;

    std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface> m_directiveSequencer;

    std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> m_capabilitiesDelegate;

    mutable std::mutex m_endpointsMutex;

    std::unordered_map<EndpointIdentifier, std::shared_ptr<EndpointInterface>> m_endpoints;

    std::unordered_map<EndpointIdentifier, PendingRegistration> m_pendingRegistrations;

    std::unordered_map<EndpointIdentifier, PendingDeregistration> m_pendingDeregistrations;

    std::unordered_map<EndpointIdentifier, PendingUpdate> m_pendingUpdates;

    const EndpointIdentifier m_defaultEndpointId;

    std::shared_ptr<CapabilityRegistrationProxy> m_capabilityRegistrationProxy;

    avsCommon::utils::threading::Executor m_executor;
};

}  // namespace endpoints
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ENDPOINTS_INCLUDE_ENDPOINTS_ENDPOINTREGISTRATIONMANAGER_H_