net.h

Go to the documentation of this file.

// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License 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 SHAKA_EMBEDDED_NET_H_
#define SHAKA_EMBEDDED_NET_H_

#include <future>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include "error.h"
#include "macros.h"
#include "optional.h"

namespace shaka {

namespace js {
struct Request;
struct Response;
}  // namespace js

enum class RequestType : int8_t {
  Unknown = -1,

  Manifest = 0,
  Segment = 1,
  License = 2,
  App = 3,
  Timing = 4,
};

class SHAKA_EXPORT Request final {
 public:
  ~Request();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(Request);

  std::vector<std::string> uris;

  std::string method;

  std::unordered_map<std::string, std::string> headers;


  const uint8_t* body() const;

  size_t body_size() const;

  void SetBodyCopy(const uint8_t* data, size_t size);

 private:
  friend class JsManager;
  friend class Player;
  Request(js::Request&& request);

  void Finalize();

  class Impl;
  std::unique_ptr<Impl> impl_;
};

class SHAKA_EXPORT Response final {
 public:
  ~Response();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(Response);

  std::string uri;

  std::string originalUri;

  std::unordered_map<std::string, std::string> headers;

  optional<double> timeMs;

  optional<bool> fromCache;


  const uint8_t* data() const;

  size_t data_size() const;

  void SetDataCopy(const uint8_t* data, size_t size);

 private:
  friend class JsManager;
  friend class Player;
  Response();
  Response(js::Response&& response);

  void Finalize();
  js::Response* JsObject();

  class Impl;
  std::unique_ptr<Impl> impl_;
};

class SHAKA_EXPORT SchemePlugin {
 public:
  SHAKA_DECLARE_INTERFACE_METHODS(SchemePlugin);

  class Client {
   public:
    SHAKA_DECLARE_INTERFACE_METHODS(Client);

    virtual void OnProgress(double time, uint64_t bytes,
                            uint64_t remaining) = 0;
  };


  virtual std::future<optional<Error>> OnNetworkRequest(const std::string& uri,
                                                        RequestType type,
                                                        const Request& request,
                                                        Client* client,
                                                        Response* response) = 0;
};

class SHAKA_EXPORT NetworkFilters {
 public:
  SHAKA_DECLARE_INTERFACE_METHODS(NetworkFilters);

  virtual std::future<optional<Error>> OnRequestFilter(RequestType type,
                                                       Request* request);

  virtual std::future<optional<Error>> OnResponseFilter(RequestType type,
                                                        Response* response);
};

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_NET_H_