ContextManager.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_CONTEXTMANAGER_INCLUDE_CONTEXTMANAGER_CONTEXTMANAGER_H_
#define ALEXA_CLIENT_SDK_CONTEXTMANAGER_INCLUDE_CONTEXTMANAGER_CONTEXTMANAGER_H_

#include <atomic>
#include <list>
#include <memory>
#include <utility>
#include <mutex>
#include <unordered_map>
#include <unordered_set>

#include <AVSCommon/AVS/CapabilityTag.h>
#include <AVSCommon/AVS/StateRefreshPolicy.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/ContextRequesterInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h>
#include <AVSCommon/SDKInterfaces/StateProviderInterface.h>
#include <AVSCommon/Utils/DeviceInfo.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/MultiTimer.h>

namespace alexaClientSDK {
namespace contextManager {

class ContextManager : public avsCommon::sdkInterfaces::ContextManagerInterface {
public:
    static std::shared_ptr<ContextManagerInterface> createContextManagerInterface(
        const std::shared_ptr<avsCommon::utils::DeviceInfo>& deviceInfo,
        const std::shared_ptr<avsCommon::utils::timing::MultiTimer>& multiTimer =
            std::make_shared<avsCommon::utils::timing::MultiTimer>(),
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder = nullptr);

    static std::shared_ptr<ContextManager> create(
        const avsCommon::utils::DeviceInfo& deviceInfo,
        std::shared_ptr<avsCommon::utils::timing::MultiTimer> multiTimer =
            std::make_shared<avsCommon::utils::timing::MultiTimer>(),
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr);

    ~ContextManager() override;

    void setStateProvider(
        const avsCommon::avs::CapabilityTag& stateProviderName,
        std::shared_ptr<avsCommon::sdkInterfaces::StateProviderInterface> stateProvider) override;

    void addStateProvider(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        std::shared_ptr<avsCommon::sdkInterfaces::StateProviderInterface> stateProvider) override;

    void removeStateProvider(const avsCommon::avs::CapabilityTag& capabilityIdentifier) override;

    avsCommon::sdkInterfaces::SetStateResult setState(
        const avsCommon::avs::CapabilityTag& stateProviderName,
        const std::string& jsonState,
        const avsCommon::avs::StateRefreshPolicy& refreshPolicy,
        const avsCommon::sdkInterfaces::ContextRequestToken stateRequestToken = 0) override;

    avsCommon::sdkInterfaces::ContextRequestToken getContext(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextRequesterInterface> contextRequester,
        const std::string& endpointId,
        const std::chrono::milliseconds& timeout) override;

    avsCommon::sdkInterfaces::ContextRequestToken getContextWithoutReportableStateProperties(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextRequesterInterface> contextRequester,
        const std::string& endpointId,
        const std::chrono::milliseconds& timeout) override;

    void reportStateChange(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        const avsCommon::avs::CapabilityState& capabilityState,
        avsCommon::sdkInterfaces::AlexaStateChangeCauseType cause) override;

    void provideStateResponse(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        const avsCommon::avs::CapabilityState& capabilityState,
        avsCommon::sdkInterfaces::ContextRequestToken stateRequestToken) override;

    void provideStateUnavailableResponse(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        avsCommon::sdkInterfaces::ContextRequestToken stateRequestToken,
        bool isEndpointUnreachable) override;

    void addContextManagerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerObserverInterface> observer) override;

    void removeContextManagerObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerObserverInterface>& observer) override;

private:  // Private type declarations.
    struct StateInfo {
        std::shared_ptr<avsCommon::sdkInterfaces::StateProviderInterface> stateProvider;

        avsCommon::utils::Optional<avsCommon::avs::CapabilityState> capabilityState;

        bool legacyCapability;

        avsCommon::avs::StateRefreshPolicy refreshPolicy;

        StateInfo(
            std::shared_ptr<avsCommon::sdkInterfaces::StateProviderInterface> initStateProvider = nullptr,
            const std::string& initJsonState = "",
            avsCommon::avs::StateRefreshPolicy initRefreshPolicy = avsCommon::avs::StateRefreshPolicy::ALWAYS);

        StateInfo(
            std::shared_ptr<avsCommon::sdkInterfaces::StateProviderInterface> initStateProvider,
            const avsCommon::utils::Optional<avsCommon::avs::CapabilityState>& initCapabilityState);

        StateInfo(const StateInfo&) = default;
    };

    using CapabilitiesState = std::unordered_map<avsCommon::avs::CapabilityTag, StateInfo>;

    using EndpointIdentifier = avsCommon::sdkInterfaces::endpoints::EndpointIdentifier;

    struct RequestTracker {
        const avsCommon::utils::timing::MultiTimer::Token timerToken;
        const std::shared_ptr<avsCommon::sdkInterfaces::ContextRequesterInterface> contextRequester;
        const bool skipReportableStateProperties;

        RequestTracker(
            avsCommon::utils::timing::MultiTimer::Token timerToken,
            std::shared_ptr<avsCommon::sdkInterfaces::ContextRequesterInterface> contextRequester,
            bool skipReportableProperties);
    };

private:  // Private method declarations.
    ContextManager(
        const std::string& defaultEndpointId,
        std::shared_ptr<avsCommon::utils::timing::MultiTimer> multiTimer,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder);

    void updateCapabilityState(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        const std::string& jsonState,
        const avsCommon::avs::StateRefreshPolicy& refreshPolicy);

    void updateCapabilityState(
        const avsCommon::avs::CapabilityTag& capabilityIdentifier,
        const avsCommon::avs::CapabilityState& capabilityState);

    avsCommon::sdkInterfaces::ContextRequestToken getContextInternal(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextRequesterInterface> contextRequester,
        const std::string& endpointId,
        const std::chrono::milliseconds& timeout,
        bool skipReportableStateProperties);

    std::function<void()> getContextAvailableCallbackIfReadyLocked(
        avsCommon::sdkInterfaces::ContextRequestToken requestToken,
        const avsCommon::sdkInterfaces::endpoints::EndpointIdentifier& endpointId);

    std::function<void()> getContextFailureCallbackLocked(
        avsCommon::sdkInterfaces::ContextRequestToken requestToken,
        avsCommon::sdkInterfaces::ContextRequestError error);

    inline avsCommon::sdkInterfaces::ContextRequestToken generateToken();

private:  // Member variable declarations
    std::mutex m_endpointsStateMutex;

    std::unordered_map<EndpointIdentifier, CapabilitiesState> m_endpointsState;

    std::mutex m_requestsMutex;

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

    std::atomic<unsigned int> m_requestCounter;

    std::unordered_map<unsigned int, std::unordered_set<avsCommon::avs::CapabilityTag>> m_pendingStateRequest;

    std::unordered_map<avsCommon::sdkInterfaces::ContextRequestToken, RequestTracker> m_pendingRequests;

    std::mutex m_observerMutex;

    std::list<std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerObserverInterface>> m_observers;

    std::atomic_bool m_shutdown;

    const std::string m_defaultEndpointId;

    std::shared_ptr<avsCommon::utils::timing::MultiTimer> m_multiTimer;

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

}  // namespace contextManager
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_CONTEXTMANAGER_INCLUDE_CONTEXTMANAGER_CONTEXTMANAGER_H_