ExternalMediaAdapterHandler.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_ACSDKEXTERNALMEDIAPLAYER_INCLUDE_ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAADAPTERHANDLER_H_
#define ALEXA_CLIENT_SDK_ACSDKEXTERNALMEDIAPLAYER_INCLUDE_ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAADAPTERHANDLER_H_

#include <functional>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>

#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <rapidjson/document.h>

#include "acsdkExternalMediaPlayerInterfaces/ExternalMediaAdapterHandlerInterface.h"
#include "acsdkExternalMediaPlayerInterfaces/ExternalMediaPlayerInterface.h"

namespace alexaClientSDK {
namespace acsdkExternalMediaPlayer {

struct AuthorizedPlayerInfo {
public:
    std::string localPlayerId;
    bool authorized;
    std::string defaultSkillToken;
    std::string playerId;
};

class ExternalMediaAdapterHandler
        : public avsCommon::sdkInterfaces::SpeakerManagerObserverInterface
        , public acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface
        , public std::enable_shared_from_this<ExternalMediaAdapterHandler> {
protected:
    ExternalMediaAdapterHandler(const std::string& name);

    bool initializeAdapterHandler(
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager);

    bool validatePlayer(const std::string& localPlayerId, bool checkAuthorized = true);

    std::string createExternalMediaPlayerEvent(
        const std::string& localPlayerId,
        const std::string& event,
        bool includePlaybackSessionId = false,
        std::function<void(rapidjson::Value::Object&, rapidjson::Value::AllocatorType&)> createPayload =
            [](rapidjson::Value::Object& v, rapidjson::Value::AllocatorType& a) {});

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

    bool removeDiscoveredPlayer(const std::string& localPlayerId);


    virtual bool handleAuthorization(const AuthorizedPlayerInfo& authorizedPlayer) = 0;

    virtual bool handleLogin(
        const std::string& localPlayerId,
        const std::string& accessToken,
        const std::string& userName,
        bool forceLogin,
        std::chrono::milliseconds tokenRefreshInterval) = 0;

    virtual bool handleLogout(const std::string& localPlayerId) = 0;

    virtual bool handlePlay(const ExternalMediaAdapterHandlerInterface::PlayParams& params) = 0;

    virtual bool handlePlayControl(
        const std::string& localPlayerId,
        acsdkExternalMediaPlayerInterfaces::RequestType requestType,
        const std::string& playbackTarget) = 0;

    virtual bool handleSeek(const std::string& localPlayerId, std::chrono::milliseconds offset) = 0;

    virtual bool handleAdjustSeek(const std::string& localPlayerId, std::chrono::milliseconds deltaOffset) = 0;

    virtual bool handleGetAdapterState(
        const std::string& localPlayerId,
        acsdkExternalMediaPlayerInterfaces::AdapterState& state) = 0;

    virtual std::chrono::milliseconds handleGetOffset(const std::string& localPlayerId);

    virtual void handleSetVolume(int8_t volume) = 0;

    virtual void handleSetMute(bool mute) = 0;

    virtual void doShutdown() override;

    std::weak_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface> m_externalMediaPlayer;

public:
    std::vector<acsdkExternalMediaPlayerInterfaces::PlayerInfo> updatePlayerInfo(
        const std::vector<acsdkExternalMediaPlayerInterfaces::PlayerInfo>& playerList) override;
    bool login(
        const std::string& localPlayerId,
        const std::string& accessToken,
        const std::string& userName,
        bool forceLogin,
        std::chrono::milliseconds tokenRefreshInterval) override;
    bool logout(const std::string& localPlayerId) override;
    bool play(const PlayParams& params) override;
    bool playControl(
        const std::string& localPlayerId,
        acsdkExternalMediaPlayerInterfaces::RequestType requestType,
        const std::string& playbackTarget) override;
    bool seek(const std::string& localPlayerId, std::chrono::milliseconds offset) override;
    bool adjustSeek(const std::string& localPlayerId, std::chrono::milliseconds deltaOffset) override;
    acsdkExternalMediaPlayerInterfaces::AdapterState getAdapterState(const std::string& localPlayerId) override;
    std::vector<acsdkExternalMediaPlayerInterfaces::AdapterState> getAdapterStates() override;
    std::chrono::milliseconds getOffset(const std::string& localPlayerId) override;
    void setExternalMediaPlayer(const std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface>
                                    externalMediaPlayer) override;

    void onSpeakerSettingsChanged(
        const Source& source,
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings) override;

private:
    std::unordered_map<std::string, acsdkExternalMediaPlayerInterfaces::PlayerInfo> m_playerInfoMap;

    bool m_muted;

    int8_t m_volume;

    std::mutex m_mutex;

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

    std::condition_variable m_attemptedSetFocusPlayerInFocusCondition;
};

}  // namespace acsdkExternalMediaPlayer
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKEXTERNALMEDIAPLAYER_INCLUDE_ACSDKEXTERNALMEDIAPLAYER_EXTERNALMEDIAADAPTERHANDLER_H_