react-native-nitro-player 0.5.6 → 0.5.7

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -455,4 +455,177 @@ open class HybridTrackPlayerSpec_cxx {
       return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func updateTracks(tracks: bridge.std__vector_TrackItem_) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.updateTracks(tracks: tracks.map({ __item in __item }))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTracksById(trackIds: bridge.std__vector_std__string_) -> bridge.Result_std__shared_ptr_Promise_std__vector_TrackItem____ {
+    do {
+      let __result = try self.__implementation.getTracksById(trackIds: trackIds.map({ __item in String(__item) }))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_TrackItem___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_TrackItem___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_TrackItem___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_TrackItem_ in
+              var __vector = bridge.create_std__vector_TrackItem_(__result.count)
+              for __item in __result {
+                __vector.push_back(__item)
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTracksNeedingUrls() -> bridge.Result_std__shared_ptr_Promise_std__vector_TrackItem____ {
+    do {
+      let __result = try self.__implementation.getTracksNeedingUrls()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_TrackItem___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_TrackItem___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_TrackItem___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_TrackItem_ in
+              var __vector = bridge.create_std__vector_TrackItem_(__result.count)
+              for __item in __result {
+                __vector.push_back(__item)
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getNextTracks(count: Double) -> bridge.Result_std__shared_ptr_Promise_std__vector_TrackItem____ {
+    do {
+      let __result = try self.__implementation.getNextTracks(count: count)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_TrackItem___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_TrackItem___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_TrackItem___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_TrackItem_ in
+              var __vector = bridge.create_std__vector_TrackItem_(__result.count)
+              for __item in __result {
+                __vector.push_back(__item)
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCurrentTrackIndex() -> bridge.Result_std__shared_ptr_Promise_double___ {
+    do {
+      let __result = try self.__implementation.getCurrentTrackIndex()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_double__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_double__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func onTracksNeedUpdate(callback: bridge.Func_void_std__vector_TrackItem__double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onTracksNeedUpdate(callback: { () -> ([TrackItem], Double) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_TrackItem__double(callback)
+        return { (__tracks: [TrackItem], __lookahead: Double) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_TrackItem_ in
+            var __vector = bridge.create_std__vector_TrackItem_(__tracks.count)
+            for __item in __tracks {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }(), __lookahead)
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setPlaybackSpeed(speed: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.setPlaybackSpeed(speed: speed)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPlaybackSpeed() -> bridge.Result_std__shared_ptr_Promise_double___ {
+    do {
+      let __result = try self.__implementation.getPlaybackSpeed()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_double__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_double__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/PlayerConfig.swift

@@ -19,7 +19,7 @@ public extension PlayerConfig {
   /**
    * Create a new instance of `PlayerConfig`.
    */
-  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?) {
+  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, lookaheadCount: Double?) {
     self.init({ () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = androidAutoEnabled {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -38,6 +38,12 @@ public extension PlayerConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = lookaheadCount {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -112,4 +118,21 @@ public extension PlayerConfig {
       }()
     }
   }
+  
+  var lookaheadCount: Double? {
+    @inline(__always)
+    get {
+      return self.__lookaheadCount.value
+    }
+    @inline(__always)
+    set {
+      self.__lookaheadCount = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -35,6 +35,14 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("onAndroidAutoConnectionChange", &HybridTrackPlayerSpec::onAndroidAutoConnectionChange);
       prototype.registerHybridMethod("isAndroidAutoConnected", &HybridTrackPlayerSpec::isAndroidAutoConnected);
       prototype.registerHybridMethod("setVolume", &HybridTrackPlayerSpec::setVolume);
+      prototype.registerHybridMethod("updateTracks", &HybridTrackPlayerSpec::updateTracks);
+      prototype.registerHybridMethod("getTracksById", &HybridTrackPlayerSpec::getTracksById);
+      prototype.registerHybridMethod("getTracksNeedingUrls", &HybridTrackPlayerSpec::getTracksNeedingUrls);
+      prototype.registerHybridMethod("getNextTracks", &HybridTrackPlayerSpec::getNextTracks);
+      prototype.registerHybridMethod("getCurrentTrackIndex", &HybridTrackPlayerSpec::getCurrentTrackIndex);
+      prototype.registerHybridMethod("onTracksNeedUpdate", &HybridTrackPlayerSpec::onTracksNeedUpdate);
+      prototype.registerHybridMethod("setPlaybackSpeed", &HybridTrackPlayerSpec::setPlaybackSpeed);
+      prototype.registerHybridMethod("getPlaybackSpeed", &HybridTrackPlayerSpec::getPlaybackSpeed);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.hpp

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

package/nitrogen/generated/shared/c++/PlayerConfig.hpp

@@ -37,10 +37,11 @@ namespace margelo::nitro::nitroplayer {
     std::optional<bool> androidAutoEnabled     SWIFT_PRIVATE;
     std::optional<bool> carPlayEnabled     SWIFT_PRIVATE;
     std::optional<bool> showInNotification     SWIFT_PRIVATE;
+    std::optional<double> lookaheadCount     SWIFT_PRIVATE;
 
   public:
     PlayerConfig() = default;
-    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification) {}
+    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> lookaheadCount): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), lookaheadCount(lookaheadCount) {}
   };
 
 } // namespace margelo::nitro::nitroplayer
@@ -55,7 +56,8 @@ namespace margelo::nitro {
       return margelo::nitro::nitroplayer::PlayerConfig(
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "androidAutoEnabled")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "carPlayEnabled")),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "showInNotification"))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "showInNotification")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "lookaheadCount"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::PlayerConfig& arg) {
@@ -63,6 +65,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "androidAutoEnabled", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidAutoEnabled));
       obj.setProperty(runtime, "carPlayEnabled", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.carPlayEnabled));
       obj.setProperty(runtime, "showInNotification", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.showInNotification));
+      obj.setProperty(runtime, "lookaheadCount", JSIConverter<std::optional<double>>::toJSI(runtime, arg.lookaheadCount));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -76,6 +79,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "androidAutoEnabled"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "carPlayEnabled"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "showInNotification"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "lookaheadCount"))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",

package/src/specs/TrackPlayer.nitro.ts

@@ -87,4 +87,61 @@ export interface TrackPlayer
   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/src/types/PlayerQueue.ts

@@ -44,4 +44,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
 }