react-native-nitro-player 0.5.5 → 0.5.7

package/ios/download/DownloadManagerCore.swift

@@ -613,6 +613,12 @@ final class DownloadManagerCore: NSObject {
         artworkString = value
       }
     }
+
+    var extraPayloadDict: [String: Any]? = nil
+    if let extraPayload = track.extraPayload {
+      extraPayloadDict = extraPayload.toDictionary()
+    }
+
     return TrackItemRecord(
       id: track.id,
       title: track.title,
@@ -620,12 +626,30 @@ final class DownloadManagerCore: NSObject {
       album: track.album,
       duration: track.duration,
       url: track.url,
-      artwork: artworkString
+      artwork: artworkString,
+      extraPayload: extraPayloadDict
     )
   }
 
   private func recordToTrackItem(_ record: TrackItemRecord) -> TrackItem {
     let artwork: Variant_NullType_String? = record.artwork.map { .second($0) }
+
+    var extraPayload: AnyMap? = nil
+    if let extraPayloadDict = record.extraPayload {
+      extraPayload = AnyMap()
+      for (key, value) in extraPayloadDict {
+        if let stringValue = value as? String {
+          extraPayload?.setString(key: key, value: stringValue)
+        } else if let doubleValue = value as? Double {
+          extraPayload?.setDouble(key: key, value: doubleValue)
+        } else if let intValue = value as? Int {
+          extraPayload?.setDouble(key: key, value: Double(intValue))
+        } else if let boolValue = value as? Bool {
+          extraPayload?.setBoolean(key: key, value: boolValue)
+        }
+      }
+    }
+
     return TrackItem(
       id: record.id,
       title: record.title,
@@ -634,7 +658,7 @@ final class DownloadManagerCore: NSObject {
       duration: record.duration,
       url: record.url,
       artwork: artwork,
-      extraPayload: nil
+      extraPayload: extraPayload
     )
   }
 
@@ -963,4 +987,59 @@ private struct TrackItemRecord: Codable {
   let duration: Double
   let url: String
   let artwork: String?
+  let extraPayload: [String: Any]?
+
+  enum CodingKeys: String, CodingKey {
+    case id, title, artist, album, duration, url, artwork, extraPayload
+  }
+
+  // Manual encoding to handle [String: Any]
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(id, forKey: .id)
+    try container.encode(title, forKey: .title)
+    try container.encode(artist, forKey: .artist)
+    try container.encode(album, forKey: .album)
+    try container.encode(duration, forKey: .duration)
+    try container.encode(url, forKey: .url)
+    try container.encodeIfPresent(artwork, forKey: .artwork)
+
+    if let extraPayload = extraPayload {
+      let jsonData = try JSONSerialization.data(withJSONObject: extraPayload)
+      if let jsonString = String(data: jsonData, encoding: .utf8) {
+        try container.encode(jsonString, forKey: .extraPayload)
+      }
+    }
+  }
+
+  // Manual decoding to handle [String: Any]
+  init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    id = try container.decode(String.self, forKey: .id)
+    title = try container.decode(String.self, forKey: .title)
+    artist = try container.decode(String.self, forKey: .artist)
+    album = try container.decode(String.self, forKey: .album)
+    duration = try container.decode(Double.self, forKey: .duration)
+    url = try container.decode(String.self, forKey: .url)
+    artwork = try container.decodeIfPresent(String.self, forKey: .artwork)
+
+    if let jsonString = try? container.decodeIfPresent(String.self, forKey: .extraPayload),
+       let jsonData = jsonString.data(using: .utf8) {
+      extraPayload = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any]
+    } else {
+      extraPayload = nil
+    }
+  }
+
+  // Initializer for code creation
+  init(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: String?, extraPayload: [String: Any]?) {
+    self.id = id
+    self.title = title
+    self.artist = artist
+    self.album = album
+    self.duration = duration
+    self.url = url
+    self.artwork = artwork
+    self.extraPayload = extraPayload
+  }
 }

package/ios/playlist/PlaylistManager.swift

@@ -274,6 +274,74 @@ class PlaylistManager {
     return true
   }
 
+  /**
+   * Update entire track objects across all playlists
+   * Matches by track.id and replaces the entire track object
+   * @param tracks Array of full TrackItem objects to update
+   * @return Dictionary of playlistId -> count of tracks updated
+   */
+  func updateTracks(tracks: [TrackItem]) -> [String: Int] {
+    let tracksMap = Dictionary(uniqueKeysWithValues: tracks.map { ($0.id, $0) })
+    var affectedPlaylists: [String: Int] = [:]
+
+    queue.sync {
+      for (playlistId, playlist) in playlists {
+        var updateCount = 0
+        let newTracks = playlist.tracks.map { track -> TrackItem in
+          if let updatedTrack = tracksMap[track.id] {
+            updateCount += 1
+            return updatedTrack
+          }
+          return track
+        }
+
+        if updateCount > 0 {
+          affectedPlaylists[playlistId] = updateCount
+          playlists[playlistId] = PlaylistModel(
+            id: playlist.id,
+            name: playlist.name,
+            description: playlist.description,
+            artwork: playlist.artwork,
+            tracks: newTracks
+          )
+        }
+      }
+    }
+
+    if !affectedPlaylists.isEmpty {
+      scheduleSave()
+      affectedPlaylists.keys.forEach { playlistId in
+        notifyPlaylistChanged(playlistId, .update)
+      }
+      notifyPlaylistsChanged(.update)
+    }
+
+    return affectedPlaylists
+  }
+
+  /**
+   * Get tracks by IDs from all playlists
+   * @param trackIds Array of track IDs to fetch
+   * @return Array of matching TrackItem objects
+   */
+  func getTracksById(trackIds: [String]) -> [TrackItem] {
+    let trackIdSet = Set(trackIds)
+    var foundTracks: [String: TrackItem] = [:]
+
+    queue.sync {
+      for playlist in playlists.values {
+        for track in playlist.tracks {
+          if trackIdSet.contains(track.id) && foundTracks[track.id] == nil {
+            foundTracks[track.id] = track
+          }
+        }
+      }
+    }
+
+    // Return in same order as requested
+    return trackIds.compactMap { foundTracks[$0] }
+  }
+
   /**
    * Get the current playlist ID
    */

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -44,4 +44,51 @@ export interface TrackPlayer extends HybridObject<{
     onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
     isAndroidAutoConnected(): boolean;
     setVolume(volume: number): boolean;
+    /**
+     * Update entire track objects across all playlists
+     * Matches by track.id and updates all properties (url, artwork, title, etc.)
+     * Note: Empty string "" is valid for TrackItem.url to support lazy loading
+     * @param tracks Array of full TrackItem objects to update
+     * @returns Promise that resolves when updates complete
+     */
+    updateTracks(tracks: TrackItem[]): Promise<void>;
+    /**
+     * Get tracks by IDs from all playlists
+     * @param trackIds Array of track IDs to fetch
+     * @returns Promise resolving to array of matching tracks
+     */
+    getTracksById(trackIds: string[]): Promise<TrackItem[]>;
+    /**
+     * Get tracks with missing/empty URLs from current playlist
+     * @returns Promise resolving to array of tracks needing URLs
+     */
+    getTracksNeedingUrls(): Promise<TrackItem[]>;
+    /**
+     * Get next N tracks from current position in playlist
+     * Useful for preloading URLs before they're needed
+     * @param count Number of upcoming tracks to return
+     * @returns Promise resolving to array of next tracks
+     */
+    getNextTracks(count: number): Promise<TrackItem[]>;
+    /**
+     * Get current track index in the active playlist
+     * @returns Promise resolving to 0-based index, or -1 if no track playing
+     */
+    getCurrentTrackIndex(): Promise<number>;
+    /**
+     * Register callback that fires when tracks will be needed soon
+     * Useful for proactive URL resolution in Android Auto/CarPlay
+     * @param callback Function called with tracks needing URLs and lookahead count
+     */
+    onTracksNeedUpdate(callback: (tracks: TrackItem[], lookahead: number) => void): void;
+    /**
+     * Get the current track index in the active playlist
+     * @returns Promise resolving to 0-based index, or -1 if no track playing
+     */
+    setPlaybackSpeed(speed: number): Promise<void>;
+    /**
+     * Get the current playback speed
+     * @returns Promise resolving to playback speed
+     */
+    getPlaybackSpeed(): Promise<number>;
 }

package/lib/types/PlayerQueue.d.ts

@@ -33,4 +33,9 @@ export interface PlayerConfig {
     androidAutoEnabled?: boolean;
     carPlayEnabled?: boolean;
     showInNotification?: boolean;
+    /**
+     * Number of upcoming tracks to preload URLs for (default: 5)
+     * Higher values = more proactive loading, but more network requests
+     */
+    lookaheadCount?: number;
 }

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -33,6 +33,7 @@
 #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_std__vector_TrackItem__double.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::nitroplayer {
@@ -62,6 +63,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::nitroplayer::JFunc_void_TrackPlayerState_std__optional_Reason__cxx::registerNatives();
     margelo::nitro::nitroplayer::JFunc_void_double_double_cxx::registerNatives();
     margelo::nitro::nitroplayer::JFunc_void_double_double_std__optional_bool__cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__double_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -0,0 +1,104 @@
+///
+/// JFunc_void_std__vector_TrackItem__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 "TrackItem.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#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>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(tracks: Array<TrackItem>, lookahead: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_TrackItem__double: public jni::JavaClass<JFunc_void_std__vector_TrackItem__double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_TrackItem__double` instance holds through JNI.
+     */
+    void invoke(const std::vector<TrackItem>& tracks, double lookahead) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */, double /* lookahead */)>("invoke");
+      method(self(), [&]() {
+        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;
+      }(), lookahead);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_TrackItem__double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_TrackItem__double_cxx final: public jni::HybridClass<JFunc_void_std__vector_TrackItem__double_cxx, JFunc_void_std__vector_TrackItem__double> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_TrackItem__double::javaobject> fromCpp(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& func) {
+      return JFunc_void_std__vector_TrackItem__double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_TrackItem__double_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JTrackItem>> tracks, double lookahead) {
+      _func([&]() {
+              size_t __size = tracks->size();
+              std::vector<TrackItem> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = tracks->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }(), lookahead);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_TrackItem__double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_TrackItem__double_cxx(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -55,6 +55,7 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
 #include "JFunc_void_bool.hpp"
+#include "JFunc_void_std__vector_TrackItem__double.hpp"
 
 namespace margelo::nitro::nitroplayer {
 
@@ -254,5 +255,164 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart, volume);
     return static_cast<bool>(__result);
   }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::updateTracks(const std::vector<TrackItem>& tracks) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */)>("updateTracks");
+    auto __result = method(_javaPart, [&]() {
+      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;
+    }());
+    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::getTracksById(const std::vector<std::string>& trackIds) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* trackIds */)>("getTracksById");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = trackIds.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 = trackIds[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+    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<std::vector<TrackItem>>> JHybridTrackPlayerSpec::getTracksNeedingUrls() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getTracksNeedingUrls");
+    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<std::vector<TrackItem>>> JHybridTrackPlayerSpec::getNextTracks(double count) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* count */)>("getNextTracks");
+    auto __result = method(_javaPart, count);
+    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<double>> JHybridTrackPlayerSpec::getCurrentTrackIndex() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCurrentTrackIndex");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__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::onTracksNeedUpdate(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_TrackItem__double::javaobject> /* callback */)>("onTracksNeedUpdate_cxx");
+    method(_javaPart, JFunc_void_std__vector_TrackItem__double_cxx::fromCpp(callback));
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setPlaybackSpeed(double speed) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* speed */)>("setPlaybackSpeed");
+    auto __result = method(_javaPart, speed);
+    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<double>> JHybridTrackPlayerSpec::getPlaybackSpeed() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getPlaybackSpeed");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__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;
+    }();
+  }
 
 } // namespace margelo::nitro::nitroplayer

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

@@ -75,6 +75,14 @@ namespace margelo::nitro::nitroplayer {
     void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
     bool isAndroidAutoConnected() override;
     bool setVolume(double volume) override;
+    std::shared_ptr<Promise<void>> updateTracks(const std::vector<TrackItem>& tracks) override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksById(const std::vector<std::string>& trackIds) override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksNeedingUrls() override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getNextTracks(double count) override;
+    std::shared_ptr<Promise<double>> getCurrentTrackIndex() override;
+    void onTracksNeedUpdate(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& callback) override;
+    std::shared_ptr<Promise<void>> setPlaybackSpeed(double speed) override;
+    std::shared_ptr<Promise<double>> getPlaybackSpeed() override;
 
   private:
     friend HybridBase;

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

@@ -37,10 +37,13 @@ namespace margelo::nitro::nitroplayer {
       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);
+      static const auto fieldLookaheadCount = clazz->getField<jni::JDouble>("lookaheadCount");
+      jni::local_ref<jni::JDouble> lookaheadCount = this->getFieldValue(fieldLookaheadCount);
       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
+        showInNotification != nullptr ? std::make_optional(static_cast<bool>(showInNotification->value())) : std::nullopt,
+        lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt
       );
     }
 
@@ -50,14 +53,15 @@ namespace margelo::nitro::nitroplayer {
      */
     [[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>);
+      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>);
       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
+        value.showInNotification.has_value() ? jni::JBoolean::valueOf(value.showInNotification.value()) : nullptr,
+        value.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__double.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_std__vector_TrackItem__double.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(tracks: array, lookahead: number) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__vector_TrackItem__double: (Array<TrackItem>, Double) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(tracks: Array<TrackItem>, lookahead: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(tracks: array, lookahead: number) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__vector_TrackItem__double_cxx: Func_void_std__vector_TrackItem__double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(tracks: Array<TrackItem>, lookahead: Double): Unit
+    = invoke_cxx(tracks,lookahead)
+
+  @FastNative
+  private external fun invoke_cxx(tracks: Array<TrackItem>, lookahead: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(tracks: array, lookahead: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Array<TrackItem>, Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__vector_TrackItem__double_java(private val function: (Array<TrackItem>, Double) -> Unit): Func_void_std__vector_TrackItem__double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(tracks: Array<TrackItem>, lookahead: Double): Unit {
+    return this.function(tracks, lookahead)
+  }
+}