ExternalMediaPlayer.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 ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAPLAYER_H_
#define ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAPLAYER_H_

#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <unordered_map>
#include <utility>

#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/DirectiveHandlerConfiguration.h>
#include <AVSCommon/AVS/NamespaceAndName.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/SDKInterfaces/LocalPlaybackHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/PlaybackHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/PlaybackRouterInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderRegistrarInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointBuilderInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <CertifiedSender/CertifiedSender.h>
#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaAdapterInterface.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaAdapterHandlerInterface.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaPlayerInterface.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaPlayerObserverInterface.h>
#include <acsdkManufactory/Annotated.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <acsdkStartupManagerInterfaces/RequiresStartupInterface.h>
#include <acsdkStartupManagerInterfaces/StartupNotifierInterface.h>

#include "acsdkExternalMediaPlayer/AuthorizedSender.h"
#include "acsdkExternalMediaPlayer/StaticExternalMediaPlayerAdapterHandler.h"

namespace alexaClientSDK {
namespace acsdkExternalMediaPlayer {

class ExternalMediaPlayer
        : public avsCommon::avs::CapabilityAgent
        , public avsCommon::utils::RequiresShutdown
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface
        , public avsCommon::sdkInterfaces::MediaPropertiesInterface
        , public avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface
        , public avsCommon::sdkInterfaces::PlaybackHandlerInterface
        , public avsCommon::sdkInterfaces::LocalPlaybackHandlerInterface
        , public acsdkStartupManagerInterfaces::RequiresStartupInterface
        , public std::enable_shared_from_this<ExternalMediaPlayer> {
public:
    // Map of adapter business names to their mediaPlayers.
    using AdapterMediaPlayerMap =
        std::unordered_map<std::string, std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>>;

    // Map of adapter business names to their speakers.
    using AdapterSpeakerMap =
        std::unordered_map<std::string, std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>>;

    // Signature of functions to create an ExternalMediaAdapter.
    using AdapterCreateFunction =
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterInterface> (*)(
            std::shared_ptr<alexaClientSDK::avsCommon::utils::metrics::MetricRecorderInterface>,
            std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
            std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> speaker,
            std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager,
            std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
            std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
            std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
            std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface> externalMediaPlayer);

    // Map of adapter business names to their creation method.
    using AdapterCreationMap = std::unordered_map<std::string, AdapterCreateFunction>;

    static constexpr const char* SPI_VERSION = "1.0";

    static std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface>
    createExternalMediaPlayerInterface(std::shared_ptr<ExternalMediaPlayer> externalMediaPlayer);

    static std::shared_ptr<ExternalMediaPlayer> createExternalMediaPlayer(
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface> endpointCapabilitiesRegistrar,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface> shutdownNotifier,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupNotifierInterface> startupNotifier,
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>
            renderPlayerInfoCardsProviderRegistrar,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder);

    static std::shared_ptr<ExternalMediaPlayer> createExternalMediaPlayerWithAdapters(
        const acsdkExternalMediaPlayer::ExternalMediaPlayer::AdapterCreationMap& adapterCreationMap,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>
            audioPipelineFactory,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::AudioFocusAnnotation,
            avsCommon::sdkInterfaces::FocusManagerInterface> audioFocusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface> endpointCapabilitiesRegistrar,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface> shutdownNotifier,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupNotifierInterface> startupNotifier,
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>
            renderPlayerInfoCardsProviderRegistrar,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager);

    void onContextAvailable(const std::string& jsonContext) override;
    void onContextFailure(const avsCommon::sdkInterfaces::ContextRequestError error) override;

    void provideState(const avsCommon::avs::NamespaceAndName& stateProviderName, unsigned int stateRequestToken)
        override;

    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;
    void onDeregistered() override;
    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;

    virtual void onButtonPressed(avsCommon::avs::PlaybackButton button) override;

    virtual void onTogglePressed(avsCommon::avs::PlaybackToggle toggle, bool action) override;

    virtual void setPlayerInFocus(const std::string& playerInFocus) override;
    virtual void updateDiscoveredPlayers(
        const std::vector<acsdkExternalMediaPlayerInterfaces::DiscoveredPlayerInfo>& addedPlayers,
        const std::unordered_set<std::string>& removedLocalPlayerIds) override;
    virtual void addAdapterHandler(
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface> adapterHandler)
        override;
    virtual void removeAdapterHandler(
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface> adapterHandler)
        override;
    virtual void addObserver(
        const std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerObserverInterface> observer)
        override;
    virtual void removeObserver(
        const std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerObserverInterface> observer)
        override;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;

    void setObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsObserverInterface> observer) override;

    bool localOperation(PlaybackOperation op) override;
    bool localSeekTo(std::chrono::milliseconds location, bool fromStart) override;

    std::chrono::milliseconds getAudioItemOffset() override;
    std::chrono::milliseconds getAudioItemDuration() override;

    std::map<std::string, std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterInterface>>
    getAdaptersMap();

    bool startup() override;

private:
    struct LocalPlayerIdHandler {
        std::string localPlayerId;
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface> adapterHandler;
    };

    static std::shared_ptr<ExternalMediaPlayer> create(
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface> endpointCapabilitiesRegistrar,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface> shutdownNotifier,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupNotifierInterface> startupNotifier,
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>
            renderPlayerInfoCardsProviderRegistrar,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder);

    ExternalMediaPlayer(
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder);

    bool init();

    void createAdapters(
        const AdapterCreationMap& adapterCreationMap,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>
            audioPipelineFactory,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager);

    std::string provideSessionState(std::vector<acsdkExternalMediaPlayerInterfaces::AdapterState> adapterStates);

    std::string providePlaybackState(std::vector<acsdkExternalMediaPlayerInterfaces::AdapterState> adapterStates);

    bool parseDirectivePayload(std::shared_ptr<DirectiveInfo> info, rapidjson::Document* document);

    void removeDirective(std::shared_ptr<DirectiveInfo> info);

    void doShutdown() override;

    void sendReportDiscoveredPlayersEvent(
        const std::vector<acsdkExternalMediaPlayerInterfaces::DiscoveredPlayerInfo>& discoveredPlayers);

    void sendAuthorizationCompleteEvent(
        const std::unordered_map<std::string, std::string>& authorized,
        const std::unordered_set<std::string>& deauthorized);

    void setHandlingCompleted(std::shared_ptr<DirectiveInfo> info);

    void sendExceptionEncounteredAndReportFailed(
        std::shared_ptr<DirectiveInfo> info,
        const std::string& message,
        avsCommon::avs::ExceptionErrorType type = avsCommon::avs::ExceptionErrorType::INTERNAL_ERROR);


    void executeProvideState(
        const avsCommon::avs::NamespaceAndName& stateProviderName,
        bool sendToken = false,
        unsigned int stateRequestToken = 0);

    bool preprocessDirective(std::shared_ptr<DirectiveInfo> info, rapidjson::Document* document);

    avsCommon::utils::Optional<LocalPlayerIdHandler> getHandlerFromPlayerId(const std::string& playerId);

    void handleAuthorizeDiscoveredPlayers(
        std::shared_ptr<DirectiveInfo> info,
        acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handleLogin(std::shared_ptr<DirectiveInfo> info, acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handleLogout(std::shared_ptr<DirectiveInfo> info, acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handlePlay(std::shared_ptr<DirectiveInfo> info, acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handlePlayControl(
        std::shared_ptr<DirectiveInfo> info,
        acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handleSeek(std::shared_ptr<DirectiveInfo> info, acsdkExternalMediaPlayerInterfaces::RequestType request);

    void handleAdjustSeek(std::shared_ptr<DirectiveInfo> info, acsdkExternalMediaPlayerInterfaces::RequestType request);

    void notifyObservers(
        const std::string& playerId,
        const acsdkExternalMediaPlayerInterfaces::ObservableSessionProperties* sessionProperties);

    void notifyObservers(
        const std::string& playerId,
        const acsdkExternalMediaPlayerInterfaces::ObservablePlaybackStateProperties* playbackProperties);

    void notifyObservers(
        const std::string& playerId,
        const acsdkExternalMediaPlayerInterfaces::ObservableSessionProperties* sessionProperties,
        const acsdkExternalMediaPlayerInterfaces::ObservablePlaybackStateProperties* playbackProperties);

    void notifyRenderPlayerInfoCardsObservers();

    std::string m_agentString;

    std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;

    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;

    std::shared_ptr<certifiedSender::CertifiedSender> m_certifiedMessageSender;

    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;

    std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> m_playbackRouter;

    std::mutex m_authorizedMutex;

    std::unordered_map<std::string, LocalPlayerIdHandler> m_authorizedAdapters;

    std::map<std::string, std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterInterface>>
        m_staticAdapters;

    std::string m_playerInFocus;

    std::mutex m_inFocusAdapterMutex;

    std::shared_ptr<AuthorizedSender> m_authorizedSender;

    std::mutex m_observersMutex;

    std::unordered_set<std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerObserverInterface>>
        m_observers;

    std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsObserverInterface> m_renderPlayerObserver;

    std::queue<std::pair<std::string, std::string>> m_eventQueue;

    typedef void (ExternalMediaPlayer::*DirectiveHandler)(
        std::shared_ptr<DirectiveInfo> info,
        acsdkExternalMediaPlayerInterfaces::RequestType request);

    static std::unordered_map<
        avsCommon::avs::NamespaceAndName,
        std::pair<acsdkExternalMediaPlayerInterfaces::RequestType, ExternalMediaPlayer::DirectiveHandler>>
        m_directiveToHandlerMap;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;

    std::unordered_set<std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface>>
        m_adapterHandlers;

    std::unordered_set<std::string> m_reportedDiscoveredPlayers;

    std::unordered_map<std::string, acsdkExternalMediaPlayerInterfaces::DiscoveredPlayerInfo>
        m_unreportedPlayersToReportAtStartup;

    std::mutex m_onStartupHasBeenCalledMutex;

    bool m_onStartupHasBeenCalled;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::FocusManagerInterface> m_focusManager;

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

}  // namespace acsdkExternalMediaPlayer
}  // namespace alexaClientSDK

#endif  // ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAPLAYER_H_