HTTPContentFetcherInterface.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_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_HTTPCONTENTFETCHERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_HTTPCONTENTFETCHERINTERFACE_H_

#include <memory>

#include <AVSCommon/Utils/HTTP/HttpResponseCode.h>
#include <AVSCommon/Utils/HTTPContent.h>
#include <AVSCommon/Utils/SDKVersion.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

class HTTPContentFetcherInterface {
public:
    enum class FetchOptions {
        CONTENT_TYPE,
        ENTIRE_BODY
    };

    enum class State {
        INITIALIZED,
        FETCHING_HEADER,
        HEADER_DONE,
        FETCHING_BODY,
        BODY_DONE,
        ERROR
    };

    struct Header {
        bool successful;
        avsCommon::utils::http::HTTPResponseCode responseCode;
        std::string contentType;
        ssize_t contentLength;

        Header() :
                successful(false),
                responseCode(avsCommon::utils::http::HTTPResponseCode::HTTP_RESPONSE_CODE_UNDEFINED),
                contentType(""),
                contentLength(0) {
        }
    };

    virtual ~HTTPContentFetcherInterface() = default;

    virtual State getState() = 0;

    virtual std::string getUrl() const = 0;

    virtual std::string getEffectiveUrl() const = 0;

    virtual Header getHeader(std::atomic<bool>* shouldShutdown) = 0;

    virtual bool getBody(std::shared_ptr<avsCommon::avs::attachment::AttachmentWriter> writer) = 0;

    virtual void shutdown() = 0;

    virtual std::unique_ptr<avsCommon::utils::HTTPContent> getContent(
        FetchOptions option,
        std::unique_ptr<avsCommon::avs::attachment::AttachmentWriter> writer = nullptr,
        const std::vector<std::string>& customHeaders = std::vector<std::string>()) = 0;

    static std::string getUserAgent();

    static std::string stateToString(State state);
};

inline std::string HTTPContentFetcherInterface::getUserAgent() {
    return "AvsDeviceSdk/" + utils::sdkVersion::getCurrentVersion();
}

inline std::string HTTPContentFetcherInterface::stateToString(HTTPContentFetcherInterface::State state) {
    switch (state) {
        case State::INITIALIZED:
            return "INITIALIZED";
        case State::FETCHING_HEADER:
            return "FETCHING_HEADER";
        case State::HEADER_DONE:
            return "HEADER_DONE";
        case State::FETCHING_BODY:
            return "FETCHING_BODY";
        case State::BODY_DONE:
            return "BODY_DONE";
        case State::ERROR:
            return "ERROR";
    }
    return "";
}

inline std::ostream& operator<<(std::ostream& os, const HTTPContentFetcherInterface::State& state) {
    os << HTTPContentFetcherInterface::stateToString(state);
    return os;
}

}  // namespace sdkInterfaces
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_HTTPCONTENTFETCHERINTERFACE_H_