react-native-nitro-player 1.6.0-alpha.1 → 1.7.0-alpha.0

package/ios/equalizer/EqualizerCore.swift

@@ -28,6 +28,27 @@ class EqualizerCore {
 
   // Current gains storage - internal so TapContext can access
   private(set) var currentGains: [Double] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  // Guards currentGains/gainsDirty between the JS thread (slider writes) and the
+  // MTAudioProcessingTap render thread — unsynchronized Swift Array access is a
+  // CoW data race (torn coefficients, loud glitches, rare crashes)
+  private var gainsLock = os_unfair_lock_s()
+
+  func withGainsLock<T>(_ body: () -> T) -> T {
+    os_unfair_lock_lock(&gainsLock)
+    defer { os_unfair_lock_unlock(&gainsLock) }
+    return body()
+  }
+
+  /// Render-thread accessor: returns a snapshot of the gains and clears the dirty
+  /// flag atomically, or nil when nothing changed.
+  func consumeDirtyGains() -> [Double]? {
+    return withGainsLock {
+      guard gainsDirty else { return nil }
+      gainsDirty = false
+      return currentGains
+    }
+  }
   private var cachedBands: [EqualizerBand]?
   private var cachedCustomPresets: [EqualizerPreset]?
 
@@ -209,9 +230,11 @@ class EqualizerCore {
     guard bandIndex >= 0 && bandIndex < 10 else { return false }
 
     let clampedGain = max(-12.0, min(12.0, gainDb))
-    currentGains[bandIndex] = clampedGain
+    withGainsLock {
+      currentGains[bandIndex] = clampedGain
+      gainsDirty = true
+    }
     cachedBands = nil
-    gainsDirty = true
 
     currentPresetName = nil
     notifyBandChange(getBands())
@@ -226,11 +249,13 @@ class EqualizerCore {
   func setAllBandGains(_ gains: [Double]) -> Bool {
     guard gains.count == 10 else { return false }
 
-    for i in 0..<10 {
-      currentGains[i] = max(-12.0, min(12.0, gains[i]))
+    withGainsLock {
+      for i in 0..<10 {
+        currentGains[i] = max(-12.0, min(12.0, gains[i]))
+      }
+      gainsDirty = true
     }
     cachedBands = nil
-    gainsDirty = true
 
     notifyBandChange(getBands())
     saveBandGains(currentGains)
@@ -406,7 +431,10 @@ class EqualizerCore {
       let gains = try? JSONDecoder().decode([Double].self, from: data),
       gains.count == 10
     {
-      currentGains = gains
+      withGainsLock {
+        currentGains = gains
+        gainsDirty = true
+      }
     }
     // else: migration from 5-band or fresh install — start at flat (currentGains already zeroed)
 
@@ -478,9 +506,10 @@ private class TapContext {
   }
 
   func updateCoefficients() {
-    guard let eqCore = eqCore else { return }
+    // Snapshot + dirty-clear happen atomically under the gains lock; nil means
+    // another consumer already took this change
+    guard let gains = eqCore?.consumeDirtyGains() else { return }
     let frequencies: [Float] = [31, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
-    let gains = eqCore.currentGains
 
     for i in 0..<10 {
       filterCoeffs[i] = calculatePeakingEQCoefficients(
@@ -490,7 +519,6 @@ private class TapContext {
         sampleRate: Double(sampleRate)
       )
     }
-    eqCore.gainsDirty = false
   }
 
   /// Calculate biquad coefficients for a peaking EQ filter

package/ios/media/MediaSessionManager.swift

@@ -16,6 +16,8 @@ class MediaSessionManager {
 
   private enum Constants {
     static let artworkSize: CGFloat = 500.0
+    static let defaultRemoteSkipInterval: Double = 15.0
+    static let supportedPlaybackRates: [Float] = [0.5, 1.0, 1.25, 1.5, 1.75, 2.0]
   }
 
   // MARK: - Properties
@@ -24,6 +26,8 @@ class MediaSessionManager {
   private let artworkCache = NSCache<NSString, UIImage>()
 
   private var showInNotification: Bool = true
+  private var remoteSkipForwardInterval: Double = Constants.defaultRemoteSkipInterval
+  private var remoteSkipBackwardInterval: Double = Constants.defaultRemoteSkipInterval
 
   // Tracks the artwork URL currently shown so we can discard stale async loads
   private var lastArtworkUrl: String?
@@ -36,6 +40,7 @@ class MediaSessionManager {
   // per event; these two Ints are computed on playerQueue instead.
   private var cachedQueueCount: Int = 0
   private var cachedPositionInQueue: Int = -1
+  private var cachedPlaybackSpeed: Double = 1.0
 
   init() {
     setupRemoteCommandCenter()
@@ -48,11 +53,24 @@ class MediaSessionManager {
   func configure(
     androidAutoEnabled: Bool?,
     carPlayEnabled: Bool?,
-    showInNotification: Bool?
+    showInNotification: Bool?,
+    remoteSkipForwardInterval: Double?,
+    remoteSkipBackwardInterval: Double?,
+    playbackSpeed: Double?
   ) {
     if let showInNotification = showInNotification {
       self.showInNotification = showInNotification
     }
+    if let playbackSpeed = sanitizedPositive(playbackSpeed) {
+      cachedPlaybackSpeed = playbackSpeed
+    }
+    if let interval = sanitizedPositive(remoteSkipForwardInterval) {
+      self.remoteSkipForwardInterval = interval
+    }
+    if let interval = sanitizedPositive(remoteSkipBackwardInterval) {
+      self.remoteSkipBackwardInterval = interval
+    }
+    updateSkipCommandIntervals()
     refresh()
   }
 
@@ -61,12 +79,14 @@ class MediaSessionManager {
   // Receives pre-computed values captured on playerQueue — no player access here.
 
   func updateFromPlayerQueue(
-    track: TrackItem, state: PlayerState, queueCount: Int, positionInQueue: Int
+    track: TrackItem, state: PlayerState, queueCount: Int, positionInQueue: Int,
+    playbackSpeed: Double
   ) {
     cachedTrack = track
     cachedState = state
     cachedQueueCount = queueCount
     cachedPositionInQueue = positionInQueue
+    cachedPlaybackSpeed = sanitizedPositive(playbackSpeed) ?? 1.0
     refreshInternal()
   }
 
@@ -123,6 +143,7 @@ class MediaSessionManager {
     let currentPosition = state.currentPosition
     let safePosition = currentPosition.isNaN || currentPosition.isInfinite ? 0 : currentPosition
     let isPlaying = state.currentState == .playing
+    let playbackSpeed = sanitizedPositive(cachedPlaybackSpeed) ?? 1.0
 
     var nowPlayingInfo: [String: Any] = [
       MPMediaItemPropertyTitle: track.title,
@@ -130,8 +151,8 @@ class MediaSessionManager {
       MPMediaItemPropertyAlbumTitle: track.album,
       MPNowPlayingInfoPropertyElapsedPlaybackTime: safePosition,
       MPMediaItemPropertyPlaybackDuration: effectiveDuration,
-      MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? 1.0 : 0.0,
-      MPNowPlayingInfoPropertyDefaultPlaybackRate: 1.0,
+      MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? playbackSpeed : 0.0,
+      MPNowPlayingInfoPropertyDefaultPlaybackRate: playbackSpeed,
       MPNowPlayingInfoPropertyPlaybackQueueCount: max(1, queueCount),
       MPNowPlayingInfoPropertyPlaybackQueueIndex: max(0, positionInQueue),
     ]
@@ -176,10 +197,17 @@ class MediaSessionManager {
     commandCenter.togglePlayPauseCommand.removeTarget(nil)
     commandCenter.nextTrackCommand.removeTarget(nil)
     commandCenter.previousTrackCommand.removeTarget(nil)
+    commandCenter.skipForwardCommand.removeTarget(nil)
+    commandCenter.skipBackwardCommand.removeTarget(nil)
     commandCenter.seekForwardCommand.removeTarget(nil)
     commandCenter.seekBackwardCommand.removeTarget(nil)
+    commandCenter.changePlaybackRateCommand.removeTarget(nil)
     commandCenter.changePlaybackPositionCommand.removeTarget(nil)
 
+    updateSkipCommandIntervals()
+    commandCenter.changePlaybackRateCommand.supportedPlaybackRates =
+      Constants.supportedPlaybackRates.map { NSNumber(value: $0) }
+
     // Play
     commandCenter.playCommand.isEnabled = true
     commandCenter.playCommand.addTarget { [weak self] _ in
@@ -221,9 +249,45 @@ class MediaSessionManager {
       return .success
     }
 
+    commandCenter.skipForwardCommand.isEnabled = false
+    commandCenter.skipForwardCommand.addTarget { [weak self] event in
+      guard let self = self, let core = self.trackPlayerCore else { return .commandFailed }
+      let interval = (event as? MPSkipIntervalCommandEvent)?.interval ?? self.remoteSkipForwardInterval
+      Task { await core.seekBy(offset: interval) }
+      return .success
+    }
+
+    commandCenter.skipBackwardCommand.isEnabled = false
+    commandCenter.skipBackwardCommand.addTarget { [weak self] event in
+      guard let self = self, let core = self.trackPlayerCore else { return .commandFailed }
+      let interval = (event as? MPSkipIntervalCommandEvent)?.interval ?? self.remoteSkipBackwardInterval
+      Task { await core.seekBy(offset: -interval) }
+      return .success
+    }
+
     commandCenter.seekForwardCommand.isEnabled = false
     commandCenter.seekBackwardCommand.isEnabled = false
 
+    commandCenter.changePlaybackRateCommand.isEnabled = false
+    commandCenter.changePlaybackRateCommand.addTarget { [weak self] event in
+      guard let core = self?.trackPlayerCore,
+        let rateEvent = event as? MPChangePlaybackRateCommandEvent
+      else {
+        return .commandFailed
+      }
+      let rate = Double(rateEvent.playbackRate)
+      guard rate.isFinite, rate > 0 else { return .commandFailed }
+      Task {
+        do {
+          try await core.setPlaybackSpeed(rate)
+        } catch {
+          NitroPlayerLogger.log(
+            "MediaSessionManager", "❌ Failed to set remote playback rate: \(error)")
+        }
+      }
+      return .success
+    }
+
     // Scrubber
     commandCenter.changePlaybackPositionCommand.isEnabled = false
     commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
@@ -257,6 +321,9 @@ class MediaSessionManager {
 
     commandCenter.nextTrackCommand.isEnabled = hasCurrentTrack && isNotLast
     commandCenter.previousTrackCommand.isEnabled = hasCurrentTrack
+    commandCenter.skipForwardCommand.isEnabled = hasCurrentTrack
+    commandCenter.skipBackwardCommand.isEnabled = hasCurrentTrack
+    commandCenter.changePlaybackRateCommand.isEnabled = hasCurrentTrack
     commandCenter.changePlaybackPositionCommand.isEnabled = hasCurrentTrack && hasDuration
   }
 
@@ -264,11 +331,29 @@ class MediaSessionManager {
     let commandCenter = MPRemoteCommandCenter.shared()
     commandCenter.nextTrackCommand.isEnabled = false
     commandCenter.previousTrackCommand.isEnabled = false
+    commandCenter.skipForwardCommand.isEnabled = false
+    commandCenter.skipBackwardCommand.isEnabled = false
+    commandCenter.changePlaybackRateCommand.isEnabled = false
     commandCenter.changePlaybackPositionCommand.isEnabled = false
   }
 
   // MARK: - Helpers
 
+  private func sanitizedPositive(_ value: Double?) -> Double? {
+    guard let value = value, value.isFinite, value > 0 else { return nil }
+    return value
+  }
+
+  private func updateSkipCommandIntervals() {
+    let commandCenter = MPRemoteCommandCenter.shared()
+    commandCenter.skipForwardCommand.preferredIntervals = [
+      NSNumber(value: remoteSkipForwardInterval)
+    ]
+    commandCenter.skipBackwardCommand.preferredIntervals = [
+      NSNumber(value: remoteSkipBackwardInterval)
+    ]
+  }
+
   private func clearNowPlayingInfo() {
     MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
     lastArtworkUrl = nil

package/ios/playlist/PlaylistManager.swift

@@ -14,7 +14,13 @@ class PlaylistManager {
   private var listeners: [(String, ([PlaylistModel], QueueOperation?) -> Void)] = []
   private var playlistListeners: [String: [(String, (PlaylistModel, QueueOperation?) -> Void)]] =
     [:]
-  private var currentPlaylistId: String?
+  // Backing store must only be touched inside `queue`; every current use of the
+  // computed property is outside a queue.sync block, so the accessors can sync.
+  private var _currentPlaylistId: String?
+  private var currentPlaylistId: String? {
+    get { queue.sync { _currentPlaylistId } }
+    set { queue.sync { _currentPlaylistId = newValue } }
+  }
   private let queue = DispatchQueue(label: "com.margelo.nitro.nitroplayer.playlist")
   private var saveDebounceWorkItem: DispatchWorkItem?
 
@@ -45,15 +51,16 @@ class PlaylistManager {
    * Delete a playlist
    */
   func deletePlaylist(playlistId: String) -> Bool {
-    let removed = queue.sync {
-      return playlists.removeValue(forKey: playlistId) != nil
+    let removed = queue.sync { () -> Bool in
+      guard playlists.removeValue(forKey: playlistId) != nil else { return false }
+      if _currentPlaylistId == playlistId {
+        _currentPlaylistId = nil
+      }
+      playlistListeners.removeValue(forKey: playlistId)
+      return true
     }
 
     if removed {
-      if currentPlaylistId == playlistId {
-        currentPlaylistId = nil
-      }
-      playlistListeners.removeValue(forKey: playlistId)
       scheduleSave()
       notifyPlaylistsChanged(.remove)
       return true
@@ -68,11 +75,9 @@ class PlaylistManager {
   func updatePlaylist(
     playlistId: String, name: String? = nil, description: String? = nil, artwork: String? = nil
   ) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return false
-    }
-
-    queue.sync {
+    // Single sync: a separate fetch-then-store loses one of two concurrent edits
+    let updated = queue.sync { () -> Bool in
+      guard let playlist = playlists[playlistId] else { return false }
       playlists[playlistId] = PlaylistModel(
         id: playlist.id,
         name: name ?? playlist.name,
@@ -80,7 +85,9 @@ class PlaylistManager {
         artwork: artwork ?? playlist.artwork,
         tracks: playlist.tracks
       )
+      return true
     }
+    guard updated else { return false }
 
     scheduleSave()
     notifyPlaylistChanged(playlistId, .update)
@@ -111,11 +118,8 @@ class PlaylistManager {
    * Add a track to a playlist
    */
   func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Int? = nil) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return false
-    }
-
-    queue.sync {
+    let added = queue.sync { () -> Bool in
+      guard let playlist = playlists[playlistId] else { return false }
       var tracks = playlist.tracks
       if let index = index, index >= 0 && index <= tracks.count {
         tracks.insert(track, at: index)
@@ -129,7 +133,9 @@ class PlaylistManager {
         artwork: playlist.artwork,
         tracks: tracks
       )
+      return true
     }
+    guard added else { return false }
 
     scheduleSave()
     notifyPlaylistChanged(playlistId, .add)
@@ -146,11 +152,8 @@ class PlaylistManager {
    * Add multiple tracks to a playlist at once
    */
   func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Int? = nil) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return false
-    }
-
-    queue.sync {
+    let added = queue.sync { () -> Bool in
+      guard let playlist = playlists[playlistId] else { return false }
       var currentTracks = playlist.tracks
       if let index = index, index >= 0 && index <= currentTracks.count {
         currentTracks.insert(contentsOf: tracks, at: index)
@@ -164,7 +167,9 @@ class PlaylistManager {
         artwork: playlist.artwork,
         tracks: currentTracks
       )
+      return true
     }
+    guard added else { return false }
 
     scheduleSave()
     notifyPlaylistChanged(playlistId, .add)
@@ -182,11 +187,8 @@ class PlaylistManager {
    * Remove a track from a playlist
    */
   func removeTrackFromPlaylist(playlistId: String, trackId: String) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return false
-    }
-
-    let removed = queue.sync {
+    let removed = queue.sync { () -> Bool in
+      guard let playlist = playlists[playlistId] else { return false }
       var tracks = playlist.tracks
       let initialCount = tracks.count
       tracks.removeAll { $0.id == trackId }
@@ -222,30 +224,27 @@ class PlaylistManager {
    * Reorder a track in a playlist
    */
   func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Int) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return false
-    }
-
-    let tracks = playlist.tracks
-    guard let oldIndex = tracks.firstIndex(where: { $0.id == trackId }),
-      newIndex >= 0 && newIndex < tracks.count
-    else {
-      return false
-    }
-
-    queue.sync {
-      var reorderedTracks = tracks
-      let track = reorderedTracks.remove(at: oldIndex)
-      reorderedTracks.insert(track, at: newIndex)
+    let reordered = queue.sync { () -> Bool in
+      guard let playlist = playlists[playlistId] else { return false }
+      var tracks = playlist.tracks
+      guard let oldIndex = tracks.firstIndex(where: { $0.id == trackId }),
+        newIndex >= 0 && newIndex < tracks.count
+      else {
+        return false
+      }
+      let track = tracks.remove(at: oldIndex)
+      tracks.insert(track, at: newIndex)
 
       playlists[playlistId] = PlaylistModel(
         id: playlist.id,
         name: playlist.name,
         description: playlist.description,
         artwork: playlist.artwork,
-        tracks: reorderedTracks
+        tracks: tracks
       )
+      return true
     }
+    guard reordered else { return false }
 
     scheduleSave()
     notifyPlaylistChanged(playlistId, .update)
@@ -417,9 +416,11 @@ class PlaylistManager {
   }
 
   private func scheduleSave() {
-    saveDebounceWorkItem?.cancel()
     let work = DispatchWorkItem { [weak self] in self?.saveToFile() }
-    saveDebounceWorkItem = work
+    queue.sync {
+      saveDebounceWorkItem?.cancel()
+      saveDebounceWorkItem = work
+    }
     // Use global background queue — saveToFile calls queue.sync internally,
     // which would deadlock if scheduled on queue itself.
     DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 0.3, execute: work)
@@ -459,7 +460,7 @@ class PlaylistManager {
       }
       let wrapper: [String: Any] = [
         "playlists": playlistsData,
-        "currentPlaylistId": currentPlaylistId as Any,
+        "currentPlaylistId": queue.sync { _currentPlaylistId } as Any,
       ]
       let data = try JSONSerialization.data(withJSONObject: wrapper, options: [])
       try NitroPlayerStorage.write(filename: "playlists.json", data: data)

package/ios/queue/HybridPlayerQueue.swift

@@ -22,13 +22,20 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
   }
 
   func deletePlaylist(playlistId: String) throws -> Promise<Void> {
-    Promise.async { _ = self.playlistManager.deletePlaylist(playlistId: playlistId) }
+    Promise.async {
+      guard self.playlistManager.deletePlaylist(playlistId: playlistId) else {
+        throw RuntimeError.error(withMessage: "Playlist not found: \(playlistId)")
+      }
+    }
   }
 
   func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?) throws -> Promise<Void> {
     Promise.async {
-      _ = self.playlistManager.updatePlaylist(
+      guard self.playlistManager.updatePlaylist(
         playlistId: playlistId, name: name, description: description, artwork: artwork)
+      else {
+        throw RuntimeError.error(withMessage: "Playlist not found: \(playlistId)")
+      }
       self.core.updatePlaylist(playlistId: playlistId)
     }
   }
@@ -48,29 +55,41 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
 
   func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws -> Promise<Void> {
     Promise.async {
-      _ = self.playlistManager.addTrackToPlaylist(playlistId: playlistId, track: track, index: index.map { Int($0) })
+      guard self.playlistManager.addTrackToPlaylist(playlistId: playlistId, track: track, index: index.map { Int($0) })
+      else {
+        throw RuntimeError.error(withMessage: "Playlist not found: \(playlistId)")
+      }
       self.core.updatePlaylist(playlistId: playlistId)
     }
   }
 
   func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Promise<Void> {
     Promise.async {
-      _ = self.playlistManager.addTracksToPlaylist(playlistId: playlistId, tracks: tracks, index: index.map { Int($0) })
+      guard self.playlistManager.addTracksToPlaylist(playlistId: playlistId, tracks: tracks, index: index.map { Int($0) })
+      else {
+        throw RuntimeError.error(withMessage: "Playlist not found: \(playlistId)")
+      }
       self.core.updatePlaylist(playlistId: playlistId)
     }
   }
 
   func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void> {
     Promise.async {
-      _ = self.playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
+      guard self.playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
+      else {
+        throw RuntimeError.error(withMessage: "Track \(trackId) not found in playlist \(playlistId)")
+      }
       self.core.updatePlaylist(playlistId: playlistId)
     }
   }
 
   func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void> {
     Promise.async {
-      _ = self.playlistManager.reorderTrackInPlaylist(
+      guard self.playlistManager.reorderTrackInPlaylist(
         playlistId: playlistId, trackId: trackId, newIndex: Int(newIndex))
+      else {
+        throw RuntimeError.error(withMessage: "Invalid reorder for track \(trackId) in playlist \(playlistId)")
+      }
       self.core.updatePlaylist(playlistId: playlistId)
     }
   }
@@ -86,8 +105,10 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
       // Update PlaylistManager.currentPlaylistId so getCurrentPlaylistId() returns correctly
       if self.playlistManager.loadPlaylist(playlistId: playlistId, index: startIndex) {
         self.core.loadPlaylistOnQueue(playlistId: playlistId, startIndex: startIndex)
+        promise.resolve(withResult: ())
+      } else {
+        promise.reject(withError: RuntimeError.error(withMessage: "Invalid playlist or index: \(playlistId)"))
       }
-      promise.resolve(withResult: ())
     }
     return promise
   }

package/lib/hooks/callbackManager.d.ts

@@ -5,6 +5,7 @@ type PlaybackProgressCallback = (position: number, totalDuration: number, isManu
 type SeekCallback = (position: number, totalDuration: number) => void;
 type TimedMetadataCallback = (metadata: TimedMetadata) => void;
 type TemporaryQueueCallback = (playNextQueue: TrackItem[], upNextQueue: TrackItem[]) => void;
+type AndroidAutoConnectionCallback = (connected: boolean) => void;
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
  * to a single native callback. This solves the problem where registering
@@ -18,7 +19,9 @@ declare class CallbackSubscriptionManager {
     private timedMetadataSubscribers;
     private temporaryQueueSubscribers;
     private playlistsChangedSubscribers;
+    private androidAutoConnectionSubscribers;
     private isPlaylistsChangedRegistered;
+    private isAndroidAutoConnectionRegistered;
     private isPlaybackStateRegistered;
     private isTrackChangeRegistered;
     private isPlaybackProgressRegistered;
@@ -61,6 +64,12 @@ declare class CallbackSubscriptionManager {
     private ensurePlaylistsChangedRegistered;
     private ensureTemporaryQueueRegistered;
     private ensureSeekRegistered;
+    /**
+     * Subscribe to Android Auto connection changes
+     * @returns Unsubscribe function
+     */
+    subscribeToAndroidAutoConnection(callback: AndroidAutoConnectionCallback): () => void;
+    private ensureAndroidAutoConnectionRegistered;
     /**
      * Subscribe to in-stream (timed) metadata events
      * @returns Unsubscribe function

package/lib/hooks/callbackManager.js

@@ -12,7 +12,9 @@ class CallbackSubscriptionManager {
     timedMetadataSubscribers = new Set();
     temporaryQueueSubscribers = new Set();
     playlistsChangedSubscribers = new Set();
+    androidAutoConnectionSubscribers = new Set();
     isPlaylistsChangedRegistered = false;
+    isAndroidAutoConnectionRegistered = false;
     isPlaybackStateRegistered = false;
     isTrackChangeRegistered = false;
     isPlaybackProgressRegistered = false;
@@ -205,6 +207,37 @@ class CallbackSubscriptionManager {
             console.error('[CallbackManager] Failed to register seek callback:', error);
         }
     }
+    /**
+     * Subscribe to Android Auto connection changes
+     * @returns Unsubscribe function
+     */
+    subscribeToAndroidAutoConnection(callback) {
+        this.androidAutoConnectionSubscribers.add(callback);
+        this.ensureAndroidAutoConnectionRegistered();
+        return () => {
+            this.androidAutoConnectionSubscribers.delete(callback);
+        };
+    }
+    ensureAndroidAutoConnectionRegistered() {
+        if (this.isAndroidAutoConnectionRegistered)
+            return;
+        try {
+            TrackPlayer.onAndroidAutoConnectionChange((connected) => {
+                this.androidAutoConnectionSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(connected);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in Android Auto connection subscriber:', error);
+                    }
+                });
+            });
+            this.isAndroidAutoConnectionRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register Android Auto connection callback:', error);
+        }
+    }
     /**
      * Subscribe to in-stream (timed) metadata events
      * @returns Unsubscribe function

package/lib/hooks/useActualQueue.js

@@ -61,6 +61,18 @@ export function useActualQueue() {
             }
         }
     }, []);
+    // Skips involving temp tracks fire track-change and temporary-queue-change
+    // together; the gate collapses the burst into one getActualQueue() fetch
+    const fetchScheduled = useRef(false);
+    const scheduleUpdate = useCallback(() => {
+        if (fetchScheduled.current)
+            return;
+        fetchScheduled.current = true;
+        queueMicrotask(() => {
+            fetchScheduled.current = false;
+            updateQueue();
+        });
+    }, [updateQueue]);
     const refreshQueue = useCallback(() => {
         if (!isMounted.current)
             return;
@@ -83,22 +95,22 @@ export function useActualQueue() {
     // track changes and temporary-queue edits do.
     useEffect(() => {
         return callbackManager.subscribeToTrackChange(() => {
-            updateQueue();
+            scheduleUpdate();
         });
-    }, [updateQueue]);
+    }, [scheduleUpdate]);
     // Update queue when playNext / upNext change (native pushes the new lists).
     useEffect(() => {
         return callbackManager.subscribeToTemporaryQueueChange(() => {
-            updateQueue();
+            scheduleUpdate();
         });
-    }, [updateQueue]);
+    }, [scheduleUpdate]);
     // Update queue when the playlist itself is edited (track added / removed / reordered).
     // Without this, a playlist mutation while paused would leave the queue stale until the
     // next track change — playback-state changes used to paper over it.
     useEffect(() => {
         return callbackManager.subscribeToPlaylistsChanged(() => {
-            updateQueue();
+            scheduleUpdate();
         });
-    }, [updateQueue]);
+    }, [scheduleUpdate]);
     return { queue, refreshQueue, isLoading };
 }