LiveViewControllerPresentationAdapter.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_LIVEVIEWCONTROLLER_LIVEVIEWCONTROLLERPRESENTATIONADAPTER_H_
#define ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_LIVEVIEWCONTROLLER_LIVEVIEWCONTROLLERPRESENTATIONADAPTER_H_

#include <memory>
#include <string>
#include <unordered_set>
#include <utility>

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

#include <acsdk/AlexaLiveViewControllerInterfaces/LiveViewControllerConfiguration.h>
#include <acsdk/AlexaLiveViewControllerInterfaces/LiveViewControllerInterface.h>
#include <acsdk/AlexaLiveViewControllerInterfaces/LiveViewControllerTypes.h>
#include <acsdk/Notifier/Notifier.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationOrchestratorClientInterface.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationTypes.h>
#include <acsdk/Sample/InteractionManager/InteractionManager.h>
#include <AIP/ASRProfile.h>
#include <AVSCommon/SDKInterfaces/AudioInputProcessorObserverInterface.h>
#include <AVSCommon/SDKInterfaces/SpeechInteractionHandlerInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <IPCServerSampleApp/AlexaPresentation/AplClientBridge.h>
#include <IPCServerSampleApp/Extensions/LiveView/AplLiveViewExtension.h>
#include <IPCServerSampleApp/Extensions/LiveView/AplLiveViewExtensionObserverInterface.h>
#include <IPCServerSampleApp/IPC/Components/LiveViewCameraHandler.h>
#include <IPCServerSampleApp/IPC/HandlerInterfaces/LiveViewCameraHandlerInterface.h>

namespace alexaClientSDK {
namespace sampleApplications {
namespace ipcServerSampleApp {
namespace liveViewController {

class LiveViewControllerPresentationAdapter
        : public presentationOrchestratorInterfaces::PresentationObserverInterface
        , public ipc::LiveViewCameraHandlerInterface
        , public alexaClientSDK::alexaLiveViewControllerInterfaces::LiveViewControllerInterface
        , public avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface
        , public avsCommon::sdkInterfaces::SpeechInteractionHandlerInterface
        , public extensions::liveView::AplLiveViewExtensionObserverInterface
        , public std::enable_shared_from_this<LiveViewControllerPresentationAdapter> {
public:
    static std::shared_ptr<LiveViewControllerPresentationAdapter> create(
        const std::shared_ptr<ipc::IPCHandlerRegistrationInterface>& ipcHandlerRegistrar,
        const std::shared_ptr<AplClientBridge>& aplClientBridge);

    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 cameraMicrophoneStateChanged(const std::string& message) override;
    void cameraFirstFrameRendered(const std::string& message) override;
    void windowIdReport(const std::string& message) override;

    LiveViewControllerInterface::Response start(
        std::unique_ptr<LiveViewControllerInterface::StartLiveViewRequest> request) override;
    LiveViewControllerInterface::Response stop() override;
    LiveViewControllerInterface::Response setCameraState(
        alexaLiveViewControllerInterfaces::CameraState cameraState) override;
    alexaLiveViewControllerInterfaces::Configuration getConfiguration() override;
    bool addObserver(
        std::weak_ptr<alexaLiveViewControllerInterfaces::LiveViewControllerObserverInterface> observer) override;
    void removeObserver(
        std::weak_ptr<alexaLiveViewControllerInterfaces::LiveViewControllerObserverInterface> observer) override;

    void handleCameraExitRequest() override;
    void handleChangeCameraMicStateRequest(bool micOn) override;

    void onStateChanged(State state) override;
    void onASRProfileChanged(const std::string& profile) override;

    std::future<bool> notifyOfWakeWord(
        capabilityAgents::aip::AudioProvider wakeWordAudioProvider,
        avsCommon::avs::AudioInputStream::Index beginIndex,
        avsCommon::avs::AudioInputStream::Index endIndex,
        std::string keyword,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp,
        std::shared_ptr<const std::vector<char>> KWDMetadata = nullptr) override;

    std::future<bool> notifyOfTapToTalk(
        capabilityAgents::aip::AudioProvider tapToTalkAudioProvider,
        avsCommon::avs::AudioInputStream::Index beginIndex = capabilityAgents::aip::AudioInputProcessor::INVALID_INDEX,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp = std::chrono::steady_clock::now()) override;

    std::future<bool> notifyOfHoldToTalkStart(
        capabilityAgents::aip::AudioProvider holdToTalkAudioProvider,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp = std::chrono::steady_clock::now(),
        avsCommon::avs::AudioInputStream::Index beginIndex =
            capabilityAgents::aip::AudioInputProcessor::INVALID_INDEX) override;

    std::future<bool> notifyOfHoldToTalkEnd() override;

    std::future<bool> notifyOfTapToTalkEnd() override;

    void setPresentationOrchestrator(
        std::shared_ptr<presentationOrchestratorInterfaces::PresentationOrchestratorClientInterface> poClient);

    void setInteractionManager(std::shared_ptr<common::InteractionManager> interactionManager);

    void handleSetCameraMicrophoneState(bool enabled);

private:
    explicit LiveViewControllerPresentationAdapter();

    void initialize(
        const std::shared_ptr<ipc::IPCHandlerRegistrationInterface>& ipcHandlerRegistrar,
        const std::shared_ptr<AplClientBridge>& aplClientBridge);

    void handleASRProfileChanged(alexaClientSDK::capabilityAgents::aip::ASRProfile profile);

    void dismissPresentation();

    void executeDismissPresentation();

    void executeOnPresentationDismissed();

    void executeSetCameraUIMicState(bool enabled);

    void executeNotifyMicrophoneStateChanged(bool enabled);

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

    std::shared_ptr<presentationOrchestratorInterfaces::PresentationOrchestratorClientInterface>
        m_presentationOrchestratorClient;

    extensions::liveView::AplLiveViewExtensionPtr m_aplLiveViewExtension;

    std::shared_ptr<ipc::LiveViewCameraHandler> m_liveViewCameraIPCHandler;

    std::shared_ptr<common::InteractionManager> m_interactionManager;

    presentationOrchestratorInterfaces::PresentationRequestToken m_startLiveViewRequestToken;

    std::string m_liveViewCameraWindowId;

    std::unique_ptr<LiveViewControllerInterface::StartLiveViewRequest> m_startLiveViewRequest;

    alexaClientSDK::capabilityAgents::aip::ASRProfile m_asrProfile;

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

    notifier::Notifier<alexaLiveViewControllerInterfaces::LiveViewControllerObserverInterface> m_notifier;
};

}  // namespace liveViewController
}  // namespace ipcServerSampleApp
}  // namespace sampleApplications
}  // namespace alexaClientSDK
#endif  // ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_LIVEVIEWCONTROLLER_LIVEVIEWCONTROLLERPRESENTATIONADAPTER_H_