react-native-audio-browser 0.2.0-next.37 → 0.2.0-next.39

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -389,9 +389,9 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
389
389
  * bridge: it runs on ExoPlayer's IO thread (TransformingDataSource.open), so blocking here is
390
390
  * safe and intentional.
391
391
  */
392
- fun getMediaRequestConfig(originalUrl: String): MediaRequestConfig? {
392
+ fun getMediaRequestConfig(originalUrl: String, track: Track): MediaRequestConfig? {
393
393
  return try {
394
- runBlocking { browserManager.resolveMediaUrl(originalUrl) }
394
+ runBlocking { browserManager.resolveMediaUrl(originalUrl, track) }
395
395
  } catch (e: Exception) {
396
396
  Timber.e(e, "Failed to transform media URL: $originalUrl")
397
397
  null
@@ -319,10 +319,7 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
319
319
  override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession {
320
320
  Timber.d("onGetSession requested by: ${controllerInfo.packageName}")
321
321
 
322
- // The player is always set up by onCreate. Don't re-run setup() here for controllers that
323
- // connect before React Native does: setup() releases and recreates the ExoPlayer, which would
324
- // kill in-progress playback (e.g. playback resumption from a car/Bluetooth controller) when a
325
- // second controller connects while JS is still booting.
322
+ // No setup() here: default options would replace the ones setupPlayer applied.
326
323
  if (player.getCallbacks() == null) {
327
324
  Timber.w("External controller connecting before React Native setup - using default options")
328
325
  }
@@ -20,11 +20,11 @@ import timber.log.Timber
20
20
  */
21
21
 
22
22
  /**
23
- * Builds the media request config for [originalUrl]. Returns null only when neither a request layer
24
- * nor a media config is set (the caller then uses the original URL as-is). Mirrors the web stub's
25
- * and iOS's `resolveMediaUrl`.
23
+ * Builds the media request config for [originalUrl], [track]'s src, with `media.resolve` run for
24
+ * [track]. Returns null only when neither a request layer nor a media config is set (the caller
25
+ * then uses the original URL as-is). Mirrors the web stub's and iOS's `resolveMediaUrl`.
26
26
  */
27
- suspend fun BrowserManager.resolveMediaUrl(originalUrl: String): MediaRequestConfig? {
27
+ suspend fun BrowserManager.resolveMediaUrl(originalUrl: String, track: Track): MediaRequestConfig? {
28
28
  val mediaConfig = config.media
29
29
  // The request layer counts as present when a static `request` OR a `requestResolver`
30
30
  // is set — a resolver-only consumer still needs its baseUrl/headers/transform
@@ -67,16 +67,6 @@ suspend fun BrowserManager.resolveMediaUrl(originalUrl: String): MediaRequestCon
67
67
  userAgent = base.userAgent,
68
68
  )
69
69
  }
70
- // Final, most-specific layer: media.resolve(track). The cached Track carries any
71
- // per-track `request` override (e.g. a strict-UA sentinel); resolve reads it and
72
- // returns the winning config. Only look up the track when a resolve callback
73
- // exists, to avoid a needless cache lookup (and its miss-log) otherwise — async
74
- // OR sync (the old code checked only `resolve`, silently breaking
75
- // resolveSync-only consumers).
76
- val track =
77
- if (mediaConfig?.resolve != null || mediaConfig?.resolveSync != null) {
78
- getCachedTrack(originalUrl)
79
- } else null
80
70
  return RequestConfigBuilder.applyMediaResolve(mediaLayered, track)
81
71
  }
82
72
 
@@ -153,12 +153,11 @@ object RequestConfigBuilder {
153
153
  * per-track `request` override (e.g. a strict-UA sentinel the consumer swaps for a clean
154
154
  * User-Agent) — and returns the config whose fields win.
155
155
  *
156
- * No-op when the media config has no `resolve` callback or no track is available (so the
157
- * request/media layers stand). The callback may return its config synchronously (variant `first`)
158
- * or via a Promise (`second`). Mirrors iOS resolveMediaTrackConfig + applyMediaResolveLayer.
156
+ * No-op when the media config has no `resolve` callback (so the request/media layers stand). The
157
+ * callback may return its config synchronously (variant `first`) or via a Promise (`second`).
158
+ * Mirrors iOS resolveMediaTrackConfig + applyMediaResolveLayer.
159
159
  */
160
- suspend fun applyMediaResolve(layered: MediaRequestConfig, track: Track?): MediaRequestConfig {
161
- if (track == null) return layered
160
+ suspend fun applyMediaResolve(layered: MediaRequestConfig, track: Track): MediaRequestConfig {
162
161
  if (layered.resolve == null && layered.resolveSync == null) return layered
163
162
  val resolved: RequestConfig =
164
163
  try {
@@ -70,6 +70,13 @@ data class PlayerSetupOptions(
70
70
  val automaticBuffer: Boolean
71
71
  get() = rebufferBuffer == null
72
72
 
73
+ /**
74
+ * A copy that equals another's when both build the same engine: without the now-playing options,
75
+ * which apply without a rebuild. A formatter is a new object on every setup call.
76
+ */
77
+ fun engineOptions() =
78
+ copy(autoUpdateNowPlayingMetadata = true, nowPlayingMetadataFormatter = null)
79
+
73
80
  fun update(options: NativeSetupPlayerOptions) {
74
81
  // Android-specific options
75
82
  options.android?.let { android ->
@@ -0,0 +1,63 @@
1
+ package com.audiobrowser.player
2
+
3
+ import androidx.media3.common.C
4
+ import androidx.media3.common.MediaItem
5
+ import androidx.media3.common.PlaybackParameters
6
+ import androidx.media3.common.Player as MediaPlayer
7
+ import androidx.media3.exoplayer.ExoPlayer
8
+ import androidx.media3.exoplayer.source.ShuffleOrder
9
+
10
+ /**
11
+ * What an engine is playing, and how: what [Player.setup] carries from the engine it releases to
12
+ * the one it builds, so new setup options don't stop playback.
13
+ */
14
+ internal data class EnginePlayback(
15
+ val mediaItems: List<MediaItem>,
16
+ val index: Int,
17
+ /**
18
+ * [C.TIME_UNSET] for a live item, which resumes at the live edge, and for 0, which is also how a
19
+ * live item reads before it has loaded.
20
+ */
21
+ val positionMs: Long,
22
+ val prepared: Boolean,
23
+ val playWhenReady: Boolean,
24
+ val repeatMode: Int,
25
+ val shuffleModeEnabled: Boolean,
26
+ val shuffleOrder: ShuffleOrder,
27
+ val playbackParameters: PlaybackParameters,
28
+ val volume: Float,
29
+ val skipSilenceEnabled: Boolean,
30
+ ) {
31
+ fun restoreTo(exoPlayer: ExoPlayer) {
32
+ exoPlayer.repeatMode = repeatMode
33
+ exoPlayer.shuffleModeEnabled = shuffleModeEnabled
34
+ exoPlayer.playbackParameters = playbackParameters
35
+ exoPlayer.volume = volume
36
+ exoPlayer.skipSilenceEnabled = skipSilenceEnabled
37
+ if (mediaItems.isNotEmpty()) {
38
+ exoPlayer.setMediaItems(mediaItems, index, positionMs)
39
+ exoPlayer.setShuffleOrder(shuffleOrder)
40
+ if (prepared) exoPlayer.prepare()
41
+ }
42
+ exoPlayer.playWhenReady = playWhenReady
43
+ }
44
+
45
+ companion object {
46
+ fun of(exoPlayer: ExoPlayer) =
47
+ EnginePlayback(
48
+ mediaItems = (0 until exoPlayer.mediaItemCount).map { exoPlayer.getMediaItemAt(it) },
49
+ index = exoPlayer.currentMediaItemIndex,
50
+ positionMs =
51
+ exoPlayer.currentPosition.takeUnless { exoPlayer.isCurrentMediaItemLive || it == 0L }
52
+ ?: C.TIME_UNSET,
53
+ prepared = exoPlayer.playbackState != MediaPlayer.STATE_IDLE,
54
+ playWhenReady = exoPlayer.playWhenReady,
55
+ repeatMode = exoPlayer.repeatMode,
56
+ shuffleModeEnabled = exoPlayer.shuffleModeEnabled,
57
+ shuffleOrder = exoPlayer.shuffleOrder,
58
+ playbackParameters = exoPlayer.playbackParameters,
59
+ volume = exoPlayer.volume,
60
+ skipSilenceEnabled = exoPlayer.skipSilenceEnabled,
61
+ )
62
+ }
63
+ }
@@ -14,7 +14,9 @@ import androidx.media3.exoplayer.source.MediaSource
14
14
  import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
15
15
  import androidx.media3.extractor.DefaultExtractorsFactory
16
16
  import com.audiobrowser.model.RetryPolicy
17
+ import com.audiobrowser.util.TrackFactory
17
18
  import com.margelo.nitro.audiobrowser.MediaRequestConfig
19
+ import com.margelo.nitro.audiobrowser.Track
18
20
  import java.io.IOException
19
21
  import java.util.concurrent.TimeUnit
20
22
  import okhttp3.OkHttpClient
@@ -28,7 +30,7 @@ class MediaFactory(
28
30
  private val hasPlayed: () -> Boolean = { false },
29
31
  private val onRetryPending: ((exception: IOException, isNetworkError: Boolean) -> Unit)? = null,
30
32
  private val transferListener: TransferListener? = null,
31
- private val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
33
+ private val getRequestConfig: (originalUrl: String, track: Track) -> MediaRequestConfig?,
32
34
  ) : MediaSource.Factory {
33
35
 
34
36
  companion object {
@@ -130,7 +132,9 @@ class MediaFactory(
130
132
  val baseFactory: DataSource.Factory = DefaultDataSource.Factory(context, httpFactory)
131
133
 
132
134
  // Wrap with TransformingDataSource to resolve URLs on the IO thread
133
- val transformingFactory = TransformingDataSource.Factory(baseFactory, getRequestConfig)
135
+ val track = TrackFactory.fromMedia3(mediaItem)
136
+ val transformingFactory =
137
+ TransformingDataSource.Factory(baseFactory) { url -> getRequestConfig(url, track) }
134
138
 
135
139
  // Configure data source factory with optional caching
136
140
  val dataSourceFactory =
@@ -381,20 +381,28 @@ class Player(internal val context: Context) {
381
381
  exoPlayer.skipSilenceEnabled = value
382
382
  }
383
383
 
384
+ private var engineOptions: PlayerSetupOptions? = null
385
+
384
386
  /**
385
- * Sets up or recreates the ExoPlayer with the provided setup options. This method can be called
386
- * multiple times to change setup options.
387
+ * Applies [setupOptions]: builds the ExoPlayer on the first call, and rebuilds it only when the
388
+ * engine options differ from the ones it was built with. A rebuild carries over the queue, the
389
+ * position and the play intent, so playback that has started goes on with the new engine.
387
390
  */
388
391
  fun setup(setupOptions: PlayerSetupOptions) {
389
- Timber.Forest.d("Setting up player with new options")
390
-
391
392
  nowPlaying.enabled = setupOptions.autoUpdateNowPlayingMetadata
392
393
  // Wrap the Nitro Func into a plain suspend call so the updater (and its tests) never touch
393
394
  // bridge types; the double-await depth is unchanged (invoke -> bridge Promise -> JS promise).
394
395
  nowPlaying.formatter =
395
396
  setupOptions.nowPlayingMetadataFormatter?.let { f -> { params -> f.invoke(params).await() } }
396
397
 
397
- val isInitialSetup = !::exoPlayer.isInitialized
398
+ val newEngineOptions = setupOptions.engineOptions()
399
+ if (newEngineOptions == engineOptions) {
400
+ Timber.Forest.d("Setup options unchanged: keeping the player")
401
+ return
402
+ }
403
+ Timber.Forest.d("Setting up player with new options")
404
+ val isInitialSetup = engineOptions == null
405
+ val carried = if (isInitialSetup) null else EnginePlayback.of(exoPlayer)
398
406
 
399
407
  if (!isInitialSetup) {
400
408
  forwardingPlayer.removeListener(playerListener)
@@ -437,19 +445,13 @@ class Player(internal val context: Context) {
437
445
  }
438
446
  reportRetryingError(exception)
439
447
  },
440
- resolveMediaConfig = { url -> browser?.getMediaRequestConfig(url) },
448
+ resolveMediaConfig = { url, track -> browser?.getMediaRequestConfig(url, track) },
441
449
  )
442
450
  loadControl = engine.loadControl
443
451
  mediaFactory = engine.mediaFactory
444
452
  exoPlayer = engine.exoPlayer
445
-
446
- // A rebuilt engine starts paused and fires no change event — sync the
447
- // eager cache and tell JS, or the stale true sticks (and the emit dedupe
448
- // would swallow the next real rise).
449
- if (!isInitialSetup) {
450
- playWhenReadyCache = false
451
- emitPlayWhenReadyChanged(false)
452
- }
453
+ // Before the listener and the session are attached, so neither hears the playback replayed.
454
+ carried?.restoreTo(exoPlayer)
453
455
 
454
456
  // Recreate forwarding player with new ExoPlayer
455
457
  forwardingPlayer =
@@ -478,11 +480,20 @@ class Player(internal val context: Context) {
478
480
  mediaSession.player = forwardingPlayer
479
481
  }
480
482
 
481
- setPlaybackState(PlaybackState.NONE)
483
+ // No listener heard the restore; its prepare() leaves the engine buffering.
484
+ setPlaybackState(
485
+ if (exoPlayer.playbackState == ExoPlayer.STATE_IDLE) PlaybackState.NONE
486
+ else PlaybackState.BUFFERING
487
+ )
488
+ // The new engine can refuse the carried intent (audio focus denied) without a change event:
489
+ // sync the eager cache and tell JS, or a stale true sticks.
490
+ playWhenReadyCache = exoPlayer.playWhenReady
491
+ emitPlayWhenReadyChanged(exoPlayer.playWhenReady)
482
492
  }
483
493
 
484
494
  // Set up automatic buffer management if enabled
485
495
  setupAutomaticBufferManager(setupOptions.automaticBuffer)
496
+ engineOptions = newEngineOptions
486
497
  }
487
498
 
488
499
  /** Sets up or tears down the automatic buffer manager based on the enabled flag. */
@@ -12,6 +12,7 @@ import com.audiobrowser.model.PlayerSetupOptions
12
12
  import com.audiobrowser.util.AndroidAudioContentTypeFactory
13
13
  import com.margelo.nitro.audiobrowser.AndroidPlayerWakeMode
14
14
  import com.margelo.nitro.audiobrowser.MediaRequestConfig
15
+ import com.margelo.nitro.audiobrowser.Track
15
16
  import java.io.IOException
16
17
 
17
18
  // media3's configurable stuck-buffering (type-1, STUCK_BUFFERING_NO_PROGRESS) timeout. Fires only
@@ -55,7 +56,7 @@ internal fun buildPlayerEngine(
55
56
  isOnline: () -> Boolean,
56
57
  hasPlayed: () -> Boolean,
57
58
  onRetryPending: (exception: IOException, isNetworkError: Boolean) -> Unit,
58
- resolveMediaConfig: (url: String) -> MediaRequestConfig?,
59
+ resolveMediaConfig: (url: String, track: Track) -> MediaRequestConfig?,
59
60
  ): PlayerEngine {
60
61
  val renderer = DefaultRenderersFactory(context)
61
62
  renderer.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
@@ -10,6 +10,7 @@ import com.margelo.nitro.audiobrowser.ImageShape
10
10
  import com.margelo.nitro.audiobrowser.ImageSource
11
11
  import com.margelo.nitro.audiobrowser.MediaRequestConfig
12
12
  import com.margelo.nitro.audiobrowser.NativeRouteEntry
13
+ import com.margelo.nitro.audiobrowser.RequestConfig
13
14
  import com.margelo.nitro.audiobrowser.ResolvedTrack
14
15
  import com.margelo.nitro.audiobrowser.Section
15
16
  import com.margelo.nitro.audiobrowser.SectionStyle
@@ -17,6 +18,7 @@ import com.margelo.nitro.audiobrowser.StyleDisplay
17
18
  import com.margelo.nitro.audiobrowser.Track
18
19
  import com.margelo.nitro.audiobrowser.TrackStyle
19
20
  import com.margelo.nitro.audiobrowser.TransformableRequestConfig
21
+ import com.margelo.nitro.core.Promise
20
22
 
21
23
  /**
22
24
  * Shared builders for Nitro structs, whose generated constructors require every field. Tests set
@@ -90,10 +92,11 @@ object TestFixtures {
90
92
  path: String? = null,
91
93
  query: Map<String, String>? = null,
92
94
  headers: Map<String, String>? = null,
95
+ resolveSync: ((Track) -> Promise<RequestConfig>)? = null,
93
96
  ) =
94
97
  MediaRequestConfig(
95
98
  resolve = null,
96
- resolveSync = null,
99
+ resolveSync = resolveSync,
97
100
  transform = null,
98
101
  transformSync = null,
99
102
  method = null,
@@ -6,6 +6,7 @@ import com.audiobrowser.TestFixtures.track
6
6
  import com.audiobrowser.TestFixtures.transformableConfig
7
7
  import com.margelo.nitro.audiobrowser.ImageContext
8
8
  import com.margelo.nitro.audiobrowser.ImageQueryParams
9
+ import com.margelo.nitro.audiobrowser.Track
9
10
  import kotlinx.coroutines.test.runTest
10
11
  import org.junit.Assert.assertEquals
11
12
  import org.junit.Assert.assertNull
@@ -31,13 +32,18 @@ class BrowserUrlResolutionTest {
31
32
  fun `resolveMediaUrl returns null when neither media nor request layer is configured`() =
32
33
  runTest {
33
34
  bm.config = BrowserConfig()
34
- assertNull(bm.resolveMediaUrl("https://cdn.example.com/a.mp3"))
35
+ assertNull(
36
+ bm.resolveMediaUrl(
37
+ "https://cdn.example.com/a.mp3",
38
+ track(src = "https://cdn.example.com/a.mp3"),
39
+ )
40
+ )
35
41
  }
36
42
 
37
43
  @Test
38
44
  fun `resolveMediaUrl applies the request layer to a relative src`() = runTest {
39
45
  bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
40
- val resolved = bm.resolveMediaUrl("/stream/123")
46
+ val resolved = bm.resolveMediaUrl("/stream/123", track(src = "/stream/123"))
41
47
  assertEquals("https://api.example.com", resolved?.baseUrl)
42
48
  assertEquals("/stream/123", resolved?.path)
43
49
  }
@@ -50,12 +56,33 @@ class BrowserUrlResolutionTest {
50
56
  media =
51
57
  mediaConfig(baseUrl = "https://media.example.com", headers = mapOf("x-token" to "abc")),
52
58
  )
53
- val resolved = bm.resolveMediaUrl("/stream/123")
59
+ val resolved = bm.resolveMediaUrl("/stream/123", track(src = "/stream/123"))
54
60
  assertEquals("https://media.example.com", resolved?.baseUrl)
55
61
  assertEquals("abc", resolved?.headers?.get("x-token"))
56
62
  assertEquals("/stream/123", resolved?.path)
57
63
  }
58
64
 
65
+ @Test
66
+ fun `resolveMediaUrl runs media resolveSync for the track it is given`() = runTest {
67
+ val resolvedFor = mutableListOf<Track>()
68
+ bm.config =
69
+ BrowserConfig(
70
+ media =
71
+ mediaConfig(
72
+ // Records the track and stops there: a Nitro Promise cannot be built off-device.
73
+ resolveSync = { track ->
74
+ resolvedFor.add(track)
75
+ throw IllegalStateException("recorded")
76
+ }
77
+ )
78
+ )
79
+ val queued = track(id = "queued", src = "https://cdn.example.com/queued.mp3")
80
+
81
+ bm.resolveMediaUrl("https://cdn.example.com/queued.mp3", queued)
82
+
83
+ assertEquals(listOf(queued), resolvedFor)
84
+ }
85
+
59
86
  @Test
60
87
  fun `resolveArtworkUrl returns original artwork untouched when no artwork config`() = runTest {
61
88
  bm.config = BrowserConfig()
@@ -0,0 +1,71 @@
1
+ package com.audiobrowser.player
2
+
3
+ import androidx.media3.common.C
4
+ import androidx.media3.exoplayer.analytics.PlayerId
5
+ import androidx.media3.exoplayer.source.MediaPeriod
6
+ import androidx.media3.exoplayer.source.MediaSource
7
+ import androidx.media3.exoplayer.upstream.DefaultAllocator
8
+ import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter
9
+ import com.audiobrowser.TestFixtures.track
10
+ import com.audiobrowser.model.RetryPolicy
11
+ import com.audiobrowser.util.TrackFactory
12
+ import com.margelo.nitro.audiobrowser.Track
13
+ import java.util.concurrent.LinkedBlockingQueue
14
+ import java.util.concurrent.TimeUnit
15
+ import org.junit.Assert.assertEquals
16
+ import org.junit.Test
17
+ import org.junit.runner.RunWith
18
+ import org.robolectric.RobolectricTestRunner
19
+ import org.robolectric.RuntimeEnvironment
20
+
21
+ @RunWith(RobolectricTestRunner::class)
22
+ class MediaFactoryTest {
23
+
24
+ @Test
25
+ fun `a queued track is handed to the media request config when its media url opens`() {
26
+ val context = RuntimeEnvironment.getApplication()
27
+ val requests = LinkedBlockingQueue<Pair<String, Track>>()
28
+ val factory =
29
+ MediaFactory(
30
+ context,
31
+ cache = null,
32
+ RetryPolicy.Default,
33
+ shouldRetry = { false },
34
+ getRequestConfig = { url, track ->
35
+ requests.add(url to track)
36
+ null
37
+ },
38
+ )
39
+ val queued = track(id = "queued", src = "http://127.0.0.1:9/queued.mp3")
40
+ val source = factory.createMediaSource(TrackFactory.toMedia3(queued))
41
+ source.prepareSource(
42
+ { _, _ -> },
43
+ PlayerId.UNSET,
44
+ DefaultBandwidthMeter.Builder(context).build(),
45
+ )
46
+ val period =
47
+ source.createPeriod(
48
+ MediaSource.MediaPeriodId(Any()),
49
+ DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE),
50
+ 0,
51
+ )
52
+ try {
53
+ period.prepare(
54
+ object : MediaPeriod.Callback {
55
+ override fun onPrepared(mediaPeriod: MediaPeriod) {}
56
+
57
+ override fun onContinueLoadingRequested(source: MediaPeriod) {}
58
+ },
59
+ 0,
60
+ )
61
+
62
+ val (url, track) =
63
+ checkNotNull(requests.poll(5, TimeUnit.SECONDS)) { "the media url never opened" }
64
+ assertEquals("http://127.0.0.1:9/queued.mp3", url)
65
+ assertEquals(queued, track)
66
+ } finally {
67
+ source.releasePeriod(period)
68
+ source.releaseSource { _, _ -> }
69
+ }
70
+ }
71
+ }
@@ -0,0 +1,92 @@
1
+ package com.audiobrowser.player
2
+
3
+ import androidx.media3.common.Player as MediaPlayer
4
+ import com.audiobrowser.Callbacks
5
+ import com.audiobrowser.TestFixtures
6
+ import com.audiobrowser.model.PlayerSetupOptions
7
+ import com.audiobrowser.util.TrackFactory
8
+ import com.margelo.nitro.audiobrowser.PlaybackState
9
+ import org.junit.After
10
+ import org.junit.Assert.assertEquals
11
+ import org.junit.Assert.assertNotSame
12
+ import org.junit.Assert.assertSame
13
+ import org.junit.Assert.assertTrue
14
+ import org.junit.Test
15
+ import org.junit.runner.RunWith
16
+ import org.mockito.Mockito.mock
17
+ import org.mockito.Mockito.mockingDetails
18
+ import org.robolectric.RobolectricTestRunner
19
+ import org.robolectric.RuntimeEnvironment
20
+
21
+ // Robolectric: Player builds a real ExoPlayer, which needs the framework and a main looper.
22
+ @RunWith(RobolectricTestRunner::class)
23
+ class PlayerSetupTest {
24
+
25
+ private val player = Player(RuntimeEnvironment.getApplication())
26
+
27
+ @After fun release() = player.exoPlayer.release()
28
+
29
+ /** Service.onCreate and AudioBrowser.onServiceConnected set up with the same options. */
30
+ @Test
31
+ fun setupWithTheSameOptionsKeepsTheEngine() {
32
+ player.setup(PlayerSetupOptions())
33
+ val engine = player.exoPlayer
34
+
35
+ player.setup(PlayerSetupOptions())
36
+ player.setup(PlayerSetupOptions(autoUpdateNowPlayingMetadata = false))
37
+
38
+ assertSame(engine, player.exoPlayer)
39
+ }
40
+
41
+ @Test
42
+ fun setupWithChangedOptionsRebuildsTheEngineAndKeepsPlaying() {
43
+ player.setup(PlayerSetupOptions())
44
+ val engine = player.exoPlayer
45
+ engine.setMediaItems(listOf(item("a"), item("b"), item("c")), 1, 5_000)
46
+ engine.repeatMode = MediaPlayer.REPEAT_MODE_ALL
47
+ engine.shuffleModeEnabled = true
48
+ engine.volume = 0.5f
49
+ engine.prepare()
50
+ engine.playWhenReady = true
51
+ player.setPlaybackState(PlaybackState.PLAYING)
52
+ val callbacks = mock(Callbacks::class.java)
53
+ player.setCallbacks(callbacks)
54
+
55
+ player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
56
+
57
+ val rebuilt = player.exoPlayer
58
+ assertNotSame(engine, rebuilt)
59
+ assertEquals(listOf("a", "b", "c"), player.tracks.map { it.title })
60
+ assertEquals(1, rebuilt.currentMediaItemIndex)
61
+ assertEquals(5_000, rebuilt.currentPosition)
62
+ assertEquals(MediaPlayer.REPEAT_MODE_ALL, rebuilt.repeatMode)
63
+ assertTrue(rebuilt.shuffleModeEnabled)
64
+ assertEquals(0.5f, rebuilt.volume)
65
+ assertTrue(rebuilt.playbackState != MediaPlayer.STATE_IDLE)
66
+ assertTrue(rebuilt.playWhenReady)
67
+ assertTrue(player.playWhenReadyCache)
68
+ assertEquals(PlaybackState.BUFFERING, player.playbackState)
69
+ assertEquals(
70
+ emptyList<String>(),
71
+ mockingDetails(callbacks)
72
+ .invocations
73
+ .map { it.method.name }
74
+ .filter { it == "onPlaybackActiveTrackChanged" },
75
+ )
76
+ }
77
+
78
+ @Test
79
+ fun setupWithChangedOptionsKeepsAnUnpreparedQueueStopped() {
80
+ player.setup(PlayerSetupOptions())
81
+ player.exoPlayer.setMediaItems(listOf(item("a")))
82
+
83
+ player.setup(PlayerSetupOptions(maxBuffer = 120_000.0))
84
+
85
+ assertEquals(listOf("a"), player.tracks.map { it.title })
86
+ assertEquals(MediaPlayer.STATE_IDLE, player.exoPlayer.playbackState)
87
+ assertEquals(PlaybackState.NONE, player.playbackState)
88
+ }
89
+
90
+ private fun item(title: String) =
91
+ TrackFactory.toMedia3(TestFixtures.track(title = title, src = "https://s/$title.mp3"))
92
+ }
@@ -460,7 +460,7 @@ class NativeAudioBrowser extends _TrackPlayer.QueuePlayer {
460
460
  * Resolves a media URL using the browser's media configuration.
461
461
  * Combines baseUrl with relative paths to create full URLs.
462
462
  * Supports the transform callback for URL manipulation.
463
- * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
463
+ * Mirrors Android's and iOS's `resolveMediaUrl`.
464
464
  */
465
465
  async resolveMediaRequest(src, track) {
466
466
  // The *resolved* request layer, not `configuration.request`: a
@@ -457,7 +457,7 @@ export class NativeAudioBrowser extends QueuePlayer {
457
457
  * Resolves a media URL using the browser's media configuration.
458
458
  * Combines baseUrl with relative paths to create full URLs.
459
459
  * Supports the transform callback for URL manipulation.
460
- * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
460
+ * Mirrors Android's and iOS's `resolveMediaUrl`.
461
461
  */
462
462
  async resolveMediaRequest(src, track) {
463
463
  // The *resolved* request layer, not `configuration.request`: a
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "react-native-audio-browser",
3
- "version": "0.2.0-next.37",
3
+ "version": "0.2.0-next.39",
4
4
  "description": "react-native-audio-browser is a react native package built with Nitro",
5
5
  "keywords": [
6
6
  "react-native",
@@ -621,7 +621,7 @@ export class NativeAudioBrowser
621
621
  * Resolves a media URL using the browser's media configuration.
622
622
  * Combines baseUrl with relative paths to create full URLs.
623
623
  * Supports the transform callback for URL manipulation.
624
- * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
624
+ * Mirrors Android's and iOS's `resolveMediaUrl`.
625
625
  */
626
626
  private async resolveMediaRequest(
627
627
  src: string,