GUIClient.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_GUICLIENT_H_
#define ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_GUI_GUICLIENT_H_

#include <thread>
#include <atomic>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
#include <string>

#include <rapidjson/document.h>

#include <acsdk/APLCapabilityCommonInterfaces/APLDocumentObserverInterface.h>
#include <acsdk/PresentationOrchestratorInterfaces/PresentationOrchestratorTypes.h>
#include <AVSCommon/AVS/FocusState.h>
#include <AVSCommon/SDKInterfaces/AuthObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ChannelObserverInterface.h>
#ifdef ENABLE_COMMS
#include <AVSCommon/SDKInterfaces/CallStateObserverInterface.h>
#endif
#include <AVSCommon/SDKInterfaces/GUIActivityEvent.h>
#include <AVSCommon/SDKInterfaces/GUIActivityEventObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Storage/MiscStorageInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <acsdkSampleApplicationInterfaces/UIAuthNotifierInterface.h>
#include <acsdkSampleApplicationInterfaces/UIStateAggregatorInterface.h>
#include <RegistrationManager/CustomerDataHandler.h>
#include <RegistrationManager/RegistrationObserverInterface.h>
#include <RegistrationManager/CustomerDataHandler.h>
#include <Communication/MessagingServerInterface.h>

#include "IPCServerSampleApp/AlexaPresentation/AplClientBridge.h"
#include "IPCServerSampleApp/AlexaPresentation/APLRuntimePresentationAdapter.h"
#include "IPCServerSampleApp/AlexaPresentation/IPCAPLAgent.h"
#include "IPCServerSampleApp/GUI/GUIClientInterface.h"
#include "IPCServerSampleApp/GUI/GUIServerInterface.h"
#include "IPCServerSampleApp/IPC/Components/AudioFocusManagerHandler.h"
#include "IPCServerSampleApp/IPC/Components/SystemHandler.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/AudioFocusManagerHandlerInterface.h"
#include "IPCServerSampleApp/IPC/HandlerInterfaces/SystemHandlerInterface.h"
#include "IPCServerSampleApp/IPC/IPCRouter.h"
#include "IPCServerSampleApp/IPC/IPCDispatcherInterface.h"
#include "IPCServerSampleApp/IPC/IPCVersionManager.h"
#include "IPCServerSampleApp/IPC/Namespaces/AudioFocusManagerNamespace.h"
#include "IPCServerSampleApp/IPC/Namespaces/SystemNamespace.h"
#include "IPCServerSampleApp/Messages/MessageInterface.h"
#include "IPCServerSampleApp/SampleApplicationReturnCodes.h"

namespace alexaClientSDK {
namespace sampleApplications {
namespace ipcServerSampleApp {
namespace gui {
class GUIClient
        : public communication::MessagingServerInterface
        , public communication::MessageListenerInterface
        , public registrationManager::RegistrationObserverInterface
        , public communication::MessagingServerObserverInterface
        , public avsCommon::sdkInterfaces::AuthObserverInterface
        , public avsCommon::sdkInterfaces::CapabilitiesObserverInterface
        , public gui::GUIClientInterface
        , public avsCommon::utils::RequiresShutdown
        , public registrationManager::CustomerDataHandler
        , public std::enable_shared_from_this<GUIClient>
        , public acsdkSampleApplicationInterfaces::UIAuthNotifierInterface
        , public acsdkSampleApplicationInterfaces::UIStateAggregatorInterface
        , public ipc::IPCDispatcherInterface
        , public ipc::AudioFocusManagerHandlerInterface
        , public ipc::SystemHandlerInterface {
public:
    static std::shared_ptr<GUIClient> create(
        std::shared_ptr<MessagingServerInterface> serverImplementation,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        const std::shared_ptr<ipc::IPCVersionManager> ipcVersionManager,
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo);

    void setGUIManager(std::shared_ptr<gui::GUIServerInterface> guiManager) override;
    bool acquireFocus(
        std::string avsInterface,
        std::string channelName,
        avsCommon::avs::ContentType contentType,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver) override;
    bool releaseFocus(
        std::string avsInterface,
        std::string channelName,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver) override;
#ifdef ENABLE_COMMS
    void sendCallStateInfo(
        const avsCommon::sdkInterfaces::CallStateObserverInterface::CallStateInfo& callStateInfo) override;
#endif
    void sendMessage(messages::MessageInterface& message) override;
    bool finalizeClientInitialization(bool errorState) override;
    void handleInitializeAPLRenderers(rapidjson::Document& payload) override;
    void handleDisplayMetrics(rapidjson::Document& payload) override;
    void handleAplEvent(rapidjson::Document& payload) override;
    void handleRenderComplete(rapidjson::Document& payload) override;
    void handleLocalRenderDocument(rapidjson::Document& payload) override;
    void handleLocalExecuteCommands(rapidjson::Document& payload) override;
    void handleLocalClearDocument(rapidjson::Document& payload) override;
    void handleOnFocusChangedReceivedConfirmation(GUIToken token) override;
    void focusAcquireRequest(
        const GUIToken token,
        const std::string& avsInterface,
        const std::string& channelName,
        avsCommon::avs::ContentType contentType) override;
    void focusReleaseRequest(const GUIToken token, const std::string& avsInterface, const std::string& channelName)
        override;
    void setLocales(const std::string& localeStr) override;
    std::shared_ptr<ipc::IPCRouter> getIPCRouter() override;

    bool start() override;
    void writeMessage(const std::string& payload) override;
    void setMessageListener(std::shared_ptr<MessageListenerInterface> messageListener) override;
    void stop() override;
    bool isReady() override;
    void setObserver(const std::shared_ptr<communication::MessagingServerObserverInterface>& observer) override;

    void onConnectionOpened() override;
    void onConnectionClosed() override;

    void onMessage(const std::string& jsonMessage) override;

    void onAuthStateChange(AuthObserverInterface::State newState, AuthObserverInterface::Error newError) override;

    void onCapabilitiesStateChange(
        avsCommon::sdkInterfaces::CapabilitiesObserverInterface::State newState,
        avsCommon::sdkInterfaces::CapabilitiesObserverInterface::Error newError,
        const std::vector<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier>& addedOrUpdatedEndpoints,
        const std::vector<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier>& deletedEndpoints) override;

    void clearData() override;

    void notifyAuthorizationRequest(const std::string& url, const std::string& code) override;
    void notifyAuthorizationStateChange(avsCommon::sdkInterfaces::AuthObserverInterface::State state) override;

    void notifyAlexaState(const std::string& state) override;

    SampleAppReturnCode run();

    void onLogout() override;

    bool dispatch(const std::string& message) override;

    void acquireChannelRequest(const std::string& message) override;
    void releaseChannelRequest(const std::string& message) override;
    void focusChangedReport(const std::string& message) override;

    void authorizationStateRequest(const std::string& message) override;
    void alexaStateRequest(const std::string& message) override;
    void authorizationInfoRequest(const std::string& message) override;
    void localesRequest(const std::string& message) override;

    void setAplClientBridge(std::shared_ptr<AplClientBridge> aplClientBridge, bool aplVersionChanged);

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

    void addToMediaPlayerMap(
        const std::string& name,
        const std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>& mediaPlayer);

    void initIPCRouter();

    void sendCompleteAuthorizationMessage(const std::string& url, const std::string& code, const std::string& clientId);

    void sendSetAlexaStateMessage(const std::string& state);

    void sendSetAuthorizationStateMessage(const std::string& state);

    void sendSetLocalesMessage(const std::string& localeStr);

private:
    // @name RequiresShutdown Functions
    void doShutdown() override;

    class ProxyFocusObserver : public avsCommon::sdkInterfaces::ChannelObserverInterface {
    public:
        ProxyFocusObserver(
            std::string avsInterface,
            GUIToken token,
            std::shared_ptr<GUIClient> focusBridge,
            std::string channelName);

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

    private:
        const std::string m_avsInterface;

        GUIToken m_token;

        std::shared_ptr<GUIClient> m_focusBridge;

        const std::string m_channelName;
    };

    GUIClient(
        std::shared_ptr<MessagingServerInterface> serverImplementation,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& customerDataManager,
        std::shared_ptr<ipc::IPCVersionManager> ipcVersionManager,
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo);

    void serverThread();

    void sendInitRequestAndWait();

#ifdef ENABLE_COMMS
    void executeSendCallStateInfo(
        const avsCommon::sdkInterfaces::CallStateObserverInterface::CallStateInfo& callStateInfo);
#endif

    void executeSendFocusResponse(const GUIToken token, const bool result);

    void startAutoreleaseTimer(const std::string& avsInterface, const GUIToken token, const std::string& channelName);

    void autoRelease(const std::string& avsInterface, const GUIToken token, const std::string& channelName);

    void sendOnFocusChanged(const GUIToken token, const avsCommon::avs::FocusState state);

    void executeSendMessage(messages::MessageInterface& message);

    void executeWriteMessage(const std::string& payload);

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

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

    void registerNamespaces();

    void executeHandleAcceptCall(rapidjson::Document& payload);

    void executeHandleStopCall(rapidjson::Document& payload);

    void executeHandleEnableLocalVideo(rapidjson::Document& payload);

    void executeHandleDisableLocalVideo(rapidjson::Document& payload);

#ifdef ENABLE_COMMS

    void executeHandleSendDtmf(rapidjson::Document& payload);
#endif

    void reportInvalidWindowIdRuntimeError(const std::string& errorMsg, const std::string& aplToken);

    // The GUI manager implementation.
    std::shared_ptr<gui::GUIServerInterface> m_guiManager;

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

    // The server implementation.
    std::shared_ptr<MessagingServerInterface> m_serverImplementation;

    std::thread m_serverThread;

    // The thread used for init messages.
    std::thread m_initThread;

    std::mutex m_mutex;

    std::condition_variable m_cond;

    std::atomic_bool m_hasServerStarted;

    std::atomic_bool m_initMessageReceived;

    std::atomic_bool m_errorState;

    std::shared_ptr<MessageListenerInterface> m_messageListener;

    std::atomic_bool m_shouldRestart;

    std::shared_ptr<communication::MessagingServerObserverInterface> m_observer;

    std::shared_ptr<AplClientBridge> m_aplClientBridge;

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

    std::atomic_bool m_limitedInteraction;

    std::map<std::string, std::function<void(rapidjson::Document&)>> m_messageHandlers;

    std::mutex m_mapMutex;

    std::map<GUIToken, std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface>> m_focusObservers;

    std::map<GUIToken, std::shared_ptr<avsCommon::utils::timing::Timer>> m_autoReleaseTimers;

    std::shared_ptr<ipc::AudioFocusManagerHandler> m_audioFocusManagerIPCHandler;

    std::shared_ptr<ipc::SystemHandler> m_systemIPCHandler;

    std::map<std::string, std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>> m_mediaPlayerMap;

    std::shared_ptr<APLRuntimePresentationAdapter> m_aplRuntimePresentationAdapter;

    std::shared_ptr<ipc::IPCRouter> m_ipcRouter;

    std::shared_ptr<IPCAPLAgent> m_ipcAPLAgent;

    std::shared_ptr<avsCommon::utils::DeviceInfo> m_deviceInfo;

    std::string m_alexaState;

    std::string m_authState;

    std::string m_authUrl;

    std::string m_authCode;

    std::string m_localeStr;

    std::string m_clientId;
};

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

#endif  // ALEXA_CLIENT_SDK_LIBIPCSERVERSAMPLEAPP_INCLUDE_IPCSERVERSAMPLEAPP_GUI_GUICLIENT_H_