APLRuntimePresentationAdapter.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_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_ALEXAPRESENTATION_APLRUNTIMEPRESENTATIONADAPTER_H_
#define ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_ALEXAPRESENTATION_APLRUNTIMEPRESENTATIONADAPTER_H_

#include <string>

#include <rapidjson/document.h>
#include <rapidjson/writer.h>

#include <acsdk/AlexaPresentationInterfaces/AlexaPresentationCapabilityAgentInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/VisualStateProviderInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentObserverInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLDocumentObserverInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLTimeoutType.h>
#include <acsdk/APLCapabilityCommonInterfaces/PresentationOptions.h>
#include <acsdk/APLCapabilityCommonInterfaces/PresentationToken.h>
#include <AVSCommon/AVS/PlayerActivity.h>
#include <AVSCommon/SDKInterfaces/DialogUXStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/GUIActivityEvent.h>
#include <AVSCommon/SDKInterfaces/GUIActivityEventObserverInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include "IPCServerSampleApp/GUI/GUIActivityEventNotifierInterface.h"

#include "IPCServerSampleApp/AlexaPresentation/APLDocumentSessionManager.h"
#include "IPCServerSampleApp/AlexaPresentation/APLRuntimeInterfaceImpl.h"

namespace alexaClientSDK {
namespace sampleApplications {
namespace ipcServerSampleApp {

class APLRuntimePresentationAdapter
        : public aplCapabilityCommonInterfaces::APLCapabilityAgentObserverInterface
        , public avsCommon::sdkInterfaces::DialogUXStateObserverInterface
        , public avsCommon::sdkInterfaces::GUIActivityEventObserverInterface
        , public aplCapabilityCommonInterfaces::VisualStateProviderInterface
        , public aplCapabilityCommonInterfaces::APLDocumentObserverInterface
        , public std::enable_shared_from_this<APLRuntimePresentationAdapter> {
public:
    static std::shared_ptr<APLRuntimePresentationAdapter> create(
        const std::shared_ptr<APLRuntimeInterfaceImpl>& runtimeInterface,
        std::shared_ptr<gui::GUIActivityEventNotifierInterface> activityEventNotifier);

    void setAlexaPresentationCA(
        std::shared_ptr<alexaPresentationInterfaces::AlexaPresentationCapabilityAgentInterface> alexaPresentationCA);

    void setDefaultWindowId(const std::string& windowId);

    std::string getAPLRuntimeVersion();

    void onRenderDocument(
        const std::string& document,
        const std::string& datasource,
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const std::string& windowId,
        const aplCapabilityCommonInterfaces::APLTimeoutType timeoutType,
        const std::string& interfaceName,
        const std::string& supportedViewports,
        const aplCapabilityCommonInterfaces::PresentationSession& presentationSession,
        const std::chrono::steady_clock::time_point& receiveTime,
        std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> agent) override;

    void onExecuteCommands(const std::string& sourceType, const aplCapabilityCommonInterfaces::PresentationToken& token)
        override;

    void onDataSourceUpdate(
        const std::string& sourceType,
        const std::string& jsonPayload,
        const aplCapabilityCommonInterfaces::PresentationToken& token) override;

    void onShowDocument(const aplCapabilityCommonInterfaces::PresentationToken& token) override;

    void onAPLDocumentSessionAvailable(
        const aplCapabilityCommonInterfaces::PresentationSession& presentationSession,
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        std::unique_ptr<aplCapabilityCommonInterfaces::APLDocumentSessionInterface>&& session) override;

    void onCommandExecutionComplete(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        alexaClientSDK::aplCapabilityCommonInterfaces::APLCommandExecutionEvent event,
        const std::string& error) override;

    void onRenderDocumentComplete(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        bool result,
        const std::string& error,
        const std::chrono::steady_clock::time_point& timestamp) override;

    void onSendEvent(const aplCapabilityCommonInterfaces::aplEventPayload::UserEvent& payload) override;

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

    void onDataSourceUpdateComplete(const std::string& token, bool result, const std::string& error) override;

    void onDataSourceFetch(const aplCapabilityCommonInterfaces::aplEventPayload::DataSourceFetch& payload) override;

    void onRuntimeError(const aplCapabilityCommonInterfaces::aplEventPayload::RuntimeError& payload) override;

    void onDocumentFinished(const std::string& token) override;

    void onActiveDocumentChanged(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const aplCapabilityCommonInterfaces::PresentationSession& session) override;

    void onSessionEnded(const aplCapabilityCommonInterfaces::PresentationSession& presentationSession) override;

    void onActivityEvent(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const avsCommon::sdkInterfaces::GUIActivityEvent& event) override;

    void provideState(
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const avsCommon::sdkInterfaces::ContextRequestToken stateRequestToken) override;

    void onGUIActivityEventReceived(
        const std::string& source,
        const avsCommon::sdkInterfaces::GUIActivityEvent& activityEvent) override;

    void onDialogUXStateChanged(
        avsCommon::sdkInterfaces::DialogUXStateObserverInterface::DialogUXState newState) override;

    void onPlayerActivityChanged(avsCommon::avs::PlayerActivity state);

    void setExecutor(std::shared_ptr<avsCommon::utils::threading::Executor>);

    void renderDocumentWithoutPresentation(
        const std::string& jsonPayload,
        const std::string& token,
        const std::string& windowId,
        const std::chrono::steady_clock::time_point& receiveTime,
        const std::string& interface,
        std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> agent);

    void clearDocument(const std::string& token);

private:
    APLRuntimePresentationAdapter(
        const std::shared_ptr<APLRuntimeInterfaceImpl>& runtimeInterface,
        std::unique_ptr<APLDocumentSessionManager> sessionManager,
        std::shared_ptr<gui::GUIActivityEventNotifierInterface> activityEventNotifier);

    void executeRenderDocument(
        const std::string& document,
        const std::string& datasource,
        const aplCapabilityCommonInterfaces::PresentationToken& token,
        const std::string& windowId,
        const aplCapabilityCommonInterfaces::APLTimeoutType timeoutType,
        const std::string& interfaceName,
        const std::string& supportedViewports,
        const aplCapabilityCommonInterfaces::PresentationSession& presentationSession,
        const std::chrono::steady_clock::time_point& receiveTime,
        std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> agent,
        bool trackAsPresentation);
    void executeClearDocument(const std::string& token);
    void executeExecuteCommands(
        const std::string& jsonPayload,
        const aplCapabilityCommonInterfaces::PresentationToken& token);
    void executeDataSourceUpdate(
        const std::string& sourceType,
        const std::string& jsonPayload,
        const std::string& token);
    void executeRequestForeground(const std::string& token);
    void executeOnCommandExecutionComplete(
        const std::string& token,
        aplCapabilityCommonInterfaces::APLCommandExecutionEvent event,
        const std::string& message);
    void executeOnRenderDocumentComplete(
        const std::string& token,
        bool result,
        const std::string& error,
        const std::chrono::steady_clock::time_point& timestamp);
    void executeOnSendEvent(const aplCapabilityCommonInterfaces::aplEventPayload::UserEvent& payload);
    void executeOnVisualContextAvailable(
        const avsCommon::sdkInterfaces::ContextRequestToken requestToken,
        const aplCapabilityCommonInterfaces::aplEventPayload::VisualContext& context);
    void executeOnDataSourceUpdateComplete(const std::string& token, bool result, const std::string& error);
    void executeOnDataSourceFetch(
        const aplCapabilityCommonInterfaces::aplEventPayload::DataSourceFetch& dataSourceFetch);
    void executeOnRuntimeError(const aplCapabilityCommonInterfaces::aplEventPayload::RuntimeError& runtimeError);
    void executeOnDocumentFinished(const std::string& token);
    void executeProvideState(const std::string& aplToken, const unsigned int stateRequestToken);
    void executeOnPlayerActivityChanged(avsCommon::avs::PlayerActivity state);

    struct PresentationAgentDocumentTracker {
        explicit PresentationAgentDocumentTracker(
            std::string token,
            std::weak_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> presentationAgent,
            bool trackAsPresentation) :
                token{std::move(token)},
                presentationAgent{std::move(presentationAgent)} {
            handleOnPresentationDismissed = trackAsPresentation;
            docCount = 1;
        };

        std::string token;

        std::weak_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> presentationAgent;

        int docCount;

        bool handleOnPresentationDismissed;
    };

    std::shared_ptr<PresentationAgentDocumentTracker> executeGetPresentationAgentTrackerFromToken(
        const std::string& token);

    std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> executeGetPresentationAgentFromToken(
        const std::string& token);

    void executeRemoveTokenFromPresentationAgentTracker(const std::string& token);

    void executeUpdateTimeoutType(
        const std::string& aplToken,
        const aplCapabilityCommonInterfaces::APLTimeoutType& timeoutType);

    const std::shared_ptr<APLRuntimeInterfaceImpl> m_runtimeInterface;

    std::unique_ptr<APLDocumentSessionManager> m_sessionManager;

    std::shared_ptr<gui::GUIActivityEventNotifierInterface> m_activityEventNotifier;

    bool m_isSpeakingOrListening;

    std::shared_ptr<alexaPresentationInterfaces::AlexaPresentationCapabilityAgentInterface> m_alexaPresentationCA;

    std::unordered_map<std::string, std::shared_ptr<PresentationAgentDocumentTracker>> m_presentationAgentTrackers;

    std::unordered_map<std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface>, unsigned int>
        m_presentationTrackersPerCA;

    std::shared_ptr<avsCommon::utils::threading::Executor> m_executor;
};
}  // namespace ipcServerSampleApp
}  // namespace sampleApplications
}  // namespace alexaClientSDK
#endif  // ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_ALEXAPRESENTATION_APLRUNTIMEPRESENTATIONADAPTER_H_