PlaylistEntry.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_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_PLAYLISTPARSER_PLAYLISTENTRY_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_PLAYLISTPARSER_PLAYLISTENTRY_H_

#include <chrono>
#include <ostream>
#include <queue>
#include <string>

#include <AVSCommon/SDKInterfaces/HTTPContentFetcherInterface.h>
#include <AVSCommon/Utils/HTTPContent.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace playlistParser {

typedef std::tuple<long, long> ByteRange;

enum class PlaylistParseResult {

    FINISHED,

    ERROR,

    STILL_ONGOING,

    // The playlist parsing was interrupted from a shutdown event
    SHUTDOWN
};

struct EncryptionInfo {
    enum class Method {
        NONE,

        AES_128,

        SAMPLE_AES
    };

    EncryptionInfo();

    EncryptionInfo(Method method, std::string url, std::string initVector = std::string());

    bool isValid() const;

    Method method;

    std::string keyURL;

    std::string initVector;

    std::chrono::milliseconds totalDuration;
};

struct PlaylistEntry {
    enum class Type {
        MEDIA_INFO,

        MEDIA_INIT_INFO,

        AUDIO_CONTENT
    };

    static PlaylistEntry createErrorEntry(const std::string& url);

    static PlaylistEntry createShutdownEntry(const std::string& url);

    static PlaylistEntry createMediaInitInfo(std::string url, ByteRange byteRange = std::make_tuple(0, 0));

    PlaylistEntry(
        std::string _url,
        std::chrono::milliseconds _duration,
        avsCommon::utils::playlistParser::PlaylistParseResult _parseResult,
        Type _type = Type::MEDIA_INFO,
        ByteRange _byteRange = std::make_tuple(0, 0),
        EncryptionInfo _encryptionInfo = EncryptionInfo(),
        std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterface> _contentFetcher = nullptr);

    bool hasValidByteRange() const;

    Type type;

    std::string url;

    std::chrono::milliseconds duration;

    PlaylistParseResult parseResult;

    ByteRange byteRange;

    EncryptionInfo encryptionInfo;

    std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterface> contentFetcher;
};

inline PlaylistEntry PlaylistEntry::createErrorEntry(const std::string& url) {
    return PlaylistEntry(
        url, std::chrono::milliseconds(-1), PlaylistParseResult::ERROR, Type::MEDIA_INFO, std::make_tuple(0, 0));
}

inline PlaylistEntry PlaylistEntry::createShutdownEntry(const std::string& url) {
    return PlaylistEntry(
        url, std::chrono::milliseconds(-1), PlaylistParseResult::SHUTDOWN, Type::MEDIA_INFO, std::make_tuple(0, 0));
}

inline PlaylistEntry PlaylistEntry::createMediaInitInfo(std::string url, ByteRange byteRange) {
    auto duration = std::chrono::milliseconds(-1);
    return PlaylistEntry(url, duration, PlaylistParseResult::STILL_ONGOING, Type::MEDIA_INIT_INFO, byteRange);
}

inline EncryptionInfo::EncryptionInfo() : method(Method::NONE) {
}

inline EncryptionInfo::EncryptionInfo(Method method, std::string url, std::string initVector) :
        method(method),
        keyURL(url),
        initVector(initVector) {
}

inline bool EncryptionInfo::isValid() const {
    return (Method::NONE == method) || (Method::NONE != method && !keyURL.empty() && !initVector.empty());
}

inline bool PlaylistEntry::hasValidByteRange() const {
    long start, end;
    std::tie(start, end) = byteRange;
    return start >= 0 && end > 0;
}

inline PlaylistEntry::PlaylistEntry(
    std::string _url,
    std::chrono::milliseconds _duration,
    avsCommon::utils::playlistParser::PlaylistParseResult _parseResult,
    Type _type,
    ByteRange _byteRange,
    EncryptionInfo _encryptionInfo,
    std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterface> _contentFetcher) :
        type(_type),
        url(_url),
        duration(_duration),
        parseResult(_parseResult),
        byteRange(_byteRange),
        encryptionInfo(_encryptionInfo),
        contentFetcher(_contentFetcher) {
}

}  // namespace playlistParser
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_PLAYLISTPARSER_PLAYLISTENTRY_H_