GUIManager.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_GUI_GUIMANAGER_H_
#define ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_GUI_GUIMANAGER_H_

#include <Audio/MicrophoneInterface.h>
#include <AFML/FocusManager.h>
#include <AVSCommon/AVS/FocusState.h>
#include <acsdkAudioPlayerInterfaces/AudioPlayerObserverInterface.h>
#include <acsdk/APLCapabilityCommonInterfaces/APLCapabilityAgentInterface.h>
#include <acsdk/Notifier/Notifier.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationOrchestratorInterface.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationOrchestratorStateObserverInterface.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationOrchestratorStateTrackerInterface.h>
#include <acsdk/Sample/InteractionManager/InteractionManager.h>
#include <acsdk/Sample/Endpoint/EndpointAlexaLauncherHandler.h>
#include <acsdk/SDKClient/SDKClientRegistry.h>
#include <acsdk/VisualCharacteristicsInterfaces/VisualCharacteristicsInterface.h>
#include <acsdk/VisualCharacteristicsInterfaces/VisualCharacteristicsSerializerInterface.h>
#ifdef ENABLE_COMMS
#include <AVSCommon/SDKInterfaces/CallStateObserverInterface.h>
#endif
#include <AVSCommon/SDKInterfaces/CapabilitiesObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ChannelObserverInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerObserverInterface.h>
#include <AVSCommon/SDKInterfaces/GUIActivityEvent.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <Settings/DeviceSettingsManager.h>
#include <Settings/SettingCallbacks.h>
#include <DefaultClient/DefaultClient.h>

#include "IPCServerSampleApp/AlexaPresentation/APLRuntimePresentationAdapter.h"
#include "IPCServerSampleApp/GUILogBridge.h"
#include "IPCServerSampleApp/GUI/CaptureState.h"
#include "IPCServerSampleApp/GUI/GUIActivityEventNotifierInterface.h"
#include "IPCServerSampleApp/GUI/GUIClientInterface.h"
#include "IPCServerSampleApp/GUI/GUIServerInterface.h"
#include "IPCServerSampleApp/GUI/TemplateRuntimePresentationAdapterBridge.h"
#include "IPCServerSampleApp/GUI/NavigationEvent.h"
#include "IPCServerSampleApp/IPC/Components/DoNotDisturbHandler.h"
#include "IPCServerSampleApp/IPC/Components/InteractionManagerHandler.h"
#include "IPCServerSampleApp/IPC/Components/LoggerHandler.h"
#include "IPCServerSampleApp/IPC/Components/SessionSetupHandler.h"
#include "IPCServerSampleApp/IPC/Components/WindowManagerHandler.h"
#include "IPCServerSampleApp/IPC/Namespaces/DoNotDisturbNamespace.h"
#include "IPCServerSampleApp/IPC/Namespaces/InteractionManagerNamespace.h"
#include "IPCServerSampleApp/IPC/Namespaces/LoggerNamespace.h"
#include "IPCServerSampleApp/IPC/Namespaces/SessionSetupNamespace.h"
#include "IPCServerSampleApp/IPC/Namespaces/WindowManagerNamespace.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/DoNotDisturbHandlerInterface.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/InteractionManagerHandlerInterface.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/LoggerHandlerInterface.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/SessionSetupHandlerInterface.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/WindowManagerHandlerInterface.h"
#include "IPCServerSampleApp/IPC/IPCVersionManager.h"
#include "IPCServerSampleApp/TimezoneHelper.h"

#ifdef UWP_BUILD
#include <SSSDKCommon/NullMicrophone.h>
#endif

namespace alexaClientSDK {
namespace sampleApplications {
namespace ipcServerSampleApp {
namespace gui {

class GUIManager
        : public avsCommon::sdkInterfaces::DialogUXStateObserverInterface
        , public avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface
        , public gui::GUIServerInterface
        , public acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface
        , public presentationOrchestratorInterfaces::PresentationOrchestratorStateObserverInterface
        , public avsCommon::sdkInterfaces::FocusManagerObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public avsCommon::sdkInterfaces::ChannelObserverInterface
        , public ipc::DoNotDisturbHandlerInterface
        , public ipc::SessionSetupHandlerInterface
        , public ipc::WindowManagerHandlerInterface
        , public ipc::InteractionManagerHandlerInterface
        , public ipc::LoggerHandlerInterface
#ifdef ENABLE_COMMS
        , public avsCommon::sdkInterfaces::CallStateObserverInterface
#endif
        , public std::enable_shared_from_this<GUIManager> {
public:
    static std::shared_ptr<GUIManager> create(
        std::shared_ptr<gui::GUIClientInterface> guiClient,
        std::shared_ptr<gui::GUIActivityEventNotifierInterface> activityEventNotifier,
        std::shared_ptr<applicationUtilities::resources::audio::MicrophoneInterface> micWrapper,
        std::shared_ptr<common::InteractionManager> interactionManager,
        std::shared_ptr<common::EndpointAlexaLauncherHandler> launcherHandler);

    void handleRecognizeSpeechRequest(capabilityAgents::aip::Initiator initiator, bool start) override;

    void handleMicrophoneToggle() override;

    void handlePlaybackPlay() override;

    void handlePlaybackPause() override;

    void handlePlaybackNext() override;

    void handlePlaybackPrevious() override;

    void handlePlaybackSeekTo(int offset) override;

    void handlePlaybackSkipForward() override;

    void handlePlaybackSkipBackward() override;

    void handlePlaybackToggle(const std::string& name, bool checked) override;

    void onUserEvent() override;

    bool handleFocusAcquireRequest(
        std::string avsInterface,
        std::string channelName,
        avsCommon::avs::ContentType contentType,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver) override;

    bool handleFocusReleaseRequest(
        std::string avsInterface,
        std::string channelName,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver) override;

    void handleGUIActivityEvent(avsCommon::sdkInterfaces::GUIActivityEvent event, const std::string& source = "")
        override;

    void handleNavigationEvent(NavigationEvent event) override;

    std::vector<visualCharacteristicsInterfaces::WindowTemplate> getWindowTemplates() override;

    std::vector<visualCharacteristicsInterfaces::InteractionMode> getInteractionModes() override;

    visualCharacteristicsInterfaces::DisplayCharacteristics getDisplayCharacteristics() override;

    void setWindowInstances(
        const std::vector<presentationOrchestratorInterfaces::PresentationOrchestratorWindowInstance>& instances,
        const std::string& defaultWindowInstanceId,
        const std::string& audioPlaybackUIWindowId) override;

    bool addWindowInstance(
        const presentationOrchestratorInterfaces::PresentationOrchestratorWindowInstance& instance) override;

    bool removeWindowInstance(const std::string& windowInstanceId) override;

    void updateWindowInstance(
        const presentationOrchestratorInterfaces::PresentationOrchestratorWindowInstance& instance) override;

    bool setDefaultWindowInstance(const std::string& windowInstanceId) override;

    bool serializeInteractionMode(
        const std::vector<visualCharacteristicsInterfaces::InteractionMode>& interactionModes,
        std::string& serializedJson) override;

    bool serializeWindowTemplate(
        const std::vector<visualCharacteristicsInterfaces::WindowTemplate>& windowTemplates,
        std::string& serializedJson) override;

    bool serializeDisplayCharacteristics(
        const visualCharacteristicsInterfaces::DisplayCharacteristics& display,
        std::string& serializedJson) override;

    void forceExit() override;

    std::chrono::milliseconds getDeviceTimezoneOffset() override;

    void handleOnMessagingServerConnectionOpened() override;

    void handleDocumentTerminated(const std::string& token, bool failed) override;

    void acceptCall() override;

    void stopCall() override;

    void enableLocalVideo() override;

    void disableLocalVideo() override;

#ifdef ENABLE_COMMS
    void sendDtmf(avsCommon::sdkInterfaces::CallManagerInterface::DTMFTone dtmfTone) override;
#endif

    void handleLocaleChange() override;

    void initClient() override;

    void doNotDisturbStateChanged(const std::string& message) override;
    void doNotDisturbStateRequest(const std::string& message) override;

    void namespaceVersionsReport(const std::string& message) override;
    void clientInitialized(const std::string& message) override;
    void clientConfigRequest(const std::string& message) override;

    void visualCharacteristicsRequest(const std::string& message) override;
    void defaultWindowInstanceChanged(const std::string& message) override;
    void windowInstancesReport(const std::string& message) override;
    void windowInstancesAdded(const std::string& message) override;
    void windowInstancesRemoved(const std::string& message) override;
    void windowInstancesUpdated(const std::string& message) override;

    void recognizeSpeechRequest(const std::string& message) override;
    void navigationEvent(const std::string& message) override;
    void guiActivityEvent(const std::string& message) override;

    void logEvent(const std::string& message) override;

    void onFocusChanged(const std::string& channelName, avsCommon::avs::FocusState newFocus) override;

    void onPlayerActivityChanged(avsCommon::avs::PlayerActivity state, const Context& context) override;

    void onStateChanged(
        const std::string& windowId,
        const presentationOrchestratorInterfaces::PresentationMetadata& metadata) override;

    void onDialogUXStateChanged(DialogUXState newState) override;

    void onStateChanged(AudioInputProcessorObserverInterface::State state) override;

#ifdef ENABLE_COMMS
    void onCallStateInfoChange(
        const avsCommon::sdkInterfaces::CallStateObserverInterface::CallStateInfo& newStateInfo) override;
    void onCallStateChange(avsCommon::sdkInterfaces::CallStateObserverInterface::CallState newCallState) override;
#endif

    void setClient(std::shared_ptr<sdkClient::SDKClientRegistry> clientRegistry);

    bool configureSettingsNotifications();

    void setIpcVersionManager(std::shared_ptr<ipc::IPCVersionManager> ipcVersionManager);

    bool parseWindowInstance(
        const rapidjson::Value& payload,
        presentationOrchestratorInterfaces::PresentationOrchestratorWindowInstance& windowInstance);

#ifdef UWP_BUILD
    void inputAudioFile(const std::string& audioFile);
#endif

    void forceClearDialogChannelFocus();

    void onFocusChanged(avsCommon::avs::FocusState newFocus, avsCommon::avs::MixingBehavior behavior) override;

    void setAPLRuntimePresentationAdapter(std::shared_ptr<APLRuntimePresentationAdapter> aplRuntimePresentationAdapter);

    void setTemplateRuntimePresentationAdapterBridge(
        std::shared_ptr<TemplateRuntimePresentationAdapterBridge> templateRuntimePresentationAdapterBridge);

    void initialize();

private:
    GUIManager(
        std::shared_ptr<gui::GUIClientInterface> guiClient,
        std::shared_ptr<gui::GUIActivityEventNotifierInterface> activityEventNotifier,
        std::shared_ptr<applicationUtilities::resources::audio::MicrophoneInterface> micWrapper,
        std::shared_ptr<common::InteractionManager> interactionManager,
        std::shared_ptr<common::EndpointAlexaLauncherHandler> launcherHandler);

    void doShutdown() override;

    void executeBackNavigation();

    void executeExitNavigation();

    void setFirmwareVersion(avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion);

    void adjustVolume(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type, int8_t delta);

    void setMute(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type, bool mute);

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

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

    void resetDevice();

    std::shared_ptr<gui::GUIClientInterface> m_guiClient;

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

    std::shared_ptr<alexaClientSDK::defaultClient::DefaultClient> m_defaultClient;

    bool m_isSpeakingOrListening;

#ifdef UWP_BUILD
    std::shared_ptr<alexaSmartScreenSDK::sssdkCommon::NullMicrophone> m_micWrapper;
#else
    std::shared_ptr<applicationUtilities::resources::audio::MicrophoneInterface> m_micWrapper;
#endif

    avsCommon::avs::PlayerActivity m_playerActivityState;

    avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface::State m_audioInputProcessorState;

    std::unordered_map<std::string, avsCommon::avs::FocusState> m_channelFocusStates;

    bool m_clearAlertChannelOnForegrounded;

    std::shared_ptr<settings::SettingCallbacks<settings::DeviceSettingsManager>> m_callbacks;

    std::shared_ptr<settings::DeviceSettingsManager> m_settingsManager;

    std::shared_ptr<ipc::DoNotDisturbHandler> m_doNotDisturbIPCHandler;

    std::shared_ptr<ipc::InteractionManagerHandler> m_interactionManagerIPCHandler;

    std::shared_ptr<ipc::LoggerHandler> m_loggerIPCHandler;

    std::shared_ptr<ipc::SessionSetupHandler> m_sessionSetupIPCHandler;

    std::shared_ptr<ipc::IPCVersionManager> m_ipcVersionManager;

    std::shared_ptr<common::EndpointAlexaLauncherHandler> m_launcherHandler;

    std::shared_ptr<ipc::WindowManagerHandler> m_windowManagerIPCHandler;

    std::string m_defaultWindowId;

    std::string m_audioPlaybackUIWindowId;

    GUILogBridge m_guiLogBridge;

    std::string m_interfaceHoldingAudioFocus;

    std::shared_ptr<TimezoneHelper> m_timezoneHelper;

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

    std::shared_ptr<presentationOrchestratorInterfaces::PresentationOrchestratorStateTrackerInterface>
        m_presentationOrchestratorStateTracker;

    std::shared_ptr<visualCharacteristicsInterfaces::VisualCharacteristicsInterface> m_visualCharacteristics;

    std::shared_ptr<visualCharacteristicsInterfaces::VisualCharacteristicsSerializerInterface>
        m_visualCharacteristicsSerializer;

    std::shared_ptr<presentationOrchestratorInterfaces::PresentationOrchestratorInterface> m_presentationOrchestrator;

    std::shared_ptr<aplCapabilityCommonInterfaces::APLCapabilityAgentInterface> m_alexaPresentationAPL;

    std::shared_ptr<APLRuntimePresentationAdapter> m_aplRuntimePresentationAdapter;

    std::shared_ptr<TemplateRuntimePresentationAdapterBridge> m_templateRuntimePresentationAdapterBridge;

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

}  // namespace gui
}  // namespace ipcServerSampleApp
}  // namespace sampleApplications
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_GUI_GUIMANAGER_H_