client.h

Go to the documentation of this file.

#ifndef MILLICAST_API_CLIENT_H
#define MILLICAST_API_CLIENT_H
 
#include <functional>
#include <list>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "millicast-sdk/exports.h"
#include "millicast-sdk/mc_logging.h"
#include "millicast-sdk/promise.h"
#include "millicast-sdk/stats.h"
 
namespace millicast {
enum class DegradationPreferences {
  DISABLED, 
  MAINTAIN_RESOLUTION, 
  MAINTAIN_FRAMERATE,  
  BALANCED 
};
 
struct BitrateSettings {
  bool disable_bwe{true};
  std::optional<int> min_bitrate_kbps;
  std::optional<int> max_bitrate_kbps;
};
 
struct TrackInfo {
  std::string media;    
  std::string track_id; 
};
 
struct MILLICAST_API ClientListener {
  virtual void on_connected() = 0;
 
  virtual void on_disconnected() = 0;
 
  virtual void on_connection_error(int status, const std::string& reason) = 0;
 
  virtual void on_signaling_error(const std::string& message) = 0;
 
  virtual void on_stats_report(std::unique_ptr<StatsReport>) {}
 
  virtual void on_viewer_count(int count) = 0;
 
  virtual ~ClientListener() = default;
};
 
struct MILLICAST_API ClientConnectionOptions {
  bool auto_reconnect{true};
};
 
struct MILLICAST_API ClientOption {
  ClientOption();
  std::optional<bool> stereo; 
  std::optional<bool>
      dtx; 
  int stats_delay_ms; 
  std::optional<DegradationPreferences>
      degradation; 
  std::string rtc_event_log_output_path;
};
 
struct ClientJsonData {
  std::string ws_url; 
  std::string jwt;    
};
 
class MILLICAST_API ClientBase {
 public:
  using Listener = ClientListener;
  using ConnectionOptions = ClientConnectionOptions;
  using Option = ClientOption;
  using JsonData = ClientJsonData;
 
  virtual ~ClientBase() = default;
 
  static std::list<std::string> get_supported_video_codecs();
 
  static std::list<std::string> get_supported_audio_codecs();
 
  static void cleanup();
};
 
inline namespace compat {
class MILLICAST_API Client : public ClientBase {
 public:
  virtual bool connect(const std::optional<ConnectionOptions>&
                           connection_options = std::nullopt) = 0;
 
  virtual bool connect(const JsonData& data,
                       const std::optional<ConnectionOptions>&
                           connection_options = std::nullopt) = 0;
 
  [[nodiscard]] virtual bool is_connected() const = 0;
 
  virtual bool disconnect() = 0;
 
  virtual void enable_stats(bool enable) = 0;
 
  virtual std::optional<std::string> get_mid(const std::string& track_id) = 0;
 
  virtual void enable_frame_transformer(bool enable) = 0;
};
}  // namespace compat
 
namespace promises {
class MILLICAST_API Client : public ClientBase {
 public:
  virtual Promise<void> connect(
      std::optional<ConnectionOptions>&& connection_options) = 0;
 
  virtual Promise<void> connect(
      JsonData&& data,
      std::optional<ConnectionOptions>&& connection_options) = 0;
 
  [[nodiscard]] virtual Promise<bool> is_connected() const = 0;
 
  virtual Promise<void> disconnect() = 0;
 
  virtual Promise<void> enable_stats(bool enable) = 0;
 
  // to be deprecated
  virtual Promise<std::optional<std::string>> get_mid(
      std::string&& track_id) = 0;
 
  virtual Promise<void> enable_frame_transformer(bool enable) = 0;
};
}  // namespace promises
 
}  // namespace millicast
 
#endif /* MILLICAST_API_CLIENT_H */