react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.20

package/src/features/output.ts

@@ -46,7 +46,7 @@ export function getOutput(): Output | undefined {
 /**
  * Subscribes to current-output changes (headphones unplugged, Bluetooth speaker
  * connected, AirPlay/route selected). Fires on iOS and Android 11+; never below.
- * @returns Cleanup function to unsubscribe.
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onOutputChanged = NativeUpdatedValue.emitterize<Output>(
   (cb) => (nativeBrowser.onOutputChanged = cb)

package/src/features/playback/controls.ts

@@ -58,8 +58,10 @@ export function seekTo(position: number): void {
 }
 
 /**
- * Jump to the live edge of the current track. No-op for non-live tracks; for
- * live, seeks to the window end (HLS) or reconnects (non-seekable streams).
+ * Jump to the live edge of the current track; no-op unless the track
+ * declares `live: true`. A stream with a seekable live window (HLS) seeks
+ * to the window's edge; a non-seekable stream (e.g. ICY radio) reconnects
+ * to rejoin live — an expired URL re-resolves through `media.resolve`.
  */
 export function seekToLiveEdge(): void {
   nativeBrowser.seekToLiveEdge()

package/src/features/playback/playWhenReady.ts

@@ -35,7 +35,7 @@ export function setPlayWhenReady(playWhenReady: boolean): void {
 /**
  * Subscribes to play when ready changes.
  * @param callback - Called when playWhenReady changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onPlayWhenReadyChanged =
   NativeUpdatedValue.emitterize<PlaybackPlayWhenReadyChangedEvent>(

package/src/features/playback/playing.ts

@@ -23,7 +23,7 @@ export function getPlayingState(): PlayingState {
 /**
  * Subscribes to playing state changes.
  * @param callback - Called when playing or buffering state changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onPlayingState = NativeUpdatedValue.emitterize<PlayingState>(
   (cb) => (nativeBrowser.onPlaybackPlayingState = cb)

package/src/features/playback/progress.test.ts

@@ -0,0 +1,169 @@
+/** @vitest-environment happy-dom */
+
+import { renderHook, act, cleanup } from '@testing-library/react'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import type { Progress } from './progress'
+import {
+  appStateListenerCount,
+  resetAppState,
+  setAppState
+} from '../../test-utils/reactNativeStub'
+
+const native = vi.hoisted(() => ({
+  getProgress: vi.fn<() => Progress>(() => ({
+    position: 0,
+    duration: 0,
+    buffered: 0
+  })),
+  onPlaybackChanged: undefined as ((event: unknown) => void) | undefined,
+  onPlaybackProgressUpdated: undefined as ((event: unknown) => void) | undefined
+}))
+
+vi.mock('../../native', () => ({ nativeBrowser: native }))
+
+const { usePolledProgress } = await import('./progress')
+
+const at = (position: number): Progress => ({
+  position,
+  duration: 300,
+  buffered: position + 10
+})
+
+beforeEach(() => {
+  vi.useFakeTimers()
+  resetAppState()
+  native.getProgress.mockReturnValue(at(0))
+})
+
+afterEach(() => {
+  cleanup()
+  vi.useRealTimers()
+})
+
+describe('usePolledProgress', () => {
+  it('starts at zero and polls the first value in', () => {
+    native.getProgress.mockReturnValue(at(12))
+    const { result } = renderHook(() => usePolledProgress())
+    // The initial poll runs inside the effect, so the zeroed useState default is
+    // never observable to a caller.
+    expect(result.current).toEqual(at(12))
+  })
+
+  it('polls on the given interval', () => {
+    const { result } = renderHook(() => usePolledProgress(500))
+    native.getProgress.mockReturnValue(at(1))
+    act(() => {
+      vi.advanceTimersByTime(500)
+    })
+    expect(result.current).toEqual(at(1))
+
+    native.getProgress.mockReturnValue(at(2))
+    act(() => {
+      vi.advanceTimersByTime(500)
+    })
+    expect(result.current).toEqual(at(2))
+  })
+
+  it('does not poll before the interval elapses', () => {
+    renderHook(() => usePolledProgress(1000))
+    native.getProgress.mockClear()
+    act(() => {
+      vi.advanceTimersByTime(999)
+    })
+    expect(native.getProgress).not.toHaveBeenCalled()
+  })
+
+  it('keeps the same object when nothing changed', () => {
+    const { result } = renderHook(() => usePolledProgress(500))
+    const first = result.current
+    act(() => {
+      vi.advanceTimersByTime(500)
+    })
+    // Identity, not equality: the hook returns the previous state object so a
+    // consumer's useEffect/memo on progress does not re-fire every tick.
+    expect(result.current).toBe(first)
+  })
+
+  it('updates immediately when playback changes, without waiting for a tick', () => {
+    const { result } = renderHook(() => usePolledProgress(10_000))
+    native.getProgress.mockReturnValue(at(7))
+    act(() => {
+      native.onPlaybackChanged?.({ state: 'playing' })
+    })
+    expect(result.current).toEqual(at(7))
+  })
+
+  it('survives a getter that throws before setup', () => {
+    native.getProgress.mockImplementation(() => {
+      throw new Error('not set up')
+    })
+    const { result } = renderHook(() => usePolledProgress(500))
+    expect(result.current).toEqual({ position: 0, duration: 0, buffered: 0 })
+    expect(() => act(() => vi.advanceTimersByTime(500))).not.toThrow()
+  })
+
+  it('stops polling in the background and resumes on return', () => {
+    const { result } = renderHook(() => usePolledProgress(500))
+
+    act(() => {
+      setAppState('background')
+    })
+    native.getProgress.mockReturnValue(at(99))
+    act(() => {
+      vi.advanceTimersByTime(5_000)
+    })
+    expect(result.current).toEqual(at(0))
+
+    // Returning to the foreground updates once immediately rather than leaving
+    // a stale position on screen until the next interval.
+    act(() => {
+      setAppState('active')
+    })
+    expect(result.current).toEqual(at(99))
+  })
+
+  it('ignores playback events while backgrounded', () => {
+    const { result } = renderHook(() => usePolledProgress(500))
+    act(() => {
+      setAppState('background')
+    })
+    native.getProgress.mockReturnValue(at(42))
+    act(() => {
+      native.onPlaybackChanged?.({ state: 'playing' })
+    })
+    expect(result.current).toEqual(at(0))
+  })
+
+  it('does not stack pollers when backgrounded twice', () => {
+    renderHook(() => usePolledProgress(500))
+    act(() => {
+      setAppState('background')
+    })
+    act(() => {
+      setAppState('active')
+    })
+    act(() => {
+      setAppState('active')
+    })
+
+    native.getProgress.mockClear()
+    act(() => {
+      vi.advanceTimersByTime(500)
+    })
+    expect(native.getProgress).toHaveBeenCalledTimes(1)
+  })
+
+  it('tears down its timer and subscriptions on unmount', () => {
+    const { unmount } = renderHook(() => usePolledProgress(500))
+    expect(appStateListenerCount()).toBe(1)
+
+    unmount()
+    expect(appStateListenerCount()).toBe(0)
+
+    native.getProgress.mockClear()
+    act(() => {
+      vi.advanceTimersByTime(5_000)
+    })
+    expect(native.getProgress).not.toHaveBeenCalled()
+  })
+})

package/src/features/playback/progress.ts

@@ -46,7 +46,7 @@ export function getProgress(): Progress {
 /**
  * Subscribes to playback progress updates.
  * @param callback - Called periodically with playback progress updates
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onProgressUpdated =
   NativeUpdatedValue.emitterize<PlaybackProgressUpdatedEvent>(
@@ -118,7 +118,8 @@ export function usePolledProgress(updateInterval = 1000): Progress {
     }
 
     const stop = () => {
-      clearTimeout(timer)
+      // Guarded: React Native types clearTimeout(handle: number) — no undefined.
+      if (timer !== undefined) clearTimeout(timer)
       timer = undefined
       unsubscribeState?.()
       unsubscribeState = undefined

package/src/features/playback/rate.ts

@@ -14,8 +14,15 @@ export function getRate(): number {
 
 /**
  * Sets the playback rate.
+ *
+ * The rate is a speed multiplier, not a transport control — it is independent
+ * of play/pause, and setting it while paused never starts playback. Use
+ * {@link play} / {@link pause} for that.
+ *
  * @param rate - The playback rate to change to, where 0.5 would be half speed,
- * 1 would be regular speed, 2 would be double speed etc.
+ * 1 would be regular speed, 2 would be double speed etc. Must be greater than
+ * zero; platforms disagree on what a non-positive rate does (iOS ignores it,
+ * Android throws, web stalls the element), so treat it as unsupported.
  */
 export function setRate(rate: number): void {
   nativeBrowser.setRate(rate)

package/src/features/playback/state.ts

@@ -18,9 +18,8 @@ import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
  * - `'buffering'`: Indicates that the player is currently loading more data
  *   before it can continue playing or is ready to start playing.
  * - `'error'`: Indicates that playback of the current item failed. Call
- *   `AudioBrowser.getError()` to get more information on the type of error that
- *   occurred. Call `AudioBrowser.retry()` or `AudioBrowser.play()` to try to play
- *   the item again.
+ *   `getPlaybackError()` (or subscribe via `usePlaybackError()`) for the
+ *   error details. Call `retry()` or `play()` to try to play the item again.
  * - `'ended'`: Indicates that playback stopped due to the end of the queue
  *   being reached.
  */
@@ -55,7 +54,7 @@ export function getPlayback(): Playback {
 /**
  * Subscribes to playback state changes.
  * @param callback - Called when the playback state changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onPlaybackChanged = NativeUpdatedValue.emitterize<Playback>(
   (cb) => (nativeBrowser.onPlaybackChanged = cb)

package/src/features/playback/trackPlaybackTime.test.ts

@@ -13,12 +13,22 @@ vi.mock('../queue/activeTrack', () => ({
   onActiveTrackChanged: { addListener: vi.fn(() => () => {}) }
 }))
 
-import { trackPlaybackTime, __emitTickForTests } from './trackPlaybackTime'
+import { trackPlaybackTime } from './trackPlaybackTime'
 
 beforeEach(() => {
   nativeMock.setPlaybackIntervalEnabled.mockClear()
 })
 
+/** Ticks through the slot `install()` assigns, so this covers that wiring too. */
+function tick(times = 1) {
+  for (let i = 0; i < times; i++) {
+    if (!nativeMock.onPlaybackInterval) {
+      throw new Error('trackPlaybackTime never installed onPlaybackInterval')
+    }
+    nativeMock.onPlaybackInterval()
+  }
+}
+
 describe('trackPlaybackTime', () => {
   it('enables native tick on first subscriber, disables on last', () => {
     const a = trackPlaybackTime(() => {}, 5)
@@ -38,17 +48,17 @@ describe('trackPlaybackTime', () => {
       (e) => calls.push({ total: e.total, sinceLast: e.sinceLast }),
       3
     )
-    __emitTickForTests(2)
+    tick(2)
     expect(calls).toEqual([])
-    __emitTickForTests(1) // total now 3 → fires
+    tick(1) // total now 3 → fires
     expect(calls).toEqual([{ total: 3, sinceLast: 3 }])
-    __emitTickForTests(3) // total now 6 → fires again
+    tick(3) // total now 6 → fires again
     expect(calls).toEqual([
       { total: 3, sinceLast: 3 },
       { total: 6, sinceLast: 3 }
     ])
     cancel()
-    __emitTickForTests(3)
+    tick(3)
     expect(calls).toHaveLength(2) // cancelled
   })
 
@@ -57,7 +67,7 @@ describe('trackPlaybackTime', () => {
     const slow: number[] = []
     const cancelFast = trackPlaybackTime((e) => fast.push(e.total), 1)
     const cancelSlow = trackPlaybackTime((e) => slow.push(e.total), 2)
-    __emitTickForTests(2)
+    tick(2)
     expect(fast).toEqual([1, 2])
     expect(slow).toEqual([2])
     cancelFast()

package/src/features/playback/trackPlaybackTime.ts

@@ -9,7 +9,7 @@ export interface PlaybackElapsed {
   total: number
   /** Seconds played since the previous callback (≈ `period`). */
   sinceLast: number
-  /** The currently playing track (id / src / url / title …), if any. */
+  /** The currently playing track (id / src / path / title …), if any. */
   track?: Track
 }
 
@@ -99,8 +99,3 @@ export function trackPlaybackTime(
     if (handles.size === 0) nativeBrowser.setPlaybackIntervalEnabled(false)
   }
 }
-
-/** @internal test hook — drives the fan-out without a native tick. */
-export function __emitTickForTests(ticks = 1) {
-  for (let i = 0; i < ticks; i++) onTick()
-}

package/src/features/playback/volume.ts

@@ -42,7 +42,7 @@ export function setSystemVolume(level: number): void {
 /**
  * Subscribes to system volume changes.
  * @param callback - Called when the system volume changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onSystemVolumeChanged = NativeUpdatedValue.emitterize<number>(
   (cb) => (nativeBrowser.onSystemVolumeChanged = cb)