TemplateRuntime.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_CAPABILITYAGENTS_TEMPLATERUNTIME_INCLUDE_TEMPLATERUNTIME_TEMPLATERUNTIME_H_
#define ALEXA_CLIENT_SDK_CAPABILITYAGENTS_TEMPLATERUNTIME_INCLUDE_TEMPLATERUNTIME_TEMPLATERUNTIME_H_
 
#include <chrono>
#include <deque>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/DialogUXStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsObserverInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderRegistrarInterface.h>
#include <AVSCommon/SDKInterfaces/TemplateRuntimeObserverInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/Timer.h>
 
namespace alexaClientSDK {
namespace capabilityAgents {
namespace templateRuntime {
 
class TemplateRuntime
        : public avsCommon::avs::CapabilityAgent
        , public avsCommon::utils::RequiresShutdown
        , public avsCommon::sdkInterfaces::RenderPlayerInfoCardsObserverInterface
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public avsCommon::sdkInterfaces::DialogUXStateObserverInterface
        , public std::enable_shared_from_this<TemplateRuntime> {
public:
    static std::shared_ptr<TemplateRuntime> createTemplateRuntime(
        const std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>&
            renderPlayerInfoCardsInterfaces,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender);
 
    static std::shared_ptr<TemplateRuntime> create(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface>>&
            renderPlayerInfoCardsInterfaces,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender);
 
    virtual ~TemplateRuntime() = default;
 
    void handleDirectiveImmediately(std::shared_ptr<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;
    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;
 
    void onFocusChanged(avsCommon::avs::FocusState newFocus, avsCommon::avs::MixingBehavior behavior) override;
 
    void onRenderPlayerCardsInfoChanged(avsCommon::avs::PlayerActivity state, const Context& context) override;
 
    void onDialogUXStateChanged(
        avsCommon::sdkInterfaces::DialogUXStateObserverInterface::DialogUXState newState) override;
 
    void addObserver(std::shared_ptr<avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface> observer);
 
    void removeObserver(std::shared_ptr<avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface> observer);
 
    void displayCardCleared();
 
    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;
 
    void addRenderPlayerInfoCardsProvider(
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface> cardsProvider);
 
private:
    enum class State {
        IDLE,
 
        /*
         * The @c TemplateRuntime has received a displayCard event is acquiring the visual channel from @c
         * FocusManager.
         */
        ACQUIRING,
 
        /*
         * The @c TemplateRuntime has focus, either background or foreground, of the channel and has
         * notified its observers of a displayCard.  @TemplateRuntime will remain in this state until there is a
         * timeout, clearCard, or focusChanged(NONE) event.
         */
        DISPLAYING,
 
        /*
         * The @c TemplateRuntime has received a timeout or a clearCard event and is releasing the
         * channel and has notified its observers to clear the display.
         */
        RELEASING,
 
        /*
         * The @c TemplateRuntime has received a displayCard event during releasing of the channel and is trying to
         * acquire the visual channel again.
         */
        REACQUIRING
    };
 
    struct AudioItemPair {
        AudioItemPair() = default;
 
        AudioItemPair(
            std::string itemId,
            std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> renderPlayerInfoDirective) :
                audioItemId{itemId},
                directive{renderPlayerInfoDirective} {};
 
        std::string audioItemId;
 
        std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> directive;
    };
 
    TemplateRuntime(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface>>&
            renderPlayerInfoCardsInterfaces,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender);
 
    // @name RequiresShutdown Functions
    void doShutdown() override;
 
    bool initialize();
 
    void removeDirective(std::shared_ptr<DirectiveInfo> info);
 
    void setHandlingCompleted(std::shared_ptr<DirectiveInfo> info);
 
    void handleRenderTemplateDirective(std::shared_ptr<DirectiveInfo> info);
 
    void handleRenderPlayerInfoDirective(std::shared_ptr<DirectiveInfo> info);
 
    void handleUnknownDirective(std::shared_ptr<DirectiveInfo> info);
 
    void executeAudioPlayerInfoUpdates(avsCommon::avs::PlayerActivity state, const Context& context);
 
    void executeAudioPlayerStartTimer(avsCommon::avs::PlayerActivity state);
 
    void executeRenderPlayerInfoCallbacks(bool isClearCard);
 
    void executeRenderTemplateCallbacks(bool isClearCard);
 
    void executeDisplayCard();
 
    void executeClearCard();
 
    void executeStartTimer(std::chrono::milliseconds timeout);
 
    void executeStopTimer();
 
    std::string stateToString(const TemplateRuntime::State state);
 
    void executeTimerEvent();
 
    void executeOnFocusChangedEvent(avsCommon::avs::FocusState newFocus);
 
    void executeDisplayCardEvent(
        const std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> info);
 
    void executeCardClearedEvent();
 
    avsCommon::utils::timing::Timer m_clearDisplayTimer;
 
    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface>> m_observers;
 
    /*
     * This is a map that is used to store the current executing @c AudioItem based on the callbacks from the
     * @c RenderPlayerInfoCardsProviderInterface.
     */
    std::unordered_map<std::shared_ptr<avsCommon::sdkInterfaces::MediaPropertiesInterface>, AudioItemPair>
        m_audioItemsInExecution;
 
    std::shared_ptr<avsCommon::sdkInterfaces::MediaPropertiesInterface> m_activeRenderPlayerInfoCardsProvider;
 
    /*
     * This queue is for storing the @c RenderPlayerInfo directives when its audioItemId does not match the audioItemId
     * in execution in the @c AudioPlayer.
     */
    std::deque<AudioItemPair> m_audioItems;
 
    std::unordered_map<
        std::shared_ptr<avsCommon::sdkInterfaces::MediaPropertiesInterface>,
        avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface::AudioPlayerInfo>
        m_audioPlayerInfo;
 
    std::shared_ptr<alexaClientSDK::avsCommon::avs::CapabilityAgent::DirectiveInfo> m_lastDisplayedDirective;
 
    bool m_isRenderTemplateLastReceived;
 
    avsCommon::avs::FocusState m_focus;
 
    State m_state;
 
    /*
     * This is a set of interfaces to the @c RenderPlayerInfoCardsProviderInterface.  The @c TemplateRuntime CA
     * used this interface to add and remove itself as an observer.
     */
    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface>>
        m_renderPlayerInfoCardsInterfaces;
 
    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> m_focusManager;
 
    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;
 
    avsCommon::utils::threading::Executor m_executor;
 
    std::chrono::milliseconds m_ttsFinishedTimeout;
 
    std::chrono::milliseconds m_audioPlaybackFinishedTimeout;
 
    std::chrono::milliseconds m_audioPlaybackStoppedPausedTimeout;
};
 
}  // namespace templateRuntime
}  // namespace capabilityAgents
}  // namespace alexaClientSDK
 
#endif  // ALEXA_CLIENT_SDK_CAPABILITYAGENTS_TEMPLATERUNTIME_INCLUDE_TEMPLATERUNTIME_TEMPLATERUNTIME_H_