react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -0,0 +1,99 @@
+///
+/// HybridDownloadManagerSpec.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 "HybridDownloadManagerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridDownloadManagerSpec: public jni::HybridClass<JHybridDownloadManagerSpec, JHybridObject>,
+                                    public virtual HybridDownloadManagerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridDownloadManagerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridDownloadManagerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridDownloadManagerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridDownloadManagerSpec() 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<JHybridDownloadManagerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void configure(const DownloadConfig& config) override;
+    DownloadConfig getConfig() override;
+    std::shared_ptr<Promise<std::string>> downloadTrack(const TrackItem& track, const std::optional<std::string>& playlistId) override;
+    std::shared_ptr<Promise<std::vector<std::string>>> downloadPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks) override;
+    std::shared_ptr<Promise<void>> pauseDownload(const std::string& downloadId) override;
+    std::shared_ptr<Promise<void>> resumeDownload(const std::string& downloadId) override;
+    std::shared_ptr<Promise<void>> cancelDownload(const std::string& downloadId) override;
+    std::shared_ptr<Promise<void>> retryDownload(const std::string& downloadId) override;
+    std::shared_ptr<Promise<void>> pauseAllDownloads() override;
+    std::shared_ptr<Promise<void>> resumeAllDownloads() override;
+    std::shared_ptr<Promise<void>> cancelAllDownloads() override;
+    std::variant<nitro::NullType, DownloadTask> getDownloadTask(const std::string& downloadId) override;
+    std::vector<DownloadTask> getActiveDownloads() override;
+    DownloadQueueStatus getQueueStatus() override;
+    bool isDownloading(const std::string& trackId) override;
+    DownloadState getDownloadState(const std::string& trackId) override;
+    bool isTrackDownloaded(const std::string& trackId) override;
+    bool isPlaylistDownloaded(const std::string& playlistId) override;
+    bool isPlaylistPartiallyDownloaded(const std::string& playlistId) override;
+    std::variant<nitro::NullType, DownloadedTrack> getDownloadedTrack(const std::string& trackId) override;
+    std::vector<DownloadedTrack> getAllDownloadedTracks() override;
+    std::variant<nitro::NullType, DownloadedPlaylist> getDownloadedPlaylist(const std::string& playlistId) override;
+    std::vector<DownloadedPlaylist> getAllDownloadedPlaylists() override;
+    std::variant<nitro::NullType, std::string> getLocalPath(const std::string& trackId) override;
+    std::shared_ptr<Promise<void>> deleteDownloadedTrack(const std::string& trackId) override;
+    std::shared_ptr<Promise<void>> deleteDownloadedPlaylist(const std::string& playlistId) override;
+    std::shared_ptr<Promise<void>> deleteAllDownloads() override;
+    std::shared_ptr<Promise<DownloadStorageInfo>> getStorageInfo() override;
+    double syncDownloads() override;
+    void setPlaybackSourcePreference(PlaybackSource preference) override;
+    PlaybackSource getPlaybackSourcePreference() override;
+    std::string getEffectiveUrl(const TrackItem& track) override;
+    void onDownloadProgress(const std::function<void(const DownloadProgress& /* progress */)>& callback) override;
+    void onDownloadStateChange(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& callback) override;
+    void onDownloadComplete(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& callback) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridDownloadManagerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,204 @@
+///
+/// JHybridEqualizerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridEqualizerSpec.hpp"
+
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerBand; }
+// Forward declaration of `GainRange` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct GainRange; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerPreset; }
+// Forward declaration of `PresetType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PresetType; }
+// Forward declaration of `EqualizerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerState; }
+
+#include "EqualizerBand.hpp"
+#include <vector>
+#include "JEqualizerBand.hpp"
+#include <string>
+#include "GainRange.hpp"
+#include "JGainRange.hpp"
+#include "EqualizerPreset.hpp"
+#include "JEqualizerPreset.hpp"
+#include "PresetType.hpp"
+#include "JPresetType.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include "EqualizerState.hpp"
+#include "JEqualizerState.hpp"
+#include <optional>
+#include <functional>
+#include "JFunc_void_bool.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_std__vector_EqualizerBand_.hpp"
+#include "JFunc_void_std__optional_std__variant_nitro__NullType__std__string__.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  jni::local_ref<JHybridEqualizerSpec::jhybriddata> JHybridEqualizerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridEqualizerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridEqualizerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridEqualizerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridEqualizerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridEqualizerSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  bool JHybridEqualizerSpec::setEnabled(bool enabled) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jboolean /* enabled */)>("setEnabled");
+    auto __result = method(_javaPart, enabled);
+    return static_cast<bool>(__result);
+  }
+  bool JHybridEqualizerSpec::isEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::vector<EqualizerBand> JHybridEqualizerSpec::getBands() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JEqualizerBand>>()>("getBands");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<EqualizerBand> __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 JHybridEqualizerSpec::setBandGain(double bandIndex, double gainDb) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(double /* bandIndex */, double /* gainDb */)>("setBandGain");
+    auto __result = method(_javaPart, bandIndex, gainDb);
+    return static_cast<bool>(__result);
+  }
+  bool JHybridEqualizerSpec::setAllBandGains(const std::vector<double>& gains) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JArrayDouble> /* gains */)>("setAllBandGains");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = gains.size();
+      jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+      __array->setRegion(0, __size, gains.data());
+      return __array;
+    }());
+    return static_cast<bool>(__result);
+  }
+  GainRange JHybridEqualizerSpec::getBandRange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JGainRange>()>("getBandRange");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::vector<EqualizerPreset> JHybridEqualizerSpec::getPresets() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JEqualizerPreset>>()>("getPresets");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<EqualizerPreset> __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::vector<EqualizerPreset> JHybridEqualizerSpec::getBuiltInPresets() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JEqualizerPreset>>()>("getBuiltInPresets");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<EqualizerPreset> __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::vector<EqualizerPreset> JHybridEqualizerSpec::getCustomPresets() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JEqualizerPreset>>()>("getCustomPresets");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<EqualizerPreset> __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 JHybridEqualizerSpec::applyPreset(const std::string& presetName) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* presetName */)>("applyPreset");
+    auto __result = method(_javaPart, jni::make_jstring(presetName));
+    return static_cast<bool>(__result);
+  }
+  std::variant<nitro::NullType, std::string> JHybridEqualizerSpec::getCurrentPresetName() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_String>()>("getCurrentPresetName");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  bool JHybridEqualizerSpec::saveCustomPreset(const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* name */)>("saveCustomPreset");
+    auto __result = method(_javaPart, jni::make_jstring(name));
+    return static_cast<bool>(__result);
+  }
+  bool JHybridEqualizerSpec::deleteCustomPreset(const std::string& name) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* name */)>("deleteCustomPreset");
+    auto __result = method(_javaPart, jni::make_jstring(name));
+    return static_cast<bool>(__result);
+  }
+  EqualizerState JHybridEqualizerSpec::getState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JEqualizerState>()>("getState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridEqualizerSpec::reset() {
+    static const auto method = javaClassStatic()->getMethod<void()>("reset");
+    method(_javaPart);
+  }
+  void JHybridEqualizerSpec::onEnabledChange(const std::function<void(bool /* enabled */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onEnabledChange_cxx");
+    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
+  }
+  void JHybridEqualizerSpec::onBandChange(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_EqualizerBand_::javaobject> /* callback */)>("onBandChange_cxx");
+    method(_javaPart, JFunc_void_std__vector_EqualizerBand__cxx::fromCpp(callback));
+  }
+  void JHybridEqualizerSpec::onPresetChange(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__optional_std__variant_nitro__NullType__std__string__::javaobject> /* callback */)>("onPresetChange_cxx");
+    method(_javaPart, JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx::fromCpp(callback));
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,82 @@
+///
+/// HybridEqualizerSpec.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 "HybridEqualizerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridEqualizerSpec: public jni::HybridClass<JHybridEqualizerSpec, JHybridObject>,
+                              public virtual HybridEqualizerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridEqualizerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridEqualizerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridEqualizerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridEqualizerSpec() 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<JHybridEqualizerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    bool setEnabled(bool enabled) override;
+    bool isEnabled() override;
+    std::vector<EqualizerBand> getBands() override;
+    bool setBandGain(double bandIndex, double gainDb) override;
+    bool setAllBandGains(const std::vector<double>& gains) override;
+    GainRange getBandRange() override;
+    std::vector<EqualizerPreset> getPresets() override;
+    std::vector<EqualizerPreset> getBuiltInPresets() override;
+    std::vector<EqualizerPreset> getCustomPresets() override;
+    bool applyPreset(const std::string& presetName) override;
+    std::variant<nitro::NullType, std::string> getCurrentPresetName() override;
+    bool saveCustomPreset(const std::string& name) override;
+    bool deleteCustomPreset(const std::string& name) override;
+    EqualizerState getState() override;
+    void reset() override;
+    void onEnabledChange(const std::function<void(bool /* enabled */)>& callback) override;
+    void onBandChange(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& callback) override;
+    void onPresetChange(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& callback) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridEqualizerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -26,6 +26,8 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "QueueOperation.hpp"
 #include <functional>
 #include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"

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

@@ -7,12 +7,14 @@
 
 #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 `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `CurrentPlayingType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class CurrentPlayingType; }
 // Forward declaration of `RepeatMode` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
@@ -20,19 +22,26 @@ 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 <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
 #include "TrackItem.hpp"
-#include <variant>
-#include <optional>
-#include "JVariant_NullType_TrackItem.hpp"
-#include <NitroModules/JNull.hpp>
+#include <vector>
 #include "JTrackItem.hpp"
 #include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+#include "PlayerState.hpp"
+#include "JPlayerState.hpp"
+#include "JVariant_NullType_TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include "JTrackPlayerState.hpp"
+#include "CurrentPlayingType.hpp"
+#include "JCurrentPlayingType.hpp"
 #include "RepeatMode.hpp"
 #include "JRepeatMode.hpp"
 #include "PlayerConfig.hpp"
@@ -87,14 +96,41 @@ namespace margelo::nitro::nitroplayer {
     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);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* songId */, jni::alias_ref<jni::JString> /* fromPlaylist */)>("playSong");
+    auto __result = method(_javaPart, jni::make_jstring(songId), fromPlaylist.has_value() ? jni::make_jstring(fromPlaylist.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;
+    }();
   }
   void JHybridTrackPlayerSpec::skipToNext() {
     static const auto method = javaClassStatic()->getMethod<void()>("skipToNext");
     method(_javaPart);
   }
+  std::shared_ptr<Promise<bool>> JHybridTrackPlayerSpec::skipToIndex(double index) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* index */)>("skipToIndex");
+    auto __result = method(_javaPart, index);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   void JHybridTrackPlayerSpec::skipToPrevious() {
     static const auto method = javaClassStatic()->getMethod<void()>("skipToPrevious");
     method(_javaPart);
@@ -103,10 +139,76 @@ namespace margelo::nitro::nitroplayer {
     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");
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::addToUpNext(const std::string& trackId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("addToUpNext");
+    auto __result = method(_javaPart, jni::make_jstring(trackId));
+    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>> JHybridTrackPlayerSpec::playNext(const std::string& trackId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("playNext");
+    auto __result = method(_javaPart, jni::make_jstring(trackId));
+    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<std::vector<TrackItem>>> JHybridTrackPlayerSpec::getActualQueue() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getActualQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<TrackItem>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JTrackItem>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<TrackItem> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __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<PlayerState>> JHybridTrackPlayerSpec::getState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getState");
     auto __result = method(_javaPart);
-    return __result->toCpp();
+    return [&]() {
+      auto __promise = Promise<PlayerState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPlayerState>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   bool JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
     static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");

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

@@ -56,11 +56,15 @@ namespace margelo::nitro::nitroplayer {
     // Methods
     void play() override;
     void pause() override;
-    void playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override;
+    std::shared_ptr<Promise<void>> playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override;
     void skipToNext() override;
+    std::shared_ptr<Promise<bool>> skipToIndex(double index) override;
     void skipToPrevious() override;
     void seek(double position) override;
-    PlayerState getState() override;
+    std::shared_ptr<Promise<void>> addToUpNext(const std::string& trackId) override;
+    std::shared_ptr<Promise<void>> playNext(const std::string& trackId) override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getActualQueue() override;
+    std::shared_ptr<Promise<PlayerState>> getState() override;
     bool setRepeatMode(RepeatMode mode) override;
     void configure(const PlayerConfig& config) override;
     void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override;

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

@@ -0,0 +1,62 @@
+///
+/// JPlaybackSource.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 "PlaybackSource.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PlaybackSource" and the the Kotlin enum "PlaybackSource".
+   */
+  struct JPlaybackSource final: public jni::JavaClass<JPlaybackSource> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/PlaybackSource;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PlaybackSource.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PlaybackSource toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PlaybackSource>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPlaybackSource> fromCpp(PlaybackSource value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAUTO = clazz->getStaticField<JPlaybackSource>("AUTO");
+      static const auto fieldDOWNLOAD = clazz->getStaticField<JPlaybackSource>("DOWNLOAD");
+      static const auto fieldNETWORK = clazz->getStaticField<JPlaybackSource>("NETWORK");
+      
+      switch (value) {
+        case PlaybackSource::AUTO:
+          return clazz->getStaticFieldValue(fieldAUTO);
+        case PlaybackSource::DOWNLOAD:
+          return clazz->getStaticFieldValue(fieldDOWNLOAD);
+        case PlaybackSource::NETWORK:
+          return clazz->getStaticFieldValue(fieldNETWORK);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer