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,
 
    ENABLE_REPEAT_ONE,
 
    DISABLE_REPEAT,
 
    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;
 
#ifdef MEDIA_PORTABILITY_ENABLED
    std::string mediaSessionId;
 
    std::string correlationToken;
#endif
};
 
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;
#ifdef MEDIA_PORTABILITY_ENABLED
        std::string mediaSessionId;
        std::string correlationToken;
#endif
        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,
#ifdef MEDIA_PORTABILITY_ENABLED
            const std::string& mediaSessionId,
            const std::string& correlationToken,
#endif
            const std::string& playbackTarget) :
                playContextToken{playContextToken},
                index{index},
                offset{offset},
                skillToken{skillToken},
                playbackSessionId{playbackSessionId},
                navigation{navigation},
                preload{preload},
                playRequestor(playRequestor),
#ifdef MEDIA_PORTABILITY_ENABLED
                mediaSessionId{mediaSessionId},
                correlationToken{correlationToken},
#endif
                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,
#ifdef MEDIA_PORTABILITY_ENABLED
        const std::string& mediaSessionId,
        const std::string& correlationToken,
#endif
        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::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_