react-native-nitro-player 0.4.0 → 0.5.0

package/src/hooks/callbackManager.ts

@@ -3,6 +3,12 @@ import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue'
 
 type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void
 type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
+type PlaybackProgressCallback = (
+  position: number,
+  totalDuration: number,
+  isManuallySeeked?: boolean
+) => void
+type SeekCallback = (position: number, totalDuration: number) => void
 
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
@@ -12,8 +18,12 @@ type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
 class CallbackSubscriptionManager {
   private playbackStateSubscribers = new Set<PlaybackStateCallback>()
   private trackChangeSubscribers = new Set<TrackChangeCallback>()
+  private playbackProgressSubscribers = new Set<PlaybackProgressCallback>()
+  private seekSubscribers = new Set<SeekCallback>()
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
+  private isPlaybackProgressRegistered = false
+  private isSeekRegistered = false
 
   /**
    * Subscribe to playback state changes
@@ -90,6 +100,83 @@ class CallbackSubscriptionManager {
       )
     }
   }
+
+  /**
+   * Subscribe to playback progress changes
+   * @returns Unsubscribe function
+   */
+  subscribeToPlaybackProgressChange(
+    callback: PlaybackProgressCallback
+  ): () => void {
+    this.playbackProgressSubscribers.add(callback)
+    this.ensurePlaybackProgressRegistered()
+
+    return () => {
+      this.playbackProgressSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to seek events
+   * @returns Unsubscribe function
+   */
+  subscribeToSeek(callback: SeekCallback): () => void {
+    this.seekSubscribers.add(callback)
+    this.ensureSeekRegistered()
+
+    return () => {
+      this.seekSubscribers.delete(callback)
+    }
+  }
+
+  private ensurePlaybackProgressRegistered(): void {
+    if (this.isPlaybackProgressRegistered) return
+
+    try {
+      TrackPlayer.onPlaybackProgressChange(
+        (position, totalDuration, isManuallySeeked) => {
+          this.playbackProgressSubscribers.forEach((subscriber) => {
+            try {
+              subscriber(position, totalDuration, isManuallySeeked)
+            } catch (error) {
+              console.error(
+                '[CallbackManager] Error in playback progress subscriber:',
+                error
+              )
+            }
+          })
+        }
+      )
+      this.isPlaybackProgressRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register playback progress callback:',
+        error
+      )
+    }
+  }
+
+  private ensureSeekRegistered(): void {
+    if (this.isSeekRegistered) return
+
+    try {
+      TrackPlayer.onSeek((position, totalDuration) => {
+        this.seekSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(position, totalDuration)
+          } catch (error) {
+            console.error('[CallbackManager] Error in seek subscriber:', error)
+          }
+        })
+      })
+      this.isSeekRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register seek callback:',
+        error
+      )
+    }
+  }
 }
 
 // Export singleton instance

package/src/hooks/useNowPlaying.ts

@@ -51,12 +51,14 @@ export function useNowPlaying(): PlayerState {
   const [state, setState] = useState<PlayerState>(DEFAULT_STATE)
   const isMounted = useRef(true)
 
-  const updateState = useCallback(async () => {
+  const fetchFullState = useCallback(async () => {
     if (!isMounted.current) return
 
     try {
       const newState = await TrackPlayer.getState()
-      setState(newState)
+      if (isMounted.current) {
+        setState(newState)
+      }
     } catch (error) {
       console.error('[useNowPlaying] Error updating player state:', error)
     }
@@ -65,34 +67,44 @@ export function useNowPlaying(): PlayerState {
   // Initialize with current state
   useEffect(() => {
     isMounted.current = true
-    updateState()
+    fetchFullState()
 
     return () => {
       isMounted.current = false
     }
-  }, [updateState])
+  }, [fetchFullState])
 
-  // Subscribe to track changes
+  // Subscribe to track changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-      updateState()
+    return callbackManager.subscribeToTrackChange(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
-
-  // Subscribe to playback state changes
+  // Subscribe to playback state changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-      updateState()
+    return callbackManager.subscribeToPlaybackState(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
+  // Subscribe to progress changes — lightweight position/duration update
+  useEffect(() => {
+    return callbackManager.subscribeToPlaybackProgressChange(
+      (currentPosition, totalDuration) => {
+        if (!isMounted.current) return
+        setState((prev) => ({ ...prev, currentPosition, totalDuration }))
+      }
+    )
+  }, [])
+
+  // Subscribe to seek events — lightweight position/duration update
+  useEffect(() => {
+    return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
+      if (!isMounted.current) return
+      setState((prev) => ({ ...prev, currentPosition, totalDuration }))
+    })
+  }, [])
 
   return state
 }

package/src/hooks/useOnPlaybackProgressChange.ts

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react'
-import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
 
 /**
  * Hook to get the current playback progress
@@ -17,7 +17,7 @@ export function useOnPlaybackProgressChange(): {
   )
 
   useEffect(() => {
-    TrackPlayer.onPlaybackProgressChange(
+    return callbackManager.subscribeToPlaybackProgressChange(
       (newPosition, newTotalDuration, newIsManuallySeeked) => {
         setPosition(newPosition)
         setTotalDuration(newTotalDuration)