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

package/src/hooks/useAndroidAutoConnection.ts

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react'
 import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
 
 /**
  * Hook to detect Android Auto connection status using the official Android for Cars API
@@ -15,15 +16,14 @@ export function useAndroidAutoConnection() {
   const [isConnected, setIsConnected] = useState<boolean>(false)
 
   useEffect(() => {
-    // Set initial state
     const initialState = TrackPlayer.isAndroidAutoConnected()
     setIsConnected(initialState)
 
-    // Listen for connection changes
-    TrackPlayer.onAndroidAutoConnectionChange((connected: boolean) => {
-      setIsConnected(connected)
-      console.log('🚗 Android Auto connection changed:', connected)
-    })
+    return callbackManager.subscribeToAndroidAutoConnection(
+      (connected: boolean) => {
+        setIsConnected(connected)
+      }
+    )
   }, [])
 
   return { isConnected }

package/src/hooks/useAudioDevices.ts

@@ -1,9 +1,12 @@
 import { useEffect, useState } from 'react'
-import { Platform } from 'react-native'
-import { NitroModules } from 'react-native-nitro-modules'
-import type { AudioDevices as AudioDevicesType } from '../specs/AudioDevices.nitro'
+import { AudioDevices } from '../index'
 import type { TAudioDevice } from '../specs/AudioDevices.nitro'
 
+function devicesEqual(a: TAudioDevice[], b: TAudioDevice[]): boolean {
+  if (a.length !== b.length) return false
+  return a.every((d, i) => d.id === b[i]!.id && d.isActive === b[i]!.isActive)
+}
+
 /**
  * Hook to get audio devices (Android only)
  *
@@ -30,34 +33,28 @@ export function useAudioDevices() {
   const [devices, setDevices] = useState<TAudioDevice[]>([])
 
   useEffect(() => {
-    if (Platform.OS !== 'android') {
+    if (!AudioDevices) {
       return undefined
     }
 
-    try {
-      const AudioDevices =
-        NitroModules.createHybridObject<AudioDevicesType>('AudioDevices')
-
-      // Get initial devices
-      const updateDevices = () => {
-        try {
-          const currentDevices = AudioDevices.getAudioDevices()
-          setDevices(currentDevices)
-        } catch (error) {
-          console.error('Error getting audio devices:', error)
-        }
+    const updateDevices = () => {
+      try {
+        const currentDevices = AudioDevices!.getAudioDevices()
+        // Bail when nothing changed — the bridge returns a fresh array identity
+        // every tick, which would otherwise re-render every consumer at 0.5Hz
+        setDevices((prev) =>
+          devicesEqual(prev, currentDevices) ? prev : currentDevices
+        )
+      } catch (error) {
+        console.error('Error getting audio devices:', error)
       }
+    }
 
-      updateDevices()
+    updateDevices()
 
-      // Poll for changes every 2 seconds
-      const interval = setInterval(updateDevices, 2000)
+    const interval = setInterval(updateDevices, 2000)
 
-      return () => clearInterval(interval)
-    } catch (error) {
-      console.error('Error setting up audio devices polling:', error)
-      return undefined
-    }
+    return () => clearInterval(interval)
   }, [])
 
   return { devices }

package/src/hooks/useDownloadActions.ts

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react'
+import { useCallback, useRef, useState } from 'react'
 import { DownloadManager } from '../index'
 import type { DownloadConfig, PlaybackSource } from '../types/DownloadTypes'
 import type { TrackItem } from '../types/PlayerQueue'
@@ -45,10 +45,34 @@ export function useDownloadActions(): UseDownloadActionsResult {
   const [isDownloading, setIsDownloading] = useState(false)
   const [isDeleting, setIsDeleting] = useState(false)
   const [error, setError] = useState<Error | null>(null)
+  // 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: TrackItem, playlistId?: string) => {
-      setIsDownloading(true)
+      beginDownloading()
       setError(null)
       try {
         const downloadId = await DownloadManager.downloadTrack(
@@ -60,15 +84,15 @@ export function useDownloadActions(): UseDownloadActionsResult {
         setError(e as Error)
         throw e
       } finally {
-        setIsDownloading(false)
+        endDownloading()
       }
     },
-    []
+    [beginDownloading, endDownloading]
   )
 
   const downloadPlaylist = useCallback(
     async (playlistId: string, tracks: TrackItem[]) => {
-      setIsDownloading(true)
+      beginDownloading()
       setError(null)
       try {
         const downloadIds = await DownloadManager.downloadPlaylist(
@@ -80,10 +104,10 @@ export function useDownloadActions(): UseDownloadActionsResult {
         setError(e as Error)
         throw e
       } finally {
-        setIsDownloading(false)
+        endDownloading()
       }
     },
-    []
+    [beginDownloading, endDownloading]
   )
 
   const pauseDownload = useCallback(async (downloadId: string) => {
@@ -114,32 +138,38 @@ export function useDownloadActions(): UseDownloadActionsResult {
     await DownloadManager.cancelAllDownloads()
   }, [])
 
-  const deleteTrack = useCallback(async (trackId: string) => {
-    setIsDeleting(true)
-    try {
-      await DownloadManager.deleteDownloadedTrack(trackId)
-    } finally {
-      setIsDeleting(false)
-    }
-  }, [])
+  const deleteTrack = useCallback(
+    async (trackId: string) => {
+      beginDeleting()
+      try {
+        await DownloadManager.deleteDownloadedTrack(trackId)
+      } finally {
+        endDeleting()
+      }
+    },
+    [beginDeleting, endDeleting]
+  )
 
-  const deletePlaylist = useCallback(async (playlistId: string) => {
-    setIsDeleting(true)
-    try {
-      await DownloadManager.deleteDownloadedPlaylist(playlistId)
-    } finally {
-      setIsDeleting(false)
-    }
-  }, [])
+  const deletePlaylist = useCallback(
+    async (playlistId: string) => {
+      beginDeleting()
+      try {
+        await DownloadManager.deleteDownloadedPlaylist(playlistId)
+      } finally {
+        endDeleting()
+      }
+    },
+    [beginDeleting, endDeleting]
+  )
 
   const deleteAll = useCallback(async () => {
-    setIsDeleting(true)
+    beginDeleting()
     try {
       await DownloadManager.deleteAllDownloads()
     } finally {
-      setIsDeleting(false)
+      endDeleting()
     }
-  }, [])
+  }, [beginDeleting, endDeleting])
 
   const configure = useCallback((config: DownloadConfig) => {
     DownloadManager.configure(config)

package/src/hooks/useDownloadProgress.ts

@@ -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'
 import type { DownloadProgress } from '../types/DownloadTypes'
@@ -37,20 +37,19 @@ export function useDownloadProgress(
   )
   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: DownloadProgress): boolean => {
-      if (
-        trackIds &&
-        trackIds.length > 0 &&
-        !trackIds.includes(progress.trackId)
-      ) {
+      const ids: string[] = JSON.parse(trackIdsKey)
+      const dlIds: string[] = 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') {
@@ -58,7 +57,7 @@ export function useDownloadProgress(
       }
       return true
     },
-    [trackIds, downloadIds, activeOnly]
+    [trackIdsKey, downloadIdsKey, activeOnly]
   )
 
   useEffect(() => {
@@ -113,13 +112,17 @@ export function useDownloadProgress(
     }
   }, [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: string) => progressMap.get(trackId),
     [progressMap]

package/src/hooks/useDownloadStorage.ts

@@ -69,9 +69,10 @@ export function useDownloadStorage(): UseDownloadStorageResult {
     ? formatBytes(storageInfo.availableSpace)
     : '0 B'
 
-  const usagePercentage = storageInfo
-    ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
-    : 0
+  const usagePercentage =
+    storageInfo && storageInfo.totalSpace > 0
+      ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
+      : 0
 
   return {
     storageInfo,

package/src/hooks/useNowPlaying.ts

@@ -50,6 +50,11 @@ const DEFAULT_STATE: PlayerState = {
 export function useNowPlaying(): PlayerState {
   const [state, setState] = useState<PlayerState>(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
@@ -57,13 +62,32 @@ export function useNowPlaying(): PlayerState {
     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
@@ -74,19 +98,21 @@ export function useNowPlaying(): PlayerState {
     }
   }, [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
@@ -95,6 +121,7 @@ export function useNowPlaying(): PlayerState {
     return callbackManager.subscribeToPlaybackProgressChange(
       (currentPosition, totalDuration) => {
         if (!isMounted.current) return
+        eventsOwnPosition.current = true
         setState((prev) => {
           if (
             Math.floor(prev.currentPosition) === Math.floor(currentPosition) &&
@@ -112,6 +139,7 @@ export function useNowPlaying(): PlayerState {
   useEffect(() => {
     return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
       if (!isMounted.current) return
+      eventsOwnPosition.current = true
       setState((prev) => ({ ...prev, currentPosition, totalDuration }))
     })
   }, [])

package/src/hooks/useOnSeek.ts

@@ -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
@@ -15,7 +15,7 @@ export function useOnSeek(): {
   )
 
   useEffect(() => {
-    TrackPlayer.onSeek((newPosition, newTotalDuration) => {
+    return callbackManager.subscribeToSeek((newPosition, newTotalDuration) => {
       setPosition(newPosition)
       setTotalDuration(newTotalDuration)
     })

package/src/hooks/usePlaylist.ts

@@ -59,7 +59,6 @@ export function usePlaylist(): UsePlaylistResult {
   const [allTracks, setAllTracks] = useState<TrackItem[]>([])
   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<string | null | undefined>(undefined)
@@ -143,20 +142,13 @@ export function usePlaylist(): UsePlaylistResult {
     }
   }, [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.

package/src/specs/TrackPlayer.nitro.ts

@@ -157,8 +157,7 @@ export interface TrackPlayer extends HybridObject<{
   ): 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/src/types/PlayerQueue.ts

@@ -60,6 +60,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/android/src/main/java/com/margelo/nitro/nitroplayer/media/NitroPlayerNotificationProvider.kt

@@ -1,200 +0,0 @@
-@file:Suppress("ktlint:standard:max-line-length")
-
-package com.margelo.nitro.nitroplayer.media
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.os.Build
-import android.os.Bundle
-import android.util.LruCache
-import android.view.KeyEvent
-import androidx.core.app.NotificationCompat
-import androidx.media3.common.util.UnstableApi
-import androidx.media3.session.CommandButton
-import androidx.media3.session.MediaNotification
-import androidx.media3.session.MediaSession
-import com.google.common.collect.ImmutableList
-import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import java.net.URL
-
-/**
- * Custom notification provider that manually builds a [MediaStyle][androidx.media.app.NotificationCompat.MediaStyle]
- * notification with artwork, title, artist, and transport controls — matching
- * the proven approach from the main branch.
- */
-@UnstableApi
-class NitroPlayerNotificationProvider(
-    private val context: Context,
-) : MediaNotification.Provider {
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-    private val notificationManager =
-        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    private val artworkCache =
-        object : LruCache<String, Bitmap>(20) {
-            override fun sizeOf(key: String, value: Bitmap): Int = 1
-        }
-
-    companion object {
-        const val NOTIFICATION_ID = 1001
-        private const val CHANNEL_ID = "nitro_player_channel"
-        private const val CHANNEL_NAME = "Music Player"
-    }
-
-    init {
-        createNotificationChannel()
-    }
-
-    override fun createNotification(
-        mediaSession: MediaSession,
-        customLayout: ImmutableList<CommandButton>,
-        actionFactory: MediaNotification.ActionFactory,
-        onNotificationChangedCallback: MediaNotification.Provider.Callback,
-    ): MediaNotification {
-        val player = mediaSession.player
-        val metadata = player.mediaMetadata
-        val isPlaying = player.isPlaying
-
-        val contentIntent =
-            PendingIntent.getActivity(
-                context,
-                0,
-                context.packageManager.getLaunchIntentForPackage(context.packageName),
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-            )
-
-        val builder =
-            NotificationCompat
-                .Builder(context, CHANNEL_ID)
-                .setContentTitle(metadata.title ?: "Unknown Title")
-                .setContentText(metadata.artist ?: "Unknown Artist")
-                .setSubText(metadata.albumTitle ?: "")
-                .setSmallIcon(android.R.drawable.ic_media_play)
-                .setContentIntent(contentIntent)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setOngoing(isPlaying)
-                .setShowWhen(false)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setCategory(NotificationCompat.CATEGORY_TRANSPORT)
-
-        // MediaStyle with session token
-        try {
-            val compatToken =
-                android.support.v4.media.session.MediaSessionCompat.Token
-                    .fromToken(mediaSession.platformToken)
-            builder.setStyle(
-                androidx.media.app.NotificationCompat
-                    .MediaStyle()
-                    .setMediaSession(compatToken)
-                    .setShowActionsInCompactView(0, 1, 2),
-            )
-        } catch (e: Exception) {
-            NitroPlayerLogger.log("NotificationProvider") { "Failed to set media session token: ${e.message}" }
-        }
-
-        // Transport actions using media button PendingIntents
-        builder.addAction(
-            android.R.drawable.ic_media_previous,
-            "Previous",
-            buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PREVIOUS, 0),
-        )
-
-        if (isPlaying) {
-            builder.addAction(
-                android.R.drawable.ic_media_pause,
-                "Pause",
-                buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PAUSE, 1),
-            )
-        } else {
-            builder.addAction(
-                android.R.drawable.ic_media_play,
-                "Play",
-                buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PLAY, 1),
-            )
-        }
-
-        builder.addAction(
-            android.R.drawable.ic_media_next,
-            "Next",
-            buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_NEXT, 2),
-        )
-
-        // Load artwork async and update notification
-        metadata.artworkUri?.toString()?.let { artworkUrl ->
-            val cached = artworkCache.get(artworkUrl)
-            if (cached != null) {
-                builder.setLargeIcon(cached)
-            } else {
-                scope.launch {
-                    val bitmap = loadArtworkBitmap(artworkUrl)
-                    if (bitmap != null) {
-                        builder.setLargeIcon(bitmap)
-                        onNotificationChangedCallback.onNotificationChanged(
-                            MediaNotification(NOTIFICATION_ID, builder.build()),
-                        )
-                    }
-                }
-            }
-        }
-
-        return MediaNotification(NOTIFICATION_ID, builder.build())
-    }
-
-    override fun handleCustomCommand(
-        session: MediaSession,
-        action: String,
-        extras: Bundle,
-    ): Boolean = false
-
-    private fun buildMediaButtonIntent(keyCode: Int, requestCode: Int): PendingIntent {
-        val intent =
-            Intent(Intent.ACTION_MEDIA_BUTTON).apply {
-                putExtra(Intent.EXTRA_KEY_EVENT, KeyEvent(KeyEvent.ACTION_DOWN, keyCode))
-                setPackage(context.packageName)
-            }
-        return PendingIntent.getBroadcast(
-            context,
-            requestCode,
-            intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-        )
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel =
-                NotificationChannel(
-                    CHANNEL_ID,
-                    CHANNEL_NAME,
-                    NotificationManager.IMPORTANCE_LOW,
-                ).apply {
-                    description = "Media playback controls"
-                    setShowBadge(false)
-                    lockscreenVisibility = Notification.VISIBILITY_PUBLIC
-                }
-            notificationManager.createNotificationChannel(channel)
-        }
-    }
-
-    private suspend fun loadArtworkBitmap(artworkUrl: String): Bitmap? {
-        artworkCache.get(artworkUrl)?.let { return it }
-        return try {
-            withContext(Dispatchers.IO) {
-                val url = URL(artworkUrl)
-                BitmapFactory.decodeStream(url.openConnection().getInputStream())
-            }?.also { artworkCache.put(artworkUrl, it) }
-        } catch (_: Exception) {
-            null
-        }
-    }
-}