react-native-nitro-player 0.5.5 → 0.5.7

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

@@ -154,6 +154,43 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun setVolume(volume: Double): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun updateTracks(tracks: Array<TrackItem>): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getTracksById(trackIds: Array<String>): Promise<Array<TrackItem>>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getTracksNeedingUrls(): Promise<Array<TrackItem>>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getNextTracks(count: Double): Promise<Array<TrackItem>>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCurrentTrackIndex(): Promise<Double>
+  
+  abstract fun onTracksNeedUpdate(callback: (tracks: Array<TrackItem>, lookahead: Double) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun onTracksNeedUpdate_cxx(callback: Func_void_std__vector_TrackItem__double): Unit {
+    val __result = onTracksNeedUpdate(callback)
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setPlaybackSpeed(speed: Double): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getPlaybackSpeed(): Promise<Double>
 
   private external fun initHybrid(): HybridData
 

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

@@ -25,7 +25,10 @@ data class PlayerConfig(
   val carPlayEnabled: Boolean?,
   @DoNotStrip
   @Keep
-  val showInNotification: Boolean?
+  val showInNotification: Boolean?,
+  @DoNotStrip
+  @Keep
+  val lookaheadCount: Double?
 ) {
   /* primary constructor */
 
@@ -37,8 +40,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?): PlayerConfig {
-      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification)
+    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, lookaheadCount: Double?): PlayerConfig {
+      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, lookaheadCount)
     }
   }
 }

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.cpp

@@ -234,6 +234,22 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(double /* result */)>
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroPlayer::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
+  Func_void_std__vector_TrackItem__double create_Func_void_std__vector_TrackItem__double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroPlayer::Func_void_std__vector_TrackItem__double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<TrackItem>& tracks, double lookahead) mutable -> void {
+      swiftClosure.call(tracks, lookahead);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridTrackPlayerSpec>
   std::shared_ptr<HybridTrackPlayerSpec> create_std__shared_ptr_HybridTrackPlayerSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroPlayer::HybridTrackPlayerSpec_cxx swiftPart = NitroPlayer::HybridTrackPlayerSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.hpp

@@ -1417,6 +1417,62 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_double_double_std__optional_bool__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<double>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<double>>`.
+   */
+  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
+  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() noexcept {
+    return Promise<double>::create();
+  }
+  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) noexcept {
+    return PromiseHolder<double>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
+    inline void call(double result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<TrackItem>&, double)>`.
+   */
+  using Func_void_std__vector_TrackItem__double = std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * tracks * /, double / * lookahead * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_TrackItem__double_Wrapper final {
+  public:
+    explicit Func_void_std__vector_TrackItem__double_Wrapper(std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>>(std::move(func))) {}
+    inline void call(std::vector<TrackItem> tracks, double lookahead) const noexcept {
+      _function->operator()(tracks, lookahead);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_TrackItem__double create_Func_void_std__vector_TrackItem__double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_TrackItem__double_Wrapper wrap_Func_void_std__vector_TrackItem__double(Func_void_std__vector_TrackItem__double value) noexcept {
+    return Func_void_std__vector_TrackItem__double_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridTrackPlayerSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridTrackPlayerSpec>`.
@@ -1464,5 +1520,14 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
   inline Result_RepeatMode_ create_Result_RepeatMode_(const std::exception_ptr& error) noexcept {
     return Result<RepeatMode>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
+  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::nitroplayer::bridge::swift

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -233,6 +233,68 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> updateTracks(const std::vector<TrackItem>& tracks) override {
+      auto __result = _swiftPart.updateTracks(tracks);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksById(const std::vector<std::string>& trackIds) override {
+      auto __result = _swiftPart.getTracksById(trackIds);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksNeedingUrls() override {
+      auto __result = _swiftPart.getTracksNeedingUrls();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getNextTracks(double count) override {
+      auto __result = _swiftPart.getNextTracks(std::forward<decltype(count)>(count));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> getCurrentTrackIndex() override {
+      auto __result = _swiftPart.getCurrentTrackIndex();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void onTracksNeedUpdate(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& callback) override {
+      auto __result = _swiftPart.onTracksNeedUpdate(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> setPlaybackSpeed(double speed) override {
+      auto __result = _swiftPart.setPlaybackSpeed(std::forward<decltype(speed)>(speed));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> getPlaybackSpeed() override {
+      auto __result = _swiftPart.getPlaybackSpeed();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroPlayer::HybridTrackPlayerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_double {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ value: Double) -> Void
+
+  public init(_ closure: @escaping (_ value: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Double) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double {
+    return Unmanaged<Func_void_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__vector_TrackItem__double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__vector_TrackItem__double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ tracks: [TrackItem], _ lookahead: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__vector_TrackItem__double {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ tracks: [TrackItem], _ lookahead: Double) -> Void
+
+  public init(_ closure: @escaping (_ tracks: [TrackItem], _ lookahead: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(tracks: bridge.std__vector_TrackItem_, lookahead: Double) -> Void {
+    self.closure(tracks.map({ __item in __item }), lookahead)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__vector_TrackItem__double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__vector_TrackItem__double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__vector_TrackItem__double {
+    return Unmanaged<Func_void_std__vector_TrackItem__double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -35,6 +35,14 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
   func setVolume(volume: Double) throws -> Bool
+  func updateTracks(tracks: [TrackItem]) throws -> Promise<Void>
+  func getTracksById(trackIds: [String]) throws -> Promise<[TrackItem]>
+  func getTracksNeedingUrls() throws -> Promise<[TrackItem]>
+  func getNextTracks(count: Double) throws -> Promise<[TrackItem]>
+  func getCurrentTrackIndex() throws -> Promise<Double>
+  func onTracksNeedUpdate(callback: @escaping (_ tracks: [TrackItem], _ lookahead: Double) -> Void) throws -> Void
+  func setPlaybackSpeed(speed: Double) throws -> Promise<Void>
+  func getPlaybackSpeed() throws -> Promise<Double>
 }
 
 public extension HybridTrackPlayerSpec_protocol {

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.5",
+  "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",