storage.h

Go to the documentation of this file.

// Copyright 2019 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_STORAGE_H_
#define SHAKA_EMBEDDED_STORAGE_H_

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

#include "async_results.h"
#include "macros.h"
#include "offline_externs.h"
#include "player.h"

namespace shaka {

class JsManager;

class SHAKA_EXPORT Storage final {
 public:
  class Client {
   public:
    SHAKA_DECLARE_INTERFACE_METHODS(Client);


    virtual void OnProgress(StoredContent content, double progress);
  };

  Storage(JsManager* engine, Player* player = nullptr);
  Storage(Storage&&);
  ~Storage();

  Storage& operator=(Storage&&);

  SHAKA_NON_COPYABLE_TYPE(Storage);

  static AsyncResults<bool> Support(JsManager* engine);

  static AsyncResults<void> DeleteAll(JsManager* engine);


  AsyncResults<void> Initialize(Client* client = nullptr);

  AsyncResults<void> Destroy();


  AsyncResults<bool> GetStoreInProgress();



  AsyncResults<bool> Configure(const std::string& name_path, DefaultValueType);
  AsyncResults<bool> Configure(const std::string& name_path, bool value);
  AsyncResults<bool> Configure(const std::string& name_path, double value);
  AsyncResults<bool> Configure(const std::string& name_path,
                               const std::string& value);
  template <typename T, typename = typename std::enable_if<
                            std::is_arithmetic<T>::value>::type>
  AsyncResults<bool> Configure(const std::string& name_path, T value) {
    // Since there are both bool and double overloads, any other number type
    // will cause an ambiguous call.  This disambiguates the calls.
    return Configure(name_path, static_cast<double>(value));
  }
  AsyncResults<bool> Configure(const std::string& name_path,
                               const char* value) {
    // For some reason, the compiler tries to use the bool overload over the
    // std::string one when passing a char pointer.
    return Configure(name_path, std::string(value));
  }


  AsyncResults<std::vector<StoredContent>> List();

  AsyncResults<void> Remove(const std::string& content_uri);

  AsyncResults<bool> RemoveEmeSessions();

  AsyncResults<StoredContent> Store(const std::string& uri);

  AsyncResults<StoredContent> Store(
      const std::string& uri,
      const std::unordered_map<std::string, std::string>& app_metadata);

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

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_STORAGE_H_