react-native-nitro-player 0.0.1

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

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

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(connected: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool connected) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* connected */)>("invoke");
+      method(self(), connected);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* connected */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean connected) {
+      _func(static_cast<bool>(connected));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* connected */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* connected */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* connected */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(position: Double, totalDuration: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double: public jni::JavaClass<JFunc_void_double_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_double_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double` instance holds through JNI.
+     */
+    void invoke(double position, double totalDuration) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* position */, double /* totalDuration */)>("invoke");
+      method(self(), position, totalDuration);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_cxx final: public jni::HybridClass<JFunc_void_double_double_cxx, JFunc_void_double_double> {
+  public:
+    static jni::local_ref<JFunc_void_double_double::javaobject> fromCpp(const std::function<void(double /* position */, double /* totalDuration */)>& func) {
+      return JFunc_void_double_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_cxx` instance holds.
+     */
+    void invoke_cxx(double position, double totalDuration) {
+      _func(position, totalDuration);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* position */, double /* totalDuration */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_double_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_cxx(const std::function<void(double /* position */, double /* totalDuration */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* position */, double /* totalDuration */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_double_double_std__optional_bool_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(position: Double, totalDuration: Double, isManuallySeeked: Boolean?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double_std__optional_bool_: public jni::JavaClass<JFunc_void_double_double_std__optional_bool_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_double_double_std__optional_bool_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double_std__optional_bool_` instance holds through JNI.
+     */
+    void invoke(double position, double totalDuration, std::optional<bool> isManuallySeeked) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* position */, double /* totalDuration */, jni::alias_ref<jni::JBoolean> /* isManuallySeeked */)>("invoke");
+      method(self(), position, totalDuration, isManuallySeeked.has_value() ? jni::JBoolean::valueOf(isManuallySeeked.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double_std__optional_bool_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_std__optional_bool__cxx final: public jni::HybridClass<JFunc_void_double_double_std__optional_bool__cxx, JFunc_void_double_double_std__optional_bool_> {
+  public:
+    static jni::local_ref<JFunc_void_double_double_std__optional_bool_::javaobject> fromCpp(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& func) {
+      return JFunc_void_double_double_std__optional_bool__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_std__optional_bool__cxx` instance holds.
+     */
+    void invoke_cxx(double position, double totalDuration, jni::alias_ref<jni::JBoolean> isManuallySeeked) {
+      _func(position, totalDuration, isManuallySeeked != nullptr ? std::make_optional(static_cast<bool>(isManuallySeeked->value())) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_double_double_std__optional_bool__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_std__optional_bool__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_std__optional_bool__cxx(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

@@ -0,0 +1,106 @@
+///
+/// JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "Playlist.hpp"
+#include <vector>
+#include "QueueOperation.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlaylist.hpp"
+#include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include "TrackItem.hpp"
+#include "JTrackItem.hpp"
+#include "JQueueOperation.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(playlists: Array<Playlist>, operation: QueueOperation?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_Playlist__std__optional_QueueOperation_: public jni::JavaClass<JFunc_void_std__vector_Playlist__std__optional_QueueOperation_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_Playlist__std__optional_QueueOperation_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_Playlist__std__optional_QueueOperation_` instance holds through JNI.
+     */
+    void invoke(const std::vector<Playlist>& playlists, std::optional<QueueOperation> operation) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JPlaylist>> /* playlists */, jni::alias_ref<JQueueOperation> /* operation */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = playlists.size();
+        jni::local_ref<jni::JArrayClass<JPlaylist>> __array = jni::JArrayClass<JPlaylist>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = playlists[__i];
+          auto __elementJni = JPlaylist::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }(), operation.has_value() ? JQueueOperation::fromCpp(operation.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_Playlist__std__optional_QueueOperation_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx final: public jni::HybridClass<JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx, JFunc_void_std__vector_Playlist__std__optional_QueueOperation_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_Playlist__std__optional_QueueOperation_::javaobject> fromCpp(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& func) {
+      return JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JPlaylist>> playlists, jni::alias_ref<JQueueOperation> operation) {
+      _func([&]() {
+              size_t __size = playlists->size();
+              std::vector<Playlist> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = playlists->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }(), operation != nullptr ? std::make_optional(operation->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_Playlist__std__optional_QueueOperation__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,55 @@
+///
+/// JHybridAndroidAutoMediaLibrarySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAndroidAutoMediaLibrarySpec.hpp"
+
+
+
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  jni::local_ref<JHybridAndroidAutoMediaLibrarySpec::jhybriddata> JHybridAndroidAutoMediaLibrarySpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAndroidAutoMediaLibrarySpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAndroidAutoMediaLibrarySpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAndroidAutoMediaLibrarySpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAndroidAutoMediaLibrarySpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAndroidAutoMediaLibrarySpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridAndroidAutoMediaLibrarySpec::setMediaLibrary(const std::string& libraryJson) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* libraryJson */)>("setMediaLibrary");
+    method(_javaPart, jni::make_jstring(libraryJson));
+  }
+  void JHybridAndroidAutoMediaLibrarySpec::clearMediaLibrary() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearMediaLibrary");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,66 @@
+///
+/// HybridAndroidAutoMediaLibrarySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAndroidAutoMediaLibrarySpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridAndroidAutoMediaLibrarySpec: public jni::HybridClass<JHybridAndroidAutoMediaLibrarySpec, JHybridObject>,
+                                            public virtual HybridAndroidAutoMediaLibrarySpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrarySpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAndroidAutoMediaLibrarySpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAndroidAutoMediaLibrarySpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAndroidAutoMediaLibrarySpec() 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<JHybridAndroidAutoMediaLibrarySpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void setMediaLibrary(const std::string& libraryJson) override;
+    void clearMediaLibrary() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAndroidAutoMediaLibrarySpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer