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

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_onVolumeChangeData.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 <functional>
+
+#include "onVolumeChangeData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JonVolumeChangeData.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: onVolumeChangeData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_onVolumeChangeData: public jni::JavaClass<JFunc_void_onVolumeChangeData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onVolumeChangeData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_onVolumeChangeData` instance holds through JNI.
+     */
+    void invoke(const onVolumeChangeData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JonVolumeChangeData> /* data */)>("invoke");
+      method(self(), JonVolumeChangeData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_onVolumeChangeData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_onVolumeChangeData_cxx final: public jni::HybridClass<JFunc_void_onVolumeChangeData_cxx, JFunc_void_onVolumeChangeData> {
+  public:
+    static jni::local_ref<JFunc_void_onVolumeChangeData::javaobject> fromCpp(const std::function<void(const onVolumeChangeData& /* data */)>& func) {
+      return JFunc_void_onVolumeChangeData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_onVolumeChangeData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JonVolumeChangeData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const onVolumeChangeData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onVolumeChangeData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onVolumeChangeData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_onVolumeChangeData_cxx(const std::function<void(const onVolumeChangeData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const onVolumeChangeData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,95 @@
+///
+/// JFunc_void_std__vector_std__string_.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 <functional>
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: Array<String>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_std__string_: public jni::JavaClass<JFunc_void_std__vector_std__string_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_std__vector_std__string_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_std__string_` instance holds through JNI.
+     */
+    void invoke(const std::vector<std::string>& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* data */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = data.size();
+        jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = data[__i];
+          auto __elementJni = jni::make_jstring(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_std__string__cxx final: public jni::HybridClass<JFunc_void_std__vector_std__string__cxx, JFunc_void_std__vector_std__string_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_std__string_::javaobject> fromCpp(const std::function<void(const std::vector<std::string>& /* data */)>& func) {
+      return JFunc_void_std__vector_std__string__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_std__string__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<jni::JString>> data) {
+      _func([&]() {
+              size_t __size = data->size();
+              std::vector<std::string> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = data->getElement(__i);
+                __vector.push_back(__element->toStdString());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<std::string>& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_std__vector_std__string__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_std__string__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_std__string__cxx(const std::function<void(const std::vector<std::string>& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<std::string>& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,221 @@
+///
+/// JHybridVideoPlayerEventEmitterSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoPlayerEventEmitterSpec.hpp"
+
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::video { struct ListenerSubscription; }
+// Forward declaration of `BandwidthData` to properly resolve imports.
+namespace margelo::nitro::video { struct BandwidthData; }
+// Forward declaration of `onLoadData` to properly resolve imports.
+namespace margelo::nitro::video { struct onLoadData; }
+// Forward declaration of `VideoOrientation` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoOrientation; }
+// Forward declaration of `AllPlayerTracks` to properly resolve imports.
+namespace margelo::nitro::video { struct AllPlayerTracks; }
+// Forward declaration of `PlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct PlayerTrack; }
+// Forward declaration of `VideoPlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct VideoPlayerTrack; }
+// Forward declaration of `onLoadStartData` to properly resolve imports.
+namespace margelo::nitro::video { struct onLoadStartData; }
+// Forward declaration of `SourceType` to properly resolve imports.
+namespace margelo::nitro::video { enum class SourceType; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `onPlaybackStateChangeData` to properly resolve imports.
+namespace margelo::nitro::video { struct onPlaybackStateChangeData; }
+// Forward declaration of `onProgressData` to properly resolve imports.
+namespace margelo::nitro::video { struct onProgressData; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoPlayerStatus; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::video { struct TimedMetadata; }
+// Forward declaration of `TimedMetadataObject` to properly resolve imports.
+namespace margelo::nitro::video { struct TimedMetadataObject; }
+// Forward declaration of `onVolumeChangeData` to properly resolve imports.
+namespace margelo::nitro::video { struct onVolumeChangeData; }
+
+#include "ListenerSubscription.hpp"
+#include "JListenerSubscription.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_bool.hpp"
+#include "BandwidthData.hpp"
+#include "JFunc_void_BandwidthData.hpp"
+#include "JBandwidthData.hpp"
+#include <optional>
+#include "onLoadData.hpp"
+#include "JFunc_void_onLoadData.hpp"
+#include "JonLoadData.hpp"
+#include "VideoOrientation.hpp"
+#include "JVideoOrientation.hpp"
+#include "AllPlayerTracks.hpp"
+#include "JAllPlayerTracks.hpp"
+#include "PlayerTrack.hpp"
+#include <vector>
+#include "JPlayerTrack.hpp"
+#include <string>
+#include "VideoPlayerTrack.hpp"
+#include "JVideoPlayerTrack.hpp"
+#include "onLoadStartData.hpp"
+#include "JFunc_void_onLoadStartData.hpp"
+#include "JonLoadStartData.hpp"
+#include "SourceType.hpp"
+#include "JSourceType.hpp"
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "JHybridVideoPlayerSourceSpec.hpp"
+#include "onPlaybackStateChangeData.hpp"
+#include "JFunc_void_onPlaybackStateChangeData.hpp"
+#include "JonPlaybackStateChangeData.hpp"
+#include "JFunc_void_double.hpp"
+#include "onProgressData.hpp"
+#include "JFunc_void_onProgressData.hpp"
+#include "JonProgressData.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "JFunc_void_VideoPlayerStatus.hpp"
+#include "JVideoPlayerStatus.hpp"
+#include "TimedMetadata.hpp"
+#include "JFunc_void_TimedMetadata.hpp"
+#include "JTimedMetadata.hpp"
+#include "TimedMetadataObject.hpp"
+#include "JTimedMetadataObject.hpp"
+#include "JFunc_void_std__vector_std__string_.hpp"
+#include "onVolumeChangeData.hpp"
+#include "JFunc_void_onVolumeChangeData.hpp"
+#include "JonVolumeChangeData.hpp"
+
+namespace margelo::nitro::video {
+
+  jni::local_ref<JHybridVideoPlayerEventEmitterSpec::jhybriddata> JHybridVideoPlayerEventEmitterSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridVideoPlayerEventEmitterSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoPlayerEventEmitterSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridVideoPlayerEventEmitterSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridVideoPlayerEventEmitterSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridVideoPlayerEventEmitterSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnAudioBecomingNoisyListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addOnAudioBecomingNoisyListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnAudioFocusChangeListener(const std::function<void(bool /* hasAudioFocus */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnAudioFocusChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnBandwidthUpdateListener(const std::function<void(const BandwidthData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_BandwidthData::javaobject> /* listener */)>("addOnBandwidthUpdateListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_BandwidthData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnBufferListener(const std::function<void(bool /* buffering */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnBufferListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnControlsVisibleChangeListener(const std::function<void(bool /* visible */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnControlsVisibleChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnEndListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addOnEndListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnExternalPlaybackChangeListener(const std::function<void(bool /* externalPlaybackActive */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_bool::javaobject> /* listener */)>("addOnExternalPlaybackChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnLoadListener(const std::function<void(const onLoadData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_onLoadData::javaobject> /* listener */)>("addOnLoadListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_onLoadData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnLoadStartListener(const std::function<void(const onLoadStartData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_onLoadStartData::javaobject> /* listener */)>("addOnLoadStartListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_onLoadStartData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnPlaybackStateChangeListener(const std::function<void(const onPlaybackStateChangeData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_onPlaybackStateChangeData::javaobject> /* listener */)>("addOnPlaybackStateChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_onPlaybackStateChangeData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnPlaybackRateChangeListener(const std::function<void(double /* rate */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_double::javaobject> /* listener */)>("addOnPlaybackRateChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_double_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnProgressListener(const std::function<void(const onProgressData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_onProgressData::javaobject> /* listener */)>("addOnProgressListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_onProgressData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnReadyToDisplayListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addOnReadyToDisplayListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnSeekListener(const std::function<void(double /* position */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_double::javaobject> /* listener */)>("addOnSeekListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_double_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnStatusChangeListener(const std::function<void(VideoPlayerStatus /* status */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_VideoPlayerStatus::javaobject> /* listener */)>("addOnStatusChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_VideoPlayerStatus_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnTimedMetadataListener(const std::function<void(const TimedMetadata& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_TimedMetadata::javaobject> /* listener */)>("addOnTimedMetadataListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_TimedMetadata_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnTextTrackDataChangedListener(const std::function<void(const std::vector<std::string>& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_std__vector_std__string_::javaobject> /* listener */)>("addOnTextTrackDataChangedListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__vector_std__string__cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_onVolumeChangeData::javaobject> /* listener */)>("addOnVolumeChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_onVolumeChangeData_cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  void JHybridVideoPlayerEventEmitterSpec::clearAllListeners() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,83 @@
+///
+/// HybridVideoPlayerEventEmitterSpec.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 "HybridVideoPlayerEventEmitterSpec.hpp"
+
+
+
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  class JHybridVideoPlayerEventEmitterSpec: public jni::HybridClass<JHybridVideoPlayerEventEmitterSpec, JHybridObject>,
+                                            public virtual HybridVideoPlayerEventEmitterSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/HybridVideoPlayerEventEmitterSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridVideoPlayerEventEmitterSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridVideoPlayerEventEmitterSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridVideoPlayerEventEmitterSpec() 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<JHybridVideoPlayerEventEmitterSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    ListenerSubscription addOnAudioBecomingNoisyListener(const std::function<void()>& listener) override;
+    ListenerSubscription addOnAudioFocusChangeListener(const std::function<void(bool /* hasAudioFocus */)>& listener) override;
+    ListenerSubscription addOnBandwidthUpdateListener(const std::function<void(const BandwidthData& /* data */)>& listener) override;
+    ListenerSubscription addOnBufferListener(const std::function<void(bool /* buffering */)>& listener) override;
+    ListenerSubscription addOnControlsVisibleChangeListener(const std::function<void(bool /* visible */)>& listener) override;
+    ListenerSubscription addOnEndListener(const std::function<void()>& listener) override;
+    ListenerSubscription addOnExternalPlaybackChangeListener(const std::function<void(bool /* externalPlaybackActive */)>& listener) override;
+    ListenerSubscription addOnLoadListener(const std::function<void(const onLoadData& /* data */)>& listener) override;
+    ListenerSubscription addOnLoadStartListener(const std::function<void(const onLoadStartData& /* data */)>& listener) override;
+    ListenerSubscription addOnPlaybackStateChangeListener(const std::function<void(const onPlaybackStateChangeData& /* data */)>& listener) override;
+    ListenerSubscription addOnPlaybackRateChangeListener(const std::function<void(double /* rate */)>& listener) override;
+    ListenerSubscription addOnProgressListener(const std::function<void(const onProgressData& /* data */)>& listener) override;
+    ListenerSubscription addOnReadyToDisplayListener(const std::function<void()>& listener) override;
+    ListenerSubscription addOnSeekListener(const std::function<void(double /* position */)>& listener) override;
+    ListenerSubscription addOnStatusChangeListener(const std::function<void(VideoPlayerStatus /* status */)>& listener) override;
+    ListenerSubscription addOnTimedMetadataListener(const std::function<void(const TimedMetadata& /* data */)>& listener) override;
+    ListenerSubscription addOnTextTrackDataChangedListener(const std::function<void(const std::vector<std::string>& /* data */)>& listener) override;
+    ListenerSubscription addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) override;
+    void clearAllListeners() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridVideoPlayerEventEmitterSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,59 @@
+///
+/// JHybridVideoPlayerFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoPlayerFactorySpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSpec; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include "JHybridVideoPlayerSpec.hpp"
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "JHybridVideoPlayerSourceSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  jni::local_ref<JHybridVideoPlayerFactorySpec::jhybriddata> JHybridVideoPlayerFactorySpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridVideoPlayerFactorySpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoPlayerFactorySpec::initHybrid),
+    });
+  }
+
+  size_t JHybridVideoPlayerFactorySpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridVideoPlayerFactorySpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridVideoPlayerFactorySpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridVideoPlayerSpec> JHybridVideoPlayerFactorySpec::createPlayer(const std::shared_ptr<HybridVideoPlayerSourceSpec>& source) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridVideoPlayerSpec::javaobject>(jni::alias_ref<JHybridVideoPlayerSourceSpec::javaobject> /* source */)>("createPlayer");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridVideoPlayerSourceSpec>(source)->getJavaPart());
+    return __result->cthis()->shared_cast<JHybridVideoPlayerSpec>();
+  }
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,65 @@
+///
+/// HybridVideoPlayerFactorySpec.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 "HybridVideoPlayerFactorySpec.hpp"
+
+
+
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  class JHybridVideoPlayerFactorySpec: public jni::HybridClass<JHybridVideoPlayerFactorySpec, JHybridObject>,
+                                       public virtual HybridVideoPlayerFactorySpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/HybridVideoPlayerFactorySpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridVideoPlayerFactorySpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridVideoPlayerFactorySpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridVideoPlayerFactorySpec() 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<JHybridVideoPlayerFactorySpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridVideoPlayerSpec> createPlayer(const std::shared_ptr<HybridVideoPlayerSourceSpec>& source) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridVideoPlayerFactorySpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::video