react-native-nitro-player 0.0.1

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

@@ -0,0 +1,70 @@
+///
+/// JHybridAudioDevicesSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAudioDevicesSpec.hpp"
+
+// Forward declaration of `TAudioDevice` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TAudioDevice; }
+
+#include "TAudioDevice.hpp"
+#include <vector>
+#include "JTAudioDevice.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  jni::local_ref<JHybridAudioDevicesSpec::jhybriddata> JHybridAudioDevicesSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAudioDevicesSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAudioDevicesSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAudioDevicesSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAudioDevicesSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAudioDevicesSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::vector<TAudioDevice> JHybridAudioDevicesSpec::getAudioDevices() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JTAudioDevice>>()>("getAudioDevices");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<TAudioDevice> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  bool JHybridAudioDevicesSpec::setAudioDevice(double deviceId) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(double /* deviceId */)>("setAudioDevice");
+    auto __result = method(_javaPart, deviceId);
+    return static_cast<bool>(__result);
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

@@ -0,0 +1,143 @@
+///
+/// JHybridPlayerQueueSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridPlayerQueueSpec.hpp"
+
+// Forward declaration of `Playlist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct Playlist; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `QueueOperation` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
+
+#include <string>
+#include <NitroModules/Null.hpp>
+#include "Playlist.hpp"
+#include <variant>
+#include "JVariant_NullType_Playlist.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JPlaylist.hpp"
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include "TrackItem.hpp"
+#include <vector>
+#include "JTrackItem.hpp"
+#include "QueueOperation.hpp"
+#include <functional>
+#include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JQueueOperation.hpp"
+#include "JFunc_void_std__string_Playlist_std__optional_QueueOperation_.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  jni::local_ref<JHybridPlayerQueueSpec::jhybriddata> JHybridPlayerQueueSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridPlayerQueueSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridPlayerQueueSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridPlayerQueueSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridPlayerQueueSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridPlayerQueueSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::string JHybridPlayerQueueSpec::createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* name */, jni::alias_ref<jni::JString> /* description */, jni::alias_ref<jni::JString> /* artwork */)>("createPlaylist");
+    auto __result = method(_javaPart, jni::make_jstring(name), description.has_value() ? jni::make_jstring(description.value()) : nullptr, artwork.has_value() ? jni::make_jstring(artwork.value()) : nullptr);
+    return __result->toStdString();
+  }
+  void JHybridPlayerQueueSpec::deletePlaylist(const std::string& playlistId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */)>("deletePlaylist");
+    method(_javaPart, jni::make_jstring(playlistId));
+  }
+  void JHybridPlayerQueueSpec::updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JString> /* name */, jni::alias_ref<jni::JString> /* description */, jni::alias_ref<jni::JString> /* artwork */)>("updatePlaylist");
+    method(_javaPart, jni::make_jstring(playlistId), name.has_value() ? jni::make_jstring(name.value()) : nullptr, description.has_value() ? jni::make_jstring(description.value()) : nullptr, artwork.has_value() ? jni::make_jstring(artwork.value()) : nullptr);
+  }
+  std::variant<nitro::NullType, Playlist> JHybridPlayerQueueSpec::getPlaylist(const std::string& playlistId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_Playlist>(jni::alias_ref<jni::JString> /* playlistId */)>("getPlaylist");
+    auto __result = method(_javaPart, jni::make_jstring(playlistId));
+    return __result->toCpp();
+  }
+  std::vector<Playlist> JHybridPlayerQueueSpec::getAllPlaylists() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JPlaylist>>()>("getAllPlaylists");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<Playlist> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridPlayerQueueSpec::addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<JTrackItem> /* track */, jni::alias_ref<jni::JDouble> /* index */)>("addTrackToPlaylist");
+    method(_javaPart, jni::make_jstring(playlistId), JTrackItem::fromCpp(track), index.has_value() ? jni::JDouble::valueOf(index.value()) : nullptr);
+  }
+  void JHybridPlayerQueueSpec::addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */, jni::alias_ref<jni::JDouble> /* index */)>("addTracksToPlaylist");
+    method(_javaPart, jni::make_jstring(playlistId), [&]() {
+      size_t __size = tracks.size();
+      jni::local_ref<jni::JArrayClass<JTrackItem>> __array = jni::JArrayClass<JTrackItem>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = tracks[__i];
+        auto __elementJni = JTrackItem::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), index.has_value() ? jni::JDouble::valueOf(index.value()) : nullptr);
+  }
+  void JHybridPlayerQueueSpec::removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JString> /* trackId */)>("removeTrackFromPlaylist");
+    method(_javaPart, jni::make_jstring(playlistId), jni::make_jstring(trackId));
+  }
+  void JHybridPlayerQueueSpec::reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JString> /* trackId */, double /* newIndex */)>("reorderTrackInPlaylist");
+    method(_javaPart, jni::make_jstring(playlistId), jni::make_jstring(trackId), newIndex);
+  }
+  void JHybridPlayerQueueSpec::loadPlaylist(const std::string& playlistId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playlistId */)>("loadPlaylist");
+    method(_javaPart, jni::make_jstring(playlistId));
+  }
+  std::variant<nitro::NullType, std::string> JHybridPlayerQueueSpec::getCurrentPlaylistId() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_String>()>("getCurrentPlaylistId");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridPlayerQueueSpec::onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_Playlist__std__optional_QueueOperation_::javaobject> /* callback */)>("onPlaylistsChanged_cxx");
+    method(_javaPart, JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx::fromCpp(callback));
+  }
+  void JHybridPlayerQueueSpec::onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string_Playlist_std__optional_QueueOperation_::javaobject> /* callback */)>("onPlaylistChanged_cxx");
+    method(_javaPart, JFunc_void_std__string_Playlist_std__optional_QueueOperation__cxx::fromCpp(callback));
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,77 @@
+///
+/// HybridPlayerQueueSpec.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 "HybridPlayerQueueSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridPlayerQueueSpec: public jni::HybridClass<JHybridPlayerQueueSpec, JHybridObject>,
+                                public virtual HybridPlayerQueueSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridPlayerQueueSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridPlayerQueueSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridPlayerQueueSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridPlayerQueueSpec() 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<JHybridPlayerQueueSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::string createPlaylist(const std::string& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override;
+    void deletePlaylist(const std::string& playlistId) override;
+    void updatePlaylist(const std::string& playlistId, const std::optional<std::string>& name, const std::optional<std::string>& description, const std::optional<std::string>& artwork) override;
+    std::variant<nitro::NullType, Playlist> getPlaylist(const std::string& playlistId) override;
+    std::vector<Playlist> getAllPlaylists() override;
+    void addTrackToPlaylist(const std::string& playlistId, const TrackItem& track, std::optional<double> index) override;
+    void addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) override;
+    void removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) override;
+    void reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) override;
+    void loadPlaylist(const std::string& playlistId) override;
+    std::variant<nitro::NullType, std::string> getCurrentPlaylistId() override;
+    void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) override;
+    void onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridPlayerQueueSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,137 @@
+///
+/// JHybridTrackPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridTrackPlayerSpec.hpp"
+
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `TrackPlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `PlayerConfig` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
+// Forward declaration of `Reason` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class Reason; }
+
+#include "PlayerState.hpp"
+#include "JPlayerState.hpp"
+#include <NitroModules/Null.hpp>
+#include "TrackItem.hpp"
+#include <variant>
+#include <optional>
+#include "JVariant_NullType_TrackItem.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JTrackItem.hpp"
+#include <string>
+#include "JVariant_NullType_String.hpp"
+#include "TrackPlayerState.hpp"
+#include "JTrackPlayerState.hpp"
+#include "PlayerConfig.hpp"
+#include "JPlayerConfig.hpp"
+#include "Reason.hpp"
+#include <functional>
+#include "JFunc_void_TrackItem_std__optional_Reason_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JReason.hpp"
+#include "JFunc_void_TrackPlayerState_std__optional_Reason_.hpp"
+#include "JFunc_void_double_double.hpp"
+#include "JFunc_void_double_double_std__optional_bool_.hpp"
+#include "JFunc_void_bool.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  jni::local_ref<JHybridTrackPlayerSpec::jhybriddata> JHybridTrackPlayerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridTrackPlayerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridTrackPlayerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridTrackPlayerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridTrackPlayerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridTrackPlayerSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridTrackPlayerSpec::play() {
+    static const auto method = javaClassStatic()->getMethod<void()>("play");
+    method(_javaPart);
+  }
+  void JHybridTrackPlayerSpec::pause() {
+    static const auto method = javaClassStatic()->getMethod<void()>("pause");
+    method(_javaPart);
+  }
+  void JHybridTrackPlayerSpec::playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* songId */, jni::alias_ref<jni::JString> /* fromPlaylist */)>("playSong");
+    method(_javaPart, jni::make_jstring(songId), fromPlaylist.has_value() ? jni::make_jstring(fromPlaylist.value()) : nullptr);
+  }
+  void JHybridTrackPlayerSpec::skipToNext() {
+    static const auto method = javaClassStatic()->getMethod<void()>("skipToNext");
+    method(_javaPart);
+  }
+  void JHybridTrackPlayerSpec::skipToPrevious() {
+    static const auto method = javaClassStatic()->getMethod<void()>("skipToPrevious");
+    method(_javaPart);
+  }
+  void JHybridTrackPlayerSpec::seek(double position) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* position */)>("seek");
+    method(_javaPart, position);
+  }
+  PlayerState JHybridTrackPlayerSpec::getState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPlayerState>()>("getState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
+    method(_javaPart, JPlayerConfig::fromCpp(config));
+  }
+  void JHybridTrackPlayerSpec::onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TrackItem_std__optional_Reason_::javaobject> /* callback */)>("onChangeTrack_cxx");
+    method(_javaPart, JFunc_void_TrackItem_std__optional_Reason__cxx::fromCpp(callback));
+  }
+  void JHybridTrackPlayerSpec::onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TrackPlayerState_std__optional_Reason_::javaobject> /* callback */)>("onPlaybackStateChange_cxx");
+    method(_javaPart, JFunc_void_TrackPlayerState_std__optional_Reason__cxx::fromCpp(callback));
+  }
+  void JHybridTrackPlayerSpec::onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double_double::javaobject> /* callback */)>("onSeek_cxx");
+    method(_javaPart, JFunc_void_double_double_cxx::fromCpp(callback));
+  }
+  void JHybridTrackPlayerSpec::onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double_double_std__optional_bool_::javaobject> /* callback */)>("onPlaybackProgressChange_cxx");
+    method(_javaPart, JFunc_void_double_double_std__optional_bool__cxx::fromCpp(callback));
+  }
+  void JHybridTrackPlayerSpec::onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onAndroidAutoConnectionChange_cxx");
+    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
+  }
+  bool JHybridTrackPlayerSpec::isAndroidAutoConnected() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isAndroidAutoConnected");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,78 @@
+///
+/// HybridTrackPlayerSpec.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 "HybridTrackPlayerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridTrackPlayerSpec: public jni::HybridClass<JHybridTrackPlayerSpec, JHybridObject>,
+                                public virtual HybridTrackPlayerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridTrackPlayerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridTrackPlayerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridTrackPlayerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridTrackPlayerSpec() 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<JHybridTrackPlayerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void play() override;
+    void pause() override;
+    void playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override;
+    void skipToNext() override;
+    void skipToPrevious() override;
+    void seek(double position) override;
+    PlayerState getState() override;
+    void configure(const PlayerConfig& config) override;
+    void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override;
+    void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) override;
+    void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) override;
+    void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override;
+    void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
+    bool isAndroidAutoConnected() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridTrackPlayerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,65 @@
+///
+/// JPlayerConfig.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 "PlayerConfig.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PlayerConfig" and the the Kotlin data class "PlayerConfig".
+   */
+  struct JPlayerConfig final: public jni::JavaClass<JPlayerConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/PlayerConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PlayerConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PlayerConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAndroidAutoEnabled = clazz->getField<jni::JBoolean>("androidAutoEnabled");
+      jni::local_ref<jni::JBoolean> androidAutoEnabled = this->getFieldValue(fieldAndroidAutoEnabled);
+      static const auto fieldCarPlayEnabled = clazz->getField<jni::JBoolean>("carPlayEnabled");
+      jni::local_ref<jni::JBoolean> carPlayEnabled = this->getFieldValue(fieldCarPlayEnabled);
+      static const auto fieldShowInNotification = clazz->getField<jni::JBoolean>("showInNotification");
+      jni::local_ref<jni::JBoolean> showInNotification = this->getFieldValue(fieldShowInNotification);
+      return PlayerConfig(
+        androidAutoEnabled != nullptr ? std::make_optional(static_cast<bool>(androidAutoEnabled->value())) : std::nullopt,
+        carPlayEnabled != nullptr ? std::make_optional(static_cast<bool>(carPlayEnabled->value())) : std::nullopt,
+        showInNotification != nullptr ? std::make_optional(static_cast<bool>(showInNotification->value())) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPlayerConfig::javaobject> fromCpp(const PlayerConfig& value) {
+      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.androidAutoEnabled.has_value() ? jni::JBoolean::valueOf(value.androidAutoEnabled.value()) : nullptr,
+        value.carPlayEnabled.has_value() ? jni::JBoolean::valueOf(value.carPlayEnabled.value()) : nullptr,
+        value.showInNotification.has_value() ? jni::JBoolean::valueOf(value.showInNotification.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer