APLDocumentSession.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_APLDOCUMENTSESSION_H_
#define ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_ALEXAPRESENTATION_APLDOCUMENTSESSION_H_

#include <chrono>
#include <string>
#include <unordered_set>

#include <AVSCommon/Utils/Threading/Executor.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLDocumentSessionInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLTimeoutType.h>
#include <acsdk/APLCapabilityCommonInterfaces/PresentationOptions.h>
#include <acsdk/APLCapabilityCommonInterfaces/PresentationSession.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationObserverInterface.h>
#include "IPCServerSampleApp/AlexaPresentation/APLViewhostInterface.h"

namespace alexaClientSDK {
namespace sampleApplications {
namespace ipcServerSampleApp {
class APLDocumentSession
        : public aplCapabilityCommonInterfaces::APLDocumentSessionInterface
        , public presentationOrchestratorInterfaces::PresentationObserverInterface
        , public APLViewhostObserverInterface
        , public std::enable_shared_from_this<APLDocumentSession> {
public:
    APLDocumentSession(
        const std::string& document,
        const std::string& data,
        const std::string& supportedViewPorts,
        const aplCapabilityCommonInterfaces::PresentationSession& presentationSession,
        const aplCapabilityCommonInterfaces::PresentationOptions& presentationOptions,
        std::shared_ptr<alexaClientSDK::aplCapabilityCommonInterfaces::APLDocumentObserverInterface> observer,
        APLViewhostInterfacePtr viewhost,
        bool hasPresentationAssociation);

    void renderDocument(
        const std::string& document,
        const std::string& data,
        const alexaClientSDK::aplCapabilityCommonInterfaces::PresentationSession& presentationSession,
        const alexaClientSDK::aplCapabilityCommonInterfaces::PresentationOptions& presentationOptions);

    void updateTimeoutType(const aplCapabilityCommonInterfaces::APLTimeoutType& timeoutType);

    void clearDocument() override;
    void executeCommands(const std::string& commands) override;
    void dataSourceUpdate(const std::string& sourceType, const std::string& payload) override;
    void interruptCommandSequence() override;
    void provideDocumentContext(const unsigned int stateRequestToken) override;
    void requestForeground() override;
    void stopTimeout() override;
    void resetTimeout() override;
    void updateLifespan(presentationOrchestratorInterfaces::PresentationLifespan lifespan) override;
    void updateTimeout(std::chrono::milliseconds timeout) override;
    std::string getToken() const override;
    bool isForegroundFocused() override;

    void onPresentationAvailable(
        presentationOrchestratorInterfaces::PresentationRequestToken id,
        std::shared_ptr<presentationOrchestratorInterfaces::PresentationInterface> presentation) override;
    void onPresentationStateChanged(
        presentationOrchestratorInterfaces::PresentationRequestToken id,
        presentationOrchestratorInterfaces::PresentationState newState) override;
    bool onNavigateBack(presentationOrchestratorInterfaces::PresentationRequestToken id) override;

    void onCommandExecutionComplete(
        const std::string& token,
        APLClient::AplCommandExecutionEvent event,
        const std::string& message) override;
    void onRenderDocumentComplete(
        const std::string& token,
        bool result,
        const std::string& error,
        const std::chrono::steady_clock::time_point& timestamp) override;
    void onSendEvent(
        const std::string& token,
        const std::string& arguments,
        const std::string& components,
        const std::string& source) override;
    void onVisualContextAvailable(
        const unsigned int requestToken,
        const std::string& token,
        const std::string& version,
        const std::string& visualContext,
        const std::string& datasourceContext) override;
    void onDataSourceUpdateComplete(const std::string& token, bool result, const std::string& error) override;
    void onDataSourceFetch(const std::string& token, const std::string& dataSourceType, const std::string& payload)
        override;
    void onRuntimeError(const std::string& token, const std::string& payload) override;
    void onDocumentFinished(const std::string& token) override;
    void onOpenURL(const std::string& token, const std::string& url) override;
    void onDocumentCleared(const std::string& token) override;
    void onSetDocumentIdleTimeout(const std::string& token, const std::chrono::milliseconds& timeout) override;

    void firstRender();

    static std::shared_ptr<APLDocumentSession> getDocumentSessionFromInterface(
        const std::shared_ptr<aplCapabilityCommonInterfaces::APLDocumentSessionInterface>& aplDocumentSessionInterface);

private:
    class APLDocumentSessionWrapper : public aplCapabilityCommonInterfaces::APLDocumentSessionInterface {
    public:
        APLDocumentSessionWrapper(std::shared_ptr<APLDocumentSession> documentSession);

        void clearDocument() override;
        void executeCommands(const std::string& commands) override;
        void dataSourceUpdate(const std::string& sourceType, const std::string& payload) override;
        void interruptCommandSequence() override;
        void provideDocumentContext(const unsigned int stateRequestToken) override;
        void requestForeground() override;
        void stopTimeout() override;
        void resetTimeout() override;
        void updateLifespan(presentationOrchestratorInterfaces::PresentationLifespan lifespan) override;
        void updateTimeout(std::chrono::milliseconds timeout) override;
        std::string getToken() const override;
        bool isForegroundFocused() override;

        operator std::shared_ptr<APLDocumentSession> const();

    private:
        std::shared_ptr<APLDocumentSession> m_documentSession;
    };

    bool executeRenderDocument(bool firstRender = false);

    void executeClearDocument(bool forceClear = false);

    bool executeIsPresentationActive() const;

    bool executeIsPresentationForegrounded() const;

    bool canHandleToken(const std::string& token);

    std::weak_ptr<APLViewhostInterface> m_viewhost;

    bool m_hasPresentationAssociation;

    std::shared_ptr<presentationOrchestratorInterfaces::PresentationInterface> m_presentation;

    presentationOrchestratorInterfaces::PresentationState m_state;

    std::string m_document;

    std::string m_data;

    aplCapabilityCommonInterfaces::PresentationSession m_presentationSession;

    aplCapabilityCommonInterfaces::PresentationOptions m_presentationOptions;

    std::shared_ptr<aplCapabilityCommonInterfaces::APLDocumentObserverInterface> m_observer;

    std::unordered_set<std::string> m_tokens;

    std::string m_supportedViewports;

    bool m_renderComplete;

    avsCommon::utils::threading::Executor m_executor;
};
}  // namespace ipcServerSampleApp
}  // namespace sampleApplications
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_ALEXAPRESENTATION_APLDOCUMENTSESSION_H_