ExternalMediaAdapterInterface.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_ACSDKEXTERNALMEDIAPLAYERINTERFACES_INCLUDE_ACSDKEXTERNALMEDIAPLAYERINTERFACES_EXTERNALMEDIAADAPTERINTERFACE_H_
#define ALEXA_CLIENT_SDK_ACSDKEXTERNALMEDIAPLAYERINTERFACES_INCLUDE_ACSDKEXTERNALMEDIAPLAYERINTERFACES_EXTERNALMEDIAADAPTERINTERFACE_H_

#include <chrono>
#include <set>
#include <string>
#include <unordered_map>

#include <AVSCommon/AVS/PlayRequestor.h>
#include <AVSCommon/Utils/RequiresShutdown.h>

namespace alexaClientSDK {
namespace acsdkExternalMediaPlayerInterfaces {

enum class RequestType {
    INIT,

    DEINIT,

    LOGIN,

    LOGOUT,

    REGISTER,

    PLAY,

    RESUME,

    PAUSE,

    STOP,

    PAUSE_RESUME_TOGGLE,

    NEXT,

    PREVIOUS,

    START_OVER,

    FAST_FORWARD,

    REWIND,

    ENABLE_REPEAT_ONE,

    DISABLE_REPEAT_ONE,

    ENABLE_REPEAT,

    DISABLE_REPEAT,

    ENABLE_SHUFFLE,

    DISABLE_SHUFFLE,

    FAVORITE,

    DESELECT_FAVORITE,

    UNFAVORITE,

    DESELECT_UNFAVORITE,

    SEEK,

    ADJUST_SEEK,

    SET_VOLUME,

    ADJUST_VOLUME,

    SET_MUTE,

    SET_DISPLAY_NAME,

    GET_INFO,

    ADD_USER,

    RESET_USER,

    NONE
};

enum class SupportedPlaybackOperation {
    PLAY,

    RESUME,

    PAUSE,

    STOP,

    NEXT,

    PREVIOUS,

    START_OVER,

    FAST_FORWARD,

    REWIND,

    ENABLE_REPEAT,

    DISABLE_REPEAT,

    ENABLE_REPEAT_ONE,

    DISABLE_REPEAT_ONE,

    ENABLE_SHUFFLE,

    DISABLE_SHUFFLE,

    FAVORITE,

    UNFAVORITE,

    SEEK,

    ADJUST_SEEK,

};

enum class ChangeCauseType {
    VOICE_INTERACTION,

    PHYSICAL_INTERACTION,

    APP_INTERACTION,

    RULE_TRIGGER,

    PERIODIC_POLL
};

enum class Favorites {
    FAVORITED,

    UNFAVORITED,

    NOT_RATED
};

enum class MediaType {
    TRACK,

    PODCAST,

    STATION,

    AD,

    SAMPLE,

    OTHER
};

enum class Navigation {
    DEFAULT,
    NONE,
    FOREGROUND
};

inline std::string navigationToString(Navigation navigation) {
    switch (navigation) {
        case Navigation::DEFAULT:
            return "DEFAULT";
        case Navigation::NONE:
            return "NONE";
        case Navigation::FOREGROUND:
            return "FOREGROUND";
    }
    return "";
}

inline std::ostream& operator<<(std::ostream& stream, const Navigation& navigation) {
    return stream << navigationToString(navigation);
}

inline Navigation stringToNavigation(const std::string& str) {
    if (str == "DEFAULT") {
        return Navigation::DEFAULT;
    } else if (str == "NONE") {
        return Navigation::NONE;
    } else if (str == "FOREGROUND") {
        return Navigation::FOREGROUND;
    } else {
        // default to DEFAULT
        return Navigation::DEFAULT;
    }
}

struct AdapterSessionState {
    /*
     * Default Constructor.
     */
    AdapterSessionState();

    std::string playerId;

    std::string localPlayerId;

    std::string endpointId;

    bool loggedIn;

    std::string userName;

    bool isGuest;

    bool launched;

    bool active;

    std::string spiVersion;

    std::string playerCookie;

    std::string skillToken;

    std::string playbackSessionId;

    std::string accessToken;

    std::chrono::milliseconds tokenRefreshInterval;
};

struct AdapterPlaybackState {
    AdapterPlaybackState();

    std::string playerId;

    std::string state;

    std::set<SupportedPlaybackOperation> supportedOperations;

    std::chrono::milliseconds trackOffset;

    bool shuffleEnabled;

    bool repeatEnabled;

    Favorites favorites;

    std::string type;

    std::string playbackSource;

    std::string playbackSourceId;

    std::string playbackId;

    std::string trackName;

    std::string trackId;

    std::string trackNumber;

    std::string artistName;

    std::string artistId;

    std::string albumName;

    std::string albumId;

    std::string tinyURL;

    std::string smallURL;

    std::string mediumURL;

    std::string largeURL;

    std::string coverId;

    std::string mediaProvider;

    MediaType mediaType;

    std::chrono::milliseconds duration;

    avsCommon::avs::PlayRequestor playRequestor;
};

class AdapterState {
public:
    AdapterState() = default;

    AdapterSessionState sessionState;

    AdapterPlaybackState playbackState;
};

class ExternalMediaAdapterInterface : public virtual avsCommon::utils::RequiresShutdown {
public:
    explicit ExternalMediaAdapterInterface(const std::string& adapterName);

    virtual ~ExternalMediaAdapterInterface() = default;

    struct HandlePlayParams {
        std::string playContextToken;
        int64_t index;
        std::chrono::milliseconds offset;
        std::string skillToken;
        std::string playbackSessionId;
        Navigation navigation;
        bool preload;
        avsCommon::avs::PlayRequestor playRequestor;
        std::string playbackTarget;

        HandlePlayParams(
            const std::string& playContextToken,
            int64_t index,
            std::chrono::milliseconds offset,
            const std::string& skillToken,
            const std::string& playbackSessionId,
            Navigation navigation,
            bool preload,
            const avsCommon::avs::PlayRequestor& playRequestor,
            const std::string& playbackTarget) :
                playContextToken{playContextToken},
                index{index},
                offset{offset},
                skillToken{skillToken},
                playbackSessionId{playbackSessionId},
                navigation{navigation},
                preload{preload},
                playRequestor(playRequestor),
                playbackTarget{playbackTarget} {
        }
    };

    virtual void init() = 0;

    virtual void deInit() = 0;

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

    virtual void handleLogout() = 0;

    virtual void handlePlay(const HandlePlayParams& params) = 0;

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

    virtual void handleSeek(std::chrono::milliseconds offset) = 0;

    virtual void handleAdjustSeek(std::chrono::milliseconds deltaOffset) = 0;

    virtual void handleAuthorized(
        bool authorized,
        const std::string& playerId,
        const std::string& defaultSkillToken) = 0;

    virtual AdapterState getState() = 0;

    virtual std::chrono::milliseconds getOffset() = 0;
};

inline AdapterSessionState::AdapterSessionState() : loggedIn{false}, isGuest{false}, launched{false}, active{false} {
}

inline AdapterPlaybackState::AdapterPlaybackState() :
        state{"IDLE"},
        trackOffset{0},
        shuffleEnabled{false},
        repeatEnabled{false},
        favorites{Favorites::NOT_RATED},
        mediaType{MediaType::TRACK},
        duration{0} {
}

inline ExternalMediaAdapterInterface::ExternalMediaAdapterInterface(const std::string& adapterName) :
        RequiresShutdown{adapterName} {
}

inline std::string RequestTypeToString(RequestType requestType) {
    switch (requestType) {
        case RequestType::INIT:
            return "INIT";
        case RequestType::DEINIT:
            return "DEINIT";
        case RequestType::LOGIN:
            return "LOGIN";
        case RequestType::LOGOUT:
            return "LOGOUT";
        case RequestType::REGISTER:
            return "REGISTER";
        case RequestType::PLAY:
            return "PLAY";
        case RequestType::RESUME:
            return "RESUME";
        case RequestType::PAUSE:
            return "PAUSE";
        case RequestType::STOP:
            return "STOP";
        case RequestType::PAUSE_RESUME_TOGGLE:
            return "PAUSE_RESUME_TOGGLE";
        case RequestType::NEXT:
            return "NEXT";
        case RequestType::PREVIOUS:
            return "PREVIOUS";
        case RequestType::START_OVER:
            return "START_OVER";
        case RequestType::FAST_FORWARD:
            return "FAST_FORWARD";
        case RequestType::REWIND:
            return "REWIND";
        case RequestType::ENABLE_REPEAT_ONE:
            return "ENABLE_REPEAT_ONE";
        case RequestType::DISABLE_REPEAT_ONE:
            return "DISABLE_REPEAT_ONE";
        case RequestType::ENABLE_REPEAT:
            return "ENABLE_REPEAT";
        case RequestType::DISABLE_REPEAT:
            return "DISABLE_REPEAT";
        case RequestType::ENABLE_SHUFFLE:
            return "ENABLE_SHUFFLE";
        case RequestType::DISABLE_SHUFFLE:
            return "DISABLE_SHUFFLE";
        case RequestType::FAVORITE:
            return "FAVORITE";
        case RequestType::DESELECT_FAVORITE:
            return "DESELECT_FAVORITE";
        case RequestType::UNFAVORITE:
            return "UNFAVORITE";
        case RequestType::DESELECT_UNFAVORITE:
            return "DESELECT_UNFAVORITE";
        case RequestType::SEEK:
            return "SEEK";
        case RequestType::ADJUST_SEEK:
            return "ADJUST_SEEK";
        case RequestType::SET_VOLUME:
            return "SET_VOLUME";
        case RequestType::ADJUST_VOLUME:
            return "ADJUST_VOLUME";
        case RequestType::SET_MUTE:
            return "SET_MUTE";
        case RequestType::SET_DISPLAY_NAME:
            return "SET_DISPLAY_NAME";
        case RequestType::GET_INFO:
            return "GET_INFO";
        case RequestType::ADD_USER:
            return "ADD_USER";
        case RequestType::RESET_USER:
            return "RESET_USER";
        case RequestType::NONE:
            return "NONE";
    }

    return "unknown request type";
}

inline std::string SupportedPlaybackOperationToString(SupportedPlaybackOperation operation) {
    switch (operation) {
        case SupportedPlaybackOperation::PLAY:
            return "Play";
        case SupportedPlaybackOperation::RESUME:
            return "Resume";
        case SupportedPlaybackOperation::PAUSE:
            return "Pause";
        case SupportedPlaybackOperation::STOP:
            return "Stop";
        case SupportedPlaybackOperation::NEXT:
            return "Next";
        case SupportedPlaybackOperation::PREVIOUS:
            return "Previous";
        case SupportedPlaybackOperation::START_OVER:
            return "StartOver";
        case SupportedPlaybackOperation::FAST_FORWARD:
            return "FastForward";
        case SupportedPlaybackOperation::REWIND:
            return "Rewind";
        case SupportedPlaybackOperation::ENABLE_REPEAT:
            return "EnableRepeat";
        case SupportedPlaybackOperation::ENABLE_REPEAT_ONE:
            return "EnableRepeatOne";
        case SupportedPlaybackOperation::DISABLE_REPEAT:
            return "DisableRepeat";
        case SupportedPlaybackOperation::DISABLE_REPEAT_ONE:
            return "DisableRepeatOne";
        case SupportedPlaybackOperation::ENABLE_SHUFFLE:
            return "EnableShuffle";
        case SupportedPlaybackOperation::DISABLE_SHUFFLE:
            return "DisableShuffle";
        case SupportedPlaybackOperation::FAVORITE:
            return "Favorite";
        case SupportedPlaybackOperation::UNFAVORITE:
            return "Unfavorite";
        case SupportedPlaybackOperation::SEEK:
            return "SetSeekPosition";
        case SupportedPlaybackOperation::ADJUST_SEEK:
            return "AdjustSeekPosition";
    }

    return "unknown operation";
}

inline std::string ChangeTriggerToString(ChangeCauseType changeType) {
    switch (changeType) {
        case ChangeCauseType::VOICE_INTERACTION:
            return "VOICE_INTERACTION";
        case ChangeCauseType::PHYSICAL_INTERACTION:
            return "PHYSICAL_INTERACTION";
        case ChangeCauseType::APP_INTERACTION:
            return "APP_INTERACTION";
        case ChangeCauseType::RULE_TRIGGER:
            return "RULE_TRIGGER";
        case ChangeCauseType::PERIODIC_POLL:
            return "PERIODIC_POLL";
    }

    return "unknown changeTrigger";
}

inline std::string RatingToString(Favorites rating) {
    switch (rating) {
        case Favorites::FAVORITED:
            return "FAVORITED";
        case Favorites::UNFAVORITED:
            return "UNFAVORITED";
        case Favorites::NOT_RATED:
            return "NOT_RATED";
    }

    return "unknown rating";
}

inline std::string MediaTypeToString(MediaType mediaType) {
    switch (mediaType) {
        case MediaType::TRACK:
            return "TRACK";
        case MediaType::PODCAST:
            return "PODCAST";
        case MediaType::STATION:
            return "STATION";
        case MediaType::AD:
            return "AD";
        case MediaType::SAMPLE:
            return "SAMPLE";
        case MediaType::OTHER:
            return "OTHER";
    }

    return "unknown mediaType";
}

inline std::string SHUFFLE_STATUS_STRING(bool shuffleEnabled) {
    return (shuffleEnabled == true) ? "SHUFFLED" : "NOT_SHUFFLED";
}

inline std::string REPEAT_STATUS_STRING(bool repeatEnabled) {
    return (repeatEnabled == true) ? "REPEATED" : "NOT_REPEATED";
}

}  // namespace acsdkExternalMediaPlayerInterfaces
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKEXTERNALMEDIAPLAYERINTERFACES_INCLUDE_ACSDKEXTERNALMEDIAPLAYERINTERFACES_EXTERNALMEDIAADAPTERINTERFACE_H_