react-native-audio-browser 0.2.0-next.18 → 0.2.0-next.19

package/src/web/__tests__/loadEdgeCases.test.ts

@@ -0,0 +1,195 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import { LifecycleHarness, trackA, trackB } from './lifecycleHarness'
+
+/**
+ * The edges the main lifecycle recordings miss, each one a bug the hoisted
+ * load path introduced or exposed. All were reproduced before being fixed;
+ * reverting any fix fails the test that names it.
+ */
+
+let h: LifecycleHarness
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('a load superseded while still in flight', () => {
+  /**
+   * The eager `unload()` aborts the in-flight `player.load()`, and Shaka
+   * rejects an aborted load with LOAD_INTERRUPTED (7000). Unless the stale
+   * load is abandoned first, its own `catch` reports that as a playback
+   * error — an error banner on every fast track switch.
+   */
+  it('does not report the interrupted load as an error', async () => {
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA)
+    await h.flush() // player.load(A) is now pending
+    h.clear()
+
+    h.browser.load(trackB)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.recorded).not.toContain('state:error')
+    expect(h.recorded.some((r) => r.startsWith('error:'))).toBe(false)
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+})
+
+describe('a track end that does not advance the queue', () => {
+  /**
+   * Suppressing `ended` mid-queue is only safe when a load takes over the
+   * state. The sleep timer set to end-of-track pauses instead, and its
+   * `element.pause()` is a no-op on an already-ended element — so nothing
+   * moved the state and the player sat reporting `playing` with silence.
+   */
+  it('reports ended when the sleep timer stops instead of advancing', async () => {
+    h.browser.setQueue([trackA, trackB])
+    h.browser.setPlayWhenReady(true)
+    h.browser.skip(0)
+    await h.flush()
+    await h.completeLoad()
+    h.browser.setSleepTimerToEndOfTrack()
+    h.clear()
+
+    h.endTrack()
+    await h.flush()
+
+    expect(h.browser.getPlayback().state).toBe('ended')
+  })
+
+  it('still suppresses ended when the queue does advance', async () => {
+    h.browser.setQueue([trackA, trackB])
+    h.browser.setPlayWhenReady(true)
+    h.browser.skip(0)
+    await h.flush()
+    await h.completeLoad()
+    h.clear()
+
+    h.endTrack()
+    await h.flush()
+
+    expect(h.recorded).not.toContain('state:ended')
+  })
+})
+
+describe('loading after a stop', () => {
+  /**
+   * `dispatch()` drops every event while `_isStopped`, to keep Shaka's
+   * teardown noise off the stopped state. The `trackLoading` raised when
+   * `load()` is called was caught by that too, so the resolution window
+   * reported `stopped` rather than `loading` on the stop → play path.
+   */
+  it('reports loading while the url resolves', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.browser.stop()
+    await h.flush()
+
+    h.browser.play()
+
+    expect(h.browser.getPlayback().state).toBe('loading')
+  })
+})
+
+describe('the remembered resume position', () => {
+  /**
+   * `onError` also runs for a *load* failure, where the element was just torn
+   * down and reads 0. Recording that overwrote the real position, so a retry
+   * that failed cost the place a later one would have resumed from.
+   */
+  it('survives a retry that also fails', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(42)
+    h.raiseError()
+    await h.flush()
+
+    h.failLoad()
+    h.browser.retry()
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(42)
+  })
+
+  it('is not applied to a different track', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.setPosition(42)
+    h.raiseError()
+    await h.flush()
+
+    // a different track becomes current, then fails at the very start
+    h.browser.load(trackB)
+    await h.flush()
+    await h.completeLoad()
+    h.raiseError()
+    await h.flush()
+
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(0)
+  })
+})
+
+describe('re-preparing the current item', () => {
+  /**
+   * ExoPlayer's `prepare()` does not re-fire `onMediaItemTransition` for an
+   * unchanged item, so neither should a retry: a consumer that resets on a
+   * track change would have its UI wiped every time one ran. The
+   * `lastTrack === track` payload was the tell.
+   */
+  it('does not announce a transition on retry', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.raiseError()
+    await h.flush()
+    h.clear()
+
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.recorded).not.toContain('activeTrack')
+    expect(h.recorded).not.toContain('nowPlaying')
+  })
+
+  it('still announces when the track actually changes', async () => {
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+    h.clear()
+
+    h.browser.load(trackB)
+    await h.flush()
+
+    expect(h.recorded).toContain('activeTrack')
+  })
+
+  it('announces the first load of all', async () => {
+    const fresh: Track = {
+      id: 'f',
+      title: 'F',
+      src: 'https://x.example.com/f.mp3'
+    }
+    h.browser.load(fresh)
+    await h.flush()
+
+    expect(h.recorded).toContain('activeTrack')
+  })
+})

package/src/web/__tests__/loadSupersession.test.ts

@@ -0,0 +1,175 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import {
+  LifecycleHarness,
+  deferredResolver,
+  trackA,
+  trackB
+} from './lifecycleHarness'
+
+/**
+ * What happens to a load that something else takes over from — a newer load,
+ * or a stop. Written before the two generation counters (`Player._loadGeneration`
+ * and `NativeAudioBrowser.currentLoadId`) were unified into one cancellation
+ * token, so they describe the behaviour rather than either mechanism.
+ */
+
+let h: LifecycleHarness
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('a load superseded mid-resolution', () => {
+  it('never hands the stale url to the player', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.load(trackB)
+    await h.flush()
+    expect(resolver.calls()).toBe(2)
+
+    // the winner resolves first, then the superseded one arrives late
+    resolver.release(2)
+    await h.flush()
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual(['https://cdn.example.com/2.mp3'])
+  })
+
+  it('leaves the winner playing', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+    h.browser.setPlayWhenReady(true)
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.load(trackB)
+    await h.flush()
+
+    resolver.release(2)
+    await h.flush()
+    await h.completeLoad()
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.browser.getActiveTrack()?.id).toBe(trackB.id)
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+})
+
+describe('a load superseded after its own url resolved', () => {
+  /**
+   * The gap the two generation counters left. Supersession was registered by
+   * the *inner* `super.load()`, which only runs once the URL has resolved — so
+   * a load whose Shaka promise had already settled ran its own success path
+   * even though a newer `load()` had been called first. One token begun at the
+   * call closes it.
+   */
+  it('does not run its callback once a newer load has begun', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+    h.browser.setPlayWhenReady(true)
+
+    const seen: Array<string | undefined> = []
+    h.browser.load(trackA, (track) => seen.push(track.id))
+    await h.flush()
+    resolver.release(1)
+    await h.flush() // super.load(A) has run; its Shaka load is pending
+
+    h.finishLoadOnly() // A's load settles, its .then is queued
+    h.browser.load(trackB) // superseded before that .then runs
+    await h.flush()
+
+    expect(seen).toEqual([])
+  })
+})
+
+describe('a load stopped mid-resolution', () => {
+  it('never hands its url to the player', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.stop()
+    await h.flush()
+
+    resolver.release(1)
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual([])
+    expect(h.browser.getPlayback().state).toBe('stopped')
+  })
+})
+
+describe('a load stopped while Shaka is loading', () => {
+  it('does not run the load callback, seek, or autoplay', async () => {
+    let loadedCalls = 0
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA, () => {
+      loadedCalls += 1
+    })
+    await h.flush() // player.load() is pending
+
+    h.browser.stop()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(loadedCalls).toBe(0)
+    expect(h.browser.getPlayback().state).toBe('stopped')
+  })
+})
+
+describe('the load that wins', () => {
+  it('runs its callback', async () => {
+    const seen: Array<string | undefined> = []
+    h.browser.load(trackA, (track) => seen.push(track.id))
+    await h.flush()
+    await h.completeLoad()
+
+    expect(seen).toEqual([trackA.id])
+  })
+
+  it('applies a seek that arrived while it was loading', async () => {
+    const resolver = deferredResolver()
+    h.browser.configuration = resolver.configuration
+
+    h.browser.load(trackA)
+    await h.flush()
+    h.browser.seekTo(30) // captured as pending: the load is still in progress
+    resolver.release(1)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(30)
+  })
+
+  it('autoplays when the intent is set', async () => {
+    h.browser.setPlayWhenReady(true)
+    h.browser.load(trackA)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.browser.getPlayback().state).toBe('playing')
+  })
+
+  it('does not autoplay without the intent', async () => {
+    const paused: Track = {
+      id: 'p',
+      title: 'P',
+      src: 'https://x.example.com/p.mp3'
+    }
+    h.browser.load(paused)
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.browser.getPlayback().state).toBe('ready')
+  })
+})

package/src/web/__tests__/retry.test.ts

@@ -0,0 +1,169 @@
+/** @vitest-environment happy-dom */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { Track } from '../../types'
+import { LifecycleHarness } from './lifecycleHarness'
+
+/**
+ * `retry()` after a failure, and `play()` from the error state — which on
+ * Android are the same operation.
+ *
+ * `retry()` is `player.prepare()` there; `play()` is `playWhenReady = true`
+ * followed by the same `prepare()`, which early-returns unless ExoPlayer is
+ * STATE_IDLE. iOS's `retry()` is `reloadResolving(startFromCurrentTime: true)`,
+ * with the reason in its own comment: "short-lived URLs/tokens may have expired
+ * since the failure".
+ *
+ * Web used to call `shaka.Player.retryStreaming()`, which returns false and
+ * does nothing unless the load mode is MEDIA_SOURCE — so for a progressive
+ * file, the case a signed URL exists for, `retry()` was a silent no-op.
+ *
+ * The point of these tests is the re-resolution: the resolver hands back a
+ * different URL each call, so a retry that replays the cached one is visible as
+ * a stale URL reaching the player.
+ */
+
+let h: LifecycleHarness
+
+/** Its `src` is the unsigned path; the resolver signs it freshly each call. */
+const signed: Track = { id: 'signed', title: 'Signed', src: '/stream/7' }
+
+/** A media resolver that mints a new URL every time it runs. */
+function freshlySigning(): {
+  media: { resolve: () => Promise<{ path: string }> }
+} {
+  let issued = 0
+  return {
+    media: {
+      resolve: () => {
+        issued += 1
+        return Promise.resolve({
+          path: `https://cdn.example.com/${issued}.mp3`
+        })
+      }
+    }
+  }
+}
+
+beforeEach(async () => {
+  h = new LifecycleHarness()
+  await h.setup()
+})
+
+describe('retry re-resolves', () => {
+  it('hands the player a freshly resolved url, not the one that failed', async () => {
+    h.browser.configuration = freshlySigning()
+
+    h.failLoad()
+    h.browser.load(signed)
+    await h.flush()
+    expect(h.loadedUrls).toEqual(['https://cdn.example.com/1.mp3'])
+    expect(h.browser.getPlayback().state).toBe('error')
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+
+    // the retry resolved again rather than replaying the expired url
+    expect(h.loadedUrls).toEqual([
+      'https://cdn.example.com/1.mp3',
+      'https://cdn.example.com/2.mp3'
+    ])
+  })
+
+  it('play() from the error state re-resolves the same way', async () => {
+    h.browser.configuration = freshlySigning()
+
+    h.failLoad()
+    h.browser.load(signed)
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.play()
+    await h.flush()
+
+    expect(h.loadedUrls[1]).toBe('https://cdn.example.com/2.mp3')
+    // play() also sets the intent; retry() does not
+    expect(h.browser.getPlayWhenReady()).toBe(true)
+  })
+
+  it('retry() does not set the play intent', async () => {
+    h.failLoad()
+    h.browser.load({ id: 'a', title: 'A', src: 'https://x.example.com/a.mp3' })
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.browser.getPlayWhenReady()).toBe(false)
+  })
+
+  it('is a no-op on a healthy player, as ExoPlayer.prepare() is', async () => {
+    h.browser.load({ id: 'a', title: 'A', src: 'https://x.example.com/a.mp3' })
+    await h.flush()
+    await h.completeLoad()
+    const before = h.loadedUrls.length
+
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.loadedUrls.length).toBe(before)
+  })
+
+  it('does nothing without a current track', async () => {
+    h.browser.retry()
+    await h.flush()
+
+    expect(h.loadedUrls).toEqual([])
+  })
+})
+
+describe('retry resumes position', () => {
+  it('resumes from where playback failed', async () => {
+    const track: Track = {
+      id: 'a',
+      title: 'A',
+      src: 'https://x.example.com/a.mp3'
+    }
+    h.browser.load(track)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(42)
+    h.failLoad()
+    h.raiseError()
+    await h.flush()
+
+    h.succeedLoads()
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    expect(h.currentTime).toBe(42)
+  })
+
+  it('does not resume a live stream — a fresh connection is the live edge', async () => {
+    const live: Track = {
+      id: 'live',
+      title: 'Live',
+      src: 'https://x.example.com/live.mp3',
+      live: true
+    }
+    h.browser.load(live)
+    await h.flush()
+    await h.completeLoad()
+
+    h.setPosition(3600)
+    h.raiseError()
+    await h.flush()
+
+    h.browser.retry()
+    await h.flush()
+    await h.completeLoad()
+
+    // seeking to an hour into a connection that no longer exists asks for a
+    // point the new stream does not have
+    expect(h.currentTime).toBe(0)
+  })
+})

package/src/web/browser/BrowserManager.ts

@@ -403,10 +403,13 @@ export class BrowserManager {
   private async transformArtworkForContent(
     content: ResolvedTrack
   ): Promise<ResolvedTrack> {
+    // No short-circuit on a missing artwork config: Android gates per *track*
+    // (`artworkConfig == null && track.artwork == null`), so a track carrying a
+    // plain `artwork` URL still gets an `artworkSource`. Returning early here
+    // meant an app with no `artwork` block never populated the field at all —
+    // `resolveArtworkSourceAsync` already handles the no-config case the way
+    // `resolveArtworkUrl` does on Android.
     const artworkConfig = this._configuration.artwork
-    if (!artworkConfig) {
-      return content
-    }
     // The shared request layer applies to artwork too — use the resolved layer
     // (resolver result or static config) so a resolver-only config still works.
     await this.ensureLayersResolved()
@@ -526,6 +529,24 @@ export class BrowserManager {
     return undefined
   }
 
+  /**
+   * Ensures the request layer is resolved for the current generation and
+   * returns it — the resolver's result when a `requestResolver` is configured,
+   * else the static `request`.
+   *
+   * Consumers outside the browse path (media URL building, artwork) must reach
+   * the request layer through this rather than reading `configuration.request`,
+   * or a resolver-only config silently loses its baseUrl, headers and transform
+   * exactly where a credential is needed. Mirrors Android's
+   * `BrowserManager.resolvedRequestConfig()`, which carries the same warning.
+   */
+  async resolvedRequestConfig(): Promise<
+    TransformableRequestConfig | undefined
+  > {
+    await this.ensureLayersResolved()
+    return this._resolvedRequest
+  }
+
   /**
    * Ensures the request/browse layer configs are resolved for the current
    * generation. Any present resolver is invoked once per generation and the
@@ -723,8 +744,9 @@ export class BrowserManager {
 
     // Transform artwork URLs on tabs via the async resolver so the shared
     // request layer (incl. its transform) applies, matching content/search.
+    // Gated per track inside the resolver, as on Android — see
+    // `transformArtworkForContent`.
     const artworkConfig = this._configuration.artwork
-    if (!artworkConfig) return tabs
     // Resolved request layer (resolver or static), matching content/search.
     await this.ensureLayersResolved()
     const requestConfig = this._resolvedRequest

package/src/web/browser/SearchManager.ts

@@ -57,24 +57,24 @@ export class SearchManager {
     }
 
     // Transform artwork URLs on search results using async method with full Track access
+    // Gated per track inside the resolver, as on Android — a result carrying a
+    // plain `artwork` URL resolves even with no `artwork` config.
     const { request: requestConfig, artwork: artworkConfig } =
       this.browserManager.configuration
-    if (artworkConfig) {
-      results = await Promise.all(
-        results.map(async (track) => {
-          const artworkSource =
-            await RequestConfigBuilder.resolveArtworkSourceAsync(
-              track,
-              requestConfig,
-              artworkConfig
-            )
-          if (artworkSource && !track.artworkSource) {
-            return { ...track, artworkSource }
-          }
-          return track
-        })
-      )
-    }
+    results = await Promise.all(
+      results.map(async (track) => {
+        const artworkSource =
+          await RequestConfigBuilder.resolveArtworkSourceAsync(
+            track,
+            requestConfig,
+            artworkConfig
+          )
+        if (artworkSource && !track.artworkSource) {
+          return { ...track, artworkSource }
+        }
+        return track
+      })
+    )
 
     return results
   }