BaseAPLCapabilityAgent.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Amazon Software License (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     https://aws.amazon.com/asl/
 *
 * 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 ACSDK_APLCAPABILITYCOMMON_BASEAPLCAPABILITYAGENT_H_
#define ACSDK_APLCAPABILITYCOMMON_BASEAPLCAPABILITYAGENT_H_

#include <chrono>
#include <map>
#include <memory>
#include <queue>
#include <string>
#include <unordered_set>

#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Metrics/DataPointDurationBuilder.h>
#include <AVSCommon/Utils/Metrics/DataPointCounterBuilder.h>
#include <AVSCommon/Utils/Optional.h>
#include <acsdk/Notifier/Notifier.h>

#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentNotifierInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentObserverInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/PresentationSession.h>
#include <acsdk/APLCapabilityCommonInterfaces/VisualStateProviderInterface.h>

namespace alexaClientSDK {
namespace aplCapabilityCommon {
class BaseAPLCapabilityAgent
        : public alexaClientSDK::avsCommon::avs::CapabilityAgent
        , public alexaClientSDK::avsCommon::utils::RequiresShutdown
        , public alexaClientSDK::avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public alexaClientSDK::aplCapabilityCommonInterfaces::APLCapabilityAgentInterface
        , public alexaClientSDK::notifier::Notifier<aplCapabilityCommonInterfaces::APLCapabilityAgentObserverInterface>
        , public std::enable_shared_from_this<BaseAPLCapabilityAgent> {
public:
    BaseAPLCapabilityAgent(
        const std::string& avsNamespace,
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<alexaClientSDK::avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder,
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        const std::string& APLMaxVersion,
        std::shared_ptr<alexaClientSDK::aplCapabilityCommonInterfaces::VisualStateProviderInterface>
            visualStateProvider = nullptr);

    virtual ~BaseAPLCapabilityAgent() = default;

    void handleDirectiveImmediately(std::shared_ptr<alexaClientSDK::avsCommon::avs::AVSDirective> directive) override;
    void preHandleDirective(std::shared_ptr<DirectiveInfo> info) override;
    void handleDirective(std::shared_ptr<DirectiveInfo> info) override;
    void cancelDirective(std::shared_ptr<DirectiveInfo> info) override;
    alexaClientSDK::avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;

    std::unordered_set<std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityConfiguration>>
    getCapabilityConfigurations() override;

    void onContextAvailable(const std::string& jsonContext) override;
    void onContextFailure(const alexaClientSDK::avsCommon::sdkInterfaces::ContextRequestError error) override;

    void provideState(
        const alexaClientSDK::avsCommon::avs::NamespaceAndName& stateProviderName,
        unsigned int stateRequestToken) override;

    // @name RequiresShutdown Functions
    void doShutdown() override;

    void onActiveDocumentChanged(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const alexaClientSDK::aplCapabilityCommonInterfaces::PresentationSession& session) override;
    void clearExecuteCommands(
        const aplCapabilityCommonInterfaces::PresentationToken& token = std::string(),
        const bool markAsFailed = true) override;
    void sendUserEvent(const aplCapabilityCommonInterfaces::aplEventPayload::UserEvent& eventPayload) override;
    void sendDataSourceFetchRequestEvent(
        const aplCapabilityCommonInterfaces::aplEventPayload::DataSourceFetch& fetchPayload) override;
    void sendRuntimeErrorEvent(const aplCapabilityCommonInterfaces::aplEventPayload::RuntimeError& errors) override;
    void onVisualContextAvailable(
        avsCommon::sdkInterfaces::ContextRequestToken requestToken,
        const aplCapabilityCommonInterfaces::aplEventPayload::VisualContext& context) override;
    void processRenderDocumentResult(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const bool result,
        const std::string& error) override;
    void processExecuteCommandsResult(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        aplCapabilityCommonInterfaces::APLCommandExecutionEvent event,
        const std::string& error) override;
    void recordRenderComplete(const std::chrono::steady_clock::time_point& timestamp) override;
    void proactiveStateReport() override;

    virtual bool initialize();


    void setExecutor(const std::shared_ptr<alexaClientSDK::avsCommon::utils::threading::Executor>& executor);

protected:
    enum class DirectiveType {
        RENDER_DOCUMENT,

        SHOW_DOCUMENT,

        EXECUTE_COMMAND,

        DYNAMIC_TOKEN_DATA_SOURCE_UPDATE,

        DYNAMIC_INDEX_DATA_SOURCE_UPDATE,

        UNKNOWN
    };

    enum class MetricEvent {
        RENDER_DOCUMENT
    };

    enum class MetricActivity {
        ACTIVITY_RENDER_DOCUMENT,

        ACTIVITY_RENDER_DOCUMENT_FAIL,
    };

    struct PresentationSessionFieldNames {
        std::string skillId;
        std::string presentationSessionId;
    };


    virtual alexaClientSDK::avsCommon::avs::DirectiveHandlerConfiguration getAPLDirectiveConfiguration() const = 0;

    virtual std::unordered_set<std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityConfiguration>>
    getAPLCapabilityConfigurations(const std::string& APLMaxVersion) = 0;

    virtual DirectiveType getDirectiveType(std::shared_ptr<DirectiveInfo> info) = 0;

    virtual const std::string& getConfigurationRootKey() = 0;

    virtual const std::string& getMetricDataPointName(MetricEvent event) = 0;

    virtual const std::string& getMetricActivityName(MetricActivity activity) = 0;

    virtual PresentationSessionFieldNames getPresentationSessionFieldNames() = 0;

    virtual const bool shouldPackPresentationSessionToAvsEvents() = 0;

    void handleUnknownDirective(std::shared_ptr<DirectiveInfo> info);

    void setHandlingCompleted(std::shared_ptr<DirectiveInfo> info);

    std::shared_ptr<alexaClientSDK::avsCommon::utils::threading::Executor> getExecutor();

private:
    void removeDirective(std::shared_ptr<DirectiveInfo> info);

    void handleRenderDocumentDirective(std::shared_ptr<DirectiveInfo> info);

    void handleShowDocumentDirective(std::shared_ptr<DirectiveInfo> info);

    void handleExecuteCommandDirective(std::shared_ptr<DirectiveInfo> info);

    void handleDynamicListDataDirective(std::shared_ptr<DirectiveInfo> info, const std::string& sourceType);

    void executeExecuteCommand(std::shared_ptr<DirectiveInfo> info);

    void executeDataSourceUpdate(std::shared_ptr<DirectiveInfo> info, const std::string& sourceType);

    void executeRenderDocument(
        const std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> info);

    void executeClearExecuteCommands(
        const std::string& reason,
        const aplCapabilityCommonInterfaces::PresentationToken& token = std::string(),
        const bool markAsFailed = true);

    void executeSendEvent(const std::string& avsNamespace, const std::string& name, const std::string& payload);

    void executeProvideState(unsigned int stateRequestToken);

    void executeProactiveStateReport();

    void executeOnVisualContextAvailable(
        const avsCommon::sdkInterfaces::ContextRequestToken requestToken,
        const aplCapabilityCommonInterfaces::aplEventPayload::VisualContext& context);

    void addPresentationSessionPayload(rapidjson::Document* document);

    std::string getPresentationSessionPayload();

    std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> m_lastDisplayedDirective;

    std::pair<std::string, std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo>>
        m_lastExecuteCommandTokenAndDirective;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;

    aplCapabilityCommonInterfaces::PresentationToken m_lastRenderedAPLToken;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;

    std::shared_ptr<alexaClientSDK::aplCapabilityCommonInterfaces::VisualStateProviderInterface> m_visualStateProvider;

    std::queue<std::tuple<std::string, std::string, std::string>> m_events;

    const std::string m_APLVersion;

    void startMetricsEvent(MetricEvent metricEvent);

    void endMetricsEvent(
        MetricEvent metricEvent,
        MetricActivity activity,
        const std::chrono::steady_clock::time_point& timestamp);

    void resetMetricsEvent(MetricEvent metricEvent);

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

    std::mutex m_MetricsRecorderMutex;

    std::map<MetricEvent, std::chrono::steady_clock::time_point> m_currentActiveTimePoints;

    std::string m_lastReportedState;

    std::chrono::time_point<std::chrono::steady_clock> m_lastReportTime;

    std::chrono::milliseconds m_minStateReportInterval{};

    std::chrono::milliseconds m_stateReportCheckInterval{};

    bool m_stateReportPending;

    alexaClientSDK::avsCommon::utils::timing::Timer m_proactiveStateTimer;

    bool m_documentRendered;

    alexaClientSDK::aplCapabilityCommonInterfaces::PresentationSession m_presentationSession;

    std::chrono::steady_clock::time_point m_renderReceivedTime;

    const std::string m_avsNamespace;

    const alexaClientSDK::avsCommon::avs::NamespaceAndName m_visualContextHeader;

    std::shared_ptr<alexaClientSDK::avsCommon::utils::threading::Executor> m_executor;
};

}  // namespace aplCapabilityCommon
}  // namespace alexaClientSDK

#endif  // ACSDK_APLCAPABILITYCOMMON_BASEAPLCAPABILITYAGENT_H_