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

package/lib/hooks/useDownloadActions.js

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { DownloadManager } from '../index';
 /**
  * Hook for download actions (download, pause, resume, cancel, delete)
@@ -7,8 +7,30 @@ export function useDownloadActions() {
     const [isDownloading, setIsDownloading] = useState(false);
     const [isDeleting, setIsDeleting] = useState(false);
     const [error, setError] = useState(null);
-    const downloadTrack = useCallback(async (track, playlistId) => {
+    // Pending counts: overlapping calls otherwise clear the flag while a
+    // second request is still in flight
+    const downloadingCount = useRef(0);
+    const deletingCount = useRef(0);
+    const beginDownloading = useCallback(() => {
+        downloadingCount.current += 1;
         setIsDownloading(true);
+    }, []);
+    const endDownloading = useCallback(() => {
+        downloadingCount.current = Math.max(0, downloadingCount.current - 1);
+        if (downloadingCount.current === 0)
+            setIsDownloading(false);
+    }, []);
+    const beginDeleting = useCallback(() => {
+        deletingCount.current += 1;
+        setIsDeleting(true);
+    }, []);
+    const endDeleting = useCallback(() => {
+        deletingCount.current = Math.max(0, deletingCount.current - 1);
+        if (deletingCount.current === 0)
+            setIsDeleting(false);
+    }, []);
+    const downloadTrack = useCallback(async (track, playlistId) => {
+        beginDownloading();
         setError(null);
         try {
             const downloadId = await DownloadManager.downloadTrack(track, playlistId);
@@ -19,11 +41,11 @@ export function useDownloadActions() {
             throw e;
         }
         finally {
-            setIsDownloading(false);
+            endDownloading();
         }
-    }, []);
+    }, [beginDownloading, endDownloading]);
     const downloadPlaylist = useCallback(async (playlistId, tracks) => {
-        setIsDownloading(true);
+        beginDownloading();
         setError(null);
         try {
             const downloadIds = await DownloadManager.downloadPlaylist(playlistId, tracks);
@@ -34,9 +56,9 @@ export function useDownloadActions() {
             throw e;
         }
         finally {
-            setIsDownloading(false);
+            endDownloading();
         }
-    }, []);
+    }, [beginDownloading, endDownloading]);
     const pauseDownload = useCallback(async (downloadId) => {
         await DownloadManager.pauseDownload(downloadId);
     }, []);
@@ -59,32 +81,32 @@ export function useDownloadActions() {
         await DownloadManager.cancelAllDownloads();
     }, []);
     const deleteTrack = useCallback(async (trackId) => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteDownloadedTrack(trackId);
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
-    }, []);
+    }, [beginDeleting, endDeleting]);
     const deletePlaylist = useCallback(async (playlistId) => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteDownloadedPlaylist(playlistId);
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
-    }, []);
+    }, [beginDeleting, endDeleting]);
     const deleteAll = useCallback(async () => {
-        setIsDeleting(true);
+        beginDeleting();
         try {
             await DownloadManager.deleteAllDownloads();
         }
         finally {
-            setIsDeleting(false);
+            endDeleting();
         }
-    }, []);
+    }, [beginDeleting, endDeleting]);
     const configure = useCallback((config) => {
         DownloadManager.configure(config);
     }, []);

package/lib/hooks/useDownloadProgress.js

@@ -1,4 +1,4 @@
-import { useEffect, useState, useRef, useCallback } from 'react';
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react';
 import { DownloadManager } from '../index';
 import { downloadCallbackManager } from './downloadCallbackManager';
 /**
@@ -8,22 +8,24 @@ export function useDownloadProgress(options = {}) {
     const { trackIds, downloadIds, activeOnly = false } = options;
     const [progressMap, setProgressMap] = useState(new Map());
     const isMounted = useRef(true);
+    // Content keys: callers pass inline arrays, so identity-based deps would
+    // resubscribe (and re-fetch over the bridge) on every parent render
+    const trackIdsKey = JSON.stringify(trackIds ?? []);
+    const downloadIdsKey = JSON.stringify(downloadIds ?? []);
     const shouldTrack = useCallback((progress) => {
-        if (trackIds &&
-            trackIds.length > 0 &&
-            !trackIds.includes(progress.trackId)) {
+        const ids = JSON.parse(trackIdsKey);
+        const dlIds = JSON.parse(downloadIdsKey);
+        if (ids.length > 0 && !ids.includes(progress.trackId)) {
             return false;
         }
-        if (downloadIds &&
-            downloadIds.length > 0 &&
-            !downloadIds.includes(progress.downloadId)) {
+        if (dlIds.length > 0 && !dlIds.includes(progress.downloadId)) {
             return false;
         }
         if (activeOnly && progress.state !== 'downloading') {
             return false;
         }
         return true;
-    }, [trackIds, downloadIds, activeOnly]);
+    }, [trackIdsKey, downloadIdsKey, activeOnly]);
     useEffect(() => {
         isMounted.current = true;
         // Initialize with current active downloads
@@ -69,12 +71,16 @@ export function useDownloadProgress(options = {}) {
             unsubscribe();
         };
     }, [shouldTrack]);
-    const progressList = Array.from(progressMap.values());
-    const overallProgress = progressList.length > 0
-        ? progressList.reduce((sum, p) => sum + p.progress, 0) /
-            progressList.length
-        : 0;
-    const isDownloading = progressList.some((p) => p.state === 'downloading');
+    const { progressList, overallProgress, isDownloading } = useMemo(() => {
+        const list = Array.from(progressMap.values());
+        return {
+            progressList: list,
+            overallProgress: list.length > 0
+                ? list.reduce((sum, p) => sum + p.progress, 0) / list.length
+                : 0,
+            isDownloading: list.some((p) => p.state === 'downloading'),
+        };
+    }, [progressMap]);
     const getProgress = useCallback((trackId) => progressMap.get(trackId), [progressMap]);
     return {
         progressMap,

package/lib/hooks/useDownloadStorage.js

@@ -46,7 +46,7 @@ export function useDownloadStorage() {
     const formattedAvailable = storageInfo
         ? formatBytes(storageInfo.availableSpace)
         : '0 B';
-    const usagePercentage = storageInfo
+    const usagePercentage = storageInfo && storageInfo.totalSpace > 0
         ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
         : 0;
     return {

package/lib/hooks/useNowPlaying.js

@@ -47,19 +47,41 @@ const DEFAULT_STATE = {
 export function useNowPlaying() {
     const [state, setState] = useState(DEFAULT_STATE);
     const isMounted = useRef(true);
+    // Once pushed events carry position, an async getState() snapshot must not
+    // overwrite it — a slow snapshot resolving after newer ticks jumped the
+    // progress bar backward on play/pause/track transitions.
+    const eventsOwnPosition = useRef(false);
+    const fetchScheduled = useRef(false);
     const fetchFullState = useCallback(async () => {
         if (!isMounted.current)
             return;
         try {
             const newState = await TrackPlayer.getState();
             if (isMounted.current) {
-                setState(newState);
+                setState((prev) => eventsOwnPosition.current
+                    ? {
+                        ...newState,
+                        currentPosition: prev.currentPosition,
+                        totalDuration: prev.totalDuration,
+                    }
+                    : newState);
             }
         }
         catch (error) {
             console.error('[useNowPlaying] Error updating player state:', error);
         }
     }, []);
+    // Coalesces the track-change + playback-state burst that fires on one
+    // transition into a single getState() round trip
+    const requestFullState = useCallback(() => {
+        if (fetchScheduled.current)
+            return;
+        fetchScheduled.current = true;
+        queueMicrotask(() => {
+            fetchScheduled.current = false;
+            fetchFullState();
+        });
+    }, [fetchFullState]);
     // Initialize with current state
     useEffect(() => {
         isMounted.current = true;
@@ -68,18 +90,20 @@ export function useNowPlaying() {
             isMounted.current = false;
         };
     }, [fetchFullState]);
-    // Subscribe to track changes — full refresh
+    // Subscribe to track changes — full refresh; the new track's position comes
+    // from the snapshot, so release event ownership until ticks resume
     useEffect(() => {
         return callbackManager.subscribeToTrackChange(() => {
-            fetchFullState();
+            eventsOwnPosition.current = false;
+            requestFullState();
         });
-    }, [fetchFullState]);
+    }, [requestFullState]);
     // Subscribe to playback state changes — full refresh
     useEffect(() => {
         return callbackManager.subscribeToPlaybackState(() => {
-            fetchFullState();
+            requestFullState();
         });
-    }, [fetchFullState]);
+    }, [requestFullState]);
     // Subscribe to progress changes — lightweight position/duration update.
     // Bail out when neither value changed at whole-second resolution: the native tick
     // is sub-second, and a new state object on every tick re-renders every consumer.
@@ -87,6 +111,7 @@ export function useNowPlaying() {
         return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
             if (!isMounted.current)
                 return;
+            eventsOwnPosition.current = true;
             setState((prev) => {
                 if (Math.floor(prev.currentPosition) === Math.floor(currentPosition) &&
                     prev.totalDuration === totalDuration) {
@@ -101,6 +126,7 @@ export function useNowPlaying() {
         return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
             if (!isMounted.current)
                 return;
+            eventsOwnPosition.current = true;
             setState((prev) => ({ ...prev, currentPosition, totalDuration }));
         });
     }, []);

package/lib/hooks/useOnSeek.js

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to get the last seek event information
  * @returns Object with last seek position and total duration, or undefined if no seek has occurred
@@ -8,7 +8,7 @@ export function useOnSeek() {
     const [position, setPosition] = useState(undefined);
     const [totalDuration, setTotalDuration] = useState(undefined);
     useEffect(() => {
-        TrackPlayer.onSeek((newPosition, newTotalDuration) => {
+        return callbackManager.subscribeToSeek((newPosition, newTotalDuration) => {
             setPosition(newPosition);
             setTotalDuration(newTotalDuration);
         });

package/lib/hooks/usePlaylist.js

@@ -40,7 +40,6 @@ export function usePlaylist() {
     const [allTracks, setAllTracks] = useState([]);
     const [isLoading, setIsLoading] = useState(true);
     const isMounted = useRef(true);
-    const hasSubscribed = useRef(false);
     // Tracks the last fetched playlist ID so track-change events can skip
     // a full refresh when the playlist itself hasn't changed.
     const lastPlaylistIdRef = useRef(undefined);
@@ -119,21 +118,13 @@ export function usePlaylist() {
             isMounted.current = false;
         };
     }, [refreshPlaylists]);
-    // Subscribe to native playlist changes (only once)
+    // Subscribe to native playlist changes via the shared manager
     useEffect(() => {
-        if (hasSubscribed.current)
-            return;
-        hasSubscribed.current = true;
-        try {
-            PlayerQueue.onPlaylistsChanged(() => {
-                if (isMounted.current) {
-                    refreshPlaylists();
-                }
-            });
-        }
-        catch (error) {
-            console.error('[usePlaylist] Error setting up playlist listener:', error);
-        }
+        return callbackManager.subscribeToPlaylistsChanged(() => {
+            if (isMounted.current) {
+                refreshPlaylists();
+            }
+        });
     }, [refreshPlaylists]);
     // Refresh on track change only if the active playlist ID changed.
     useEffect(() => {

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

@@ -92,8 +92,7 @@ export interface TrackPlayer extends HybridObject<{
      */
     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
+     * Set playback speed. Rejects non-finite and non-positive values.
      */
     setPlaybackSpeed(speed: number): Promise<void>;
     /**

package/lib/types/PlayerQueue.d.ts

@@ -48,6 +48,14 @@ export interface PlayerConfig {
     androidAutoEnabled?: boolean;
     carPlayEnabled?: boolean;
     showInNotification?: boolean;
+    /**
+     * Fixed interval, in seconds, for remote skip-forward controls (default: 15)
+     */
+    remoteSkipForwardInterval?: number;
+    /**
+     * Fixed interval, in seconds, for remote skip-backward controls (default: 15)
+     */
+    remoteSkipBackwardInterval?: number;
     /**
      * Number of upcoming tracks to preload URLs for (default: 5)
      * Higher values = more proactive loading, but more network requests

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

@@ -38,6 +38,10 @@ 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 fieldRemoteSkipForwardInterval = clazz->getField<jni::JDouble>("remoteSkipForwardInterval");
+      jni::local_ref<jni::JDouble> remoteSkipForwardInterval = this->getFieldValue(fieldRemoteSkipForwardInterval);
+      static const auto fieldRemoteSkipBackwardInterval = clazz->getField<jni::JDouble>("remoteSkipBackwardInterval");
+      jni::local_ref<jni::JDouble> remoteSkipBackwardInterval = this->getFieldValue(fieldRemoteSkipBackwardInterval);
       static const auto fieldLookaheadCount = clazz->getField<jni::JDouble>("lookaheadCount");
       jni::local_ref<jni::JDouble> lookaheadCount = this->getFieldValue(fieldLookaheadCount);
       static const auto fieldAndroidNotificationIcon = clazz->getField<jni::JString>("androidNotificationIcon");
@@ -46,6 +50,8 @@ namespace margelo::nitro::nitroplayer {
         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,
+        remoteSkipForwardInterval != nullptr ? std::make_optional(remoteSkipForwardInterval->value()) : std::nullopt,
+        remoteSkipBackwardInterval != nullptr ? std::make_optional(remoteSkipBackwardInterval->value()) : std::nullopt,
         lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt,
         androidNotificationIcon != nullptr ? std::make_optional(androidNotificationIcon->toStdString()) : std::nullopt
       );
@@ -57,7 +63,7 @@ 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>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
+      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -65,6 +71,8 @@ namespace margelo::nitro::nitroplayer {
         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.remoteSkipForwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipForwardInterval.value()) : nullptr,
+        value.remoteSkipBackwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipBackwardInterval.value()) : nullptr,
         value.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr,
         value.androidNotificationIcon.has_value() ? jni::make_jstring(value.androidNotificationIcon.value()) : nullptr
       );

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

@@ -28,6 +28,12 @@ data class PlayerConfig(
   val showInNotification: Boolean?,
   @DoNotStrip
   @Keep
+  val remoteSkipForwardInterval: Double?,
+  @DoNotStrip
+  @Keep
+  val remoteSkipBackwardInterval: Double?,
+  @DoNotStrip
+  @Keep
   val lookaheadCount: Double?,
   @DoNotStrip
   @Keep
@@ -43,8 +49,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
-      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, lookaheadCount, androidNotificationIcon)
+    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
+      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, remoteSkipForwardInterval, remoteSkipBackwardInterval, lookaheadCount, androidNotificationIcon)
     }
   }
 }

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

@@ -18,7 +18,7 @@ public extension PlayerConfig {
   /**
    * Create a new instance of `PlayerConfig`.
    */
-  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, lookaheadCount: Double?, androidNotificationIcon: String?) {
+  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?) {
     self.init({ () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = androidAutoEnabled {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -37,6 +37,18 @@ public extension PlayerConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = remoteSkipForwardInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = remoteSkipBackwardInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }(), { () -> bridge.std__optional_double_ in
       if let __unwrappedValue = lookaheadCount {
         return bridge.create_std__optional_double_(__unwrappedValue)
@@ -88,6 +100,30 @@ public extension PlayerConfig {
     }()
   }
   
+  @inline(__always)
+  var remoteSkipForwardInterval: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__remoteSkipForwardInterval) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__remoteSkipForwardInterval)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var remoteSkipBackwardInterval: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__remoteSkipBackwardInterval) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__remoteSkipBackwardInterval)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
   @inline(__always)
   var lookaheadCount: Double? {
     return { () -> Double? in

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

@@ -43,12 +43,14 @@ 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> remoteSkipForwardInterval     SWIFT_PRIVATE;
+    std::optional<double> remoteSkipBackwardInterval     SWIFT_PRIVATE;
     std::optional<double> lookaheadCount     SWIFT_PRIVATE;
     std::optional<std::string> androidNotificationIcon     SWIFT_PRIVATE;
 
   public:
     PlayerConfig() = default;
-    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon) {}
+    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> remoteSkipForwardInterval, std::optional<double> remoteSkipBackwardInterval, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), remoteSkipForwardInterval(remoteSkipForwardInterval), remoteSkipBackwardInterval(remoteSkipBackwardInterval), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon) {}
 
   public:
     friend bool operator==(const PlayerConfig& lhs, const PlayerConfig& rhs) = default;
@@ -67,6 +69,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "showInNotification"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))
       );
@@ -76,6 +80,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidAutoEnabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.carPlayEnabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "showInNotification"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.showInNotification));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.remoteSkipForwardInterval));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.remoteSkipBackwardInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.lookaheadCount));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.androidNotificationIcon));
       return obj;
@@ -91,6 +97,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAutoEnabled")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayEnabled")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "showInNotification")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))) return false;
       return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.6.0",
+  "version": "1.7.0-alpha.1",
   "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/hooks/callbackManager.ts

@@ -19,6 +19,7 @@ type TemporaryQueueCallback = (
   playNextQueue: TrackItem[],
   upNextQueue: TrackItem[]
 ) => void
+type AndroidAutoConnectionCallback = (connected: boolean) => void
 
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
@@ -33,7 +34,10 @@ class CallbackSubscriptionManager {
   private timedMetadataSubscribers = new Set<TimedMetadataCallback>()
   private temporaryQueueSubscribers = new Set<TemporaryQueueCallback>()
   private playlistsChangedSubscribers = new Set<() => void>()
+  private androidAutoConnectionSubscribers =
+    new Set<AndroidAutoConnectionCallback>()
   private isPlaylistsChangedRegistered = false
+  private isAndroidAutoConnectionRegistered = false
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
   private isPlaybackProgressRegistered = false
@@ -272,6 +276,46 @@ class CallbackSubscriptionManager {
     }
   }
 
+  /**
+   * Subscribe to Android Auto connection changes
+   * @returns Unsubscribe function
+   */
+  subscribeToAndroidAutoConnection(
+    callback: AndroidAutoConnectionCallback
+  ): () => void {
+    this.androidAutoConnectionSubscribers.add(callback)
+    this.ensureAndroidAutoConnectionRegistered()
+
+    return () => {
+      this.androidAutoConnectionSubscribers.delete(callback)
+    }
+  }
+
+  private ensureAndroidAutoConnectionRegistered(): void {
+    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/src/hooks/useActualQueue.ts

@@ -73,6 +73,18 @@ export function useActualQueue(): UseActualQueueResult {
     }
   }, [])
 
+  // 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
     setIsLoading(true)
@@ -97,25 +109,25 @@ export function useActualQueue(): UseActualQueueResult {
   // 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 }
 }