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

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

@@ -0,0 +1,307 @@
+///
+/// JHybridVideoPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoPlayerSpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerEventEmitterSpec; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoPlayerStatus; }
+// Forward declaration of `MixAudioMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class MixAudioMode; }
+// Forward declaration of `IgnoreSilentSwitchMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class IgnoreSilentSwitchMode; }
+// Forward declaration of `PlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct PlayerTrack; }
+// Forward declaration of `AllPlayerTracks` to properly resolve imports.
+namespace margelo::nitro::video { struct AllPlayerTracks; }
+// Forward declaration of `VideoPlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct VideoPlayerTrack; }
+// Forward declaration of `TrackType` to properly resolve imports.
+namespace margelo::nitro::video { enum class TrackType; }
+
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "JHybridVideoPlayerSourceSpec.hpp"
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+#include "JHybridVideoPlayerEventEmitterSpec.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "JVideoPlayerStatus.hpp"
+#include "MixAudioMode.hpp"
+#include "JMixAudioMode.hpp"
+#include "IgnoreSilentSwitchMode.hpp"
+#include "JIgnoreSilentSwitchMode.hpp"
+#include "PlayerTrack.hpp"
+#include <optional>
+#include "JPlayerTrack.hpp"
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <vector>
+#include "AllPlayerTracks.hpp"
+#include "JAllPlayerTracks.hpp"
+#include "VideoPlayerTrack.hpp"
+#include "JVideoPlayerTrack.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_HybridVideoPlayerSourceSpec.hpp"
+#include <NitroModules/JNull.hpp>
+#include "TrackType.hpp"
+#include "JTrackType.hpp"
+
+namespace margelo::nitro::video {
+
+  jni::local_ref<JHybridVideoPlayerSpec::jhybriddata> JHybridVideoPlayerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridVideoPlayerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoPlayerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridVideoPlayerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridVideoPlayerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridVideoPlayerSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::shared_ptr<HybridVideoPlayerSourceSpec> JHybridVideoPlayerSpec::getSource() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridVideoPlayerSourceSpec::javaobject>()>("getSource");
+    auto __result = method(_javaPart);
+    return __result->cthis()->shared_cast<JHybridVideoPlayerSourceSpec>();
+  }
+  std::shared_ptr<HybridVideoPlayerEventEmitterSpec> JHybridVideoPlayerSpec::getEventEmitter() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridVideoPlayerEventEmitterSpec::javaobject>()>("getEventEmitter");
+    auto __result = method(_javaPart);
+    return __result->cthis()->shared_cast<JHybridVideoPlayerEventEmitterSpec>();
+  }
+  bool JHybridVideoPlayerSpec::getShowNotificationControls() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getShowNotificationControls");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoPlayerSpec::setShowNotificationControls(bool showNotificationControls) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* showNotificationControls */)>("setShowNotificationControls");
+    method(_javaPart, showNotificationControls);
+  }
+  VideoPlayerStatus JHybridVideoPlayerSpec::getStatus() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JVideoPlayerStatus>()>("getStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  double JHybridVideoPlayerSpec::getDuration() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getDuration");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridVideoPlayerSpec::getVolume() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getVolume");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridVideoPlayerSpec::setVolume(double volume) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* volume */)>("setVolume");
+    method(_javaPart, volume);
+  }
+  double JHybridVideoPlayerSpec::getCurrentTime() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getCurrentTime");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridVideoPlayerSpec::setCurrentTime(double currentTime) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* currentTime */)>("setCurrentTime");
+    method(_javaPart, currentTime);
+  }
+  int64_t JHybridVideoPlayerSpec::getSubtitleDelay() {
+    static const auto method = javaClassStatic()->getMethod<int64_t()>("getSubtitleDelay");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridVideoPlayerSpec::setSubtitleDelay(int64_t subtitleDelay) {
+    static const auto method = javaClassStatic()->getMethod<void(int64_t /* subtitleDelay */)>("setSubtitleDelay");
+    method(_javaPart, subtitleDelay);
+  }
+  bool JHybridVideoPlayerSpec::getMuted() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getMuted");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoPlayerSpec::setMuted(bool muted) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* muted */)>("setMuted");
+    method(_javaPart, muted);
+  }
+  bool JHybridVideoPlayerSpec::getLoop() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getLoop");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoPlayerSpec::setLoop(bool loop) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* loop */)>("setLoop");
+    method(_javaPart, loop);
+  }
+  double JHybridVideoPlayerSpec::getRate() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getRate");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridVideoPlayerSpec::setRate(double rate) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* rate */)>("setRate");
+    method(_javaPart, rate);
+  }
+  MixAudioMode JHybridVideoPlayerSpec::getMixAudioMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMixAudioMode>()>("getMixAudioMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridVideoPlayerSpec::setMixAudioMode(MixAudioMode mixAudioMode) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMixAudioMode> /* mixAudioMode */)>("setMixAudioMode");
+    method(_javaPart, JMixAudioMode::fromCpp(mixAudioMode));
+  }
+  IgnoreSilentSwitchMode JHybridVideoPlayerSpec::getIgnoreSilentSwitchMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JIgnoreSilentSwitchMode>()>("getIgnoreSilentSwitchMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridVideoPlayerSpec::setIgnoreSilentSwitchMode(IgnoreSilentSwitchMode ignoreSilentSwitchMode) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JIgnoreSilentSwitchMode> /* ignoreSilentSwitchMode */)>("setIgnoreSilentSwitchMode");
+    method(_javaPart, JIgnoreSilentSwitchMode::fromCpp(ignoreSilentSwitchMode));
+  }
+  bool JHybridVideoPlayerSpec::getPlayInBackground() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getPlayInBackground");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoPlayerSpec::setPlayInBackground(bool playInBackground) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* playInBackground */)>("setPlayInBackground");
+    method(_javaPart, playInBackground);
+  }
+  bool JHybridVideoPlayerSpec::getPlayWhenInactive() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getPlayWhenInactive");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridVideoPlayerSpec::setPlayWhenInactive(bool playWhenInactive) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* playWhenInactive */)>("setPlayWhenInactive");
+    method(_javaPart, playWhenInactive);
+  }
+  bool JHybridVideoPlayerSpec::getIsPlaying() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isPlaying");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::optional<PlayerTrack> JHybridVideoPlayerSpec::getSelectedTrack() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPlayerTrack>()>("getSelectedTrack");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridVideoPlayerSpec::replaceSourceAsync(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>>& source) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JVariant_NullType_HybridVideoPlayerSourceSpec> /* source */)>("replaceSourceAsync");
+    auto __result = method(_javaPart, source.has_value() ? JVariant_NullType_HybridVideoPlayerSourceSpec::fromCpp(source.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::vector<PlayerTrack> JHybridVideoPlayerSpec::getAvailableTextTracks() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JPlayerTrack>>()>("getAvailableTextTracks");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<PlayerTrack> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridVideoPlayerSpec::initialize() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("initialize");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridVideoPlayerSpec::preload() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("preload");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridVideoPlayerSpec::play() {
+    static const auto method = javaClassStatic()->getMethod<void()>("play");
+    method(_javaPart);
+  }
+  void JHybridVideoPlayerSpec::pause() {
+    static const auto method = javaClassStatic()->getMethod<void()>("pause");
+    method(_javaPart);
+  }
+  void JHybridVideoPlayerSpec::seekBy(double time) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* time */)>("seekBy");
+    method(_javaPart, time);
+  }
+  void JHybridVideoPlayerSpec::seekTo(double time) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* time */)>("seekTo");
+    method(_javaPart, time);
+  }
+  AllPlayerTracks JHybridVideoPlayerSpec::getAllPlayerTracks() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAllPlayerTracks>()>("getAllPlayerTracks");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridVideoPlayerSpec::selectTrackById(TrackType type, const std::optional<std::string>& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTrackType> /* type */, jni::alias_ref<jni::JString> /* id */)>("selectTrackById");
+    method(_javaPart, JTrackType::fromCpp(type), id.has_value() ? jni::make_jstring(id.value()) : nullptr);
+  }
+  void JHybridVideoPlayerSpec::selectTrackByIndex(TrackType type, std::optional<double> index) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTrackType> /* type */, jni::alias_ref<jni::JDouble> /* index */)>("selectTrackByIndex");
+    method(_javaPart, JTrackType::fromCpp(type), index.has_value() ? jni::JDouble::valueOf(index.value()) : nullptr);
+  }
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,102 @@
+///
+/// HybridVideoPlayerSpec.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 "HybridVideoPlayerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  class JHybridVideoPlayerSpec: public jni::HybridClass<JHybridVideoPlayerSpec, JHybridObject>,
+                                public virtual HybridVideoPlayerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/HybridVideoPlayerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridVideoPlayerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridVideoPlayerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridVideoPlayerSpec() 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<JHybridVideoPlayerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::shared_ptr<HybridVideoPlayerSourceSpec> getSource() override;
+    std::shared_ptr<HybridVideoPlayerEventEmitterSpec> getEventEmitter() override;
+    bool getShowNotificationControls() override;
+    void setShowNotificationControls(bool showNotificationControls) override;
+    VideoPlayerStatus getStatus() override;
+    double getDuration() override;
+    double getVolume() override;
+    void setVolume(double volume) override;
+    double getCurrentTime() override;
+    void setCurrentTime(double currentTime) override;
+    int64_t getSubtitleDelay() override;
+    void setSubtitleDelay(int64_t subtitleDelay) override;
+    bool getMuted() override;
+    void setMuted(bool muted) override;
+    bool getLoop() override;
+    void setLoop(bool loop) override;
+    double getRate() override;
+    void setRate(double rate) override;
+    MixAudioMode getMixAudioMode() override;
+    void setMixAudioMode(MixAudioMode mixAudioMode) override;
+    IgnoreSilentSwitchMode getIgnoreSilentSwitchMode() override;
+    void setIgnoreSilentSwitchMode(IgnoreSilentSwitchMode ignoreSilentSwitchMode) override;
+    bool getPlayInBackground() override;
+    void setPlayInBackground(bool playInBackground) override;
+    bool getPlayWhenInactive() override;
+    void setPlayWhenInactive(bool playWhenInactive) override;
+    bool getIsPlaying() override;
+    std::optional<PlayerTrack> getSelectedTrack() override;
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> replaceSourceAsync(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>>& source) override;
+    std::vector<PlayerTrack> getAvailableTextTracks() override;
+    std::shared_ptr<Promise<void>> initialize() override;
+    std::shared_ptr<Promise<void>> preload() override;
+    void play() override;
+    void pause() override;
+    void seekBy(double time) override;
+    void seekTo(double time) override;
+    AllPlayerTracks getAllPlayerTracks() override;
+    void selectTrackById(TrackType type, const std::optional<std::string>& id) override;
+    void selectTrackByIndex(TrackType type, std::optional<double> index) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridVideoPlayerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::video

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

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

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

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