@pigeonmal/react-native-video 7.0.0-beta.2

package/nitrogen/generated/android/c++/JHybridVideoViewViewManagerSpec.cpp

@@ -0,0 +1,184 @@
+///
+/// JHybridVideoViewViewManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoViewViewManagerSpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSpec; }
+// Forward declaration of `ResizeMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class ResizeMode; }
+// Forward declaration of `SurfaceType` to properly resolve imports.
+namespace margelo::nitro::video { enum class SurfaceType; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::video { struct ListenerSubscription; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include <optional>
+#include "JHybridVideoPlayerSpec.hpp"
+#include "ResizeMode.hpp"
+#include "JResizeMode.hpp"
+#include "SurfaceType.hpp"
+#include "JSurfaceType.hpp"
+#include "ListenerSubscription.hpp"
+#include "JListenerSubscription.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_bool.hpp"
+
+namespace margelo::nitro::video {
+
+  jni::local_ref<JHybridVideoViewViewManagerSpec::jhybriddata> JHybridVideoViewViewManagerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridVideoViewViewManagerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoViewViewManagerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridVideoViewViewManagerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridVideoViewViewManagerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridVideoViewViewManagerSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::shared_ptr<HybridVideoPlayerSpec>> JHybridVideoViewViewManagerSpec::getPlayer() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridVideoPlayerSpec::javaobject>()>("getPlayer");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->cthis()->shared_cast<JHybridVideoPlayerSpec>()) : std::nullopt;
+  }
+  void JHybridVideoViewViewManagerSpec::setPlayer(const std::optional<std::shared_ptr<HybridVideoPlayerSpec>>& player) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHybridVideoPlayerSpec::javaobject> /* player */)>("setPlayer");
+    method(_javaPart, player.has_value() ? std::dynamic_pointer_cast<JHybridVideoPlayerSpec>(player.value())->getJavaPart() : nullptr);
+  }
+  bool JHybridVideoViewViewManagerSpec::getControls() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getControls");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoViewViewManagerSpec::setControls(bool controls) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* controls */)>("setControls");
+    method(_javaPart, controls);
+  }
+  bool JHybridVideoViewViewManagerSpec::getPictureInPicture() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getPictureInPicture");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoViewViewManagerSpec::setPictureInPicture(bool pictureInPicture) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* pictureInPicture */)>("setPictureInPicture");
+    method(_javaPart, pictureInPicture);
+  }
+  bool JHybridVideoViewViewManagerSpec::getAutoEnterPictureInPicture() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getAutoEnterPictureInPicture");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoViewViewManagerSpec::setAutoEnterPictureInPicture(bool autoEnterPictureInPicture) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* autoEnterPictureInPicture */)>("setAutoEnterPictureInPicture");
+    method(_javaPart, autoEnterPictureInPicture);
+  }
+  ResizeMode JHybridVideoViewViewManagerSpec::getResizeMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JResizeMode>()>("getResizeMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridVideoViewViewManagerSpec::setResizeMode(ResizeMode resizeMode) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JResizeMode> /* resizeMode */)>("setResizeMode");
+    method(_javaPart, JResizeMode::fromCpp(resizeMode));
+  }
+  bool JHybridVideoViewViewManagerSpec::getKeepScreenAwake() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getKeepScreenAwake");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoViewViewManagerSpec::setKeepScreenAwake(bool keepScreenAwake) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* keepScreenAwake */)>("setKeepScreenAwake");
+    method(_javaPart, keepScreenAwake);
+  }
+  SurfaceType JHybridVideoViewViewManagerSpec::getSurfaceType() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JSurfaceType>()>("getSurfaceType");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridVideoViewViewManagerSpec::setSurfaceType(SurfaceType surfaceType) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSurfaceType> /* surfaceType */)>("setSurfaceType");
+    method(_javaPart, JSurfaceType::fromCpp(surfaceType));
+  }
+
+  // Methods
+  void JHybridVideoViewViewManagerSpec::enterFullscreen() {
+    static const auto method = javaClassStatic()->getMethod<void()>("enterFullscreen");
+    method(_javaPart);
+  }
+  void JHybridVideoViewViewManagerSpec::exitFullscreen() {
+    static const auto method = javaClassStatic()->getMethod<void()>("exitFullscreen");
+    method(_javaPart);
+  }
+  void JHybridVideoViewViewManagerSpec::enterPictureInPicture() {
+    static const auto method = javaClassStatic()->getMethod<void()>("enterPictureInPicture");
+    method(_javaPart);
+  }
+  void JHybridVideoViewViewManagerSpec::exitPictureInPicture() {
+    static const auto method = javaClassStatic()->getMethod<void()>("exitPictureInPicture");
+    method(_javaPart);
+  }
+  bool JHybridVideoViewViewManagerSpec::canEnterPictureInPicture() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("canEnterPictureInPicture");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addOnPictureInPictureChangeListener(const std::function<void(bool /* isInPictureInPicture */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnPictureInPictureChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addOnFullscreenChangeListener(const std::function<void(bool /* fullscreen */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnFullscreenChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addWillEnterFullscreenListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addWillEnterFullscreenListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addWillExitFullscreenListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addWillExitFullscreenListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addWillEnterPictureInPictureListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addWillEnterPictureInPictureListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoViewViewManagerSpec::addWillExitPictureInPictureListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addWillExitPictureInPictureListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  void JHybridVideoViewViewManagerSpec::clearAllListeners() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JHybridVideoViewViewManagerSpec.hpp

@@ -0,0 +1,89 @@
+///
+/// HybridVideoViewViewManagerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  class JHybridVideoViewViewManagerSpec: public jni::HybridClass<JHybridVideoViewViewManagerSpec, JHybridObject>,
+                                         public virtual HybridVideoViewViewManagerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/HybridVideoViewViewManagerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridVideoViewViewManagerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridVideoViewViewManagerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridVideoViewViewManagerSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridVideoViewViewManagerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::shared_ptr<HybridVideoPlayerSpec>> getPlayer() override;
+    void setPlayer(const std::optional<std::shared_ptr<HybridVideoPlayerSpec>>& player) override;
+    bool getControls() override;
+    void setControls(bool controls) override;
+    bool getPictureInPicture() override;
+    void setPictureInPicture(bool pictureInPicture) override;
+    bool getAutoEnterPictureInPicture() override;
+    void setAutoEnterPictureInPicture(bool autoEnterPictureInPicture) override;
+    ResizeMode getResizeMode() override;
+    void setResizeMode(ResizeMode resizeMode) override;
+    bool getKeepScreenAwake() override;
+    void setKeepScreenAwake(bool keepScreenAwake) override;
+    SurfaceType getSurfaceType() override;
+    void setSurfaceType(SurfaceType surfaceType) override;
+
+  public:
+    // Methods
+    void enterFullscreen() override;
+    void exitFullscreen() override;
+    void enterPictureInPicture() override;
+    void exitPictureInPicture() override;
+    bool canEnterPictureInPicture() override;
+    ListenerSubscription addOnPictureInPictureChangeListener(const std::function<void(bool /* isInPictureInPicture */)>& listener) override;
+    ListenerSubscription addOnFullscreenChangeListener(const std::function<void(bool /* fullscreen */)>& listener) override;
+    ListenerSubscription addWillEnterFullscreenListener(const std::function<void()>& listener) override;
+    ListenerSubscription addWillExitFullscreenListener(const std::function<void()>& listener) override;
+    ListenerSubscription addWillEnterPictureInPictureListener(const std::function<void()>& listener) override;
+    ListenerSubscription addWillExitPictureInPictureListener(const std::function<void()>& listener) override;
+    void clearAllListeners() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridVideoViewViewManagerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JIgnoreSilentSwitchMode.hpp

@@ -0,0 +1,62 @@
+///
+/// JIgnoreSilentSwitchMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IgnoreSilentSwitchMode.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IgnoreSilentSwitchMode" and the the Kotlin enum "IgnoreSilentSwitchMode".
+   */
+  struct JIgnoreSilentSwitchMode final: public jni::JavaClass<JIgnoreSilentSwitchMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/IgnoreSilentSwitchMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IgnoreSilentSwitchMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IgnoreSilentSwitchMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IgnoreSilentSwitchMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIgnoreSilentSwitchMode> fromCpp(IgnoreSilentSwitchMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAUTO = clazz->getStaticField<JIgnoreSilentSwitchMode>("AUTO");
+      static const auto fieldIGNORE = clazz->getStaticField<JIgnoreSilentSwitchMode>("IGNORE");
+      static const auto fieldOBEY = clazz->getStaticField<JIgnoreSilentSwitchMode>("OBEY");
+      
+      switch (value) {
+        case IgnoreSilentSwitchMode::AUTO:
+          return clazz->getStaticFieldValue(fieldAUTO);
+        case IgnoreSilentSwitchMode::IGNORE:
+          return clazz->getStaticFieldValue(fieldIGNORE);
+        case IgnoreSilentSwitchMode::OBEY:
+          return clazz->getStaticFieldValue(fieldOBEY);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JListenerSubscription.hpp

@@ -0,0 +1,67 @@
+///
+/// JListenerSubscription.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ListenerSubscription.hpp"
+
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ListenerSubscription" and the the Kotlin data class "ListenerSubscription".
+   */
+  struct JListenerSubscription final: public jni::JavaClass<JListenerSubscription> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/ListenerSubscription;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ListenerSubscription by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ListenerSubscription toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRemove = clazz->getField<JFunc_void::javaobject>("remove");
+      jni::local_ref<JFunc_void::javaobject> remove = this->getFieldValue(fieldRemove);
+      return ListenerSubscription(
+        [&]() -> std::function<void()> {
+          if (remove->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(remove);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto removeRef = jni::make_global(remove);
+            return JNICallable<JFunc_void, void()>(std::move(removeRef));
+          }
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JListenerSubscription::javaobject> fromCpp(const ListenerSubscription& value) {
+      using JSignature = JListenerSubscription(jni::alias_ref<JFunc_void::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JFunc_void_cxx::fromCpp(value.remove)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JLivePlaybackParams.hpp

@@ -0,0 +1,73 @@
+///
+/// JLivePlaybackParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LivePlaybackParams.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LivePlaybackParams" and the the Kotlin data class "LivePlaybackParams".
+   */
+  struct JLivePlaybackParams final: public jni::JavaClass<JLivePlaybackParams> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/LivePlaybackParams;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LivePlaybackParams by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LivePlaybackParams toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMinPlaybackSpeed = clazz->getField<jni::JDouble>("minPlaybackSpeed");
+      jni::local_ref<jni::JDouble> minPlaybackSpeed = this->getFieldValue(fieldMinPlaybackSpeed);
+      static const auto fieldMaxPlaybackSpeed = clazz->getField<jni::JDouble>("maxPlaybackSpeed");
+      jni::local_ref<jni::JDouble> maxPlaybackSpeed = this->getFieldValue(fieldMaxPlaybackSpeed);
+      static const auto fieldMaxOffsetMs = clazz->getField<jni::JDouble>("maxOffsetMs");
+      jni::local_ref<jni::JDouble> maxOffsetMs = this->getFieldValue(fieldMaxOffsetMs);
+      static const auto fieldMinOffsetMs = clazz->getField<jni::JDouble>("minOffsetMs");
+      jni::local_ref<jni::JDouble> minOffsetMs = this->getFieldValue(fieldMinOffsetMs);
+      static const auto fieldTargetOffsetMs = clazz->getField<jni::JDouble>("targetOffsetMs");
+      jni::local_ref<jni::JDouble> targetOffsetMs = this->getFieldValue(fieldTargetOffsetMs);
+      return LivePlaybackParams(
+        minPlaybackSpeed != nullptr ? std::make_optional(minPlaybackSpeed->value()) : std::nullopt,
+        maxPlaybackSpeed != nullptr ? std::make_optional(maxPlaybackSpeed->value()) : std::nullopt,
+        maxOffsetMs != nullptr ? std::make_optional(maxOffsetMs->value()) : std::nullopt,
+        minOffsetMs != nullptr ? std::make_optional(minOffsetMs->value()) : std::nullopt,
+        targetOffsetMs != nullptr ? std::make_optional(targetOffsetMs->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLivePlaybackParams::javaobject> fromCpp(const LivePlaybackParams& value) {
+      using JSignature = JLivePlaybackParams(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.minPlaybackSpeed.has_value() ? jni::JDouble::valueOf(value.minPlaybackSpeed.value()) : nullptr,
+        value.maxPlaybackSpeed.has_value() ? jni::JDouble::valueOf(value.maxPlaybackSpeed.value()) : nullptr,
+        value.maxOffsetMs.has_value() ? jni::JDouble::valueOf(value.maxOffsetMs.value()) : nullptr,
+        value.minOffsetMs.has_value() ? jni::JDouble::valueOf(value.minOffsetMs.value()) : nullptr,
+        value.targetOffsetMs.has_value() ? jni::JDouble::valueOf(value.targetOffsetMs.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JMixAudioMode.hpp

@@ -0,0 +1,65 @@
+///
+/// JMixAudioMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MixAudioMode.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "MixAudioMode" and the the Kotlin enum "MixAudioMode".
+   */
+  struct JMixAudioMode final: public jni::JavaClass<JMixAudioMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/MixAudioMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum MixAudioMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MixAudioMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<MixAudioMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JMixAudioMode> fromCpp(MixAudioMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMIXWITHOTHERS = clazz->getStaticField<JMixAudioMode>("MIXWITHOTHERS");
+      static const auto fieldDONOTMIX = clazz->getStaticField<JMixAudioMode>("DONOTMIX");
+      static const auto fieldDUCKOTHERS = clazz->getStaticField<JMixAudioMode>("DUCKOTHERS");
+      static const auto fieldAUTO = clazz->getStaticField<JMixAudioMode>("AUTO");
+      
+      switch (value) {
+        case MixAudioMode::MIXWITHOTHERS:
+          return clazz->getStaticFieldValue(fieldMIXWITHOTHERS);
+        case MixAudioMode::DONOTMIX:
+          return clazz->getStaticFieldValue(fieldDONOTMIX);
+        case MixAudioMode::DUCKOTHERS:
+          return clazz->getStaticFieldValue(fieldDUCKOTHERS);
+        case MixAudioMode::AUTO:
+          return clazz->getStaticFieldValue(fieldAUTO);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/android/c++/JNativeDrmParams.hpp

@@ -0,0 +1,111 @@
+///
+/// JNativeDrmParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NativeDrmParams.hpp"
+
+#include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload.hpp"
+#include "JOnGetLicensePayload.hpp"
+#include "OnGetLicensePayload.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NativeDrmParams" and the the Kotlin data class "NativeDrmParams".
+   */
+  struct JNativeDrmParams final: public jni::JavaClass<JNativeDrmParams> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/NativeDrmParams;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NativeDrmParams by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NativeDrmParams toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldLicenseUrl = clazz->getField<jni::JString>("licenseUrl");
+      jni::local_ref<jni::JString> licenseUrl = this->getFieldValue(fieldLicenseUrl);
+      static const auto fieldCertificateUrl = clazz->getField<jni::JString>("certificateUrl");
+      jni::local_ref<jni::JString> certificateUrl = this->getFieldValue(fieldCertificateUrl);
+      static const auto fieldContentId = clazz->getField<jni::JString>("contentId");
+      jni::local_ref<jni::JString> contentId = this->getFieldValue(fieldContentId);
+      static const auto fieldLicenseHeaders = clazz->getField<jni::JMap<jni::JString, jni::JString>>("licenseHeaders");
+      jni::local_ref<jni::JMap<jni::JString, jni::JString>> licenseHeaders = this->getFieldValue(fieldLicenseHeaders);
+      static const auto fieldMultiSession = clazz->getField<jni::JBoolean>("multiSession");
+      jni::local_ref<jni::JBoolean> multiSession = this->getFieldValue(fieldMultiSession);
+      static const auto fieldGetLicense = clazz->getField<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload::javaobject>("getLicense");
+      jni::local_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload::javaobject> getLicense = this->getFieldValue(fieldGetLicense);
+      return NativeDrmParams(
+        type != nullptr ? std::make_optional(type->toStdString()) : std::nullopt,
+        licenseUrl != nullptr ? std::make_optional(licenseUrl->toStdString()) : std::nullopt,
+        certificateUrl != nullptr ? std::make_optional(certificateUrl->toStdString()) : std::nullopt,
+        contentId != nullptr ? std::make_optional(contentId->toStdString()) : std::nullopt,
+        licenseHeaders != nullptr ? std::make_optional([&]() {
+          std::unordered_map<std::string, std::string> __map;
+          __map.reserve(licenseHeaders->size());
+          for (const auto& __entry : *licenseHeaders) {
+            __map.emplace(__entry.first->toStdString(), __entry.second->toStdString());
+          }
+          return __map;
+        }()) : std::nullopt,
+        multiSession != nullptr ? std::make_optional(static_cast<bool>(multiSession->value())) : std::nullopt,
+        getLicense != nullptr ? std::make_optional([&]() -> std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::string>>>>(const OnGetLicensePayload& /* payload */)> {
+          if (getLicense->isInstanceOf(JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload_cxx::javaobject>(getLicense);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto getLicenseRef = jni::make_global(getLicense);
+            return JNICallable<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload, std::shared_ptr<Promise<std::shared_ptr<Promise<std::string>>>>(OnGetLicensePayload)>(std::move(getLicenseRef));
+          }
+        }()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNativeDrmParams::javaobject> fromCpp(const NativeDrmParams& value) {
+      using JSignature = JNativeDrmParams(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.type.has_value() ? jni::make_jstring(value.type.value()) : nullptr,
+        value.licenseUrl.has_value() ? jni::make_jstring(value.licenseUrl.value()) : nullptr,
+        value.certificateUrl.has_value() ? jni::make_jstring(value.certificateUrl.value()) : nullptr,
+        value.contentId.has_value() ? jni::make_jstring(value.contentId.value()) : nullptr,
+        value.licenseHeaders.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+          auto __map = jni::JHashMap<jni::JString, jni::JString>::create(value.licenseHeaders.value().size());
+          for (const auto& __entry : value.licenseHeaders.value()) {
+            __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+          }
+          return __map;
+        }() : nullptr,
+        value.multiSession.has_value() ? jni::JBoolean::valueOf(value.multiSession.value()) : nullptr,
+        value.getLicense.has_value() ? JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__string_____OnGetLicensePayload_cxx::fromCpp(value.getLicense.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video