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.
- package/android/src/main/java/com/audiobrowser/AudioBrowser.kt +2 -2
- package/android/src/main/java/com/audiobrowser/Service.kt +1 -4
- package/android/src/main/java/com/audiobrowser/browser/BrowserUrlResolution.kt +4 -14
- package/android/src/main/java/com/audiobrowser/http/RequestConfigBuilder.kt +4 -5
- package/android/src/main/java/com/audiobrowser/model/PlayerSetupOptions.kt +7 -0
- package/android/src/main/java/com/audiobrowser/player/EnginePlayback.kt +63 -0
- package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt +6 -2
- package/android/src/main/java/com/audiobrowser/player/Player.kt +26 -15
- package/android/src/main/java/com/audiobrowser/player/PlayerEngineFactory.kt +2 -1
- package/android/src/test/java/com/audiobrowser/TestFixtures.kt +4 -1
- package/android/src/test/java/com/audiobrowser/browser/BrowserUrlResolutionTest.kt +30 -3
- package/android/src/test/java/com/audiobrowser/player/MediaFactoryTest.kt +71 -0
- package/android/src/test/java/com/audiobrowser/player/PlayerSetupTest.kt +92 -0
- package/lib/commonjs/web/NativeAudioBrowser.js +1 -1
- package/lib/module/web/NativeAudioBrowser.js +1 -1
- package/package.json +1 -1
- package/src/web/NativeAudioBrowser.ts +1 -1
|
@@ -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
|
-
//
|
|
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]
|
|
24
|
-
*
|
|
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
|
|
157
|
-
*
|
|
158
|
-
*
|
|
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
|
|
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
|
|
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
|
-
*
|
|
386
|
-
*
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
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(
|
|
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
|
|
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
|
|
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
|
@@ -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
|
|
624
|
+
* Mirrors Android's and iOS's `resolveMediaUrl`.
|
|
625
625
|
*/
|
|
626
626
|
private async resolveMediaRequest(
|
|
627
627
|
src: string,
|