spactureai-mobile-player 1.0.30

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

@@ -0,0 +1,83 @@
+///
+/// JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <NitroModules/Null.hpp>
+#include "TextTrack.hpp"
+#include <variant>
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JVariant_NullType_TextTrack.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JTextTrack.hpp"
+#include <string>
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(track: Variant_NullType_TextTrack?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__: public jni::JavaClass<JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/Func_void_std__optional_std__variant_nitro__NullType__TextTrack__;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__` instance holds through JNI.
+     */
+    void invoke(const std::optional<std::variant<nitro::NullType, TextTrack>>& track) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVariant_NullType_TextTrack> /* track */)>("invoke");
+      method(self(), track.has_value() ? JVariant_NullType_TextTrack::fromCpp(track.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_std__variant_nitro__NullType__TextTrack__ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx final: public jni::HybridClass<JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx, JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__::javaobject> fromCpp(const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& func) {
+      return JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JVariant_NullType_TextTrack> track) {
+      _func(track != nullptr ? std::make_optional(track->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/Func_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx(const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)> _func;
+  };
+
+} // namespace margelo::nitro::unifiedplayer

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 © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::unifiedplayer {
+
+  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 constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/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 constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/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::unifiedplayer

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

@@ -0,0 +1,224 @@
+///
+/// JHybridVideoPlayerEventEmitterSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoPlayerEventEmitterSpec.hpp"
+
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct ListenerSubscription; }
+// Forward declaration of `BandwidthData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct BandwidthData; }
+// Forward declaration of `onLoadData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadData; }
+// Forward declaration of `VideoOrientation` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoOrientation; }
+// Forward declaration of `onLoadStartData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadStartData; }
+// Forward declaration of `SourceType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SourceType; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `onPlaybackStateChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onPlaybackStateChangeData; }
+// Forward declaration of `onProgressData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onProgressData; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoPlayerStatus; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadata; }
+// Forward declaration of `TimedMetadataObject` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadataObject; }
+// Forward declaration of `TextTrack` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TextTrack; }
+// Forward declaration of `onVolumeChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { 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 "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 <vector>
+#include "JTimedMetadataObject.hpp"
+#include <string>
+#include "JFunc_void_std__vector_std__string_.hpp"
+#include <NitroModules/Null.hpp>
+#include "TextTrack.hpp"
+#include <variant>
+#include "JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__.hpp"
+#include "JVariant_NullType_TextTrack.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JTextTrack.hpp"
+#include "onVolumeChangeData.hpp"
+#include "JFunc_void_onVolumeChangeData.hpp"
+#include "JonVolumeChangeData.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  std::shared_ptr<JHybridVideoPlayerEventEmitterSpec> JHybridVideoPlayerEventEmitterSpec::JavaPart::getJHybridVideoPlayerEventEmitterSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridVideoPlayerEventEmitterSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridVideoPlayerEventEmitterSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridVideoPlayerEventEmitterSpec::CxxPart::jhybriddata> JHybridVideoPlayerEventEmitterSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridVideoPlayerEventEmitterSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridVideoPlayerEventEmitterSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridVideoPlayerEventEmitterSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridVideoPlayerEventEmitterSpec>(castJavaPart);
+  }
+
+  void JHybridVideoPlayerEventEmitterSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoPlayerEventEmitterSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnAudioBecomingNoisyListener(const std::function<void()>& listener) {
+    static const auto method = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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 = _javaPart->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::addOnTrackChangeListener(const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JListenerSubscription>(jni::alias_ref<JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack__::javaobject> /* listener */)>("addOnTrackChangeListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_std__variant_nitro__NullType__TextTrack___cxx::fromCpp(listener));
+    return __result->toCpp();
+  }
+  ListenerSubscription JHybridVideoPlayerEventEmitterSpec::addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) {
+    static const auto method = _javaPart->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 = _javaPart->javaClassStatic()->getMethod<void()>("clearAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::unifiedplayer

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

@@ -0,0 +1,82 @@
+///
+/// HybridVideoPlayerEventEmitterSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+
+
+
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace facebook;
+
+  class JHybridVideoPlayerEventEmitterSpec: public virtual HybridVideoPlayerEventEmitterSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/HybridVideoPlayerEventEmitterSpec;";
+      std::shared_ptr<JHybridVideoPlayerEventEmitterSpec> getJHybridVideoPlayerEventEmitterSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/HybridVideoPlayerEventEmitterSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridVideoPlayerEventEmitterSpec(const jni::local_ref<JHybridVideoPlayerEventEmitterSpec::JavaPart>& javaPart):
+      HybridObject(HybridVideoPlayerEventEmitterSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridVideoPlayerEventEmitterSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridVideoPlayerEventEmitterSpec::JavaPart>& 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 addOnTrackChangeListener(const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& listener) override;
+    ListenerSubscription addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) override;
+    void clearAllListeners() override;
+
+  private:
+    jni::global_ref<JHybridVideoPlayerEventEmitterSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::unifiedplayer

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

@@ -0,0 +1,60 @@
+///
+/// JHybridVideoPlayerFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridVideoPlayerFactorySpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSpec; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include "JHybridVideoPlayerSpec.hpp"
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "JHybridVideoPlayerSourceSpec.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  std::shared_ptr<JHybridVideoPlayerFactorySpec> JHybridVideoPlayerFactorySpec::JavaPart::getJHybridVideoPlayerFactorySpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridVideoPlayerFactorySpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridVideoPlayerFactorySpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridVideoPlayerFactorySpec::CxxPart::jhybriddata> JHybridVideoPlayerFactorySpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridVideoPlayerFactorySpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridVideoPlayerFactorySpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridVideoPlayerFactorySpec::JavaPart!");
+    }
+    return std::make_shared<JHybridVideoPlayerFactorySpec>(castJavaPart);
+  }
+
+  void JHybridVideoPlayerFactorySpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVideoPlayerFactorySpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridVideoPlayerSpec> JHybridVideoPlayerFactorySpec::createPlayer(const std::shared_ptr<HybridVideoPlayerSourceSpec>& source) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridVideoPlayerSpec::JavaPart>(jni::alias_ref<JHybridVideoPlayerSourceSpec::JavaPart> /* source */)>("createPlayer");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridVideoPlayerSourceSpec>(source)->getJavaPart());
+    return __result->getJHybridVideoPlayerSpec();
+  }
+
+} // namespace margelo::nitro::unifiedplayer

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

@@ -0,0 +1,63 @@
+///
+/// HybridVideoPlayerFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridVideoPlayerFactorySpec.hpp"
+
+
+
+
+namespace margelo::nitro::unifiedplayer {
+
+  using namespace facebook;
+
+  class JHybridVideoPlayerFactorySpec: public virtual HybridVideoPlayerFactorySpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/HybridVideoPlayerFactorySpec;";
+      std::shared_ptr<JHybridVideoPlayerFactorySpec> getJHybridVideoPlayerFactorySpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/unifiedplayer/HybridVideoPlayerFactorySpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridVideoPlayerFactorySpec(const jni::local_ref<JHybridVideoPlayerFactorySpec::JavaPart>& javaPart):
+      HybridObject(HybridVideoPlayerFactorySpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridVideoPlayerFactorySpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridVideoPlayerFactorySpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridVideoPlayerSpec> createPlayer(const std::shared_ptr<HybridVideoPlayerSourceSpec>& source) override;
+
+  private:
+    jni::global_ref<JHybridVideoPlayerFactorySpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::unifiedplayer