spactureai-mobile-player 1.0.30

package/nitrogen/generated/shared/c++/HybridVideoPlayerSourceSpec.hpp

@@ -0,0 +1,69 @@
+///
+/// HybridVideoPlayerSourceSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct NativeVideoConfig; }
+// Forward declaration of `VideoInformation` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct VideoInformation; }
+
+#include <string>
+#include "NativeVideoConfig.hpp"
+#include "VideoInformation.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayerSource`
+   * Inherit this class to create instances of `HybridVideoPlayerSourceSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayerSource: public HybridVideoPlayerSourceSpec {
+   * public:
+   *   HybridVideoPlayerSource(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerSourceSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerSourceSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerSourceSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getUri() = 0;
+      virtual NativeVideoConfig getConfig() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<VideoInformation>> getAssetInformationAsync() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayerSource";
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoPlayerSpec.cpp

@@ -0,0 +1,57 @@
+///
+/// HybridVideoPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerSpec.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  void HybridVideoPlayerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("source", &HybridVideoPlayerSpec::getSource);
+      prototype.registerHybridGetter("eventEmitter", &HybridVideoPlayerSpec::getEventEmitter);
+      prototype.registerHybridGetter("showNotificationControls", &HybridVideoPlayerSpec::getShowNotificationControls);
+      prototype.registerHybridSetter("showNotificationControls", &HybridVideoPlayerSpec::setShowNotificationControls);
+      prototype.registerHybridGetter("status", &HybridVideoPlayerSpec::getStatus);
+      prototype.registerHybridGetter("duration", &HybridVideoPlayerSpec::getDuration);
+      prototype.registerHybridGetter("volume", &HybridVideoPlayerSpec::getVolume);
+      prototype.registerHybridSetter("volume", &HybridVideoPlayerSpec::setVolume);
+      prototype.registerHybridGetter("currentTime", &HybridVideoPlayerSpec::getCurrentTime);
+      prototype.registerHybridSetter("currentTime", &HybridVideoPlayerSpec::setCurrentTime);
+      prototype.registerHybridGetter("muted", &HybridVideoPlayerSpec::getMuted);
+      prototype.registerHybridSetter("muted", &HybridVideoPlayerSpec::setMuted);
+      prototype.registerHybridGetter("loop", &HybridVideoPlayerSpec::getLoop);
+      prototype.registerHybridSetter("loop", &HybridVideoPlayerSpec::setLoop);
+      prototype.registerHybridGetter("rate", &HybridVideoPlayerSpec::getRate);
+      prototype.registerHybridSetter("rate", &HybridVideoPlayerSpec::setRate);
+      prototype.registerHybridGetter("mixAudioMode", &HybridVideoPlayerSpec::getMixAudioMode);
+      prototype.registerHybridSetter("mixAudioMode", &HybridVideoPlayerSpec::setMixAudioMode);
+      prototype.registerHybridGetter("ignoreSilentSwitchMode", &HybridVideoPlayerSpec::getIgnoreSilentSwitchMode);
+      prototype.registerHybridSetter("ignoreSilentSwitchMode", &HybridVideoPlayerSpec::setIgnoreSilentSwitchMode);
+      prototype.registerHybridGetter("playInBackground", &HybridVideoPlayerSpec::getPlayInBackground);
+      prototype.registerHybridSetter("playInBackground", &HybridVideoPlayerSpec::setPlayInBackground);
+      prototype.registerHybridGetter("playWhenInactive", &HybridVideoPlayerSpec::getPlayWhenInactive);
+      prototype.registerHybridSetter("playWhenInactive", &HybridVideoPlayerSpec::setPlayWhenInactive);
+      prototype.registerHybridGetter("isPlaying", &HybridVideoPlayerSpec::getIsPlaying);
+      prototype.registerHybridGetter("selectedTrack", &HybridVideoPlayerSpec::getSelectedTrack);
+      prototype.registerHybridMethod("replaceSourceAsync", &HybridVideoPlayerSpec::replaceSourceAsync);
+      prototype.registerHybridMethod("getAvailableTextTracks", &HybridVideoPlayerSpec::getAvailableTextTracks);
+      prototype.registerHybridMethod("selectTextTrack", &HybridVideoPlayerSpec::selectTextTrack);
+      prototype.registerHybridMethod("release", &HybridVideoPlayerSpec::release);
+      prototype.registerHybridMethod("captureFrame", &HybridVideoPlayerSpec::captureFrame);
+      prototype.registerHybridMethod("initialize", &HybridVideoPlayerSpec::initialize);
+      prototype.registerHybridMethod("preload", &HybridVideoPlayerSpec::preload);
+      prototype.registerHybridMethod("play", &HybridVideoPlayerSpec::play);
+      prototype.registerHybridMethod("pause", &HybridVideoPlayerSpec::pause);
+      prototype.registerHybridMethod("seekBy", &HybridVideoPlayerSpec::seekBy);
+      prototype.registerHybridMethod("seekTo", &HybridVideoPlayerSpec::seekTo);
+    });
+  }
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoPlayerSpec.hpp

@@ -0,0 +1,120 @@
+///
+/// HybridVideoPlayerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerEventEmitterSpec; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoPlayerStatus; }
+// Forward declaration of `MixAudioMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class MixAudioMode; }
+// Forward declaration of `IgnoreSilentSwitchMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class IgnoreSilentSwitchMode; }
+// Forward declaration of `TextTrack` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TextTrack; }
+
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "MixAudioMode.hpp"
+#include "IgnoreSilentSwitchMode.hpp"
+#include "TextTrack.hpp"
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayer`
+   * Inherit this class to create instances of `HybridVideoPlayerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayer: public HybridVideoPlayerSpec {
+   * public:
+   *   HybridVideoPlayer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::shared_ptr<HybridVideoPlayerSourceSpec> getSource() = 0;
+      virtual std::shared_ptr<HybridVideoPlayerEventEmitterSpec> getEventEmitter() = 0;
+      virtual bool getShowNotificationControls() = 0;
+      virtual void setShowNotificationControls(bool showNotificationControls) = 0;
+      virtual VideoPlayerStatus getStatus() = 0;
+      virtual double getDuration() = 0;
+      virtual double getVolume() = 0;
+      virtual void setVolume(double volume) = 0;
+      virtual double getCurrentTime() = 0;
+      virtual void setCurrentTime(double currentTime) = 0;
+      virtual bool getMuted() = 0;
+      virtual void setMuted(bool muted) = 0;
+      virtual bool getLoop() = 0;
+      virtual void setLoop(bool loop) = 0;
+      virtual double getRate() = 0;
+      virtual void setRate(double rate) = 0;
+      virtual MixAudioMode getMixAudioMode() = 0;
+      virtual void setMixAudioMode(MixAudioMode mixAudioMode) = 0;
+      virtual IgnoreSilentSwitchMode getIgnoreSilentSwitchMode() = 0;
+      virtual void setIgnoreSilentSwitchMode(IgnoreSilentSwitchMode ignoreSilentSwitchMode) = 0;
+      virtual bool getPlayInBackground() = 0;
+      virtual void setPlayInBackground(bool playInBackground) = 0;
+      virtual bool getPlayWhenInactive() = 0;
+      virtual void setPlayWhenInactive(bool playWhenInactive) = 0;
+      virtual bool getIsPlaying() = 0;
+      virtual std::optional<TextTrack> getSelectedTrack() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> replaceSourceAsync(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>>& source) = 0;
+      virtual std::vector<TextTrack> getAvailableTextTracks() = 0;
+      virtual void selectTextTrack(const std::optional<std::variant<nitro::NullType, TextTrack>>& textTrack) = 0;
+      virtual void release() = 0;
+      virtual std::shared_ptr<Promise<std::string>> captureFrame() = 0;
+      virtual std::shared_ptr<Promise<void>> initialize() = 0;
+      virtual std::shared_ptr<Promise<void>> preload() = 0;
+      virtual void play() = 0;
+      virtual void pause() = 0;
+      virtual void seekBy(double time) = 0;
+      virtual void seekTo(double time) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayer";
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerFactorySpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridVideoViewViewManagerFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoViewViewManagerFactorySpec.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  void HybridVideoViewViewManagerFactorySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("createViewManager", &HybridVideoViewViewManagerFactorySpec::createViewManager);
+    });
+  }
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerFactorySpec.hpp

@@ -0,0 +1,64 @@
+///
+/// HybridVideoViewViewManagerFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVideoViewViewManagerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoViewViewManagerSpec; }
+
+#include <memory>
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoViewViewManagerFactory`
+   * Inherit this class to create instances of `HybridVideoViewViewManagerFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoViewViewManagerFactory: public HybridVideoViewViewManagerFactorySpec {
+   * public:
+   *   HybridVideoViewViewManagerFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoViewViewManagerFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoViewViewManagerFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoViewViewManagerFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridVideoViewViewManagerSpec> createViewManager(double nitroId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoViewViewManagerFactory";
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerSpec.cpp

@@ -0,0 +1,46 @@
+///
+/// HybridVideoViewViewManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  void HybridVideoViewViewManagerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("player", &HybridVideoViewViewManagerSpec::getPlayer);
+      prototype.registerHybridSetter("player", &HybridVideoViewViewManagerSpec::setPlayer);
+      prototype.registerHybridGetter("controls", &HybridVideoViewViewManagerSpec::getControls);
+      prototype.registerHybridSetter("controls", &HybridVideoViewViewManagerSpec::setControls);
+      prototype.registerHybridGetter("pictureInPicture", &HybridVideoViewViewManagerSpec::getPictureInPicture);
+      prototype.registerHybridSetter("pictureInPicture", &HybridVideoViewViewManagerSpec::setPictureInPicture);
+      prototype.registerHybridGetter("autoEnterPictureInPicture", &HybridVideoViewViewManagerSpec::getAutoEnterPictureInPicture);
+      prototype.registerHybridSetter("autoEnterPictureInPicture", &HybridVideoViewViewManagerSpec::setAutoEnterPictureInPicture);
+      prototype.registerHybridGetter("resizeMode", &HybridVideoViewViewManagerSpec::getResizeMode);
+      prototype.registerHybridSetter("resizeMode", &HybridVideoViewViewManagerSpec::setResizeMode);
+      prototype.registerHybridGetter("keepScreenAwake", &HybridVideoViewViewManagerSpec::getKeepScreenAwake);
+      prototype.registerHybridSetter("keepScreenAwake", &HybridVideoViewViewManagerSpec::setKeepScreenAwake);
+      prototype.registerHybridGetter("surfaceType", &HybridVideoViewViewManagerSpec::getSurfaceType);
+      prototype.registerHybridSetter("surfaceType", &HybridVideoViewViewManagerSpec::setSurfaceType);
+      prototype.registerHybridMethod("enterFullscreen", &HybridVideoViewViewManagerSpec::enterFullscreen);
+      prototype.registerHybridMethod("exitFullscreen", &HybridVideoViewViewManagerSpec::exitFullscreen);
+      prototype.registerHybridMethod("enterPictureInPicture", &HybridVideoViewViewManagerSpec::enterPictureInPicture);
+      prototype.registerHybridMethod("exitPictureInPicture", &HybridVideoViewViewManagerSpec::exitPictureInPicture);
+      prototype.registerHybridMethod("canEnterPictureInPicture", &HybridVideoViewViewManagerSpec::canEnterPictureInPicture);
+      prototype.registerHybridMethod("addOnPictureInPictureChangeListener", &HybridVideoViewViewManagerSpec::addOnPictureInPictureChangeListener);
+      prototype.registerHybridMethod("addOnFullscreenChangeListener", &HybridVideoViewViewManagerSpec::addOnFullscreenChangeListener);
+      prototype.registerHybridMethod("addWillEnterFullscreenListener", &HybridVideoViewViewManagerSpec::addWillEnterFullscreenListener);
+      prototype.registerHybridMethod("addWillExitFullscreenListener", &HybridVideoViewViewManagerSpec::addWillExitFullscreenListener);
+      prototype.registerHybridMethod("addWillEnterPictureInPictureListener", &HybridVideoViewViewManagerSpec::addWillEnterPictureInPictureListener);
+      prototype.registerHybridMethod("addWillExitPictureInPictureListener", &HybridVideoViewViewManagerSpec::addWillExitPictureInPictureListener);
+      prototype.registerHybridMethod("clearAllListeners", &HybridVideoViewViewManagerSpec::clearAllListeners);
+    });
+  }
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerSpec.hpp

@@ -0,0 +1,99 @@
+///
+/// HybridVideoViewViewManagerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSpec; }
+// Forward declaration of `ResizeMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class ResizeMode; }
+// Forward declaration of `SurfaceType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SurfaceType; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct ListenerSubscription; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include <optional>
+#include "ResizeMode.hpp"
+#include "SurfaceType.hpp"
+#include "ListenerSubscription.hpp"
+#include <functional>
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoViewViewManager`
+   * Inherit this class to create instances of `HybridVideoViewViewManagerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoViewViewManager: public HybridVideoViewViewManagerSpec {
+   * public:
+   *   HybridVideoViewViewManager(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoViewViewManagerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoViewViewManagerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoViewViewManagerSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::shared_ptr<HybridVideoPlayerSpec>> getPlayer() = 0;
+      virtual void setPlayer(const std::optional<std::shared_ptr<HybridVideoPlayerSpec>>& player) = 0;
+      virtual bool getControls() = 0;
+      virtual void setControls(bool controls) = 0;
+      virtual bool getPictureInPicture() = 0;
+      virtual void setPictureInPicture(bool pictureInPicture) = 0;
+      virtual bool getAutoEnterPictureInPicture() = 0;
+      virtual void setAutoEnterPictureInPicture(bool autoEnterPictureInPicture) = 0;
+      virtual ResizeMode getResizeMode() = 0;
+      virtual void setResizeMode(ResizeMode resizeMode) = 0;
+      virtual bool getKeepScreenAwake() = 0;
+      virtual void setKeepScreenAwake(bool keepScreenAwake) = 0;
+      virtual SurfaceType getSurfaceType() = 0;
+      virtual void setSurfaceType(SurfaceType surfaceType) = 0;
+
+    public:
+      // Methods
+      virtual void enterFullscreen() = 0;
+      virtual void exitFullscreen() = 0;
+      virtual void enterPictureInPicture() = 0;
+      virtual void exitPictureInPicture() = 0;
+      virtual bool canEnterPictureInPicture() = 0;
+      virtual ListenerSubscription addOnPictureInPictureChangeListener(const std::function<void(bool /* isInPictureInPicture */)>& listener) = 0;
+      virtual ListenerSubscription addOnFullscreenChangeListener(const std::function<void(bool /* fullscreen */)>& listener) = 0;
+      virtual ListenerSubscription addWillEnterFullscreenListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillExitFullscreenListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillEnterPictureInPictureListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillExitPictureInPictureListener(const std::function<void()>& listener) = 0;
+      virtual void clearAllListeners() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoViewViewManager";
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/shared/c++/IgnoreSilentSwitchMode.hpp

@@ -0,0 +1,80 @@
+///
+/// IgnoreSilentSwitchMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::unifiedplayer {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IgnoreSilentSwitchMode).
+   */
+  enum class IgnoreSilentSwitchMode {
+    AUTO      SWIFT_NAME(auto) = 0,
+    IGNORE      SWIFT_NAME(ignore) = 1,
+    OBEY      SWIFT_NAME(obey) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::unifiedplayer
+
+namespace margelo::nitro {
+
+  // C++ IgnoreSilentSwitchMode <> JS IgnoreSilentSwitchMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode> final {
+    static inline margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("auto"): return margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::AUTO;
+        case hashString("ignore"): return margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::IGNORE;
+        case hashString("obey"): return margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::OBEY;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IgnoreSilentSwitchMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode arg) {
+      switch (arg) {
+        case margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::AUTO: return JSIConverter<std::string>::toJSI(runtime, "auto");
+        case margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::IGNORE: return JSIConverter<std::string>::toJSI(runtime, "ignore");
+        case margelo::nitro::unifiedplayer::IgnoreSilentSwitchMode::OBEY: return JSIConverter<std::string>::toJSI(runtime, "obey");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IgnoreSilentSwitchMode to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("auto"):
+        case hashString("ignore"):
+        case hashString("obey"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/ListenerSubscription.hpp

@@ -0,0 +1,83 @@
+///
+/// ListenerSubscription.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <functional>
+
+namespace margelo::nitro::unifiedplayer {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ListenerSubscription).
+   */
+  struct ListenerSubscription final {
+  public:
+    std::function<void()> remove     SWIFT_PRIVATE;
+
+  public:
+    ListenerSubscription() = default;
+    explicit ListenerSubscription(std::function<void()> remove): remove(remove) {}
+
+  public:
+    // ListenerSubscription is not equatable because these properties are not equatable: remove
+  };
+
+} // namespace margelo::nitro::unifiedplayer
+
+namespace margelo::nitro {
+
+  // C++ ListenerSubscription <> JS ListenerSubscription (object)
+  template <>
+  struct JSIConverter<margelo::nitro::unifiedplayer::ListenerSubscription> final {
+    static inline margelo::nitro::unifiedplayer::ListenerSubscription fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::unifiedplayer::ListenerSubscription(
+        JSIConverter<std::function<void()>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remove")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::unifiedplayer::ListenerSubscription& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remove"), JSIConverter<std::function<void()>>::toJSI(runtime, arg.remove));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::function<void()>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remove")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro