player.h

Go to the documentation of this file.

// Copyright 2016 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_PLAYER_H_
#define SHAKA_EMBEDDED_PLAYER_H_

#include <math.h>

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

#include "async_results.h"
#include "error.h"
#include "js_manager.h"
#include "macros.h"
#include "manifest.h"
#include "media/media_player.h"
#include "net.h"
#include "player_externs.h"
#include "stats.h"
#include "track.h"

namespace shaka {

struct DefaultValueType final {};

extern SHAKA_EXPORT const DefaultValueType DefaultValue;

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

    virtual void OnError(const Error& error);

    virtual void OnBuffering(bool is_buffering);
  };

  Player(JsManager* engine);
  Player(Player&&);
  ~Player();

  Player& operator=(Player&&);

  SHAKA_NON_COPYABLE_TYPE(Player);


  enum class LogLevel : uint8_t {
    // These have the same values as shaka.log.Level.
    None = 0,
    Error = 1,
    Warning = 2,
    Info = 3,
    Debug = 4,
    V1 = 5,
    V2 = 6,
  };

  static AsyncResults<void> SetLogLevel(JsManager* engine, LogLevel level);

  static AsyncResults<LogLevel> GetLogLevel(JsManager* engine);

  static AsyncResults<std::string> GetPlayerVersion(JsManager* engine);


  AsyncResults<void> Initialize(Client* client,
                                media::MediaPlayer* player = nullptr);

  AsyncResults<void> Destroy();


  AsyncResults<bool> IsAudioOnly() const;

  AsyncResults<bool> IsBuffering() const;

  AsyncResults<bool> IsInProgress() const;

  AsyncResults<bool> IsLive() const;

  AsyncResults<bool> IsTextTrackVisible() const;

  AsyncResults<bool> UsingEmbeddedTextTrack() const;


  AsyncResults<optional<std::string>> AssetUri() const;

  AsyncResults<optional<DrmInfo>> DrmInfo() const;

  AsyncResults<std::vector<LanguageRole>> GetAudioLanguagesAndRoles() const;

  AsyncResults<BufferedInfo> GetBufferedInfo() const;

  AsyncResults<double> GetExpiration() const;

  AsyncResults<Stats> GetStats() const;

  AsyncResults<std::vector<Track>> GetTextTracks() const;

  AsyncResults<std::vector<Track>> GetVariantTracks() const;

  AsyncResults<std::vector<LanguageRole>> GetTextLanguagesAndRoles() const;

  AsyncResults<std::string> KeySystem() const;

  AsyncResults<BufferedRange> SeekRange() const;


  AsyncResults<void> Load(const std::string& manifest_uri,
                          double start_time = NAN,
                          const std::string& mime_type = "");

  AsyncResults<void> Unload();


  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<void> ResetConfiguration();

  AsyncResults<void> RetryStreaming();

  AsyncResults<void> SelectAudioLanguage(const std::string& language,
                                         optional<std::string> role = nullopt);

  AsyncResults<void> SelectEmbeddedTextTrack();

  AsyncResults<void> SelectTextLanguage(const std::string& language,
                                        optional<std::string> role = nullopt);


  AsyncResults<void> SelectTextTrack(const Track& track);

  AsyncResults<void> SelectVariantTrack(const Track& track,
                                        bool clear_buffer = false);

  AsyncResults<void> SetTextTrackVisibility(bool visibility);



  AsyncResults<bool> GetConfigurationBool(const std::string& name_path);
  AsyncResults<double> GetConfigurationDouble(const std::string& name_path);
  AsyncResults<std::string> GetConfigurationString(
      const std::string& name_path);

  AsyncResults<Track> AddTextTrack(const std::string& uri,
                                   const std::string& language,
                                   const std::string& kind,
                                   const std::string& mime,
                                   const std::string& codec = "",
                                   const std::string& label = "");

  AsyncResults<void> Attach(media::MediaPlayer* player);

  AsyncResults<void> Detach();

  /*
   * Adds an object that is called when network requests happen.  These are
   * called in the order they are registered.
   * @param filters The object that receives the calls.
   */
  void AddNetworkFilters(NetworkFilters* filters);

  void RemoveNetworkFilters(NetworkFilters* filters);


  AsyncResults<bool> Configure(const std::string& name_path,
                               const std::vector<uint8_t>& data) {
    return Configure(name_path, data.data(), data.size());
  }
  AsyncResults<bool> Configure(const std::string& name_path,
                               const uint8_t* data, size_t data_size);

 private:
  friend class Storage;
  void* GetRawJsValue();

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

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_PLAYER_H_