Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

feat: improve playback resilience and provider compatibility

David Nashasha313c6a0bbb1
diff --git a/.gitignore b/.gitignore
index c2b98ee0..a7f83127 100644
--- a/.gitignore
+++ b/.gitignore
@@ -44,6 +44,7 @@ domain/bin/
.pi/
.kotlin/
hs_err_pid*.log
+replay_pid*.log
gradle_build.log
ksp.log
__pycache__/
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index dc33909f..220f0497 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -541,6 +541,7 @@ dependencies {
androidTestImplementation(libs.espresso.core)
androidTestImplementation(libs.uiautomator)
androidTestImplementation(libs.truth)
+ androidTestImplementation(libs.datastore.preferences)
}
tasks.configureEach {
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/AdaptiveFallbackRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/AdaptiveFallbackRuntimeTest.kt
new file mode 100644
index 00000000..f5bd87c8
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/AdaptiveFallbackRuntimeTest.kt
@@ -0,0 +1,425 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlayerError
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI validation using an isolated provider and private local media. */
+@RunWith(AndroidJUnit4::class)
+class AdaptiveFallbackRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "adaptive-fallback-fixture-private.json")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("adaptiveFallbackFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "adaptive-fallback-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "adaptive-fallback-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("V4 ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ // Movie facts can put either Play or Resume below the visible TV viewport.
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 2_000) else null)
+ ?: error("Missing UI: $text")
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+ private fun dismissFixtureResumePrompt() {
+ if (compose.onAllNodes(hasText("Start Over")).fetchSemanticsNodes().size == 1) {
+ compose.onNodeWithText("Start Over").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ }
+ private fun engineFailure(engine: PlayerEngine): androidx.media3.common.PlaybackException? {
+ var failure: androidx.media3.common.PlaybackException? = null
+ instrumentation.runOnMainSync {
+ val player=engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible=true }.get(engine) as? ExoPlayer
+ failure=player?.playerError
+ }
+ return failure
+ }
+ private fun control(query: String) = java.net.URL("http://10.0.2.2:18784/control?$query").readText()
+
+ @Test fun provisionIsolatedMovies() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val original = providers.getActiveProvider().first()?.id ?: error("Fixture requires an existing active provider")
+ val last = prefs.lastActiveProviderId.first() ?: error("Fixture requires an existing last provider")
+ val restore = File(app.filesDir, "adaptive-fallback-restore.json")
+ if (!setup.exists()) {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val saved = store.data.first()[stringPreferencesKey("vod_variant_observations")]
+ restore.writeText(JSONObject().put("vod_variant_observations", saved ?: JSONObject.NULL).toString())
+ }
+ check(restore.exists()) { "Original fixture preference snapshot required" }
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(LegacyProvider(name = "V4 UI validation 20261006", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18784", username = "validation", password = "validation", maxConnections = 5,
+ isActive = false, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "V4 UI validation 20261006")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", original).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val categories = withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ for (category in categories) movies.getMoviesByCategory(id, category.id).first()
+ // Refresh/import is asynchronous: an existing catalogue can still have three stale rows.
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { candidates ->
+ candidates.size == 3 && candidates.all { movie ->
+ val hydrated = movies.getMovieDetails(id, movie.id).getOrNull()
+ val resolved = hydrated?.let { movies.getStreamInfo(it).getOrNull() }
+ resolved?.expirationTime?.let { it > System.currentTimeMillis() + 3_600_000 } == true
+ }
+ }
+ }
+ check(rows.all { it.name.startsWith("V4 ") })
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ val remaining = rows.map { movies.getStreamInfo(it).getOrNull()!!.expirationTime!! - System.currentTimeMillis() }
+ Log.i("AdaptiveFallbackFixture", "provisioned provider=$id movies=${rows.size} minimumResolvedLifetimeMs=${remaining.min()}")
+ Unit
+ }
+
+ @Test fun cleanupOnlyIsolatedMovies() = runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ check(providers.getProvider(id)?.name == "V4 UI validation 20261006")
+ check(providers.deleteProvider(id).isSuccess)
+ check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val restore = File(app.filesDir, "adaptive-fallback-restore.json")
+ val saved = JSONObject(restore.readText())
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ val key = stringPreferencesKey("vod_variant_observations")
+ if (saved.isNull(key.name)) current.remove(key) else current[key] = saved.getString(key.name)
+ }
+ check(restore.delete())
+ check(setup.delete())
+ for (case in listOf("server", "unknown", "auth", "auth403", "limit", "drm-valid", "drm-invalid")) {
+ for (suffix in listOf(".json", "-session.txt", ".png")) File(app.filesDir, "adaptive-fallback-$case$suffix").delete()
+ }
+ for (name in listOf("adaptive-fallback-driver.png", "adaptive-fallback-driver.xml", "adaptive-fallback-expired-retry.png")) File(app.filesDir, name).delete()
+ }
+
+
+ @Test fun brokenRepresentationThroughMoviesUi() {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("adaptiveFallbackCase") ?: "server"
+ val code = when(case) { "server" -> 503; "unknown" -> 410; "auth" -> 401; "auth403" -> 403; "limit" -> 509; else -> error("Unsupported case") }
+ val eligible = case in setOf("server", "unknown")
+ control("reset=1")
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ click("Movies"); click("V4 Adaptive UI Fixture"); click("Play")
+ lateinit var vm: PlayerViewModel
+ await("normal player context") { var found=false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm=it; found=true } }; found }
+ await("first frame") {
+ dismissFixtureResumePrompt()
+ engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.playerStats.value.ttffMs > 0
+ }
+ await("normal player overlays gone") { dismissFixtureResumePrompt(); !vm.resumePrompt.value.show && device.findObject(By.textContains("Resolving playback")) == null }
+ val title = getter(vm,"getCurrentTitle")
+ val url = getter(vm,"getCurrentStreamUrl")
+ check(engine.availableVideoTracks.value.any { it.id == com.streamvault.player.PLAYER_TRACK_AUTO_ID && it.isSelected }) {
+ "V4 requires existing Auto selection; do not override a saved manual selection"
+ }
+ val errors = JSONArray()
+ val statsListener = androidx.media3.exoplayer.analytics.PlaybackStatsListener(true, null)
+ instrumentation.runOnMainSync {
+ val player=engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible=true }.get(engine) as ExoPlayer
+ player.addAnalyticsListener(statsListener)
+ player.addAnalyticsListener(object: androidx.media3.exoplayer.analytics.AnalyticsListener {
+ override fun onLoadError(eventTime: androidx.media3.exoplayer.analytics.AnalyticsListener.EventTime,
+ loadEventInfo: androidx.media3.exoplayer.source.LoadEventInfo,
+ mediaLoadData: androidx.media3.exoplayer.source.MediaLoadData,
+ error: java.io.IOException, wasCanceled: Boolean) {
+ errors.put(JSONObject().put("category",com.streamvault.player.playback.PlayerErrorClassifier.classify(error).name)
+ .put("httpStatus",(error as? androidx.media3.datasource.HttpDataSource.InvalidResponseCodeException)?.responseCode)
+ .put("requestedTrackId",mediaLoadData.trackFormat?.id).put("requestedHeight",mediaLoadData.trackFormat?.height)
+ .put("rendition",loadEventInfo.uri.path?.substringBeforeLast('/'))
+ .put("selectedHeight",player.videoFormat?.height).put("canceled",wasCanceled))
+ }
+ })
+ }
+ val samples=JSONArray()
+ val began=SystemClock.elapsedRealtime()
+ var failedHeight=0
+ var failedAt=0L
+ var alternate=false
+ var terminalAt=0L
+ Log.i("AdaptiveFallbackFixture","capture-ready case=$case")
+ while(SystemClock.elapsedRealtime()-began < if(eligible) 130_000 else 90_000) {
+ compose.waitForIdle()
+ val elapsed=SystemClock.elapsedRealtime()-began
+ val height=engine.videoFormat.value.height
+ if(failedHeight==0 && elapsed>=15_000) {
+ check(height in setOf(720,1080))
+ failedHeight=height; failedAt=elapsed
+ control("fail=${if(height==1080) "hd" else "sd"}&code=$code")
+ Log.i("AdaptiveFallbackFixture","fault case=$case selectedHeight=$height status=$code elapsedMs=$elapsed")
+ }
+ if(failedHeight>0 && errors.length()>0 && height>0 && height!=failedHeight && engine.playbackState.value==PlaybackState.READY) alternate=true
+ val failure=engineFailure(engine)
+ if(failure!=null && !engine.isPlaying.value && terminalAt==0L) terminalAt=elapsed
+ val sample=JSONObject().put("elapsedMs",elapsed).put("positionMs",engine.currentPosition.value)
+ .put("state",engine.playbackState.value.name).put("height",height).put("bufferMs",engine.playerStats.value.bufferedDurationMs)
+ .put("rebuffers",engine.playerStats.value.rebufferCount)
+ .put("terminalErrorCode",failure?.errorCodeName)
+ .put("terminalCategory",failure?.let { com.streamvault.player.playback.PlayerErrorClassifier.classify(it).name })
+ .put("qualityAuto",engine.availableVideoTracks.value.any { it.id == com.streamvault.player.PLAYER_TRACK_AUTO_ID && it.isSelected })
+ instrumentation.runOnMainSync {
+ val player=engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible=true }.get(engine) as ExoPlayer
+ sample.put("trackId",player.videoFormat?.id).put("bitrate",player.videoFormat?.bitrate)
+ sample.put("renderedBuffers",player.videoDecoderCounters?.renderedOutputBufferCount)
+ val selected = JSONArray()
+ for (group in player.currentTracks.groups.filter { it.type == androidx.media3.common.C.TRACK_TYPE_VIDEO }) {
+ for (index in 0 until group.length) if (group.isTrackSelected(index)) {
+ val format=group.getTrackFormat(index)
+ selected.put(JSONObject().put("id",format.id).put("height",format.height).put("bitrate",format.bitrate))
+ }
+ }
+ sample.put("selectedRepresentations",selected)
+ }
+ samples.put(sample)
+ val stats=statsListener.combinedPlaybackStats
+ val logs=device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ val prepares=logs.lineSequence().count { "prepare resolvedStreamType=HLS" in it }
+ val report=JSONObject().put("case",case).put("failedHeight",failedHeight).put("faultElapsedMs",failedAt)
+ .put("alternate",alternate).put("terminalElapsedMs",terminalAt).put("prepareCount",prepares)
+ .put("samples",samples).put("loadErrors",errors).put("rebufferCountAfterFirstFrame",stats.totalRebufferCount)
+ .put("rebufferDurationMsAfterFirstFrame",stats.totalRebufferTimeMs).put("maxRebufferMs",stats.maxRebufferTimeMs)
+ File(app.filesDir,"adaptive-fallback-$case.json").writeText(report.toString())
+ if(eligible) check(engine.playbackState.value!=PlaybackState.ERROR) { "Eligible fallback became terminal" }
+ if(!eligible && terminalAt>0 && elapsed-terminalAt>=15_000) break
+ SystemClock.sleep(500)
+ }
+ assertThat(errors.length()).isGreaterThan(0)
+ assertThat(getter(vm,"getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm,"getCurrentStreamUrl")).isEqualTo(url)
+ File(app.filesDir,"adaptive-fallback-$case-session.txt").writeText(device.executeShellCommand("dumpsys media_session"))
+ val logs=device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=HLS" in it }).isEqualTo(1)
+ if(eligible) { assertThat(alternate).isTrue(); assertThat(engine.playbackState.value).isEqualTo(PlaybackState.READY); assertThat(engine.isPlaying.value).isTrue() }
+ else {
+ assertThat(alternate).isFalse(); assertThat(engineFailure(engine)).isNotNull(); assertThat(engine.isPlaying.value).isFalse()
+ assertThat(com.streamvault.player.playback.PlayerErrorClassifier.classify(engineFailure(engine)!!).name)
+ .isEqualTo(if(case=="limit") "PROVIDER_LIMIT" else "HTTP_AUTH")
+ }
+ Log.i("AdaptiveFallbackFixture","complete case=$case alternate=$alternate terminalMs=$terminalAt prepares=1")
+ }
+
+ @Test fun provisionProtectedMovie() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val file = File(app.filesDir,"adaptive-fallback-drm-private.json")
+ check(!file.exists()) { "Protected fixture already provisioned" }
+ val original = providers.getActiveProvider().first()?.id ?: error("Active provider required")
+ val last = prefs.lastActiveProviderId.first() ?: original
+ val id = providers.addProvider(LegacyProvider(name="V4 protected UI validation 20261006",type=ProviderType.M3U,
+ serverUrl="http://10.0.2.2:18784",m3uUrl="http://10.0.2.2:18784/drm-playlist.m3u",
+ m3uVodClassificationEnabled=true,isActive=false)).getOrNull() ?: error("Protected provider creation failed")
+ file.writeText(JSONObject().put("id",id).put("active",original).put("last",last).toString())
+ check(providers.refreshProviderData(id,force=true).isSuccess)
+ val rows = withTimeout(60_000) { movies.getMovies(id).first { it.size==1 } }
+ check(rows.single().name=="V4 Protected Movie UI Fixture")
+ val source = movies.getStreamInfo(rows.single()).getOrNull() ?: error("DRM source unavailable")
+ check(source.drmInfo?.scheme==com.streamvault.domain.model.DrmScheme.CLEARKEY)
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ Log.i("AdaptiveFallbackFixture","protected-provisioned provider=$id drm=CLEARKEY")
+ Unit
+ }
+
+ @Test fun protectedMovieThroughNormalUi() {
+ enabled()
+ val mode=InstrumentationRegistry.getArguments().getString("adaptiveFallbackDrm") ?: "invalid"
+ check(mode in setOf("valid","invalid"))
+ control("reset=1&license=$mode")
+ val engine=component("provideMainPlayerEngineProvider") as PlayerEngine
+ click("Movies");click("V4 Protected Movie UI Fixture");click("Play")
+ lateinit var vm: PlayerViewModel
+ await("protected movie context") { var found=false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm=it;found=true } };found }
+ var terminalError: PlayerError? = null
+ if(mode=="valid") {
+ await("encrypted first frame") { dismissFixtureResumePrompt(); engine.isPlaying.value && engine.playbackState.value==PlaybackState.READY && engine.playerStats.value.ttffMs>0 }
+ assertThat(engine.videoFormat.value.height).isEqualTo(720)
+ } else {
+ terminalError = runBlocking {
+ withTimeout(45_000) {
+ engine.error.filterNotNull().filter { it is PlayerError.DrmError }.first()
+ }
+ }
+ }
+ val title=getter(vm,"getCurrentTitle");val url=getter(vm,"getCurrentStreamUrl")
+ val samples=JSONArray();val began=SystemClock.elapsedRealtime()
+ while(SystemClock.elapsedRealtime()-began<20_000) {
+ compose.waitForIdle()
+ val failure=engineFailure(engine)
+ samples.put(JSONObject().put("elapsedMs",SystemClock.elapsedRealtime()-began)
+ .put("state",engine.playbackState.value.name).put("height",engine.videoFormat.value.height)
+ .put("positionMs",engine.currentPosition.value).put("rebuffers",engine.playerStats.value.rebufferCount)
+ .put("terminalErrorCode",failure?.errorCodeName)
+ .put("terminalCategory",failure?.let { com.streamvault.player.playback.PlayerErrorClassifier.classify(it).name }))
+ File(app.filesDir,"adaptive-fallback-drm-$mode.json").writeText(samples.toString())
+ if(mode=="valid") check(engine.playbackState.value==PlaybackState.READY)
+ else if (terminalError is PlayerError.DrmError) {
+ // A terminal failure is sampled until the test ends; the player
+ // must not be allowed to drift into an alternate rendition.
+ check(!engine.isPlaying.value)
+ }
+ SystemClock.sleep(500)
+ }
+ assertThat(getter(vm,"getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm,"getCurrentStreamUrl")).isEqualTo(url)
+ File(app.filesDir,"adaptive-fallback-drm-$mode-session.txt").writeText(device.executeShellCommand("dumpsys media_session"))
+ val logs=device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=DASH" in it }).isEqualTo(1)
+ if(mode=="invalid") {
+ assertThat(logs).contains("fatal-error category=DRM")
+ assertThat(terminalError).isInstanceOf(PlayerError.DrmError::class.java)
+ }
+ device.takeScreenshot(File(app.filesDir,"adaptive-fallback-drm-$mode.png"))
+ Log.i("AdaptiveFallbackFixture","protected-complete mode=$mode prepares=1 state=${engine.playbackState.value}")
+ }
+
+ @Test fun cleanupProtectedMovie() = runBlocking {
+ enabled()
+ val file=File(app.filesDir,"adaptive-fallback-drm-private.json")
+ val saved=JSONObject(file.readText())
+ val providers=component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs=component("preferencesRepositoryProvider") as PreferencesRepository
+ check(providers.getProvider(saved.getLong("id"))?.name=="V4 protected UI validation 20261006")
+ check(providers.deleteProvider(saved.getLong("id")).isSuccess)
+ check(providers.setActiveProvider(saved.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(saved.getLong("last"))
+ check(file.delete())
+ }
+ @Test fun restoreOnlyFixtureCompatibilityLearning() {
+ enabled()
+ val file = File(app.filesDir, "adaptive-fallback-compatibility-private.json")
+ val changes = JSONArray(file.readText())
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ for (index in 0 until changes.length()) {
+ val change = changes.getJSONObject(index)
+ val expected = change.getJSONObject("expected")
+ val id = expected.getLong("id")
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id)).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) {
+ val actual = cursor.getString(cursor.getColumnIndexOrThrow(column))
+ check(actual == if (expected.isNull(column)) null else expected.get(column).toString())
+ }
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id))
+ if (!change.isNull("original")) {
+ val original = change.getJSONObject("original")
+ val columns = original.keys().asSequence().toList()
+ check(columns.all { it.matches(Regex("[a-z_]+")) })
+ database.execSQL("INSERT INTO playback_compatibility_records (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }})",
+ columns.map { if (original.isNull(it)) null else original.get(it).toString() }.toTypedArray())
+ }
+ }
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/CatchUpRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/CatchUpRuntimeTest.kt
new file mode 100644
index 00000000..5cd4d260
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/CatchUpRuntimeTest.kt
@@ -0,0 +1,402 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.hasScrollToIndexAction
+import androidx.compose.ui.test.hasClickAction
+import androidx.compose.ui.test.performScrollToIndex
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.ChannelRepository
+import com.streamvault.domain.repository.EpgRepository
+import com.streamvault.domain.model.Program
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal archive UI validation using an isolated provider and private local media. */
+@RunWith(AndroidJUnit4::class)
+class CatchUpRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "catch-up-fixture-private.json")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("catchUpFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "catch-up-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "catch-up-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("Progressive ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ // Movie facts can put either Play or Resume below the visible TV viewport.
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 2_000) else null)
+ ?: error("Missing UI: $text")
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+ private fun findPlayers(store: ViewModelStore): List<PlayerViewModel> {
+ val players = mutableListOf<PlayerViewModel>()
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) players.add(model)
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) players.addAll(findPlayers(nested))
+ }
+ }
+ return players.distinct()
+ }
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+ private fun control(fail: Boolean) = java.net.URL("http://10.0.2.2:18772/control?failBeta=$fail").readText()
+
+ @Suppress("UNCHECKED_CAST")
+ private fun store(prefs: PreferencesRepository): DataStore<Preferences> {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ return prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ }
+
+ @Test fun provisionIsolatedArchive() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val channels = component("channelRepositoryImplProvider") as ChannelRepository
+ val restore = File(app.filesDir, "catch-up-restore.json")
+ if (!setup.exists()) {
+ val original = store(prefs).data.first()
+ val saved = JSONObject()
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ saved.put(name, original[stringPreferencesKey(name)] ?: JSONObject.NULL)
+ }
+ restore.writeText(saved.toString())
+ }
+ check(restore.exists())
+ val active = providers.getActiveProvider().first()?.id ?: -1L
+ val last = prefs.lastActiveProviderId.first() ?: -1L
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else
+ providers.addProvider(LegacyProvider(name = "V2 Archive validation 20261003", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18772", username = "validation", password = "validation",
+ maxConnections = 5, allowedOutputFormats = listOf("m3u8"), preferredLiveStreamFormat = LiveStreamFormatMode.HLS,
+ isActive = false, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "V2 Archive validation 20261003")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", active).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.LIVE, force = true).isSuccess)
+ val rows = withTimeout(60_000) { channels.getChannels(id).first { it.size == 1 } }
+ check(rows.single().name == "V2 Archive Channel")
+ check(rows.single().catchUpSupported && rows.single().catchUpDays == 3)
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ Log.i("CatchUpFixture", "provisioned provider=$id channels=1")
+ Unit
+ }
+
+ private fun player(): PlayerViewModel {
+ lateinit var vm: PlayerViewModel
+ await("player context") {
+ var found = false
+ instrumentation.runOnMainSync {
+ val candidates = findPlayers(compose.activity.viewModelStore)
+ candidates.singleOrNull {
+ getter(it, "getCurrentTitle") == "V2 Archive Channel" &&
+ it.playerEngine.isPlaying.value && it.playerEngine.playbackState.value == PlaybackState.READY
+ }?.let { vm = it; found = true }
+ }
+ found
+ }
+ return vm
+ }
+
+ private fun openArchive(name: String): PlayerViewModel {
+ await("fixture channel row") {
+ compose.onAllNodesWithContentDescription("V2 Archive Channel", substring = true).fetchSemanticsNodes().isNotEmpty()
+ }
+ compose.onNodeWithContentDescription("V2 Archive Channel", substring = true)
+ .performSemanticsAction(SemanticsActions.OnClick) { it() }
+ SystemClock.sleep(800)
+ // Pro mode's first click previews; its second click uses the ordinary preview handoff.
+ if (compose.onAllNodesWithContentDescription("V2 Archive Channel", substring = true).fetchSemanticsNodes().isNotEmpty()) {
+ compose.onNodeWithContentDescription("V2 Archive Channel", substring = true)
+ .performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ val vm = player()
+ await("fixture guide") { vm.programHistory.value.count { it.title.startsWith("V2 Program ") } == 3 && vm.currentProgram.value?.title == "V2 Current Program" }
+ await("setup channel ready") { vm.playerEngine.isPlaying.value && vm.playerEngine.playbackState.value == PlaybackState.READY }
+ // LIVE center opens channel information; Menu opens the ordinary transport controls.
+ if (!vm.showControls.value) device.pressKeyCode(android.view.KeyEvent.KEYCODE_MENU)
+ await("live transport controls") { vm.showControls.value }
+ val archive = app.getString(com.streamvault.feature.playback.R.string.player_archive)
+ val archiveButton = hasText(archive) and hasClickAction()
+ if (compose.onAllNodes(archiveButton).fetchSemanticsNodes().isEmpty()) {
+ compose.onAllNodes(hasScrollToIndexAction())[0].performScrollToIndex(6)
+ }
+ await("archive control") { compose.onAllNodes(archiveButton).fetchSemanticsNodes().isNotEmpty() }
+ compose.onNode(archiveButton).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("archive picker") { compose.onAllNodes(hasText("V2 Program $name")).fetchSemanticsNodes().isNotEmpty() }
+ // The picker delays interaction on Compose's test clock, not the decoder's wall clock.
+ compose.mainClock.advanceTimeBy(650)
+ compose.waitForIdle()
+ compose.onNodeWithText("V2 Program $name").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("archive picker dismissed") {
+ compose.onAllNodes(hasText(app.getString(com.streamvault.feature.playback.R.string.player_archive_title))).fetchSemanticsNodes().isEmpty()
+ }
+ await("selected catch-up ready") {
+ val engine = vm.playerEngine
+ val source = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as? StreamInfo
+ source?.playbackContentKind == PlaybackContentKind.CATCH_UP &&
+ getter(vm, "getCurrentTitle") == "V2 Archive Channel: V2 Program $name" &&
+ engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.videoFormat.value.height == 720 && engine.playerStats.value.ttffMs > 0
+ }
+ val engine = vm.playerEngine
+ val physicalSource = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ // A CATCH_UP label alone is insufficient: the provider must retain the selected archive URL.
+ assertThat(physicalSource.url).isEqualTo(getter(vm, "getCurrentStreamUrl"))
+ assertThat(engine.currentPosition.value).isLessThan(15_000)
+ val context = getter(vm, "getPlayerPlaybackContextCoordinator")!!
+ val selected = getter(context, "getSelectedCatchUpProgram") as Program
+ val expected = JSONObject(java.net.URL("http://10.0.2.2:18772/fixture-state").readText()).getJSONArray("programs")
+ val window = (0 until expected.length()).map(expected::getJSONObject).single { it.getString("title") == "V2 Program $name" }
+ assertThat(selected.title).isEqualTo("V2 Program $name")
+ assertThat(selected.startTime).isEqualTo(window.getLong("start_timestamp") * 1000)
+ assertThat(selected.endTime).isEqualTo(window.getLong("stop_timestamp") * 1000)
+ assertThat(engine.duration.value).isAtLeast(239_000)
+ assertThat(engine.duration.value).isAtMost(242_000)
+ Log.i("CatchUpFixture", "selected program=$name start=${selected.startTime} end=${selected.endTime} position=${engine.currentPosition.value} intent=CATCH_UP")
+ return vm
+ }
+
+ private fun sample(engine: PlayerEngine, name: String, duration: Long) {
+ val began = SystemClock.elapsedRealtime()
+ val samples = JSONArray()
+ Log.i("CatchUpFixture", "capture-ready case=${name.lowercase()} intent=CATCH_UP ttffMs=${engine.playerStats.value.ttffMs}")
+ while (SystemClock.elapsedRealtime() - began < duration) {
+ compose.waitForIdle()
+ val source = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ assertThat(source.playbackContentKind).isEqualTo(PlaybackContentKind.CATCH_UP)
+ val stats = engine.playerStats.value
+ val row = JSONObject().put("elapsedMs", SystemClock.elapsedRealtime() - began)
+ .put("positionMs", engine.currentPosition.value).put("state", engine.playbackState.value.name)
+ .put("height", engine.videoFormat.value.height).put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames).put("pssKb", Debug.getPss())
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as ExoPlayer
+ assertThat(player.isCurrentMediaItemLive).isFalse()
+ assertThat(player.isCurrentMediaItemDynamic).isFalse()
+ row.put("timelineLive", false).put("timelineDynamic", false)
+ player.videoDecoderCounters?.let {
+ it.ensureUpdated()
+ row.put("renderedBuffers", it.renderedOutputBufferCount).put("decoderDroppedBuffers", it.droppedBufferCount)
+ }
+ }
+ check(engine.playbackState.value != PlaybackState.ERROR)
+ samples.put(row)
+ File(app.filesDir, "catch-up-${name.lowercase()}.json").writeText(samples.toString())
+ SystemClock.sleep(1_000)
+ }
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs).doesNotContain("live-recovery selected")
+ assertThat(logs).doesNotContain("buffer-policy promote")
+ }
+
+ private fun backToChannel() {
+ var returned = false
+ for (attempt in 0 until 5) {
+ device.pressBack(); SystemClock.sleep(500); compose.waitForIdle()
+ if (compose.onAllNodesWithContentDescription("V2 Archive Channel", substring = true).fetchSemanticsNodes().isNotEmpty()) {
+ returned = true; break
+ }
+ }
+ check(returned) { "Normal Back did not return to fixture channel" }
+ }
+
+ @Test fun normalUiCatchUpAndAdjacentPrograms() {
+ enabled()
+ control(false)
+ click("Live TV")
+ await("fixture category") { compose.onAllNodes(hasText("V2 Archive Validation")).fetchSemanticsNodes().isNotEmpty() }
+ compose.onNodeWithText("V2 Archive Validation").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ val vm = openArchive("Beta")
+ val engine = vm.playerEngine
+ val title = getter(vm, "getCurrentTitle")
+ val url = getter(vm, "getCurrentStreamUrl")
+ sample(engine, "Beta", 180_000)
+ // Seek outside the currently buffered region while the fixture briefly fails segment reads.
+ control(true)
+ try {
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("seek outage buffers", 15_000) { engine.playbackState.value == PlaybackState.BUFFERING }
+ SystemClock.sleep(1_500)
+ } finally { control(false) }
+ await("finite seek recovery", 45_000) {
+ engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.currentPosition.value in 59_000..75_000
+ }
+ val position = engine.currentPosition.value
+ await("recovered progression") { engine.currentPosition.value > position + 5_000 }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(url)
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.title).isEqualTo(title)
+ assertThat(history.streamUrl).isEqualTo(url)
+ assertThat(history.resumePositionMs).isAtLeast(59_000)
+ val selected = getter(getter(vm, "getPlayerPlaybackContextCoordinator")!!, "getSelectedCatchUpProgram") as Program
+ assertThat(selected.title).isEqualTo("V2 Program Beta")
+ Log.i("CatchUpFixture", "recovery-complete program=Beta position=${engine.currentPosition.value} historyTitleRetained=true")
+ backToChannel()
+ val older = openArchive("Alpha")
+ val olderEngine = older.playerEngine
+ val olderPosition = olderEngine.currentPosition.value
+ await("earlier program progresses") { olderEngine.currentPosition.value > olderPosition + 5_000 }
+ assertThat(getter(older, "getCurrentStreamUrl")).isNotEqualTo(url)
+ backToChannel()
+ val newer = openArchive("Gamma")
+ val newerEngine = newer.playerEngine
+ assertThat(getter(newer, "getCurrentStreamUrl")).isNotEqualTo(url)
+ sample(newerEngine, "Gamma", 145_000)
+ assertThat(getter(newer, "getCurrentTitle")).isEqualTo("V2 Archive Channel: V2 Program Gamma")
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I PlayerVM:I")
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("Player stuck")
+ assertThat(logs).doesNotContain("live-recovery selected")
+ assertThat(logs).doesNotContain("prepare resolvedStreamType=MPEG_TS_LIVE")
+ Log.i("CatchUpFixture", "complete catchUp=true earlier=true later=true position=${newerEngine.currentPosition.value}")
+ }
+
+ @Test fun restoreOnlyFixtureLearning() = runBlocking {
+ enabled()
+ val file = File(app.filesDir, "catch-up-learning-private.json")
+ val saved = JSONObject(file.readText())
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val observations = saved.getJSONObject("liveObservations")
+ store(prefs).edit { current ->
+ val key = stringPreferencesKey("live_variant_observations")
+ val expected = if (observations.isNull("expected")) null else observations.getString("expected")
+ check(current[key] == expected)
+ if (observations.isNull("original")) current.remove(key) else current[key] = observations.getString("original")
+ }
+ val changes = saved.getJSONArray("compatibility")
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ for (index in 0 until changes.length()) {
+ val change = changes.getJSONObject(index)
+ val expected = change.getJSONObject("expected")
+ val id = expected.getLong("id")
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id)).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) {
+ val actual = cursor.getString(cursor.getColumnIndexOrThrow(column))
+ check(actual == if (expected.isNull(column)) null else expected.get(column).toString())
+ }
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id))
+ if (!change.isNull("original")) {
+ val original = change.getJSONObject("original")
+ val columns = original.keys().asSequence().toList()
+ check(columns.all { it.matches(Regex("[a-z_]+")) })
+ database.execSQL("INSERT INTO playback_compatibility_records (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }})",
+ columns.map { if (original.isNull(it)) null else original.get(it).toString() }.toTypedArray())
+ }
+ }
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ Unit
+ }
+
+ @Test fun cleanupOnlyIsolatedArchive() = runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ check(providers.getProvider(id)?.name == "V2 Archive validation 20261003")
+ check(providers.deleteProvider(id).isSuccess)
+ check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val restore = File(app.filesDir, "catch-up-restore.json")
+ val saved = JSONObject(restore.readText())
+ store(prefs).edit { current ->
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ val key = stringPreferencesKey(name)
+ if (saved.isNull(name)) current.remove(key) else current[key] = saved.getString(name)
+ }
+ current.asMap().keys.filter { it.name in listOf("last_split_catalog_type_$id", "last_live_category_id_$id") }
+ .forEach { current.remove(it) }
+ }
+ check(restore.delete()); check(setup.delete())
+ for (name in listOf("catch-up-beta.json", "catch-up-gamma.json", "catch-up-driver.png", "catch-up-driver.xml")) File(app.filesDir, name).delete()
+ Unit
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/EpisodeFallbackRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/EpisodeFallbackRuntimeTest.kt
new file mode 100644
index 00000000..629deb91
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/EpisodeFallbackRuntimeTest.kt
@@ -0,0 +1,426 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.os.SystemClock
+import android.util.Log
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.test.hasScrollAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.onFirst
+import androidx.compose.ui.test.performScrollToNode
+import androidx.lifecycle.ViewModelStore
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import androidx.test.uiautomator.StaleObjectException
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.VodDuplicateHandlingMode
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.domain.repository.SeriesRepository
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.dao.SeriesDao
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import com.streamvault.player.PlayerError
+import com.streamvault.player.PLAYER_TRACK_AUTO_ID
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import java.net.URI
+import org.json.JSONObject
+import javax.inject.Provider
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in local, finite-media episode acceptance. Injected errors prove wiring only. */
+@RunWith(AndroidJUnit4::class)
+class EpisodeFallbackRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setupFile get() = File(app.filesDir, "episode-fallback-fixture-private.txt")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("episodeFallbackFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + 30_000
+ while (!condition() && SystemClock.elapsedRealtime() < end) SystemClock.sleep(100)
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "episode-fallback-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "episode-fallback-driver.xml"))
+ }
+ check(condition()) { "Timed out: $label" }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.endsWith("Fixture")) {
+ compose.onNodeWithText(text, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.waitForIdle()
+ return
+ }
+ var node = device.wait(Until.findObject(By.textContains(text)), 3_000)
+ if (text.startsWith("S01E")) {
+ if (node == null) compose.onAllNodes(hasScrollAction()).onFirst()
+ .performScrollToNode(hasText(text, substring = true))
+ compose.onNodeWithText(text, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.waitForIdle()
+ return
+ }
+ var bounds: android.graphics.Rect? = null
+ repeat(3) {
+ if (bounds == null) try {
+ bounds = (device.wait(Until.findObject(By.textContains(text)), 3_000)
+ ?: error("Missing fixture UI: $text")).visibleBounds
+ } catch (_: StaleObjectException) { device.waitForIdle() }
+ }
+ val b = bounds ?: error("Fixture UI remained stale: $text")
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ device.waitForIdle(); compose.waitForIdle()
+ }
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields) {
+ if (!Map::class.java.isAssignableFrom(field.type)) continue
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+ private fun getter(vm: Any, prefix: String): Any? = vm.javaClass.methods
+ .single { it.name.substringBefore('$') == prefix && it.parameterCount == 0 }.invoke(vm)
+
+ @Test fun provisionIsolatedFixture() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val series = component("seriesRepositoryImplProvider") as SeriesRepository
+ val oldActive = providers.getActiveProvider().first()?.id ?: -1L
+ val oldLast = prefs.lastActiveProviderId.first() ?: -1L
+ val oldMode = prefs.vodDuplicateHandlingMode.first()
+ val id = if (setupFile.exists()) setupFile.readLines()[0].toLong() else providers.addProvider(LegacyProvider(name = "Episode fallback validation 20261002",
+ type = ProviderType.XTREAM_CODES, serverUrl = "http://10.0.2.2:18768", username = "validation", password = "validation",
+ isActive = false, maxConnections = 1, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "Episode fallback validation 20261002")
+ if (!setupFile.exists()) setupFile.writeText("$id\n$oldActive\n$oldLast\n${oldMode.name}\n")
+ check(providers.refreshProviderData(id, force = true).isSuccess) { "Fixture series sync failed" }
+ for (category in series.getCategories(id).first()) series.getSeriesByCategory(id, category.id).first()
+ val rows = withTimeout(60_000) { series.getSeries(id).first { it.isNotEmpty() } }
+ check(rows.isNotEmpty())
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ prefs.setVodDuplicateHandlingMode(VodDuplicateHandlingMode.GROUPED)
+ println("EpisodeFixture: isolated provider $id provisioned; catalogue rows=${rows.size}")
+ }
+
+ @Test fun normalEpisodeUiRecoveryAndSustainedPlayback() {
+ enabled()
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ fun source() = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as? StreamInfo
+ fun sourcePath() = source()?.url?.let { URI(it).path }
+ fun inject() {
+ @Suppress("UNCHECKED_CAST")
+ val errors = engine.javaClass.getDeclaredField("_error").apply { isAccessible = true }.get(engine) as MutableSharedFlow<PlayerError?>
+ instrumentation.runOnMainSync { check(errors.tryEmit(PlayerError.DecoderError("Episode fixture injected decoder failure"))) }
+ }
+ click("Series")
+ click("Episode Resilience Fixture")
+ click("S01E02")
+ await("HEVC episode startup") { sourcePath()?.endsWith("/50102.mp4") == true && engine.availableAudioTracks.value.size >= 2 }
+ lateinit var vm: PlayerViewModel
+ instrumentation.runOnMainSync { vm = findPlayer(compose.activity.viewModelStore) ?: error("Player ViewModel not found") }
+ SystemClock.sleep(1_500) // Preparation completes before its history lookup/dialog.
+ compose.waitForIdle()
+ if (vm.resumePrompt.value.show) {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("resume prompt dismissed") { !vm.resumePrompt.value.show }
+ }
+ val logicalEpisode = vm.currentEpisode.value ?: error("Logical episode missing")
+ val logicalSeries = vm.currentSeries.value ?: error("Logical series missing")
+ val title = getter(vm, "getCurrentTitle")
+ val url = getter(vm, "getCurrentStreamUrl")
+ Log.i("EpisodeFixture", "logical provider=${logicalSeries.providerId} series=${logicalSeries.id} episode=${logicalEpisode.id} season=${logicalEpisode.seasonNumber} number=${logicalEpisode.episodeNumber} metadataDuration=${logicalEpisode.durationSeconds}")
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("seek ready") { engine.currentPosition.value in 59_000..65_000 && engine.playbackState.value == PlaybackState.READY }
+ instrumentation.runOnMainSync { engine.pause() }
+ if (!vm.showControls.value) device.pressDPadCenter()
+ repeat(3) {
+ if (!vm.showControls.value) { device.pressDPadCenter(); SystemClock.sleep(200) }
+ }
+ if (!vm.showControls.value) device.executeShellCommand("input mouse tap ${device.displayWidth / 2} ${device.displayHeight / 2}")
+ device.waitForIdle(); compose.waitForIdle()
+ device.takeScreenshot(File(app.filesDir, "episode-fallback-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "episode-fallback-driver.xml"))
+ Log.i("EpisodeFixture", "driver controls=${vm.showControls.value} resume=${vm.resumePrompt.value.show}")
+ val spanish = engine.availableAudioTracks.value.first { it.language in listOf("es", "spa") }.name
+ val english = engine.availableSubtitleTracks.value.first { it.language in listOf("en", "eng") }.name
+ compose.onNodeWithContentDescription("Audio").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(spanish, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithContentDescription("Subs").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(english, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ fun languages() = engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") } &&
+ engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }
+ await("selected languages", ::languages)
+ device.pressBack() // Close the subtitle chooser before observing video frames.
+ compose.waitForIdle()
+ inject()
+ val recovery = getter(vm, "getPlayerRecoveryCoordinator") ?: error("Recovery state unavailable")
+ await("software retry") { getter(recovery, "getRetriedWithSoftwareDecoder") == true }
+ assertThat(sourcePath()).endsWith("/50102.mp4")
+ await("software retry ready") { engine.playbackState.value == PlaybackState.READY &&
+ engine.playerStats.value.videoCodec.contains("hevc", ignoreCase = true) && engine.videoFormat.value.height == 1080 }
+ val position = engine.currentPosition.value
+ Log.i("EpisodeFixture", "source identity name=${logicalSeries.name} tmdb=${logicalSeries.tmdbId} episodes=${logicalSeries.seasons.flatMap { it.episodes }.map { listOf(it.id,it.seriesId,it.episodeNumber,it.title) }} codec=${engine.playerStats.value.videoCodec} height=${engine.videoFormat.value.height} duration=${engine.duration.value} position=$position")
+ val before = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ val prepares = before.lineSequence().count { "prepare resolvedStreamType" in it }
+ inject()
+ SystemClock.sleep(1_000)
+ Log.i("EpisodeFixture", "candidate-outcome notice=${vm.playerNotice.value?.message} codec=${engine.playerStats.value.videoCodec} duration=${engine.duration.value}")
+ if (sourcePath()?.endsWith("/50202.mp4") != true) runBlocking {
+ val repository = component("seriesRepositoryImplProvider") as SeriesRepository
+ val candidateId = logicalSeries.variants.first { it.rawSeriesId != logicalSeries.id }.rawSeriesId
+ val candidate = repository.getSeriesDetails(logicalSeries.providerId, candidateId).getOrNull()
+ Log.i("EpisodeFixture", "candidate identity id=${candidate?.id} name=${candidate?.name} tmdb=${candidate?.tmdbId} episodes=${candidate?.seasons?.flatMap { it.episodes }?.map { listOf(it.id,it.seriesId,it.episodeNumber,it.title,it.durationSeconds) }}")
+ }
+ await("physical AVC source") { sourcePath()?.endsWith("/50202.mp4") == true }
+ await("first replacement resume") { engine.isPlaying.value && engine.currentPosition.value >= position - 2_000 && languages() }
+ assertThat(engine.currentPosition.value).isAtMost(position + 2_000)
+ assertThat(vm.currentEpisode.value?.id).isEqualTo(logicalEpisode.id)
+ assertThat(vm.currentSeries.value?.id).isEqualTo(logicalSeries.id)
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(url)
+ assertThat(logicalSeries.seasons.flatMap { it.episodes }.map { it.episodeNumber }).containsAtLeast(1, 2, 3)
+ val after = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(after.lineSequence().count { "prepare resolvedStreamType" in it } - prepares).isEqualTo(1)
+ Log.i("EpisodeFixture", "capture-ready logicalSeries=${logicalSeries.id} logicalEpisode=${logicalEpisode.id} physicalRemote=50202 position=$position")
+ val end = SystemClock.elapsedRealtime() + 130_000
+ val startPosition = engine.currentPosition.value
+ var previousState = engine.playbackState.value
+ var rebufferTransitions = 0
+ var sampledBufferingMs = 0L
+ val initialDrops = engine.playerStats.value.droppedFrames
+ while (SystemClock.elapsedRealtime() < end) {
+ assertThat(sourcePath()).endsWith("/50202.mp4")
+ assertThat(vm.currentEpisode.value?.id).isEqualTo(logicalEpisode.id)
+ val state = engine.playbackState.value
+ if (state == PlaybackState.BUFFERING) {
+ sampledBufferingMs += 500
+ if (previousState != state) rebufferTransitions++
+ }
+ previousState = state
+ SystemClock.sleep(500)
+ }
+ assertThat(engine.currentPosition.value).isGreaterThan(startPosition + 100_000)
+ assertThat(engine.playbackState.value).isEqualTo(PlaybackState.READY)
+ assertThat(languages()).isTrue()
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.contentId).isEqualTo(logicalEpisode.id)
+ assertThat(history.resumePositionMs).isAtLeast(startPosition + 100_000)
+ assertThat(history.seriesId).isEqualTo(logicalSeries.id)
+ assertThat(history.streamUrl).isEqualTo(url)
+ Log.i("EpisodeFixture", "capture-stats rebufferTransitions=$rebufferTransitions sampledBufferingMs=$sampledBufferingMs drops=$initialDrops->${engine.playerStats.value.droppedFrames} duration=${engine.duration.value} historyContentId=${history.contentId} historyPosition=${history.resumePositionMs} stalls=${engine.playerStats.value.videoStallCount}")
+ val renewal = Class.forName("com.streamvault.feature.playback.player.PlayerLifecycleActionsKt").methods
+ .single { it.name == "startTokenRenewalMonitoring" && it.parameterCount == 3 }
+ instrumentation.runOnMainSync { renewal.invoke(null, vm, System.currentTimeMillis() + 1000, null) }
+ SystemClock.sleep(2_000)
+ assertThat(sourcePath()).endsWith("/50202.mp4")
+ val renewed = getter(vm, "getCurrentResolvedStreamInfo") as StreamInfo
+ assertThat(URI(renewed.url).path).endsWith("/50202.mp4")
+ assertThat(renewed.title).isEqualTo(title)
+ assertThat(device.executeShellCommand("logcat -d -s PlayerVM:I")).contains("token-renewal request-changed=false")
+ val beforeRepeat = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ inject(); SystemClock.sleep(5_000)
+ assertThat(sourcePath()).endsWith("/50202.mp4")
+ assertThat(device.executeShellCommand("logcat -d -s Media3PlayerEngine:I").lineSequence().count { "prepare resolvedStreamType" in it })
+ .isEqualTo(beforeRepeat.lineSequence().count { "prepare resolvedStreamType" in it })
+ Log.i("EpisodeFixture", "positive-complete retained-logical-identity languages navigation single-prepare repeat-error-no-prepare")
+ }
+
+ @Test fun cleanupOnlyFixture() = runBlocking {
+ enabled()
+ val values = setupFile.readLines()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = values[0].toLong()
+ providers.getProvider(id)?.let { fixture ->
+ check(fixture.name == "Episode fallback validation 20261002")
+ check(providers.deleteProvider(id).isSuccess)
+ }
+ if (values[1].toLong() > 0) check(providers.setActiveProvider(values[1].toLong()).isSuccess)
+ prefs.setLastActiveProviderId(values[2].toLong())
+ prefs.setVodDuplicateHandlingMode(VodDuplicateHandlingMode.valueOf(values[3]))
+ val restoreFile = File(app.filesDir, "episode-fallback-restore.json")
+ check(restoreFile.exists()) { "Original playback preference values required for cleanup" }
+ val original = JSONObject(restoreFile.readText())
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ for (name in listOf("player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ val key = stringPreferencesKey(name)
+ if (original.isNull(name)) current.remove(key) else current[key] = original.getString(name)
+ }
+ }
+ check(setupFile.delete())
+ check(restoreFile.delete())
+ for (name in listOf("episode-fallback-driver.png", "episode-fallback-driver.xml")) File(app.filesDir, name).delete()
+ println("EpisodeFixture: temporary provider removed; previous provider and grouping restored")
+ }
+
+ @Test fun restoreOnlyFixtureGroupingPreference() = runBlocking {
+ enabled()
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val restoreFile = File(app.filesDir, "episode-fallback-restore.json")
+ val original = JSONObject(restoreFile.readText())
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ store.edit { current ->
+ val name = "vod_duplicate_handling_mode"
+ val key = stringPreferencesKey(name)
+ if (original.isNull(name)) current.remove(key) else current[key] = original.getString(name)
+ }
+ check(restoreFile.delete())
+ }
+
+ @Test fun cleanupOnlyFixtureCompatibilityResult() {
+ enabled()
+ val file = File(app.filesDir, "episode-fallback-compatibility.json")
+ val expected = JSONObject(file.readText())
+ check(expected.getLong("last_failed_at") == 0L)
+ check(expected.getLong("last_succeeded_at") == 1790946020112L)
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(expected.getLong("id"))).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) check(cursor.getString(cursor.getColumnIndexOrThrow(column)) == expected.get(column).toString())
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(expected.getLong("id")))
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ }
+
+ @Test fun normalEpisodeUiNegativeControl() {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("episodeFallbackCase") ?: error("Missing control case")
+ check(case in setOf("wrong", "missing", "saved", "manual", "cancel"))
+ val prefix = when (case) { "wrong" -> "Wrong Episode Fixture"; "missing", "cancel" -> "Missing Metadata Fixture"; else -> "Episode Resilience Fixture" }
+ val physical = when (case) { "wrong" -> "51202.mp4"; "missing", "cancel" -> "52202.mp4"; else -> "50202.mp4" }
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ // Fixture URLs expire; force only this fixture's source metadata to refresh.
+ val sourceRemote = when (case) { "wrong" -> "511"; "missing", "cancel" -> "521"; else -> "501" }
+ val repository = component("seriesRepositoryImplProvider")
+ val fixtureDao = repository.javaClass.getDeclaredField("seriesDao").apply { isAccessible = true }.get(repository) as SeriesDao
+ runBlocking {
+ val row = fixtureDao.getByProviderSeriesId(setupFile.readLines()[0].toLong(), sourceRemote) ?: error("Missing fixture source")
+ check(row.name.startsWith(prefix))
+ fixtureDao.update(row.copy(detailHydratedAt = 0L, cacheState = "SUMMARY_ONLY"))
+ }
+ fun inject() {
+ @Suppress("UNCHECKED_CAST")
+ val errors = engine.javaClass.getDeclaredField("_error").apply { isAccessible = true }.get(engine) as MutableSharedFlow<PlayerError?>
+ instrumentation.runOnMainSync { check(errors.tryEmit(PlayerError.DecoderError("Episode fixture control $case"))) }
+ }
+ click("Series"); click("Browse Full Series Library"); click(prefix); click("S01E02")
+ await("control player context") { var found = false; instrumentation.runOnMainSync { found = findPlayer(compose.activity.viewModelStore) != null }; found }
+ lateinit var vm: PlayerViewModel
+ instrumentation.runOnMainSync { vm = findPlayer(compose.activity.viewModelStore) ?: error("Missing player") }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("control resume dismissed") { !vm.resumePrompt.value.show }
+ }
+ await("control startup") { engine.playbackState.value == PlaybackState.READY && engine.availableAudioTracks.value.isNotEmpty() }
+ val series = vm.currentSeries.value ?: error("Missing series")
+ instrumentation.runOnMainSync { engine.seekTo(60_000) }
+ await("control seek") { engine.currentPosition.value >= 59_000 }
+ inject()
+ val recovery = getter(vm, "getPlayerRecoveryCoordinator")!!
+ await("control software retry") { getter(recovery, "getRetriedWithSoftwareDecoder") == true }
+ await("control software ready") { engine.playbackState.value == PlaybackState.READY && engine.currentPosition.value >= 59_000 &&
+ engine.playerStats.value.videoCodec.contains("hevc", ignoreCase = true) }
+ try {
+ if (case == "saved") runBlocking { prefs.setPreferredVodVariant(series.providerId, series.logicalGroupId, series.id) }
+ if (case == "manual") {
+ val track = engine.availableVideoTracks.value.first { it.id != PLAYER_TRACK_AUTO_ID }
+ instrumentation.runOnMainSync { engine.selectVideoTrack(track.id) }
+ await("manual video") { engine.availableVideoTracks.value.none { it.id == PLAYER_TRACK_AUTO_ID && it.isSelected } }
+ }
+ if (case == "cancel") {
+ // Repeat the suspended network lookup even after a prior driver failure.
+ val repository = component("seriesRepositoryImplProvider")
+ val dao = repository.javaClass.getDeclaredField("seriesDao").apply { isAccessible = true }.get(repository) as SeriesDao
+ runBlocking {
+ val candidate = dao.getByProviderSeriesId(series.providerId, "522") ?: error("Missing fixture candidate")
+ check(candidate.name.startsWith("Missing Metadata Fixture"))
+ dao.update(candidate.copy(detailHydratedAt = 0L, cacheState = "SUMMARY_ONLY"))
+ }
+ java.net.URL("http://10.0.2.2:18768/control?delay=522").readText()
+ }
+ val before = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ val count = before.lineSequence().count { "prepare resolvedStreamType" in it && physical in it }
+ inject()
+ if (case == "cancel") {
+ val state = getter(vm, "getEpisodeSourceState")!!
+ await("candidate lookup reserved") { getter(state, "getAttempted") == true }
+ val oldToken = getter(state, "getToken")
+ SystemClock.sleep(300)
+ repeat(6) {
+ if (getter(state, "getToken") == oldToken) {
+ device.pressBack()
+ compose.waitForIdle()
+ if (device.findObject(By.text("Close playback?")) != null) {
+ compose.onNodeWithText("Yes").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.waitForIdle()
+ }
+ SystemClock.sleep(100)
+ }
+ }
+ await("lookup session canceled") { getter(state, "getToken") != oldToken }
+ }
+ SystemClock.sleep(6_000)
+ val after = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(after.lineSequence().count { "prepare resolvedStreamType" in it && physical in it }).isEqualTo(count)
+ Log.i("EpisodeFixture", "negative-complete case=$case provider=${series.providerId} logicalSeries=${series.id} logicalEpisode=${vm.currentEpisode.value?.id} sourceRemote=${sourceRemote}02 candidateRemote=${physical.removeSuffix(".mp4")} identity=S01E02 candidatePrepareDelta=0")
+ } finally {
+ if (case == "saved") runBlocking { prefs.clearPreferredVodVariant(series.providerId, series.logicalGroupId) }
+ if (case == "cancel") java.net.URL("http://10.0.2.2:18768/control?delay=0").readText()
+ }
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/MovieFallbackRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/MovieFallbackRuntimeTest.kt
new file mode 100644
index 00000000..03e9786a
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/MovieFallbackRuntimeTest.kt
@@ -0,0 +1,122 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.os.SystemClock
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.semantics.SemanticsActions
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.player.PlayerEngine
+import com.streamvault.player.PlayerError
+import com.streamvault.player.PlaybackState
+import dagger.hilt.internal.GeneratedComponentManager
+import javax.inject.Provider
+import kotlinx.coroutines.flow.MutableSharedFlow
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.Rule
+import org.junit.runner.RunWith
+
+/** Opt-in integration probe; requires the local Stage 4 provider and valid matching media.
+ * Error injection validates recovery wiring, not platform decoder-failure detection.
+ */
+@RunWith(AndroidJUnit4::class)
+class MovieFallbackRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ @Test
+ fun injectedDecoderFailurePreservesPositionAndTracksAndDoesNotLoop() {
+ val instrumentation = InstrumentationRegistry.getInstrumentation()
+ assumeTrue(InstrumentationRegistry.getArguments().getString("movieFallbackFixture") == "true")
+ val app = ApplicationProvider.getApplicationContext<Application>()
+ val component = (app as GeneratedComponentManager<*>).generatedComponent()
+ val providerField = component.javaClass.getDeclaredField("provideMainPlayerEngineProvider").apply { isAccessible = true }
+ val engine = (providerField.get(component) as Provider<*>).get() as PlayerEngine
+ val device = UiDevice.getInstance(instrumentation)
+ compose.waitForIdle()
+ fun clickText(text: String) {
+ compose.waitForIdle()
+ val node = device.wait(Until.findObject(By.textContains(text)), 2_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 5_000) else null)
+ ?: error("Missing fixture UI: $text")
+ val bounds = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${bounds.centerX()} ${bounds.centerY()}")
+ device.waitForIdle()
+ compose.waitForIdle()
+ }
+ fun await(label: String, condition: () -> Boolean) {
+ val deadline = SystemClock.elapsedRealtime() + 20_000
+ while (!condition() && SystemClock.elapsedRealtime() < deadline) SystemClock.sleep(100)
+ check(condition()) { "Timed out: $label" }
+ }
+ fun source(): String = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }
+ .get(engine).let { (it as? StreamInfo)?.url.orEmpty() }
+ fun inject() {
+ @Suppress("UNCHECKED_CAST")
+ val errors = engine.javaClass.getDeclaredField("_error").apply { isAccessible = true }.get(engine) as MutableSharedFlow<PlayerError?>
+ instrumentation.runOnMainSync { check(errors.tryEmit(PlayerError.DecoderError("Stage 4 injected decoder failure"))) }
+ }
+ clickText("Movies")
+ clickText("Resilience Fixture")
+ clickText("Play")
+ device.wait(Until.findObject(By.text("Resume")), 1_000)?.let {
+ val b = it.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ compose.waitForIdle()
+ }
+ await("valid HEVC startup") { source().endsWith("/101.mp4") && engine.availableAudioTracks.value.size >= 2 }
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.pause() }
+ await("nonzero seek") { engine.currentPosition.value >= 59_000 }
+ device.pressDPadCenter()
+ device.waitForIdle()
+ val spanish = engine.availableAudioTracks.value.first { it.language in listOf("es", "spa") }.name
+ val english = engine.availableSubtitleTracks.value.first { it.language in listOf("en", "eng") }.name
+ compose.onNodeWithContentDescription("Audio").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(spanish, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithContentDescription("Subs").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(english, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("manual track selections") {
+ engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") } &&
+ engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }
+ }
+ val position = engine.currentPosition.value
+ inject()
+ SystemClock.sleep(2_000) // Allow the existing software-decoder retry to complete first.
+ if (source().endsWith("/101.mp4")) inject()
+ await("AVC fallback") { source().endsWith("/102.mp4") }
+ await("AVC decoder running") {
+ engine.playerStats.value.videoCodec.let { it.contains("avc", ignoreCase = true) || it.contains("264") }
+ }
+ await("resumed tracks") {
+ engine.currentPosition.value >= position - 2_000 &&
+ engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") } &&
+ engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }
+ }
+ assertThat(engine.currentPosition.value).isLessThan(position + 15_000)
+ await("candidate playing") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ val resumedPosition = engine.currentPosition.value
+ await("candidate position advancing") { engine.currentPosition.value >= resumedPosition + 2_000 }
+ println("Stage4: AVC active; resume within tolerance; Spanish audio and English subtitles retained")
+ fun recoveryLog() = device.executeShellCommand("logcat -d -s PlayerVM:I Media3PlayerEngine:I")
+ fun handledErrors(log: String) = log.lineSequence().count { "handle-playback-error type=DecoderError contentType=MOVIE" in it }
+ val beforeSecondError = recoveryLog()
+ val beforePrepareCount = beforeSecondError.lineSequence().count { "prepare resolvedStreamType" in it }
+ inject()
+ await("second error consumed by movie recovery") { handledErrors(recoveryLog()) > handledErrors(beforeSecondError) }
+ val observationEnd = SystemClock.elapsedRealtime() + 5_000
+ while (SystemClock.elapsedRealtime() < observationEnd) {
+ assertThat(source()).endsWith("/102.mp4")
+ SystemClock.sleep(100)
+ }
+ assertThat(recoveryLog().lineSequence().count { "prepare resolvedStreamType" in it }).isEqualTo(beforePrepareCount)
+ println("Stage4: second candidate error caused no further variant switch")
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackBufferComparisonRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackBufferComparisonRuntimeTest.kt
new file mode 100644
index 00000000..9f55d7cc
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackBufferComparisonRuntimeTest.kt
@@ -0,0 +1,281 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.app.ActivityManager
+import android.os.Debug
+import android.os.SystemClock
+import androidx.media3.common.C
+import androidx.media3.common.Player as Media3Player
+import androidx.test.core.app.ActivityScenario
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.streamvault.app.MainActivity
+import com.streamvault.domain.model.PlaybackBufferMode
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.DecoderMode
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import javax.inject.Provider
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in local fixture probe for a same-device load-control comparison. */
+@RunWith(AndroidJUnit4::class)
+class PlaybackBufferComparisonRuntimeTest {
+ @Test
+ fun compareBufferPolicyForFixture() = runBlocking {
+ val arguments = InstrumentationRegistry.getArguments()
+ assumeTrue(arguments.getString("bufferComparisonFixture") == "true")
+ val fixtureUrl = requireNotNull(arguments.getString("fixtureUrl"))
+ val runId = requireNotNull(arguments.getString("runId"))
+ require(runId.matches(Regex("[A-Za-z0-9_-]{1,40}")))
+ val streamType = arguments.getString("streamType")
+ ?.let(StreamType::valueOf)
+ ?: StreamType.HLS
+ require(streamType in setOf(StreamType.HLS, StreamType.DASH, StreamType.PROGRESSIVE, StreamType.MPEG_TS)) {
+ "Unsupported comparison fixture stream type: $streamType"
+ }
+ val contentKind = arguments.getString("contentKind")
+ ?.let(PlaybackContentKind::valueOf)
+ ?: PlaybackContentKind.ON_DEMAND
+ val bufferMode = arguments.getString("bufferMode")
+ ?.let(PlaybackBufferMode::valueOf)
+ ?: PlaybackBufferMode.AUTO
+ require(bufferMode in setOf(PlaybackBufferMode.AUTO, PlaybackBufferMode.MEDIUM)) {
+ "Unsupported comparison buffer mode: $bufferMode"
+ }
+ val containerExtension = arguments.getString("containerExtension")
+ ?.trim()
+ ?.removePrefix(".")
+ ?.takeIf(String::isNotEmpty)
+ ?: when (streamType) {
+ StreamType.HLS -> "m3u8"
+ StreamType.DASH -> "mpd"
+ StreamType.MPEG_TS -> "ts"
+ else -> "mp4"
+ }
+ // The V8 recurrence comparison needs enough time to observe the next gated restore
+ // and its post-restoration pressure window in one source session.
+ val durationSeconds = arguments.getString("durationSeconds")?.toIntOrNull()
+ ?.coerceIn(30, 600) ?: 120
+ // Development-only Stage 3 control; never write a saved decoder preference.
+ val videoDecoderMode = arguments.getString("videoDecoderMode")?.let(DecoderMode::valueOf)
+ val manualVideoHeight = arguments.getString("manualVideoHeight")?.toIntOrNull()
+
+ val instrumentation = InstrumentationRegistry.getInstrumentation()
+ val app = ApplicationProvider.getApplicationContext<Application>()
+ val lowRamDevice = app.getSystemService(ActivityManager::class.java)?.isLowRamDevice ?: false
+ val component = (app as GeneratedComponentManager<*>).generatedComponent()
+ val provider = component.javaClass.getDeclaredField("provideMainPlayerEngineProvider").apply {
+ isAccessible = true
+ }.get(component) as Provider<*>
+ val engine = provider.get() as PlayerEngine
+ fun requestedMode(field: String) = engine.javaClass.getDeclaredField(field).apply {
+ isAccessible = true
+ }.get(engine) as DecoderMode
+ val originalAudioMode = requestedMode("requestedAudioDecoderMode")
+ val originalVideoMode = requestedMode("requestedVideoDecoderMode")
+ val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+ val errors = JSONArray()
+ val errorJob = scope.launchCollectErrors(engine, errors)
+ fun <T> main(action: () -> T): T {
+ val result = java.util.concurrent.atomic.AtomicReference<T>()
+ instrumentation.runOnMainSync { result.set(action()) }
+ return result.get()
+ }
+ val scenario = ActivityScenario.launch(MainActivity::class.java)
+ var renderView: android.view.View? = null
+ val samples = JSONArray()
+ val startedAt = SystemClock.elapsedRealtime()
+ try {
+ scenario.onActivity { activity ->
+ renderView = engine.createRenderView(activity, com.streamvault.player.PlayerSurfaceResizeMode.FIT)
+ activity.setContentView(renderView)
+ engine.bindRenderView(renderView!!, com.streamvault.player.PlayerSurfaceResizeMode.FIT)
+ }
+ main {
+ engine.setMediaSessionEnabled(true)
+ engine.setPlaybackBufferMode(bufferMode)
+ videoDecoderMode?.let { engine.setDecoderModes(originalAudioMode, it) }
+ engine.prepare(
+ StreamInfo(
+ url = fixtureUrl,
+ title = "Stage 1 ${streamType.name} buffer fixture",
+ streamType = streamType,
+ containerExtension = containerExtension,
+ playbackContentKind = contentKind
+ )
+ )
+ engine.play()
+ }
+ withTimeout(45_000) {
+ while (!engine.isPlaying.value || engine.playbackState.value != PlaybackState.READY ||
+ engine.playerStats.value.ttffMs <= 0L
+ ) delay(100)
+ }
+ val firstFrameAtMs = SystemClock.elapsedRealtime() - startedAt
+ manualVideoHeight?.let { height -> main {
+ val track = engine.availableVideoTracks.value.first { it.name.contains("${height}p") }
+ engine.selectVideoTrack(track.id)
+ } }
+ val deadline = SystemClock.elapsedRealtime() + durationSeconds * 1_000L
+ while (SystemClock.elapsedRealtime() < deadline) {
+ val stats = engine.playerStats.value
+ val decoderSample = main {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply {
+ isAccessible = true
+ }.get(engine) as androidx.media3.exoplayer.ExoPlayer
+ val counters = player.videoDecoderCounters
+ counters?.ensureUpdated()
+ JSONObject()
+ .put("rendered", counters?.renderedOutputBufferCount)
+ .put("dropped", counters?.droppedBufferCount)
+ .put("skipped", counters?.skippedOutputBufferCount)
+ .put("droppedToKeyframe", counters?.droppedToKeyframeCount)
+ .put("maxConsecutiveDropped", counters?.maxConsecutiveDroppedBufferCount)
+ .put("decoderInitCount", counters?.decoderInitCount)
+ .put("frameRate", player.videoFormat?.frameRate)
+ .put("codecs", player.videoFormat?.codecs)
+ .put("colorTransfer", player.videoFormat?.colorInfo?.colorTransfer)
+ .put("videoOverrideCount", player.trackSelectionParameters.overrides.values.count {
+ it.mediaTrackGroup.type == C.TRACK_TYPE_VIDEO
+ })
+ .put("maxVideoHeight", player.trackSelectionParameters.maxVideoHeight)
+ .put("videoQualityAuto", engine.availableVideoTracks.value.firstOrNull {
+ it.id == com.streamvault.player.PLAYER_TRACK_AUTO_ID
+ }?.isSelected)
+ .put("overrideMaxHeight", player.trackSelectionParameters.overrides.values
+ .filter { it.type == C.TRACK_TYPE_VIDEO }.flatMap { override ->
+ override.trackIndices.map { override.mediaTrackGroup.getFormat(it).height }
+ }.maxOrNull())
+ .put("displayRefreshHz", renderView?.display?.mode?.refreshRate)
+ }
+ val memory = Debug.MemoryInfo().also { Debug.getMemoryInfo(it) }
+ val javaAllocated = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()
+ val liveOffsetMs = if (contentKind == PlaybackContentKind.LIVE) main {
+ runCatching {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply {
+ isAccessible = true
+ }.get(engine) as? Media3Player
+ if (player?.isCommandAvailable(Media3Player.COMMAND_GET_CURRENT_MEDIA_ITEM) == true) {
+ player.currentLiveOffset
+ } else {
+ C.TIME_UNSET
+ }
+ }.getOrDefault(C.TIME_UNSET)
+ } else {
+ C.TIME_UNSET
+ }
+ samples.put(
+ JSONObject()
+ .put("elapsedMs", SystemClock.elapsedRealtime() - startedAt)
+ .put("state", engine.playbackState.value.name)
+ .put("isPlaying", engine.isPlaying.value)
+ .put("positionMs", engine.currentPosition.value)
+ .put("liveOffsetMs", liveOffsetMs)
+ .put("bufferedMs", stats.bufferedDurationMs)
+ .put("rebufferCount", stats.rebufferCount)
+ .put("droppedFrames", stats.droppedFrames)
+ .put("width", stats.width)
+ .put("height", stats.height)
+ .put("videoBitrate", stats.videoBitrate)
+ .put("bandwidthEstimate", stats.bandwidthEstimate)
+ .put("decoder", stats.videoDecoderName)
+ .put("ttffMs", stats.ttffMs)
+ .put("javaAllocatedBytes", javaAllocated)
+ .put("totalPssKb", memory.totalPss)
+ .put("decoderCounters", decoderSample)
+ )
+ delay(1_000)
+ }
+ val last = engine.playerStats.value
+ val result = JSONObject()
+ .put("runId", runId)
+ .put("fixtureUrl", fixtureUrl.replace(Regex("https?://[^/]+"), "<fixture-host>"))
+ .put("contentKind", contentKind.name)
+ .put("streamType", streamType.name)
+ .put("bufferMode", bufferMode.name)
+ .put("requestedVideoDecoderMode", videoDecoderMode?.name ?: originalVideoMode.name)
+ .put("lowRamDevice", lowRamDevice)
+ .put("durationSeconds", durationSeconds)
+ .put("firstFrameMs", firstFrameAtMs)
+ .put("finalState", engine.playbackState.value.name)
+ .put("finalIsPlaying", engine.isPlaying.value)
+ .put("finalPositionMs", engine.currentPosition.value)
+ .put("finalDurationMs", engine.duration.value)
+ .put("finalLiveOffsetMs", if (contentKind == PlaybackContentKind.LIVE) main {
+ runCatching {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply {
+ isAccessible = true
+ }.get(engine) as? Media3Player
+ if (player?.isCommandAvailable(Media3Player.COMMAND_GET_CURRENT_MEDIA_ITEM) == true) {
+ player.currentLiveOffset
+ } else {
+ C.TIME_UNSET
+ }
+ }.getOrDefault(C.TIME_UNSET)
+ } else C.TIME_UNSET)
+ .put("finalBufferMs", last.bufferedDurationMs)
+ .put("finalRebufferCount", last.rebufferCount)
+ .put("finalDroppedFrames", last.droppedFrames)
+ .put("finalWidth", last.width)
+ .put("finalHeight", last.height)
+ .put("finalVideoBitrate", last.videoBitrate)
+ .put("finalBandwidthEstimate", last.bandwidthEstimate)
+ .put("finalDecoder", last.videoDecoderName)
+ .put("errors", errors)
+ .put("samples", samples)
+ val resultJson = result.toString(2)
+ java.io.File(app.filesDir, "buffer-comparison-$runId.json").writeText(resultJson)
+ arguments.getString("resultCallbackUrl")?.trim()?.takeIf(String::isNotEmpty)?.let { callbackUrl ->
+ val connection = java.net.URL(callbackUrl).openConnection() as java.net.HttpURLConnection
+ try {
+ connection.requestMethod = "POST"
+ connection.doOutput = true
+ connection.setRequestProperty("Content-Type", "application/json")
+ connection.outputStream.use { it.write(resultJson.toByteArray(Charsets.UTF_8)) }
+ check(connection.responseCode in 200..299) { "Result callback returned ${connection.responseCode}" }
+ } finally {
+ connection.disconnect()
+ }
+ }
+ println("Stage1BufferComparison runId=$runId streamType=$streamType contentKind=$contentKind " +
+ "bufferMode=$bufferMode " +
+ "lowRamDevice=$lowRamDevice " +
+ "firstFrameMs=$firstFrameAtMs samples=${samples.length()} " +
+ "finalState=${engine.playbackState.value} bufferMs=${last.bufferedDurationMs} " +
+ "rebuffers=${last.rebufferCount} dropped=${last.droppedFrames} " +
+ "size=${last.width}x${last.height} errors=${errors.length()}")
+ } finally {
+ scope.cancel()
+ errorJob.cancel()
+ main {
+ engine.stop()
+ engine.clearPreloadWindow()
+ renderView?.let(engine::releaseRenderView)
+ videoDecoderMode?.let { engine.setDecoderModes(originalAudioMode, originalVideoMode) }
+ }
+ scenario.close()
+ }
+ }
+
+ private fun CoroutineScope.launchCollectErrors(engine: PlayerEngine, errors: JSONArray) = launch {
+ engine.error.collect { error -> if (error != null) synchronized(errors) { errors.put(error.javaClass.simpleName) } }
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackContentionRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackContentionRuntimeTest.kt
new file mode 100644
index 00000000..1aa80697
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackContentionRuntimeTest.kt
@@ -0,0 +1,135 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.os.SystemClock
+import androidx.test.core.app.ActivityScenario
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.streamvault.app.MainActivity
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
+import com.streamvault.player.*
+import com.streamvault.player.playback.FrameThumbnailRequest
+import com.streamvault.player.playback.Media3FrameThumbnailExtractor
+import dagger.hilt.internal.GeneratedComponentManager
+import javax.inject.Provider
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.collect
+import okhttp3.OkHttpClient
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.CopyOnWriteArrayList
+
+/** Opt-in measured probe of production playback components, not the episode navigation UI. */
+@RunWith(AndroidJUnit4::class)
+class PlaybackContentionRuntimeTest {
+ @Test fun compareForegroundWithBackgroundReaders() = runBlocking {
+ assumeTrue(InstrumentationRegistry.getArguments().getString("contentionFixture") == "true")
+ val instrumentation = InstrumentationRegistry.getInstrumentation()
+ val app = ApplicationProvider.getApplicationContext<Application>()
+ val component = (app as GeneratedComponentManager<*>).generatedComponent()
+ fun provided(name: String) = (component.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(component) as Provider<*>).get()
+ val engine = provided("provideMainPlayerEngineProvider") as PlayerEngine
+ val client = provided("provideOkHttpClientProvider") as OkHttpClient
+ val extractor = Media3FrameThumbnailExtractor(app, client)
+ val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+ val errors = CopyOnWriteArrayList<String>()
+ val errorJob = scope.launch { engine.error.collect { if (it != null) errors += it.javaClass.simpleName } }
+ fun main(action: () -> Unit) = instrumentation.runOnMainSync(action)
+ fun server(path: String, body: String? = null): JSONObject {
+ val connection = URL("http://10.0.2.2:18768/$path").openConnection() as HttpURLConnection
+ connection.connectTimeout = 5_000; connection.readTimeout = 5_000
+ if (body != null) { connection.requestMethod = "POST"; connection.doOutput = true; connection.outputStream.use { it.write(body.toByteArray()) } }
+ return try { JSONObject(connection.inputStream.bufferedReader().use { it.readText() }) } finally { connection.disconnect() }
+ }
+ suspend fun waitReady() {
+ withTimeout(30_000) { while (!engine.isPlaying.value || engine.playbackState.value != PlaybackState.READY) delay(100) }
+ }
+ val results = JSONArray()
+ val foregroundPriority = InstrumentationRegistry.getArguments().getString("foregroundPriority") == "true"
+ val connectionLimitOnly = InstrumentationRegistry.getArguments().getString("connectionLimitOnly") == "true"
+ val scenario = ActivityScenario.launch(MainActivity::class.java)
+ var render: android.view.View? = null
+ try {
+ scenario.onActivity { activity ->
+ render = engine.createRenderView(activity, PlayerSurfaceResizeMode.FIT)
+ activity.setContentView(render)
+ engine.bindRenderView(render!!, PlayerSurfaceResizeMode.FIT)
+ }
+ val cases = if (connectionLimitOnly) listOf(
+ Case("one_connection_neighbors", false, true, 1)
+ ) else if (foregroundPriority) listOf(
+ Case("priority_off", false, false, 0, seconds = 90),
+ Case("priority_neighbors", false, true, 0, seconds = 90),
+ Case("healthy_neighbors", false, true, 0, rateBps = 30_000_000),
+ Case("one_connection_neighbors", false, true, 1)
+ ) else listOf(
+ Case("off", false, false, 0), Case("thumbnails", true, false, 0),
+ Case("neighbors", false, true, 0), Case("both", true, true, 0),
+ Case("one_connection_off", false, false, 1), Case("one_connection_both", true, true, 1)
+ )
+ for (case in cases) {
+ val (name, thumbnails, neighbors, limit) = case
+ main { engine.stop(); engine.clearPreloadWindow() }
+ extractor.clearCache(); delay(2_000); errors.clear()
+ server("control", "{\"rate_bps\":${case.rateBps},\"limit\":$limit}")
+ fun stream(role: String) = StreamInfo(
+ "http://10.0.2.2:18768/$role.mp4?case=$name", title = "Contention $role",
+ headers = mapOf("X-Validation-Role" to role), streamType = StreamType.PROGRESSIVE,
+ containerExtension = "mp4", playbackContentKind = PlaybackContentKind.ON_DEMAND
+ )
+ val current = stream("foreground"); val next = stream("next")
+ val before = SystemClock.elapsedRealtime()
+ main { engine.prepare(current); engine.play() }
+ waitReady()
+ val startup = SystemClock.elapsedRealtime() - before
+ if (neighbors) main { engine.preloadWindow(PlayerPreloadWindow(listOf(
+ PlayerPreloadItem("previous", stream("previous"), PlayerPreloadContentType.VOD),
+ PlayerPreloadItem("current", current, PlayerPreloadContentType.VOD),
+ PlayerPreloadItem("next", next, PlayerPreloadContentType.VOD)
+ ), 1)) }
+ var frames = 0
+ val thumbnailsJob = if (thumbnails) scope.launch {
+ for (position in listOf(0L, 10_000L, 20_000L, 30_000L, 40_000L, 50_000L)) {
+ if (extractor.loadFrame(FrameThumbnailRequest(current.copy(headers = mapOf("X-Validation-Role" to "thumbnail")), false), position) != null) frames++
+ }
+ } else null
+ val samples = JSONArray()
+ repeat(case.seconds) { i ->
+ val stats = engine.playerStats.value
+ samples.put(JSONObject().put("second", i).put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames)
+ .put("state", engine.playbackState.value.name).put("position", engine.currentPosition.value))
+ delay(1_000)
+ }
+ thumbnailsJob?.cancelAndJoin()
+ val delivery = server("status")
+ val handoffStart = SystemClock.elapsedRealtime()
+ main { engine.prepare(next); engine.play() }
+ val handoffFailure = runCatching { waitReady() }.exceptionOrNull()?.javaClass?.simpleName
+ val handoff = SystemClock.elapsedRealtime() - handoffStart
+ val result = JSONObject().put("case", name).put("startupMs", startup).put("nextReadyMs", handoff)
+ .put("handoffFailure", handoffFailure ?: JSONObject.NULL)
+ .put("thumbnailFrames", frames).put("samples", samples).put("errors", JSONArray(errors)).put("server", delivery)
+ results.put(result)
+ java.io.File(app.filesDir, "contention-results.json").writeText(results.toString(2))
+ println("Stage5 completed $name startupMs=$startup nextReadyMs=$handoff thumbnailFrames=$frames errors=${errors.size}")
+ }
+ } finally {
+ scope.cancel(); errorJob.cancel()
+ main { engine.stop(); engine.clearPreloadWindow(); render?.let { engine.releaseRenderView(it) } }
+ extractor.clearCache(); scenario.close()
+ }
+ }
+ private data class Case(
+ val name: String, val thumbnails: Boolean, val neighbors: Boolean, val limit: Int,
+ val rateBps: Int = 8_000_000, val seconds: Int = 60
+ )
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackV3RuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackV3RuntimeTest.kt
new file mode 100644
index 00000000..aa21ff6a
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackV3RuntimeTest.kt
@@ -0,0 +1,951 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.graphics.Bitmap
+import android.os.Debug
+import android.os.SystemClock
+import android.view.InputDevice
+import android.view.MotionEvent
+import android.view.View
+import android.util.Log
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.hasClickAction
+import androidx.compose.ui.test.hasScrollToIndexAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.compose.ui.test.performScrollToIndex
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.Program
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
+import com.streamvault.domain.repository.ChannelRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.domain.repository.SeriesRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.feature.playback.player.SeekThumbnailProvider
+import com.streamvault.feature.playback.player.updateSeekPreview
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import com.streamvault.player.playback.ResolvedStreamType
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URI
+import java.net.URL
+import java.security.MessageDigest
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import okhttp3.OkHttpClient
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in V3 normal-player scrubbing, episode handoff, and cancellation probe. */
+@RunWith(AndroidJUnit4::class)
+class PlaybackV3RuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val fixtureName = "Playback resilience V3 20261003"
+ private val providerUrl = "http://10.0.2.2:18773"
+ private val outputDir get() = File(app.filesDir, "playback-v3-private")
+ private var lastArchiveFirstFrameMs = 0L
+ private data class TimelineScreenArea(val left: Float, val top: Float, val width: Float, val height: Float) {
+ fun point(fraction: Float) = Offset(left + width * fraction.coerceIn(0.02f, 0.98f), top + height / 2f)
+ }
+
+ @Test
+ fun validateLegacyRemoteReadCancellation() {
+ assumeTrue(InstrumentationRegistry.getArguments().getString("playbackV3Fixture") == "true")
+ val provider = SeekThumbnailProvider(app, OkHttpClient())
+ server("/control?failBeta=false&failEpisodeId=none&cap=5&reset=1")
+ try {
+ runBlocking {
+ repeat(2) { requestNumber ->
+ val url = "$providerUrl/thumbnail/slow.mp4?cancel-check=${SystemClock.elapsedRealtime()}-$requestNumber"
+ val job = launch(Dispatchers.IO) { provider.loadFrame(url, 170_000) }
+ withTimeout(5_000) {
+ while (eventCount(server("/stats"), "request-start", role = "native-thumbnail") < requestNumber + 1) {
+ delay(50)
+ }
+ }
+
+ val cancelledAt = SystemClock.elapsedRealtime()
+ job.cancel()
+ withTimeout(8_000) {
+ while (true) {
+ val stats = server("/stats")
+ val active = stats.getJSONArray("active").let { rows ->
+ (0 until rows.length()).count { rows.getJSONObject(it).optString("role") == "native-thumbnail" }
+ }
+ if (active == 0) break
+ delay(50)
+ }
+ }
+ job.join()
+ assertThat(SystemClock.elapsedRealtime() - cancelledAt).isLessThan(8_000)
+ assertThat(thumbnailWorkerThreads().length()).isEqualTo(0)
+ }
+ }
+ } finally {
+ server("/control?failBeta=false&failEpisodeId=none&cap=5&reset=1")
+ }
+ }
+
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("playbackV3Fixture") == "true")
+
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+
+ private fun server(path: String): JSONObject {
+ val connection = URL("$providerUrl$path").openConnection() as HttpURLConnection
+ connection.connectTimeout = 5_000
+ connection.readTimeout = 10_000
+ return try { JSONObject(connection.inputStream.bufferedReader().use { it.readText() }) }
+ finally { connection.disconnect() }
+ }
+
+ private fun await(label: String, timeoutMs: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeoutMs
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ device.takeScreenshot(File(outputDir, "timeout-$label.png"))
+ device.dumpWindowHierarchy(File(outputDir, "timeout-$label.xml"))
+ error("Timed out: $label")
+ }
+
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("S01E")) {
+ compose.onNodeWithText(text, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 20_000)
+ ?: run {
+ outputDir.mkdirs()
+ val safeLabel = text.replace(Regex("[^A-Za-z0-9_-]"), "_")
+ device.takeScreenshot(File(outputDir, "missing-$safeLabel.png"))
+ device.dumpWindowHierarchy(File(outputDir, "missing-$safeLabel.xml"))
+ error("Missing V3 UI text after 20 seconds: $text")
+ }
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+
+ private fun acceptResumePromptIfPresent() {
+ compose.waitForIdle()
+ if (device.findObject(By.text("Resume Playback")) == null) return
+ val resume = device.findObject(By.text("Resume")) ?: error("Resume prompt has no Resume button")
+ val bounds = resume.visibleBounds
+ device.executeShellCommand("input mouse tap ${bounds.centerX()} ${bounds.centerY()}")
+ compose.waitForIdle()
+ Log.i("PlaybackV3Fixture", "episode-resume-prompt accepted=true")
+ }
+
+ private fun findPlayers(store: ViewModelStore): List<PlayerViewModel> {
+ val found = mutableListOf<PlayerViewModel>()
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) found += model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val values = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ values.values.filterIsInstance<ViewModelStore>().forEach { found += findPlayers(it) }
+ }
+ }
+ return found.distinct()
+ }
+
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+
+ private fun setter(owner: Any, name: String, value: Any?) {
+ owner.javaClass.methods.single {
+ it.name.substringBefore('$') == name && it.parameterCount == 1
+ }.invoke(owner, value)
+ }
+
+ private fun resolvedPlaybackUrl(vm: PlayerViewModel): String =
+ getter(vm, "getCurrentResolvedPlaybackUrl") as String
+
+ private fun setResolvedPlaybackUrl(vm: PlayerViewModel, value: String) =
+ setter(vm, "setCurrentResolvedPlaybackUrl", value)
+
+ private fun resolvedStreamInfo(vm: PlayerViewModel): StreamInfo? =
+ getter(vm, "getCurrentResolvedStreamInfo") as StreamInfo?
+
+ private fun setResolvedStreamInfo(vm: PlayerViewModel, value: StreamInfo?) =
+ setter(vm, "setCurrentResolvedStreamInfo", value)
+
+ private fun vmForEpisode(number: Int): PlayerViewModel {
+ lateinit var vm: PlayerViewModel
+ await("episode $number ViewModel") {
+ var found = false
+ instrumentation.runOnMainSync {
+ findPlayers(compose.activity.viewModelStore).singleOrNull {
+ it.currentEpisode.value?.episodeNumber == number &&
+ it.playerEngine.isPlaying.value && it.playerEngine.playbackState.value == PlaybackState.READY
+ }?.let {
+ vm = it
+ found = true
+ }
+ }
+ found
+ }
+ return vm
+ }
+
+ private fun activeSource(engine: PlayerEngine): StreamInfo? = engine.javaClass
+ .getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as? StreamInfo
+
+ private fun playEpisodeFromDetails(number: Int): PlayerViewModel {
+ val label = "S01E%02d".format(number)
+ repeat(8) {
+ if (compose.onAllNodesWithText(label, substring = true).fetchSemanticsNodes().isNotEmpty()) return@repeat
+ val x = (device.displayWidth * 0.78f).toInt()
+ val startY = (device.displayHeight * 0.82f).toInt()
+ val endY = (device.displayHeight * 0.28f).toInt()
+ device.swipe(x, startY, x, endY, 12)
+ SystemClock.sleep(300)
+ compose.waitForIdle()
+ }
+ await("episode button $label") {
+ compose.onAllNodesWithText(label, substring = true).fetchSemanticsNodes().isNotEmpty()
+ }
+ val started = SystemClock.elapsedRealtime()
+ click(label)
+ val vm = vmForEpisode(number)
+ await("episode $number first frame") {
+ val source = activeSource(vm.playerEngine)
+ source?.url?.let { URI(it).path?.endsWith("/${73100 + number}.mp4") } == true &&
+ vm.playerEngine.playerStats.value.ttffMs > 0
+ }
+ Log.i("PlaybackV3Fixture", "episode-ready number=$number elapsedMs=${SystemClock.elapsedRealtime() - started} " +
+ "ttffMs=${vm.playerEngine.playerStats.value.ttffMs} bufferMs=${vm.playerEngine.playerStats.value.bufferedDurationMs}")
+ return vm
+ }
+
+ private fun openEpisodePicker(vm: PlayerViewModel) {
+ ensureVodControlsVisible(vm)
+ val label = app.getString(com.streamvault.feature.playback.R.string.player_episodes)
+ await("episode picker control") { compose.onAllNodesWithContentDescription(label).fetchSemanticsNodes().isNotEmpty() }
+ compose.onNodeWithContentDescription(label).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+
+ private fun selectAdjacentEpisode(vm: PlayerViewModel, number: Int): Long {
+ openEpisodePicker(vm)
+ val title = "S01E%02d".format(number)
+ await("picker episode $title") { compose.onAllNodesWithText(title, substring = true).fetchSemanticsNodes().isNotEmpty() }
+ val started = SystemClock.elapsedRealtime()
+ click(title)
+ acceptResumePromptIfPresent()
+ await("episode $number first frame") {
+ vm.currentEpisode.value?.episodeNumber == number && vm.playerEngine.isPlaying.value &&
+ vm.playerEngine.playbackState.value == PlaybackState.READY && vm.playerEngine.playerStats.value.ttffMs > 0
+ }
+ val elapsed = SystemClock.elapsedRealtime() - started
+ val source = activeSource(vm.playerEngine) ?: error("No physical episode source")
+ assertThat(URI(source.url).path).endsWith("/${73100 + number}.mp4")
+ val history = history(vm)
+ assertThat(history.contentId).isEqualTo(vm.currentEpisode.value?.id)
+ assertThat(history.seriesId).isEqualTo(vm.currentSeries.value?.id)
+ Log.i("PlaybackV3Fixture", "episode-handoff number=$number elapsedMs=$elapsed ttffMs=${vm.playerEngine.playerStats.value.ttffMs} " +
+ "historyContentId=${history.contentId} historyPositionMs=${history.resumePositionMs}")
+ return elapsed
+ }
+
+ private fun eventCount(stats: JSONObject, event: String, role: String? = null, program: String? = null): Int {
+ val events = stats.getJSONArray("events")
+ return (0 until events.length()).count { index ->
+ val row = events.getJSONObject(index)
+ row.optString("event") == event && (role == null || row.optString("role") == role) &&
+ (program == null || row.optString("program") == program || row.optString("episode") == program)
+ }
+ }
+
+ private fun awaitNativeThumbnailStarts(expected: Int, timeoutMs: Long = 15_000): JSONObject? {
+ val end = SystemClock.elapsedRealtime() + timeoutMs
+ var stats = server("/stats")
+ while (SystemClock.elapsedRealtime() < end) {
+ stats = server("/stats")
+ if (eventCount(stats, "request-start", role = "native-thumbnail") >= expected) return stats
+ SystemClock.sleep(100)
+ }
+ return null
+ }
+
+ private fun timelineScreenArea(timeline: String): TimelineScreenArea {
+ val bounds = compose.onNodeWithContentDescription(timeline).fetchSemanticsNode().boundsInRoot
+ val location = IntArray(2)
+ instrumentation.runOnMainSync {
+ compose.activity.window.decorView.findViewById<View>(android.R.id.content).getLocationOnScreen(location)
+ }
+ return TimelineScreenArea(location[0] + bounds.left, location[1] + bounds.top, bounds.width, bounds.height)
+ }
+
+ private fun injectTimelineEvent(action: Int, point: Offset, downTimeMs: Long) {
+ val event = MotionEvent.obtain(downTimeMs, SystemClock.uptimeMillis(), action, point.x, point.y, 0).apply {
+ source = InputDevice.SOURCE_TOUCHSCREEN
+ }
+ try {
+ check(instrumentation.uiAutomation.injectInputEvent(event, true)) { "Could not inject timeline motion event $action" }
+ } finally {
+ event.recycle()
+ }
+ }
+
+ private fun beginTimelineGesture(area: TimelineScreenArea, startFraction: Float, targetFraction: Float): Long {
+ val downTime = SystemClock.uptimeMillis()
+ injectTimelineEvent(MotionEvent.ACTION_DOWN, area.point(startFraction), downTime)
+ SystemClock.sleep(40)
+ injectTimelineEvent(MotionEvent.ACTION_MOVE, area.point(targetFraction), downTime)
+ return downTime
+ }
+
+ private fun moveTimelineGesture(area: TimelineScreenArea, targetFraction: Float, downTimeMs: Long) {
+ injectTimelineEvent(MotionEvent.ACTION_MOVE, area.point(targetFraction), downTimeMs)
+ }
+
+ private fun endTimelineGesture(area: TimelineScreenArea, targetFraction: Float, downTimeMs: Long) {
+ injectTimelineEvent(MotionEvent.ACTION_UP, area.point(targetFraction), downTimeMs)
+ compose.waitForIdle()
+ }
+
+ private fun thumbnailWorkerThreads(): JSONArray {
+ val rows = JSONArray()
+ Thread.getAllStackTraces().forEach { (thread, stack) ->
+ if (stack.any { it.className.contains("SeekThumbnailProvider") || it.className.contains("MediaMetadataRetriever") }) {
+ rows.put(JSONObject().put("name", thread.name).put("state", thread.state.name)
+ .put("frames", stack.take(8).joinToString(" | ") { "${it.className}.${it.methodName}" }))
+ }
+ }
+ return rows
+ }
+
+ private fun dragLegacyThumbnail(vm: PlayerViewModel): JSONObject {
+ ensureVodControlsVisible(vm)
+ val timeline = app.getString(com.streamvault.feature.playback.R.string.player_vod_timeline)
+ await("R7 VOD timeline") { compose.onAllNodesWithContentDescription(timeline).fetchSemanticsNodes().isNotEmpty() }
+ val previousUrl = resolvedPlaybackUrl(vm)
+ val previousInfo = resolvedStreamInfo(vm)
+ val slowUrl = "$providerUrl/thumbnail/slow.mp4?run=${SystemClock.elapsedRealtime()}"
+ val began = SystemClock.elapsedRealtime()
+ try {
+ setResolvedPlaybackUrl(vm, slowUrl)
+ setResolvedStreamInfo(vm, previousInfo?.copy(url = slowUrl, headers = emptyMap(), userAgent = null))
+ server("/control?reset=1")
+ val area = timelineScreenArea(timeline)
+ val duration = vm.playerEngine.duration.value.coerceAtLeast(1L)
+ val startFraction = (vm.playerEngine.currentPosition.value.toFloat() / duration).coerceIn(0.02f, 0.98f)
+ val firstTarget = (startFraction + 0.08f).coerceAtMost(0.95f)
+ val secondTarget = (firstTarget + 0.08f).coerceAtMost(0.98f)
+ var downTime: Long? = null
+ var first: JSONObject? = null
+ var second: JSONObject? = null
+ try {
+ val gestureDownTime = beginTimelineGesture(area, startFraction, firstTarget)
+ downTime = gestureDownTime
+ first = awaitNativeThumbnailStarts(1)
+ if (first != null) {
+ moveTimelineGesture(area, secondTarget, gestureDownTime)
+ second = awaitNativeThumbnailStarts(2, timeoutMs = 5_000)
+ }
+ } finally {
+ downTime?.let { endTimelineGesture(area, if (second != null) secondTarget else firstTarget, it) }
+ }
+ await("R7 scrub release clears preview") { !vm.seekPreview.value.visible }
+ val releasedAt = SystemClock.elapsedRealtime()
+ val samples = JSONArray()
+ while (SystemClock.elapsedRealtime() - releasedAt < 8_000) {
+ val stats = server("/stats")
+ val player = vm.playerEngine.playerStats.value
+ samples.put(JSONObject().put("elapsedMs", SystemClock.elapsedRealtime() - releasedAt)
+ .put("nativeActive", stats.getJSONArray("active").let { active -> (0 until active.length()).count { active.getJSONObject(it).optString("role") == "native-thumbnail" } })
+ .put("nativeWorkerThreads", thumbnailWorkerThreads()).put("positionMs", vm.playerEngine.currentPosition.value)
+ .put("state", vm.playerEngine.playbackState.value.name).put("playing", vm.playerEngine.isPlaying.value)
+ .put("bufferMs", player.bufferedDurationMs).put("rebuffers", player.rebufferCount)
+ .put("drops", player.droppedFrames).put("pssKb", Debug.getPss()))
+ SystemClock.sleep(250)
+ }
+ val boundStats = server("/stats")
+ val boundActive = boundStats.getJSONArray("active").let { active ->
+ (0 until active.length()).count { active.getJSONObject(it).optString("role") == "native-thumbnail" }
+ }
+ val boundWorkers = thumbnailWorkerThreads()
+ val bounded = boundActive == 0 && boundWorkers.length() == 0
+ val result = JSONObject().put("declaredCancellationBoundMs", 8_000).put("firstRequestStarted", first != null)
+ .put("secondRequestStarted", second != null).put("nativeStarts", eventCount(boundStats, "request-start", "native-thumbnail"))
+ .put("nativeEndsAtBound", eventCount(boundStats, "request-end", "native-thumbnail"))
+ .put("nativeActiveAtBound", boundActive).put("workersAtBound", boundWorkers).put("withinBound", bounded)
+ .put("foregroundSamples", samples).put("previewHiddenAfterRelease", !vm.seekPreview.value.visible)
+ .put("elapsedMs", SystemClock.elapsedRealtime() - began)
+ File(outputDir, "r7-rapid-scrub.json").writeText(result.toString(2))
+ Log.i("PlaybackV3Fixture", "R7 rapidScrub first=${first != null} second=${second != null} withinBound=$bounded")
+ return result
+ } finally {
+ setResolvedPlaybackUrl(vm, previousUrl)
+ setResolvedStreamInfo(vm, previousInfo)
+ }
+ }
+
+ private fun startSlowPreviewAndNavigateAway(vm: PlayerViewModel): JSONObject {
+ val previousUrl = resolvedPlaybackUrl(vm)
+ val previousInfo = resolvedStreamInfo(vm)
+ val slowUrl = "$providerUrl/thumbnail/slow.mp4?navigation=${SystemClock.elapsedRealtime()}"
+ try {
+ server("/control?reset=1")
+ setResolvedPlaybackUrl(vm, slowUrl)
+ setResolvedStreamInfo(vm, previousInfo?.copy(url = slowUrl, headers = emptyMap(), userAgent = null))
+ vm.updateSeekPreview(170_000)
+ val started = awaitNativeThumbnailStarts(1)
+ val began = SystemClock.elapsedRealtime()
+ device.pressBack()
+ await("navigate away from slow preview") {
+ compose.onAllNodesWithContentDescription(app.getString(com.streamvault.feature.playback.R.string.player_vod_timeline))
+ .fetchSemanticsNodes().isEmpty()
+ }
+ val afterDisposeVisible = vm.seekPreview.value.visible
+ val samples = JSONArray()
+ while (SystemClock.elapsedRealtime() - began < 8_000) {
+ val stats = server("/stats")
+ samples.put(JSONObject().put("elapsedMs", SystemClock.elapsedRealtime() - began)
+ .put("nativeActive", stats.getJSONArray("active").let { active -> (0 until active.length()).count { active.getJSONObject(it).optString("role") == "native-thumbnail" } })
+ .put("nativeWorkerThreads", thumbnailWorkerThreads()).put("previewVisible", vm.seekPreview.value.visible)
+ .put("previewLoading", vm.seekPreview.value.isLoading))
+ SystemClock.sleep(250)
+ }
+ val finalStats = server("/stats")
+ val result = JSONObject().put("nativeStarted", started != null)
+ .put("nativeStartCount", started?.let { eventCount(it, "request-start", "native-thumbnail") } ?: 0)
+ .put("nativeEndsAtBound", eventCount(finalStats, "request-end", "native-thumbnail"))
+ .put("nativeActiveAtBound", finalStats.getJSONArray("active").let { active -> (0 until active.length()).count { active.getJSONObject(it).optString("role") == "native-thumbnail" } })
+ .put("previewVisibleAfterDispose", afterDisposeVisible).put("previewVisibleAtBound", vm.seekPreview.value.visible)
+ .put("workerThreadsAtBound", thumbnailWorkerThreads()).put("samples", samples)
+ result.put("previewClearedAfterDispose", !afterDisposeVisible && !vm.seekPreview.value.visible)
+ .put("withinBound", result.getInt("nativeActiveAtBound") == 0 && result.getJSONArray("workerThreadsAtBound").length() == 0)
+ File(outputDir, "r7-navigation-away.json").writeText(result.toString(2))
+ return result
+ } finally {
+ setResolvedPlaybackUrl(vm, previousUrl)
+ setResolvedStreamInfo(vm, previousInfo)
+ }
+ }
+
+ private fun history(vm: PlayerViewModel): PlaybackHistory = vm.javaClass.methods
+ .single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, vm.playerEngine.currentPosition.value, vm.playerEngine.duration.value) as PlaybackHistory
+
+ private fun ensureVodControlsVisible(vm: PlayerViewModel) {
+ if (!vm.showControls.value) {
+ // A centered screen tap reveals VOD controls without activating a focused Play button.
+ device.executeShellCommand("input mouse tap ${device.displayWidth / 2} ${device.displayHeight / 2}")
+ }
+ await("VOD player controls visible") { vm.showControls.value }
+ compose.waitForIdle()
+ }
+ private fun preloadRefresh(vm: PlayerViewModel) {
+ vm.javaClass.declaredMethods.single {
+ it.name.substringBefore('$') == "clearPreloadWindow" && it.parameterCount == 0
+ }.apply { isAccessible = true }.invoke(vm)
+ val requestVersion = getter(vm, "getPrepareRequestVersion") as Long
+ vm.javaClass.declaredMethods.single {
+ it.name.substringBefore('$') == "refreshPreloadWindow" && it.parameterCount == 1
+ }.apply { isAccessible = true }.invoke(vm, requestVersion)
+ }
+
+ private fun awaitScrubPlayback(vm: PlayerViewModel, fraction: Float, label: String) {
+ val engine = vm.playerEngine
+ val targetMs = (engine.duration.value * fraction.coerceIn(0f, 1f)).toLong()
+ val end = SystemClock.elapsedRealtime() + 45_000
+ var lastPosition = engine.currentPosition.value
+ var lastState = engine.playbackState.value
+ var lastPlaying = engine.isPlaying.value
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ lastPosition = engine.currentPosition.value
+ lastState = engine.playbackState.value
+ lastPlaying = engine.isPlaying.value
+ if (lastState == PlaybackState.READY && lastPlaying && kotlin.math.abs(lastPosition - targetMs) <= 15_000L) {
+ return
+ }
+ SystemClock.sleep(100)
+ }
+ device.takeScreenshot(File(outputDir, "timeout-$label.png"))
+ device.dumpWindowHierarchy(File(outputDir, "timeout-$label.xml"))
+ error("Timed out: $label targetMs=$targetMs positionMs=$lastPosition state=$lastState playing=$lastPlaying")
+ }
+
+ private fun dragTimeline(vm: PlayerViewModel, enabled: Boolean, fraction: Float): JSONObject {
+ ensureVodControlsVisible(vm)
+ val timeline = app.getString(com.streamvault.feature.playback.R.string.player_vod_timeline)
+ await("VOD timeline") { compose.onAllNodesWithContentDescription(timeline).fetchSemanticsNodes().isNotEmpty() }
+ val previousUrl = resolvedPlaybackUrl(vm)
+ val previousInfo = resolvedStreamInfo(vm)
+ val engine = vm.playerEngine
+ val positionBeforeMs = engine.currentPosition.value
+ val durationMs = engine.duration.value
+ check(durationMs > 0L) { "VOD timeline has no duration" }
+ val targetFraction = fraction.coerceIn(0.02f, 0.98f)
+ val targetPositionMs = (durationMs * targetFraction).toLong()
+ val startFraction = (positionBeforeMs.toFloat() / durationMs.toFloat()).coerceIn(0.02f, 0.98f)
+ if (!enabled) {
+ val unsupported = "rtsp://preview-disabled.invalid/live"
+ setResolvedPlaybackUrl(vm, unsupported)
+ setResolvedStreamInfo(vm, previousInfo?.copy(url = unsupported, streamType = StreamType.RTSP))
+ }
+ val began = SystemClock.elapsedRealtime()
+ var previewMs: Long? = null
+ var width = 0
+ var height = 0
+ var previewVisibleWhileScrubbing = false
+ var previewLoadingWhileScrubbing = false
+ var previewPositionMs: Long? = null
+ val previousBitmap = vm.seekPreview.value.frameBitmap
+ val statsBefore = server("/stats")
+ val startsBefore = statsBefore.getJSONArray("events").length()
+ var area: TimelineScreenArea? = null
+ var downTime: Long? = null
+ var released = false
+ try {
+ val gestureArea = timelineScreenArea(timeline)
+ area = gestureArea
+ val gestureDownTime = beginTimelineGesture(gestureArea, startFraction, targetFraction)
+ downTime = gestureDownTime
+ val deadline = SystemClock.elapsedRealtime() + 5_000
+ while (enabled && SystemClock.elapsedRealtime() < deadline) {
+ val preview = vm.seekPreview.value
+ if (preview.visible) {
+ previewVisibleWhileScrubbing = true
+ previewPositionMs = preview.positionMs
+ previewLoadingWhileScrubbing = previewLoadingWhileScrubbing || preview.isLoading
+ }
+ val bitmap = preview.frameBitmap
+ if (bitmap != null && bitmap !== previousBitmap) {
+ previewMs = SystemClock.elapsedRealtime() - began
+ width = bitmap.width
+ height = bitmap.height
+ break
+ }
+ Thread.sleep(25)
+ }
+ if (!enabled) {
+ SystemClock.sleep(250)
+ assertThat(vm.seekPreview.value.isLoading).isFalse()
+ assertThat(vm.seekPreview.value.frameBitmap).isNull()
+ }
+ endTimelineGesture(gestureArea, targetFraction, gestureDownTime)
+ released = true
+ } finally {
+ if (!released) {
+ val openArea = area
+ val openDownTime = downTime
+ if (openArea != null && openDownTime != null) {
+ runCatching { endTimelineGesture(openArea, targetFraction, openDownTime) }
+ }
+ }
+ setResolvedPlaybackUrl(vm, previousUrl)
+ setResolvedStreamInfo(vm, previousInfo)
+ }
+ assertThat(vm.seekPreview.value.visible).isFalse()
+ val stats = server("/stats")
+ val events = stats.getJSONArray("events")
+ val thumbnailRequestDelta = JSONArray()
+ for (index in startsBefore until events.length()) {
+ val event = events.getJSONObject(index)
+ if (event.optString("event") == "request-start") {
+ thumbnailRequestDelta.put(JSONObject().put("role", event.optString("role"))
+ .put("agent", event.optString("agent")).put("program", event.optString("program")))
+ }
+ }
+ return JSONObject().put("enabled", enabled).put("fraction", targetFraction)
+ .put("targetPositionMs", targetPositionMs).put("positionBeforeMs", positionBeforeMs)
+ .put("positionAtReleaseMs", engine.currentPosition.value).put("stateAtRelease", engine.playbackState.value.name)
+ .put("playingAtRelease", engine.isPlaying.value).put("previewMs", previewMs ?: JSONObject.NULL)
+ .put("previewVisibleWhileScrubbing", previewVisibleWhileScrubbing)
+ .put("previewLoadingWhileScrubbing", previewLoadingWhileScrubbing).put("previewPositionMs", previewPositionMs ?: JSONObject.NULL)
+ .put("previewWidth", width).put("previewHeight", height).put("thumbnailRequestDelta", thumbnailRequestDelta)
+ .put("contentType", getter(vm, "getCurrentContentType")?.toString())
+ .put("resolvedUrlPath", URI(resolvedPlaybackUrl(vm)).path)
+ .put("bufferMs", engine.playerStats.value.bufferedDurationMs)
+ .put("rebuffers", engine.playerStats.value.rebufferCount).put("drops", engine.playerStats.value.droppedFrames)
+ .put("nativeHeapBytes", Debug.getNativeHeapAllocatedSize())
+ }
+
+ private fun capturePlayback(vm: PlayerViewModel, label: String): JSONObject {
+ val folder = File(outputDir, label).apply { mkdirs() }
+ val samples = JSONArray()
+ val hashes = mutableListOf<String>()
+ val started = SystemClock.elapsedRealtime()
+ val firstPosition = vm.playerEngine.currentPosition.value
+ repeat(61) { index ->
+ val file = File(folder, "frame-%02d.png".format(index))
+ check(device.takeScreenshot(file)) { "Screenshot failed at $index" }
+ hashes += sha256(file)
+ val stats = vm.playerEngine.playerStats.value
+ val sourceEpisode = activeSource(vm.playerEngine)?.url?.let { URI(it).path?.substringAfterLast('/') }
+ samples.put(JSONObject().put("elapsedMs", SystemClock.elapsedRealtime() - started)
+ .put("positionMs", vm.playerEngine.currentPosition.value).put("state", vm.playerEngine.playbackState.value.name)
+ .put("playing", vm.playerEngine.isPlaying.value)
+ .put("logicalEpisode", vm.currentEpisode.value?.episodeNumber).put("sourceEpisode", sourceEpisode)
+ .put("bufferMs", stats.bufferedDurationMs).put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames)
+ .put("ttffMs", stats.ttffMs).put("pssKb", Debug.getPss()).put("nativeHeapBytes", Debug.getNativeHeapAllocatedSize()))
+ if (index < 60) SystemClock.sleep(2_000)
+ }
+ val positions = vm.playerEngine.currentPosition.value
+ val unique = hashes.toSet().size
+ val adjacent = hashes.zipWithNext().count { (a, b) -> a != b }
+ val summary = JSONObject().put("label", label).put("frameCount", hashes.size).put("durationMs", SystemClock.elapsedRealtime() - started)
+ .put("uniqueHashes", unique).put("adjacentChanges", adjacent).put("positionStartMs", firstPosition)
+ .put("positionEndMs", positions).put("positionDeltaMs", positions - firstPosition)
+ .put("finalState", vm.playerEngine.playbackState.value.name).put("finalPlaying", vm.playerEngine.isPlaying.value)
+ .put("samples", samples)
+ File(folder, "summary.json").writeText(summary.toString(2))
+ assertThat(positions).isGreaterThan(firstPosition + 90_000)
+ assertThat(vm.playerEngine.playbackState.value).isEqualTo(PlaybackState.READY)
+ assertThat(vm.playerEngine.isPlaying.value).isTrue()
+ Log.i("PlaybackV3Fixture", "capture label=$label frames=${hashes.size} unique=$unique adjacent=$adjacent " +
+ "durationMs=${summary.getLong("durationMs")} positionDelta=${positions - firstPosition} " +
+ "rebuffers=${vm.playerEngine.playerStats.value.rebufferCount} drops=${vm.playerEngine.playerStats.value.droppedFrames}")
+ return summary
+ }
+
+ private fun sha256(file: File): String = MessageDigest.getInstance("SHA-256")
+ .digest(file.readBytes()).joinToString("") { "%02x".format(it) }
+
+ private suspend fun awaitProviderCap(repository: ProviderRepository, id: Long, expected: Int) {
+ withTimeout(30_000) {
+ while (repository.getProvider(id)?.maxConnections != expected) delay(100)
+ }
+ }
+
+ private suspend fun setFixtureCap(repository: ProviderRepository, id: Long, expected: Int) {
+ val provider = repository.getProvider(id) ?: error("V3 fixture provider disappeared")
+ if (provider.maxConnections != expected) {
+ check(repository.updateProvider(provider.copy(maxConnections = expected)).isSuccess) {
+ "Could not set V3 fixture connection cap"
+ }
+ }
+ awaitProviderCap(repository, id, expected)
+ }
+
+ private suspend fun syncFixture(providerId: Long, providers: ProviderRepository) {
+ check(providers.refreshProviderData(providerId, force = true).isSuccess) { "V3 fixture provider refresh failed" }
+ val series = component("seriesRepositoryImplProvider") as SeriesRepository
+ val categories = series.getCategories(providerId).first()
+ check(categories.any { it.name == "V3 Episode Validation" }) { "V3 series category missing" }
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(providerId, section = ContentType.SERIES, force = true).isSuccess)
+ val categoryId = categories.single { it.name == "V3 Episode Validation" }.id
+ withTimeout(60_000) { series.getSeriesByCategory(providerId, categoryId).first { it.isNotEmpty() } }
+ check(sync.processQueuedXtreamIndexJobs(providerId, section = ContentType.LIVE, force = true).isSuccess)
+ val channels = component("channelRepositoryImplProvider") as ChannelRepository
+ withTimeout(60_000) { channels.getChannels(providerId).first { rows -> rows.any { it.name == "V3 Catch-up Channel" } } }
+ }
+
+ private fun openArchive(name: String): PlayerViewModel {
+ await("V3 channel row") {
+ compose.onAllNodesWithContentDescription("V3 Catch-up Channel", substring = true).fetchSemanticsNodes().isNotEmpty()
+ }
+ compose.onNodeWithContentDescription("V3 Catch-up Channel", substring = true)
+ .performSemanticsAction(SemanticsActions.OnClick) { it() }
+ SystemClock.sleep(800)
+ if (compose.onAllNodesWithContentDescription("V3 Catch-up Channel", substring = true).fetchSemanticsNodes().isNotEmpty()) {
+ compose.onNodeWithContentDescription("V3 Catch-up Channel", substring = true)
+ .performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ lateinit var vm: PlayerViewModel
+ await("V3 live player") {
+ instrumentation.runOnMainSync {
+ vm = findPlayers(compose.activity.viewModelStore).singleOrNull {
+ getter(it, "getCurrentTitle") == "V3 Catch-up Channel" && it.playerEngine.isPlaying.value
+ } ?: return@runOnMainSync
+ }
+ getter(vm, "getCurrentTitle") == "V3 Catch-up Channel"
+ }
+ await("V3 programme guide") {
+ vm.programHistory.value.count { it.title.startsWith("V3 Program ") } == 3 &&
+ vm.currentProgram.value?.title == "V3 Current Program"
+ }
+ if (!vm.showControls.value) device.pressKeyCode(android.view.KeyEvent.KEYCODE_MENU)
+ await("V3 live transport controls") { vm.showControls.value }
+ val archiveLabel = app.getString(com.streamvault.feature.playback.R.string.player_archive)
+ val archiveAction = androidx.compose.ui.test.hasText(archiveLabel) and hasClickAction()
+ if (compose.onAllNodes(archiveAction).fetchSemanticsNodes().isEmpty()) {
+ compose.onAllNodes(hasScrollToIndexAction())[0].performScrollToIndex(6)
+ }
+ await("V3 archive action") { compose.onAllNodes(archiveAction).fetchSemanticsNodes().isNotEmpty() }
+ compose.onNode(archiveAction).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("V3 archive item") { compose.onAllNodesWithText("V3 Program $name").fetchSemanticsNodes().isNotEmpty() }
+ compose.mainClock.advanceTimeBy(650)
+ val selectionStarted = SystemClock.elapsedRealtime()
+ compose.onNodeWithText("V3 Program $name").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("V3 archive first frame") {
+ val stream = activeSource(vm.playerEngine)
+ stream?.playbackContentKind == PlaybackContentKind.CATCH_UP &&
+ getter(vm, "getCurrentTitle") == "V3 Catch-up Channel: V3 Program $name" &&
+ vm.playerEngine.playbackState.value == PlaybackState.READY && vm.playerEngine.playerStats.value.ttffMs > 0
+ }
+ lastArchiveFirstFrameMs = SystemClock.elapsedRealtime() - selectionStarted
+ Log.i("PlaybackV3Fixture", "catchup-handoff program=$name firstFrameMs=$lastArchiveFirstFrameMs ttffMs=${vm.playerEngine.playerStats.value.ttffMs}")
+ return vm
+ }
+
+ private fun backToFixtureChannel() {
+ var returned = false
+ repeat(5) {
+ if (returned) return@repeat
+ device.pressBack()
+ SystemClock.sleep(400)
+ compose.waitForIdle()
+ returned = compose.onAllNodesWithContentDescription("V3 Catch-up Channel", substring = true).fetchSemanticsNodes().isNotEmpty()
+ }
+ check(returned) { "Normal Back did not return to the V3 catch-up channel" }
+ }
+
+ @Test fun validateNormalUiV3Matrix() = runBlocking {
+ enabled()
+ check(server("/health").getBoolean("ok")) { "Fresh V3 server is not reachable" }
+ outputDir.mkdirs()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val original = providers.getActiveProvider().first() ?: error("Original provider is missing")
+ val originalLast = prefs.lastActiveProviderId.first() ?: original.id
+ val fixtureId = providers.addProvider(LegacyProvider(
+ name = fixtureName, type = ProviderType.XTREAM_CODES, serverUrl = providerUrl,
+ username = "v3-fixture", password = "v3-fixture", maxConnections = 1,
+ allowedOutputFormats = listOf("m3u8", "ts"), preferredLiveStreamFormat = LiveStreamFormatMode.HLS,
+ isActive = false, xtreamFastSyncEnabled = false
+ )).getOrNull() ?: error("V3 fixture provider creation failed")
+ val manifest = JSONObject().put("id", fixtureId).put("name", fixtureName)
+ .put("originalProviderId", original.id).put("originalLastProviderId", originalLast)
+ File(outputDir, "setup-private.json").writeText(manifest.toString(2))
+ try {
+ server("/control?cap=unknown&reset=1")
+ syncFixture(fixtureId, providers)
+ assertThat(providers.getProvider(fixtureId)?.maxConnections).isEqualTo(1)
+ check(providers.setActiveProvider(fixtureId).isSuccess)
+ prefs.setLastActiveProviderId(fixtureId)
+ Log.i("PlaybackV3Fixture", "provider-ready id=$fixtureId requestedCap=unknown effectiveCap=1")
+
+ click("Series")
+ click("V3 Neighbor Fixture")
+ var vm = playEpisodeFromDetails(2)
+ val engine = vm.playerEngine
+ val unknownStart = server("/stats")
+ SystemClock.sleep(12_000)
+ val unknownAfter = server("/stats")
+ assertThat(eventCount(unknownAfter, "request-start", role = "episode", program = "73101")).isEqualTo(0)
+ assertThat(eventCount(unknownAfter, "request-start", role = "episode", program = "73103")).isEqualTo(0)
+ assertThat(unknownAfter.getInt("peak")).isAtMost(1)
+ Log.i("PlaybackV3Fixture", "episode-preload requestedCap=unknown effectiveCap=1 starts=" +
+ unknownStart.getJSONArray("events").length() + " suppressed=true bufferMs=${engine.playerStats.value.bufferedDurationMs}")
+
+ server("/control?cap=1&reset=1")
+ check(providers.refreshProviderData(fixtureId, force = true).isSuccess)
+ setFixtureCap(providers, fixtureId, 1)
+ preloadRefresh(vm)
+ SystemClock.sleep(12_000)
+ val oneStats = server("/stats")
+ assertThat(eventCount(oneStats, "request-start", role = "episode", program = "73101")).isEqualTo(0)
+ assertThat(eventCount(oneStats, "request-start", role = "episode", program = "73103")).isEqualTo(0)
+ assertThat(oneStats.getInt("peak")).isAtMost(1)
+ Log.i("PlaybackV3Fixture", "episode-preload requestedCap=1 effectiveCap=1 suppressed=true bufferMs=${engine.playerStats.value.bufferedDurationMs}")
+
+ server("/control?cap=5&reset=1")
+ check(providers.refreshProviderData(fixtureId, force = true).isSuccess)
+ setFixtureCap(providers, fixtureId, 5)
+ preloadRefresh(vm)
+ await("permitted adjacent episode reads") {
+ val stats = server("/stats")
+ eventCount(stats, "request-start", role = "episode", program = "73101") > 0 &&
+ eventCount(stats, "request-start", role = "episode", program = "73103") > 0
+ }
+ val multiStats = server("/stats")
+ assertThat(multiStats.getInt("peak")).isAtMost(5)
+ Log.i("PlaybackV3Fixture", "episode-preload requestedCap=5 effectiveCap=5 previousAndNext=true serverPeak=${multiStats.getInt("peak")}")
+
+ val scrubRows = JSONArray()
+ val previewEnabledScrub = dragTimeline(vm, enabled = true, fraction = 0.15f)
+ awaitScrubPlayback(vm, 0.15f, "preview-enabled-scrub")
+ previewEnabledScrub.put("positionAfterReadyMs", engine.currentPosition.value)
+ scrubRows.put(previewEnabledScrub)
+ val previewDisabledScrub = dragTimeline(vm, enabled = false, fraction = 0.45f)
+ awaitScrubPlayback(vm, 0.45f, "preview-disabled-scrub")
+ previewDisabledScrub.put("positionAfterReadyMs", engine.currentPosition.value)
+ scrubRows.put(previewDisabledScrub)
+ File(outputDir, "scrub-results.json").writeText(scrubRows.toString(2))
+ capturePlayback(vm, "preview-enabled")
+ // A second no-read scrub mode follows the same slider gesture and engine seek path.
+ val beforeDisabledScrubMs = engine.currentPosition.value
+ val disabledScrub = dragTimeline(vm, enabled = false, fraction = 0.30f)
+ awaitScrubPlayback(vm, 0.30f, "preview-disabled-followup-scrub")
+ disabledScrub.put("positionAfterReadyMs", engine.currentPosition.value)
+ File(outputDir, "preview-disabled-seek.json").writeText(
+ JSONObject().put("positionBeforeMs", beforeDisabledScrubMs).put("gesture", disabledScrub)
+ .put("positionAfterAwaitMs", engine.currentPosition.value).put("durationMs", engine.duration.value)
+ .put("logicalEpisode", vm.currentEpisode.value?.episodeNumber)
+ .put("sourceEpisode", activeSource(engine)?.url?.let { URI(it).path?.substringAfterLast('/') })
+ .toString(2)
+ )
+ capturePlayback(vm, "preview-disabled")
+
+ // Cancel an active current-episode recovery by navigating in the normal episode picker.
+ server("/control?cap=1&reset=1")
+ check(providers.refreshProviderData(fixtureId, force = true).isSuccess)
+ setFixtureCap(providers, fixtureId, 1)
+ preloadRefresh(vm)
+ server("/control?failEpisodeId=73102")
+ instrumentation.runOnMainSync { engine.seekTo(240_000); engine.play() }
+ await("controlled episode recovery request", 30_000) {
+ eventCount(server("/stats"), "controlled-503", role = "episode", program = "73102") > 0
+ }
+ val recoveryStart = server("/stats")
+ val failedAttemptsBeforeNavigation = eventCount(recoveryStart, "controlled-503", role = "episode", program = "73102")
+
+ val nextMs = selectAdjacentEpisode(vm, 3)
+ SystemClock.sleep(2_000)
+ val recoveryAfterNavigation = server("/stats")
+ assertThat(eventCount(recoveryAfterNavigation, "controlled-503", role = "episode", program = "73102"))
+ .isEqualTo(failedAttemptsBeforeNavigation)
+ server("/control?failEpisodeId=none")
+ val previousMs = selectAdjacentEpisode(vm, 2)
+ val handoff = JSONObject().put("nextFirstFrameMs", nextMs).put("previousFirstFrameMs", previousMs)
+ .put("logicalEpisode", vm.currentEpisode.value?.episodeNumber).put("history", JSONObject()
+ .put("contentId", history(vm).contentId).put("positionMs", history(vm).resumePositionMs))
+ .put("recoveryFailedAttemptsBeforeNavigation", failedAttemptsBeforeNavigation)
+ .put("recoveryFailedAttemptsAfterNavigation", eventCount(recoveryAfterNavigation, "controlled-503", role = "episode", program = "73102"))
+ File(outputDir, "episode-handoff.json").writeText(handoff.toString(2))
+
+ val r7RapidScrub = dragLegacyThumbnail(vm)
+ val r7Navigation = startSlowPreviewAndNavigateAway(vm)
+ // The player Back action lands on series details; one more Back returns to the library.
+ device.pressBack()
+ await("library after leaving series details") { device.findObject(By.textContains("Live TV")) != null }
+
+ // The channel/program fixture uses fresh UTC guide windows from this server process.
+ server("/control?failBeta=false&failEpisodeId=none&cap=5&reset=1")
+ check(providers.refreshProviderData(fixtureId, force = true).isSuccess)
+ setFixtureCap(providers, fixtureId, 5)
+ click("Live TV")
+ click("V3 Catch-up Validation")
+ vm = openArchive("Beta")
+ val catchup = vm.playerEngine
+ val selectedProgram = getter(getter(vm, "getPlayerPlaybackContextCoordinator")!!, "getSelectedCatchUpProgram") as Program
+ assertThat(selectedProgram.title).isEqualTo("V3 Program Beta")
+ assertThat(activeSource(catchup)?.playbackContentKind).isEqualTo(PlaybackContentKind.CATCH_UP)
+ await("permitted previous and next catch-up reads", 45_000) {
+ val stats = server("/stats")
+ stats.toString().contains("\"program\":\"alpha\"") && stats.toString().contains("\"program\":\"gamma\"")
+ }
+ val archivePreloads = server("/stats")
+ assertThat(archivePreloads.getInt("peak")).isAtMost(5)
+ assertThat(archivePreloads.toString()).contains("\"program\":\"alpha\"")
+ assertThat(archivePreloads.toString()).contains("\"program\":\"gamma\"")
+ val catchupHistory = history(vm)
+ assertThat(catchupHistory.title).contains("V3 Program Beta")
+ Log.i("PlaybackV3Fixture", "catchup-neighbors previousNext=true peak=${archivePreloads.getInt("peak")} " +
+ "historyContent=${catchupHistory.contentId} titleCorrect=true")
+ server("/control?failBeta=true")
+ instrumentation.runOnMainSync { catchup.seekTo(60_000); catchup.play() }
+ await("catch-up recovery starts", 20_000) { catchup.playbackState.value == PlaybackState.BUFFERING }
+ val archiveRecoveryStart = server("/stats")
+ server("/control?failBeta=false")
+ await("catch-up recovery completes", 60_000) { catchup.isPlaying.value && catchup.playbackState.value == PlaybackState.READY }
+ assertThat(getter(getter(vm, "getPlayerPlaybackContextCoordinator")!!, "getSelectedCatchUpProgram").toString())
+ .contains("V3 Program Beta")
+ Log.i("PlaybackV3Fixture", "catchup-recovery state=${catchup.playbackState.value} requests=${archiveRecoveryStart.getJSONArray("events").length()}")
+ backToFixtureChannel()
+ val archiveFirstFrames = JSONObject()
+ vm = openArchive("Alpha")
+ assertThat(getter(getter(vm, "getPlayerPlaybackContextCoordinator")!!, "getSelectedCatchUpProgram").toString())
+ .contains("V3 Program Alpha")
+ assertThat(history(vm).title).contains("V3 Program Alpha")
+ archiveFirstFrames.put("previousProgramMs", lastArchiveFirstFrameMs)
+ backToFixtureChannel()
+ vm = openArchive("Gamma")
+ assertThat(getter(getter(vm, "getPlayerPlaybackContextCoordinator")!!, "getSelectedCatchUpProgram").toString())
+ .contains("V3 Program Gamma")
+ assertThat(history(vm).title).contains("V3 Program Gamma")
+ archiveFirstFrames.put("nextProgramMs", lastArchiveFirstFrameMs)
+ File(outputDir, "catchup-handoff.json").writeText(archiveFirstFrames.toString(2))
+ val result = JSONObject().put("fixtureProviderId", fixtureId).put("unknownEffectiveCap", 1).put("oneEffectiveCap", 1)
+ .put("multiEffectiveCap", 5).put("scrubs", scrubRows).put("episodeHandoffs", handoff)
+ .put("episodeRecoveryCancellation", recoveryAfterNavigation).put("catchupRecovery", archiveRecoveryStart)
+ .put("r7RapidScrub", r7RapidScrub).put("r7NavigationAway", r7Navigation)
+ .put("catchupHandoffs", archiveFirstFrames)
+ val enabledPreviewReady = !scrubRows.getJSONObject(0).isNull("previewMs")
+ result.put("enabledPreviewReadyWithin5s", enabledPreviewReady)
+ val r7RapidPassed = r7RapidScrub.optBoolean("firstRequestStarted") && r7RapidScrub.optBoolean("secondRequestStarted") && r7RapidScrub.optBoolean("withinBound")
+ val r7NavigationPassed = r7Navigation.optBoolean("nativeStarted") && r7Navigation.optBoolean("previewClearedAfterDispose") && r7Navigation.optBoolean("withinBound")
+ result.put("r7RapidScrubPassed", r7RapidPassed).put("r7NavigationAwayPassed", r7NavigationPassed)
+ File(outputDir, "result.json").writeText(result.toString(2))
+ check(enabledPreviewReady && r7RapidPassed && r7NavigationPassed) {
+ "V3 thumbnail acceptance failed: enabledPreviewReady=$enabledPreviewReady r7RapidPassed=$r7RapidPassed r7NavigationPassed=$r7NavigationPassed"
+ }
+ } finally {
+ val fixture = providers.getProvider(fixtureId)
+ if (fixture != null) {
+ check(fixture.name == fixtureName && fixture.serverUrl == providerUrl) { "Refusing to delete a non-fixture provider" }
+ if (original.id != fixtureId) check(providers.setActiveProvider(original.id).isSuccess)
+ prefs.setLastActiveProviderId(originalLast)
+ check(providers.deleteProvider(fixtureId).isSuccess)
+ }
+ withTimeout(60_000) {
+ while (providers.getProvider(fixtureId) != null) delay(100)
+ }
+ val restoredOriginal = providers.getProvider(original.id)
+ check(
+ restoredOriginal != null &&
+ restoredOriginal == original.copy(lastSyncedAt = restoredOriginal.lastSyncedAt)
+ ) { "Original provider changed during fixture cleanup" }
+ assertThat(providers.getActiveProvider().first()?.id).isEqualTo(original.id)
+ Log.i("PlaybackV3Fixture", "cleanup fixtureRemoved=true originalProvider=${original.id} activeRestored=true")
+ }
+ }
+
+ private fun closeToBrowse() {
+ repeat(5) {
+ device.pressBack()
+ SystemClock.sleep(400)
+ compose.waitForIdle()
+ if (compose.onAllNodesWithText("Series", substring = false).fetchSemanticsNodes().isNotEmpty()) return
+ }
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/TrueLiveWindowRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/TrueLiveWindowRuntimeTest.kt
new file mode 100644
index 00000000..bdf8992b
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/TrueLiveWindowRuntimeTest.kt
@@ -0,0 +1,347 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.common.C
+import androidx.media3.common.Player as Media3Player
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.analytics.PlaybackStats
+import androidx.media3.exoplayer.analytics.PlaybackStatsListener
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.repository.ChannelRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.atomic.AtomicLong
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Live TV validation of a genuine dynamic HLS window expiry. */
+@RunWith(AndroidJUnit4::class)
+class TrueLiveWindowRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "v5-dynamic-live-fixture-private.json")
+ private val output get() = File(app.filesDir, "v5-dynamic-live-private")
+
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("v5Fixture") == "true")
+
+ private fun component(name: String): Any {
+ val generated = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (generated.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(generated) as Provider<*>).get()!!
+ }
+
+ private fun await(label: String, timeoutMs: Long = 45_000, condition: () -> Boolean) {
+ val deadline = android.os.SystemClock.elapsedRealtime() + timeoutMs
+ while (android.os.SystemClock.elapsedRealtime() < deadline) {
+ compose.waitForIdle()
+ if (condition()) return
+ android.os.SystemClock.sleep(100)
+ }
+ device.takeScreenshot(File(app.filesDir, "v5-dynamic-live-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "v5-dynamic-live-driver.xml"))
+ error("Timed out: $label")
+ }
+
+ private fun click(text: String) {
+ compose.waitForIdle()
+ val node = device.wait(Until.findObject(By.textContains(text)), 8_000)
+ ?: error("Missing UI text: $text")
+ val bounds = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${bounds.centerX()} ${bounds.centerY()}")
+ compose.waitForIdle()
+ }
+
+ private fun findPlayers(store: ViewModelStore): List<PlayerViewModel> {
+ val found = mutableListOf<PlayerViewModel>()
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) found += model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val values = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ values.values.filterIsInstance<ViewModelStore>().forEach { found += findPlayers(it) }
+ }
+ }
+ return found.distinct()
+ }
+
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+
+ private fun control(query: String): JSONObject = JSONObject(java.net.URL("http://10.0.2.2:18785/control?$query").readText())
+ private fun events(): JSONObject = JSONObject(java.net.URL("http://10.0.2.2:18785/events").readText())
+
+ private fun liveOffset(engine: PlayerEngine): Long = AtomicLong(C.TIME_UNSET.toLong()).also { result ->
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as? Media3Player
+ if (player?.isCommandAvailable(Media3Player.COMMAND_GET_CURRENT_MEDIA_ITEM) == true) {
+ result.set(player.currentLiveOffset)
+ }
+ }
+ }.get()
+
+ private fun playerPosition(engine: PlayerEngine): Long = AtomicLong(C.TIME_UNSET.toLong()).also { result ->
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }
+ .get(engine) as? Media3Player
+ if (player != null) result.set(player.currentPosition)
+ }
+ }.get()
+
+ private fun playerError(engine: PlayerEngine): androidx.media3.common.PlaybackException? {
+ var result: androidx.media3.common.PlaybackException? = null
+ instrumentation.runOnMainSync {
+ result = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }
+ .get(engine).let { it as? ExoPlayer }?.playerError
+ }
+ return result
+ }
+
+ private fun hash(file: File): String = MessageDigest.getInstance("SHA-256")
+ .digest(file.readBytes()).joinToString("") { "%02x".format(it) }
+
+ private fun engineFor(title: String): PlayerViewModel {
+ var result: PlayerViewModel? = null
+ await("player context $title") {
+ instrumentation.runOnMainSync {
+ findPlayers(compose.activity.viewModelStore).firstOrNull { getter(it, "getCurrentTitle") == title }?.let {
+ result = it
+ }
+ }
+ result != null
+ }
+ return checkNotNull(result)
+ }
+
+ private fun openChannel(name: String): PlayerViewModel {
+ await("Live TV route") { device.findObject(By.textContains("Live TV")) != null }
+ click("Live TV")
+ await("V5 category") { compose.onAllNodesWithText("V5 Dynamic Live", substring = true).fetchSemanticsNodes().isNotEmpty() }
+ click("V5 Dynamic Live")
+ await("channel row $name") { compose.onAllNodesWithContentDescription(name, substring = true).fetchSemanticsNodes().isNotEmpty() }
+ compose.onNodeWithContentDescription(name, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ android.os.SystemClock.sleep(800)
+ if (compose.onAllNodesWithContentDescription(name, substring = true).fetchSemanticsNodes().isNotEmpty()) {
+ compose.onNodeWithContentDescription(name, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ val vm = engineFor(name)
+ await("dynamic first frame $name") {
+ val engine = vm.playerEngine
+ engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY &&
+ engine.playerStats.value.ttffMs > 0 && liveOffset(engine) != C.TIME_UNSET.toLong()
+ }
+ instrumentation.runOnMainSync {
+ val player = vm.playerEngine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }
+ .get(vm.playerEngine) as ExoPlayer
+ check(player.isCurrentMediaItemLive) { "V5 source was not live" }
+ check(player.isCurrentMediaItemDynamic) { "V5 source was not dynamic" }
+ }
+ return vm
+ }
+
+ private fun capture(engine: PlayerEngine, label: String, durationFrames: Int = 61): JSONObject {
+ val folder = File(output, label).apply { mkdirs() }
+ val hashes = JSONArray()
+ val samples = JSONArray()
+ val started = android.os.SystemClock.elapsedRealtime()
+ repeat(durationFrames) { index ->
+ compose.waitForIdle()
+ val frame = File(folder, "frame_%02d.png".format(index))
+ check(device.takeScreenshot(frame)) { "Could not capture $frame" }
+ hashes.put(hash(frame))
+ samples.put(JSONObject().put("frame", index).put("elapsedMs", android.os.SystemClock.elapsedRealtime() - started)
+ .put("positionMs", playerPosition(engine)).put("state", engine.playbackState.value.name)
+ .put("playing", engine.isPlaying.value).put("liveOffsetMs", liveOffset(engine))
+ .put("speed", engine.playbackSpeed.value).put("bufferedMs", engine.playerStats.value.bufferedDurationMs)
+ .put("rebufferCount", engine.playerStats.value.rebufferCount).put("droppedFrames", engine.playerStats.value.droppedFrames)
+ .put("width", engine.playerStats.value.width).put("height", engine.playerStats.value.height))
+ if (index < durationFrames - 1) android.os.SystemClock.sleep(2_000)
+ }
+ val values = (0 until hashes.length()).map { hashes.getString(it) }
+ val report = JSONObject().put("label", label).put("frameCount", durationFrames)
+ .put("durationMs", android.os.SystemClock.elapsedRealtime() - started)
+ .put("uniqueHashes", values.toSet().size).put("adjacentChanges", values.zipWithNext().count { it.first != it.second })
+ .put("positionStartMs", samples.getJSONObject(0).getLong("positionMs"))
+ .put("positionEndMs", samples.getJSONObject(samples.length() - 1).getLong("positionMs"))
+ .put("hashes", hashes).put("samples", samples)
+ File(folder, "summary.json").writeText(report.toString(2))
+ return report
+ }
+
+ private fun ensureProvisioned() = runBlocking {
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val channels = component("channelRepositoryImplProvider") as ChannelRepository
+ val original = providers.getActiveProvider().first()?.id
+ val last = prefs.lastActiveProviderId.first()
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(
+ LegacyProvider(name = "V5 Dynamic Live validation 20261007", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18785", username = "v5-fixture", password = "v5-fixture", maxConnections = 5,
+ allowedOutputFormats = listOf("m3u8"), preferredLiveStreamFormat = LiveStreamFormatMode.HLS,
+ isActive = false, xtreamFastSyncEnabled = false)
+ ).getOrNull() ?: error("V5 fixture provider creation failed")
+ check(providers.getProvider(id)?.name == "V5 Dynamic Live validation 20261007")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id)
+ .put("active", original ?: JSONObject.NULL).put("last", last ?: JSONObject.NULL).toString(2))
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.LIVE, force = true).isSuccess)
+ val rows = withTimeout(60_000) { channels.getChannels(id).first { it.size == 2 } }
+ check(rows.map { it.name }.toSet() == setOf("V5 Dynamic Live Alpha", "V5 Dynamic Live Beta"))
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ println("V5 provisioned provider=$id channels=${rows.size}")
+ }
+
+ @Test
+ fun provisionIsolatedDynamicLive() = runBlocking {
+ enabled()
+ ensureProvisioned()
+ }
+
+ @Test
+ fun dynamicLiveWindowExpiryThroughNormalUi() {
+ enabled()
+ if (!setup.exists()) ensureProvisioned()
+ output.deleteRecursively()
+ output.mkdirs()
+ control("reset=1")
+ val alpha = openChannel("V5 Dynamic Live Alpha")
+ val alphaEngine = alpha.playerEngine
+ val alphaStats = PlaybackStatsListener(true, null)
+ instrumentation.runOnMainSync {
+ alphaEngine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }
+ .get(alphaEngine).let { it as ExoPlayer }.addAnalyticsListener(alphaStats)
+ }
+ val alphaFirstOffset = liveOffset(alphaEngine)
+ val alphaPrepareBefore = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ .lineSequence().count { "prepare resolvedStreamType=HLS" in it }
+ android.os.SystemClock.sleep(10_000)
+ val alphaHealthyOffset = liveOffset(alphaEngine)
+ val jump = control("jump=1&channel=1001")
+ val beforePosition = playerPosition(alphaEngine)
+ var sawBehind = false
+ var recoveredOffset = C.TIME_UNSET.toLong()
+ var recoveredPosition = beforePosition
+ val deadline = android.os.SystemClock.elapsedRealtime() + 60_000
+ while (android.os.SystemClock.elapsedRealtime() < deadline) {
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ val error = playerError(alphaEngine)
+ sawBehind = sawBehind || logs.contains("category=LIVE_WINDOW") ||
+ error?.errorCode == androidx.media3.common.PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW
+ if (sawBehind && alphaEngine.isPlaying.value && alphaEngine.playbackState.value == PlaybackState.READY) {
+ recoveredOffset = liveOffset(alphaEngine)
+ recoveredPosition = playerPosition(alphaEngine)
+ if (recoveredOffset != C.TIME_UNSET.toLong() && recoveredOffset in 0..20_000 && recoveredPosition > beforePosition + 2_000) break
+ }
+ android.os.SystemClock.sleep(500)
+ }
+ check(sawBehind) { "Dynamic playlist jump did not produce behind-live-window evidence" }
+ check(alphaEngine.isPlaying.value && alphaEngine.playbackState.value == PlaybackState.READY)
+ check(recoveredOffset in 0..20_000) { "Recovery did not target the live default: $recoveredOffset" }
+ check(recoveredPosition >= 0L) { "Recovery position was unavailable: $recoveredPosition" }
+ val alphaReport = capture(alphaEngine, "alpha-window-recovery")
+
+ device.pressBack()
+ await("V5 category after Alpha") { compose.onAllNodesWithText("V5 Dynamic Live", substring = true).fetchSemanticsNodes().isNotEmpty() }
+ control("reset=1")
+ val beta = openChannel("V5 Dynamic Live Beta")
+ val betaEngine = beta.playerEngine
+ val betaStats = PlaybackStatsListener(true, null)
+ instrumentation.runOnMainSync {
+ betaEngine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }
+ .get(betaEngine).let { it as ExoPlayer }.addAnalyticsListener(betaStats)
+ }
+ val betaReport = capture(betaEngine, "beta-dynamic-control")
+
+ val logs = device.executeShellCommand("logcat -d -v time")
+ val session = device.executeShellCommand("dumpsys media_session")
+ val prepareCount = logs.lineSequence().count { "prepare resolvedStreamType=HLS" in it }
+ val report = JSONObject().put("alphaFirstLiveOffsetMs", alphaFirstOffset)
+ .put("alphaHealthyLiveOffsetMs", alphaHealthyOffset).put("alphaRecoveredLiveOffsetMs", recoveredOffset)
+ .put("alphaPrepareCountBeforeJump", alphaPrepareBefore).put("prepareCountTotal", prepareCount)
+ .put("windowJump", jump).put("alpha", alphaReport).put("beta", betaReport)
+ .put("alphaRebufferCount", alphaEngine.playerStats.value.rebufferCount)
+ .put("alphaRebufferDurationMs", alphaStats.combinedPlaybackStats.totalRebufferTimeMs)
+ .put("betaRebufferCount", betaEngine.playerStats.value.rebufferCount)
+ .put("betaRebufferDurationMs", betaStats.combinedPlaybackStats.totalRebufferTimeMs)
+ .put("logs", logs).put("session", session)
+ File(output, "v5-final-report.json").writeText(report.toString(2))
+ File(output, "v5-session.txt").writeText(session)
+ File(output, "v5-logcat.txt").writeText(logs)
+ val relevant = logs.lineSequence().filter {
+ it.contains("prepare resolvedStreamType") || it.contains("LIVE_WINDOW") ||
+ it.contains("fatal-error") || it.contains("Player stuck") || it.contains("MPEG_TS_LIVE") ||
+ it.contains("first-frame-success") || it.contains("read-progress")
+ }.joinToString("\n")
+ File(output, "v5-relevant-log.txt").writeText(relevant)
+ assertThat(prepareCount).isAtMost(3)
+ assertThat(logs).doesNotContain("MPEG_TS_LIVE")
+ assertThat(logs).doesNotContain("live-ts-fallback")
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("Player stuck")
+ assertThat(session).contains("com.streamvault.app.debug")
+ Log.i("V5DynamicLive", "complete behindLiveWindow=$sawBehind recoveredOffsetMs=$recoveredOffset prepares=$prepareCount " +
+ "alphaRebuffers=${alphaEngine.playerStats.value.rebufferCount} betaRebuffers=${betaEngine.playerStats.value.rebufferCount}")
+ // Leave the report readable through `run-as` before the connected-test
+ // teardown removes the app data and isolated fixture provider.
+ android.os.SystemClock.sleep(10_000)
+ cleanupIsolatedDynamicLive()
+ }
+
+ @Test
+ fun cleanupIsolatedDynamicLive() = runBlocking {
+ enabled()
+ val saved = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = saved.getLong("id")
+ check(providers.getProvider(id)?.name == "V5 Dynamic Live validation 20261007")
+ check(providers.deleteProvider(id).isSuccess)
+ if (!saved.isNull("active")) check(providers.setActiveProvider(saved.getLong("active")).isSuccess)
+ if (!saved.isNull("last")) prefs.setLastActiveProviderId(saved.getLong("last"))
+ check(setup.delete())
+ File(app.filesDir, "v5-dynamic-live-driver.png").delete()
+ File(app.filesDir, "v5-dynamic-live-driver.xml").delete()
+ Unit
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/V12BandwidthRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/V12BandwidthRuntimeTest.kt
new file mode 100644
index 00000000..7eeaa055
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/V12BandwidthRuntimeTest.kt
@@ -0,0 +1,331 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.common.C
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import com.streamvault.app.MainActivity
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI acceptance for V12 sustained delivery shortage/restoration. */
+@RunWith(AndroidJUnit4::class)
+class V12BandwidthRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "v12-bandwidth-fixture-private.json")
+
+ private fun enabled() = assumeTrue(
+ InstrumentationRegistry.getArguments().getString("v12BandwidthFixture") == "true"
+ )
+
+ private fun component(name: String): Any {
+ val generated = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (generated.javaClass.getDeclaredField(name).apply { isAccessible = true }
+ .get(generated) as Provider<*>).get()!!
+ }
+
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ error("Timed out: $label")
+ }
+
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("V12 ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: error("Missing UI: $text")
+ val bounds = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${bounds.centerX()} ${bounds.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+
+ private fun control(rate: Long, label: String, reset: Boolean = false): JSONObject {
+ val query = "rate=$rate&label=$label&reset=${if (reset) 1 else 0}"
+ return JSONObject(java.net.URL("http://10.0.2.2:18786/control?$query").readText())
+ }
+
+ @Test fun provisionIsolatedMovies() {
+ runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val original = providers.getActiveProvider().first()?.id ?: -1L
+ val last = prefs.lastActiveProviderId.first() ?: -1L
+ val restore = File(app.filesDir, "v12-bandwidth-restore.json")
+ if (!setup.exists()) {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val snapshot = store.data.first()
+ val saved = JSONObject()
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ saved.put(name, snapshot[stringPreferencesKey(name)] ?: JSONObject.NULL)
+ }
+ restore.writeText(saved.toString())
+ }
+ check(restore.exists()) { "Original fixture preference snapshot required" }
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(
+ LegacyProvider(
+ name = "V12 Bandwidth UI validation 20261007",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18786",
+ username = "validation",
+ password = "validation",
+ maxConnections = 5,
+ isActive = false,
+ xtreamFastSyncEnabled = false,
+ )
+ ).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "V12 Bandwidth UI validation 20261007")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", original).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val categories = withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ for (category in categories) movies.getMoviesByCategory(id, category.id).first()
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.MOVIE, force = true).isSuccess)
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { candidates ->
+ candidates.size == 3 && candidates.all { movie ->
+ val hydrated = movies.getMovieDetails(id, movie.id).getOrNull()
+ hydrated?.let { movies.getStreamInfo(it).getOrNull() }?.expirationTime
+ ?.let { it > System.currentTimeMillis() + 3_600_000 } == true
+ }
+ }
+ }
+ check(rows.map { it.name }.toSet() == setOf("V12 Adaptive Sustainable", "V12 Adaptive Unsustainable", "V12 Progressive Control"))
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ prefs.setVodDuplicateHandlingMode(com.streamvault.domain.model.VodDuplicateHandlingMode.SHOW_ALL)
+ Log.i("V12BandwidthFixture", "provisioned provider=$id movies=${rows.size}")
+ }
+ }
+
+ @Test fun normalMoviesUiSustainedBandwidth() = runCase("sustainable", "V12 Adaptive Sustainable", adaptive = true)
+
+ @Test fun normalMoviesUiUnsustainableBandwidth() = runCase("unsustainable", "V12 Adaptive Unsustainable", adaptive = true)
+
+ @Test fun normalMoviesUiProgressiveBandwidth() = runCase("progressive", "V12 Progressive Control", adaptive = false)
+
+ private fun runCase(case: String, title: String, adaptive: Boolean) {
+ enabled()
+ val requestedDuration = InstrumentationRegistry.getArguments().getString("v12DurationSeconds")?.toIntOrNull()?.coerceIn(360, 480) ?: 410
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ control(120_000_000, "$case-start", reset = true)
+ click("Movies"); click(title); click("Play")
+ lateinit var vm: PlayerViewModel
+ await("player context") {
+ var found = false
+ instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }
+ found
+ }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) {
+ if (compose.onAllNodes(hasText("Start Over")).fetchSemanticsNodes().isNotEmpty()) {
+ compose.onNodeWithText("Start Over").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ }
+ await("first frame") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.playerStats.value.ttffMs > 0 }
+ device.wait(Until.findObject(By.text("Start Over")), 5_000)?.let {
+ compose.onNodeWithText("Start Over").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } ?: device.wait(Until.findObject(By.text("Resume")), 2_000)?.let {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ await("resume dialog dismissed") { !vm.resumePrompt.value.show && device.findObject(By.text("Resume Playback")) == null }
+ await("resolving overlay cleared") { device.findObject(By.textContains("Resolving playback")) == null }
+ val source = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ assertThat(source.playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ val samples = JSONArray()
+ val started = SystemClock.elapsedRealtime()
+ var slowApplied = false
+ var restored = false
+ val end = started + requestedDuration * 1_000L
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ val elapsed = SystemClock.elapsedRealtime() - started
+ if (elapsed >= 30_000 && !slowApplied) {
+ control(if (case == "unsustainable") 600_000 else 3_200_000, "$case-shortage")
+ slowApplied = true
+ }
+ if (elapsed >= 350_000 && !restored) {
+ control(120_000_000, "$case-restored")
+ restored = true
+ }
+ val stats = engine.playerStats.value
+ val sample = JSONObject()
+ .put("elapsedMs", elapsed)
+ .put("positionMs", engine.currentPosition.value)
+ .put("state", engine.playbackState.value.name)
+ .put("playing", engine.isPlaying.value)
+ .put("height", engine.videoFormat.value.height)
+ .put("selectedBitrate", engine.videoFormat.value.bitrate)
+ .put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount)
+ .put("droppedFrames", stats.droppedFrames)
+ .put("bandwidthEstimate", stats.bandwidthEstimate)
+ .put("pssKb", Debug.getPss())
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as ExoPlayer
+ sample.put("timelineLive", player.isCurrentMediaItemLive)
+ .put("timelineDynamic", player.isCurrentMediaItemDynamic)
+ .put("videoWidth", player.videoFormat?.width)
+ .put("videoHeight", player.videoFormat?.height)
+ .put("trackOverrideCount", player.trackSelectionParameters.overrides.values.count { it.type == C.TRACK_TYPE_VIDEO })
+ player.videoDecoderCounters?.let { counters ->
+ counters.ensureUpdated()
+ sample.put("renderedBuffers", counters.renderedOutputBufferCount)
+ .put("decoderDroppedBuffers", counters.droppedBufferCount)
+ .put("decoderSkippedBuffers", counters.skippedOutputBufferCount)
+ }
+ }
+ samples.put(sample)
+ File(app.filesDir, "v12-$case.json").writeText(samples.toString())
+ check(engine.playbackState.value != PlaybackState.ERROR) { "V12 $case entered ERROR" }
+ SystemClock.sleep(1_000)
+ }
+ check(slowApplied && restored) { "V12 phases were not both applied" }
+ assertThat(samples.length()).isAtLeast(360)
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ val finalStats = engine.playerStats.value
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.streamUrl).isEqualTo(logicalUrl)
+ assertThat(engine.availableVideoTracks.value.count { it.isSelected }).isAtLeast(1)
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("buffer-policy promote")
+ val result = JSONObject()
+ .put("case", case)
+ .put("requestedDurationSeconds", requestedDuration)
+ .put("sampleCount", samples.length())
+ .put("firstFrameMs", engine.playerStats.value.ttffMs)
+ .put("finalState", engine.playbackState.value.name)
+ .put("finalIsPlaying", engine.isPlaying.value)
+ .put("finalPositionMs", engine.currentPosition.value)
+ .put("finalDurationMs", engine.duration.value)
+ .put("finalBufferMs", finalStats.bufferedDurationMs)
+ .put("finalRebufferCount", finalStats.rebufferCount)
+ .put("finalDroppedFrames", finalStats.droppedFrames)
+ .put("finalVideoBitrate", finalStats.videoBitrate)
+ .put("finalBandwidthEstimate", finalStats.bandwidthEstimate)
+ .put("finalHeight", finalStats.height)
+ .put("logicalTitle", logicalTitle)
+ .put("logicalUrl", logicalUrl)
+ .put("historyContentId", history.contentId)
+ .put("selectedTracks", JSONArray(engine.availableVideoTracks.value.map { JSONObject().put("id", it.id).put("name", it.name).put("selected", it.isSelected) }))
+ .put("samples", samples)
+ File(app.filesDir, "v12-$case.json").writeText(result.toString())
+ Log.i("V12BandwidthFixture", "complete case=$case durationMs=${SystemClock.elapsedRealtime() - started} " +
+ "samples=${samples.length()} finalState=${engine.playbackState.value} finalPlaying=${engine.isPlaying.value} " +
+ "rebuffers=${finalStats.rebufferCount} drops=${finalStats.droppedFrames} historyId=${history.contentId}")
+ }
+
+ @Test fun cleanupOnlyIsolatedMovies() {
+ runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ if (providers.getProvider(id) != null) check(providers.deleteProvider(id).isSuccess)
+ if (original.getLong("active") > 0L) check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val saved = JSONObject(File(app.filesDir, "v12-bandwidth-restore.json").readText())
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ val key = stringPreferencesKey(name)
+ if (saved.isNull(name)) current.remove(key) else current[key] = saved.getString(name)
+ }
+ }
+ check(File(app.filesDir, "v12-bandwidth-restore.json").delete())
+ check(setup.delete())
+ for (case in listOf("sustainable", "unsustainable", "progressive")) File(app.filesDir, "v12-$case.json").delete()
+ }
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/VodDashRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/VodDashRuntimeTest.kt
new file mode 100644
index 00000000..9aec6194
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/VodDashRuntimeTest.kt
@@ -0,0 +1,379 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI validation using an isolated provider and private local media. */
+@RunWith(AndroidJUnit4::class)
+class VodDashRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "vod-dash-fixture-private.json")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("vodDashFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "vod-dash-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "vod-dash-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("DASH ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ // Movie facts can put either Play or Resume below the visible TV viewport.
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 2_000) else null)
+ ?: error("Missing UI: $text")
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+ private fun control(rate: Long) = java.net.URL("http://10.0.2.2:18770/control?rate=$rate").readText()
+
+ @Test fun provisionIsolatedMovies() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val original = providers.getActiveProvider().first()?.id ?: -1L
+ val last = prefs.lastActiveProviderId.first() ?: -1L
+ val restore = File(app.filesDir, "vod-dash-restore.json")
+ if (!setup.exists()) {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val saved = store.data.first()[stringPreferencesKey("vod_variant_observations")]
+ restore.writeText(JSONObject().put("vod_variant_observations", saved ?: JSONObject.NULL).toString())
+ }
+ check(restore.exists()) { "Original fixture preference snapshot required" }
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(LegacyProvider(name = "DASH UI validation 20261003", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18770", username = "validation", password = "validation", maxConnections = 5,
+ isActive = false, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "DASH UI validation 20261003")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", original).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val categories = withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ for (category in categories) movies.getMoviesByCategory(id, category.id).first()
+ // Fixture provisioning is separate from background-worker acceptance. The worker can
+ // defer on the emulator's transient low-memory flag; import only this fixture section.
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.MOVIE, force = true).isSuccess)
+ // Refresh/import is asynchronous: an existing catalogue can still have three stale rows.
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { candidates ->
+ candidates.size == 3 && candidates.all { movie ->
+ val hydrated = movies.getMovieDetails(id, movie.id).getOrNull()
+ val resolved = hydrated?.let { movies.getStreamInfo(it).getOrNull() }
+ resolved?.expirationTime?.let { it > System.currentTimeMillis() + 3_600_000 } == true
+ }
+ }
+ }
+ check(rows.all { it.name.startsWith("DASH ") })
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ val remaining = rows.map { movies.getStreamInfo(it).getOrNull()!!.expirationTime!! - System.currentTimeMillis() }
+ Log.i("VodDashFixture", "provisioned provider=$id movies=${rows.size} minimumResolvedLifetimeMs=${remaining.min()}")
+ Unit
+ }
+
+ @Test fun normalMoviesUiPlayback() {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("vodDashCase") ?: "adaptive"
+ check(case in setOf("adaptive", "direct4k", "same1080"))
+ val title = when (case) { "direct4k" -> "DASH Direct 4K UI Fixture"; "same1080" -> "DASH Same 1080 UI Fixture"; else -> "DASH Adaptive UI Fixture" }
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ control(if (case == "adaptive") 4_000_000 else 120_000_000)
+ click("Movies"); click(title); click("Play")
+ lateinit var vm: PlayerViewModel
+ await("player context") { var found = false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }; found }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("first frame") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.playerStats.value.ttffMs > 0 }
+ // History/detail resolution can publish a resume prompt after first frame.
+ device.wait(Until.findObject(By.text("Resume")), 5_000)?.let {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { action -> action() }
+ }
+ await("resume dialog dismissed") { !vm.resumePrompt.value.show && device.findObject(By.text("Resume Playback")) == null }
+ await("playback after resume dialog") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ await("resolving overlay cleared") { device.findObject(By.textContains("Resolving playback")) == null }
+ if (engine.duration.value > 195_000 && engine.duration.value - engine.currentPosition.value < 195_000) {
+ val resumed = engine.currentPosition.value
+ instrumentation.runOnMainSync { engine.seekTo(10_000); engine.play() }
+ await("enough finite content for sustained capture") {
+ engine.currentPosition.value in 9_000..20_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY
+ }
+ Log.i("VodDashFixture", "capture-position-normalized resumedMs=$resumed targetMs=10000 reason=finite-window")
+ }
+ fun source() = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ assertThat(source().playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ Log.i("VodDashFixture", "capture-ready case=$case intent=${source().playbackContentKind} ttffMs=${engine.playerStats.value.ttffMs} resumeDialog=false resolvingOverlay=false")
+ val samples = JSONArray()
+ // Leave room for slow 4K ADB captures while keeping the 240-second fixture finite.
+ val end = SystemClock.elapsedRealtime() + 180_000L
+ val began = SystemClock.elapsedRealtime()
+ var high = false; var low = false; var downAfterHigh = false
+ var fasterApplied = false; var slowerApplied = false
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ check(device.findObject(By.text("Resume Playback")) == null)
+ val elapsed = SystemClock.elapsedRealtime() - began
+ if (case == "adaptive" && elapsed >= 20_000 && !fasterApplied) {
+ control(120_000_000); fasterApplied = true
+ }
+ if (case == "adaptive" && elapsed >= 80_000 && !slowerApplied) {
+ control(4_000_000); slowerApplied = true
+ }
+ val stats = engine.playerStats.value
+ val h = engine.videoFormat.value.height
+ if (h in 1..720) { low = true; if (high) downAfterHigh = true }
+ if (h >= 1080) high = true
+ val sample = JSONObject().put("elapsedMs", elapsed).put("positionMs", engine.currentPosition.value)
+ .put("state", engine.playbackState.value.name).put("height", h).put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames)
+ .put("javaAllocatedBytes", Debug.getRuntimeStat("art.gc.bytes-allocated"))
+ .put("pssKb", Debug.getPss())
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as ExoPlayer
+ assertThat(player.isCurrentMediaItemLive).isFalse()
+ assertThat(player.isCurrentMediaItemDynamic).isFalse()
+ sample.put("timelineLive", player.isCurrentMediaItemLive).put("timelineDynamic", player.isCurrentMediaItemDynamic)
+ .put("videoWidth", player.videoFormat?.width).put("videoHeight", player.videoFormat?.height)
+ player.videoDecoderCounters?.let { counters ->
+ counters.ensureUpdated()
+ sample.put("renderedBuffers", counters.renderedOutputBufferCount)
+ .put("decoderDroppedBuffers", counters.droppedBufferCount)
+ .put("decoderSkippedBuffers", counters.skippedOutputBufferCount)
+ .put("decoderCounterInstance", System.identityHashCode(counters))
+ }
+ }
+ samples.put(sample)
+ File(app.filesDir, "vod-dash-$case.json").writeText(samples.toString())
+ check(engine.playbackState.value != PlaybackState.ERROR)
+ SystemClock.sleep(1_000)
+ }
+ if (case == "adaptive") {
+ assertThat(fasterApplied).isTrue(); assertThat(slowerApplied).isTrue()
+ assertThat(low).isTrue(); assertThat(high).isTrue(); assertThat(downAfterHigh).isTrue()
+ }
+ else assertThat(engine.videoFormat.value.height).isEqualTo(if (case == "direct4k") 2160 else 1080)
+ control(120_000_000)
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("seek resume") { engine.currentPosition.value in 59_000..70_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ val seekPosition = engine.currentPosition.value
+ await("position progresses after seek") { engine.currentPosition.value >= seekPosition + 3_000 }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.streamUrl).isEqualTo(logicalUrl)
+ assertThat(history.resumePositionMs).isAtLeast(59_000)
+ val renewal = Class.forName("com.streamvault.feature.playback.player.PlayerLifecycleActionsKt").methods.single { it.name == "startTokenRenewalMonitoring" && it.parameterCount == 3 }
+ instrumentation.runOnMainSync { renewal.invoke(null, vm, System.currentTimeMillis() + 1000, null) }
+ SystemClock.sleep(2_500)
+ assertThat(device.executeShellCommand("logcat -d -s PlayerVM:I")).contains("token-renewal request-changed=false")
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=DASH" in it }).isEqualTo(1)
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("buffer-policy promote")
+ Log.i("VodDashFixture", "complete case=$case low=$low high=$high downAfterHigh=$downAfterHigh position=${engine.currentPosition.value} prepares=1 historyId=${history.contentId}")
+ }
+
+ @Test fun cleanupOnlyIsolatedMovies() = runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ check(providers.getProvider(id)?.name == "DASH UI validation 20261003")
+ check(providers.deleteProvider(id).isSuccess)
+ check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val restore = File(app.filesDir, "vod-dash-restore.json")
+ val saved = JSONObject(restore.readText())
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ val key = stringPreferencesKey("vod_variant_observations")
+ if (saved.isNull(key.name)) current.remove(key) else current[key] = saved.getString(key.name)
+ }
+ check(restore.delete())
+ check(setup.delete())
+ for (case in listOf("adaptive", "direct4k", "same1080")) File(app.filesDir, "vod-dash-$case.json").delete()
+ for (name in listOf("vod-dash-driver.png", "vod-dash-driver.xml", "vod-dash-expired-retry.png")) File(app.filesDir, name).delete()
+ }
+
+ @Test fun expiredFixtureRetryRetainsIdentityWithoutPreparing() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val id = JSONObject(setup.readText()).getLong("id")
+ check(providers.getProvider(id)?.name == "DASH UI validation 20261003")
+ java.net.URL("http://10.0.2.2:18770/control?rate=120000000&ttl=-60").readText()
+ try {
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.MOVIE, force = true).isSuccess)
+ withTimeout(60_000) {
+ movies.getMovies(id).first { rows ->
+ rows.size == 3 && rows.all { movie ->
+ movies.getStreamInfo(movie).getOrNull()?.expirationTime?.let { it < System.currentTimeMillis() } == true
+ }
+ }
+ }
+ click("Movies"); click("DASH Adaptive UI Fixture"); click("Play")
+ val banner = "This stream's subscription has expired."
+ await("expired source message") { device.findObject(By.textContains(banner)) != null }
+ lateinit var vm: PlayerViewModel
+ await("expired player context") {
+ var found = false
+ instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }
+ found
+ }
+ val title = getter(vm, "getCurrentTitle")
+ val url = getter(vm, "getCurrentStreamUrl")
+ val contentId = getter(vm, "getCurrentContentId")
+ assertThat(title).isEqualTo("DASH Adaptive UI Fixture")
+ val generation = getter(vm, "getPrepareRequestVersion") as Long
+ val priorNotice = vm.playerNotice.value
+ click("Retry")
+ await("Retry begins a new logical playback request") { (getter(vm, "getPrepareRequestVersion") as Long) > generation }
+ await("Retry completes with a new terminal expiry notice") {
+ vm.playerNotice.value?.message?.contains(banner) == true &&
+ vm.playerNotice.value !== priorNotice
+ }
+ await("expired source remains terminal after Retry") { device.findObject(By.textContains(banner)) != null }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(url)
+ assertThat(getter(vm, "getCurrentContentId")).isEqualTo(contentId)
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ assertThat(engine.isPlaying.value).isFalse()
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs).doesNotContain("prepare resolvedStreamType=")
+ assertThat(logs).doesNotContain("first-frame-success")
+ device.takeScreenshot(File(app.filesDir, "vod-dash-expired-retry.png"))
+ Log.i("VodDashFixture", "expired-retry-complete logicalIdentityRetained=true prepares=0")
+ } finally {
+ java.net.URL("http://10.0.2.2:18770/control?rate=120000000&ttl=7200").readText()
+ }
+ Unit
+ }
+
+ @Test fun restoreOnlyFixtureCompatibilityLearning() {
+ enabled()
+ val file = File(app.filesDir, "vod-dash-compatibility-private.json")
+ val changes = JSONArray(file.readText())
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ for (index in 0 until changes.length()) {
+ val change = changes.getJSONObject(index)
+ val expected = change.getJSONObject("expected")
+ val id = expected.getLong("id")
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id)).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) {
+ val actual = cursor.getString(cursor.getColumnIndexOrThrow(column))
+ check(actual == if (expected.isNull(column)) null else expected.get(column).toString())
+ }
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id))
+ if (!change.isNull("original")) {
+ val original = change.getJSONObject("original")
+ val columns = original.keys().asSequence().toList()
+ check(columns.all { it.matches(Regex("[a-z_]+")) })
+ database.execSQL("INSERT INTO playback_compatibility_records (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }})",
+ columns.map { if (original.isNull(it)) null else original.get(it).toString() }.toTypedArray())
+ }
+ }
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/VodHlsRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/VodHlsRuntimeTest.kt
new file mode 100644
index 00000000..e1145db4
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/VodHlsRuntimeTest.kt
@@ -0,0 +1,368 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI validation using an isolated provider and private local media. */
+@RunWith(AndroidJUnit4::class)
+class VodHlsRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "vod-hls-fixture-private.json")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("vodHlsFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "vod-hls-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "vod-hls-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("HLS ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ // Movie facts can put either Play or Resume below the visible TV viewport.
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 2_000) else null)
+ ?: error("Missing UI: $text")
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+ private fun control(rate: Long) = java.net.URL("http://10.0.2.2:18769/control?rate=$rate").readText()
+
+ @Test fun provisionIsolatedMovies() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val original = providers.getActiveProvider().first()?.id ?: -1L
+ val last = prefs.lastActiveProviderId.first() ?: -1L
+ val restore = File(app.filesDir, "vod-hls-restore.json")
+ if (!setup.exists()) {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val saved = store.data.first()[stringPreferencesKey("vod_variant_observations")]
+ restore.writeText(JSONObject().put("vod_variant_observations", saved ?: JSONObject.NULL).toString())
+ }
+ check(restore.exists()) { "Original fixture preference snapshot required" }
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(LegacyProvider(name = "HLS UI validation 20261002", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18769", username = "validation", password = "validation", maxConnections = 5,
+ isActive = false, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "HLS UI validation 20261002")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", original).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val categories = withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ for (category in categories) movies.getMoviesByCategory(id, category.id).first()
+ // Refresh/import is asynchronous: an existing catalogue can still have three stale rows.
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { candidates ->
+ candidates.size == 3 && candidates.all { movie ->
+ val hydrated = movies.getMovieDetails(id, movie.id).getOrNull()
+ val resolved = hydrated?.let { movies.getStreamInfo(it).getOrNull() }
+ resolved?.expirationTime?.let { it > System.currentTimeMillis() + 3_600_000 } == true
+ }
+ }
+ }
+ check(rows.all { it.name.startsWith("HLS ") })
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ val remaining = rows.map { movies.getStreamInfo(it).getOrNull()!!.expirationTime!! - System.currentTimeMillis() }
+ Log.i("VodHlsFixture", "provisioned provider=$id movies=${rows.size} minimumResolvedLifetimeMs=${remaining.min()}")
+ Unit
+ }
+
+ @Test fun normalMoviesUiPlayback() {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("vodHlsCase") ?: "adaptive"
+ check(case in setOf("adaptive", "direct4k", "same1080"))
+ val title = when (case) { "direct4k" -> "HLS Direct 4K UI Fixture"; "same1080" -> "HLS Same 1080 UI Fixture"; else -> "HLS Adaptive UI Fixture" }
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ control(if (case == "adaptive") 6_000_000 else 120_000_000)
+ click("Movies"); click(title); click("Play")
+ lateinit var vm: PlayerViewModel
+ await("player context") { var found = false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }; found }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("first frame") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.playerStats.value.ttffMs > 0 }
+ // History/detail resolution can publish a resume prompt after first frame.
+ device.wait(Until.findObject(By.text("Resume")), 5_000)?.let {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { action -> action() }
+ }
+ await("resume dialog dismissed") { !vm.resumePrompt.value.show && device.findObject(By.text("Resume Playback")) == null }
+ await("playback after resume dialog") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ await("resolving overlay cleared") { device.findObject(By.textContains("Resolving playback")) == null }
+ if (engine.duration.value > 150_000 && engine.duration.value - engine.currentPosition.value < 150_000) {
+ val resumed = engine.currentPosition.value
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("enough finite content for sustained capture") {
+ engine.currentPosition.value in 59_000..70_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY
+ }
+ Log.i("VodHlsFixture", "capture-position-normalized resumedMs=$resumed targetMs=60000 reason=finite-window")
+ }
+ fun source() = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ assertThat(source().playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ Log.i("VodHlsFixture", "capture-ready case=$case intent=${source().playbackContentKind} ttffMs=${engine.playerStats.value.ttffMs} resumeDialog=false resolvingOverlay=false")
+ val samples = JSONArray()
+ val end = SystemClock.elapsedRealtime() + 135_000L
+ val began = SystemClock.elapsedRealtime()
+ var high = false; var low = false; var downAfterHigh = false
+ var fasterApplied = false; var slowerApplied = false
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ check(device.findObject(By.text("Resume Playback")) == null)
+ val elapsed = SystemClock.elapsedRealtime() - began
+ if (case == "adaptive" && elapsed >= 20_000 && !fasterApplied) {
+ control(120_000_000); fasterApplied = true
+ }
+ if (case == "adaptive" && elapsed >= 80_000 && !slowerApplied) {
+ control(6_000_000); slowerApplied = true
+ }
+ val stats = engine.playerStats.value
+ val h = engine.videoFormat.value.height
+ if (h in 1..720) { low = true; if (high) downAfterHigh = true }
+ if (h >= 1080) high = true
+ val sample = JSONObject().put("elapsedMs", elapsed).put("positionMs", engine.currentPosition.value)
+ .put("state", engine.playbackState.value.name).put("height", h).put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames)
+ .put("javaAllocatedBytes", Debug.getRuntimeStat("art.gc.bytes-allocated"))
+ .put("pssKb", Debug.getPss())
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as ExoPlayer
+ sample.put("timelineLive", player.isCurrentMediaItemLive).put("timelineDynamic", player.isCurrentMediaItemDynamic)
+ .put("videoWidth", player.videoFormat?.width).put("videoHeight", player.videoFormat?.height)
+ player.videoDecoderCounters?.let { counters ->
+ counters.ensureUpdated()
+ sample.put("renderedBuffers", counters.renderedOutputBufferCount)
+ .put("decoderDroppedBuffers", counters.droppedBufferCount)
+ .put("decoderSkippedBuffers", counters.skippedOutputBufferCount)
+ .put("decoderCounterInstance", System.identityHashCode(counters))
+ }
+ }
+ samples.put(sample)
+ File(app.filesDir, "vod-hls-$case.json").writeText(samples.toString())
+ check(engine.playbackState.value != PlaybackState.ERROR)
+ SystemClock.sleep(1_000)
+ }
+ if (case == "adaptive") {
+ assertThat(fasterApplied).isTrue(); assertThat(slowerApplied).isTrue()
+ assertThat(low).isTrue(); assertThat(high).isTrue(); assertThat(downAfterHigh).isTrue()
+ }
+ else assertThat(engine.videoFormat.value.height).isEqualTo(if (case == "direct4k") 2160 else 1080)
+ control(120_000_000)
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("seek resume") { engine.currentPosition.value in 59_000..70_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ val seekPosition = engine.currentPosition.value
+ await("position progresses after seek") { engine.currentPosition.value >= seekPosition + 3_000 }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.streamUrl).isEqualTo(logicalUrl)
+ assertThat(history.resumePositionMs).isAtLeast(59_000)
+ val renewal = Class.forName("com.streamvault.feature.playback.player.PlayerLifecycleActionsKt").methods.single { it.name == "startTokenRenewalMonitoring" && it.parameterCount == 3 }
+ instrumentation.runOnMainSync { renewal.invoke(null, vm, System.currentTimeMillis() + 1000, null) }
+ SystemClock.sleep(2_500)
+ assertThat(device.executeShellCommand("logcat -d -s PlayerVM:I")).contains("token-renewal request-changed=false")
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=HLS" in it }).isEqualTo(1)
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("buffer-policy promote")
+ Log.i("VodHlsFixture", "complete case=$case low=$low high=$high downAfterHigh=$downAfterHigh position=${engine.currentPosition.value} prepares=1 historyId=${history.contentId}")
+ }
+
+ @Test fun cleanupOnlyIsolatedMovies() = runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ check(providers.getProvider(id)?.name == "HLS UI validation 20261002")
+ check(providers.deleteProvider(id).isSuccess)
+ check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val restore = File(app.filesDir, "vod-hls-restore.json")
+ val saved = JSONObject(restore.readText())
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ val key = stringPreferencesKey("vod_variant_observations")
+ if (saved.isNull(key.name)) current.remove(key) else current[key] = saved.getString(key.name)
+ }
+ check(restore.delete())
+ check(setup.delete())
+ for (case in listOf("adaptive", "direct4k", "same1080")) File(app.filesDir, "vod-hls-$case.json").delete()
+ for (name in listOf("vod-hls-driver.png", "vod-hls-driver.xml", "vod-hls-expired-retry.png")) File(app.filesDir, name).delete()
+ }
+
+ @Test fun expiredFixtureRetryRetainsIdentityWithoutPreparing() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val id = JSONObject(setup.readText()).getLong("id")
+ check(providers.getProvider(id)?.name == "HLS UI validation 20261002")
+ java.net.URL("http://10.0.2.2:18769/control?rate=120000000&ttl=-60").readText()
+ try {
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ withTimeout(60_000) {
+ movies.getMovies(id).first { rows ->
+ rows.size == 3 && rows.all { movie ->
+ movies.getStreamInfo(movie).getOrNull()?.expirationTime?.let { it < System.currentTimeMillis() } == true
+ }
+ }
+ }
+ click("Movies"); click("HLS Adaptive UI Fixture"); click("Play")
+ val banner = "This stream's subscription has expired."
+ await("expired source message") { device.findObject(By.textContains(banner)) != null }
+ lateinit var vm: PlayerViewModel
+ await("expired player context") {
+ var found = false
+ instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }
+ found
+ }
+ val title = getter(vm, "getCurrentTitle")
+ val url = getter(vm, "getCurrentStreamUrl")
+ val contentId = getter(vm, "getCurrentContentId")
+ assertThat(title).isEqualTo("HLS Adaptive UI Fixture")
+ val generation = getter(vm, "getPrepareRequestVersion") as Long
+ val priorNotice = vm.playerNotice.value
+ click("Retry")
+ await("Retry begins a new logical playback request") { (getter(vm, "getPrepareRequestVersion") as Long) > generation }
+ await("Retry completes with a new terminal expiry notice") {
+ vm.playerNotice.value?.message?.contains(banner) == true &&
+ vm.playerNotice.value !== priorNotice
+ }
+ await("expired source remains terminal after Retry") { device.findObject(By.textContains(banner)) != null }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(title)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(url)
+ assertThat(getter(vm, "getCurrentContentId")).isEqualTo(contentId)
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ assertThat(engine.isPlaying.value).isFalse()
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs).doesNotContain("prepare resolvedStreamType=")
+ assertThat(logs).doesNotContain("first-frame-success")
+ device.takeScreenshot(File(app.filesDir, "vod-hls-expired-retry.png"))
+ Log.i("VodHlsFixture", "expired-retry-complete logicalIdentityRetained=true prepares=0")
+ } finally {
+ java.net.URL("http://10.0.2.2:18769/control?rate=120000000&ttl=7200").readText()
+ }
+ Unit
+ }
+
+ @Test fun restoreOnlyFixtureCompatibilityLearning() {
+ enabled()
+ val file = File(app.filesDir, "vod-hls-compatibility-private.json")
+ val changes = JSONArray(file.readText())
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ for (index in 0 until changes.length()) {
+ val change = changes.getJSONObject(index)
+ val expected = change.getJSONObject("expected")
+ val id = expected.getLong("id")
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id)).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) {
+ val actual = cursor.getString(cursor.getColumnIndexOrThrow(column))
+ check(actual == if (expected.isNull(column)) null else expected.get(column).toString())
+ }
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id))
+ if (!change.isNull("original")) {
+ val original = change.getJSONObject("original")
+ val columns = original.keys().asSequence().toList()
+ check(columns.all { it.matches(Regex("[a-z_]+")) })
+ database.execSQL("INSERT INTO playback_compatibility_records (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }})",
+ columns.map { if (original.isNull(it)) null else original.get(it).toString() }.toTypedArray())
+ }
+ }
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/VodProgressiveRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/VodProgressiveRuntimeTest.kt
new file mode 100644
index 00000000..20f7be16
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/VodProgressiveRuntimeTest.kt
@@ -0,0 +1,368 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import android.os.Debug
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.lifecycle.ViewModelStore
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.local.StreamVaultDatabase
+import com.streamvault.data.sync.ProviderSyncCommands
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI validation using an isolated provider and private local media. */
+@RunWith(AndroidJUnit4::class)
+class VodProgressiveRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "vod-progressive-fixture-private.json")
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("vodProgressiveFixture") == "true")
+ private fun component(name: String): Any {
+ val c = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (c.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(c) as Provider<*>).get()!!
+ }
+ private fun await(label: String, timeout: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeout
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "vod-progressive-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "vod-progressive-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text.startsWith("Progressive ")) {
+ compose.onNodeWithContentDescription(text).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else if (text == "Play") {
+ // Movie facts can put either Play or Resume below the visible TV viewport.
+ val button = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(button).fetchSemanticsNodes().size == 1 }
+ compose.onNode(button).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: (if (text == "Play") device.wait(Until.findObject(By.textStartsWith("Resume from")), 2_000) else null)
+ ?: error("Missing UI: $text")
+ val b = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${b.centerX()} ${b.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val map = field.apply { isAccessible = true }.get(model) as? Map<*, *> ?: continue
+ for (nested in map.values.filterIsInstance<ViewModelStore>()) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+ private fun control(rate: Long) = java.net.URL("http://10.0.2.2:18771/control?rate=$rate").readText()
+
+ @Test fun provisionIsolatedMovies() = runBlocking {
+ enabled()
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val original = providers.getActiveProvider().first()?.id ?: -1L
+ val last = prefs.lastActiveProviderId.first() ?: -1L
+ val restore = File(app.filesDir, "vod-progressive-restore.json")
+ if (!setup.exists()) {
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val snapshot = store.data.first()
+ val saved = JSONObject()
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) saved.put(name, snapshot[stringPreferencesKey(name)] ?: JSONObject.NULL)
+ restore.writeText(saved.toString())
+ }
+ check(restore.exists()) { "Original fixture preference snapshot required" }
+ val id = if (setup.exists()) JSONObject(setup.readText()).getLong("id") else providers.addProvider(LegacyProvider(name = "Progressive UI validation 20261003", type = ProviderType.XTREAM_CODES,
+ serverUrl = "http://10.0.2.2:18771", username = "validation", password = "validation", maxConnections = 5,
+ isActive = false, xtreamFastSyncEnabled = false)).getOrNull() ?: error("Fixture creation failed")
+ check(providers.getProvider(id)?.name == "Progressive UI validation 20261003")
+ if (!setup.exists()) setup.writeText(JSONObject().put("id", id).put("active", original).put("last", last).toString())
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ val categories = withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ for (category in categories) movies.getMoviesByCategory(id, category.id).first()
+ // Fixture provisioning is separate from background-worker acceptance. The worker can
+ // defer on the emulator's transient low-memory flag; import only this fixture section.
+ val sync = component("syncManagerProvider") as ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = ContentType.MOVIE, force = true).isSuccess)
+ // Refresh/import is asynchronous: an existing catalogue can still have three stale rows.
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { candidates ->
+ candidates.size == 2 && candidates.all { movie ->
+ val hydrated = movies.getMovieDetails(id, movie.id).getOrNull()
+ val resolved = hydrated?.let { movies.getStreamInfo(it).getOrNull() }
+ resolved?.expirationTime?.let { it > System.currentTimeMillis() + 3_600_000 } == true
+ }
+ }
+ }
+ check(rows.all { it.name.startsWith("Progressive ") })
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ prefs.setVodDuplicateHandlingMode(com.streamvault.domain.model.VodDuplicateHandlingMode.SHOW_ALL)
+ val remaining = rows.map { movies.getStreamInfo(it).getOrNull()!!.expirationTime!! - System.currentTimeMillis() }
+ Log.i("VodProgressiveFixture", "provisioned provider=$id movies=${rows.size} minimumResolvedLifetimeMs=${remaining.min()}")
+ Unit
+ }
+
+ @Test fun normalMoviesUiPlayback() {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("vodProgressiveCase") ?: "direct4k"
+ check(case in setOf("direct4k", "same1080"))
+ val title = if (case == "direct4k") "Progressive Matched Movie 4K AVC" else "Progressive Matched Movie 1080p AVC"
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ control(120_000_000)
+ click("Movies"); click(title); click("Play")
+ lateinit var vm: PlayerViewModel
+ await("player context") { var found = false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true } }; found }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("first frame") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.playerStats.value.ttffMs > 0 }
+ // History/detail resolution can publish a resume prompt after first frame.
+ device.wait(Until.findObject(By.text("Resume")), 5_000)?.let {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { action -> action() }
+ }
+ await("resume dialog dismissed") { !vm.resumePrompt.value.show && device.findObject(By.text("Resume Playback")) == null }
+ await("playback after resume dialog") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ await("resolving overlay cleared") { device.findObject(By.textContains("Resolving playback")) == null }
+ if (engine.duration.value > 195_000 && engine.duration.value - engine.currentPosition.value < 195_000) {
+ val resumed = engine.currentPosition.value
+ instrumentation.runOnMainSync { engine.seekTo(10_000); engine.play() }
+ await("enough finite content for sustained capture") {
+ engine.currentPosition.value in 9_000..20_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY
+ }
+ Log.i("VodProgressiveFixture", "capture-position-normalized resumedMs=$resumed targetMs=10000 reason=finite-window")
+ }
+ await("fixture language tracks") { engine.availableAudioTracks.value.any { it.language in listOf("es", "spa") } && engine.availableSubtitleTracks.value.any { it.language in listOf("en", "eng") } }
+ device.pressDPadCenter(); compose.waitForIdle()
+ val spanish = engine.availableAudioTracks.value.first { it.language in listOf("es", "spa") }.name
+ val english = engine.availableSubtitleTracks.value.first { it.language in listOf("en", "eng") }.name
+ compose.onNodeWithContentDescription("Audio").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(spanish, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithContentDescription("Subs").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(english, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("selected fixture languages") { engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") } && engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") } }
+ fun source() = engine.javaClass.getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+ assertThat(source().playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ Log.i("VodProgressiveFixture", "capture-ready case=$case intent=${source().playbackContentKind} ttffMs=${engine.playerStats.value.ttffMs} resumeDialog=false resolvingOverlay=false")
+ val samples = JSONArray()
+ // Leave room for slow 4K ADB captures while keeping the 240-second fixture finite.
+ val end = SystemClock.elapsedRealtime() + 180_000L
+ val began = SystemClock.elapsedRealtime()
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ check(device.findObject(By.text("Resume Playback")) == null)
+ val elapsed = SystemClock.elapsedRealtime() - began
+ val stats = engine.playerStats.value
+ val h = engine.videoFormat.value.height
+ val sample = JSONObject().put("elapsedMs", elapsed).put("positionMs", engine.currentPosition.value)
+ .put("state", engine.playbackState.value.name).put("height", h).put("bufferMs", stats.bufferedDurationMs)
+ .put("rebuffers", stats.rebufferCount).put("drops", stats.droppedFrames)
+ .put("javaAllocatedBytes", Debug.getRuntimeStat("art.gc.bytes-allocated"))
+ .put("pssKb", Debug.getPss())
+ instrumentation.runOnMainSync {
+ val player = engine.javaClass.getDeclaredField("exoPlayer").apply { isAccessible = true }.get(engine) as ExoPlayer
+ assertThat(player.isCurrentMediaItemLive).isFalse()
+ assertThat(player.isCurrentMediaItemDynamic).isFalse()
+ sample.put("timelineLive", player.isCurrentMediaItemLive).put("timelineDynamic", player.isCurrentMediaItemDynamic)
+ .put("videoWidth", player.videoFormat?.width).put("videoHeight", player.videoFormat?.height)
+ player.videoDecoderCounters?.let { counters ->
+ counters.ensureUpdated()
+ sample.put("renderedBuffers", counters.renderedOutputBufferCount)
+ .put("decoderDroppedBuffers", counters.droppedBufferCount)
+ .put("decoderSkippedBuffers", counters.skippedOutputBufferCount)
+ .put("decoderCounterInstance", System.identityHashCode(counters))
+ }
+ }
+ samples.put(sample)
+ File(app.filesDir, "vod-progressive-$case.json").writeText(samples.toString())
+ check(engine.playbackState.value != PlaybackState.ERROR)
+ SystemClock.sleep(1_000)
+ }
+ assertThat(engine.videoFormat.value.height).isEqualTo(if (case == "direct4k") 2160 else 1080)
+ control(120_000_000)
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("seek resume") { engine.currentPosition.value in 59_000..70_000 && engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ val seekPosition = engine.currentPosition.value
+ await("position progresses after seek") { engine.currentPosition.value >= seekPosition + 3_000 }
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ val history = vm.javaClass.methods.single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+ assertThat(history.streamUrl).isEqualTo(logicalUrl)
+ assertThat(history.resumePositionMs).isAtLeast(59_000)
+ assertThat(engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") }).isTrue()
+ assertThat(engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }).isTrue()
+ val renewal = Class.forName("com.streamvault.feature.playback.player.PlayerLifecycleActionsKt").methods.single { it.name == "startTokenRenewalMonitoring" && it.parameterCount == 3 }
+ instrumentation.runOnMainSync { renewal.invoke(null, vm, System.currentTimeMillis() + 1000, null) }
+ SystemClock.sleep(2_500)
+ assertThat(device.executeShellCommand("logcat -d -s PlayerVM:I")).contains("token-renewal request-changed=false")
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=PROGRESSIVE" in it }).isEqualTo(1)
+ assertThat(logs).doesNotContain("fatal-error")
+ assertThat(logs).doesNotContain("buffer-policy promote")
+ assertThat(engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") }).isTrue()
+ assertThat(engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }).isTrue()
+ Log.i("VodProgressiveFixture", "complete case=$case position=${engine.currentPosition.value} prepares=1 historyId=${history.contentId}")
+ }
+
+ @Test fun normalMoviesUiSerialTurnover() {
+ enabled()
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ control(120_000_000)
+ click("Movies"); click("Progressive Matched Movie 4K AVC"); click("Play")
+ lateinit var first: PlayerViewModel
+ await("first player context") { var found = false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { first = it; found = true } }; found }
+ SystemClock.sleep(1_500)
+ if (first.resumePrompt.value.show) compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("first resume dismissed") { !first.resumePrompt.value.show }
+ await("first ready") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.videoFormat.value.height == 2160 }
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("first nonzero seek") { engine.currentPosition.value in 59_000..75_000 && engine.isPlaying.value }
+ val firstUrl = getter(first, "getCurrentStreamUrl")
+ Log.i("VodProgressiveFixture", "turnover-before position=${engine.currentPosition.value}")
+ var returned = false
+ for (attempt in 0 until 5) {
+ device.pressBack(); SystemClock.sleep(500); compose.waitForIdle()
+ if (compose.onAllNodesWithContentDescription("Progressive Matched Movie 1080p AVC").fetchSemanticsNodes().isNotEmpty()) { returned = true; break }
+ }
+ check(returned) { "Normal Back navigation did not return to Movies" }
+ click("Progressive Matched Movie 1080p AVC"); click("Play")
+ lateinit var next: PlayerViewModel
+ await("next player context") { var found = false; instrumentation.runOnMainSync { findPlayer(compose.activity.viewModelStore)?.let { next = it; found = true } }; found }
+ SystemClock.sleep(1_500)
+ if (next.resumePrompt.value.show) compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("next resume dismissed") { !next.resumePrompt.value.show }
+ await("next ready") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY && engine.videoFormat.value.height == 1080 }
+ val position = engine.currentPosition.value
+ await("next progresses") { engine.currentPosition.value > position + 5_000 }
+ assertThat(getter(next, "getCurrentTitle")).isEqualTo("Progressive Matched Movie 1080p AVC")
+ assertThat(getter(next, "getCurrentStreamUrl")).isNotEqualTo(firstUrl)
+ assertThat(engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") }).isTrue()
+ assertThat(engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }).isTrue()
+ val logs = device.executeShellCommand("logcat -d -s Media3PlayerEngine:I")
+ assertThat(logs.lineSequence().count { "prepare resolvedStreamType=PROGRESSIVE" in it }).isEqualTo(2)
+ assertThat(logs).doesNotContain("fatal-error")
+ Log.i("VodProgressiveFixture", "serial-turnover-complete prepares=2 nextHeight=1080 languagesRetained=true")
+ }
+
+ @Test fun cleanupOnlyIsolatedMovies() = runBlocking {
+ enabled()
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val id = original.getLong("id")
+ check(providers.getProvider(id)?.name == "Progressive UI validation 20261003")
+ check(providers.deleteProvider(id).isSuccess)
+ check(providers.setActiveProvider(original.getLong("active")).isSuccess)
+ prefs.setLastActiveProviderId(original.getLong("last"))
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val restore = File(app.filesDir, "vod-progressive-restore.json")
+ val saved = JSONObject(restore.readText())
+ store.edit { current ->
+ current.remove(stringPreferencesKey("last_split_catalog_type_$id"))
+ for (name in listOf("vod_variant_observations", "player_vod_track_global_preferences", "player_vod_track_preferences", "vod_duplicate_handling_mode")) {
+ val key = stringPreferencesKey(name)
+ if (saved.isNull(name)) current.remove(key) else current[key] = saved.getString(name)
+ }
+ }
+ check(restore.delete())
+ check(setup.delete())
+ for (case in listOf("direct4k", "same1080")) File(app.filesDir, "vod-progressive-$case.json").delete()
+ for (name in listOf("vod-progressive-driver.png", "vod-progressive-driver.xml")) File(app.filesDir, name).delete()
+ }
+
+ @Test fun restoreOnlyFixtureCompatibilityLearning() {
+ enabled()
+ val file = File(app.filesDir, "vod-progressive-compatibility-private.json")
+ val changes = JSONArray(file.readText())
+ val database = (component("provideDatabaseProvider") as StreamVaultDatabase).openHelper.writableDatabase
+ database.beginTransaction()
+ try {
+ for (index in 0 until changes.length()) {
+ val change = changes.getJSONObject(index)
+ val expected = change.getJSONObject("expected")
+ val id = expected.getLong("id")
+ database.query("SELECT * FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id)).use { cursor ->
+ check(cursor.moveToFirst())
+ for (column in cursor.columnNames) {
+ val actual = cursor.getString(cursor.getColumnIndexOrThrow(column))
+ check(actual == if (expected.isNull(column)) null else expected.get(column).toString())
+ }
+ check(!cursor.moveToNext())
+ }
+ database.execSQL("DELETE FROM playback_compatibility_records WHERE id = ?", arrayOf<Any>(id))
+ if (!change.isNull("original")) {
+ val original = change.getJSONObject("original")
+ val columns = original.keys().asSequence().toList()
+ check(columns.all { it.matches(Regex("[a-z_]+")) })
+ database.execSQL("INSERT INTO playback_compatibility_records (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }})",
+ columns.map { if (original.isNull(it)) null else original.get(it).toString() }.toTypedArray())
+ }
+ }
+ database.setTransactionSuccessful()
+ } finally { database.endTransaction() }
+ check(file.delete())
+ }
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/VodTokenRenewalRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/VodTokenRenewalRuntimeTest.kt
new file mode 100644
index 00000000..5f24a033
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/VodTokenRenewalRuntimeTest.kt
@@ -0,0 +1,515 @@
+package com.streamvault.app.ui
+
+import android.app.Application
+import android.content.Context
+import android.os.SystemClock
+import android.util.Log
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performSemanticsAction
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.lifecycle.ViewModelStore
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.Until
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.domain.model.LegacyProvider
+import com.streamvault.domain.model.PlaybackHistory
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.feature.playback.player.PlayerViewModel
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.io.File
+import java.net.URL
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in normal Movies UI validation for changed authenticated playback requests. */
+@RunWith(AndroidJUnit4::class)
+class VodTokenRenewalRuntimeTest {
+ @get:Rule val compose = createAndroidComposeRule<com.streamvault.app.MainActivity>()
+ private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+ private val device get() = UiDevice.getInstance(instrumentation)
+ private val setup get() = File(app.filesDir, "v11-renewal-fixture-private.json")
+
+ private fun enabled() = assumeTrue(InstrumentationRegistry.getArguments().getString("v11Fixture") == "true")
+ private fun component(name: String): Any {
+ val graph = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (graph.javaClass.getDeclaredField(name).apply { isAccessible = true }.get(graph) as Provider<*>).get()!!
+ }
+
+ private fun await(label: String, timeoutMs: Long = 45_000, condition: () -> Boolean) {
+ val end = SystemClock.elapsedRealtime() + timeoutMs
+ while (SystemClock.elapsedRealtime() < end) {
+ compose.waitForIdle()
+ if (condition()) return
+ SystemClock.sleep(100)
+ }
+ if (!condition()) {
+ device.takeScreenshot(File(app.filesDir, "v11-renewal-driver.png"))
+ device.dumpWindowHierarchy(File(app.filesDir, "v11-renewal-driver.xml"))
+ error("Timed out: $label")
+ }
+ }
+
+ private fun click(text: String) {
+ compose.waitForIdle()
+ if (text == "Play") {
+ val playOrResume = hasText("Play") or hasText("Resume from", substring = true)
+ compose.waitUntil(10_000) { compose.onAllNodes(playOrResume).fetchSemanticsNodes().size == 1 }
+ compose.onNode(playOrResume).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ } else {
+ val node = device.wait(Until.findObject(By.textContains(text)), 5_000)
+ ?: device.wait(Until.findObject(By.descContains(text)), 5_000)
+ ?: error("Missing UI: $text")
+ val bounds = node.visibleBounds
+ device.executeShellCommand("input mouse tap ${bounds.centerX()} ${bounds.centerY()}")
+ }
+ compose.waitForIdle()
+ }
+
+ private fun navigateToMoviesTab() {
+ repeat(4) {
+ compose.waitForIdle()
+ if (device.wait(Until.findObject(By.text("Movies")), 100) != null) return
+ device.pressBack()
+ SystemClock.sleep(250)
+ }
+ error("Movies tab did not become visible after backing out of the prior screen")
+ }
+
+ private fun findPlayer(store: ViewModelStore): PlayerViewModel? {
+ for (key in store.keys()) {
+ val model = store[key] ?: continue
+ if (model is PlayerViewModel) return model
+ for (field in model.javaClass.declaredFields.filter { Map::class.java.isAssignableFrom(it.type) }) {
+ val nestedStores = (field.apply { isAccessible = true }.get(model) as? Map<*, *>)
+ ?.values?.filterIsInstance<ViewModelStore>().orEmpty()
+ for (nested in nestedStores) findPlayer(nested)?.let { return it }
+ }
+ }
+ return null
+ }
+
+ private fun getter(owner: Any, name: String): Any? = owner.javaClass.methods
+ .single { it.name.substringBefore('$') == name && it.parameterCount == 0 }.invoke(owner)
+
+ private fun source(engine: PlayerEngine): StreamInfo = engine.javaClass
+ .getDeclaredField("lastStreamInfo").apply { isAccessible = true }.get(engine) as StreamInfo
+
+ private fun providerId(): Long = JSONObject(setup.readText()).getLong("id")
+
+ private fun control(accepted: String, reset: Boolean = false) {
+ val resetArg = if (reset) "&reset=1" else ""
+ URL("http://10.0.2.2:18774/control?accept=$accepted$resetArg").readText()
+ }
+
+ private fun serverState(): JSONObject = JSONObject(URL("http://10.0.2.2:18774/events").readText())
+
+ private fun logs(tag: String): String = device.executeShellCommand("logcat -d -s $tag:I")
+
+ private fun applyCredential(provider: LegacyProvider, credential: String): LegacyProvider = when (credential) {
+ "old" -> provider.copy(username = "old-user", password = "old-pass")
+ "next" -> provider.copy(username = "next-user", password = "next-pass")
+ "third" -> provider.copy(username = "third-user", password = "third-pass")
+ "invalid" -> provider.copy(username = "invalid-user", password = "invalid-pass")
+ else -> error("Unknown fixture credential state")
+ }
+
+ private suspend fun updateCredential(credential: String) {
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val provider = providers.getProvider(providerId()) ?: error("V11 fixture provider disappeared")
+ check(provider.name == FIXTURE_NAME) { "Refusing to update a provider not owned by this fixture" }
+ check(providers.updateProvider(applyCredential(provider, credential)).isSuccess)
+ }
+
+ private fun startRenewal(vm: PlayerViewModel, expiryAtMs: Long, checkAtMs: Long) {
+ val function = Class.forName("com.streamvault.feature.playback.player.PlayerLifecycleActionsKt")
+ .methods.single { it.name == "startTokenRenewalMonitoring" && it.parameterCount == 3 }
+ instrumentation.runOnMainSync { function.invoke(null, vm, expiryAtMs, checkAtMs) }
+ }
+
+ private fun history(vm: PlayerViewModel, engine: PlayerEngine): PlaybackHistory = vm.javaClass.methods
+ .single { it.name.substringBefore('$') == "buildPlaybackHistorySnapshot" && it.parameterCount == 2 }
+ .invoke(vm, engine.currentPosition.value, engine.duration.value) as PlaybackHistory
+
+ private fun enterPlayback(title: String, engine: PlayerEngine): PlayerViewModel {
+ navigateToMoviesTab()
+ click("Movies")
+ await("movie catalog row: $title") {
+ device.wait(Until.findObject(By.textContains(title)), 100) != null ||
+ device.wait(Until.findObject(By.descContains(title)), 100) != null
+ }
+ click(title)
+ click("Play")
+ lateinit var vm: PlayerViewModel
+ await("player context") {
+ var found = false
+ instrumentation.runOnMainSync {
+ findPlayer(compose.activity.viewModelStore)?.let { vm = it; found = true }
+ }
+ found
+ }
+ SystemClock.sleep(1_500)
+ if (vm.resumePrompt.value.show) {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ await("first frame") {
+ engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY &&
+ engine.playerStats.value.ttffMs > 0
+ }
+ device.wait(Until.findObject(By.text("Resume")), 5_000)?.let {
+ compose.onNodeWithText("Resume").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ }
+ await("resume prompt dismissed") { !vm.resumePrompt.value.show && engine.isPlaying.value }
+ return vm
+ }
+
+ private fun selectProgressiveLanguages(engine: PlayerEngine) {
+ await("Spanish and English subtitle tracks") {
+ engine.availableAudioTracks.value.any { it.language in listOf("es", "spa") } &&
+ engine.availableSubtitleTracks.value.any { it.language in listOf("en", "eng") }
+ }
+ device.pressDPadCenter()
+ compose.waitForIdle()
+ val spanish = engine.availableAudioTracks.value.first { it.language in listOf("es", "spa") }.name
+ val english = engine.availableSubtitleTracks.value.first { it.language in listOf("en", "eng") }.name
+ compose.onNodeWithContentDescription("Audio").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(spanish, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithContentDescription("Subs").performSemanticsAction(SemanticsActions.OnClick) { it() }
+ compose.onNodeWithText(english, substring = true).performSemanticsAction(SemanticsActions.OnClick) { it() }
+ await("selected fixture languages") {
+ engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") } &&
+ engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }
+ }
+ }
+
+ private fun seekToNonzero(engine: PlayerEngine): Long {
+ instrumentation.runOnMainSync { engine.seekTo(60_000); engine.play() }
+ await("nonzero seek resumes") {
+ engine.currentPosition.value in 59_000..70_000 && engine.isPlaying.value &&
+ engine.playbackState.value == PlaybackState.READY
+ }
+ return engine.currentPosition.value
+ }
+
+ private fun mediaEvents(state: JSONObject): List<JSONObject> =
+ state.getJSONArray("events").let { rows -> (0 until rows.length()).map { rows.getJSONObject(it) } }
+
+ @Test
+ fun provisionIsolatedProvider() = runBlocking {
+ enabled()
+ control("old", reset = true)
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ if (setup.exists()) {
+ val existingId = JSONObject(setup.readText()).getLong("id")
+ if (providers.getProvider(existingId)?.name != FIXTURE_NAME) setup.delete()
+ }
+
+ if (!setup.exists()) {
+ val originalActive = providers.getActiveProvider().first()?.id ?: -1L
+ val originalLast = prefs.lastActiveProviderId.first() ?: -1L
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val snapshot = store.data.first()
+ val savedPreferences = JSONObject()
+ for (key in PREFERENCE_KEYS) {
+ savedPreferences.put(key, snapshot[stringPreferencesKey(key)] ?: JSONObject.NULL)
+ }
+ val id = providers.addProvider(
+ LegacyProvider(
+ name = FIXTURE_NAME,
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = FIXTURE_SERVER,
+ username = "old-user",
+ password = "old-pass",
+ maxConnections = 5,
+ isActive = false,
+ xtreamFastSyncEnabled = false
+ )
+ ).getOrNull() ?: error("V11 fixture provider creation failed")
+ setup.writeText(
+ JSONObject().put("id", id).put("active", originalActive).put("last", originalLast)
+ .put("preferences", savedPreferences).toString()
+ )
+ }
+
+ val id = providerId()
+ check(providers.getProvider(id)?.name == FIXTURE_NAME)
+ check(providers.refreshProviderData(id, force = true).isSuccess)
+ withTimeout(60_000) { movies.getCategories(id).first { it.isNotEmpty() } }
+ val sync = component("syncManagerProvider") as com.streamvault.data.sync.ProviderSyncCommands
+ check(sync.processQueuedXtreamIndexJobs(id, section = com.streamvault.domain.model.ContentType.MOVIE, force = true).isSuccess)
+ val rows = withTimeout(60_000) {
+ movies.getMovies(id).first { items -> items.size == 2 && items.all { it.name.startsWith("V11 ") } }
+ }
+ check(rows.map { it.name }.toSet() == setOf(HLS_TITLE, PROGRESSIVE_TITLE))
+ check(providers.setActiveProvider(id).isSuccess)
+ prefs.setLastActiveProviderId(id)
+ control("old", reset = true)
+ Log.i("VodTokenRenewal", "provisioned provider=$id movies=${rows.size} maxConnections=5")
+ Unit
+ }
+
+ @Test
+ fun changedAuthenticatedRequestRenewsCurrentItem() = runBlocking {
+ enabled()
+ val case = InstrumentationRegistry.getArguments().getString("v11Case") ?: "adaptive"
+ check(case in setOf("adaptive", "progressive"))
+ updateCredential("old")
+ control("old", reset = true)
+ device.executeShellCommand("logcat -c")
+
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ val title = if (case == "adaptive") HLS_TITLE else PROGRESSIVE_TITLE
+ val vm = enterPlayback(title, engine)
+
+ if (case == "adaptive") {
+ await("adaptive variants") { engine.availableVideoTracks.value.any { it.name.contains("1080p", ignoreCase = true) } }
+ val manual = engine.availableVideoTracks.value.first { it.name.contains("1080p", ignoreCase = true) }
+ Log.i("VodTokenRenewal", "manual-video-selection id=${manual.id} name=${manual.name}")
+ instrumentation.runOnMainSync { engine.selectVideoTrack(manual.id) }
+ await("manual 1080p selection") {
+ engine.videoFormat.value.height == 1080 &&
+ engine.availableVideoTracks.value.any { it.isSelected && it.name.contains("1080p", ignoreCase = true) }
+ }
+ } else {
+ selectProgressiveLanguages(engine)
+ }
+
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ val contentId = history(vm, engine).contentId
+ val positionBefore = seekToNonzero(engine)
+ val oldPhysicalUrl = source(engine).url
+ assertThat(oldPhysicalUrl).contains("/movie/old-user/old-pass/")
+
+ updateCredential("next")
+ control("old,next")
+ val handoffStartedAt = SystemClock.elapsedRealtime()
+ val priorFirstFrames = logs("Media3PlayerEngine").split("first-frame-success").size - 1
+ startRenewal(vm, System.currentTimeMillis() + 60_000L, System.currentTimeMillis())
+
+ await("new physical credential URL") { source(engine).url.contains("/movie/next-user/next-pass/") }
+ await("new authenticated media request") {
+ mediaEvents(serverState()).any { it.optString("event") == "open" && it.optString("credential") == "next" }
+ }
+ await("first frame after credential renewal", 30_000) {
+ logs("Media3PlayerEngine").split("first-frame-success").size - 1 > priorFirstFrames
+ }
+ await("playback advances after credential renewal") {
+ engine.playbackState.value == PlaybackState.READY && engine.isPlaying.value &&
+ engine.currentPosition.value >= positionBefore + 2_000
+ }
+ val handoffMs = SystemClock.elapsedRealtime() - handoffStartedAt
+ val afterHistory = history(vm, engine)
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ assertThat(afterHistory.streamUrl).isEqualTo(logicalUrl)
+ assertThat(afterHistory.contentId).isEqualTo(contentId)
+ assertThat(afterHistory.resumePositionMs).isAtLeast(59_000)
+ assertThat(engine.currentPosition.value).isAtLeast(positionBefore - 1_000)
+ assertThat(source(engine).url).isNotEqualTo(oldPhysicalUrl)
+
+ if (case == "adaptive") {
+ Log.i(
+ "VodTokenRenewal",
+ "adaptive-track-state height=${engine.videoFormat.value.height} tracks=" +
+ engine.availableVideoTracks.value.joinToString("|") { "${it.name}:${it.id}:${it.isSelected}" }
+ )
+ assertThat(engine.videoFormat.value.height).isEqualTo(1080)
+ assertThat(engine.availableVideoTracks.value.any {
+ it.isSelected && it.name.contains("1080p", ignoreCase = true)
+ }).isTrue()
+ } else {
+ assertThat(engine.availableAudioTracks.value.any { it.isSelected && it.language in listOf("es", "spa") }).isTrue()
+ assertThat(engine.availableSubtitleTracks.value.any { it.isSelected && it.language in listOf("en", "eng") }).isTrue()
+ }
+
+ // After handoff, retire the old credential at the server and observe that the player
+ // makes no more requests with it.
+ control("next")
+ SystemClock.sleep(2_000)
+ val finalServer = serverState()
+ val events = mediaEvents(finalServer)
+ assertThat(events.any { it.optString("event") == "open" && it.optString("credential") == "old" }).isTrue()
+ assertThat(events.any { it.optString("event") == "open" && it.optString("credential") == "next" }).isTrue()
+ val active = finalServer.getJSONObject("active")
+ val activeNames = active.names() ?: JSONArray()
+ assertThat((0 until activeNames.length()).map { active.getJSONObject(activeNames.getString(it)).optString("credential") })
+ .doesNotContain("old")
+ assertThat(finalServer.getInt("peakActive")).isAtMost(5)
+ val vmLogs = logs("PlayerVM")
+ assertThat(vmLogs).contains("token-renewal request-changed=true")
+ assertThat(vmLogs.split("token-renewal request-changed=true").size - 1).isEqualTo(1)
+ val engineLogs = logs("Media3PlayerEngine")
+ assertThat(engineLogs.split("renew-url resolvedStreamType=").size - 1).isEqualTo(1)
+ assertThat(engineLogs).doesNotContain("fatal-error")
+ Log.i("VodTokenRenewal", "handoff case=$case positionBefore=$positionBefore positionAfter=${engine.currentPosition.value} interruptionObservedMs=$handoffMs oldRequestRetired=true peakActive=${finalServer.getInt("peakActive")} renewals=1")
+ Unit
+ }
+
+ @Test
+ fun pendingRenewalIsCancelledWhenNavigationChangesContent() = runBlocking {
+ enabled()
+ updateCredential("old")
+ control("old,next,third", reset = true)
+ device.executeShellCommand("logcat -c")
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ val first = enterPlayback(HLS_TITLE, engine)
+ val scheduledAt = System.currentTimeMillis() + 7_000L
+ startRenewal(first, scheduledAt + 60_000L, scheduledAt)
+
+ updateCredential("next")
+ device.pressBack()
+ SystemClock.sleep(250)
+ device.pressBack()
+ await("movie detail with a second title") {
+ device.wait(Until.findObject(By.desc(PROGRESSIVE_TITLE)), 100) != null
+ }
+ compose.onNodeWithContentDescription(PROGRESSIVE_TITLE)
+ .performSemanticsAction(SemanticsActions.OnClick) { it() }
+ click("Play")
+ lateinit var second: PlayerViewModel
+ await("second player context") {
+ var found = false
+ instrumentation.runOnMainSync {
+ findPlayer(compose.activity.viewModelStore)?.let { second = it; found = true }
+ }
+ found && getter(second, "getCurrentTitle") == PROGRESSIVE_TITLE
+ }
+ await("second source ready") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ assertThat(source(engine).url).contains("/movie/next-user/next-pass/")
+ val secondLogicalUrl = getter(second, "getCurrentStreamUrl")
+ updateCredential("third")
+
+ val remaining = (scheduledAt + 4_000L - System.currentTimeMillis()).coerceAtLeast(0L)
+ SystemClock.sleep(remaining)
+ await("second playback remains healthy") { engine.isPlaying.value && engine.playbackState.value == PlaybackState.READY }
+ assertThat(getter(second, "getCurrentTitle")).isEqualTo(PROGRESSIVE_TITLE)
+ assertThat(getter(second, "getCurrentStreamUrl")).isEqualTo(secondLogicalUrl)
+ assertThat(source(engine).url).contains("/movie/next-user/next-pass/")
+ assertThat(logs("Media3PlayerEngine")).doesNotContain("renew-url resolvedStreamType=")
+ Log.i("VodTokenRenewal", "navigation-cancellation oldSessionRenewal=cancelled secondItemRetained=true")
+ Unit
+ }
+
+ @Test
+ fun invalidReplacementCredentialsStopRenewalAttempts() = runBlocking {
+ enabled()
+ updateCredential("old")
+ control("old", reset = true)
+ device.executeShellCommand("logcat -c")
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ val vm = enterPlayback(PROGRESSIVE_TITLE, engine)
+ selectProgressiveLanguages(engine)
+ val logicalTitle = getter(vm, "getCurrentTitle")
+ val logicalUrl = getter(vm, "getCurrentStreamUrl")
+ seekToNonzero(engine)
+
+ updateCredential("invalid")
+ startRenewal(vm, System.currentTimeMillis() + 60_000L, System.currentTimeMillis())
+ control("none")
+ await("invalid physical credential URL") { source(engine).url.contains("/movie/invalid-user/invalid-pass/") }
+ await("invalid credentials rejected") {
+ mediaEvents(serverState()).any {
+ it.optString("event") == "media" && it.optString("credential") == "invalid" && it.optInt("status") == 401
+ }
+ }
+ await("terminal authentication classification", 30_000) {
+ logs("Media3PlayerEngine").contains("fatal-error category=HTTP_AUTH reason=terminal-auth")
+ }
+ val initialInvalidAttempts = mediaEvents(serverState()).count {
+ it.optString("event") == "media" && it.optString("credential") == "invalid" && it.optInt("status") == 401
+ }
+ SystemClock.sleep(10_000)
+ val finalEvents = mediaEvents(serverState())
+ val finalInvalidAttempts = finalEvents.count {
+ it.optString("event") == "media" && it.optString("credential") == "invalid" && it.optInt("status") == 401
+ }
+ assertThat(finalInvalidAttempts).isEqualTo(initialInvalidAttempts)
+ assertThat(getter(vm, "getCurrentTitle")).isEqualTo(logicalTitle)
+ assertThat(getter(vm, "getCurrentStreamUrl")).isEqualTo(logicalUrl)
+ assertThat(logs("PlayerVM").split("token-renewal request-changed=true").size - 1).isEqualTo(1)
+ assertThat(logs("Media3PlayerEngine").split("renew-url resolvedStreamType=").size - 1).isEqualTo(1)
+ Log.i("VodTokenRenewal", "invalid-credentials terminal=true invalidRequests=$finalInvalidAttempts renewalAttempts=1 retryWindowMs=10000")
+ Unit
+ }
+
+ @Test
+ fun cleanupOnlyIsolatedProvider() = runBlocking {
+ enabled()
+ check(setup.exists()) { "V11 fixture setup record is missing" }
+ val original = JSONObject(setup.readText())
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val prefs = component("preferencesRepositoryProvider") as PreferencesRepository
+ val fixtureId = original.getLong("id")
+ check(providers.getProvider(fixtureId)?.name == FIXTURE_NAME)
+ check(providers.deleteProvider(fixtureId).isSuccess)
+ val originalActive = original.getLong("active")
+ if (originalActive > 0L) check(providers.setActiveProvider(originalActive).isSuccess)
+ val originalLast = original.getLong("last")
+ if (originalLast > 0L) prefs.setLastActiveProviderId(originalLast)
+
+ val context = prefs.javaClass.getDeclaredField("context").apply { isAccessible = true }.get(prefs) as Context
+ @Suppress("UNCHECKED_CAST")
+ val store = prefs.javaClass.getDeclaredMethod("getDataStore", Context::class.java).apply { isAccessible = true }
+ .invoke(prefs, context) as DataStore<Preferences>
+ val savedPreferences = original.getJSONObject("preferences")
+ store.edit { values ->
+ for (key in PREFERENCE_KEYS) {
+ val saved = savedPreferences.opt(key)
+ if (saved == null || saved === JSONObject.NULL) values.remove(stringPreferencesKey(key))
+ else values[stringPreferencesKey(key)] = saved.toString()
+ }
+ }
+ check(providers.getProvider(fixtureId) == null)
+ if (originalActive > 0L) check(providers.getActiveProvider().first()?.id == originalActive)
+ if (originalLast > 0L) check(prefs.lastActiveProviderId.first() == originalLast)
+ setup.delete()
+ File(app.filesDir, "v11-renewal-driver.png").delete()
+ File(app.filesDir, "v11-renewal-driver.xml").delete()
+ Log.i("VodTokenRenewal", "cleanup fixtureProvider=$fixtureId restoredActive=$originalActive restoredLast=$originalLast")
+ Unit
+ }
+
+ private companion object {
+ const val FIXTURE_NAME = "V11 auth rollover UI fixture 20261004"
+ const val FIXTURE_SERVER = "http://10.0.2.2:18774"
+ const val HLS_TITLE = "V11 HLS Adaptive Fixture"
+ const val PROGRESSIVE_TITLE = "V11 Progressive Tracks Fixture"
+ val PREFERENCE_KEYS = listOf(
+ "player_vod_track_global_preferences",
+ "player_vod_track_preferences",
+ "vod_duplicate_handling_mode",
+ "vod_variant_observations"
+ )
+ }
+}
diff --git a/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncDaoMovieStageTest.kt b/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncDaoMovieStageTest.kt
new file mode 100644
index 00000000..dbc8ee6f
--- /dev/null
+++ b/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncDaoMovieStageTest.kt
@@ -0,0 +1,69 @@
+package com.streamvault.data.local
+
+import android.content.Context
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.dao.CatalogSyncDao
+import com.streamvault.data.local.dao.MovieDao
+import com.streamvault.data.local.dao.ProviderDao
+import com.streamvault.data.local.entity.MovieImportStageEntity
+import com.streamvault.data.local.entity.ProviderEntity
+import com.streamvault.domain.model.ProviderType
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CatalogSyncDaoMovieStageTest {
+ private lateinit var db: StreamVaultDatabase
+ private lateinit var providerDao: ProviderDao
+ private lateinit var movieDao: MovieDao
+ private lateinit var catalogSyncDao: CatalogSyncDao
+
+ @Before
+ fun createDb() {
+ val context = ApplicationProvider.getApplicationContext<Context>()
+ db = Room.inMemoryDatabaseBuilder(context, StreamVaultDatabase::class.java).build()
+ providerDao = db.providerDao()
+ movieDao = db.movieDao()
+ catalogSyncDao = db.catalogSyncDao()
+ }
+
+ @After
+ fun closeDb() {
+ db.close()
+ }
+
+ @Test
+ fun insertMissingMoviesFromStage_setsSummaryCacheState() = runTest {
+ providerDao.insert(
+ ProviderEntity(
+ id = 1L,
+ name = "M3U fixture",
+ type = ProviderType.M3U
+ )
+ )
+ catalogSyncDao.insertMovieStages(
+ listOf(
+ MovieImportStageEntity(
+ sessionId = 10L,
+ providerId = 1L,
+ streamId = 701L,
+ name = "Protected movie",
+ streamUrl = "http://127.0.0.1/movie.mp4",
+ syncFingerprint = "fixture"
+ )
+ )
+ )
+
+ catalogSyncDao.insertMissingMoviesFromStage(providerId = 1L, sessionId = 10L)
+
+ val inserted = movieDao.getByStreamId(providerId = 1L, streamId = 701L)
+ assertThat(inserted).isNotNull()
+ assertThat(inserted?.cacheState).isEqualTo("SUMMARY_ONLY")
+ }
+}
diff --git a/data/src/main/java/com/streamvault/data/local/dao/CatalogSyncDao.kt b/data/src/main/java/com/streamvault/data/local/dao/CatalogSyncDao.kt
index 56f46504..e03e4fb2 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/CatalogSyncDao.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/CatalogSyncDao.kt
@@ -609,7 +609,10 @@ interface CatalogSyncDao {
is_user_protected,
playback_metadata_json,
sync_fingerprint,
- added_at
+ added_at,
+ cache_state,
+ detail_hydrated_at,
+ remote_stale_at
)
SELECT
stage.stream_id,
@@ -645,7 +648,10 @@ interface CatalogSyncDao {
) THEN 1 ELSE 0 END,
stage.playback_metadata_json,
stage.sync_fingerprint,
- stage.added_at
+ stage.added_at,
+ 'SUMMARY_ONLY',
+ 0,
+ 0
FROM movie_import_stage AS stage
WHERE stage.session_id = :sessionId
AND stage.provider_id = :providerId
diff --git a/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.kt b/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.kt
index 1622471d..9256f923 100644
--- a/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.kt
+++ b/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.kt
@@ -31,7 +31,8 @@ fun Provider.toTypedConfiguration(): ProviderConfiguration = when (type) {
guideSourcePolicy = guideSourcePolicy,
channelLogoSourcePolicy = channelLogoSourcePolicy,
fastSyncEnabled = xtreamFastSyncEnabled,
- liveSyncMode = xtreamLiveSyncMode
+ liveSyncMode = xtreamLiveSyncMode,
+ preferredLiveStreamFormat = preferredLiveStreamFormat
)
ProviderType.M3U -> M3uConfig(
playlistUrl = m3uUrl.ifBlank { serverUrl },
diff --git a/data/src/main/java/com/streamvault/data/provider/ProductionProviderCapabilityFactories.kt b/data/src/main/java/com/streamvault/data/provider/ProductionProviderCapabilityFactories.kt
index ec775a35..32fa58a7 100644
--- a/data/src/main/java/com/streamvault/data/provider/ProductionProviderCapabilityFactories.kt
+++ b/data/src/main/java/com/streamvault/data/provider/ProductionProviderCapabilityFactories.kt
@@ -243,6 +243,7 @@ private class XtreamCapabilityAdapter(
val streamId = directToken?.streamId ?: request.content.numericRemoteId()
?: return Result.error("Xtream playback stream ID is missing")
val resolvedExtension = clients.resolveLiveContainerExtension(
+ snapshot,
kind,
directToken?.containerExtension ?: request.containerExtension
)
@@ -259,6 +260,9 @@ private class XtreamCapabilityAdapter(
)
val sourceIsInternal = token != null
val resolvedUrl = when {
+ kind == XtreamStreamKind.LIVE && XtreamUrlFactory.isGeneratedCatchUpUrl(
+ request.sourceUrl, config.serverUrl, config.username, config.password, streamId
+ ) -> request.sourceUrl
request.preferStableUrl -> stableUrl
directSource != null -> directSource
sourceIsInternal -> stableUrl
diff --git a/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.kt b/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.kt
index d0159343..0dddcb19 100644
--- a/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.kt
+++ b/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.kt
@@ -138,7 +138,8 @@ fun ProviderConfiguration.toLegacyProvider(
guideSourcePolicy = guideSourcePolicy,
channelLogoSourcePolicy = channelLogoSourcePolicy,
xtreamFastSyncEnabled = fastSyncEnabled,
- xtreamLiveSyncMode = liveSyncMode
+ xtreamLiveSyncMode = liveSyncMode,
+ preferredLiveStreamFormat = preferredLiveStreamFormat
)
is M3uConfig -> common.copy(
m3uUrl = playlistUrl,
diff --git a/data/src/main/java/com/streamvault/data/provider/TypedProviderClientFactory.kt b/data/src/main/java/com/streamvault/data/provider/TypedProviderClientFactory.kt
index 8f4dfebf..5b076d43 100644
--- a/data/src/main/java/com/streamvault/data/provider/TypedProviderClientFactory.kt
+++ b/data/src/main/java/com/streamvault/data/provider/TypedProviderClientFactory.kt
@@ -156,10 +156,19 @@ class TypedProviderClientFactory @Inject constructor(
)
}
- suspend fun resolveLiveContainerExtension(kind: XtreamStreamKind, value: String?): String? {
+ suspend fun resolveLiveContainerExtension(
+ snapshot: ProviderSnapshot,
+ kind: XtreamStreamKind,
+ value: String?
+ ): String? {
if (kind != XtreamStreamKind.LIVE) return value
+ val providerPreference = (snapshot.configuration as? XtreamConfig)?.preferredLiveStreamFormat
return when (preferencesRepository.playerLiveStreamFormatMode.first()) {
- LiveStreamFormatMode.AUTO -> value
+ LiveStreamFormatMode.AUTO -> when (providerPreference) {
+ LiveStreamFormatMode.HLS -> "m3u8"
+ LiveStreamFormatMode.MPEG_TS -> "ts"
+ LiveStreamFormatMode.AUTO, null -> value
+ }
LiveStreamFormatMode.HLS -> "m3u8"
LiveStreamFormatMode.MPEG_TS -> "ts"
}
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamUrlFactory.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamUrlFactory.kt
index 542adccb..689c707c 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamUrlFactory.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamUrlFactory.kt
@@ -267,6 +267,42 @@ object XtreamUrlFactory {
}.distinct()
}
+ /** Matches only archive URLs generated for this provider and channel, retaining their time range. */
+ fun isGeneratedCatchUpUrl(
+ url: String,
+ serverUrl: String,
+ username: String,
+ password: String,
+ streamId: Long
+ ): Boolean = runCatching {
+ val prefix = serverUrl.trimEnd('/') + "/"
+ if (!url.startsWith(prefix) || !StreamEntryUrlPolicy.isAllowed(url)) return@runCatching false
+ val relative = URI(url.removePrefix(prefix))
+ val segments = relative.rawPath.split('/')
+ val duration: Long
+ val start: String
+ val extension: String
+ when (segments.firstOrNull()) {
+ "timeshift", "timeshifts" -> {
+ if (segments.size != 6) return@runCatching false
+ duration = segments[3].toLongOrNull() ?: return@runCatching false
+ val file = XtreamUrlCodec.decode(segments[5])
+ extension = normalizeContainerExtension(file.substringAfterLast('.', "")) ?: return@runCatching false
+ start = if (segments[0] == "timeshift") XtreamUrlCodec.decode(segments[4]) else file.substringBeforeLast('.')
+ }
+ "timeshift.php", "streaming" -> {
+ if (relative.rawPath !in listOf("timeshift.php", "streaming/timeshift.php")) return@runCatching false
+ val query = parseQuery(relative.rawQuery)
+ duration = query["duration"]?.toLongOrNull() ?: return@runCatching false
+ start = query["start"] ?: return@runCatching false
+ extension = query["extension"]?.let(::normalizeContainerExtension) ?: "ts"
+ }
+ else -> return@runCatching false
+ }
+ if (duration <= 0 || !start.matches(Regex("\\d{4}-\\d{2}-\\d{2}:\\d{2}-\\d{2}"))) return@runCatching false
+ url in buildCatchUpUrls(serverUrl, username, password, duration, start, streamId, listOf(extension))
+ }.getOrDefault(false)
+
fun buildInternalStreamUrl(
providerId: Long,
kind: XtreamStreamKind,
diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
index e267e64d..5881e5c3 100644
--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
@@ -26,10 +26,12 @@ import com.streamvault.data.remote.stalker.StalkerRequestDescriptor
import com.streamvault.data.remote.stalker.StalkerResponseMetrics
import com.streamvault.data.remote.stalker.StalkerTrafficCoordinator
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
+import com.streamvault.data.security.CredentialDecryptionException
import com.streamvault.data.sync.ContentCachePolicy
import com.streamvault.data.sync.CatalogHydrationCommands
import com.streamvault.data.util.MoviePresentationSettings
import com.streamvault.data.util.buildPresentedMovies
+import com.streamvault.data.util.movieLogicalGroupId
import com.streamvault.data.util.rankSearchResults
import com.streamvault.data.util.toFtsPrefixQuery
import com.streamvault.domain.model.Category
@@ -489,7 +491,7 @@ class MovieRepositoryImpl @Inject constructor(
private fun scheduleMoviePrefetch(providerId: Long, categoryId: Long, loadMode: VodCategoryLoadMode) {
if (loadMode != VodCategoryLoadMode.PAGED) return
repositoryScope.launch {
- val provider = loadCompatibilityProvider(providerId) ?: return@launch
+ val provider = loadBackgroundCompatibilityProvider(providerId) ?: return@launch
val current = movieCategoryHydrationDao.get(providerId, categoryId)
if (current?.isComplete == true) return@launch
if (provider.catalogLayout == CatalogLayout.SPLIT && provider.catalogLayoutDetectionVersion > 0) {
@@ -553,6 +555,28 @@ class MovieRepositoryImpl @Inject constructor(
?.let { movie -> attachMoviePresentation(movie).variants }
.orEmpty()
+ override suspend fun hasExplicitMovieVariantSelection(movieId: Long): Boolean {
+ val movie = movieDao.getById(movieId)?.toDomain() ?: return true
+ if (movie.providerId <= 0L) return true
+ val settings = moviePresentationSettingsFlow.first()
+ val logicalGroupId = movie.logicalGroupId?.takeIf { it.isNotBlank() }
+ ?: movieLogicalGroupId(movie)
+ val selectionKey = "${movie.providerId}|$logicalGroupId"
+ if (selectionKey in settings.preferredVariants) return true
+
+ val raw = loadPresentationCandidates(movie).filter { it.providerId == movie.providerId }
+ val groupedMovie = buildPresentedMovies(
+ movies = raw.map { it.toDomain() },
+ settings = settings.copy(duplicateHandlingMode = VodDuplicateHandlingMode.GROUPED)
+ ).firstOrNull { presented ->
+ presented.id == movie.id || presented.variants.any { it.rawMovieId == movie.id }
+ }
+ val groupMovieIds = groupedMovie?.variants?.map { it.rawMovieId }.orEmpty().toSet() + movie.id
+ return settings.preferredVariants.any { (key, selectedMovieId) ->
+ key.startsWith("${movie.providerId}|") && selectedMovieId in groupMovieIds
+ }
+ }
+
override suspend fun getMovieDetails(
providerId: Long,
movieId: Long,
@@ -1680,7 +1704,7 @@ class MovieRepositoryImpl @Inject constructor(
repositoryScope.launch {
if (!backgroundRefreshes.awaitAdd(key)) return@launch
try {
- val provider = loadCompatibilityProvider(providerId) ?: return@launch
+ val provider = loadBackgroundCompatibilityProvider(providerId) ?: return@launch
if (provider.type != ProviderType.XTREAM_CODES && provider.type != ProviderType.STALKER_PORTAL) {
return@launch
}
@@ -1990,5 +2014,13 @@ class MovieRepositoryImpl @Inject constructor(
private suspend fun loadCompatibilityProvider(providerId: Long): Provider? =
providerCapabilityResolver.snapshot(providerId)?.toLegacyProvider()
+
+ private suspend fun loadBackgroundCompatibilityProvider(providerId: Long): Provider? =
+ try {
+ loadCompatibilityProvider(providerId)
+ } catch (_: CredentialDecryptionException) {
+ Log.w(TAG, "Skipping background movie work because provider credentials are unreadable (providerId=$providerId)")
+ null
+ }
}
diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
index b1b9e053..5cc1b880 100644
--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
@@ -426,6 +426,7 @@ class ProviderRepositoryImpl @Inject constructor(
xtreamLiveSyncMode = config.liveSyncMode,
guideSourcePolicy = config.guideSourcePolicy,
channelLogoSourcePolicy = config.channelLogoSourcePolicy,
+ preferredLiveStreamFormat = config.preferredLiveStreamFormat,
onProgress = onProgress,
id = request.existingProviderId
)
@@ -500,6 +501,7 @@ class ProviderRepositoryImpl @Inject constructor(
xtreamLiveSyncMode: com.streamvault.domain.model.ProviderXtreamLiveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
guideSourcePolicy: GuideSourcePolicy = GuideSourcePolicy.AUTO,
channelLogoSourcePolicy: ChannelLogoSourcePolicy = ChannelLogoSourcePolicy.SUPPLIER_PREFERRED,
+ preferredLiveStreamFormat: LiveStreamFormatMode? = null,
onProgress: ((String) -> Unit)? = null,
id: Long? = null
): Result<Provider> = try {
@@ -557,7 +559,8 @@ class ProviderRepositoryImpl @Inject constructor(
guideSourcePolicy = guideSourcePolicy,
channelLogoSourcePolicy = channelLogoSourcePolicy,
fastSyncEnabled = xtreamFastSyncEnabled,
- liveSyncMode = xtreamLiveSyncMode
+ liveSyncMode = xtreamLiveSyncMode,
+ preferredLiveStreamFormat = preferredLiveStreamFormat
),
configurationGeneration = candidateGeneration
)
@@ -584,6 +587,7 @@ class ProviderRepositoryImpl @Inject constructor(
xtreamLiveSyncMode = xtreamLiveSyncMode,
guideSourcePolicy = guideSourcePolicy,
channelLogoSourcePolicy = channelLogoSourcePolicy,
+ preferredLiveStreamFormat = preferredLiveStreamFormat,
xtreamFastSyncEnabled = false,
isActive = false,
status = ProviderStatus.PARTIAL,
@@ -604,6 +608,7 @@ class ProviderRepositoryImpl @Inject constructor(
xtreamLiveSyncMode = xtreamLiveSyncMode,
guideSourcePolicy = guideSourcePolicy,
channelLogoSourcePolicy = channelLogoSourcePolicy,
+ preferredLiveStreamFormat = preferredLiveStreamFormat,
xtreamFastSyncEnabled = false,
isActive = false,
status = ProviderStatus.PARTIAL
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index 19eb4853..ffc0145d 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -20,6 +20,7 @@ import com.streamvault.data.sync.ContentCachePolicy
import com.streamvault.data.sync.CatalogHydrationCommands
import com.streamvault.data.util.SeriesPresentationSettings
import com.streamvault.data.util.buildPresentedSeries
+import com.streamvault.data.util.seriesLogicalGroupId
import com.streamvault.domain.model.*
import com.streamvault.domain.model.LegacyProvider as Provider
import com.streamvault.domain.model.Result.Success
@@ -464,6 +465,29 @@ class SeriesRepositoryImpl @Inject constructor(
override suspend fun getSeriesById(seriesId: Long): Series? =
seriesDao.getById(seriesId)?.toDomain()
+ override suspend fun getSeriesVariants(seriesId: Long): List<VodSeriesVariant> {
+ val series = getSeriesById(seriesId) ?: return emptyList()
+ if (series.providerId <= 0L) return emptyList()
+ return attachSeriesPresentation(series).variants
+ }
+
+ override suspend fun hasExplicitSeriesVariantSelection(seriesId: Long): Boolean {
+ val series = getSeriesById(seriesId) ?: return true
+ if (series.providerId <= 0L) return true
+ val settings = seriesPresentationSettingsFlow.first()
+ val currentKey = "${series.providerId}|${seriesLogicalGroupId(series)}"
+ if (currentKey in settings.preferredVariants) return true
+ val raw = loadSeriesPresentationCandidates(series).filter { it.providerId == series.providerId }
+ // Membership is derived from existing grouping even if presentation is currently Show All.
+ val members = buildPresentedSeries(raw.map { it.toDomain() }, settings.copy(
+ duplicateHandlingMode = VodDuplicateHandlingMode.GROUPED
+ )).firstOrNull { it.id == series.id || it.variants.any { variant -> variant.rawSeriesId == series.id } }
+ val ids = members?.variants?.map { it.rawSeriesId }.orEmpty().toSet() + series.id
+ return settings.preferredVariants.any { (key, selectedId) ->
+ key.startsWith("${series.providerId}|") && selectedId in ids
+ }
+ }
+
override suspend fun getEpisodeById(episodeId: Long): Episode? =
episodeDao.getById(episodeId)?.toDomain()
diff --git a/data/src/main/java/com/streamvault/data/util/VodMovieDeduplication.kt b/data/src/main/java/com/streamvault/data/util/VodMovieDeduplication.kt
index 55ac18f7..a01b95d3 100644
--- a/data/src/main/java/com/streamvault/data/util/VodMovieDeduplication.kt
+++ b/data/src/main/java/com/streamvault/data/util/VodMovieDeduplication.kt
@@ -68,7 +68,7 @@ private val EDITION_TOKENS: List<String> = listOf(
private val YEAR_REGEX = Regex("""(19|20)\d{2}""")
private val YEAR_SUFFIX_REGEX = Regex("""\s*\((19|20)\d{2}\)\s*$""")
private val QUALITY_CLEANUP_REGEX = Regex(
- """\b(8k|4320p|uhd|ultra\s*hd|4k|2160p|2k|qhd|1440p|full\s*hd|fullhd|fhd|1080p|1080i|hd|720p|576p|540p|hq|sd|480p|360p|240p|hdr10|hdr|dolby\s*vision|remux|blu\s*ray|bluray|bdrip|web\s*dl|web-dl|webrip|hevc|h265|x265|av1)\b""",
+ """\b(8k|4320p|uhd|ultra\s*hd|4k|2160p|2k|qhd|1440p|full\s*hd|fullhd|fhd|1080p|1080i|hd|720p|576p|540p|hq|sd|480p|360p|240p|hdr10|hdr|dolby\s*vision|remux|blu\s*ray|bluray|bdrip|web\s*dl|web-dl|webrip|hevc|h[ ._-]*265|x265|hev1|hvc1|avc|h[ ._-]*264|x264|av1)\b""",
RegexOption.IGNORE_CASE
)
private val NON_ALPHANUMERIC_REGEX = Regex("""[^a-z0-9]+""")
diff --git a/data/src/test/java/com/streamvault/data/provider/LegacyProviderLiveFormatPreferenceTest.kt b/data/src/test/java/com/streamvault/data/provider/LegacyProviderLiveFormatPreferenceTest.kt
new file mode 100644
index 00000000..23ea8aba
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/provider/LegacyProviderLiveFormatPreferenceTest.kt
@@ -0,0 +1,33 @@
+package com.streamvault.data.provider
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.model.Provider
+import com.streamvault.domain.model.ProviderAccountRuntime
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.XtreamConfig
+import org.junit.Test
+
+class LegacyProviderLiveFormatPreferenceTest {
+
+ @Test
+ fun `Xtream live format preference survives legacy repository projection`() {
+ val configuration = XtreamConfig(
+ serverUrl = "https://example.test",
+ username = "user",
+ password = "secret",
+ preferredLiveStreamFormat = LiveStreamFormatMode.MPEG_TS
+ )
+ val provider = configuration.toLegacyProvider(
+ identity = com.streamvault.domain.model.Provider(
+ id = 12L,
+ name = "Test provider",
+ type = ProviderType.XTREAM_CODES
+ ),
+ runtime = ProviderAccountRuntime()
+ )
+
+ assertThat(provider.toTypedConfiguration())
+ .isEqualTo(configuration)
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/provider/ProductionProviderCapabilityFactoriesTest.kt b/data/src/test/java/com/streamvault/data/provider/ProductionProviderCapabilityFactoriesTest.kt
index 6e04d585..9365a813 100644
--- a/data/src/test/java/com/streamvault/data/provider/ProductionProviderCapabilityFactoriesTest.kt
+++ b/data/src/test/java/com/streamvault/data/provider/ProductionProviderCapabilityFactoriesTest.kt
@@ -25,6 +25,10 @@ import com.streamvault.domain.model.StalkerPortalLearning
import com.streamvault.domain.model.XtreamConfig
import com.streamvault.domain.provider.CapabilityResolution
import com.streamvault.domain.provider.PlaybackResolver
+import com.streamvault.domain.provider.PlaybackRequest
+import com.streamvault.domain.provider.ProviderContentReference
+import com.streamvault.data.remote.xtream.XtreamUrlFactory
+import com.streamvault.data.remote.xtream.XtreamStreamKind
import org.junit.Test
import kotlinx.coroutines.test.runTest
import org.mockito.kotlin.mock
@@ -38,6 +42,45 @@ class ProductionProviderCapabilityFactoriesTest {
private val movieDao: MovieDao = mock()
private val programDao: ProgramDao = mock()
+ @Test fun `Xtream live identity preserves every generated archive time range even on stable renewal`() = runTest {
+ val config = XtreamConfig("https://archive.test/base", "user name", "pass/word",
+ httpUserAgent = "ArchiveTest/1", httpHeaders = "X-Archive: validation")
+ val provider = snapshot(ProviderType.XTREAM_CODES, config)
+ whenever(clients.resolveLiveContainerExtension(provider, XtreamStreamKind.LIVE, "m3u8")).thenReturn("m3u8")
+ val resolver = (availableSet(registry().resolve(provider)).playback() as CapabilityResolution.Available).capability
+ val urls = listOf("m3u8", "ts").flatMap { extension ->
+ XtreamUrlFactory.buildCatchUpUrls(config.serverUrl, config.username, config.password,
+ 4, "2026-10-03:07-55", 1001, listOf(extension)).also { assertThat(it).hasSize(6) }
+ }
+ for (url in urls) for (stable in listOf(false, true)) {
+ val resolved = resolver.resolve(PlaybackRequest(url, ProviderContentReference(provider.provider.id, streamId = 1001),
+ ContentType.LIVE, "m3u8", preferStableUrl = stable)).getOrNull()!!
+ assertThat(resolved.url).isEqualTo(url)
+ assertThat(resolved.userAgent).isEqualTo("ArchiveTest/1")
+ assertThat(resolved.headers).containsEntry("X-Archive", "validation")
+ assertThat(resolved.containerExtension).isEqualTo("m3u8")
+ }
+ }
+
+ @Test fun `Xtream ordinary live URLs still normalize to current provider credentials`() = runTest {
+ val config = XtreamConfig("https://archive.test", "current", "secret")
+ val provider = snapshot(ProviderType.XTREAM_CODES, config)
+ whenever(clients.resolveLiveContainerExtension(provider, XtreamStreamKind.LIVE, "m3u8")).thenReturn("m3u8")
+ val resolver = (availableSet(registry().resolve(provider)).playback() as CapabilityResolution.Available).capability
+ val inputs = listOf("https://archive.test/live/old/old/1001.m3u8",
+ XtreamUrlFactory.buildInternalStreamUrl(provider.provider.id, XtreamStreamKind.LIVE, 1001, "m3u8"),
+ "https://other.test/timeshift/current/secret/4/2026-10-03%3A07-55/1001.m3u8",
+ "https://archive.test/timeshift/old/old/4/2026-10-03%3A07-55/1001.m3u8",
+ "https://archive.test/timeshift/current/secret/4/2026-10-03%3A07-55/999.m3u8",
+ "https://archive.test/timeshift/current/secret/0/2026-10-03%3A07-55/1001.m3u8",
+ "https://archive.test/timeshift.php?username=current&password=secret&stream=1001&start=bad&duration=4")
+ for (url in inputs) for (stable in listOf(false, true)) {
+ val resolved = resolver.resolve(PlaybackRequest(url, ProviderContentReference(provider.provider.id, streamId = 1001),
+ ContentType.LIVE, "m3u8", preferStableUrl = stable)).getOrNull()!!
+ assertThat(resolved.url).isEqualTo("https://archive.test/live/current/secret/1001.m3u8")
+ }
+ }
+
@Test
fun `production factories register every provider type exactly once`() {
val stalker = snapshot(
diff --git a/data/src/test/java/com/streamvault/data/provider/ProviderConfigurationCodecTest.kt b/data/src/test/java/com/streamvault/data/provider/ProviderConfigurationCodecTest.kt
index 039f55b6..db694daa 100644
--- a/data/src/test/java/com/streamvault/data/provider/ProviderConfigurationCodecTest.kt
+++ b/data/src/test/java/com/streamvault/data/provider/ProviderConfigurationCodecTest.kt
@@ -16,7 +16,12 @@ class ProviderConfigurationCodecTest {
@Test
fun `round trips every subtype without plaintext credentials`() {
val configurations = listOf<ProviderConfiguration>(
- XtreamConfig("https://x.test", "alice", "secret"),
+ XtreamConfig(
+ "https://x.test",
+ "alice",
+ "secret",
+ preferredLiveStreamFormat = LiveStreamFormatMode.MPEG_TS
+ ),
M3uConfig("https://m.test/list.m3u", epgUrl = "https://m.test/epg.xml"),
StalkerConfig(
portalUrl = "https://s.test",
diff --git a/data/src/test/java/com/streamvault/data/provider/TypedProviderClientFactoryLiveFormatTest.kt b/data/src/test/java/com/streamvault/data/provider/TypedProviderClientFactoryLiveFormatTest.kt
new file mode 100644
index 00000000..06a62c58
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/provider/TypedProviderClientFactoryLiveFormatTest.kt
@@ -0,0 +1,90 @@
+package com.streamvault.data.provider
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.remote.jellyfin.JellyfinProvider
+import com.streamvault.data.remote.stalker.StalkerApiService
+import com.streamvault.data.remote.stalker.StalkerPortalStateStore
+import com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolver
+import com.streamvault.data.remote.xtream.XtreamApiService
+import com.streamvault.data.remote.xtream.XtreamStreamKind
+import com.streamvault.domain.model.LiveStreamFormatMode
+import com.streamvault.domain.model.Provider
+import com.streamvault.domain.model.ProviderSnapshot
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.XtreamConfig
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class TypedProviderClientFactoryLiveFormatTest {
+ @Test
+ fun `auto honors imported provider TS format over catalog HLS extension`() = runTest {
+ val factory = factory(LiveStreamFormatMode.AUTO)
+
+ val resolved = factory.resolveLiveContainerExtension(
+ snapshot(LiveStreamFormatMode.MPEG_TS),
+ XtreamStreamKind.LIVE,
+ "m3u8"
+ )
+
+ assertThat(resolved).isEqualTo("ts")
+ }
+
+ @Test
+ fun `explicit app HLS format overrides imported provider TS format`() = runTest {
+ val factory = factory(LiveStreamFormatMode.HLS)
+
+ val resolved = factory.resolveLiveContainerExtension(
+ snapshot(LiveStreamFormatMode.MPEG_TS),
+ XtreamStreamKind.LIVE,
+ "ts"
+ )
+
+ assertThat(resolved).isEqualTo("m3u8")
+ }
+
+ @Test
+ fun `provider live format preference does not change VOD extension`() = runTest {
+ val factory = factory(LiveStreamFormatMode.AUTO)
+
+ val resolved = factory.resolveLiveContainerExtension(
+ snapshot(LiveStreamFormatMode.MPEG_TS),
+ XtreamStreamKind.MOVIE,
+ "mp4"
+ )
+
+ assertThat(resolved).isEqualTo("mp4")
+ }
+
+ private fun factory(mode: LiveStreamFormatMode): TypedProviderClientFactory {
+ val preferences = mock<PreferencesRepository>().apply {
+ whenever(playerLiveStreamFormatMode).thenReturn(flowOf(mode))
+ }
+ return TypedProviderClientFactory(
+ xtreamApiService = mock<XtreamApiService>(),
+ stalkerApiService = mock<StalkerApiService>(),
+ jellyfinProvider = mock<JellyfinProvider>(),
+ preferencesRepository = preferences,
+ stalkerRemoteIdentityResolver = mock<StalkerRemoteIdentityResolver>(),
+ stalkerPortalStateStore = mock<StalkerPortalStateStore>()
+ )
+ }
+
+ private fun snapshot(preference: LiveStreamFormatMode) = ProviderSnapshot(
+ provider = Provider(
+ id = 1L,
+ name = "Xtream",
+ type = ProviderType.XTREAM_CODES
+ ),
+ configuration = XtreamConfig(
+ serverUrl = "https://provider.example",
+ username = "user",
+ password = "pass",
+ preferredLiveStreamFormat = preference
+ ),
+ configurationGeneration = 1L
+ )
+}
diff --git a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
index 0da5bd9b..1cc76a8d 100644
--- a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
@@ -20,10 +20,12 @@ import com.streamvault.data.local.entity.PlaybackHistoryLiteEntity
import com.streamvault.data.local.entity.ProviderEntity
import com.streamvault.data.local.entity.XtreamIndexJobEntity
import com.streamvault.data.mapper.toEntity
+import com.streamvault.data.mapper.toDomain
import com.streamvault.data.provider.ProviderCapabilityResolver
import com.streamvault.data.provider.TypedProviderClientFactory
import com.streamvault.data.provider.toProviderSnapshot
import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.util.movieLogicalGroupId
import com.streamvault.data.remote.stalker.StalkerDeviceProfile
import com.streamvault.data.remote.stalker.StalkerProviderProfile
import com.streamvault.data.remote.stalker.StalkerProvider
@@ -39,6 +41,7 @@ import com.streamvault.data.remote.stalker.StalkerApiService
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
import com.streamvault.data.security.CredentialCrypto
+import com.streamvault.data.security.CredentialDecryptionException
import com.streamvault.data.sync.SyncManager
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.LibraryBrowseQuery
@@ -80,6 +83,8 @@ import org.mockito.kotlin.never
import org.mockito.kotlin.times
import org.mockito.kotlin.verify
import org.mockito.kotlin.whenever
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
class MovieRepositoryImplTest {
@@ -109,6 +114,81 @@ class MovieRepositoryImplTest {
override suspend fun <T> inTransaction(block: suspend () -> T): T = block()
}
+ @Test
+ fun `explicit provider variant preference is reported for its movie group`() = runTest {
+ val movie = movieRecord(
+ id = 10L,
+ name = "Space Run (2024) 4K HEVC",
+ genre = "Action",
+ categoryId = 3L,
+ rating = 8f
+ )
+ whenever(movieDao.getById(movie.id)).thenReturn(movie)
+ val logicalGroupId = movieLogicalGroupId(movie.toDomain())
+ val repository = createRepository(
+ duplicateHandlingMode = VodDuplicateHandlingMode.SMART,
+ preferredVariants = mapOf("${movie.providerId}|$logicalGroupId" to 11L)
+ )
+
+ assertThat(repository.hasExplicitMovieVariantSelection(movie.id)).isTrue()
+ }
+
+ @Test
+ fun `missing provider variant preference is not treated as a manual choice`() = runTest {
+ val movie = movieRecord(
+ id = 10L,
+ name = "Space Run (2024) 4K HEVC",
+ genre = "Action",
+ categoryId = 3L,
+ rating = 8f
+ )
+ whenever(movieDao.getById(movie.id)).thenReturn(movie)
+ val repository = createRepository(duplicateHandlingMode = VodDuplicateHandlingMode.SMART)
+
+ assertThat(repository.hasExplicitMovieVariantSelection(movie.id)).isFalse()
+ }
+
+ @Test
+ fun `movie preview contains background credential decryption failure`() = runTest {
+ val uncaughtExceptionLatch = CountDownLatch(1)
+ var uncaughtException: Throwable? = null
+ val previousUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
+ Thread.setDefaultUncaughtExceptionHandler { _, error ->
+ uncaughtException = error
+ uncaughtExceptionLatch.countDown()
+ }
+
+ try {
+ whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(categoryDao.getByProviderAndType(7L, ContentType.MOVIE.name)).thenReturn(
+ flowOf(listOf(CategoryEntity(providerId = 7L, categoryId = 42L, name = "Action", type = ContentType.MOVIE)))
+ )
+ whenever(movieDao.getByCategoryPreview(7L, 42L, 18)).thenReturn(flowOf(emptyList()))
+
+ val provider = Provider(
+ id = 7L,
+ name = "Xtream",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass",
+ status = ProviderStatus.ACTIVE
+ )
+ whenever(providerCapabilityResolver.snapshot(7L))
+ .thenReturn(provider.toProviderSnapshot())
+ .thenThrow(CredentialDecryptionException())
+
+ val result = createRepository().getCategoryPreviewRows(7L, listOf(42L), 18).first()
+
+ assertThat(result).containsKey(42L)
+ verify(providerCapabilityResolver, timeout(1_000).times(2)).snapshot(7L)
+ assertThat(uncaughtExceptionLatch.await(300, TimeUnit.MILLISECONDS)).isFalse()
+ assertThat(uncaughtException).isNull()
+ } finally {
+ Thread.setDefaultUncaughtExceptionHandler(previousUncaughtExceptionHandler)
+ }
+ }
+
@Test
fun `getRecommendations prioritizes movies similar to recent history`() = runTest {
val watchedMovie = movieEntity(
diff --git a/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
index 2381abc8..458a2365 100644
--- a/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
@@ -2,6 +2,7 @@ package com.streamvault.data.repository
import android.content.Context
import com.google.gson.Gson
+import com.google.gson.JsonParser
import com.google.common.truth.Truth.assertThat
import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.dao.CategoryDao
@@ -65,9 +66,11 @@ import com.streamvault.domain.model.StalkerTransportMode
import com.streamvault.domain.model.StalkerTransportOrigin
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.GuideSourcePolicy
+import com.streamvault.domain.model.LiveStreamFormatMode
import com.streamvault.domain.model.XtreamConfig
import com.streamvault.domain.model.SyncMetadata
import com.streamvault.domain.repository.SyncMetadataRepository
+import com.streamvault.domain.repository.ProviderSetupRequest
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
@@ -824,6 +827,54 @@ class ProviderRepositoryImplTest {
verify(syncManager, never()).scheduleProviderSyncResume(9L)
}
+ @Test
+ fun `setupProvider persists playlist live format preference after Xtream authentication`() = runTest {
+ whenever(credentialCrypto.encryptIfNeeded("pass")).thenReturn("pass")
+ whenever(providerDao.insert(any())).thenReturn(9L)
+ whenever(syncManager.sync(eq(9L), eq(false), anyOrNull(), anyOrNull(), anyOrNull(), eq(true), eq(true)))
+ .thenReturn(Result.success(Unit))
+ whenever(syncManager.currentSyncState(9L)).thenReturn(SyncState.Success(123L))
+ whenever(channelDao.getCount(9L)).thenReturn(flowOf(0))
+ whenever(syncMetadataRepository.getMetadata(9L)).thenReturn(SyncMetadata(providerId = 9L, movieCount = 3))
+ whenever(xtreamApiService.authenticate(any(), any())).thenReturn(
+ XtreamAuthResponse(
+ userInfo = XtreamUserInfo(
+ username = "user",
+ password = "pass",
+ auth = 1,
+ status = "Active"
+ ),
+ serverInfo = XtreamServerInfo(
+ url = "example.com",
+ port = "80",
+ serverProtocol = "http"
+ )
+ )
+ )
+
+ val result = repository.setupProvider(
+ ProviderSetupRequest.Configured(
+ name = "Xtream",
+ configuration = XtreamConfig(
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass",
+ fastSyncEnabled = false,
+ preferredLiveStreamFormat = LiveStreamFormatMode.MPEG_TS
+ )
+ )
+ )
+
+ assertThat(result.isSuccess).isTrue()
+ val committed = argumentCaptor<ProviderConfigEntity>()
+ verify(providerSnapshotDao).commitConfiguration(committed.capture())
+ val storedFormat = JsonParser.parseString(committed.firstValue.encryptedConfigJson)
+ .asJsonObject
+ .get("preferredLiveStreamFormat")
+ ?.asString
+ assertThat(storedFormat).isEqualTo(LiveStreamFormatMode.MPEG_TS.name)
+ }
+
@Test
fun `loginXtream does not fail onboarding when provider has no live but committed vod categories`() = runTest {
whenever(credentialCrypto.encryptIfNeeded("pass")).thenReturn("pass")
diff --git a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
index 1c2e088c..c50f1eff 100644
--- a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
@@ -1258,6 +1258,54 @@ class SeriesRepositoryImplTest {
assertThat(result.single().variants.map { it.rawSeriesId }).containsExactly(18L, 17L).inOrder()
}
+ private suspend fun stubFallbackSeries() {
+ val source = SeriesEntity(id = 17L, seriesId = 1700L, name = "Drama 1080p", providerId = 7L, tmdbId = 5000L)
+ val candidate = source.copy(id = 18L, seriesId = 1800L, name = "Drama 720p")
+ whenever(seriesDao.getById(17L)).thenReturn(source)
+ whenever(seriesDao.getById(18L)).thenReturn(candidate)
+ whenever(seriesDao.getByProviderAndTmdbIdSync(7L, 5000L)).thenReturn(listOf(source, candidate))
+ }
+
+ @Test
+ fun currentAndStaleSavedChoiceBlockFallback() = runTest {
+ stubFallbackSeries()
+ for (selections in listOf(mapOf("7|series:7:tmdb:5000" to 999L), mapOf("7|series:7:drama:2024" to 18L))) {
+ assertThat(createRepository(VodDuplicateHandlingMode.SMART, preferredVariants = selections)
+ .hasExplicitSeriesVariantSelection(17L)).isTrue()
+ }
+ verifyNoInteractions(seriesCatalogSource, xtreamApiService)
+ }
+
+ @Test
+ fun otherProviderChoiceDoesNotBlock() = runTest {
+ stubFallbackSeries()
+ val repository = createRepository(VodDuplicateHandlingMode.SMART,
+ preferredVariants = mapOf("8|series:8:tmdb:5000" to 18L, "7|unrelated" to 99L))
+ assertThat(repository.hasExplicitSeriesVariantSelection(17L)).isFalse()
+ }
+
+ @Test
+ fun autoPresentedSelectedIdIsNotManual() = runTest {
+ stubFallbackSeries()
+ val repository = createRepository(VodDuplicateHandlingMode.SMART)
+ assertThat(repository.getSeriesVariants(17L).map { it.rawSeriesId }).containsExactly(17L, 18L)
+ assertThat(repository.hasExplicitSeriesVariantSelection(17L)).isFalse()
+ verifyNoInteractions(seriesCatalogSource, xtreamApiService)
+ }
+
+ @Test
+ fun showAllDoesNotInventVariants() = runTest {
+ stubFallbackSeries()
+ assertThat(createRepository().getSeriesVariants(17L)).isEmpty()
+ verifyNoInteractions(seriesCatalogSource, xtreamApiService)
+ }
+
+ @Test
+ fun missingSeriesBlocksFallback() = runTest {
+ assertThat(createRepository().hasExplicitSeriesVariantSelection(999L)).isTrue()
+ assertThat(createRepository().getSeriesVariants(999L)).isEmpty()
+ }
+
private fun createRepository(
duplicateHandlingMode: VodDuplicateHandlingMode = VodDuplicateHandlingMode.SHOW_ALL,
variantPreferenceMode: VodVariantPreferenceMode = VodVariantPreferenceMode.BALANCED,
diff --git a/data/src/test/java/com/streamvault/data/util/VodMovieDeduplicationTest.kt b/data/src/test/java/com/streamvault/data/util/VodMovieDeduplicationTest.kt
index dda8c991..de53e9bf 100644
--- a/data/src/test/java/com/streamvault/data/util/VodMovieDeduplicationTest.kt
+++ b/data/src/test/java/com/streamvault/data/util/VodMovieDeduplicationTest.kt
@@ -9,6 +9,21 @@ import org.junit.Test
class VodMovieDeduplicationTest {
+ @Test
+ fun `codec labelled counterparts group without merging unrelated titles or years`() {
+ for ((hevc, avc) in listOf("HEVC" to "AVC", "H.265" to "H.264", "x265" to "x264", "hvc1" to "avc")) {
+ val source = movie(1L, "Resilience Fixture 1080p $hevc", "2026")
+ val counterpart = movie(2L, "Resilience Fixture 720p $avc", "2026")
+ val unrelated = movie(3L, "Unrelated Fixture 720p $avc", "2026")
+ val remake = movie(4L, "Resilience Fixture 720p $avc", "2025")
+ val settings = MoviePresentationSettings(VodDuplicateHandlingMode.SMART, VodVariantPreferenceMode.BEST_QUALITY)
+ val grouped = buildPresentedMovies(listOf(source, counterpart, unrelated, remake), settings)
+ assertThat(grouped).hasSize(3)
+ assertThat(grouped.single { it.id == 1L }.variants.map { it.rawMovieId }).containsExactly(1L, 2L)
+ assertThat(buildPresentedMovies(listOf(source, counterpart), settings.copy(duplicateHandlingMode = VodDuplicateHandlingMode.SHOW_ALL))).hasSize(2)
+ }
+ }
+
@Test
fun `force latest prefers newest version over older higher quality`() {
val older4k = movie(
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index bcccbafd..6f5177b7 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -2,6 +2,37 @@
All notable product changes are recorded in this document.
+## [1.2.0]
+
+### Added
+
+- Added temporary automatic quality reduction for supported adaptive streams when decoding struggles, with gradual restoration and respect for manual quality choices.
+- Added AVC/H.264 fallback for eligible HEVC episodes, preserving playback position, audio, subtitles, and episode history.
+
+### Fixed
+
+- Fixed repeated stream restarts during network outages and unnecessary recovery from nonfatal audio errors.
+- Fixed stalled live playback recovery to refresh the live window without interrupting active network retries.
+- Fixed adaptive playback failing to try another available rendition after eligible server or missing-segment errors.
+- Fixed expiring stream links renewing only once or unnecessarily restarting unchanged playback.
+- Fixed manual video-quality selections resetting during stream renewal.
+- Fixed automatic movie and episode fallback overriding saved variants or manual video-quality choices.
+- Fixed movie fallback losing playback position or track preferences, and accepting incompatible sources or conflicting codec labels.
+- Fixed Xtream catch-up links opening live content instead of the selected archived program.
+- Fixed Xtream playlist setup ignoring the requested HLS or MPEG-TS format when playback format is set to Auto.
+- Fixed matching AVC/H.264 and HEVC/H.265 movie versions failing to group together.
+- Fixed newly imported movie summaries skipping detail loading.
+- Fixed background movie refresh crashes when saved provider credentials cannot be decrypted.
+- Fixed cropped video during adaptive resolution changes on affected Android TV emulators.
+
+### Changed
+
+- Improved playback buffer memory limits based on stream bitrate, device memory, and multiview usage.
+- Prioritized active playback over adjacent-item preloading and removed startup thumbnail warmup.
+- Improved seek previews with request-header support and cancellation when seeking or leaving the player.
+- Reduced audio output buffering for more responsive playback.
+- Restored automatic live playback speed adjustments to stay near the live edge.
+
## [1.0.19]
### Added
diff --git a/domain/src/main/java/com/streamvault/domain/model/Provider.kt b/domain/src/main/java/com/streamvault/domain/model/Provider.kt
index 8aff4dce..fd04cfef 100644
--- a/domain/src/main/java/com/streamvault/domain/model/Provider.kt
+++ b/domain/src/main/java/com/streamvault/domain/model/Provider.kt
@@ -66,6 +66,7 @@ data class LegacyProvider(
val channelLogoSourcePolicy: ChannelLogoSourcePolicy = ChannelLogoSourcePolicy.SUPPLIER_PREFERRED,
val xtreamFastSyncEnabled: Boolean = true,
val xtreamLiveSyncMode: ProviderXtreamLiveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
+ val preferredLiveStreamFormat: LiveStreamFormatMode? = null,
val m3uVodClassificationEnabled: Boolean = false,
val catalogLayout: CatalogLayout = CatalogLayout.SPLIT,
val catalogLayoutDetectionVersion: Int = 0,
diff --git a/domain/src/main/java/com/streamvault/domain/model/ProviderConfiguration.kt b/domain/src/main/java/com/streamvault/domain/model/ProviderConfiguration.kt
index 1ffd2ffe..7fa2471c 100644
--- a/domain/src/main/java/com/streamvault/domain/model/ProviderConfiguration.kt
+++ b/domain/src/main/java/com/streamvault/domain/model/ProviderConfiguration.kt
@@ -20,7 +20,8 @@ data class XtreamConfig(
val channelLogoSourcePolicy: ChannelLogoSourcePolicy = ChannelLogoSourcePolicy.SUPPLIER_PREFERRED,
val fastSyncEnabled: Boolean = true,
val liveSyncMode: ProviderXtreamLiveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
- override val schemaVersion: Int = CURRENT_SCHEMA_VERSION
+ override val schemaVersion: Int = CURRENT_SCHEMA_VERSION,
+ val preferredLiveStreamFormat: LiveStreamFormatMode? = null
) : ProviderConfiguration {
override val type: ProviderType = ProviderType.XTREAM_CODES
diff --git a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
index 1a01ba33..b24830f5 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt
@@ -37,6 +37,8 @@ interface MovieRepository {
fun searchMovies(providerId: Long, query: String): Flow<List<Movie>>
suspend fun getMovie(movieId: Long): Movie?
suspend fun getMovieVariants(movieId: Long): List<VodMovieVariant> = emptyList()
+ /** True when the viewer explicitly pinned a provider variant for this movie group. */
+ suspend fun hasExplicitMovieVariantSelection(movieId: Long): Boolean = false
suspend fun getMovieDetails(
providerId: Long,
movieId: Long,
diff --git a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
index e1a8d2ef..85c424ba 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/SeriesRepository.kt
@@ -8,6 +8,7 @@ import com.streamvault.domain.model.Result
import com.streamvault.domain.model.Series
import com.streamvault.domain.model.SeriesDetailPresentationHint
import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.VodSeriesVariant
import com.streamvault.domain.model.VodCategoryHydration
import com.streamvault.domain.model.VodCategoryHydrationRequest
import kotlinx.coroutines.flow.Flow
@@ -34,6 +35,8 @@ interface SeriesRepository {
): Result<Unit> = Result.success(Unit)
fun searchSeries(providerId: Long, query: String): Flow<List<Series>>
suspend fun getSeriesById(seriesId: Long): Series?
+ suspend fun getSeriesVariants(seriesId: Long): List<VodSeriesVariant> = emptyList()
+ suspend fun hasExplicitSeriesVariantSelection(seriesId: Long): Boolean = true
suspend fun getEpisodeById(episodeId: Long): Episode?
suspend fun getSeriesDetails(
providerId: Long,
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt b/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
index 93ca0f60..b3d84ae1 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
@@ -3,6 +3,7 @@ package com.streamvault.domain.usecase
import com.streamvault.domain.manager.ProviderSetupInputValidator
import com.streamvault.domain.model.ChannelLogoSourcePolicy
import com.streamvault.domain.model.GuideSourcePolicy
+import com.streamvault.domain.model.LiveStreamFormatMode
import com.streamvault.domain.model.LegacyProvider as Provider
import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
@@ -265,7 +266,8 @@ class ValidateAndAddProvider @Inject constructor(
epgSyncMode = command.epgSyncMode,
liveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
guideSourcePolicy = command.guideSourcePolicy,
- channelLogoSourcePolicy = command.channelLogoSourcePolicy
+ channelLogoSourcePolicy = command.channelLogoSourcePolicy,
+ preferredLiveStreamFormat = parsedXtream.preferredLiveStreamFormat
),
existingProviderId = command.existingProviderId
),
@@ -463,7 +465,8 @@ class ValidateAndAddProvider @Inject constructor(
data class Success(
val serverUrl: String,
val username: String,
- val password: String
+ val password: String,
+ val preferredLiveStreamFormat: LiveStreamFormatMode?
) : ParsedXtreamPlaylistUrlResult
}
@@ -509,7 +512,12 @@ class ValidateAndAddProvider @Inject constructor(
return ParsedXtreamPlaylistUrlResult.Success(
serverUrl = "$scheme://$authority",
username = username,
- password = password
+ password = password,
+ preferredLiveStreamFormat = when (query["output"]?.lowercase()) {
+ "ts" -> LiveStreamFormatMode.MPEG_TS
+ "m3u8" -> LiveStreamFormatMode.HLS
+ else -> null
+ }
)
}
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
index 56d190da..5c36ec70 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
@@ -12,6 +12,7 @@ import com.streamvault.domain.manager.ValidatedXtreamProviderInput
import com.streamvault.domain.model.ChannelLogoSourcePolicy
import com.streamvault.domain.model.GuideSourcePolicy
import com.streamvault.domain.model.JellyfinConfig
+import com.streamvault.domain.model.LiveStreamFormatMode
import com.streamvault.domain.model.M3uConfig
import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.LegacyProvider as Provider
@@ -338,7 +339,7 @@ class ValidateAndAddProviderTest {
providerSetupInputValidator = FakeProviderSetupInputValidator(
m3uResult = Result.success(
ValidatedM3uProviderInput(
- url = "http://extapk2302.shop:8080/get.php?username=Hakan1605&password=wg9daUwzfV&type=m3u_plus",
+ url = "http://extapk2302.shop:8080/get.php?username=Hakan1605&password=wg9daUwzfV&type=m3u_plus&output=ts",
name = "Imported Playlist",
httpUserAgent = "PlaylistAgent/2.0",
httpHeaders = "Referer: https://example.com"
@@ -350,7 +351,7 @@ class ValidateAndAddProviderTest {
val result = useCase.addM3u(
M3uProviderSetupCommand(
- url = "http://extapk2302.shop:8080/get.php?username=Hakan1605&password=wg9daUwzfV&type=m3u_plus",
+ url = "http://extapk2302.shop:8080/get.php?username=Hakan1605&password=wg9daUwzfV&type=m3u_plus&output=ts",
name = "Imported Playlist",
epgSyncMode = ProviderEpgSyncMode.BACKGROUND,
existingProviderId = 19L
@@ -373,6 +374,8 @@ class ValidateAndAddProviderTest {
id = 19L
)
)
+ assertThat(repository.lastXtreamConfig?.preferredLiveStreamFormat)
+ .isEqualTo(LiveStreamFormatMode.MPEG_TS)
}
@Test
@@ -741,6 +744,7 @@ private data class StalkerCall(
private class FakeProviderRepository : ProviderRepository {
var lastXtreamCall: XtreamCall? = null
+ var lastXtreamConfig: XtreamConfig? = null
var lastM3uCall: M3uCall? = null
var lastStalkerCall: StalkerCall? = null
var xtreamResult: Result<Provider>? = null
@@ -778,12 +782,15 @@ private class FakeProviderRepository : ProviderRepository {
onCode: ((String) -> Unit)?
): Result<Provider> = when (request) {
is ProviderSetupRequest.Configured -> when (val config = request.configuration) {
- is XtreamConfig -> loginXtream(
- config.serverUrl, config.username, config.password, request.name,
- config.httpUserAgent, config.httpHeaders, config.fastSyncEnabled,
- config.epgSyncMode, config.liveSyncMode, config.guideSourcePolicy,
- config.channelLogoSourcePolicy, onProgress, request.existingProviderId
- )
+ is XtreamConfig -> {
+ lastXtreamConfig = config
+ loginXtream(
+ config.serverUrl, config.username, config.password, request.name,
+ config.httpUserAgent, config.httpHeaders, config.fastSyncEnabled,
+ config.epgSyncMode, config.liveSyncMode, config.guideSourcePolicy,
+ config.channelLogoSourcePolicy, onProgress, request.existingProviderId
+ )
+ }
is M3uConfig -> validateM3u(
config.playlistUrl, request.name, config.httpUserAgent, config.httpHeaders,
config.epgSyncMode, config.vodClassificationEnabled, config.guideSourcePolicy,
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/CancellableHttpMediaDataSource.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/CancellableHttpMediaDataSource.kt
new file mode 100644
index 00000000..2155d044
--- /dev/null
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/CancellableHttpMediaDataSource.kt
@@ -0,0 +1,121 @@
+package com.streamvault.feature.playback.player
+
+import android.media.MediaDataSource
+import android.os.Build
+import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import okhttp3.Call
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+/** Random-access HTTP input whose active reads can be interrupted when thumbnail work is cancelled. */
+internal class CancellableHttpMediaDataSource(
+ private val url: String,
+ baseClient: OkHttpClient,
+ headers: Map<String, String>,
+ callTimeoutMs: Long
+) : MediaDataSource() {
+ private val client = baseClient.newBuilder()
+ .callTimeout(callTimeoutMs, TimeUnit.MILLISECONDS)
+ .build()
+ private val requestHeaders = buildMap {
+ headers.forEach { (name, value) ->
+ if (!name.equals("Range", ignoreCase = true)) put(name, value)
+ }
+ if (keys.none { it.equals("User-Agent", ignoreCase = true) }) {
+ put("User-Agent", "Stagefright/1.2 (Linux;Android ${Build.VERSION.RELEASE})")
+ }
+ }
+ private val activeCalls = ConcurrentHashMap.newKeySet<Call>()
+ private val closed = AtomicBoolean(false)
+ private val contentLength = AtomicLong(-1L)
+
+ override fun getSize(): Long = contentLength.get()
+
+ override fun readAt(position: Long, buffer: ByteArray, offset: Int, size: Int): Int {
+ if (closed.get()) return -1
+ if (position < 0L || offset < 0 || size < 0 || offset + size > buffer.size) {
+ throw IllegalArgumentException("Invalid byte range")
+ }
+ if (size == 0) return 0
+ val knownLength = contentLength.get()
+ if (knownLength >= 0L && position >= knownLength) return -1
+
+ val lastByte = if (Long.MAX_VALUE - position < size - 1L) {
+ Long.MAX_VALUE
+ } else {
+ position + size - 1L
+ }
+ val request = Request.Builder()
+ .url(url)
+ .header("Range", "bytes=$position-$lastByte")
+ .apply { requestHeaders.forEach { (name, value) -> header(name, value) } }
+ .get()
+ .build()
+ val call = client.newCall(request)
+ activeCalls.add(call)
+ if (closed.get()) call.cancel()
+
+ try {
+ call.execute().use { response ->
+ updateContentLength(
+ response.header("Content-Range"),
+ response.body?.contentLength(),
+ response.code
+ )
+ if (response.code == 416 && position >= contentLength.get()) return -1
+ if (!response.isSuccessful) throw IOException("Thumbnail byte read failed: HTTP ${response.code}")
+
+ val body = response.body ?: return -1
+ val rangeStart = response.header("Content-Range")
+ ?.let(CONTENT_RANGE_START::matchEntire)
+ ?.groupValues
+ ?.getOrNull(1)
+ ?.toLongOrNull()
+ if (response.code == 206 && rangeStart != position) {
+ throw IOException("Thumbnail range response started at $rangeStart, requested $position")
+ }
+
+ val source = body.source()
+ if (response.code != 206 && position > 0L) source.skip(position)
+ return source.read(buffer, offset, size)
+ }
+ } finally {
+ activeCalls.remove(call)
+ }
+ }
+
+ override fun close() {
+ if (!closed.compareAndSet(false, true)) return
+ activeCalls.forEach(Call::cancel)
+ activeCalls.clear()
+ }
+
+ private fun updateContentLength(contentRange: String?, bodyLength: Long?, statusCode: Int) {
+ val rangeLength = contentRange
+ ?.let(CONTENT_RANGE_LENGTH::matchEntire)
+ ?.groupValues
+ ?.getOrNull(1)
+ ?.toLongOrNull()
+ val unsatisfiedRangeLength = contentRange
+ ?.let(UNSATISFIED_RANGE_LENGTH::matchEntire)
+ ?.groupValues
+ ?.getOrNull(1)
+ ?.toLongOrNull()
+ val length = rangeLength ?: unsatisfiedRangeLength ?: if (statusCode == 200) {
+ bodyLength?.takeIf { it >= 0L }
+ } else {
+ null
+ }
+ if (length != null) contentLength.compareAndSet(-1L, length)
+ }
+
+ private companion object {
+ val CONTENT_RANGE_START = Regex("bytes (\\d+)-\\d+/(?:\\d+|\\*)", RegexOption.IGNORE_CASE)
+ val CONTENT_RANGE_LENGTH = Regex("bytes \\d+-\\d+/(\\d+)", RegexOption.IGNORE_CASE)
+ val UNSATISFIED_RANGE_LENGTH = Regex("bytes \\*/(\\d+)", RegexOption.IGNORE_CASE)
+ }
+}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerContentResolver.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerContentResolver.kt
index 50ef0feb..b821d488 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerContentResolver.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerContentResolver.kt
@@ -9,6 +9,7 @@ import com.streamvault.domain.model.Series
import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.model.StreamType
import com.streamvault.domain.model.VodMovieVariant
+import com.streamvault.domain.model.VodSeriesVariant
import com.streamvault.domain.provider.PlayerCredentialFailure
import com.streamvault.domain.provider.PlayerPlaybackResolutionFailure
import com.streamvault.domain.provider.PlayerPlaybackResolver
@@ -58,12 +59,39 @@ class PlayerContentResolver @Inject constructor(
internal suspend fun getMovieVariants(movieId: Long): List<VodMovieVariant> =
movieRepository.getMovieVariants(movieId)
+ internal suspend fun hasExplicitMovieVariantSelection(movieId: Long): Boolean =
+ movieRepository.hasExplicitMovieVariantSelection(movieId)
+
internal suspend fun getMovieStreamInfo(movie: Movie): Result<StreamInfo> =
movieRepository.getStreamInfo(movie)
internal suspend fun getSeriesDetails(providerId: Long, seriesId: Long): Result<Series> =
seriesRepository.getSeriesDetails(providerId, seriesId)
+ internal suspend fun getRawSeries(seriesId: Long): Series? = seriesRepository.getSeriesById(seriesId)
+
+ internal suspend fun getSeriesVariants(seriesId: Long): List<VodSeriesVariant> =
+ seriesRepository.getSeriesVariants(seriesId)
+
+ internal suspend fun hasExplicitSeriesVariantSelection(seriesId: Long): Boolean =
+ seriesRepository.hasExplicitSeriesVariantSelection(seriesId)
+
+ internal suspend fun getEpisodeStreamInfo(episode: Episode): Result<StreamInfo> =
+ seriesRepository.getEpisodeStreamInfo(episode)
+
+ internal suspend fun resolvePhysicalEpisodeStream(
+ source: PhysicalEpisodeSource,
+ logicalTitle: String
+ ): PlayerPlaybackStreamResolution = resolvePlaybackStream(
+ logicalUrl = source.episode.streamUrl,
+ internalContentId = source.episode.id,
+ providerId = source.episode.providerId,
+ contentType = ContentType.SERIES_EPISODE,
+ currentTitle = logicalTitle,
+ currentSeries = source.series,
+ currentEpisode = source.episode
+ ).let { resolution -> resolution.copy(streamInfo = resolution.streamInfo?.copy(title = logicalTitle)) }
+
internal suspend fun getEpisodeById(episodeId: Long): Episode? =
seriesRepository.getEpisodeById(episodeId)
}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicy.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicy.kt
new file mode 100644
index 00000000..6fee61fd
--- /dev/null
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicy.kt
@@ -0,0 +1,122 @@
+package com.streamvault.feature.playback.player
+
+import com.streamvault.domain.model.Episode
+import com.streamvault.domain.model.Series
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.StreamTypeResolver
+import java.util.Locale
+import kotlin.math.abs
+
+internal data class EpisodeFallbackSource(
+ val series: Series,
+ val episode: Episode,
+ val streamInfo: StreamInfo,
+ val codecHint: String?,
+ val heightHint: Int?,
+ val positionMs: Long,
+ val durationMs: Long
+)
+
+internal fun selectEpisodeFallbackSeries(source: EpisodeFallbackSource, rawVariants: List<Series>): Series? {
+ val height = sourceHeight(source) ?: return null
+ if (!eligibleSource(source)) return null
+ if (rawVariants.none { it.id == source.series.id && sameSeries(source.series, it) }) return null
+ return rawVariants.filter { candidate ->
+ candidate.id != source.series.id && sameSeries(source.series, candidate) &&
+ qualityHeight(candidate.name)?.let { it <= height } == true &&
+ codec(candidate.name) in setOf(null, "avc") && !ambiguousCodec(candidate.name)
+ }.sortedWith(compareByDescending<Series> { qualityHeight(it.name) }.thenBy { it.id }).firstOrNull()
+}
+
+internal fun verifyEpisodeFallback(source: EpisodeFallbackSource, candidateDetails: Series): Episode? {
+ if (!eligibleSource(source) || candidateDetails.id == source.series.id || !sameSeries(source.series, candidateDetails)) return null
+ val identity = explicitIdentity(source.episode) ?: return null
+ if (!belongs(source.episode, source.series)) return null
+ val originals = source.series.seasons.flatMap { it.episodes }.filter {
+ it.seasonNumber == identity.first && it.episodeNumber == identity.second
+ }
+ if (originals.size != 1 || originals.single().id != source.episode.id ||
+ explicitIdentity(originals.single()) != identity) return null
+ val matches = candidateDetails.seasons.flatMap { it.episodes }.filter {
+ it.seasonNumber == identity.first && it.episodeNumber == identity.second
+ }
+ val episode = matches.singleOrNull() ?: return null
+ if (!belongs(episode, candidateDetails) || explicitIdentity(episode) != identity ||
+ titleKey(episode.title) != titleKey(source.episode.title)) return null
+ if (codec(episode.title) != "avc" || ambiguousCodec(episode.title) ||
+ ambiguousCodec(candidateDetails.name) || codec(candidateDetails.name) == "hevc") return null
+ val episodeHeight = qualityHeight(episode.title)
+ val seriesHeight = qualityHeight(candidateDetails.name)
+ if (ambiguousQuality(episode.title) || ambiguousQuality(candidateDetails.name)) return null
+ if (episodeHeight != null && seriesHeight != null && episodeHeight != seriesHeight) return null
+ val height = episodeHeight ?: seriesHeight ?: return null
+ if (height > (sourceHeight(source) ?: return null)) return null
+ val candidateDuration = episode.durationSeconds.toLong() * 1000L
+ if (candidateDuration <= 0 || source.durationMs <= 0 || source.episode.durationSeconds <= 0 ||
+ abs(source.durationMs - candidateDuration) > 2000L ||
+ abs(source.episode.durationSeconds.toLong() * 1000L - candidateDuration) > 2000L ||
+ source.positionMs < 0 || source.positionMs > candidateDuration - 15000L) return null
+ return episode
+}
+
+private fun eligibleSource(source: EpisodeFallbackSource): Boolean =
+ source.streamInfo.playbackContentKind == PlaybackContentKind.ON_DEMAND &&
+ StreamTypeResolver.resolve(source.streamInfo) == ResolvedStreamType.PROGRESSIVE &&
+ source.series.id > 0 && source.series.providerId > 0 && source.series.tmdbId?.let { it > 0 } == true &&
+ sourceHeight(source) != null &&
+ (if (!source.codecHint.isNullOrBlank()) codec(source.codecHint) else codec(source.episode.title)) == "hevc" &&
+ verifiedSourceEpisode(source)
+
+private fun verifiedSourceEpisode(source: EpisodeFallbackSource): Boolean {
+ val identity = explicitIdentity(source.episode) ?: return false
+ if (!belongs(source.episode, source.series)) return false
+ val matches = source.series.seasons.flatMap { it.episodes }.filter {
+ it.seasonNumber == identity.first && it.episodeNumber == identity.second
+ }
+ return matches.size == 1 && matches.single().id == source.episode.id && explicitIdentity(matches.single()) == identity
+}
+
+private fun sourceHeight(source: EpisodeFallbackSource): Int? =
+ source.heightHint?.takeIf { it > 0 } ?: qualityHeight(source.episode.title) ?: qualityHeight(source.series.name)
+
+private fun belongs(episode: Episode, series: Series) =
+ episode.id > 0 && episode.seriesId == series.id && episode.providerId == series.providerId
+
+private fun sameSeries(source: Series, candidate: Series) =
+ source.providerId > 0 && candidate.providerId == source.providerId && source.tmdbId?.let { it > 0 } == true &&
+ candidate.tmdbId == source.tmdbId && titleKey(candidate.name) == titleKey(source.name)
+
+private val identityPattern = Regex("(?i)(?<![a-z0-9])s(\\d{1,3})e(\\d{1,3})(?!\\d)")
+private val extraIdentityPattern = Regex("(?i)(?:s\\d+|e\\d+|[-–/&,;+]\\s*\\d+|\\band\\s+\\d+)")
+private fun explicitIdentity(episode: Episode): Pair<Int, Int>? {
+ val match = identityPattern.findAll(episode.title).toList().singleOrNull() ?: return null
+ if (extraIdentityPattern.containsMatchIn(episode.title.removeRange(match.range))) return null
+ val season = match.groupValues[1].toIntOrNull() ?: return null
+ val number = match.groupValues[2].toIntOrNull() ?: return null
+ return (season to number).takeIf { season > 0 && number > 0 && season == episode.seasonNumber && number == episode.episodeNumber }
+}
+
+private val codecAvc = Regex("(?i)(?<![a-z0-9])(?:avc|h[ ._-]*264|x264|avc1)(?![a-z0-9])")
+private val codecHevc = Regex("(?i)(?<![a-z0-9])(?:hevc|h[ ._-]*265|x265|hev1|hvc1)(?![a-z0-9])")
+private fun ambiguousCodec(text: String) = codecAvc.containsMatchIn(text) && codecHevc.containsMatchIn(text)
+private fun codec(text: String): String? = when {
+ ambiguousCodec(text) -> "ambiguous"
+ codecHevc.containsMatchIn(text) -> "hevc"
+ codecAvc.containsMatchIn(text) -> "avc"
+ else -> null
+}
+private val qualityPatterns = listOf(
+ "(?:8k|4320p)" to 4320, "(?:4k|uhd|2160[pi]?)" to 2160,
+ "(?:2k|qhd|1440p)" to 1440, "(?:fhd|full\\s*hd|1080[pi]?)" to 1080,
+ "720p" to 720, "576p" to 576, "540p" to 540, "480p" to 480, "360p" to 360, "240p" to 240
+).map { (pattern, height) -> Regex("(?i)(?<![a-z0-9])$pattern(?![a-z0-9])") to height }
+private fun qualityHeights(text: String) = qualityPatterns.filter { it.first.containsMatchIn(text) }.map { it.second }.distinct()
+private fun qualityHeight(text: String) = qualityHeights(text).singleOrNull()
+private fun ambiguousQuality(text: String) = qualityHeights(text).size > 1
+private fun titleKey(text: String): String {
+ var stripped = codecAvc.replace(codecHevc.replace(text, " "), " ")
+ qualityPatterns.forEach { stripped = it.first.replace(stripped, " ") }
+ return stripped.lowercase(Locale.ROOT).replace(Regex("[^\\p{L}\\p{N}]+"), " ").trim()
+}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupport.kt
new file mode 100644
index 00000000..1937a980
--- /dev/null
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupport.kt
@@ -0,0 +1,164 @@
+package com.streamvault.feature.playback.player
+
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.Result
+import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.StreamTypeResolver
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.launch
+
+internal enum class EpisodeFallbackResult { NotEligible, Recovered, HandledFailure }
+
+internal fun PlayerViewModel.retryPhysicalEpisode() {
+ val token = episodeSourceState.retryPhysical(playerEngine.currentPosition.value, playerEngine.duration.value) ?: return
+ val physical = episodeSourceState.source(token) ?: return
+ val identity = currentStreamUrl
+ val position = episodeSourceState.progressSnapshot(token, 0, 0)?.first ?: return
+ fun current() = episodeSourceState.isCurrent(token) && !episodeSourceState.failed &&
+ isActivePlaybackSession(token.requestVersion, identity)
+ clearPreloadWindow()
+ playerEngine.stop()
+ playbackSessionScope(token.requestVersion)?.launch {
+ try {
+ val resolved = playerContentResolver.resolvePhysicalEpisodeStream(physical, currentTitle)
+ if (!current()) return@launch
+ val info = resolved.streamInfo
+ if (info == null) {
+ episodeSourceState.markFailed(token)
+ val message = resolved.failureMessage ?: "Could not resolve the compatible episode."
+ setLastFailureReason(message)
+ showPlayerNotice(message, PlayerRecoveryType.SOURCE, buildRecoveryActions(PlayerRecoveryType.SOURCE))
+ return@launch
+ }
+ if (!preparePlayer(info, token.requestVersion, preserveVodTrackPreferences = true,
+ episodeToken = token, requiredSourceType = ResolvedStreamType.PROGRESSIVE)) {
+ if (current()) episodeSourceState.markFailed(token)
+ return@launch
+ }
+ if (!current()) return@launch
+ playerEngine.seekTo(position)
+ playerEngine.play()
+ } catch (error: CancellationException) {
+ throw error
+ } catch (_: Exception) {
+ if (current()) {
+ episodeSourceState.markFailed(token)
+ val message = "Could not prepare the compatible episode."
+ setLastFailureReason(message)
+ showPlayerNotice(message, PlayerRecoveryType.SOURCE, buildRecoveryActions(PlayerRecoveryType.SOURCE))
+ }
+ }
+ }
+}
+
+internal interface EpisodeFallbackPort {
+ val state: PlayerEpisodeSourceState
+ val source: EpisodeFallbackSource
+ val manualVideo: Boolean
+ fun isCurrent(token: EpisodeSourceToken): Boolean
+ fun stopFailedSource()
+ suspend fun prepare(info: StreamInfo, token: EpisodeSourceToken): Boolean
+ fun seekAndPlay(positionMs: Long)
+ fun failure(message: String)
+ fun recovered()
+}
+
+internal suspend fun runEpisodeFallback(resolver: PlayerContentResolver, port: EpisodeFallbackPort): EpisodeFallbackResult {
+ val initial = port.state.token
+ if (port.state.attempted || port.manualVideo || !port.isCurrent(initial)) return EpisodeFallbackResult.NotEligible
+ var reserved: EpisodeSourceToken? = null
+ fun current(token: EpisodeSourceToken) = port.isCurrent(token) && !port.state.failed && !port.manualVideo
+ fun fail(message: String): EpisodeFallbackResult {
+ reserved?.takeIf(port::isCurrent)?.let { port.state.markFailed(it); port.failure(message) }
+ return EpisodeFallbackResult.HandledFailure
+ }
+ try {
+ val logical = port.source
+ if (logical.streamInfo.playbackContentKind != PlaybackContentKind.ON_DEMAND ||
+ StreamTypeResolver.resolve(logical.streamInfo) != ResolvedStreamType.PROGRESSIVE) return EpisodeFallbackResult.NotEligible
+ if (resolver.hasExplicitSeriesVariantSelection(logical.series.id) || !current(initial)) return EpisodeFallbackResult.NotEligible
+ val rawOriginal = resolver.getRawSeries(logical.series.id) ?: return EpisodeFallbackResult.NotEligible
+ if (!current(initial) || rawOriginal.providerId != logical.series.providerId) return EpisodeFallbackResult.NotEligible
+ val variants = resolver.getSeriesVariants(rawOriginal.id)
+ if (!current(initial) || variants.none { it.rawSeriesId == rawOriginal.id }) return EpisodeFallbackResult.NotEligible
+ val raw = mutableListOf(rawOriginal)
+ for (variant in variants.distinctBy { it.rawSeriesId }) {
+ if (variant.rawSeriesId == rawOriginal.id) continue
+ val member = resolver.getRawSeries(variant.rawSeriesId)
+ if (!current(initial)) return EpisodeFallbackResult.NotEligible
+ if (member?.providerId == rawOriginal.providerId) raw += member
+ }
+ val source = logical.copy(series = rawOriginal.copy(seasons = logical.series.seasons))
+ val selected = selectEpisodeFallbackSeries(source, raw) ?: return EpisodeFallbackResult.NotEligible
+ if (!current(initial)) return EpisodeFallbackResult.NotEligible
+ val token = port.state.reserveFallback(initial, source.positionMs, source.durationMs) ?: return EpisodeFallbackResult.NotEligible
+ reserved = token
+ port.stopFailedSource()
+ if (!current(token)) return fail("Automatic episode recovery was canceled.")
+ val detailsResult = resolver.getSeriesDetails(selected.providerId, selected.id)
+ if (!current(token)) return fail("Automatic episode recovery was canceled.")
+ val details = detailsResult.getOrNull()
+ ?: return fail((detailsResult as? Result.Error)?.message ?: "Could not load the compatible episode.")
+ if (details.id != selected.id || details.providerId != selected.providerId) return fail("Could not verify the compatible episode.")
+ val episode = verifyEpisodeFallback(source, details) ?: return fail("Could not verify the compatible episode.")
+ if (resolver.hasExplicitSeriesVariantSelection(rawOriginal.id) || !current(token)) return fail("Automatic episode recovery was canceled.")
+ val streamResult = resolver.getEpisodeStreamInfo(episode)
+ if (!current(token)) return fail("Automatic episode recovery was canceled.")
+ val stream = streamResult.getOrNull()
+ ?: return fail((streamResult as? Result.Error)?.message ?: "Could not resolve the compatible episode.")
+ val resolved = stream.copy(title = source.streamInfo.title, playbackContentKind = PlaybackContentKind.ON_DEMAND)
+ if (StreamTypeResolver.resolve(resolved) != ResolvedStreamType.PROGRESSIVE) return fail("The compatible episode is not a progressive source.")
+ if (!port.state.stage(token, details, episode)) return EpisodeFallbackResult.HandledFailure
+ if (!port.prepare(resolved, token)) {
+ if (port.isCurrent(token)) port.state.markFailed(token)
+ return EpisodeFallbackResult.HandledFailure // Preparation owns its specific failure notice.
+ }
+ if (!current(token)) return fail("Automatic episode recovery was canceled.")
+ port.seekAndPlay(source.positionMs)
+ port.recovered()
+ return EpisodeFallbackResult.Recovered
+ } catch (error: CancellationException) {
+ throw error
+ } catch (_: Exception) {
+ return if (reserved != null) fail("Could not prepare the compatible episode.") else EpisodeFallbackResult.NotEligible
+ }
+}
+
+internal suspend fun PlayerViewModel.tryFallbackToAvcEpisodeVariant(
+ requestVersion: Long,
+ playbackUrl: String
+): EpisodeFallbackResult {
+ if (currentContentType != ContentType.SERIES_EPISODE || !isActivePlaybackSession(requestVersion, playbackUrl)) return EpisodeFallbackResult.NotEligible
+ val logicalIdentity = episodeRecoveryIdentity(currentStreamUrl, playbackUrl)
+ val series = currentSeries.value ?: return EpisodeFallbackResult.NotEligible
+ val episode = currentEpisode.value ?: return EpisodeFallbackResult.NotEligible
+ if (series.providerId != currentProviderId || episode.providerId != currentProviderId) return EpisodeFallbackResult.NotEligible
+ val stream = currentResolvedStreamInfo ?: return EpisodeFallbackResult.NotEligible
+ val stats = playerEngine.playerStats.value
+ val source = EpisodeFallbackSource(series, episode, stream, stats.videoCodec,
+ playerEngine.videoFormat.value.height.takeIf { it > 0 }, playerEngine.currentPosition.value,
+ playerEngine.duration.value.takeIf { it > 0 } ?: episode.durationSeconds.toLong() * 1000)
+ return runEpisodeFallback(playerContentResolver, object : EpisodeFallbackPort {
+ override val state = episodeSourceState
+ override val source = source
+ override val manualVideo: Boolean get() = hasManualVideoTrackChoice(playerEngine.availableVideoTracks.value)
+ override fun isCurrent(token: EpisodeSourceToken) =
+ state.isCurrent(token) && !state.failed && isActivePlaybackSession(requestVersion, logicalIdentity)
+ override fun stopFailedSource() { clearPreloadWindow(); playerEngine.stop() }
+ override suspend fun prepare(info: StreamInfo, token: EpisodeSourceToken) = preparePlayer(
+ info.copy(title = currentTitle), requestVersion, preserveVodTrackPreferences = true,
+ episodeToken = token, requiredSourceType = ResolvedStreamType.PROGRESSIVE, requireAutoVideoSelection = true)
+ override fun seekAndPlay(positionMs: Long) { playerEngine.seekTo(positionMs); playerEngine.play() }
+ override fun failure(message: String) {
+ setLastFailureReason(message)
+ showPlayerNotice(message, PlayerRecoveryType.SOURCE, buildRecoveryActions(PlayerRecoveryType.SOURCE))
+ }
+ override fun recovered() {
+ appendRecoveryAction("Switched to compatible AVC/H.264 episode variant")
+ showPlayerNotice("Retrying with a compatible AVC/H.264 episode variant.", PlayerRecoveryType.DECODER,
+ buildRecoveryActions(PlayerRecoveryType.DECODER))
+ }
+ })
+}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceState.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceState.kt
new file mode 100644
index 00000000..9cf22ffb
--- /dev/null
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceState.kt
@@ -0,0 +1,77 @@
+package com.streamvault.feature.playback.player
+
+import com.streamvault.domain.model.Episode
+import com.streamvault.domain.model.Series
+
+internal data class EpisodeSourceToken(val requestVersion: Long, val generation: Long)
+internal data class PhysicalEpisodeSource(val token: EpisodeSourceToken, val series: Series, val episode: Episode)
+
+internal class PlayerEpisodeSourceState {
+ var token = EpisodeSourceToken(0, 0)
+ private set
+ var attempted = false
+ private set
+ private var physical: PhysicalEpisodeSource? = null
+ private var captured: Pair<Long, Long>? = null
+ private var awaitingResume = false
+ var failed = false
+ private set
+ val recoveryPending: Boolean get() = awaitingResume
+ var manualVideoRevision = 0L
+ private set
+ fun onVideoSelection() { manualVideoRevision++ }
+ fun retryPhysical(positionMs: Long, durationMs: Long): EpisodeSourceToken? {
+ val previous = physical ?: return null
+ val progress = if (awaitingResume) captured else positionMs to durationMs
+ if (!attempted || progress == null || progress.first < 0 || progress.second <= 0) return null
+ token = token.copy(generation = token.generation + 1)
+ physical = previous.copy(token = token)
+ captured = progress
+ awaitingResume = true
+ failed = false
+ return token
+ }
+
+ fun reset(requestVersion: Long): EpisodeSourceToken {
+ token = EpisodeSourceToken(requestVersion, token.generation + 1)
+ attempted = false
+ physical = null
+ captured = null
+ awaitingResume = false
+ failed = false
+ return token
+ }
+ fun isCurrent(token: EpisodeSourceToken) = token == this.token
+ fun reserveFallback(token: EpisodeSourceToken, positionMs: Long, durationMs: Long): EpisodeSourceToken? {
+ if (!isCurrent(token) || attempted || positionMs < 0 || durationMs <= 0) return null
+ this.token = token.copy(generation = token.generation + 1)
+ attempted = true
+ captured = positionMs to durationMs
+ awaitingResume = true
+ return this.token
+ }
+ fun stage(token: EpisodeSourceToken, series: Series, episode: Episode): Boolean {
+ if (!isCurrent(token) || !attempted) return false
+ physical = PhysicalEpisodeSource(token, series, episode)
+ return true
+ }
+ fun confirmResume(token: EpisodeSourceToken, positionMs: Long): Boolean {
+ if (!isCurrent(token) || physical == null || !awaitingResume || failed) return false
+ val position = captured?.first ?: return false
+ if (positionMs < position - 2000L || positionMs > position + 2000L) return false
+ awaitingResume = false
+ return true
+ }
+ fun markFailed(token: EpisodeSourceToken) { if (isCurrent(token)) failed = true }
+ fun source(token: EpisodeSourceToken): PhysicalEpisodeSource? = physical.takeIf { isCurrent(token) }
+ fun progressSnapshot(token: EpisodeSourceToken, positionMs: Long, durationMs: Long): Pair<Long, Long>? =
+ if (!isCurrent(token)) null else if (awaitingResume) captured else positionMs to durationMs
+}
+
+internal fun episodeRecoveryIdentity(logicalUrl: String, failingResolvedUrl: String): String =
+ logicalUrl.takeIf { it.isNotBlank() } ?: failingResolvedUrl
+
+internal fun isEpisodePreparationCurrent(state: PlayerEpisodeSourceState, token: EpisodeSourceToken,
+ sessionActive: Boolean, manualVideo: Boolean, videoRevision: Long, requireAuto: Boolean): Boolean =
+ sessionActive && state.isCurrent(token) && !state.failed &&
+ (!requireAuto || (!manualVideo && videoRevision == state.manualVideoRevision))
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerLifecycleActions.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerLifecycleActions.kt
index d107f543..0ccb4bbc 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerLifecycleActions.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerLifecycleActions.kt
@@ -2,14 +2,67 @@ package com.streamvault.feature.playback.player
import androidx.lifecycle.viewModelScope
import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.StreamInfo
import com.streamvault.player.PlaybackState
import com.streamvault.player.PlayerEngine
-import kotlinx.coroutines.delay
import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
private const val LIFECYCLE_TOKEN_RENEWAL_LEAD_MS = 60_000L
-private const val LIFECYCLE_TOKEN_RENEWAL_CHECK_INTERVAL_MS = 10_000L
+private const val LIFECYCLE_TOKEN_RENEWAL_RECHECK_INTERVAL_MS = 15_000L
+private const val LIFECYCLE_TOKEN_RENEWAL_FINAL_GRACE_MS = 15_000L
+
+internal fun isSamePlaybackRequestForRenewal(current: StreamInfo, refreshed: StreamInfo): Boolean =
+ current.copy(title = null, expirationTime = null) ==
+ refreshed.copy(title = null, expirationTime = null)
+
+internal fun shouldArmNextTokenRenewal(
+ previousExpiryTime: Long,
+ refreshedExpiryTime: Long?,
+ nowMs: Long
+): Boolean {
+ val refreshedExpiry = refreshedExpiryTime ?: return false
+ if (refreshedExpiry >= Long.MAX_VALUE || refreshedExpiry <= previousExpiryTime) return false
+ return refreshedExpiry > nowMs && refreshedExpiry - nowMs > LIFECYCLE_TOKEN_RENEWAL_LEAD_MS
+}
+
+internal fun nextTokenRenewalCheckAtMs(
+ previousExpiryTime: Long,
+ refreshedExpiryTime: Long?,
+ nowMs: Long
+): Long? {
+ val refreshedExpiry = refreshedExpiryTime?.takeIf { it > 0L && it < Long.MAX_VALUE } ?: return null
+ if (refreshedExpiry > nowMs && refreshedExpiry - nowMs > LIFECYCLE_TOKEN_RENEWAL_LEAD_MS) {
+ return refreshedExpiry - LIFECYCLE_TOKEN_RENEWAL_LEAD_MS
+ }
+
+ val latestExpiry = maxOf(previousExpiryTime, refreshedExpiry)
+ val lastCheckAt = if (latestExpiry > Long.MAX_VALUE - LIFECYCLE_TOKEN_RENEWAL_FINAL_GRACE_MS) {
+ Long.MAX_VALUE
+ } else {
+ latestExpiry + LIFECYCLE_TOKEN_RENEWAL_FINAL_GRACE_MS
+ }
+ if (nowMs >= lastCheckAt) return null
+
+ val nextIntervalAt = if (nowMs > Long.MAX_VALUE - LIFECYCLE_TOKEN_RENEWAL_RECHECK_INTERVAL_MS) {
+ Long.MAX_VALUE
+ } else {
+ nowMs + LIFECYCLE_TOKEN_RENEWAL_RECHECK_INTERVAL_MS
+ }
+ return minOf(nextIntervalAt, lastCheckAt)
+}
+
+internal fun isUsableTokenRenewalExpiry(
+ previousExpiryTime: Long,
+ refreshedExpiryTime: Long?,
+ nowMs: Long
+): Boolean {
+ val refreshedExpiry = refreshedExpiryTime ?: return true
+ if (refreshedExpiry == 0L || refreshedExpiry == Long.MAX_VALUE) return true
+ return refreshedExpiry > previousExpiryTime && refreshedExpiry > nowMs
+}
/** Captures the old content before prepare mutates the shared playback context. */
internal fun PlayerViewModel.queueContentSwitchProgressFlush(): Job? {
@@ -43,8 +96,13 @@ internal fun PlayerViewModel.queueContentSwitchProgressFlush(): Job? {
*/
internal fun PlayerViewModel.queueForcedProgressFlush(): Job? {
if (currentContentType == ContentType.LIVE) return null
+ val history = buildPlaybackHistorySnapshot(playerEngine.currentPosition.value, playerEngine.duration.value)
return viewModelScope.launch {
- persistPlaybackProgress()
+ if (history != null) {
+ val result = playbackHistoryCoordinator.updateResumePosition(history)
+ logRepositoryFailure("Persist playback resume position", result)
+ if (result.isSuccess) playbackHistoryCoordinator.updateWatchNextProgress(history)
+ }
logRepositoryFailure(
operation = "Flush pending playback progress at lifecycle boundary",
result = playbackHistoryCoordinator.flushPendingProgress()
@@ -83,31 +141,74 @@ internal suspend fun PlayerViewModel.persistPlaybackProgress() {
}
}
-internal fun PlayerViewModel.startTokenRenewalMonitoring(expirationTime: Long?) {
+internal fun PlayerViewModel.startTokenRenewalMonitoring(
+ expirationTime: Long?,
+ scheduledCheckAtMs: Long? = null
+) {
tokenRenewalJob?.cancel()
tokenRenewalJob = null
- val expiry = expirationTime?.takeIf { it > 0L } ?: return
+ val expiry = expirationTime?.takeIf { it > 0L && it < Long.MAX_VALUE } ?: return
val requestVersion = prepareRequestVersion
+ val episodeToken = episodeSourceState.token
tokenRenewalJob = playbackSessionScope(requestVersion)?.launch {
- while (true) {
- delay(LIFECYCLE_TOKEN_RENEWAL_CHECK_INTERVAL_MS)
- if (!playerEngine.isPlaying.value) continue
- val remaining = expiry - System.currentTimeMillis()
- if (remaining > LIFECYCLE_TOKEN_RENEWAL_LEAD_MS) continue
- if (!isActivePlaybackSession(requestVersion)) return@launch
- val refreshed = resolvePlaybackStreamInfo(
- logicalUrl = currentStreamUrl,
- internalContentId = currentContentId,
- providerId = currentProviderId,
- contentType = currentContentType
- ) ?: return@launch
- if (!isActivePlaybackSession(requestVersion)) return@launch
- currentResolvedPlaybackUrl = refreshed.url
- currentResolvedStreamInfo = refreshed
- playerEngine.renewStreamUrl(refreshed)
- startTokenRenewalMonitoring(refreshed.expirationTime)
+ val nowBeforeWait = System.currentTimeMillis()
+ val defaultCheckAt = (expiry - LIFECYCLE_TOKEN_RENEWAL_LEAD_MS).coerceAtLeast(nowBeforeWait)
+ val checkAt = scheduledCheckAtMs ?: defaultCheckAt
+ delay((checkAt - nowBeforeWait).coerceAtLeast(0L))
+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return@launch
+
+ // If playback is paused at the deadline, wait for resume instead of polling in the
+ // background. Session cancellation still releases this wait when content changes.
+ playerEngine.isPlaying.first { isPlaying -> isPlaying }
+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return@launch
+
+ val refreshed = resolvePlaybackStreamInfo(
+ logicalUrl = currentStreamUrl,
+ internalContentId = currentContentId,
+ providerId = currentProviderId,
+ contentType = currentContentType
+ ) ?: return@launch
+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return@launch
+
+ val now = System.currentTimeMillis()
+ val refreshedExpiry = refreshed.expirationTime
+ val sameRequest = currentResolvedStreamInfo?.let {
+ isSamePlaybackRequestForRenewal(it, refreshed)
+ } == true
+ val hasUsableChangedRequest = !sameRequest && refreshedExpiry?.let { it > now } == true
+ if (!isUsableTokenRenewalExpiry(expiry, refreshedExpiry, now) && !hasUsableChangedRequest) {
+ android.util.Log.w(
+ "PlayerVM",
+ "token-renewal skipped reason=stale-expiry current-remaining-ms=${expiry - now} " +
+ "refreshed-remaining-ms=${refreshedExpiry?.minus(now)}"
+ )
+ nextTokenRenewalCheckAtMs(expiry, refreshedExpiry, now)?.let { nextCheckAt ->
+ startTokenRenewalMonitoring(expiry, scheduledCheckAtMs = nextCheckAt)
+ }
return@launch
}
+
+ android.util.Log.i(
+ "PlayerVM",
+ "token-renewal request-changed=${!sameRequest} current-remaining-ms=${expiry - now} " +
+ "refreshed-remaining-ms=${refreshedExpiry?.minus(now)}"
+ )
+ currentResolvedPlaybackUrl = refreshed.url
+ currentResolvedStreamInfo = refreshed
+
+ if (sameRequest) {
+ // A timestamp or display-title change cannot justify replacing an identical request.
+ // Recheck only during the final renewal window instead of discarding a healthy buffer.
+ nextTokenRenewalCheckAtMs(expiry, refreshedExpiry, now)?.let { nextCheckAt ->
+ startTokenRenewalMonitoring(refreshedExpiry, scheduledCheckAtMs = nextCheckAt)
+ }
+ return@launch
+ }
+
+ playerEngine.renewStreamUrl(refreshed)
+ nextTokenRenewalCheckAtMs(expiry, refreshedExpiry, now)?.let { nextCheckAt ->
+ startTokenRenewalMonitoring(refreshedExpiry, scheduledCheckAtMs = nextCheckAt)
+ }
}
}
@@ -132,6 +233,7 @@ fun PlayerViewModel.onAppForegrounded() {
fun PlayerViewModel.onPlayerScreenDisposed(): Job? {
val progressFlush = queueForcedProgressFlush()
+ episodeSourceState.reset(prepareRequestVersion)
clearPreloadWindow()
playerPlaybackContextCoordinator.clearSelectedCatchUpProgram()
playerEngine.stopLiveTimeshift()
@@ -154,6 +256,7 @@ internal fun PlayerViewModel.clearPlaybackTimers() {
fun PlayerViewModel.handOffPlaybackToMultiView(): Job? {
val progressFlush = queueForcedProgressFlush()
+ episodeSourceState.reset(prepareRequestVersion)
clearPreloadWindow()
playerPlaybackContextCoordinator.clearSelectedCatchUpProgram()
playerEngine.stopLiveTimeshift()
@@ -180,9 +283,6 @@ internal fun PlayerViewModel.cleanupAfterCleared(mainPlayerEngine: PlayerEngine)
aspectRatioJob?.cancel()
recentChannelsJob?.cancel()
lastVisitedCategoryJob?.cancel()
- thumbnailPreloadJob?.cancel()
- inFlightThumbnailPreloadKey = null
- lastCompletedThumbnailPreloadKey = null
playerThumbnailCoordinator.clearCache()
val activeEngine = playerEngine
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupport.kt
index e7696340..c7a8f201 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupport.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupport.kt
@@ -1,13 +1,34 @@
package com.streamvault.feature.playback.player
import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.StreamType
import com.streamvault.domain.model.VodMovieVariant
-import com.streamvault.domain.util.movieVariantQualityScore
+import com.streamvault.player.PLAYER_TRACK_AUTO_ID
+import com.streamvault.player.PlayerTrack
+import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.StreamTypeResolver
+import java.text.Normalizer
import java.util.Locale
+import kotlin.math.abs
-private val AVC_CODEC_TOKENS = listOf("avc", "h264", "x264")
-private val HEVC_CODEC_TOKENS = listOf("hevc", "h265", "x265", "hev1", "hvc1")
+private val AVC_CODEC_TOKENS = listOf("avc", "h264", "h 264", "x264")
+private val HEVC_CODEC_TOKENS = listOf("hevc", "h265", "h 265", "x265", "hev1", "hvc1")
private val MOVIE_CODEC_TOKEN_REGEX = Regex("""[^a-z0-9]+""")
+private val MOVIE_TITLE_METADATA_REGEX = Regex(
+ """(?i)(?<![a-z0-9])(?:8k|4320p|uhd|ultra\s*hd|4k|2160[pi]?|2k|qhd|1440p|full\s*hd|fhd|1080[pi]?|720p|576p|540p|480p|360p|240p|hd|hq|sd|dolby\s*vision|hdr10|hdr|hevc|h[ ._-]*265|x265|hev1|hvc1|avc|h[ ._-]*264|x264|web\s*dl|web\s*rip|blu\s*ray|bluray|remux)(?![a-z0-9])"""
+)
+private val MOVIE_TITLE_NON_ALPHANUMERIC_REGEX = Regex("""[^\p{L}\p{N}]+""")
+private val MOVIE_RESOLUTION_PATTERNS = listOf(
+ Regex("""(?<![a-z0-9])(?:8k|4320p)(?![a-z0-9])""") to 4320,
+ Regex("""(?<![a-z0-9])(?:uhd|ultra\s*hd|4k|2160[pi]?)(?![a-z0-9])""") to 2160,
+ Regex("""(?<![a-z0-9])(?:2k|qhd|1440p)(?![a-z0-9])""") to 1440,
+ Regex("""(?<![a-z0-9])(?:full\s*hd|fhd|1080[pi]?)(?![a-z0-9])""") to 1080,
+ Regex("""(?<![a-z0-9])(?:720p|hd)(?![a-z0-9])""") to 720,
+ Regex("""(?<![a-z0-9])(?:576p|540p|hq|sd)(?![a-z0-9])""") to 576,
+ Regex("""(?<![a-z0-9])480p(?![a-z0-9])""") to 480,
+ Regex("""(?<![a-z0-9])360p(?![a-z0-9])""") to 360,
+ Regex("""(?<![a-z0-9])240p(?![a-z0-9])""") to 240
+)
internal suspend fun PlayerViewModel.tryFallbackToAvcMovieVariant(
requestVersion: Long,
@@ -16,62 +37,183 @@ internal suspend fun PlayerViewModel.tryFallbackToAvcMovieVariant(
if (currentContentType != com.streamvault.domain.model.ContentType.MOVIE) return false
if (currentProviderId <= 0L || currentContentId <= 0L) return false
if (playerRecoveryCoordinator.retriedWithAvcMovieVariant) return false
- if (!isActivePlaybackSession(requestVersion, playbackUrl)) return false
+ val episodeToken = episodeSourceState.token
+ val videoSelectionRevision = episodeSourceState.manualVideoRevision
+ fun isCurrent(requireOriginalUrl: Boolean = true): Boolean = isEpisodePreparationCurrent(
+ state = episodeSourceState,
+ token = episodeToken,
+ sessionActive = if (requireOriginalUrl) isActivePlaybackSession(requestVersion, playbackUrl)
+ else isActivePlaybackSession(requestVersion),
+ manualVideo = hasManualVideoTrackChoice(playerEngine.availableVideoTracks.value),
+ videoRevision = videoSelectionRevision,
+ requireAuto = true
+ )
+ if (!isCurrent()) return false
val currentMovie = playerContentResolver.getMovie(currentContentId) ?: return false
- val variants = playerContentResolver.getMovieVariants(currentContentId)
- val fallbackVariant = selectAvcMovieFallbackVariant(currentMovie, variants) ?: return false
+ if (!isCurrent()) return false
+ val variants = playerContentResolver.getMovieVariants(currentMovie.id)
+ if (!isCurrent()) return false
+ val currentStreamInfo = currentResolvedStreamInfo ?: return false
+ if (StreamTypeResolver.resolve(currentStreamInfo) != ResolvedStreamType.PROGRESSIVE) return false
+ val currentStreamType = currentStreamInfo.streamType.takeUnless { it == StreamType.UNKNOWN }
+ ?: StreamType.PROGRESSIVE
+ val hasExplicitVariantChoice = playerContentResolver.hasExplicitMovieVariantSelection(currentMovie.id)
+ if (!isCurrent()) return false
+ val hasManualTrackChoice = hasManualVideoTrackChoice(playerEngine.availableVideoTracks.value)
+ val fallbackVariant = selectAvcMovieFallbackVariant(
+ currentMovie = currentMovie,
+ variants = variants,
+ currentStreamType = currentStreamType,
+ hasExplicitVariantChoice = hasExplicitVariantChoice,
+ hasManualVideoTrackChoice = hasManualTrackChoice,
+ currentCodecHint = playerEngine.playerStats.value.videoCodec
+ ) ?: return false
val fallbackMovie = playerContentResolver.getMovie(fallbackVariant.rawMovieId) ?: return false
+ if (!isCurrent()) return false
+ if (fallbackMovie.providerId != currentMovie.providerId) return false
+ val resumePositionMs = playerEngine.currentPosition.value.coerceAtLeast(0L)
+ val sourceDurationMs = playerEngine.duration.value.takeIf { it > 0L }
+ ?: currentMovie.durationSeconds.takeIf { it > 0 }?.times(1_000L)
+ ?: return false
+ if (!areMovieVariantDurationsCompatible(sourceDurationMs, fallbackMovie.durationSeconds)) return false
+ val fallbackDurationMs = fallbackMovie.durationSeconds * 1_000L
+ if (resumePositionMs >= fallbackDurationMs - MOVIE_VARIANT_END_GUARD_MS) return false
val fallbackStreamInfo = playerContentResolver.getMovieStreamInfo(fallbackMovie).getOrNull() ?: return false
- if (!isActivePlaybackSession(requestVersion, playbackUrl)) return false
+ if (!isCurrent()) return false
+ if (playerContentResolver.hasExplicitMovieVariantSelection(currentMovie.id)) return false
+ if (!isCurrent()) return false
+ val previousContentId = currentContentId
+ val previousStreamUrl = currentStreamUrl
+ val previousTitle = currentTitle
+ val previousArtworkUrl = currentArtworkUrl
playerRecoveryCoordinator.retriedWithAvcMovieVariant = true
currentContentId = fallbackMovie.id
currentStreamUrl = fallbackMovie.streamUrl
- currentTitle = fallbackMovie.name
- playbackTitleFlow.value = fallbackMovie.name
- currentArtworkUrl = fallbackMovie.posterUrl ?: fallbackMovie.backdropUrl ?: currentArtworkUrl
- val resolvedStreamInfo = fallbackStreamInfo.copy(title = fallbackStreamInfo.title ?: fallbackMovie.name)
- setLastFailureReason("HEVC playback failed. Retrying with an AVC/H.264 movie variant.")
- appendRecoveryAction("Switched to AVC/H.264 movie variant")
+ val resolvedStreamInfo = fallbackStreamInfo.copy(title = previousTitle.ifBlank { currentMovie.name })
+ if (!preparePlayer(
+ resolvedStreamInfo,
+ requestVersion,
+ preserveVodTrackPreferences = true,
+ episodeToken = episodeToken,
+ requiredSourceType = ResolvedStreamType.PROGRESSIVE,
+ requireAutoVideoSelection = true,
+ videoSelectionRevision = videoSelectionRevision
+ )) {
+ if (!isActivePlaybackSession(requestVersion)) return false
+ currentContentId = previousContentId
+ currentStreamUrl = previousStreamUrl
+ currentTitle = previousTitle
+ playbackTitleFlow.value = previousTitle
+ currentArtworkUrl = previousArtworkUrl
+ playerRecoveryCoordinator.retriedWithAvcMovieVariant = false
+ return false
+ }
+ if (!isCurrent(requireOriginalUrl = false)) return false
+ if (resumePositionMs > 0L) playerEngine.seekTo(resumePositionMs)
+ setLastFailureReason("HEVC playback failed. Retrying with a compatible AVC/H.264 movie variant.")
+ appendRecoveryAction("Switched to compatible AVC/H.264 movie variant")
showPlayerNotice(
- message = "Retrying with an AVC/H.264 movie variant.",
+ message = "Retrying with a compatible AVC/H.264 movie variant.",
recoveryType = PlayerRecoveryType.DECODER,
actions = buildRecoveryActions(PlayerRecoveryType.DECODER)
)
- if (!preparePlayer(resolvedStreamInfo, requestVersion)) return false
playerEngine.play()
return true
}
+private const val MOVIE_VARIANT_DURATION_TOLERANCE_MS = 90_000L
+private const val MOVIE_VARIANT_DURATION_TOLERANCE_PERCENT = 3L
+private const val MOVIE_VARIANT_END_GUARD_MS = 15_000L
+
+internal fun areMovieVariantDurationsCompatible(
+ sourceDurationMs: Long,
+ variantDurationSeconds: Int
+): Boolean {
+ if (sourceDurationMs <= 0L || variantDurationSeconds <= 0) return false
+ val variantDurationMs = variantDurationSeconds * 1_000L
+ val toleranceMs = maxOf(
+ MOVIE_VARIANT_DURATION_TOLERANCE_MS,
+ (sourceDurationMs / 100L) * MOVIE_VARIANT_DURATION_TOLERANCE_PERCENT
+ )
+ return abs(sourceDurationMs - variantDurationMs) <= toleranceMs
+}
+
internal fun selectAvcMovieFallbackVariant(
currentMovie: Movie,
- variants: List<VodMovieVariant>
+ variants: List<VodMovieVariant>,
+ currentStreamType: StreamType = StreamType.PROGRESSIVE,
+ hasExplicitVariantChoice: Boolean = false,
+ hasManualVideoTrackChoice: Boolean = false,
+ currentCodecHint: String? = null
): VodMovieVariant? {
+ if (currentStreamType != StreamType.PROGRESSIVE) return null
+ if (hasExplicitVariantChoice || hasManualVideoTrackChoice) return null
+
+ val currentTitleKey = movieVariantTitleKey(currentMovie.name)
+ if (currentTitleKey.isBlank()) return null
+ val currentHeight = movieVariantResolutionHeight(currentMovie.name) ?: return null
+ val measuredCodec = currentCodecHint.orEmpty().trim()
+ val hasMeasuredCodec = measuredCodec.isNotBlank() && !measuredCodec.equals("unknown", ignoreCase = true)
+ val currentIsHevc = when {
+ hasMeasuredCodec && hasHevcCodec(measuredCodec) -> true
+ hasMeasuredCodec && hasAvcCodec(measuredCodec) -> false
+ else -> hasHevcCodec(currentMovie.name)
+ }
+ if (!currentIsHevc) return null
+
val candidateVariants = variants.asSequence()
.filter { it.rawMovieId != currentMovie.id }
.filter { it.streamUrl.isNotBlank() }
+ .filter { movieVariantTitleKey(it.name) == currentTitleKey }
+ .filter {
+ val codecLabel = "${it.name} ${it.label}"
+ hasAvcCodec(codecLabel) && !hasHevcCodec(codecLabel)
+ }
+ .mapNotNull { variant ->
+ movieVariantResolutionHeight("${variant.name} ${variant.label}")
+ ?.takeIf { height -> height <= currentHeight }
+ ?.let { height -> variant to height }
+ }
.sortedWith(
- compareByDescending<VodMovieVariant> { movieCodecFallbackPriority(it.name) }
- .thenByDescending { movieVariantQualityScore(it.name) }
- .thenByDescending { it.addedAt }
- .thenByDescending { it.rating }
- .thenBy { it.name.lowercase(Locale.ROOT) }
- .thenBy { it.rawMovieId }
+ compareByDescending<Pair<VodMovieVariant, Int>> { it.second }
+ .thenByDescending { it.first.addedAt }
+ .thenByDescending { it.first.rating }
+ .thenBy { it.first.name.lowercase(Locale.ROOT) }
+ .thenBy { it.first.rawMovieId }
)
- return candidateVariants.firstOrNull { movieCodecFallbackPriority(it.name) > 0 }
+ return candidateVariants.firstOrNull()?.first
}
-private fun movieCodecFallbackPriority(title: String): Int {
- val normalized = normalizeMovieVariantCodecText(title)
- val hasHevc = HEVC_CODEC_TOKENS.any { token -> normalized.contains(" $token ") }
- if (hasHevc) return 0
+internal fun hasManualVideoTrackChoice(tracks: List<PlayerTrack>): Boolean =
+ tracks.any { it.id == PLAYER_TRACK_AUTO_ID } && tracks.none { it.id == PLAYER_TRACK_AUTO_ID && it.isSelected }
+
+private fun movieVariantResolutionHeight(value: String): Int? {
+ val normalized = value.lowercase(Locale.ROOT)
+ return MOVIE_RESOLUTION_PATTERNS.firstNotNullOfOrNull { (pattern, height) ->
+ height.takeIf { pattern.containsMatchIn(normalized) }
+ }
+}
+
+private fun movieVariantTitleKey(value: String): String {
+ val withoutVariantMetadata = MOVIE_TITLE_METADATA_REGEX.replace(value, " ")
+ val decomposed = Normalizer.normalize(withoutVariantMetadata, Normalizer.Form.NFD)
+ .replace(Regex("\\p{Mn}+"), "")
+ return MOVIE_TITLE_NON_ALPHANUMERIC_REGEX
+ .replace(decomposed.lowercase(Locale.ROOT), "")
+}
+
+private fun hasHevcCodec(value: String): Boolean = hasCodecToken(value, HEVC_CODEC_TOKENS)
+
+private fun hasAvcCodec(value: String): Boolean = hasCodecToken(value, AVC_CODEC_TOKENS)
- val hasAvc = AVC_CODEC_TOKENS.any { token -> normalized.contains(" $token ") }
- return if (hasAvc) 2 else 1
+private fun hasCodecToken(value: String, tokens: List<String>): Boolean {
+ val normalized = normalizeMovieVariantCodecText(value)
+ return tokens.any { token -> normalized.contains(" $token ") }
}
private fun normalizeMovieVariantCodecText(value: String): String {
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerNoticeActions.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerNoticeActions.kt
index e39aa161..e27f6230 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerNoticeActions.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerNoticeActions.kt
@@ -98,6 +98,11 @@ fun PlayerViewModel.restartCurrentProgram() {
}
fun PlayerViewModel.retryStream(streamUrl: String, epgChannelId: String?) {
+ if (currentContentType == ContentType.SERIES_EPISODE &&
+ episodeSourceState.source(episodeSourceState.token) != null && streamUrl == currentStreamUrl) {
+ retryPhysicalEpisode()
+ return
+ }
if (isCatchUpPlayback.value) {
val requestVersion = beginPlaybackSession()
playbackSessionScope(requestVersion)?.launch {
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActions.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActions.kt
index 68192ba7..999112bd 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActions.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActions.kt
@@ -11,61 +11,11 @@ import com.streamvault.player.AUDIO_VIDEO_OFFSET_MAX_MS
import com.streamvault.player.AUDIO_VIDEO_OFFSET_MIN_MS
import com.streamvault.player.PlaybackState
import com.streamvault.player.PlayerError
-import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
-import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.withLock
-import kotlin.collections.LinkedHashSet
-
-private const val THUMBNAIL_PRELOAD_BUCKET_MS = 10_000L
-private const val THUMBNAIL_PRELOAD_FRAME_BUDGET = 6
-
-internal fun buildThumbnailPreloadPositions(
- durationMs: Long,
- currentPositionMs: Long,
- bucketMs: Long = THUMBNAIL_PRELOAD_BUCKET_MS,
- frameBudget: Int = THUMBNAIL_PRELOAD_FRAME_BUDGET
-): List<Long> {
- if (durationMs <= 0L || bucketMs <= 0L || frameBudget <= 0) return emptyList()
-
- val maxPositionMs = durationMs.coerceAtLeast(0L)
- val anchorPositionMs = (currentPositionMs.coerceIn(0L, maxPositionMs) / bucketMs) * bucketMs
- val plannedPositions = LinkedHashSet<Long>()
- var offsetMs = 0L
-
- while (plannedPositions.size < frameBudget) {
- val forwardPositionMs = anchorPositionMs + offsetMs
- if (forwardPositionMs <= maxPositionMs) {
- plannedPositions += forwardPositionMs
- }
- if (plannedPositions.size >= frameBudget) break
-
- if (offsetMs > 0L) {
- val backwardPositionMs = anchorPositionMs - offsetMs
- if (backwardPositionMs >= 0L) {
- plannedPositions += backwardPositionMs
- }
- }
-
- if (forwardPositionMs > maxPositionMs && anchorPositionMs - offsetMs < 0L) {
- break
- }
- offsetMs += bucketMs
- }
-
- return plannedPositions.toList()
-}
-
-internal fun shouldStartThumbnailPreload(
- preloadKey: String,
- lastCompletedPreloadKey: String?,
- inFlightPreloadKey: String?
-): Boolean = preloadKey.isNotBlank() &&
- preloadKey != lastCompletedPreloadKey &&
- preloadKey != inFlightPreloadKey
fun PlayerViewModel.selectAudioTrack(trackId: String) {
val selectedTrack = playerEngine.availableAudioTracks.value.firstOrNull { it.id == trackId }
@@ -120,6 +70,7 @@ private fun PlayerViewModel.persistVodTrackPreferences(
}
fun PlayerViewModel.selectVideoQuality(trackId: String) {
+ episodeSourceState.onVideoSelection()
playerEngine.selectVideoTrack(trackId)
}
@@ -416,42 +367,6 @@ fun PlayerViewModel.updateSeekPreview(positionMs: Long?) {
}
}
-internal fun PlayerViewModel.startThumbnailPreload() {
- val url = currentResolvedPlaybackUrl.ifBlank { currentStreamUrl }
- val streamInfo = currentResolvedStreamInfo
- val isLive = currentContentType == ContentType.LIVE
- if (url.isBlank() || !playerThumbnailCoordinator.supportsFrameExtraction(url, streamInfo, isLive)) return
- if (!shouldStartThumbnailPreload(url, lastCompletedThumbnailPreloadKey, inFlightThumbnailPreloadKey)) return
- val durationMs = playerEngine.duration.value
- if (durationMs <= 0L) return
- val preloadPositions = buildThumbnailPreloadPositions(
- durationMs = durationMs,
- currentPositionMs = playerEngine.currentPosition.value
- )
- if (preloadPositions.isEmpty()) return
-
- thumbnailPreloadJob?.cancel()
- inFlightThumbnailPreloadKey = url
- thumbnailPreloadJob = viewModelScope.launch(Dispatchers.Default) {
- try {
- preloadPositions.forEach { positionMs ->
- ensureActive()
- playerThumbnailCoordinator.loadFrame(
- streamUrl = url,
- streamInfo = streamInfo,
- isLive = isLive,
- positionMs = positionMs
- )
- }
- lastCompletedThumbnailPreloadKey = url
- } finally {
- if (inFlightThumbnailPreloadKey == url) {
- inFlightThumbnailPreloadKey = null
- }
- }
- }
-}
-
internal fun PlayerViewModel.clearSeekPreview() {
seekPreviewJob?.cancel()
seekPreviewRequestVersion++
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupport.kt
index 3395d19b..c3835f14 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupport.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupport.kt
@@ -38,6 +38,19 @@ internal fun resolvePlaybackProbeFailure(responseCode: Int): PlaybackProbeFailur
else -> null
}
+internal fun shouldProbeProviderStreamUrl(
+ providerType: ProviderType,
+ url: String,
+ hasInternalSource: Boolean,
+ probeAlreadyPassed: Boolean
+): Boolean {
+ if (shouldSkipPlaybackProbe(providerType, url)) return false
+ if (providerType != ProviderType.STALKER_PORTAL && probeAlreadyPassed) return false
+ return hasInternalSource && (
+ providerType == ProviderType.XTREAM_CODES || providerType == ProviderType.STALKER_PORTAL
+ )
+}
+
internal fun shouldSkipPlaybackProbe(
providerType: ProviderType,
url: String
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupport.kt
index 505f4cd4..01eaf488 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupport.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupport.kt
@@ -34,6 +34,9 @@ internal fun classifyPlaybackError(error: PlayerError): PlayerRecoveryType = whe
internal fun resolvePlaybackErrorMessage(error: PlayerError): String = when (classifyPlaybackError(error)) {
PlayerRecoveryType.NETWORK -> "This stream is not responding right now. You can retry or try another source."
PlayerRecoveryType.SOURCE -> when {
+ error.message.contains("HTTP 404", ignoreCase = true) ->
+ "This stream resource was not found (HTTP 404). The provider may have removed it."
+
error.message.contains("HTTP 456", ignoreCase = true) ||
error.message.contains("access denied", ignoreCase = true) ->
"This provider rejected playback for this channel. The MAC or subscription may not have access to this stream."
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinator.kt
index a95300f2..f975006e 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinator.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinator.kt
@@ -24,18 +24,29 @@ class PlayerPreloadWindowCoordinator @Inject constructor(
series: Series,
currentEpisode: Episode,
providerId: Long,
- isCurrent: () -> Boolean
+ isCurrent: () -> Boolean,
+ physicalCurrent: PhysicalEpisodeSource? = null,
+ allowNeighborMedia: Boolean = true
): PlayerPreloadWindow? {
if (!isCurrent()) return null
+ if (physicalCurrent != null || !allowNeighborMedia) {
+ // Recovery owns one provider media source. Keep navigation logical, but do not
+ // open sibling preload responses alongside the recovered rendition.
+ return PlayerPreloadWindow(items = listOf(current.copy(
+ key = physicalCurrent?.let(::physicalEpisodePreloadKey) ?: episodePreloadKey(providerId, currentEpisode),
+ contentType = PlayerPreloadContentType.VOD
+ )), currentIndex = 0)
+ }
val neighbors = buildEpisodePreloadNeighbors(series, currentEpisode) ?: return null
val items = mutableListOf<PlayerPreloadItem>()
+ val currentKey = physicalCurrent?.let(::physicalEpisodePreloadKey) ?: episodePreloadKey(providerId, currentEpisode)
neighbors.forEach { episode ->
if (!isCurrent()) return null
val key = episodePreloadKey(providerId, episode)
if (episodeMatches(episode, currentEpisode)) {
items += current.copy(
- key = key,
+ key = currentKey,
contentType = PlayerPreloadContentType.VOD
)
return@forEach
@@ -70,7 +81,7 @@ class PlayerPreloadWindowCoordinator @Inject constructor(
)
}
- val currentIndex = items.indexOfFirst { it.key == episodePreloadKey(providerId, currentEpisode) }
+ val currentIndex = items.indexOfFirst { it.key == currentKey }
if (currentIndex < 0) return null
return PlayerPreloadWindow(items = items, currentIndex = currentIndex)
}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowSupport.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowSupport.kt
index 529ef9a9..02d5d82f 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowSupport.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreloadWindowSupport.kt
@@ -80,6 +80,9 @@ internal fun buildCatchUpPreloadTimeline(
internal fun episodePreloadKey(providerId: Long, episode: Episode): String =
"episode:$providerId:${episode.playbackEpisodeIdentity()}"
+internal fun physicalEpisodePreloadKey(source: PhysicalEpisodeSource): String =
+ "episode:${source.episode.providerId}:series:${source.series.id}:local:${source.episode.id}:remote:${source.episode.episodeId}"
+
internal fun catchUpPreloadKey(providerId: Long, channel: Channel, program: Program): String =
"catchup:$providerId:${channel.id}:${program.startTime}:${program.endTime}"
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinator.kt
index 31f98404..d4980f74 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinator.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinator.kt
@@ -7,6 +7,9 @@ import com.streamvault.domain.model.Result as DomainResult
import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.settings.VodTrackPreferences
import com.streamvault.player.PlayerEngine
+import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.StreamTypeResolver
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.player.playback.applyPlaybackTransportPolicy
import com.streamvault.player.playback.applyUnsafeTlsBypass
import kotlinx.coroutines.Dispatchers
@@ -35,7 +38,8 @@ class PlayerPreparationCoordinator @Inject constructor(
val probePassedPlaybackKeys: Set<String>,
val probeBeforePlayback: Boolean,
val audioVideoOffsetMs: Int,
- val vodTrackPreferences: VodTrackPreferences? = null
+ val vodTrackPreferences: VodTrackPreferences? = null,
+ val requiredSourceType: ResolvedStreamType? = null
)
internal sealed interface Result {
@@ -91,6 +95,12 @@ class PlayerPreparationCoordinator @Inject constructor(
}
if (!isCurrent()) return null
+ if (request.requiredSourceType != null &&
+ (StreamTypeResolver.resolve(preparedStreamInfo) != request.requiredSourceType ||
+ preparedStreamInfo.playbackContentKind != PlaybackContentKind.ON_DEMAND)) {
+ val contentLabel = if (request.contentType == ContentType.MOVIE) "movie" else "episode"
+ return Result.Failure("The compatible $contentLabel is not a progressive on-demand source.", PlayerRecoveryType.SOURCE)
+ }
applyPlaybackPreferences(
engine = playerEngineCoordinator.currentEngine,
contentType = request.contentType,
@@ -187,18 +197,15 @@ class PlayerPreparationCoordinator @Inject constructor(
currentStreamUrl = request.currentStreamUrl,
url = url
)
- if (provider.type != ProviderType.STALKER_PORTAL &&
- cacheKey in request.probePassedPlaybackKeys
- ) {
- return false
- }
- return (
- provider.type == ProviderType.XTREAM_CODES ||
- provider.type == ProviderType.STALKER_PORTAL
- ) && (
- playerContentResolver.isInternalStreamUrl(request.currentStreamUrl) ||
- playerContentResolver.isInternalStreamUrl(url)
- )
+ val hasInternalSource =
+ playerContentResolver.isInternalStreamUrl(request.currentStreamUrl) ||
+ playerContentResolver.isInternalStreamUrl(url)
+ return shouldProbeProviderStreamUrl(
+ providerType = provider.type,
+ url = url,
+ hasInternalSource = hasInternalSource,
+ probeAlreadyPassed = cacheKey in request.probePassedPlaybackKeys
+ )
}
private suspend fun probePlaybackUrl(streamInfo: StreamInfo): PlaybackProbeFailure? {
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
index f9218086..e8d4af38 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
@@ -4,10 +4,13 @@ import android.util.Log
import com.streamvault.domain.model.Channel
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.DecoderMode
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.StreamInfo
import com.streamvault.player.PlayerEngine
import com.streamvault.player.PlayerError
+import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.StreamTypeResolver
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
@@ -42,6 +45,9 @@ internal interface PlayerRecoveryExecutionPort {
): Boolean
fun tryNextCatchUpVariant(): Boolean
suspend fun tryFallbackToAvcMovieVariant(requestVersion: Long, playbackUrl: String): Boolean
+ suspend fun tryFallbackToAvcEpisodeVariant(requestVersion: Long, playbackUrl: String): EpisodeFallbackResult =
+ EpisodeFallbackResult.NotEligible
+ fun handleEpisodeReplacementError(error: PlayerError): Boolean = false
suspend fun tryRefreshXtreamPlaybackAfterAuthError(
error: PlayerError,
requestVersion: Long,
@@ -87,11 +93,12 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
)
cancel()
if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return null
+ if (request.contentType == ContentType.SERIES_EPISODE && port.handleEpisodeReplacementError(error)) return null
if (error is PlayerError.DecoderError && !port.recoveryState.retriedWithSoftwareDecoder) {
if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return null
if (request.contentType == ContentType.LIVE) {
- val currentLiveHlsSession = request.resolvedStreamInfo?.streamType == com.streamvault.domain.model.StreamType.HLS
+ val currentLiveHlsSession = request.isLiveHlsSession()
if (currentLiveHlsSession) {
val channel = request.channel
if (channel != null && port.tryAlternateStream(channel, allowXtreamTsFallback = false)) {
@@ -100,6 +107,15 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
logWarning(
"Decoder error on live HLS. Keeping hardware path to match Sparkle-like playback on ${port.appPackageName}."
)
+ if (!error.isDeferredLiveStall) {
+ port.setLastFailureReason(error.message)
+ port.showPlayerNotice(
+ message = resolvePlaybackErrorMessage(error),
+ recoveryType = PlayerRecoveryType.DECODER,
+ actions = port.buildRecoveryActions(PlayerRecoveryType.DECODER)
+ )
+ }
+ return null
}
}
port.recoveryState.retriedWithSoftwareDecoder = true
@@ -145,6 +161,12 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
recoveryJob = sessionScope?.launch {
if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return@launch
+ if (error is PlayerError.DecoderError && request.contentType == ContentType.SERIES_EPISODE) {
+ when (port.tryFallbackToAvcEpisodeVariant(request.requestVersion, request.playbackUrl)) {
+ EpisodeFallbackResult.Recovered, EpisodeFallbackResult.HandledFailure -> return@launch
+ EpisodeFallbackResult.NotEligible -> Unit
+ }
+ }
if (
error is PlayerError.DecoderError &&
request.contentType == ContentType.MOVIE &&
@@ -279,3 +301,18 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
runCatching { Log.w("PlayerVM", message) }
}
}
+
+private fun PlayerRecoveryRequest.isLiveHlsSession(): Boolean {
+ val streamInfo = resolvedStreamInfo
+ if (isCatchUp || streamInfo?.playbackContentKind == PlaybackContentKind.CATCH_UP) return false
+
+ if (streamInfo != null) {
+ val resolvedType = StreamTypeResolver.resolve(streamInfo)
+ if (resolvedType != ResolvedStreamType.UNKNOWN) {
+ return resolvedType == ResolvedStreamType.HLS
+ }
+ }
+
+ return listOfNotNull(streamInfo?.url, currentStreamUrl, playbackUrl)
+ .any { url -> StreamTypeResolver.resolve(url = url, isLive = true) == ResolvedStreamType.HLS }
+}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionPortAdapter.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionPortAdapter.kt
index 2149e7d5..4f0a1102 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionPortAdapter.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionPortAdapter.kt
@@ -30,6 +30,8 @@ internal class PlayerRecoveryExecutionPortAdapter(
private val logRepositoryFailure: (String, Result<Unit>) -> Unit,
private val fallbackToPreviousChannel: (String) -> Boolean,
private val hasLastChannel: () -> Boolean,
+ private val tryFallbackToAvcEpisodeVariant: suspend (Long, String) -> EpisodeFallbackResult = { _, _ -> EpisodeFallbackResult.NotEligible },
+ private val handleEpisodeReplacementError: (PlayerError) -> Boolean = { false },
) : PlayerRecoveryExecutionPort {
override val playerEngine: PlayerEngine
get() = engineCoordinator.currentEngine
@@ -48,6 +50,11 @@ internal class PlayerRecoveryExecutionPortAdapter(
override suspend fun tryFallbackToAvcMovieVariant(requestVersion: Long, playbackUrl: String): Boolean =
tryFallbackToAvcMovieVariant.invoke(requestVersion, playbackUrl)
+ override suspend fun tryFallbackToAvcEpisodeVariant(requestVersion: Long, playbackUrl: String): EpisodeFallbackResult =
+ tryFallbackToAvcEpisodeVariant.invoke(requestVersion, playbackUrl)
+
+ override fun handleEpisodeReplacementError(error: PlayerError): Boolean = handleEpisodeReplacementError.invoke(error)
+
override suspend fun tryRefreshXtreamPlaybackAfterAuthError(
error: PlayerError,
requestVersion: Long,
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt
index e3b37928..3ac21dcd 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerScreen.kt
@@ -179,6 +179,10 @@ fun PlayerScreen(
val sleepTimerExitEvent by viewModel.sleepTimerExitEvent.collectAsStateWithLifecycle()
val playerPreferences by viewModel.playerPreferencesUiState.collectAsStateWithLifecycle()
+ DisposableEffect(viewModel) {
+ onDispose { viewModel.clearSeekPreview() }
+ }
+
var modalState by remember { mutableStateOf(PlayerModalState()) }
var channelInfoSubPanelOpen by remember { mutableStateOf(false) }
var showClosePlaybackConfirmation by rememberSaveable { mutableStateOf(false) }
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinator.kt
index 7ce199df..80dfd33c 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinator.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinator.kt
@@ -48,7 +48,11 @@ class PlayerThumbnailCoordinator @Inject constructor(
Log.d(TAG, "frame-thumbnail backend=none reason=legacy-unsupported")
return null
}
- return legacyProvider.loadFrame(streamUrl, positionMs)
+ return legacyProvider.loadFrame(
+ streamUrl = streamUrl,
+ positionMs = positionMs,
+ requestHeaders = streamInfo.thumbnailRequestHeaders()
+ )
}
internal fun clearCache() {
@@ -76,6 +80,18 @@ class PlayerThumbnailCoordinator @Inject constructor(
}
}
+private fun StreamInfo?.thumbnailRequestHeaders(): Map<String, String> {
+ val source = this ?: return emptyMap()
+ val normalizedUserAgent = source.userAgent?.trim().orEmpty()
+ if (normalizedUserAgent.isBlank()) return source.headers
+ return buildMap(source.headers.size + 1) {
+ source.headers.forEach { (name, value) ->
+ if (!name.equals("User-Agent", ignoreCase = true)) put(name, value)
+ }
+ put("User-Agent", normalizedUserAgent)
+ }
+}
+
@Module
@InstallIn(SingletonComponent::class)
internal abstract class PlayerThumbnailModule {
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
index f646ed01..711bb64f 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
@@ -80,8 +80,6 @@ class PlayerViewModel @Inject constructor(
companion object {
private const val MIN_WATCHED_FOR_AUTO_PLAY_MS = 5_000L
private const val AUTO_PLAY_COUNTDOWN_SECONDS = 10
- private const val TOKEN_RENEWAL_LEAD_MS = 60_000L
- private const val TOKEN_RENEWAL_CHECK_INTERVAL_MS = 10_000L
private const val LOW_BANDWIDTH_THRESHOLD_BPS = 500_000L
private const val LOW_BANDWIDTH_DURATION_SECONDS = 30
internal val PLAYBACK_TIMER_PRESETS_MINUTES = setOf(0, 15, 30, 45, 60, 90, 120)
@@ -223,6 +221,7 @@ class PlayerViewModel @Inject constructor(
internal var lastRecordedVariantObservationSignature: String? = null
internal var lastRecordedVodVariantObservationSignature: String? = null
internal val playbackSessionCoordinator = PlaybackSessionCoordinator(viewModelScope)
+ internal val episodeSourceState = PlayerEpisodeSourceState()
private val playerRecoveryExecutionPort = PlayerRecoveryExecutionPortAdapter(
appPackageName = appContext.packageName,
engineCoordinator = playerEngineCoordinator,
@@ -265,7 +264,18 @@ class PlayerViewModel @Inject constructor(
},
logRepositoryFailure = { operation, result -> logRepositoryFailure(operation, result) },
fallbackToPreviousChannel = { reason -> fallbackToPreviousChannel(reason) },
- hasLastChannel = { hasLastChannel() }
+ hasLastChannel = { hasLastChannel() },
+ tryFallbackToAvcEpisodeVariant = { requestVersion, playbackUrl -> tryFallbackToAvcEpisodeVariant(requestVersion, playbackUrl) },
+ handleEpisodeReplacementError = { error ->
+ if (episodeSourceState.attempted && episodeSourceState.recoveryPending) {
+ episodeSourceState.markFailed(episodeSourceState.token)
+ playerEngine.stop()
+ val type = classifyPlaybackError(error)
+ setLastFailureReason(error.message)
+ showPlayerNotice(resolvePlaybackErrorMessage(error), type, buildRecoveryActions(type))
+ true
+ } else false
+ }
)
internal val prepareRequestVersion: Long
get() = playbackSessionCoordinator.currentId
@@ -377,12 +387,9 @@ class PlayerViewModel @Inject constructor(
internal var lastVisitedCategoryJob: Job? = null
internal var controlsHideJob: Job? = null
internal var seekPreviewJob: Job? = null
- internal var thumbnailPreloadJob: Job? = null
private var preloadWindowJob: Job? = null
private var preloadWindowInFlightFingerprint: String? = null
private var acceptedPreloadWindowFingerprint: String? = null
- internal var inFlightThumbnailPreloadKey: String? = null
- internal var lastCompletedThumbnailPreloadKey: String? = null
private var lowBandwidthMonitorJob: Job? = null
internal var progressTrackingJob: Job? = null
internal var tokenRenewalJob: Job? = null
@@ -533,7 +540,6 @@ class PlayerViewModel @Inject constructor(
} else {
if (currentContentType != ContentType.LIVE) {
recordMovieVariantSuccessObservation()
- startThumbnailPreload()
}
refreshPreloadWindow(prepareRequestVersion)
}
@@ -558,6 +564,9 @@ class PlayerViewModel @Inject constructor(
autoPlayEnabled = autoPlayEnabled
)
}.collect { observation ->
+ if (currentContentType == ContentType.SERIES_EPISODE && playerEngine.playbackState.value == PlaybackState.READY) {
+ episodeSourceState.confirmResume(episodeSourceState.token, observation.positionMs)
+ }
_skipChapter.value = if (
readySideEffectsRequestVersion == prepareRequestVersion &&
currentContentType.isSkippableChapterContent()
@@ -955,12 +964,12 @@ class PlayerViewModel @Inject constructor(
internal fun beginPlaybackSession(): Long {
val sessionId = playbackSessionCoordinator.begin().id
+ episodeSourceState.reset(sessionId)
lastTriggeredCreditsChapterStartMs = null
creditsAutoPlayTriggeredForSession = false
_skipChapter.value = null
playerRecoveryCoordinator.beginSession(sessionId)
playerRecoveryExecutionCoordinator.cancel()
- thumbnailPreloadJob?.cancel()
preloadWindowJob?.cancel()
preloadWindowJob = null
preloadWindowInFlightFingerprint = null
@@ -989,6 +998,7 @@ class PlayerViewModel @Inject constructor(
val neighborKeys: List<String>,
val series: Series? = null,
val episode: Episode? = null,
+ val physicalEpisode: PhysicalEpisodeSource? = null,
val selectedProgram: Program? = null,
val channel: com.streamvault.domain.model.Channel? = null,
val timelinePrograms: List<Program> = emptyList()
@@ -1002,7 +1012,8 @@ class PlayerViewModel @Inject constructor(
val series = currentSeries.value ?: return null
val episode = currentEpisode.value ?: return null
val neighbors = buildEpisodePreloadNeighbors(series, episode) ?: return null
- val currentKey = episodePreloadKey(providerId, episode)
+ val physicalEpisode = episodeSourceState.source(episodeSourceState.token)
+ val currentKey = physicalEpisode?.let(::physicalEpisodePreloadKey) ?: episodePreloadKey(providerId, episode)
return PreloadWindowSnapshot(
providerId = providerId,
current = PlayerPreloadItem(
@@ -1012,7 +1023,8 @@ class PlayerViewModel @Inject constructor(
),
neighborKeys = neighbors.map { episodePreloadKey(providerId, it) },
series = series,
- episode = episode
+ episode = episode,
+ physicalEpisode = physicalEpisode
)
}
@@ -1063,6 +1075,7 @@ class PlayerViewModel @Inject constructor(
}
preloadWindowJob?.cancel()
+ val episodeToken = episodeSourceState.token
preloadWindowInFlightFingerprint = fingerprint
preloadWindowJob = playbackSessionScope(requestVersion)?.launch {
val window = when {
@@ -1072,7 +1085,10 @@ class PlayerViewModel @Inject constructor(
series = snapshot.series,
currentEpisode = snapshot.episode,
providerId = snapshot.providerId,
- isCurrent = { isActivePlaybackSession(requestVersion) }
+ isCurrent = { isActivePlaybackSession(requestVersion) && episodeSourceState.isCurrent(episodeToken) },
+ physicalCurrent = snapshot.physicalEpisode,
+ allowNeighborMedia = playerProviderCoordinator.getProvider(snapshot.providerId)
+ ?.maxConnections?.let { it > 1 } == true
)
snapshot.selectedProgram != null && snapshot.channel != null ->
@@ -1087,7 +1103,7 @@ class PlayerViewModel @Inject constructor(
else -> null
}
- if (window == null || !isActivePlaybackSession(requestVersion)) {
+ if (window == null || !isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) {
if (preloadWindowInFlightFingerprint == fingerprint) {
preloadWindowInFlightFingerprint = null
}
@@ -1137,9 +1153,10 @@ class PlayerViewModel @Inject constructor(
seasonNumber: Int?,
episodeNumber: Int?
): Episode? {
+ val episodeToken = episodeSourceState.token
return when (val result = playerContentResolver.getSeriesDetails(providerId, seriesId)) {
is Result.Success -> {
- if (!isActivePlaybackSession(requestVersion)) return null
+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return null
val series = result.data.sanitizedForPlayer()
val resolution = buildSeriesEpisodeResolution(
series = series,
@@ -1172,7 +1189,7 @@ class PlayerViewModel @Inject constructor(
}
else -> {
- if (!isActivePlaybackSession(requestVersion)) return null
+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return null
_currentSeries.value = null
_currentEpisode.value = null
_nextEpisode.value = null
@@ -1187,9 +1204,13 @@ class PlayerViewModel @Inject constructor(
internal fun buildPlaybackHistorySnapshot(
positionMs: Long,
durationMs: Long
- ): PlaybackHistory? = buildPlaybackHistorySnapshot(
- positionMs = positionMs,
- durationMs = durationMs,
+ ): PlaybackHistory? {
+ val progress = if (currentContentType == ContentType.SERIES_EPISODE) {
+ episodeSourceState.progressSnapshot(episodeSourceState.token, positionMs, durationMs) ?: return null
+ } else positionMs to durationMs
+ return buildPlaybackHistorySnapshot(
+ positionMs = progress.first,
+ durationMs = progress.second,
currentContentId = currentContentId,
currentProviderId = currentProviderId,
currentContentType = currentContentType,
@@ -1201,6 +1222,7 @@ class PlayerViewModel @Inject constructor(
currentSeasonNumber = currentSeasonNumber,
currentEpisodeNumber = currentEpisodeNumber
)
+ }
internal fun isActivePlaybackSession(
requestVersion: Long,
@@ -1243,16 +1265,26 @@ class PlayerViewModel @Inject constructor(
streamInfo: com.streamvault.domain.model.StreamInfo,
requestVersion: Long,
probeBeforePlayback: Boolean = true,
- showFailureNotice: Boolean = true
+ showFailureNotice: Boolean = true,
+ preserveVodTrackPreferences: Boolean = false,
+ episodeToken: EpisodeSourceToken = episodeSourceState.token,
+ requiredSourceType: com.streamvault.player.playback.ResolvedStreamType? = null,
+ requireAutoVideoSelection: Boolean = false,
+ videoSelectionRevision: Long = episodeSourceState.manualVideoRevision
): Boolean {
- if (!isActivePlaybackSession(requestVersion)) return false
+ fun isCurrent() = isEpisodePreparationCurrent(episodeSourceState, episodeToken,
+ isActivePlaybackSession(requestVersion), hasManualVideoTrackChoice(playerEngine.availableVideoTracks.value),
+ videoSelectionRevision, requireAutoVideoSelection)
+ if (!isCurrent()) return false
- activeVodTrackPreferences = playerPreparationCoordinator.resolveVodTrackPreferences(
- contentType = currentContentType,
- providerId = currentProviderId,
- contentId = currentContentId,
- seriesId = currentSeriesId
- )
+ if (!preserveVodTrackPreferences) {
+ activeVodTrackPreferences = playerPreparationCoordinator.resolveVodTrackPreferences(
+ contentType = currentContentType,
+ providerId = currentProviderId,
+ contentId = currentContentId,
+ seriesId = currentSeriesId
+ )
+ }
val preparationResult = playerPreparationCoordinator.prepare(
request = PlayerPreparationCoordinator.Request(
@@ -1263,13 +1295,16 @@ class PlayerViewModel @Inject constructor(
probePassedPlaybackKeys = probePassedPlaybackKeys.toSet(),
probeBeforePlayback = probeBeforePlayback,
audioVideoOffsetMs = _audioVideoOffsetUiState.value.effectiveOffsetMs,
- vodTrackPreferences = activeVodTrackPreferences
+ vodTrackPreferences = activeVodTrackPreferences,
+ requiredSourceType = requiredSourceType ?: episodeSourceState.source(episodeToken)?.let {
+ com.streamvault.player.playback.ResolvedStreamType.PROGRESSIVE
+ }
),
- isCurrent = { isActivePlaybackSession(requestVersion) }
+ isCurrent = { isCurrent() }
) ?: return false
if (preparationResult is PlayerPreparationCoordinator.Result.Failure) {
- if (!isActivePlaybackSession(requestVersion)) return false
+ if (!isCurrent()) return false
setLastFailureReason(preparationResult.message)
if (showFailureNotice) {
showPlayerNotice(
@@ -1283,7 +1318,7 @@ class PlayerViewModel @Inject constructor(
val success = preparationResult as PlayerPreparationCoordinator.Result.Success
success.probeCacheKey?.let(probePassedPlaybackKeys::add)
- if (!isActivePlaybackSession(requestVersion)) return false
+ if (!isCurrent()) return false
currentResolvedPlaybackUrl = success.streamInfo.url
currentResolvedStreamInfo = success.streamInfo
readySideEffectsRequestVersion = requestVersion
@@ -1645,7 +1680,12 @@ class PlayerViewModel @Inject constructor(
internalContentId: Long,
providerId: Long,
contentType: ContentType
- ): PlayerPlaybackStreamResolution = playerContentResolver.resolvePlaybackStream(
+ ): PlayerPlaybackStreamResolution {
+ val physical = episodeSourceState.source(episodeSourceState.token)
+ ?.takeIf { contentType == ContentType.SERIES_EPISODE && providerId == currentProviderId &&
+ internalContentId == currentContentId && logicalUrl == currentStreamUrl }
+ if (physical != null) return playerContentResolver.resolvePhysicalEpisodeStream(physical, currentTitle)
+ return playerContentResolver.resolvePlaybackStream(
logicalUrl = logicalUrl,
internalContentId = internalContentId,
providerId = providerId,
@@ -1654,6 +1694,7 @@ class PlayerViewModel @Inject constructor(
currentSeries = currentSeries.value,
currentEpisode = currentEpisode.value
)
+ }
internal suspend fun resolvePlaybackStreamInfo(
logicalUrl: String,
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerZapActions.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerZapActions.kt
index 8a6291e0..6e96613f 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerZapActions.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerZapActions.kt
@@ -5,7 +5,6 @@ import com.streamvault.domain.model.Channel
import com.streamvault.domain.model.ChannelNumberingMode
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.PlaybackHistory
-import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.currentCoroutineContext
import kotlinx.coroutines.delay
import kotlinx.coroutines.ensureActive
@@ -150,22 +149,6 @@ internal fun releaseOutgoingLiveZapPlayback(
clearPreload()
}
-internal fun shouldPreloadAdjacentChannel(
- streamUrl: String,
- providerType: ProviderType?,
- maxConnections: Int,
- preloadCoolingDown: Boolean
-): Boolean {
- if (streamUrl.isBlank() || preloadCoolingDown) return false
- return when (providerType) {
- ProviderType.M3U -> true
- ProviderType.JELLYFIN -> true
- ProviderType.XTREAM_CODES,
- ProviderType.STALKER_PORTAL -> maxConnections >= 2
- null -> false
- }
-}
-
fun PlayerViewModel.playNext() {
clearNumericChannelInput()
if (channelList.isEmpty()) return
@@ -319,8 +302,6 @@ internal fun PlayerViewModel.changeChannel(index: Int, isAutoFallback: Boolean =
.first()
}
- preloadAdjacentChannel(index)
-
requestEpg(
providerId = currentProviderId,
epgChannelId = channel.epgChannelId,
@@ -337,36 +318,6 @@ internal fun PlayerViewModel.changeChannel(index: Int, isAutoFallback: Boolean =
if (currentContentType == ContentType.LIVE && !isAutoFallback) scheduleZapBufferWatchdog(index)
}
-internal fun PlayerViewModel.preloadAdjacentChannel(currentIndex: Int) {
- if (channelList.size < 2) return
- val nextIndex = (currentIndex + 1) % channelList.size
- val nextChannel = channelList[nextIndex]
- if (nextChannel.streamUrl.isBlank()) {
- clearPreloadWindow()
- return
- }
- playbackSessionScope()?.launch {
- val provider = playerProviderCoordinator.getProvider(nextChannel.providerId)
- if (!shouldPreloadAdjacentChannel(
- streamUrl = nextChannel.streamUrl,
- providerType = provider?.type,
- maxConnections = provider?.maxConnections ?: 1,
- preloadCoolingDown = playerRecoveryCoordinator.isLivePreloadCoolingDown(nextChannel.providerId)
- )
- ) {
- clearPreloadWindow()
- return@launch
- }
- val streamInfo = resolvePlaybackStreamInfo(
- nextChannel.streamUrl,
- nextChannel.id,
- nextChannel.providerId,
- ContentType.LIVE
- ) ?: return@launch
- playerEngine.preload(streamInfo)
- }
-}
-
internal fun PlayerViewModel.recordLivePlayback(channel: com.streamvault.domain.model.Channel) {
recordActiveLivePlayback(channel)
}
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/SeekThumbnailProvider.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/SeekThumbnailProvider.kt
index d1327f87..e1f01902 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/SeekThumbnailProvider.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/SeekThumbnailProvider.kt
@@ -6,16 +6,23 @@ import android.media.MediaMetadataRetriever
import android.net.Uri
import android.util.LruCache
import dagger.hilt.android.qualifiers.ApplicationContext
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withTimeoutOrNull
+import okhttp3.OkHttpClient
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
import kotlin.math.roundToInt
@Singleton
class SeekThumbnailProvider @Inject constructor(
- @param:ApplicationContext private val context: Context
+ @param:ApplicationContext private val context: Context,
+ private val okHttpClient: OkHttpClient
) {
companion object {
private const val FRAME_BUCKET_MS = 10_000L
@@ -43,39 +50,78 @@ class SeekThumbnailProvider @Inject constructor(
return scheme == null || scheme in setOf("http", "https", "file", "content")
}
- suspend fun loadFrame(streamUrl: String, positionMs: Long): Bitmap? = withContext(Dispatchers.IO) {
+ suspend fun loadFrame(
+ streamUrl: String,
+ positionMs: Long,
+ requestHeaders: Map<String, String> = emptyMap()
+ ): Bitmap? {
if (!supportsFrameExtraction(streamUrl)) {
- return@withContext null
+ return null
}
val bucketPosition = bucketPositionMs(positionMs)
val cacheKey = "$streamUrl#$bucketPosition"
- bitmapCache.get(cacheKey)?.let { return@withContext it }
+ bitmapCache.get(cacheKey)?.let { return it }
+
+ val bitmap = withTimeoutOrNull(RETRIEVER_TIMEOUT_MS) {
+ extractFrameCancellable(streamUrl, requestHeaders, bucketPosition)
+ }
+ if (bitmap != null) bitmapCache.put(cacheKey, bitmap)
+ return bitmap
+ }
+
+ private suspend fun extractFrameCancellable(
+ streamUrl: String,
+ requestHeaders: Map<String, String>,
+ bucketPositionMs: Long
+ ): Bitmap? = suspendCancellableCoroutine { continuation ->
+ val activeAttempt = AtomicReference<ActiveRetrieverAttempt?>()
+ continuation.invokeOnCancellation { activeAttempt.get()?.cancelNetworkReads() }
+
+ Dispatchers.IO.dispatch(continuation.context, Runnable {
+ if (!continuation.isActive) return@Runnable
+
+ val uri = Uri.parse(streamUrl)
+ val dataSource = when (uri.scheme?.lowercase()) {
+ "http", "https" -> CancellableHttpMediaDataSource(
+ url = streamUrl,
+ baseClient = okHttpClient,
+ headers = requestHeaders,
+ callTimeoutMs = RETRIEVER_TIMEOUT_MS
+ )
+ else -> null
+ }
+ val attempt = ActiveRetrieverAttempt(MediaMetadataRetriever(), dataSource)
+ activeAttempt.set(attempt)
+ if (!continuation.isActive) {
+ attempt.cancelNetworkReads()
+ attempt.release()
+ activeAttempt.compareAndSet(attempt, null)
+ return@Runnable
+ }
- // withTimeoutOrNull guards against MediaMetadataRetriever.setDataSource() hanging
- // indefinitely on a remote HTTP URL (e.g. a live stream with no file extension).
- withTimeoutOrNull(RETRIEVER_TIMEOUT_MS) {
- val retriever = MediaMetadataRetriever()
try {
- val uri = Uri.parse(streamUrl)
+ val retriever = attempt.retriever
when (uri.scheme?.lowercase()) {
"content", "file" -> retriever.setDataSource(context, uri)
- else -> retriever.setDataSource(streamUrl, emptyMap())
+ "http", "https" -> retriever.setDataSource(requireNotNull(dataSource))
+ else -> retriever.setDataSource(streamUrl, requestHeaders)
}
- val rawBitmap = retriever.getFrameAtTime(bucketPosition * 1000L, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
- ?: retriever.getFrameAtTime(bucketPosition * 1000L)
- ?: return@withTimeoutOrNull null
-
- val scaledBitmap = rawBitmap.scaleDown(MAX_PREVIEW_WIDTH)
- bitmapCache.put(cacheKey, scaledBitmap)
- scaledBitmap
+ val frameTimeUs = bucketPositionMs * 1000L
+ val rawBitmap = retriever.getFrameAtTime(frameTimeUs, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+ ?: retriever.getFrameAtTime(frameTimeUs)
+ val scaledBitmap = rawBitmap?.scaleDown(MAX_PREVIEW_WIDTH)
+ if (continuation.isActive) continuation.resume(scaledBitmap)
+ } catch (error: CancellationException) {
+ if (continuation.isActive) continuation.resumeWithException(error)
} catch (_: Exception) {
- null
+ if (continuation.isActive) continuation.resume(null)
} finally {
- runCatching { retriever.release() }
+ activeAttempt.compareAndSet(attempt, null)
+ attempt.release()
}
- }
+ })
}
fun clearCache() {
@@ -87,4 +133,21 @@ class SeekThumbnailProvider @Inject constructor(
val scaledHeight = (height * (maxWidth.toFloat() / width.toFloat())).roundToInt().coerceAtLeast(1)
return Bitmap.createScaledBitmap(this, maxWidth, scaledHeight, true)
}
+
+ private class ActiveRetrieverAttempt(
+ val retriever: MediaMetadataRetriever,
+ private val dataSource: CancellableHttpMediaDataSource?
+ ) {
+ private val released = AtomicBoolean(false)
+
+ fun cancelNetworkReads() {
+ dataSource?.close()
+ }
+
+ fun release() {
+ if (!released.compareAndSet(false, true)) return
+ cancelNetworkReads()
+ runCatching { retriever.release() }
+ }
+ }
}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/multiview/MultiViewViewModelTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/multiview/MultiViewViewModelTest.kt
index 4bb60124..3c625e08 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/multiview/MultiViewViewModelTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/multiview/MultiViewViewModelTest.kt
@@ -59,6 +59,7 @@ class MultiViewViewModelTest {
whenever(preferences.playerAudioVideoSyncEnabled).thenReturn(flowOf(false))
whenever(preferences.playerAudioVideoOffsetMs).thenReturn(flowOf(0))
whenever(preferences.getMultiViewPreset(any())).thenReturn(flowOf(emptyList()))
+ whenever(preferences.multiViewPerformanceMode).thenReturn(flowOf(null))
whenever(preferences.multiViewCenterTwoSlotLayout).thenReturn(flowOf(false))
whenever(preferences.multiViewRespectProviderConnectionLimit).thenReturn(flowOf(false))
whenever(preferences.parentalControlLevel).thenReturn(flowOf(0))
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeContentResolverTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeContentResolverTest.kt
new file mode 100644
index 00000000..a91e4f15
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeContentResolverTest.kt
@@ -0,0 +1,46 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.Episode
+import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.Series
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.provider.PlayerPlaybackResolver
+import com.streamvault.domain.repository.ChannelRepository
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.SeriesRepository
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class PlayerEpisodeContentResolverTest {
+ private val seriesRepository = mock<SeriesRepository>()
+ private val resolver = PlayerContentResolver(mock<ChannelRepository>(), mock<MovieRepository>(),
+ seriesRepository, mock<PlayerPlaybackResolver>())
+
+ @Test
+ fun rawLookupDoesNotHydrate() = runTest {
+ val series = Series(id = 17, name = "Drama", providerId = 7)
+ whenever(seriesRepository.getSeriesById(17)).thenReturn(series)
+ whenever(seriesRepository.getSeriesVariants(17)).thenReturn(emptyList())
+ whenever(seriesRepository.hasExplicitSeriesVariantSelection(17)).thenReturn(false)
+ assertThat(resolver.getRawSeries(17)).isEqualTo(series)
+ assertThat(resolver.getSeriesVariants(17)).isEmpty()
+ assertThat(resolver.hasExplicitSeriesVariantSelection(17)).isFalse()
+ verify(seriesRepository, never()).getSeriesDetails(any(), any(), any())
+ }
+
+ @Test
+ fun episodeStreamResolutionUsesVerifiedEpisode() = runTest {
+ val episode = Episode(id = 18, title = "Drama S01E02 720p AVC", seasonNumber = 1,
+ episodeNumber = 2, seriesId = 17, providerId = 7)
+ val info = StreamInfo(url = "http://fixture.invalid/18.mp4")
+ whenever(seriesRepository.getEpisodeStreamInfo(episode)).thenReturn(Result.success(info))
+ assertThat(resolver.getEpisodeStreamInfo(episode).getOrNull()).isEqualTo(info)
+ verify(seriesRepository).getEpisodeStreamInfo(episode)
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicyTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicyTest.kt
new file mode 100644
index 00000000..0e485f28
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackPolicyTest.kt
@@ -0,0 +1,105 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.*
+import org.junit.Test
+
+class PlayerEpisodeFallbackPolicyTest {
+ private val sourceEpisode = Episode(101, "Drama S01E02 1080p HEVC", 2, 1,
+ durationSeconds = 180, seriesId = 10, providerId = 7)
+ private val candidateEpisode = sourceEpisode.copy(id = 201, seriesId = 20,
+ title = "Drama S01E02 720p AVC")
+ private fun series(id: Long, name: String, episodes: List<Episode>) = Series(id, name,
+ providerId = 7, tmdbId = 5000, seasons = listOf(Season(1, episodes = episodes)))
+ private val original = series(10, "Drama 1080p", listOf(sourceEpisode))
+ private val candidate = series(20, "Drama 720p", listOf(candidateEpisode))
+ private fun source() = EpisodeFallbackSource(original, sourceEpisode,
+ StreamInfo("http://fixture.invalid/101.mp4", streamType = StreamType.PROGRESSIVE,
+ playbackContentKind = PlaybackContentKind.ON_DEMAND), "video/hevc", 1080, 60000, 180000)
+
+ @Test fun matchingExplicitIdentitySelectsAvc() {
+ assertThat(selectEpisodeFallbackSeries(source(), listOf(original, candidate))).isEqualTo(candidate)
+ assertThat(verifyEpisodeFallback(source(), candidate)).isEqualTo(candidateEpisode)
+ }
+
+ @Test fun ambiguousOrDerivedIdentityRejected() {
+ for (title in listOf("Drama 720p AVC", "Drama S01E03 720p AVC", "Drama S00E02 720p AVC",
+ "Drama S01E02-E03 720p AVC", "Drama S01E02E03 720p AVC", "Drama S01E02 E03 720p AVC",
+ "Drama S01E02-S01E03 720p AVC", "Other S01E02 720p AVC")) {
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(title = title))))))).isNull()
+ }
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode, candidateEpisode.copy(id = 202))))))).isNull()
+ assertThat(verifyEpisodeFallback(source().copy(series = original.copy(seasons = listOf(
+ Season(1, episodes = listOf(sourceEpisode, sourceEpisode.copy(id = 102)))))), candidate)).isNull()
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(episodeNumber = 3))))))).isNull()
+ }
+
+ @Test fun rawMembershipAndTmdbRequired() {
+ for (wrong in listOf(candidate.copy(providerId = 8), candidate.copy(tmdbId = null),
+ candidate.copy(tmdbId = 6000), candidate.copy(name = "Other 720p"))) {
+ assertThat(selectEpisodeFallbackSeries(source(), listOf(original, wrong))).isNull()
+ assertThat(verifyEpisodeFallback(source(), wrong)).isNull()
+ }
+ assertThat(selectEpisodeFallbackSeries(source(), listOf(candidate))).isNull()
+ assertThat(verifyEpisodeFallback(source().copy(series = original.copy(tmdbId = null)), candidate)).isNull()
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(providerId = 8))))))).isNull()
+ }
+
+ @Test fun measuredSourceFormatWins() {
+ assertThat(selectEpisodeFallbackSeries(source().copy(codecHint = "video/av01"), listOf(original, candidate))).isNull()
+ assertThat(selectEpisodeFallbackSeries(source().copy(codecHint = "video/avc"), listOf(original, candidate))).isNull()
+ assertThat(selectEpisodeFallbackSeries(source().copy(heightHint = 480), listOf(original, candidate))).isNull()
+ assertThat(verifyEpisodeFallback(source().copy(codecHint = null, heightHint = null), candidate)).isNotNull()
+ for (title in listOf("Drama S01E02 720p", "Drama S01E02 720p AVC HEVC",
+ "Drama S01E02 720p 1080p AVC", "Drama S01E02 2160p AVC")) {
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(title = title))))))).isNull()
+ }
+ }
+
+ @Test fun candidateOrderingIsDeterministic() {
+ val sameHeight = candidate.copy(id = 19)
+ val lower = candidate.copy(id = 21, name = "Drama 480p")
+ val higher = candidate.copy(id = 22, name = "Drama 2160p")
+ assertThat(selectEpisodeFallbackSeries(source(), listOf(original, candidate, lower, higher, sameHeight))).isEqualTo(sameHeight)
+ }
+
+ @Test fun codecOnlyInEpisodeIsVerifiedAfterHydration() {
+ assertThat(selectEpisodeFallbackSeries(source(), listOf(original, candidate.copy(seasons = emptyList())))).isNotNull()
+ assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = emptyList()))).isNull()
+ assertThat(verifyEpisodeFallback(source(), candidate)).isNotNull()
+ }
+
+ @Test fun invalidSourceIdentityRejectedBeforeCandidateLookup() {
+ assertThat(selectEpisodeFallbackSeries(source().copy(episode = sourceEpisode.copy(title = "Drama HEVC")), listOf(original, candidate))).isNull()
+ assertThat(selectEpisodeFallbackSeries(source().copy(series = original.copy(seasons = listOf(
+ Season(1, episodes = listOf(sourceEpisode, sourceEpisode.copy(id = 102)))))), listOf(original, candidate))).isNull()
+ for (shorthand in listOf("S01E02/03", "S01E02 & 03", "S01E02 + 03", "S01E02,03")) {
+ val episode = sourceEpisode.copy(title = "Drama $shorthand 1080p HEVC")
+ val source = source().copy(episode = episode, series = original.copy(seasons = listOf(Season(1, episodes = listOf(episode)))))
+ val details = candidate.copy(seasons = listOf(Season(1, episodes = listOf(candidateEpisode.copy(title = "Drama $shorthand 720p AVC")))))
+ assertThat(selectEpisodeFallbackSeries(source, listOf(original, candidate))).isNull()
+ assertThat(verifyEpisodeFallback(source, details)).isNull()
+ }
+ }
+
+ @Test fun durationAndEndGuardBoundaries() {
+ for (seconds in listOf(178, 182)) assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(durationSeconds = seconds))))))).isNotNull()
+ for (seconds in listOf(0, 177, 183)) assertThat(verifyEpisodeFallback(source(), candidate.copy(seasons = listOf(
+ Season(1, episodes = listOf(candidateEpisode.copy(durationSeconds = seconds))))))).isNull()
+ assertThat(verifyEpisodeFallback(source().copy(positionMs = 165000), candidate)).isNotNull()
+ for (position in listOf(-1L, 165001L)) assertThat(verifyEpisodeFallback(source().copy(positionMs = position), candidate)).isNull()
+ assertThat(verifyEpisodeFallback(source().copy(durationMs = 0), candidate)).isNull()
+ for (kind in listOf(PlaybackContentKind.LIVE, PlaybackContentKind.CATCH_UP, PlaybackContentKind.UNKNOWN)) {
+ assertThat(selectEpisodeFallbackSeries(source().let { it.copy(streamInfo = it.streamInfo.copy(playbackContentKind = kind)) }, listOf(original, candidate))).isNull()
+ }
+ for (type in listOf(StreamType.HLS, StreamType.DASH, StreamType.MPEG_TS, StreamType.RTSP)) {
+ assertThat(selectEpisodeFallbackSeries(source().let { it.copy(streamInfo = it.streamInfo.copy(streamType = type)) }, listOf(original, candidate))).isNull()
+ }
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupportTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupportTest.kt
new file mode 100644
index 00000000..e47653ea
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeFallbackSupportTest.kt
@@ -0,0 +1,156 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.*
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.kotlin.*
+
+class PlayerEpisodeFallbackSupportTest {
+ private val originalEpisode = Episode(101, "Drama S01E02 1080p HEVC", 2, 1,
+ durationSeconds = 240, providerId = 7, seriesId = 10)
+ private val original = Series(10, "Drama 1080p", providerId = 7, tmdbId = 5000,
+ seasons = listOf(Season(1, episodes = listOf(originalEpisode))))
+ private val candidateEpisode = originalEpisode.copy(id = 201, seriesId = 20, title = "Drama S01E02 720p AVC")
+ private val candidate = original.copy(id = 20, name = "Drama 720p",
+ seasons = listOf(Season(1, episodes = listOf(candidateEpisode))))
+ private val info = StreamInfo("https://fixture.invalid/avc.mp4", playbackContentKind = PlaybackContentKind.ON_DEMAND)
+
+ private suspend fun fixture(): Pair<PlayerContentResolver, Port> {
+ val resolver = mock<PlayerContentResolver>()
+ whenever(resolver.hasExplicitSeriesVariantSelection(10)).thenReturn(false)
+ whenever(resolver.getRawSeries(10)).thenReturn(original.copy(seasons = emptyList()))
+ whenever(resolver.getRawSeries(20)).thenReturn(candidate.copy(seasons = emptyList()))
+ whenever(resolver.getSeriesVariants(10)).thenReturn(listOf(
+ variant(original), variant(candidate)))
+ whenever(resolver.getSeriesDetails(7, 20)).thenReturn(Result.success(candidate))
+ whenever(resolver.getEpisodeStreamInfo(candidateEpisode)).thenReturn(Result.success(info))
+ return resolver to Port()
+ }
+
+ private fun variant(series: Series) = VodSeriesVariant(series.id, series.name, series.id,
+ null, null, series.tmdbId, null, 0f, 0, 0, 0, 0, series.name)
+
+ private inner class Port : EpisodeFallbackPort {
+ override val state = PlayerEpisodeSourceState().apply { reset(1) }
+ override val source = EpisodeFallbackSource(original, originalEpisode,
+ info.copy(url = "https://fixture.invalid/hevc.mp4"), "video/hevc", 1080, 60000, 240000)
+ override var manualVideo = false
+ val events = mutableListOf<String>()
+ var prepareResult = true
+ var prepareCount = 0
+ var seekPosition = -1L
+ var onPrepare: () -> Unit = {}
+ override fun isCurrent(token: EpisodeSourceToken) = state.isCurrent(token)
+ override fun stopFailedSource() { events += "clear-preload"; events += "stop" }
+ override suspend fun prepare(info: StreamInfo, token: EpisodeSourceToken): Boolean {
+ prepareCount++; events += "prepare"; onPrepare(); return prepareResult
+ }
+ override fun seekAndPlay(positionMs: Long) { seekPosition = positionMs; events += "seek-play" }
+ override fun failure(message: String) { events += "failure:$message" }
+ override fun recovered() { events += "notice" }
+ }
+
+ @Test fun stopAndPreloadClearPrecedeCandidateLookup() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.getSeriesDetails(7, 20)).thenAnswer {
+ assertThat(port.events).containsExactly("clear-preload", "stop").inOrder()
+ port.events += "lookup"; Result.success(candidate)
+ }
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.Recovered)
+ assertThat(port.events).containsExactly("clear-preload", "stop", "lookup", "prepare", "seek-play", "notice").inOrder()
+ assertThat(port.seekPosition).isEqualTo(60000L)
+ assertThat(port.state.source(port.state.token)?.episode).isEqualTo(candidateEpisode)
+ }
+
+ @Test fun oneCandidateDespiteLookupOrPrepareFailure() = runTest {
+ for (lookupFails in listOf(true, false)) {
+ val (resolver, port) = fixture()
+ if (lookupFails) whenever(resolver.getSeriesDetails(7, 20)).thenReturn(Result.error("lookup failed"))
+ else port.prepareResult = false
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.NotEligible)
+ verify(resolver, times(1)).getSeriesDetails(7, 20)
+ assertThat(port.prepareCount).isEqualTo(if (lookupFails) 0 else 1)
+ assertThat(port.state.progressSnapshot(port.state.token, 0, 0)).isEqualTo(60000L to 240000L)
+ }
+ }
+
+ @Test fun manualChoiceBeforeLookupBlocks() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.hasExplicitSeriesVariantSelection(10)).thenReturn(true)
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.NotEligible)
+ verify(resolver, never()).getSeriesDetails(any(), any())
+ assertThat(port.events).isEmpty()
+ port.manualVideo = true
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.NotEligible)
+ }
+
+ @Test fun manualTrackChosenDuringLookupBlocksPrepare() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.getSeriesDetails(7, 20)).thenAnswer { port.manualVideo = true; Result.success(candidate) }
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.prepareCount).isEqualTo(0)
+ }
+
+ @Test fun newRequestDuringEachAwaitCannotPublish() = runTest {
+ for (boundary in listOf("details", "stream", "prepare")) {
+ val (resolver, port) = fixture()
+ if (boundary == "details") whenever(resolver.getSeriesDetails(7, 20)).thenAnswer { port.state.reset(2); Result.success(candidate) }
+ if (boundary == "stream") whenever(resolver.getEpisodeStreamInfo(candidateEpisode)).thenAnswer { port.state.reset(2); Result.success(info) }
+ if (boundary == "prepare") {
+ port.onPrepare = { port.state.reset(2) }
+ }
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.seekPosition).isEqualTo(-1L)
+ assertThat(port.state.token.requestVersion).isEqualTo(2L)
+ assertThat(port.state.source(port.state.token)).isNull()
+ }
+ }
+
+ @Test fun finalAdaptiveSourceRejectedBeforePrepare() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.getEpisodeStreamInfo(candidateEpisode)).thenReturn(Result.success(
+ info.copy(url = "https://fixture.invalid/avc.m3u8")))
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.prepareCount).isEqualTo(0)
+ }
+
+ @Test fun terminalCandidateErrorsRemainTerminal() = runTest {
+ for (message in listOf("HTTP 401", "subscription expired", "DRM failure", "HTTP 509")) {
+ val (resolver, port) = fixture()
+ whenever(resolver.getEpisodeStreamInfo(candidateEpisode)).thenReturn(Result.error(message))
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.events.last()).isEqualTo("failure:$message")
+ assertThat(port.prepareCount).isEqualTo(0)
+ assertThat(port.state.attempted).isTrue()
+ }
+ }
+
+ @Test fun savedChoiceDuringLookupBlocksPrepare() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.hasExplicitSeriesVariantSelection(10)).thenReturn(false, true)
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.prepareCount).isEqualTo(0)
+ }
+
+ @Test fun asynchronousCandidateFailureCannotSeekOrPlay() = runTest {
+ val (resolver, port) = fixture()
+ port.onPrepare = { port.state.markFailed(port.state.token) }
+ assertThat(runEpisodeFallback(resolver, port)).isEqualTo(EpisodeFallbackResult.HandledFailure)
+ assertThat(port.seekPosition).isEqualTo(-1L)
+ }
+
+ @Test fun cancelDoesNotRollbackNewSource() = runTest {
+ val (resolver, port) = fixture()
+ whenever(resolver.getSeriesDetails(7, 20)).thenAnswer {
+ port.state.reset(2)
+ throw kotlinx.coroutines.CancellationException("new content")
+ }
+ try { runEpisodeFallback(resolver, port); org.junit.Assert.fail("Cancellation must propagate") }
+ catch (_: kotlinx.coroutines.CancellationException) { }
+ assertThat(port.state.token.requestVersion).isEqualTo(2L)
+ assertThat(port.events).containsExactly("clear-preload", "stop").inOrder()
+ assertThat(port.prepareCount).isEqualTo(0)
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceIntegrationTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceIntegrationTest.kt
new file mode 100644
index 00000000..1fedf39c
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceIntegrationTest.kt
@@ -0,0 +1,65 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.*
+import com.streamvault.domain.repository.*
+import com.streamvault.domain.provider.PlayerPlaybackResolver
+import org.mockito.kotlin.*
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class PlayerEpisodeSourceIntegrationTest {
+ @Test fun renewalResolvesPhysicalEpisode() = runTest {
+ val repository = mock<SeriesRepository>()
+ val episode = Episode(201, "Drama S01E02 720p AVC", 2, 1,
+ seriesId = 20, providerId = 7, streamUrl = "xtream://fixture/episode/201")
+ val series = Series(20, "Drama 720p", providerId = 7)
+ val physical = PhysicalEpisodeSource(EpisodeSourceToken(1, 2), series, episode)
+ val info = StreamInfo("https://fixture.invalid/renewed-avc.mp4", title = "Drama S01E02 720p AVC")
+ whenever(repository.getEpisodeStreamInfo(episode)).thenReturn(Result.success(info))
+ val resolver = PlayerContentResolver(mock(), mock(), repository, mock<PlayerPlaybackResolver>())
+ val result = resolver.resolvePhysicalEpisodeStream(physical, "Logical Drama")
+ assertThat(result.streamInfo?.url).isEqualTo(info.url)
+ assertThat(result.streamInfo?.title).isEqualTo("Logical Drama")
+ assertThat(result.streamInfo?.playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ verify(repository).getEpisodeStreamInfo(episode)
+ verify(repository, never()).getEpisodeById(any())
+ }
+
+ @Test fun logicalHistoryAndNavigationRemainOriginal() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ state.stage(token, Series(20, "Drama 720p"), Episode(201, "S01E02 AVC", 2, 1))
+ val logical = Episode(101, "Drama S01E02 HEVC", 2, 1, seriesId = 10, providerId = 7)
+ val progress = state.progressSnapshot(token, 0, 0)!!
+ val history = buildPlaybackHistorySnapshot(progress.first, progress.second,
+ currentContentId = 101, currentProviderId = 7, currentContentType = ContentType.SERIES_EPISODE,
+ currentTitle = "Logical Drama", currentArtworkUrl = null, currentStreamUrl = "logical-hevc",
+ currentSeriesId = 10, currentEpisode = logical, currentSeasonNumber = 1, currentEpisodeNumber = 2)
+ assertThat(history?.contentId).isEqualTo(101L)
+ assertThat(history?.seriesId).isEqualTo(10L)
+ assertThat(history?.streamUrl).isEqualTo("logical-hevc")
+ assertThat(history?.resumePositionMs).isEqualTo(60000L)
+ assertThat(buildEpisodePreloadNeighbors(Series(10, "Drama", seasons = listOf(
+ Season(1, episodes = listOf(logical, logical.copy(id = 102, episodeNumber = 3))))), logical)
+ ?.map { it.id }).containsExactly(101L, 102L).inOrder()
+ }
+
+ @Test fun lifecycleFlushDuringRecoveryKeepsSnapshot() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 61000, 180000)!!
+ val capturedAtDisposal = state.progressSnapshot(token, 0, 0)
+ state.reset(2)
+ assertThat(capturedAtDisposal).isEqualTo(61000L to 180000L)
+ assertThat(state.progressSnapshot(token, 0, 0)).isNull()
+ }
+
+ @Test fun resolvedUrlReplacementKeepsCapturedLogicalSession() {
+ val logical = "xtream://fixture/episode/101"
+ val identity = episodeRecoveryIdentity(logical, "https://fixture.invalid/hevc.mp4")
+ assertThat(matchesActivePlaybackSession(1, 1, identity,
+ "https://fixture.invalid/avc.mp4", logical)).isTrue()
+ assertThat(matchesActivePlaybackSession(1, 2, identity,
+ "https://fixture.invalid/avc.mp4", logical)).isFalse()
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceStateTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceStateTest.kt
new file mode 100644
index 00000000..d6073a12
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerEpisodeSourceStateTest.kt
@@ -0,0 +1,72 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.Episode
+import com.streamvault.domain.model.Series
+import org.junit.Test
+
+class PlayerEpisodeSourceStateTest {
+ @Test fun failedAttemptIsNotRefunded() {
+ val state = PlayerEpisodeSourceState()
+ val initial = state.reset(1)
+ val reserved = state.reserveFallback(initial, 60000, 180000)!!
+ assertThat(state.isCurrent(initial)).isFalse()
+ assertThat(state.reserveFallback(reserved, 0, 180000)).isNull()
+ assertThat(state.reserveFallback(state.reset(2), 60000, 180000)).isNotNull()
+ }
+
+ @Test fun resetInvalidatesOldGeneration() {
+ val state = PlayerEpisodeSourceState()
+ val old = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ state.reset(2)
+ assertThat(state.isCurrent(old)).isFalse()
+ assertThat(state.stage(old, Series(20, "Drama"), Episode(201, "S01E02", 2, 1))).isFalse()
+ assertThat(state.progressSnapshot(old, 0, 0)).isNull()
+ }
+
+ @Test fun transientZeroKeepsCapturedProgress() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ assertThat(state.progressSnapshot(token, 0, 0)).isEqualTo(60000L to 180000L)
+ assertThat(state.progressSnapshot(token, 1000, 180000)).isEqualTo(60000L to 180000L)
+ }
+
+ @Test fun confirmationRequiresCapturedSeek() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ assertThat(state.confirmResume(token, 60000)).isFalse() // no replacement staged
+ state.stage(token, Series(20, "Drama"), Episode(201, "S01E02", 2, 1))
+ assertThat(state.confirmResume(token, 0)).isFalse()
+ assertThat(state.confirmResume(token, 57999)).isFalse()
+ assertThat(state.confirmResume(token, 58000)).isTrue()
+ assertThat(state.progressSnapshot(token, 62000, 180000)).isEqualTo(62000L to 180000L)
+ }
+
+ @Test fun manualTrackKeepsPhysicalSource() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ val series = Series(20, "Drama")
+ val episode = Episode(201, "S01E02", 2, 1)
+ assertThat(state.stage(token, series, episode)).isTrue()
+ assertThat(state.source(token)).isEqualTo(PhysicalEpisodeSource(token, series, episode))
+ // Reading/staging state is independent of track preference; only reset clears it.
+ assertThat(state.source(token)).isNotNull()
+ state.reset(1)
+ assertThat(state.source(token)).isNull()
+ }
+
+ @Test fun retryPhysicalKeepsCandidateAndConsumedBudget() {
+ val state = PlayerEpisodeSourceState()
+ val token = state.reserveFallback(state.reset(1), 60000, 180000)!!
+ val episode = Episode(201, "S01E02 AVC", 2, 1)
+ state.stage(token, Series(20, "Drama 720p"), episode)
+ state.markFailed(token)
+ val retry = state.retryPhysical(65000, 180000)
+ assertThat(retry).isNotNull()
+ assertThat(state.source(retry!!)?.episode).isEqualTo(episode)
+ assertThat(state.isCurrent(token)).isFalse()
+ assertThat(state.attempted).isTrue()
+ assertThat(state.failed).isFalse()
+ assertThat(state.reserveFallback(retry, 65000, 180000)).isNull()
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupportTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupportTest.kt
new file mode 100644
index 00000000..453d51cc
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerMovieFallbackSupportTest.kt
@@ -0,0 +1,124 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.StreamType
+import com.streamvault.domain.model.VodMovieVariant
+import org.junit.Test
+
+class PlayerMovieFallbackSupportTest {
+
+ @Test
+ fun `selects the best lower AVC variant for the same title`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 1080p HEVC")
+ val lower = variant(id = 12L, name = "Example Film (2021) 720p AVC")
+ val higher = variant(id = 11L, name = "Example Film (2021) 4K AVC")
+ val unrelated = variant(id = 13L, name = "Different Film (2021) 480p AVC")
+
+ val selected = selectAvcMovieFallbackVariant(current, listOf(higher, unrelated, lower))
+
+ assertThat(selected).isEqualTo(lower)
+ }
+
+ @Test
+ fun `rejects AVC candidates with unknown quality`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 4K HEVC")
+ val unknown = variant(id = 11L, name = "Example Film (2021) AVC")
+
+ assertThat(selectAvcMovieFallbackVariant(current, listOf(unknown))).isNull()
+ }
+
+ @Test
+ fun `does not use a provider variant fallback for a non HEVC source`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 1080p AVC")
+ val lower = variant(id = 11L, name = "Example Film (2021) 720p AVC")
+
+ assertThat(selectAvcMovieFallbackVariant(current, listOf(lower))).isNull()
+ }
+
+ @Test
+ fun `allows same resolution when AVC is a codec compatible fallback`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 4K HEVC")
+ val compatible = variant(id = 11L, name = "Example Film (2021) 4K AVC")
+
+ assertThat(selectAvcMovieFallbackVariant(current, listOf(compatible))).isEqualTo(compatible)
+ }
+
+ @Test
+ fun `recognizes dotted codec labels when title only provides the quality`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 1080p H.265")
+ val compatible = variant(
+ id = 11L,
+ name = "Example Film (2021) 720p",
+ label = "720p H.264"
+ )
+
+ assertThat(selectAvcMovieFallbackVariant(current, listOf(compatible))).isEqualTo(compatible)
+ }
+
+ @Test
+ fun `does not switch adaptive sources to a provider variant`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 4K HEVC")
+ val lower = variant(id = 11L, name = "Example Film (2021) 1080p AVC")
+
+ assertThat(
+ selectAvcMovieFallbackVariant(
+ currentMovie = current,
+ variants = listOf(lower),
+ currentStreamType = StreamType.HLS
+ )
+ ).isNull()
+ }
+
+ @Test
+ fun `preserves an explicit provider variant choice`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 4K HEVC")
+ val lower = variant(id = 11L, name = "Example Film (2021) 1080p AVC")
+
+ assertThat(
+ selectAvcMovieFallbackVariant(
+ currentMovie = current,
+ variants = listOf(lower),
+ hasExplicitVariantChoice = true
+ )
+ ).isNull()
+ }
+
+ @Test
+ fun `preserves a manual video track choice`() {
+ val current = movie(id = 10L, name = "Example Film (2021) 4K HEVC")
+ val lower = variant(id = 11L, name = "Example Film (2021) 1080p AVC")
+
+ assertThat(
+ selectAvcMovieFallbackVariant(
+ currentMovie = current,
+ variants = listOf(lower),
+ hasManualVideoTrackChoice = true
+ )
+ ).isNull()
+ }
+
+ private fun movie(id: Long, name: String) = Movie(
+ id = id,
+ name = name,
+ providerId = 1L,
+ streamUrl = "https://provider.invalid/movie/$id.mkv"
+ )
+
+ private fun variant(id: Long, name: String, label: String = name.substringAfterLast(' ')) = VodMovieVariant(
+ rawMovieId = id,
+ name = name,
+ streamUrl = "https://provider.invalid/movie/$id.mkv",
+ streamId = id,
+ containerExtension = "mkv",
+ releaseDate = "2021-01-01",
+ year = "2021",
+ durationSeconds = 5_400,
+ rating = 7.0f,
+ addedAt = id,
+ qualityScore = 0,
+ recencyScore = 0L,
+ reliabilityScore = 0,
+ label = label
+ )
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActionsTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActionsTest.kt
deleted file mode 100644
index 33e9a78e..00000000
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackPreferenceActionsTest.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.streamvault.feature.playback.player
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-
-class PlayerPlaybackPreferenceActionsTest {
-
- @Test
- fun `buildThumbnailPreloadPositions bounds preload near current position`() {
- val positions = buildThumbnailPreloadPositions(
- durationMs = 7 * 60 * 1000L,
- currentPositionMs = 95_000L,
- bucketMs = 10_000L,
- frameBudget = 6
- )
-
- assertThat(positions).containsExactly(90_000L, 100_000L, 80_000L, 110_000L, 70_000L, 120_000L).inOrder()
- }
-
- @Test
- fun `buildThumbnailPreloadPositions caps at media bounds`() {
- val positions = buildThumbnailPreloadPositions(
- durationMs = 25_000L,
- currentPositionMs = 0L,
- bucketMs = 10_000L,
- frameBudget = 6
- )
-
- assertThat(positions).containsExactly(0L, 10_000L, 20_000L).inOrder()
- }
-
- @Test
- fun `shouldStartThumbnailPreload rejects completed and in flight keys`() {
- assertThat(
- shouldStartThumbnailPreload(
- preloadKey = "media-a",
- lastCompletedPreloadKey = "media-a",
- inFlightPreloadKey = null
- )
- ).isFalse()
-
- assertThat(
- shouldStartThumbnailPreload(
- preloadKey = "media-a",
- lastCompletedPreloadKey = null,
- inFlightPreloadKey = "media-a"
- )
- ).isFalse()
-
- assertThat(
- shouldStartThumbnailPreload(
- preloadKey = "media-b",
- lastCompletedPreloadKey = "media-a",
- inFlightPreloadKey = null
- )
- ).isTrue()
- }
-}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupportTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupportTest.kt
index 2212c40f..f4bda8c9 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupportTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackProbeSupportTest.kt
@@ -54,4 +54,44 @@ class PlayerPlaybackProbeSupportTest {
assertThat(skipped).isFalse()
}
+
+ @Test
+ fun `provider probe policy skips live urls and keeps eligible internal vod urls`() {
+ assertThat(
+ shouldProbeProviderStreamUrl(
+ providerType = ProviderType.XTREAM_CODES,
+ url = "http://example.com/live/user/pass/2112.m3u8",
+ hasInternalSource = true,
+ probeAlreadyPassed = false
+ )
+ ).isFalse()
+ assertThat(
+ shouldProbeProviderStreamUrl(
+ providerType = ProviderType.XTREAM_CODES,
+ url = "http://example.com/movie/user/pass/2112.mp4",
+ hasInternalSource = true,
+ probeAlreadyPassed = false
+ )
+ ).isTrue()
+ }
+
+ @Test
+ fun `provider probe policy skips stalker temporary links and reuses passed xtream probes`() {
+ assertThat(
+ shouldProbeProviderStreamUrl(
+ providerType = ProviderType.STALKER_PORTAL,
+ url = "http://example.com/play/live.php?stream=2112&play_token=abc",
+ hasInternalSource = true,
+ probeAlreadyPassed = false
+ )
+ ).isFalse()
+ assertThat(
+ shouldProbeProviderStreamUrl(
+ providerType = ProviderType.XTREAM_CODES,
+ url = "http://example.com/movie/user/pass/2112.mp4",
+ hasInternalSource = true,
+ probeAlreadyPassed = true
+ )
+ ).isFalse()
+ }
}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupportTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupportTest.kt
index b953671f..5291721e 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupportTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPlaybackRecoverySupportTest.kt
@@ -19,6 +19,15 @@ class PlayerPlaybackRecoverySupportTest {
.isEqualTo("Provider rejected playback, likely max connections or bandwidth limit.")
}
+ @Test
+ fun `404 source error is explained as an unavailable stream resource`() {
+ val error = PlayerError.SourceError("Stream resource not found (HTTP 404).")
+
+ assertThat(classifyPlaybackError(error)).isEqualTo(PlayerRecoveryType.SOURCE)
+ assertThat(resolvePlaybackErrorMessage(error))
+ .isEqualTo("This stream resource was not found (HTTP 404). The provider may have removed it.")
+ }
+
@Test
fun `live provider auth retry is limited to managed IPTV providers`() {
assertThat(shouldAttemptProviderAuthRetry(ProviderType.XTREAM_CODES, ContentType.LIVE)).isTrue()
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinatorTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinatorTest.kt
index 0efe47a9..27d76846 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinatorTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreloadWindowCoordinatorTest.kt
@@ -219,6 +219,72 @@ class PlayerPreloadWindowCoordinatorTest {
assertThat(window?.currentIndex).isEqualTo(0)
}
+ @Test
+ fun sameRemoteIdDifferentSeriesHasDistinctPreloadKey() = runTest {
+ val logical = episode(2, 2).copy(episodeId = 99)
+ val replacement = logical.copy(id = 22, seriesId = 20)
+ val series = Series(10, "Drama", providerId = 7,
+ seasons = listOf(Season(1, episodes = listOf(logical))))
+ val physical = PhysicalEpisodeSource(EpisodeSourceToken(1, 2),
+ Series(20, "Drama 720p", providerId = 7), replacement)
+ val item = PlayerPreloadItem("current", StreamInfo("https://fixture.invalid/avc.mp4"),
+ PlayerPreloadContentType.VOD)
+ val window = PlayerPreloadWindowCoordinator(mock(), mock(), mock()).buildEpisodeWindow(
+ current = item, series = series, currentEpisode = logical, providerId = 7,
+ isCurrent = { true }, physicalCurrent = physical)
+ assertThat(window?.items?.single()?.key).isEqualTo("episode:7:series:20:local:22:remote:99")
+ assertThat(window?.items?.single()?.streamInfo).isEqualTo(item.streamInfo)
+ assertThat(window?.currentIndex).isEqualTo(0)
+ }
+
+ @Test
+ fun oldPreloadCallbackCannotRestoreHevc() = runTest {
+ val state = PlayerEpisodeSourceState()
+ val old = state.reset(1)
+ val currentEpisode = episode(2, 2)
+ state.reserveFallback(old, 60000, 180000)
+ val window = PlayerPreloadWindowCoordinator(mock(), mock(), mock()).buildEpisodeWindow(
+ current = PlayerPreloadItem("old", StreamInfo("https://fixture.invalid/hevc.mp4"), PlayerPreloadContentType.VOD),
+ series = Series(10, "Drama", seasons = listOf(Season(1, episodes = listOf(currentEpisode)))),
+ currentEpisode = currentEpisode, providerId = 7, isCurrent = { state.isCurrent(old) })
+ assertThat(window).isNull()
+ }
+
+ @Test
+ fun recoveredPhysicalEpisodeDoesNotOpenNeighborMedia() = runTest {
+ val logical = episode(2, 2)
+ val series = Series(10, "Drama", providerId = 7,
+ seasons = listOf(Season(1, episodes = listOf(episode(1, 1), logical, episode(3, 3)))))
+ val physical = PhysicalEpisodeSource(EpisodeSourceToken(1, 2),
+ Series(20, "Drama 720p", providerId = 7), logical.copy(id = 22, seriesId = 20))
+ val resolver = mock<PlayerContentResolver>()
+ val item = PlayerPreloadItem("current", StreamInfo("https://fixture.invalid/avc.mp4"), PlayerPreloadContentType.VOD)
+ whenever(resolver.resolvePlaybackStream(any(), any(), any(), any(), any(), anyOrNull(), anyOrNull()))
+ .thenReturn(PlayerPlaybackStreamResolution(null))
+ val window = PlayerPreloadWindowCoordinator(resolver, mock(), mock()).buildEpisodeWindow(
+ current = item, series = series, currentEpisode = logical, providerId = 7,
+ isCurrent = { true }, physicalCurrent = physical)
+ assertThat(window?.items).containsExactly(item.copy(key = physicalEpisodePreloadKey(physical)))
+ assertThat(series.seasons.single().episodes.map { it.episodeNumber }).containsExactly(1, 2, 3).inOrder()
+ org.mockito.Mockito.verifyNoInteractions(resolver)
+ }
+
+ @Test
+ fun singleConnectionLogicalEpisodeDoesNotResolveNeighbors() = runTest {
+ val logical = episode(2, 2)
+ val series = Series(10, "Drama", providerId = 7,
+ seasons = listOf(Season(1, episodes = listOf(episode(1, 1), logical, episode(3, 3)))))
+ val resolver = mock<PlayerContentResolver>()
+ whenever(resolver.resolvePlaybackStream(any(), any(), any(), any(), any(), anyOrNull(), anyOrNull()))
+ .thenReturn(PlayerPlaybackStreamResolution(null))
+ val item = PlayerPreloadItem("current", StreamInfo("https://fixture.invalid/hevc.mp4"), PlayerPreloadContentType.VOD)
+ val window = PlayerPreloadWindowCoordinator(resolver, mock(), mock()).buildEpisodeWindow(
+ current = item, series = series, currentEpisode = logical, providerId = 7,
+ isCurrent = { true }, allowNeighborMedia = false)
+ assertThat(window?.items).containsExactly(item.copy(key = episodePreloadKey(7, logical)))
+ org.mockito.Mockito.verifyNoInteractions(resolver)
+ }
+
private fun episode(id: Long, number: Int) = Episode(
id = id,
title = "Episode $id",
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinatorContentKindTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinatorContentKindTest.kt
index c6514e19..508cd3ec 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinatorContentKindTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerPreparationCoordinatorContentKindTest.kt
@@ -14,6 +14,7 @@ import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.settings.PlayerPreferences
import com.streamvault.feature.playback.api.PlaybackStreamPreparer
import com.streamvault.player.PlayerEngine
+import com.streamvault.player.playback.ResolvedStreamType
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import okhttp3.OkHttpClient
@@ -80,5 +81,35 @@ class PlayerPreparationCoordinatorContentKindTest {
val expected = replacement.copy(playbackContentKind = PlaybackContentKind.ON_DEMAND)
assertThat(result).isEqualTo(PlayerPreparationCoordinator.Result.Success(expected, null))
verify(engine).prepare(expected)
+
+ val guarded = coordinator.prepare(
+ PlayerPreparationCoordinator.Request(
+ streamInfo = input,
+ contentType = ContentType.SERIES_EPISODE,
+ providerId = 0L,
+ currentStreamUrl = null,
+ probePassedPlaybackKeys = emptySet(),
+ probeBeforePlayback = false,
+ audioVideoOffsetMs = 0,
+ requiredSourceType = ResolvedStreamType.PROGRESSIVE
+ ), isCurrent = { true })
+ assertThat(guarded).isInstanceOf(PlayerPreparationCoordinator.Result.Failure::class.java)
+ // Exactly the original unguarded call reached the engine; guarded HLS must not.
+ org.mockito.kotlin.verify(engine, org.mockito.kotlin.times(1)).prepare(expected)
+
+ val episodeState = PlayerEpisodeSourceState()
+ val token = episodeState.reset(1)
+ val revision = episodeState.manualVideoRevision
+ var manualVideo = false
+ whenever(preparer.prepare(input)).thenAnswer {
+ manualVideo = true
+ input.copy(url = "https://fixture.invalid/avc.mp4").let { Result.success(it) }
+ }
+ val manualCanceled = coordinator.prepare(
+ PlayerPreparationCoordinator.Request(input, ContentType.SERIES_EPISODE, 0,
+ null, emptySet(), false, 0),
+ isCurrent = { isEpisodePreparationCurrent(episodeState, token, true, manualVideo, revision, true) })
+ assertThat(manualCanceled).isNull()
+ org.mockito.kotlin.verify(engine, org.mockito.kotlin.times(1)).prepare(org.mockito.kotlin.any())
}
}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
index 739f9708..5fc62f76 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
@@ -4,12 +4,16 @@ import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.DecoderMode
import com.streamvault.domain.model.Result
+import com.streamvault.domain.model.Channel
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
import com.streamvault.player.PlayerEngine
import com.streamvault.player.PlayerError
import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.runTest
import org.junit.Test
import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
import org.mockito.kotlin.verify
class PlayerRecoveryExecutionCoordinatorTest {
@@ -48,6 +52,163 @@ class PlayerRecoveryExecutionCoordinatorTest {
verify(port.playerEngine).play()
}
+ @Test
+ fun `live HLS stall without an alternate keeps the current decoder mode`() = runTest {
+ val port = RecordingRecoveryPort()
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val liveHlsError = request(
+ PlayerError.DecoderError(
+ "Video playback stalled. Automatic recovery was not attempted to avoid opening another provider connection."
+ )
+ ).copy(
+ contentType = ContentType.LIVE,
+ currentStreamUrl = "https://example.test/live/channel.m3u8",
+ resolvedStreamInfo = StreamInfo(
+ url = "https://example.test/live/channel.m3u8",
+ streamType = StreamType.HLS
+ ),
+ channel = Channel(id = 1L, name = "Live channel"),
+ livePlaybackReady = true
+ )
+
+ coordinator.handlePlaybackError(liveHlsError, this, port)
+ advanceUntilIdle()
+
+ assertThat(port.alternateStreamCalls).isEqualTo(1)
+ assertThat(port.lastAllowXtreamTsFallback).isFalse()
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isFalse()
+ assertThat(port.notices).isEmpty()
+ verify(port.playerEngine, never()).setDecoderModes(DecoderMode.SOFTWARE, DecoderMode.SOFTWARE)
+ verify(port.playerEngine, never()).play()
+ }
+
+ @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+ @Test
+ fun `live HLS URL with unknown provider stream type keeps the current decoder mode`() = runTest {
+ val port = RecordingRecoveryPort()
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val liveHlsError = request(PlayerError.DecoderError("Video playback stalled."))
+ .copy(
+ contentType = ContentType.LIVE,
+ currentStreamUrl = "https://example.test/live/channel.m3u8?token=abc",
+ resolvedStreamInfo = StreamInfo(
+ url = "https://example.test/live/channel.m3u8?token=abc",
+ streamType = StreamType.UNKNOWN
+ ),
+ channel = Channel(id = 1L, name = "Live channel"),
+ livePlaybackReady = true
+ )
+
+ coordinator.handlePlaybackError(liveHlsError, this, port)
+ advanceUntilIdle()
+
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isFalse()
+ assertThat(port.notices).hasSize(1)
+ assertThat(port.notices.single().recoveryType).isEqualTo(PlayerRecoveryType.DECODER)
+ verify(port.playerEngine, never()).setDecoderModes(DecoderMode.SOFTWARE, DecoderMode.SOFTWARE)
+ verify(port.playerEngine, never()).play()
+ }
+
+ @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+ @Test
+ fun `catch-up HLS decoder error uses the non-live decoder fallback`() = runTest {
+ val port = RecordingRecoveryPort()
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val catchUpHlsError = request(PlayerError.DecoderError("Video playback stalled."))
+ .copy(
+ contentType = ContentType.LIVE,
+ currentStreamUrl = "https://example.test/archive/program.m3u8",
+ resolvedStreamInfo = StreamInfo(
+ url = "https://example.test/archive/program.m3u8",
+ streamType = StreamType.HLS,
+ playbackContentKind = com.streamvault.domain.model.PlaybackContentKind.CATCH_UP
+ ),
+ channel = Channel(id = 1L, name = "Archive channel"),
+ isCatchUp = true
+ )
+
+ coordinator.handlePlaybackError(catchUpHlsError, this, port)
+ advanceUntilIdle()
+
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isTrue()
+ verify(port.playerEngine).setDecoderModes(DecoderMode.SOFTWARE, DecoderMode.SOFTWARE)
+ verify(port.playerEngine).play()
+ }
+
+ @Test
+ fun `movie AVC fallback is attempted at most once in a playback session`() = runTest {
+ val port = RecordingRecoveryPort().apply { avcFallbackResult = true }
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val decoderFailure = request(PlayerError.DecoderError("decoder failed"))
+
+ coordinator.handlePlaybackError(decoderFailure, this, port)
+ advanceUntilIdle()
+ coordinator.handlePlaybackError(decoderFailure, this, port)
+ advanceUntilIdle()
+ coordinator.handlePlaybackError(decoderFailure, this, port)
+ advanceUntilIdle()
+
+ assertThat(port.avcFallbackCalls).isEqualTo(1)
+ assertThat(port.recoveryState.retriedWithAvcMovieVariant).isTrue()
+ }
+
+ @Test
+ fun `missing live source tries another stream without enabling TS fallback after ready`() = runTest {
+ val port = RecordingRecoveryPort().apply { alternateStreamResult = true }
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val request = request(PlayerError.SourceError("Stream resource not found (HTTP 404)."))
+ .copy(
+ contentType = ContentType.LIVE,
+ channel = Channel(id = 1L, name = "Live channel"),
+ livePlaybackReady = true
+ )
+
+ coordinator.handlePlaybackError(request, this, port)
+ advanceUntilIdle()
+
+ assertThat(port.alternateStreamCalls).isEqualTo(1)
+ assertThat(port.lastAllowXtreamTsFallback).isFalse()
+ assertThat(port.notices.single().recoveryType).isEqualTo(PlayerRecoveryType.SOURCE)
+ }
+
+ @Test
+ fun episodeSoftwareRetryPrecedesVariant() = runTest {
+ val port = RecordingRecoveryPort().apply { episodeFallbackResult = EpisodeFallbackResult.Recovered }
+ val coordinator = PlayerRecoveryExecutionCoordinator()
+ val failure = request(PlayerError.DecoderError("decoder failed")).copy(contentType = ContentType.SERIES_EPISODE)
+ coordinator.handlePlaybackError(failure, this, port)
+ advanceUntilIdle()
+ assertThat(port.episodeFallbackCalls).isEqualTo(0)
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isTrue()
+ coordinator.handlePlaybackError(failure, this, port)
+ advanceUntilIdle()
+ assertThat(port.episodeFallbackCalls).isEqualTo(1)
+ assertThat(port.avcFallbackCalls).isEqualTo(0)
+ }
+
+ @Test
+ fun handledEpisodeFailureDoesNotFallThroughAuthOrNotice() = runTest {
+ val port = RecordingRecoveryPort().apply {
+ recoveryState.retriedWithSoftwareDecoder = true
+ episodeFallbackResult = EpisodeFallbackResult.HandledFailure
+ }
+ PlayerRecoveryExecutionCoordinator().handlePlaybackError(
+ request(PlayerError.DecoderError("decoder failed")).copy(contentType = ContentType.SERIES_EPISODE), this, port)
+ advanceUntilIdle()
+ assertThat(port.episodeFallbackCalls).isEqualTo(1)
+ assertThat(port.authRefreshCalls).isEqualTo(0)
+ assertThat(port.notices).isEmpty()
+ }
+
+ @Test
+ fun nonDecoderErrorNeverSearchesVariants() = runTest {
+ val port = RecordingRecoveryPort()
+ PlayerRecoveryExecutionCoordinator().handlePlaybackError(
+ request(PlayerError.NetworkError("timeout")).copy(contentType = ContentType.SERIES_EPISODE), this, port)
+ advanceUntilIdle()
+ assertThat(port.episodeFallbackCalls).isEqualTo(0)
+ }
+
private fun request(error: PlayerError) = PlayerRecoveryRequest(
error = error,
requestVersion = 1L,
@@ -66,6 +227,14 @@ class PlayerRecoveryExecutionCoordinatorTest {
override val playerEngine: PlayerEngine = mock()
override val recoveryState = PlayerRecoveryCoordinator()
var active = true
+ var alternateStreamResult = false
+ var alternateStreamCalls = 0
+ var avcFallbackResult = false
+ var avcFallbackCalls = 0
+ var episodeFallbackResult = EpisodeFallbackResult.NotEligible
+ var episodeFallbackCalls = 0
+ var authRefreshCalls = 0
+ var lastAllowXtreamTsFallback: Boolean? = null
val notices = mutableListOf<Notice>()
override fun isActivePlaybackSession(requestVersion: Long, playbackUrl: String): Boolean = active
@@ -74,17 +243,30 @@ class PlayerRecoveryExecutionCoordinatorTest {
channel: com.streamvault.domain.model.Channel,
preferXtreamTsFallback: Boolean,
allowXtreamTsFallback: Boolean
- ): Boolean = false
+ ): Boolean {
+ alternateStreamCalls++
+ lastAllowXtreamTsFallback = allowXtreamTsFallback
+ return alternateStreamResult
+ }
override fun tryNextCatchUpVariant(): Boolean = false
- override suspend fun tryFallbackToAvcMovieVariant(requestVersion: Long, playbackUrl: String): Boolean = false
+ override suspend fun tryFallbackToAvcMovieVariant(requestVersion: Long, playbackUrl: String): Boolean {
+ avcFallbackCalls++
+ if (avcFallbackResult) recoveryState.retriedWithAvcMovieVariant = true
+ return avcFallbackResult
+ }
override suspend fun tryRefreshXtreamPlaybackAfterAuthError(
error: PlayerError,
requestVersion: Long,
playbackUrl: String
- ): Boolean = false
+ ): Boolean { authRefreshCalls++; return false }
+
+ override suspend fun tryFallbackToAvcEpisodeVariant(requestVersion: Long, playbackUrl: String): EpisodeFallbackResult {
+ episodeFallbackCalls++
+ return episodeFallbackResult
+ }
override fun recordMovieVariantFailureObservation(error: PlayerError) = Unit
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinatorTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinatorTest.kt
index 5a424eee..d48c0f58 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinatorTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerThumbnailCoordinatorTest.kt
@@ -42,7 +42,7 @@ class PlayerThumbnailCoordinatorTest {
)
assertThat(result).isSameInstanceAs(bitmap)
- verify(legacyProvider, never()).loadFrame(any(), any())
+ verify(legacyProvider, never()).loadFrame(any(), any(), any())
}
@Test
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTokenRenewalPolicyTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTokenRenewalPolicyTest.kt
new file mode 100644
index 00000000..011524fc
--- /dev/null
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerTokenRenewalPolicyTest.kt
@@ -0,0 +1,108 @@
+package com.streamvault.feature.playback.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.StreamInfo
+import org.junit.Test
+
+class PlayerTokenRenewalPolicyTest {
+
+ @Test
+ fun `expiry and title changes do not require replacing the playback source`() {
+ val current = StreamInfo(
+ url = "https://cdn.example/movie.mp4?token=stable",
+ title = "Movie",
+ expirationTime = 1_000_000L
+ )
+ val refreshed = current.copy(
+ title = "Updated title",
+ expirationTime = 2_000_000L
+ )
+
+ assertThat(isSamePlaybackRequestForRenewal(current, refreshed)).isTrue()
+ }
+
+ @Test
+ fun `changed authorization headers require replacing the playback source`() {
+ val current = StreamInfo(
+ url = "https://cdn.example/movie.mp4",
+ headers = mapOf("Authorization" to "Bearer old"),
+ expirationTime = 1_000_000L
+ )
+ val refreshed = current.copy(
+ headers = mapOf("Authorization" to "Bearer new"),
+ expirationTime = 2_000_000L
+ )
+
+ assertThat(isSamePlaybackRequestForRenewal(current, refreshed)).isFalse()
+ }
+
+ @Test
+ fun `stale refreshed expiry is rejected even when the URL changes`() {
+ val previousExpiry = 1_000_000L
+ val now = 1_000_000L
+
+ assertThat(
+ isUsableTokenRenewalExpiry(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = previousExpiry,
+ nowMs = now
+ )
+ ).isFalse()
+ assertThat(
+ isUsableTokenRenewalExpiry(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = 999_000L,
+ nowMs = now
+ )
+ ).isFalse()
+ assertThat(
+ isUsableTokenRenewalExpiry(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = 1_001_000L,
+ nowMs = now
+ )
+ ).isTrue()
+ assertThat(
+ isUsableTokenRenewalExpiry(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = null,
+ nowMs = now
+ )
+ ).isTrue()
+ }
+
+ @Test
+ fun `next renewal requires a later expiry outside the lead window`() {
+ val previousExpiry = 1_000_000L
+ val now = 1_000_000L
+
+ assertThat(
+ shouldArmNextTokenRenewal(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = 1_121_000L,
+ nowMs = now
+ )
+ ).isTrue()
+ assertThat(
+ shouldArmNextTokenRenewal(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = previousExpiry,
+ nowMs = now
+ )
+ ).isFalse()
+ assertThat(
+ shouldArmNextTokenRenewal(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = 1_059_000L,
+ nowMs = now
+ )
+ ).isFalse()
+ assertThat(
+ shouldArmNextTokenRenewal(
+ previousExpiryTime = previousExpiry,
+ refreshedExpiryTime = Long.MAX_VALUE,
+ nowMs = now
+ )
+ ).isFalse()
+ }
+}
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerZapActionsTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerZapActionsTest.kt
index bc16dd74..8ef0c90d 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerZapActionsTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerZapActionsTest.kt
@@ -1,7 +1,6 @@
package com.streamvault.feature.playback.player
import com.google.common.truth.Truth.assertThat
-import com.streamvault.domain.model.ProviderType
import org.junit.Test
class PlayerZapActionsTest {
@@ -42,63 +41,4 @@ class PlayerZapActionsTest {
assertThat(calls).containsExactly("stopPlayback", "stopLiveTimeshift", "clearPreload").inOrder()
}
- @Test
- fun `shouldPreloadAdjacentChannel skips Stalker internal streams`() {
- val shouldPreload = shouldPreloadAdjacentChannel(
- streamUrl = "stalker://1/live/99?cmd=ffmpeg%20http%3A%2F%2Fportal.example.com%2Fch%2F99",
- providerType = ProviderType.STALKER_PORTAL,
- maxConnections = 1,
- preloadCoolingDown = false
- )
-
- assertThat(shouldPreload).isFalse()
- }
-
- @Test
- fun `shouldPreloadAdjacentChannel skips Xtream live streams`() {
- val shouldPreload = shouldPreloadAdjacentChannel(
- streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.XTREAM_CODES,
- maxConnections = 1,
- preloadCoolingDown = false
- )
-
- assertThat(shouldPreload).isFalse()
- }
-
- @Test
- fun `shouldPreloadAdjacentChannel allows Xtream streams with spare connection budget`() {
- val shouldPreload = shouldPreloadAdjacentChannel(
- streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.XTREAM_CODES,
- maxConnections = 2,
- preloadCoolingDown = false
- )
-
- assertThat(shouldPreload).isTrue()
- }
-
- @Test
- fun `shouldPreloadAdjacentChannel allows M3U streams`() {
- val shouldPreload = shouldPreloadAdjacentChannel(
- streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.M3U,
- maxConnections = 1,
- preloadCoolingDown = false
- )
-
- assertThat(shouldPreload).isTrue()
- }
-
- @Test
- fun `shouldPreloadAdjacentChannel skips streams while provider preload is cooling down`() {
- val shouldPreload = shouldPreloadAdjacentChannel(
- streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.XTREAM_CODES,
- maxConnections = 2,
- preloadCoolingDown = true
- )
-
- assertThat(shouldPreload).isFalse()
- }
}
diff --git a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
index 6ce9dc7f..d5d0244f 100644
--- a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
@@ -4,6 +4,7 @@ import android.app.ActivityManager
import android.content.Context
import android.os.Build
import android.os.Handler
+import android.os.SystemClock
import android.util.Log
import androidx.annotation.MainThread
import androidx.annotation.OptIn
@@ -18,8 +19,6 @@ import androidx.media3.common.Timeline
import androidx.media3.common.Tracks
import androidx.media3.common.util.UnstableApi
import androidx.media3.exoplayer.DecoderReuseEvaluation
-import androidx.media3.exoplayer.DefaultLivePlaybackSpeedControl
-import androidx.media3.exoplayer.DefaultLoadControl
import androidx.media3.exoplayer.DefaultRenderersFactory
import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.exoplayer.Renderer
@@ -27,6 +26,9 @@ import androidx.media3.exoplayer.ScrubbingModeParameters
import androidx.media3.exoplayer.analytics.AnalyticsListener
import androidx.media3.exoplayer.audio.AudioSink
import androidx.media3.exoplayer.audio.AudioRendererEventListener
+import androidx.media3.exoplayer.audio.AudioTrackAudioOutputProvider
+import androidx.media3.exoplayer.audio.DefaultAudioSink
+import androidx.media3.exoplayer.audio.DefaultAudioTrackBufferSizeProvider
import androidx.media3.exoplayer.mediacodec.MediaCodecInfo
import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
import androidx.media3.exoplayer.video.MediaCodecVideoRenderer
@@ -47,21 +49,25 @@ import com.streamvault.domain.model.VideoFormat
import com.streamvault.domain.repository.PlaybackCompatibilityRepository
import com.streamvault.player.audio.PlayerAudioFocusController
import com.streamvault.player.playback.ActiveDecoderPolicy
+import com.streamvault.player.playback.AdaptiveDecodePressurePolicy
+import com.streamvault.player.playback.DecodePressureSample
import com.streamvault.player.playback.DefaultDecoderPreferencePolicy
import com.streamvault.player.playback.DefaultPlaybackCompatibilityProfile
import com.streamvault.player.playback.AudioVideoOffsetAudioSink
import com.streamvault.player.playback.LiveAudioTapAudioSink
+import com.streamvault.player.playback.createLivePlaybackSpeedControl
import com.streamvault.player.playback.PlaybackCodecSelector
import com.streamvault.player.playback.PlaybackCompatibilityProfile
import com.streamvault.player.playback.PlaybackBufferPolicies
import com.streamvault.player.playback.PlaybackBufferPolicy
+import com.streamvault.player.playback.PlaybackLoadControl
+import com.streamvault.player.playback.LiveVideoStallRecovery
import com.streamvault.player.playback.PlaybackErrorCategory
import com.streamvault.player.playback.FfmpegAudioFallbackRequest
import com.streamvault.player.playback.FfmpegExtensionSupport
import com.streamvault.player.playback.InitialBitratePolicy
import com.streamvault.player.playback.PlaybackLogSanitizer
import com.streamvault.player.playback.PlaybackPreparationPlan
-import com.streamvault.player.playback.PlaybackExtensionRendererMode
import com.streamvault.player.playback.PlaybackRetryContext
import com.streamvault.player.playback.PlayerDataSourceFactoryProvider
import com.streamvault.player.playback.PlayerErrorClassifier
@@ -70,28 +76,27 @@ import com.streamvault.player.playback.Media3PreloadWindowManager
import com.streamvault.player.playback.PlayerRetryPolicy
import com.streamvault.player.playback.PlayerTimeoutProfile
import com.streamvault.player.playback.isLivePlayback
-import com.streamvault.player.playback.PreloadCoordinator
import com.streamvault.player.playback.ResolvedStreamType
import com.streamvault.player.playback.resolveRetryAttemptAfterPlaybackStarted
import com.streamvault.player.playback.resolveRetryAttemptAfterReady
-import com.streamvault.player.playback.resolveRetryAttemptForCategory
+import com.streamvault.player.playback.isScheduledAppSourceRetryCurrent
+import com.streamvault.player.playback.resolveNextAppSourceRetryAttempt
import com.streamvault.player.playback.resolveRetrySeekPositionMs
+import com.streamvault.player.playback.resolveScheduledRetrySeekPositionMs
import com.streamvault.player.playback.StreamTypeResolver
import com.streamvault.player.playback.VideoStallDetector
import com.streamvault.player.playback.AutomaticRecoveryAction
-import com.streamvault.player.playback.buildLiveTsFallbackStreamInfo
import com.streamvault.player.playback.buildDecoderReuseWorkaroundEvaluation
import com.streamvault.player.playback.buildPlaybackRendererPlan
+import com.streamvault.player.playback.buildPlaybackRendererFactorySettings
import com.streamvault.player.playback.shouldAttemptAutomaticRecovery
import com.streamvault.player.playback.hasEffectivePlaybackStarted
import com.streamvault.player.playback.shouldArmPlaybackStartedRecovery
-import com.streamvault.player.playback.shouldFallbackMalformedHlsToLiveTs
-import com.streamvault.player.playback.shouldFallbackStalledHlsToLiveTs
import com.streamvault.player.playback.shouldPreservePlaybackStateForRetry
import com.streamvault.player.playback.shouldRecoverFrameSilentReadyStalls
import com.streamvault.player.playback.shouldRecoverPositionAdvancingReadyStalls
import com.streamvault.player.playback.shouldRecoverReadyStalls
-import com.streamvault.player.playback.shouldReconnectLiveStall
+import com.streamvault.player.playback.shouldDeferAppStallRecovery
import com.streamvault.player.playback.shouldForceSoftwareForAmbiguousDecoderFallback
import com.streamvault.player.stats.FrameRateDetector
import com.streamvault.player.stats.PlayerStatsCollector
@@ -102,6 +107,7 @@ import com.streamvault.player.timeshift.LiveTimeshiftState
import com.streamvault.player.timeshift.LiveTimeshiftStatus
import com.streamvault.player.timeshift.TimeshiftConfig
import com.streamvault.player.tracks.PlayerTrackController
+import com.streamvault.player.tracks.AdaptiveDecodePressureTracks
import com.streamvault.player.ui.PlayerViewBinder
import com.streamvault.player.ui.SubtitleStyleController
import dagger.hilt.android.qualifiers.ApplicationContext
@@ -135,7 +141,6 @@ class Media3PlayerEngine @Inject constructor(
companion object {
private const val TAG = "Media3PlayerEngine"
- private const val AUDIO_RENDERER_RECOVERY_COOLDOWN_MS = 15_000L
private const val LEGACY_TEXTURE_VIEW_MAX_SDK = Build.VERSION_CODES.N_MR1
private const val FIRE_TV_MEDIATEK_TEXTURE_VIEW_MAX_SDK = Build.VERSION_CODES.P
private const val TEXTURE_VIEW_STARTUP_TIMEOUT_MS = 9_000L
@@ -220,6 +225,7 @@ class Media3PlayerEngine @Inject constructor(
private var currentResolvedStreamType: ResolvedStreamType = ResolvedStreamType.UNKNOWN
private var currentTimeoutProfile: PlayerTimeoutProfile = PlayerTimeoutProfile.VOD
private var currentRetryPolicy: PlayerRetryPolicy? = null
+ private val preloadPriorityHandler = Handler(context.mainLooper)
private var currentRetryContext: PlaybackRetryContext? = null
private var playbackStarted = false
private var liveBufferingRecoveryArmed = false
@@ -227,12 +233,13 @@ class Media3PlayerEngine @Inject constructor(
private var hasRenderedFirstVideoFrame = false
private var prepareStartMs = 0L
private var retryAttempt = 0
- private var lastRetryCategory: PlaybackErrorCategory? = null
private var retryJob: Job? = null
private var retryGeneration = 0L
+ private var pendingRetrySeekPositionOverrideMs: Long? = null
private var currentBufferIsLive: Boolean? = null
private var currentBufferPolicyLabel: String? = null
private var currentBufferPolicy: PlaybackBufferPolicy? = null
+ private var playbackLoadControl: PlaybackLoadControl? = null
private var audioCodecUnsupportedReported = false
private var lastSupportErrorMessage: String? = null
private val isLowMemoryPlaybackDevice: Boolean = run {
@@ -336,21 +343,25 @@ class Media3PlayerEngine @Inject constructor(
).also {
it.bind { exoPlayer }
}
+ // Media3 passes this meter's listener through MediaSource.prepareSource and attaches it to
+ // media data sources. The provider only attaches our separate byte counter, avoiding duplicate
+ // bandwidth samples that would make adaptive selection overestimate network capacity.
private val dataSourceFactoryProvider =
PlayerDataSourceFactoryProvider(
context = context,
baseClient = okHttpClient,
- transferListener = transferByteCounter,
- additionalTransferListener = bandwidthMeter.transferListener
+ transferListener = transferByteCounter
)
private val mediaSourceFactory = PlayerMediaSourceFactory(dataSourceFactoryProvider)
- private val preloadCoordinator = PreloadCoordinator()
private var preloadWindowManager: Media3PreloadWindowManager? = null
private var pendingPreloadWindow: PlayerPreloadWindow? = null
private val compatibilityProfile: PlaybackCompatibilityProfile = DefaultPlaybackCompatibilityProfile
private val audioDecoderPreferencePolicy = DefaultDecoderPreferencePolicy()
private val videoDecoderPreferencePolicy = DefaultDecoderPreferencePolicy()
private val videoStallDetector = VideoStallDetector()
+ private val liveVideoStallRecovery = LiveVideoStallRecovery()
+ private val adaptiveDecodePressurePolicy = AdaptiveDecodePressurePolicy()
+ private val adaptiveDecodePressureTracks = AdaptiveDecodePressureTracks()
// All reads/writes on Dispatchers.Main.immediate (engine scope).
@get:MainThread private var activeLiveTimeshiftStreamInfo: StreamInfo? = null
@get:MainThread private var activeLiveTimeshiftChannelKey: String? = null
@@ -358,7 +369,6 @@ class Media3PlayerEngine @Inject constructor(
private var pendingTimeshiftSeekMs: Long? = null
private var pendingTimeshiftSeekToEnd: Boolean = false
private var pendingTimeshiftAutoPlay: Boolean = false
- private var lastAudioRendererRecoveryAtMs: Long = 0L
private data class PendingLearnedAudioFallback(
val mediaId: String,
@@ -371,6 +381,46 @@ class Media3PlayerEngine @Inject constructor(
startEngineCollectors()
}
+ private fun clearAdaptiveDecodePressure() {
+ adaptiveDecodePressurePolicy.reset()
+ exoPlayer?.let { player ->
+ val parameters = adaptiveDecodePressureTracks.clear(player.trackSelectionParameters)
+ if (parameters != player.trackSelectionParameters) player.trackSelectionParameters = parameters
+ }
+ }
+
+ private fun updateAdaptiveDecodePressure(timeMs: Long) {
+ val player = exoPlayer ?: return
+ val adaptive = currentResolvedStreamType in setOf(
+ ResolvedStreamType.HLS, ResolvedStreamType.DASH, ResolvedStreamType.SMOOTH_STREAMING
+ )
+ val format = player.videoFormat
+ val context = if (adaptive) adaptiveDecodePressureTracks.context(
+ player.currentTracks, format, player.trackSelectionParameters, trackController.isVideoAutoSelected
+ ) else null
+ val counters = player.videoDecoderCounters
+ if (context == null || counters == null || format == null) {
+ clearAdaptiveDecodePressure()
+ return
+ }
+ counters.ensureUpdated()
+ val change = adaptiveDecodePressurePolicy.observe(DecodePressureSample(
+ timeMs = timeMs, groupKey = context.group, eligible = true,
+ readyAndPlaying = player.isPlaying && player.playbackState == Player.STATE_READY &&
+ !shouldDeferAppStallRecovery(currentRetryPolicy?.hasPendingLoadRecovery == true, retryJob?.isActive == true),
+ bufferedMs = player.totalBufferedDuration,
+ rendered = counters.renderedOutputBufferCount, dropped = counters.droppedBufferCount,
+ height = format.height, bitrate = format.bitrate, renditions = context.renditions
+ )) ?: return
+ val parameters = adaptiveDecodePressureTracks.constrain(player.trackSelectionParameters, context, change.maxHeight, change.maxBitrate ?: Int.MAX_VALUE)
+ if (parameters != player.trackSelectionParameters) player.trackSelectionParameters = parameters
+ if (Log.isLoggable("PlaybackPerf", Log.DEBUG)) {
+ Log.d("PlaybackPerf", "decode-pressure maxHeight=${change.maxHeight ?: "auto"} " +
+ "restorationStableMs=${change.restorationStableMs ?: "n/a"} " +
+ "drops=${counters.droppedBufferCount} rendered=${counters.renderedOutputBufferCount}")
+ }
+ }
+
private fun startEngineCollectors() {
if (isDisposed) return
scope.launch {
@@ -382,6 +432,8 @@ class Media3PlayerEngine @Inject constructor(
while (true) {
delay(1_000L)
val stats = _playerStats.value
+ updateAdaptiveDecodePressure(SystemClock.elapsedRealtime())
+ updateForegroundPreloadPriority()
if (lastStreamInfo != null && Log.isLoggable("PlaybackPerf", Log.DEBUG)) {
Log.d(
"PlaybackPerf",
@@ -395,8 +447,13 @@ class Media3PlayerEngine @Inject constructor(
)
}
val liveStream = isCurrentStreamLive()
+ val selectedVideo = exoPlayer?.currentTracks?.isTypeSelected(C.TRACK_TYPE_VIDEO) == true
val effectivePlaybackStarted = isEffectivelyPlaybackStarted()
val liveBufferingRecoveryEligible = liveStream && effectivePlaybackStarted
+ val appStallRecoveryDeferred = shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = currentRetryPolicy?.hasPendingLoadRecovery == true,
+ sourceRetryPending = retryJob?.isActive == true
+ )
val stalled = videoStallDetector.shouldReportStall(
playbackState = _playbackState.value,
isPlaying = _isPlaying.value,
@@ -404,15 +461,16 @@ class Media3PlayerEngine @Inject constructor(
currentPositionMs = _currentPosition.value,
bufferedDurationMs = stats.bufferedDurationMs,
playWhenReady = exoPlayer?.playWhenReady == true,
- recoverBufferingStalls = liveBufferingRecoveryEligible,
- recoverReadyStalls = liveStream && shouldRecoverReadyStalls(currentResolvedStreamType),
+ recoverBufferingStalls = liveBufferingRecoveryEligible && !appStallRecoveryDeferred,
+ recoverReadyStalls = liveStream && selectedVideo && !appStallRecoveryDeferred &&
+ shouldRecoverReadyStalls(currentResolvedStreamType),
recoverPositionAdvancingReadyStalls =
- liveStream && shouldRecoverPositionAdvancingReadyStalls(
+ liveStream && selectedVideo && !appStallRecoveryDeferred && shouldRecoverPositionAdvancingReadyStalls(
currentResolvedStreamType,
lastStreamInfo?.playbackContentKind ?: PlaybackContentKind.UNKNOWN
),
recoverFrameSilentReadyStalls =
- liveStream && shouldRecoverFrameSilentReadyStalls(
+ liveStream && selectedVideo && !appStallRecoveryDeferred && shouldRecoverFrameSilentReadyStalls(
currentResolvedStreamType,
lastStreamInfo?.playbackContentKind ?: PlaybackContentKind.UNKNOWN
)
@@ -469,6 +527,11 @@ class Media3PlayerEngine @Inject constructor(
override fun renewStreamUrl(streamInfo: StreamInfo) {
if (ensureNotDisposed("renewStreamUrl")) return
val player = exoPlayer ?: return
+ retryJob?.cancel()
+ retryJob = null
+ retryGeneration++
+ pendingRetrySeekPositionOverrideMs = null
+ _retryStatus.value = null
val playbackPlan = buildPlaybackPreparationPlan(
streamInfo = streamInfo,
preload = false,
@@ -482,7 +545,6 @@ class Media3PlayerEngine @Inject constructor(
currentRetryContext = playbackPlan.retryContext
currentRetryPolicy = playbackPlan.retryPolicy
retryAttempt = 0
- lastRetryCategory = null
_retryStatus.value = null
playbackStarted = false
liveBufferingRecoveryArmed = false
@@ -519,7 +581,12 @@ class Media3PlayerEngine @Inject constructor(
}
override fun stop() {
+ clearAdaptiveDecodePressure()
retryJob?.cancel()
+ retryJob = null
+ retryGeneration++
+ pendingRetrySeekPositionOverrideMs = null
+ _retryStatus.value = null
exoPlayer?.stop()
_playbackState.value = PlaybackState.IDLE
_isPlaying.value = false
@@ -536,10 +603,14 @@ class Media3PlayerEngine @Inject constructor(
}
override fun seekTo(positionMs: Long) {
+ adaptiveDecodePressurePolicy.discontinuity()
if (activeLiveTimeshiftStreamInfo != null && !isPlayingTimeshiftSnapshot && _timeshiftState.value.supported) {
switchToTimeshiftSnapshot(positionMs = positionMs.coerceAtLeast(0L), autoPlay = true)
return
}
+ if (_retryStatus.value != null) {
+ pendingRetrySeekPositionOverrideMs = positionMs.coerceAtLeast(0L)
+ }
exoPlayer?.seekTo(positionMs)
}
@@ -637,6 +708,7 @@ class Media3PlayerEngine @Inject constructor(
override fun setResolutionConstrainedForMultiView(constrained: Boolean) {
constrainResolutionForMultiView = constrained
+ playbackLoadControl?.setMultiview(constrained)
}
override fun setFastRetryOnTransientFailures(enabled: Boolean) {
@@ -787,6 +859,7 @@ class Media3PlayerEngine @Inject constructor(
}
override fun setNetworkQualityPreferences(wifiMaxHeight: Int?, ethernetMaxHeight: Int?) {
+ clearAdaptiveDecodePressure()
trackController.setNetworkQualityPreferences(wifiMaxHeight, ethernetMaxHeight)
exoPlayer?.let { player -> trackController.applyInitialParameters(player, constrainResolutionForMultiView) }
}
@@ -796,6 +869,7 @@ class Media3PlayerEngine @Inject constructor(
}
override fun selectVideoTrack(trackId: String) {
+ clearAdaptiveDecodePressure()
exoPlayer?.let { trackController.selectVideoTrack(it, trackId) }
}
@@ -856,32 +930,6 @@ class Media3PlayerEngine @Inject constructor(
}
}
- override fun preload(streamInfo: StreamInfo?) {
- if (streamInfo == null) {
- preloadCoordinator.invalidate("cleared")
- preloadWindowManager?.clearWindow()
- pendingPreloadWindow = null
- Log.i(TAG, "preload-window reset reason=legacy-clear")
- return
- }
- if (streamInfo.url == lastStreamInfo?.url) return
-
- val mediaId = mediaSourceFactory.mediaIdFor(streamInfo)
- val playbackPlan = buildPlaybackPreparationPlan(
- streamInfo = streamInfo,
- preload = true,
- playbackStarted = { false }
- )
- val (_, mediaSource) = mediaSourceFactory.create(
- streamInfo = streamInfo,
- resolvedStreamType = playbackPlan.resolvedStreamType,
- retryPolicy = playbackPlan.retryPolicy,
- vodHttpProtocolMode = requestedVodHttpProtocolMode,
- preload = true
- )
- preloadCoordinator.store(mediaId, streamInfo, playbackPlan.resolvedStreamType, mediaSource)
- }
-
override fun preloadWindow(window: PlayerPreloadWindow) {
val normalized = normalizePlayerPreloadWindow(window)
if (normalized.items.isEmpty()) {
@@ -891,10 +939,8 @@ class Media3PlayerEngine @Inject constructor(
return
}
- // The legacy cache is intended for adjacent live-channel zapping. A VOD or
- // catch-up window must not accidentally reuse that source for another class.
- preloadCoordinator.invalidate("sliding-window")
pendingPreloadWindow = normalized
+ updateForegroundPreloadPriority()
preloadWindowManager?.updateWindow(normalized)
Log.i(
TAG,
@@ -903,6 +949,22 @@ class Media3PlayerEngine @Inject constructor(
)
}
+ override fun clearPreloadWindow() {
+ preloadWindowManager?.clearWindow()
+ pendingPreloadWindow = null
+ }
+
+ private fun updateForegroundPreloadPriority() {
+ val player = exoPlayer
+ preloadWindowManager?.updateForegroundPlayback(
+ state = _playbackState.value,
+ isPlaying = player?.isPlaying == true,
+ bufferedDurationMs = player?.totalBufferedDuration ?: 0L,
+ recovering = retryJob?.isActive == true || _retryStatus.value != null ||
+ currentRetryPolicy?.hasPendingLoadRecovery == true
+ )
+ }
+
override fun createRenderView(
context: Context,
resizeMode: PlayerSurfaceResizeMode,
@@ -931,7 +993,6 @@ class Media3PlayerEngine @Inject constructor(
liveBufferingRecoveryArmed = false
playbackStartedRecoveryArmed = false
retryAttempt = 0
- lastRetryCategory = null
}
override fun release() {
@@ -950,10 +1011,12 @@ class Media3PlayerEngine @Inject constructor(
}
private fun resetEngineState(restartCollectors: Boolean) {
+ clearAdaptiveDecodePressure()
retryJob?.cancel()
retryJob = null
- preloadCoordinator.release()
pendingPreloadWindow = null
+ retryGeneration++
+ pendingRetrySeekPositionOverrideMs = null
statsCollector.stop()
audioFocusController.release()
mediaSession?.release()
@@ -978,7 +1041,6 @@ class Media3PlayerEngine @Inject constructor(
playbackStartedRecoveryArmed = false
hasRenderedFirstVideoFrame = false
retryAttempt = 0
- lastRetryCategory = null
_retryStatus.value = null
_playbackState.value = PlaybackState.IDLE
_isPlaying.value = false
@@ -1033,9 +1095,12 @@ class Media3PlayerEngine @Inject constructor(
seekPositionMs: Long?,
autoPlay: Boolean
) {
+ clearAdaptiveDecodePressure()
+ preloadWindowManager?.updateForegroundPlayback(PlaybackState.BUFFERING, false, 0L, true)
retryJob?.cancel()
retryJob = null
retryGeneration++
+ pendingRetrySeekPositionOverrideMs = null
lastStreamInfo = streamInfo
val mediaId = mediaSourceFactory.mediaIdFor(streamInfo)
val mediaChanged = lastMediaId != mediaId
@@ -1048,7 +1113,6 @@ class Media3PlayerEngine @Inject constructor(
val shouldArmLiveBufferingRecovery = armPlaybackStartedRecovery && isCurrentStreamLive()
if (!preserveRetryState || mediaChanged) {
retryAttempt = 0
- lastRetryCategory = null
_retryStatus.value = null
}
if (mediaChanged) {
@@ -1081,6 +1145,7 @@ class Media3PlayerEngine @Inject constructor(
videoStallRecoveryAttempt = 0
videoStallSafeRecoveryPerformed = false
}
+ if (!preserveRetryState || mediaChanged) liveVideoStallRecovery.reset()
selectedVideoDecoderName = "Unknown"
selectedAudioDecoderName = "Unknown"
ffmpegAvailability = ffmpegExtensionSupport.availability()
@@ -1171,11 +1236,14 @@ class Media3PlayerEngine @Inject constructor(
}
player.playbackParameters = PlaybackParameters(_playbackSpeed.value)
- val managedMediaSource = preloadWindowManager?.getMediaSource(streamInfo)
- val mediaSource = managedMediaSource
- ?: preloadCoordinator.tryReuse(mediaId, streamInfo, currentResolvedStreamType)
+ val managedSource = preloadWindowManager?.getMediaSource(streamInfo)
+ if (managedSource != null) {
+ // Reuse the policy installed in this source so load retries, fallback, stall
+ // deferral and preload priority all observe the same recovery state.
+ currentRetryPolicy = managedSource.retryPolicy
+ }
+ val mediaSource = managedSource?.mediaSource
?: run {
- Log.i(TAG, "preload-source direct-fallback mediaId=$mediaId")
mediaSourceFactory.create(
streamInfo = streamInfo,
resolvedStreamType = currentResolvedStreamType,
@@ -1184,10 +1252,9 @@ class Media3PlayerEngine @Inject constructor(
preload = false
).second
}
- if (managedMediaSource != null) {
+ if (managedSource != null) {
Log.i(TAG, "preload-source reused mediaId=$mediaId source=window")
}
- preloadCoordinator.onPlaybackStarted(mediaId)
player.setMediaSource(mediaSource)
player.prepare()
seekPositionMs?.takeIf { it > 0L }?.let(player::seekTo)
@@ -1223,6 +1290,7 @@ class Media3PlayerEngine @Inject constructor(
mediaSession = null
existing.release()
exoPlayer = null
+ playbackLoadControl = null
preloadWindowManager?.release()
if (preloadWindowManager != null) {
Log.i(TAG, "preload-window manager-recreated reason=player-recreate")
@@ -1256,26 +1324,22 @@ class Media3PlayerEngine @Inject constructor(
bufferMode = requestedPlaybackBufferMode,
streamInfo = lastStreamInfo
)
- val loadControl = DefaultLoadControl.Builder()
- .setBufferDurationsMs(
- bufferPolicy.minBufferMs,
- bufferPolicy.maxBufferMs,
- bufferPolicy.playbackBufferMs,
- bufferPolicy.rebufferMs
- )
- .setTargetBufferBytes(bufferPolicy.targetBufferBytes)
- .setPrioritizeTimeOverSizeThresholds(bufferPolicy.prioritizeTimeOverSizeThresholds)
- .build()
- val livePlaybackSpeedControl = DefaultLivePlaybackSpeedControl.Builder()
- .setFallbackMinPlaybackSpeed(1.0f)
- .setFallbackMaxPlaybackSpeed(1.0f)
- .build()
+ val loadControl = PlaybackLoadControl(
+ policy = bufferPolicy,
+ heapBytes = Runtime.getRuntime().maxMemory(),
+ multiview = constrainResolutionForMultiView
+ ).also { playbackLoadControl = it }
+ val livePlaybackSpeedControl = createLivePlaybackSpeedControl()
val preloadManager = Media3PreloadWindowManager(
context = context,
mediaSourceFactory = mediaSourceFactory,
dataSourceFactoryProvider = dataSourceFactoryProvider,
- bandwidthMeter = bandwidthMeter
+ bandwidthMeter = bandwidthMeter,
+ onForegroundRecoveryChanged = {
+ preloadPriorityHandler.post { updateForegroundPreloadPriority() }
+ },
+ playbackStarted = { isEffectivelyPlaybackStarted() }
)
preloadWindowManager = preloadManager
return preloadManager.createPlayer(
@@ -1334,7 +1398,7 @@ class Media3PlayerEngine @Inject constructor(
return "buffer-policy label=$label streamType=$resolvedStreamType mode=$bufferMode " +
"reason=$qualityReason minMs=$minBufferMs maxMs=$maxBufferMs " +
"playbackMs=$playbackBufferMs rebufferMs=$rebufferMs " +
- "targetBytes=$targetBufferBytes lowMemoryCapped=$lowMemoryCapped"
+ "byteHint=$targetBufferBytes sizing=selected-bitrate-and-heap sizePriority=true lowMemoryCapped=$lowMemoryCapped"
}
@@ -1353,6 +1417,7 @@ class Media3PlayerEngine @Inject constructor(
useAudioVideoSyncSink = _audioVideoSyncEnabled.value,
useVideoRendererWorkaround = compatibilityProfile.shouldDisableDecoderReuseWorkaround()
)
+ val rendererFactorySettings = buildPlaybackRendererFactorySettings(rendererPlan)
audioVideoSyncSinkActive = false
val audioCodecSelector = if (rendererPlan.useAudioManagedCodecSelector) {
PlaybackCodecSelector(
@@ -1362,7 +1427,7 @@ class Media3PlayerEngine @Inject constructor(
} else {
MediaCodecSelector.DEFAULT
}
- val videoCodecSelector = if (rendererPlan.useVideoManagedCodecSelector) {
+ val preferredVideoCodecSelector = if (rendererPlan.useVideoManagedCodecSelector) {
PlaybackCodecSelector(
policyProvider = { videoDecoderPolicy },
knownBadProvider = { badDecoderNames }
@@ -1370,6 +1435,10 @@ class Media3PlayerEngine @Inject constructor(
} else {
MediaCodecSelector.DEFAULT
}
+ val videoCodecSelector = com.streamvault.player.playback.PlaybackVideoCodecCompatibility(
+ delegate = preferredVideoCodecSelector,
+ emulatorWorkaroundEligible = compatibilityProfile.shouldDisableDecoderReuseWorkaround()
+ )
val factory = object : DefaultRenderersFactory(context) {
override fun buildAudioSink(
@@ -1377,11 +1446,18 @@ class Media3PlayerEngine @Inject constructor(
enableFloatOutput: Boolean,
enableAudioTrackPlaybackParams: Boolean
): AudioSink {
- val audioSink = requireNotNull(
- super.buildAudioSink(context, enableFloatOutput, enableAudioTrackPlaybackParams)
- ) {
- "DefaultRenderersFactory did not provide an AudioSink."
- }
+ // Reduced the first-cue offset in the V13 emulator capture without an observed underrun.
+ val bufferSizeProvider = DefaultAudioTrackBufferSizeProvider.Builder()
+ .setTargetPcmBufferDurationUs(100_000)
+ .build()
+ val audioOutputProvider = AudioTrackAudioOutputProvider.Builder(context)
+ .setAudioTrackBufferSizeProvider(bufferSizeProvider)
+ .build()
+ val audioSink = DefaultAudioSink.Builder(context)
+ .setEnableFloatOutput(enableFloatOutput)
+ .setEnableAudioOutputPlaybackParameters(enableAudioTrackPlaybackParams)
+ .setAudioOutputProvider(audioOutputProvider)
+ .build()
val syncAwareSink = if (rendererPlan.useAudioVideoSyncSink) {
audioVideoSyncSinkActive = true
AudioVideoOffsetAudioSink(
@@ -1410,9 +1486,9 @@ class Media3PlayerEngine @Inject constructor(
) {
super.buildAudioRenderers(
context,
- rendererPlan.audioExtensionRendererMode.toMedia3ExtensionRendererMode(),
+ rendererFactorySettings.audioExtensionRendererMode,
audioCodecSelector,
- enableDecoderFallback,
+ enableDecoderFallback && rendererFactorySettings.enableDecoderFallback,
audioSink,
eventHandler,
eventListener,
@@ -1433,9 +1509,9 @@ class Media3PlayerEngine @Inject constructor(
if (!rendererPlan.useVideoRendererWorkaround) {
super.buildVideoRenderers(
context,
- rendererPlan.videoExtensionRendererMode.toMedia3ExtensionRendererMode(),
+ rendererFactorySettings.videoExtensionRendererMode,
videoCodecSelector,
- enableDecoderFallback,
+ enableDecoderFallback && rendererFactorySettings.enableDecoderFallback,
eventHandler,
eventListener,
allowedVideoJoiningTimeMs,
@@ -1447,7 +1523,7 @@ class Media3PlayerEngine @Inject constructor(
val rendererBuilder = MediaCodecVideoRenderer.Builder(context)
.setMediaCodecSelector(videoCodecSelector)
.setAllowedJoiningTimeMs(allowedVideoJoiningTimeMs)
- .setEnableDecoderFallback(enableDecoderFallback)
+ .setEnableDecoderFallback(enableDecoderFallback && rendererFactorySettings.enableDecoderFallback)
.setEventHandler(eventHandler)
.setEventListener(eventListener)
.setMaxDroppedFramesToNotify(50)
@@ -1467,16 +1543,11 @@ class Media3PlayerEngine @Inject constructor(
}
return factory.apply {
- setEnableDecoderFallback(true)
+ setEnableDecoderFallback(rendererFactorySettings.enableDecoderFallback)
setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON)
}
}
- private fun PlaybackExtensionRendererMode.toMedia3ExtensionRendererMode(): Int = when (this) {
- PlaybackExtensionRendererMode.PLATFORM_FIRST -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
- PlaybackExtensionRendererMode.EXTENSIONS_FIRST -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
- }
-
private fun createAnalyticsListener(): AnalyticsListener {
return object : AnalyticsListener {
override fun onVideoInputFormatChanged(
@@ -1535,20 +1606,6 @@ class Media3PlayerEngine @Inject constructor(
)
}
- override fun onAudioSinkError(
- eventTime: AnalyticsListener.EventTime,
- audioSinkError: Exception
- ) {
- handleAudioRendererIssue(audioSinkError, "audio-sink")
- }
-
- override fun onAudioCodecError(
- eventTime: AnalyticsListener.EventTime,
- audioCodecError: Exception
- ) {
- handleAudioRendererIssue(audioCodecError, "audio-codec")
- }
-
override fun onDroppedVideoFrames(
eventTime: AnalyticsListener.EventTime,
droppedFrames: Int,
@@ -1596,6 +1653,7 @@ class Media3PlayerEngine @Inject constructor(
Player.STATE_ENDED -> PlaybackState.ENDED
else -> PlaybackState.IDLE
}
+ updateForegroundPreloadPriority()
if (previousState == PlaybackState.READY && _playbackState.value == PlaybackState.BUFFERING) {
statsCollector.incrementRebufferCount()
}
@@ -1606,7 +1664,6 @@ class Media3PlayerEngine @Inject constructor(
playbackStarted = playbackStarted
)
if (retryAttempt == 0) {
- lastRetryCategory = null
}
if (isPlayingTimeshiftSnapshot && pendingTimeshiftSeekToEnd) {
pendingTimeshiftSeekToEnd = false
@@ -1628,6 +1685,7 @@ class Media3PlayerEngine @Inject constructor(
override fun onIsPlayingChanged(isPlaying: Boolean) {
_isPlaying.value = isPlaying
+ updateForegroundPreloadPriority()
if (isPlaying) {
if (_playbackState.value == PlaybackState.READY) {
markPlaybackStarted("playing-ready")
@@ -1649,6 +1707,7 @@ class Media3PlayerEngine @Inject constructor(
newPosition: Player.PositionInfo,
reason: Int
) {
+ adaptiveDecodePressurePolicy.discontinuity()
_currentPosition.value = newPosition.positionMs
syncTimeshiftState()
}
@@ -1796,7 +1855,6 @@ class Media3PlayerEngine @Inject constructor(
playbackStartedRecoveryArmed = false
retryAttempt = resolveRetryAttemptAfterPlaybackStarted(retryAttempt)
if (retryAttempt == 0) {
- lastRetryCategory = null
}
Log.i(
TAG,
@@ -1924,18 +1982,17 @@ class Media3PlayerEngine @Inject constructor(
private fun handleVideoStall() {
val streamInfo = lastStreamInfo ?: return
+ if (exoPlayer?.currentTracks?.isTypeSelected(C.TRACK_TYPE_VIDEO) != true) return
+ if (shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = currentRetryPolicy?.hasPendingLoadRecovery == true,
+ sourceRetryPending = retryJob?.isActive == true
+ )) return
videoStallCount++
_playerStats.value = _playerStats.value.copy(videoStallCount = videoStallCount)
val wasPlaying = exoPlayer?.playWhenReady ?: true
val seekPosition = exoPlayer?.currentPosition?.takeIf { it > 0L }
val nextRecoveryAttempt = videoStallRecoveryAttempt + 1
- val liveReconnectionStall = shouldReconnectLiveStall(
- playbackState = _playbackState.value,
- resolvedStreamType = currentResolvedStreamType,
- recoveryAttempt = nextRecoveryAttempt,
- playbackContentKind = streamInfo.playbackContentKind
- )
Log.w(
TAG,
"video-stall count=$videoStallCount recovered=$videoStallSafeRecoveryPerformed decoder=$selectedVideoDecoderName policy=$activeVideoDecoderPolicy surface=${_renderSurfaceType.value} target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
@@ -1947,37 +2004,29 @@ class Media3PlayerEngine @Inject constructor(
}
videoStallRecoveryAttempt = nextRecoveryAttempt
- if (liveReconnectionStall) {
- Log.w(TAG, "live-${_playbackState.value.name.lowercase()}-stall reconnect attempt=$videoStallRecoveryAttempt")
- prepareInternal(
- streamInfo = streamInfo,
- preserveRetryState = true,
- seekPositionMs = null,
- autoPlay = wasPlaying
- )
- return
- }
- if (
- isCurrentStreamLive() &&
- shouldFallbackStalledHlsToLiveTs(
- resolvedStreamType = currentResolvedStreamType,
- recoveryAttempt = videoStallRecoveryAttempt
- )
- ) {
- val fallbackStreamInfo = buildLiveTsFallbackStreamInfo(streamInfo)
- if (fallbackStreamInfo != null) {
- Log.w(
- TAG,
- "video-stall live-ts-fallback from=HLS attempt=$videoStallRecoveryAttempt target=${PlaybackLogSanitizer.sanitizeUrl(fallbackStreamInfo.url)}"
- )
- prepareInternal(
- streamInfo = fallbackStreamInfo,
- preserveRetryState = false,
- seekPositionMs = null,
- autoPlay = wasPlaying
+ val player = exoPlayer
+ if (player != null) {
+ when (liveVideoStallRecovery.recover(
+ player = player,
+ livePlayback = isCurrentStreamLive(),
+ loadRetryPending = shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = currentRetryPolicy?.hasPendingLoadRecovery == true,
+ sourceRetryPending = retryJob?.isActive == true
)
- return
+ )) {
+ LiveVideoStallRecovery.Result.SEEKED -> {
+ videoStallDetector.restartAfterRecoveryAttempt()
+ Log.w(TAG, "video-stall in-place-live-seek attempt=$videoStallRecoveryAttempt")
+ return
+ }
+ LiveVideoStallRecovery.Result.STOPPED -> {
+ recordCompatibilityFailure("VIDEO_STALL")
+ Log.w(TAG, "video-stall stopped-loading after unsuccessful or unavailable in-place recovery")
+ _error.tryEmit(PlayerError.DecoderError("Video playback stalled. Try another stream."))
+ return
+ }
+ LiveVideoStallRecovery.Result.NONE -> Unit
}
}
@@ -2177,61 +2226,6 @@ class Media3PlayerEngine @Inject constructor(
currentResolvedStreamType
)
- private fun handleAudioRendererIssue(error: Exception, source: String) {
- val streamInfo = lastStreamInfo
- if (streamInfo == null) {
- lastSupportErrorMessage = error.message ?: "Audio playback failed."
- _error.tryEmit(PlayerError.DecoderError(error.message ?: "Audio playback failed."))
- return
- }
-
- if (
- source == "audio-codec" &&
- tryFfmpegAudioFallback(
- trigger = "audio-renderer-$source",
- mimeTypes = audioMimeTypes(),
- detail = error.message
- )
- ) {
- return
- }
-
- val now = System.currentTimeMillis()
- if (now - lastAudioRendererRecoveryAtMs < AUDIO_RENDERER_RECOVERY_COOLDOWN_MS) {
- Log.e(
- TAG,
- "audio-renderer-failed source=$source target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)} message=${PlaybackLogSanitizer.sanitizeMessage(error.message)}"
- )
- lastSupportErrorMessage = error.message ?: "Audio playback failed for this stream."
- _error.tryEmit(
- PlayerError.DecoderError(
- error.message ?: "Audio playback failed for this stream."
- )
- )
- return
- }
-
- lastAudioRendererRecoveryAtMs = now
- val wasPlaying = exoPlayer?.playWhenReady ?: true
- val seekPosition = exoPlayer?.currentPosition
- ?.takeIf { currentResolvedStreamType == ResolvedStreamType.PROGRESSIVE && it > 0L }
-
- Log.w(
- TAG,
- "audio-renderer-recover source=$source target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)} message=${PlaybackLogSanitizer.sanitizeMessage(error.message)}"
- )
-
- retryJob?.cancel()
- retryJob = null
- _retryStatus.value = null
- prepareInternal(
- streamInfo = streamInfo,
- preserveRetryState = false,
- seekPositionMs = seekPosition,
- autoPlay = wasPlaying
- )
- }
-
private fun tryFfmpegAudioFallback(
trigger: String,
mimeTypes: List<String>,
@@ -2378,7 +2372,11 @@ class Media3PlayerEngine @Inject constructor(
): PlaybackPreparationPlan {
val resolvedStreamType = StreamTypeResolver.resolve(streamInfo)
val timeoutProfile = PlayerTimeoutProfile.resolve(streamInfo, resolvedStreamType, preload = preload)
- val retryContext = PlaybackRetryContext(resolvedStreamType, timeoutProfile)
+ val retryContext = PlaybackRetryContext(
+ resolvedStreamType = resolvedStreamType,
+ timeoutProfile = timeoutProfile,
+ playbackContentKind = streamInfo.playbackContentKind
+ )
return PlaybackPreparationPlan(
resolvedStreamType = resolvedStreamType,
timeoutProfile = timeoutProfile,
@@ -2386,6 +2384,9 @@ class Media3PlayerEngine @Inject constructor(
retryPolicy = PlayerRetryPolicy(
streamContext = retryContext,
fastRetryOnTransientFailures = { fastRetryOnTransientFailures },
+ onLoadRecoveryChanged = {
+ preloadPriorityHandler.post { updateForegroundPreloadPriority() }
+ },
playbackStarted = { playbackStarted() }
)
)
@@ -2472,6 +2473,7 @@ class Media3PlayerEngine @Inject constructor(
val effectivePlaybackStarted = isEffectivelyPlaybackStarted()
if (streamInfo == null || mediaId == null || retryPolicy == null || retryContext == null) {
+ pendingRetrySeekPositionOverrideMs = null
_retryStatus.value = null
lastSupportErrorMessage = error.message
_error.tryEmit(PlayerError.fromException(error))
@@ -2513,35 +2515,9 @@ class Media3PlayerEngine @Inject constructor(
}
}
- if (
- shouldFallbackMalformedHlsToLiveTs(
- category = category,
- resolvedStreamType = currentResolvedStreamType,
- playbackStarted = effectivePlaybackStarted
- )
- ) {
- val fallbackStreamInfo = buildLiveTsFallbackStreamInfo(streamInfo)
- if (fallbackStreamInfo != null) {
- Log.w(
- TAG,
- "source-malformed live-ts-fallback from=HLS target=${PlaybackLogSanitizer.sanitizeUrl(fallbackStreamInfo.url)}"
- )
- prepareInternal(
- fallbackStreamInfo,
- preserveRetryState = false,
- seekPositionMs = null,
- autoPlay = true
- )
- return
- }
- }
-
- val nextAttempt = resolveRetryAttemptForCategory(
- currentAttempt = retryAttempt,
- lastCategory = lastRetryCategory,
- nextCategory = category
- )
- if (retryPolicy.shouldRetry(error, retryContext, effectivePlaybackStarted, nextAttempt)) {
+ retryPolicy.clearPendingLoadRecovery()
+ val nextAttempt = resolveNextAppSourceRetryAttempt(retryAttempt)
+ if (retryPolicy.shouldRetryWholeSource(error, effectivePlaybackStarted, nextAttempt)) {
val delayMs = retryPolicy.retryDelayMs(error, nextAttempt)
val player = exoPlayer
val retrySeekPositionMs = resolveRetrySeekPositionMs(
@@ -2557,29 +2533,39 @@ class Media3PlayerEngine @Inject constructor(
// (e.g. in tests), convert retryGeneration to AtomicLong.
val scheduledRetryGeneration = retryGeneration
retryAttempt = nextAttempt
- lastRetryCategory = category
_retryStatus.value = PlayerRetryStatus(
attempt = nextAttempt,
- maxAttempts = retryPolicy.maxAttempts(error, effectivePlaybackStarted),
+ maxAttempts = retryPolicy.maxWholeSourceRetryAttempts(error, effectivePlaybackStarted),
delayMs = delayMs
)
Log.w(
TAG,
- "retry category=$category attempt=$nextAttempt delayMs=$delayMs reason=${retryPolicy.retryReason(error)} " +
+ "retry scope=source category=$category attempt=$nextAttempt/" +
+ "${retryPolicy.maxWholeSourceRetryAttempts(error, effectivePlaybackStarted)} " +
+ "delayMs=$delayMs reason=${retryPolicy.retryReason(error)} " +
"errorCode=${error.errorCodeName} causeChain=${formatErrorCauseChain(error)} " +
"target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
)
retryJob = scope.launch {
delay(delayMs)
- if (
- scheduledRetryGeneration != retryGeneration ||
- lastMediaId != mediaId ||
- retryAttempt != nextAttempt ||
- lastRetryCategory != category
+ if (!isScheduledAppSourceRetryCurrent(
+ scheduledGeneration = scheduledRetryGeneration,
+ currentGeneration = retryGeneration,
+ scheduledMediaId = mediaId,
+ currentMediaId = lastMediaId,
+ scheduledAttempt = nextAttempt,
+ currentAttempt = retryAttempt
+ )
) {
return@launch
}
retryJob = null
+ val scheduledSeekPositionMs = resolveScheduledRetrySeekPositionMs(
+ category = category,
+ plannedPositionMs = retrySeekPositionMs,
+ userSeekOverrideMs = pendingRetrySeekPositionOverrideMs
+ )
+ pendingRetrySeekPositionOverrideMs = null
if (category == PlaybackErrorCategory.LIVE_WINDOW &&
currentResolvedStreamType != ResolvedStreamType.MPEG_TS_LIVE
) {
@@ -2587,18 +2573,20 @@ class Media3PlayerEngine @Inject constructor(
}
prepareInternal(
streamInfo,
- preserveRetryState = shouldPreservePlaybackStateForRetry(
- category = category,
- playbackStarted = effectivePlaybackStarted,
- liveBufferingRecoveryArmed = false
- ),
- seekPositionMs = retrySeekPositionMs,
+ preserveRetryState = category == PlaybackErrorCategory.LIVE_WINDOW ||
+ shouldPreservePlaybackStateForRetry(
+ category = category,
+ playbackStarted = effectivePlaybackStarted,
+ liveBufferingRecoveryArmed = false
+ ),
+ seekPositionMs = scheduledSeekPositionMs,
autoPlay = true
)
}
return
}
+ pendingRetrySeekPositionOverrideMs = null
_retryStatus.value = null
Log.e(
TAG,
diff --git a/player/src/main/java/com/streamvault/player/PlayerEngine.kt b/player/src/main/java/com/streamvault/player/PlayerEngine.kt
index 55d8ea7a..b1ff6a2e 100644
--- a/player/src/main/java/com/streamvault/player/PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/PlayerEngine.kt
@@ -122,12 +122,6 @@ interface PlayerEngine {
*/
fun setScrubbingMode(enabled: Boolean)
- /**
- * Pre-warm the player with a stream that will likely be played next.
- * Only the initial manifest/key-frames are fetched — no full buffering.
- * Call with `null` to discard any preloaded data.
- */
- fun preload(streamInfo: StreamInfo?)
/**
* Preload a bounded VOD or catch-up navigation window. Implementations that
@@ -135,8 +129,8 @@ interface PlayerEngine {
*/
fun preloadWindow(window: PlayerPreloadWindow) {}
- /** Clears both sliding-window and legacy single-item preload state. */
- fun clearPreloadWindow() = preload(null)
+ /** Clears any sliding-window preload state. */
+ fun clearPreloadWindow() = Unit
fun createRenderView(
context: Context,
@@ -248,7 +242,14 @@ data class PlayerStats(
sealed class PlayerError(val message: String) {
class NetworkError(message: String) : PlayerError(message)
class SourceError(message: String) : PlayerError(message)
- class DecoderError(message: String) : PlayerError(message)
+ class DecoderError(message: String) : PlayerError(message) {
+ /** Stall signal emitted when opening another provider connection is intentionally suppressed. */
+ val isDeferredLiveStall: Boolean
+ get() = message.contains(
+ "Automatic recovery was not attempted to avoid opening another provider connection.",
+ ignoreCase = true
+ )
+ }
class DrmError(message: String, val scheme: DrmScheme? = null) : PlayerError(message)
class UnknownError(message: String) : PlayerError(message)
@@ -261,6 +262,7 @@ sealed class PlayerError(val message: String) {
PlaybackErrorCategory.FORMAT_UNSUPPORTED -> buildCodecErrorMessage(e)
PlaybackErrorCategory.NETWORK -> buildNetworkErrorMessage(chain)
PlaybackErrorCategory.HTTP_AUTH -> buildHttpErrorMessage(chain, "Access denied")
+ PlaybackErrorCategory.HTTP_NOT_FOUND -> "Stream resource not found (HTTP 404)."
PlaybackErrorCategory.HTTP_SERVER -> buildHttpErrorMessage(chain, "Server error")
PlaybackErrorCategory.PROVIDER_LIMIT ->
"Provider rejected playback, likely max connections or bandwidth limit (HTTP 509)."
@@ -288,6 +290,7 @@ sealed class PlayerError(val message: String) {
PlaybackErrorCategory.PROVIDER_LIMIT,
PlaybackErrorCategory.EMPTY_RESPONSE,
PlaybackErrorCategory.SOURCE_MALFORMED,
+ PlaybackErrorCategory.HTTP_NOT_FOUND,
PlaybackErrorCategory.LIVE_WINDOW -> SourceError(msg)
PlaybackErrorCategory.DECODER,
diff --git a/player/src/main/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicy.kt b/player/src/main/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicy.kt
new file mode 100644
index 00000000..5f4149c1
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicy.kt
@@ -0,0 +1,158 @@
+package com.streamvault.player.playback
+
+internal data class DecodePressureRendition(val height: Int, val bitrate: Int)
+internal data class DecodePressureSample(
+ val timeMs: Long, val groupKey: Any, val eligible: Boolean, val readyAndPlaying: Boolean,
+ val bufferedMs: Long, val rendered: Int, val dropped: Int, val height: Int, val bitrate: Int,
+ val renditions: List<DecodePressureRendition>
+)
+internal data class DecodePressureChange(
+ val maxHeight: Int?,
+ val maxBitrate: Int? = null,
+ val restorationStableMs: Long? = null
+)
+
+internal class AdaptiveDecodePressurePolicy {
+ // Trial thresholds from docs/PLAYBACK-STAGE3-EVIDENCE-2026-10-01.md:
+ // software 4K dropped ~80% with >=4s buffered; controls had sparse bursts.
+ // Require two 5s windows with >=20% / 30 dropped frames, after 10s settling.
+ // These are conservative engineering gates, not calibrated TV-device optima.
+ private var group: Any? = null
+ private var cap: Int? = null
+ private var previous: DecodePressureSample? = null
+ private var window: DecodePressureSample? = null
+ private var warmUntilMs = 0L
+ private var changeAfterMs = 0L
+ private var pressureWindows = 0
+ private var stableMs = 0L
+ private var pressureBufferHealthy = true
+ private var stableBufferHealthy = true
+ private var restorationStableMs = BASE_RESTORATION_STABLE_MS
+ private var lastRestorationMs: Long? = null
+
+ fun reset() {
+ group = null
+ cap = null
+ changeAfterMs = 0
+ clearRestorationHistory()
+ resetObservation()
+ }
+
+ fun discontinuity() {
+ clearRestorationHistory()
+ resetObservation()
+ }
+
+ private fun clearRestorationHistory() {
+ restorationStableMs = BASE_RESTORATION_STABLE_MS
+ lastRestorationMs = null
+ }
+
+ private fun resetObservation() {
+ previous = null
+ window = null
+ warmUntilMs = 0
+ pressureWindows = 0
+ stableMs = 0
+ pressureBufferHealthy = true
+ stableBufferHealthy = true
+ }
+
+ fun observe(sample: DecodePressureSample): DecodePressureChange? {
+ if (!sample.eligible || (group != null && group != sample.groupKey)) {
+ val hadCap = cap != null
+ reset()
+ if (hadCap) return DecodePressureChange(null)
+ if (!sample.eligible) return null
+ }
+ group = sample.groupKey
+ if (!sample.readyAndPlaying) {
+ // Pause/buffering time cannot add stable or pressure evidence, but it does not
+ // end this source's restoration history. Explicit position discontinuities do.
+ resetObservation()
+ return null
+ }
+ lastRestorationMs?.let { restoredAt ->
+ if (sample.timeMs >= restoredAt + RAPID_RECURRENCE_WINDOW_MS) {
+ // A full minute of healthy restored output means the recurrence has ended.
+ restorationStableMs = BASE_RESTORATION_STABLE_MS
+ lastRestorationMs = null
+ }
+ }
+ val old = previous
+ if (old == null || sample.height != old.height || sample.timeMs <= old.timeMs ||
+ sample.timeMs - old.timeMs > 2_500 || sample.rendered < old.rendered || sample.dropped < old.dropped
+ ) {
+ // Decoder/format/counter boundaries restart measurements but retain the policy's
+ // restoration history. Explicit user seeks use discontinuity() above.
+ resetObservation()
+ previous = sample
+ warmUntilMs = sample.timeMs + 10_000
+ return null
+ }
+ previous = sample
+ if (sample.timeMs < warmUntilMs) return null
+ pressureBufferHealthy = pressureBufferHealthy && sample.bufferedMs >= 4_000
+ stableBufferHealthy = stableBufferHealthy && sample.bufferedMs >= 2_000
+ val start = window ?: run { window = sample; return null }
+ val elapsed = sample.timeMs - start.timeMs
+ if (elapsed < 5_000) return null
+ val dropped = (sample.dropped - start.dropped).toLong()
+ val frames = dropped + (sample.rendered - start.rendered).toLong()
+ val ratio = if (frames > 0) dropped.toDouble() / frames else 0.0
+ val pressure = pressureBufferHealthy && frames >= 60 && dropped >= 30 && ratio >= 0.20
+ val stable = stableBufferHealthy && frames >= 60 && ratio <= 0.02
+ window = sample
+ pressureBufferHealthy = sample.bufferedMs >= 4_000
+ stableBufferHealthy = sample.bufferedMs >= 2_000
+ pressureWindows = if (pressure) pressureWindows + 1 else 0
+ stableMs = if (stable) stableMs + elapsed else 0
+ if (sample.timeMs < changeAfterMs) return null
+
+ if (pressureWindows >= 2) {
+ val next = sample.renditions.filter {
+ it.height > 0 && it.height < minOf(sample.height, cap ?: Int.MAX_VALUE) &&
+ it.bitrate > 0 && sample.bitrate > 0 && it.bitrate <= sample.bitrate
+ }.maxWithOrNull(compareBy<DecodePressureRendition> { it.height }.thenBy { it.bitrate }) ?: return null
+ return change(sample.timeMs, next.height, next.bitrate)
+ }
+ val limit = cap ?: return null
+ if (stableMs >= restorationStableMs) {
+ val heights = sample.renditions.filter { it.height > 0 && it.bitrate > 0 }.map { it.height }.distinct().sorted()
+ val next = heights.firstOrNull { it > limit } ?: return null
+ return change(sample.timeMs, next.takeUnless { it == heights.last() },
+ sample.renditions.filter { it.height == next }.maxOf { it.bitrate })
+ }
+ return null
+ }
+
+ private fun change(nowMs: Long, height: Int?, bitrate: Int?): DecodePressureChange {
+ val oldCap = cap
+ val restoring = oldCap != null && (height == null || height > oldCap)
+ if (restoring) {
+ lastRestorationMs = nowMs
+ } else if (oldCap == null && height != null) {
+ val sinceRestorationMs = lastRestorationMs?.let { nowMs - it }
+ if (sinceRestorationMs != null && sinceRestorationMs in 0..RAPID_RECURRENCE_WINDOW_MS) {
+ // V8 measured renewed pressure ~31s after restore. One 30s increment gives
+ // that source an extra stable window while keeping restoration bounded.
+ restorationStableMs = BACKED_OFF_RESTORATION_STABLE_MS
+ }
+ lastRestorationMs = null
+ }
+ cap = height
+ changeAfterMs = nowMs + 30_000
+ resetObservation()
+ return DecodePressureChange(
+ maxHeight = height,
+ maxBitrate = bitrate.takeIf { height != null },
+ restorationStableMs = restorationStableMs.takeIf { restoring }
+ )
+ }
+
+ private companion object {
+ const val BASE_RESTORATION_STABLE_MS = 60_000L
+ const val BACKED_OFF_RESTORATION_STABLE_MS = 90_000L
+ const val RAPID_RECURRENCE_WINDOW_MS = 60_000L
+ }
+}
diff --git a/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt b/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
index 649b615c..8a52637b 100644
--- a/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
+++ b/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
@@ -2,6 +2,7 @@ package com.streamvault.player.playback
import androidx.media3.common.Format
import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
import androidx.media3.exoplayer.DecoderReuseEvaluation
import androidx.media3.exoplayer.mediacodec.MediaCodecInfo
import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
@@ -57,6 +58,27 @@ internal enum class PlaybackExtensionRendererMode {
EXTENSIONS_FIRST
}
+internal data class PlaybackRendererFactorySettings(
+ val audioExtensionRendererMode: Int,
+ val videoExtensionRendererMode: Int,
+ val enableDecoderFallback: Boolean
+)
+
+@UnstableApi
+internal fun buildPlaybackRendererFactorySettings(
+ plan: PlaybackRendererPlan
+): PlaybackRendererFactorySettings = PlaybackRendererFactorySettings(
+ audioExtensionRendererMode = plan.audioExtensionRendererMode.toMedia3RendererMode(),
+ videoExtensionRendererMode = plan.videoExtensionRendererMode.toMedia3RendererMode(),
+ enableDecoderFallback = true
+)
+
+@UnstableApi
+internal fun PlaybackExtensionRendererMode.toMedia3RendererMode(): Int = when (this) {
+ PlaybackExtensionRendererMode.PLATFORM_FIRST -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+ PlaybackExtensionRendererMode.EXTENSIONS_FIRST -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
+}
+
internal fun extensionRendererModeFor(activeDecoderMode: DecoderMode): PlaybackExtensionRendererMode {
return when (activeDecoderMode) {
DecoderMode.AUTO,
diff --git a/player/src/main/java/com/streamvault/player/playback/ForegroundPreloadPolicy.kt b/player/src/main/java/com/streamvault/player/playback/ForegroundPreloadPolicy.kt
new file mode 100644
index 00000000..34f08261
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/ForegroundPreloadPolicy.kt
@@ -0,0 +1,16 @@
+package com.streamvault.player.playback
+
+import com.streamvault.player.PlaybackState
+
+internal fun shouldAllowNeighborPreload(
+ previouslyAllowed: Boolean,
+ state: PlaybackState,
+ isPlaying: Boolean,
+ bufferedDurationMs: Long,
+ recovering: Boolean,
+ providerLimitBlocked: Boolean = false
+): Boolean {
+ if (state != PlaybackState.READY || !isPlaying || recovering || providerLimitBlocked) return false
+ // Keep a reserve for the foreground and use hysteresis to avoid restarting on each sample.
+ return if (previouslyAllowed) bufferedDurationMs > 5_000L else bufferedDurationMs >= 10_000L
+}
diff --git a/player/src/main/java/com/streamvault/player/playback/LiveAudioTapAudioSink.kt b/player/src/main/java/com/streamvault/player/playback/LiveAudioTapAudioSink.kt
index b2d5450e..63716eff 100644
--- a/player/src/main/java/com/streamvault/player/playback/LiveAudioTapAudioSink.kt
+++ b/player/src/main/java/com/streamvault/player/playback/LiveAudioTapAudioSink.kt
@@ -39,9 +39,8 @@ internal class LiveAudioTapAudioSink(
encodedAccessUnitCount: Int
): Boolean {
val startPosition = buffer.position()
- val copySource = buffer.asReadOnlyBuffer()
val handled = delegate.handleBuffer(buffer, presentationTimeUs, encodedAccessUnitCount)
- copyConsumedForTap(copySource, startPosition, buffer.position(), presentationTimeUs)
+ copyConsumedForTap(buffer, startPosition, buffer.position(), presentationTimeUs)
return handled
}
@@ -57,7 +56,7 @@ internal class LiveAudioTapAudioSink(
return
}
val adjustedPresentationTimeUs = presentationTimeUs + consumedOffsetUs(startPosition)
- val duplicate = buffer.apply {
+ val duplicate = buffer.asReadOnlyBuffer().apply {
position(startPosition)
limit(endPosition)
}
diff --git a/player/src/main/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactory.kt b/player/src/main/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactory.kt
new file mode 100644
index 00000000..ff53a981
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactory.kt
@@ -0,0 +1,8 @@
+package com.streamvault.player.playback
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultLivePlaybackSpeedControl
+
+@UnstableApi
+internal fun createLivePlaybackSpeedControl(): DefaultLivePlaybackSpeedControl =
+ DefaultLivePlaybackSpeedControl.Builder().build()
diff --git a/player/src/main/java/com/streamvault/player/playback/LiveTsFallbackUrl.kt b/player/src/main/java/com/streamvault/player/playback/LiveTsFallbackUrl.kt
deleted file mode 100644
index e6234584..00000000
--- a/player/src/main/java/com/streamvault/player/playback/LiveTsFallbackUrl.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package com.streamvault.player.playback
-
-import com.streamvault.domain.model.StreamInfo
-import com.streamvault.domain.model.StreamType
-import java.net.URI
-import java.util.Locale
-
-internal fun buildLiveTsFallbackStreamInfo(streamInfo: StreamInfo): StreamInfo? {
- val fallbackUrl = buildLiveTsFallbackUrl(streamInfo.url) ?: return null
- return streamInfo.copy(
- url = fallbackUrl,
- streamType = StreamType.MPEG_TS,
- containerExtension = "ts"
- )
-}
-
-internal fun shouldFallbackMalformedHlsToLiveTs(
- category: PlaybackErrorCategory,
- resolvedStreamType: ResolvedStreamType,
- playbackStarted: Boolean
-): Boolean = false
-
-internal fun shouldFallbackStalledHlsToLiveTs(
- resolvedStreamType: ResolvedStreamType,
- recoveryAttempt: Int
-): Boolean = false
-
-internal fun buildLiveTsFallbackUrl(url: String): String? {
- val uri = runCatching { URI(url) }.getOrNull() ?: return null
- val path = uri.path.orEmpty()
- if (!path.contains("/live/", ignoreCase = true)) return null
-
- val query = uri.rawQuery.orEmpty()
- val queryFallback = if (query.contains("ext=m3u8", ignoreCase = true)) {
- val updated = Regex("""(?i)(^|&)ext=m3u8(?=&|$)""").replace(query) { match ->
- "${match.groupValues[1]}ext=ts"
- }
- rebuildUri(uri, path = path, query = updated)
- } else {
- null
- }
- if (queryFallback != null) return queryFallback
-
- if (!path.lowercase(Locale.ROOT).endsWith(".m3u8")) return null
- return rebuildUri(
- uri = uri,
- path = path.dropLast(".m3u8".length) + ".ts",
- query = uri.rawQuery
- )
-}
-
-private fun rebuildUri(uri: URI, path: String, query: String?): String {
- return URI(
- uri.scheme,
- uri.rawAuthority,
- path,
- query,
- uri.rawFragment
- ).toASCIIString()
-}
diff --git a/player/src/main/java/com/streamvault/player/playback/LiveVideoStallRecovery.kt b/player/src/main/java/com/streamvault/player/playback/LiveVideoStallRecovery.kt
new file mode 100644
index 00000000..4b66f57f
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/LiveVideoStallRecovery.kt
@@ -0,0 +1,52 @@
+@file:androidx.media3.common.util.UnstableApi
+
+package com.streamvault.player.playback
+
+import androidx.media3.common.Player
+import androidx.media3.common.C
+import androidx.media3.common.Timeline
+
+/** Called only after the frame-silence detector confirms a stall. Main thread only. */
+internal class LiveVideoStallRecovery {
+ enum class Result { NONE, SEEKED, STOPPED }
+ private var attempted = false
+
+ fun reset() {
+ attempted = false
+ }
+
+ fun recover(player: Player, livePlayback: Boolean, loadRetryPending: Boolean): Result {
+ if (loadRetryPending || !livePlayback || !player.playWhenReady ||
+ !player.currentTracks.isTypeSelected(C.TRACK_TYPE_VIDEO)
+ ) return Result.NONE
+
+ if (attempted && player.playbackState in listOf(Player.STATE_READY, Player.STATE_BUFFERING)) {
+ player.stop()
+ return Result.STOPPED
+ }
+ if (player.playbackState != Player.STATE_READY || !player.isCurrentMediaItemLive) return Result.NONE
+ if (!attempted && player.isCurrentMediaItemSeekable) {
+ val index = player.currentMediaItemIndex
+ val window = player.currentTimeline.getWindow(index, Timeline.Window())
+ var positionMs = window.defaultPositionMs
+ if (positionMs == C.TIME_UNSET) {
+ player.stop()
+ return Result.STOPPED
+ }
+ // A seek at the current millisecond can be skipped by Media3. With the
+ // engine's default EXACT seek parameters, a distinct target resets renderers.
+ if (positionMs == player.currentPosition) {
+ positionMs = if (window.durationMs != C.TIME_UNSET && positionMs >= window.durationMs) {
+ (positionMs - 1L).coerceAtLeast(0L)
+ } else positionMs + 1L
+ }
+ attempted = true
+ // Request a seek on the current source; subsequent frames establish success.
+ player.seekTo(index, positionMs)
+ return Result.SEEKED
+ }
+ // Persistent/nonseekable decoder stalls must not keep accumulating unused samples.
+ player.stop()
+ return Result.STOPPED
+ }
+}
diff --git a/player/src/main/java/com/streamvault/player/playback/Media3PreloadWindowManager.kt b/player/src/main/java/com/streamvault/player/playback/Media3PreloadWindowManager.kt
index 2cb69ac0..bea3863d 100644
--- a/player/src/main/java/com/streamvault/player/playback/Media3PreloadWindowManager.kt
+++ b/player/src/main/java/com/streamvault/player/playback/Media3PreloadWindowManager.kt
@@ -20,16 +20,20 @@ import com.streamvault.domain.model.StreamInfo
import com.streamvault.player.PlayerPreloadContentType
import com.streamvault.player.PlayerPreloadItem
import com.streamvault.player.PlayerPreloadWindow
+import com.streamvault.player.PlaybackState
import com.streamvault.player.normalizePlayerPreloadWindow
+import java.util.concurrent.atomic.AtomicBoolean
import kotlin.math.abs
internal const val PLAYER_PRELOAD_RANGE_MS = 3_000L
internal fun playerPreloadTargetStatus(
currentIndex: Int?,
- rankingIndex: Int
+ rankingIndex: Int,
+ readsAllowed: Boolean = true,
+ completed: Boolean = false
): DefaultPreloadManager.PreloadStatus? {
- return if (currentIndex != null && abs(rankingIndex - currentIndex) == 1) {
+ return if ((readsAllowed || completed) && currentIndex != null && abs(rankingIndex - currentIndex) == 1) {
DefaultPreloadManager.PreloadStatus.specifiedRangeLoaded(
0L,
PLAYER_PRELOAD_RANGE_MS
@@ -81,14 +85,23 @@ internal class Media3PreloadWindowManager(
private val mediaSourceFactory: PlayerMediaSourceFactory,
@Suppress("UNUSED_PARAMETER")
private val dataSourceFactoryProvider: PlayerDataSourceFactoryProvider,
- private val bandwidthMeter: BandwidthMeter
+ private val bandwidthMeter: BandwidthMeter,
+ private val onForegroundRecoveryChanged: () -> Unit = {},
+ private val playbackStarted: () -> Boolean = { false }
) {
+ data class ManagedMediaSource(
+ val mediaSource: MediaSource,
+ val retryPolicy: PlayerRetryPolicy
+ )
+
private data class ManagedCandidate(
val key: String,
val streamInfo: StreamInfo,
val mediaItem: MediaItem,
val mediaSource: MediaSource,
+ val retryPolicy: PlayerRetryPolicy,
+ val wasHandedToPlayback: AtomicBoolean,
val rankingIndex: Int,
val streamIdentity: String
)
@@ -98,9 +111,20 @@ internal class Media3PreloadWindowManager(
private var released = false
private val candidatesByKey = linkedMapOf<String, ManagedCandidate>()
private val mediaItemsByStreamIdentity = mutableMapOf<String, MediaItem>()
+ private val completedMediaItems = mutableSetOf<MediaItem>()
+ private val candidatesByRanking = mutableMapOf<Int, ManagedCandidate>()
+ private val foregroundMediaItems = mutableSetOf<MediaItem>()
+ private var readsAllowed = false
+ private var providerLimitBlocked = false
private val listener = object : PreloadManagerListener {
override fun onCompleted(mediaItem: MediaItem) {
+ val candidate = candidatesByKey.values.firstOrNull { it.mediaItem == mediaItem }
+ if (candidate != null && mediaItem !in foregroundMediaItems && readsAllowed &&
+ currentIndex?.let { abs(candidate.rankingIndex - it) == 1 } == true
+ ) {
+ completedMediaItems += mediaItem
+ }
safeLog(
"preload completed mediaId=${mediaItem.mediaId} sourceCount=${candidatesByKey.size}"
)
@@ -108,7 +132,15 @@ internal class Media3PreloadWindowManager(
override fun onError(exception: PreloadException) {
val failed = candidatesByKey.values.firstOrNull { it.mediaItem == exception.mediaItem }
+ if (PlayerErrorClassifier.classify(exception) == PlaybackErrorCategory.PROVIDER_LIMIT) {
+ providerLimitBlocked = true
+ readsAllowed = false
+ safeLog("preload-window disabled reason=provider-limit")
+ }
failed?.let { candidate ->
+ completedMediaItems.remove(candidate.mediaItem)
+ foregroundMediaItems.remove(candidate.mediaItem)
+ candidatesByRanking.remove(candidate.rankingIndex)
preloadManager?.remove(candidate.mediaItem)
candidatesByKey.remove(candidate.key)
mediaItemsByStreamIdentity.remove(candidate.streamIdentity)
@@ -132,7 +164,10 @@ internal class Media3PreloadWindowManager(
val targetStatusControl = object :
TargetPreloadStatusControl<Int, DefaultPreloadManager.PreloadStatus> {
override fun getTargetPreloadStatus(index: Int): DefaultPreloadManager.PreloadStatus =
- playerPreloadTargetStatus(currentIndex, index)
+ playerPreloadTargetStatus(
+ currentIndex, index, readsAllowed,
+ candidatesByRanking[index]?.mediaItem in completedMediaItems
+ )
?: DefaultPreloadManager.PreloadStatus.PRELOAD_STATUS_NOT_PRELOADED
}
val builder = DefaultPreloadManager.Builder(
@@ -147,6 +182,7 @@ internal class Media3PreloadWindowManager(
preloadManager = builder.build().also { it.addListener(listener) }
currentIndex = null
+ readsAllowed = false
safeLog("preload-window manager-created")
return builder.buildExoPlayer(
@@ -167,47 +203,93 @@ internal class Media3PreloadWindowManager(
return
}
- currentIndex = normalized.currentIndex
- manager.setCurrentPlayingIndex(normalized.currentIndex)
+ val currentItem = normalized.items[normalized.currentIndex]
+ val reusableCurrent = candidatesByKey[currentItem.key]
+ ?.takeIf { it.streamIdentity == preloadStreamIdentity(currentItem.streamInfo) }
+ if (reusableCurrent == null) providerLimitBlocked = false
+ val stableCurrentIndex = reusableCurrent?.rankingIndex ?: normalized.currentIndex
val nextCandidates = linkedMapOf<String, ManagedCandidate>()
normalized.items.forEachIndexed { rankingIndex, item ->
val streamIdentity = preloadStreamIdentity(item.streamInfo)
+ val expectedRankingIndex = stableCurrentIndex + rankingIndex - normalized.currentIndex
val existing = candidatesByKey[item.key]
- if (existing != null && existing.streamIdentity == streamIdentity) {
- nextCandidates[item.key] = existing.copy(rankingIndex = rankingIndex)
+ if (existing != null && existing.streamIdentity == streamIdentity &&
+ existing.rankingIndex == expectedRankingIndex
+ ) {
+ nextCandidates[item.key] = existing
return@forEachIndexed
}
- existing?.let { manager.remove(it.mediaItem) }
+ existing?.let {
+ manager.remove(it.mediaItem)
+ completedMediaItems.remove(it.mediaItem)
+ }
- val candidate = createManagedCandidate(item, rankingIndex, streamIdentity)
+ val candidate = createManagedCandidate(item, expectedRankingIndex, streamIdentity)
if (candidate != null) {
- manager.add(candidate.mediaSource, rankingIndex)
+ manager.add(candidate.mediaSource, expectedRankingIndex)
+ // RankingData is immutable inside Media3; every added candidate must use its
+ // stable ranking index, not the candidate's transient list position.
nextCandidates[item.key] = candidate
}
}
candidatesByKey.values
.filter { it.key !in nextCandidates }
- .forEach { manager.remove(it.mediaItem) }
+ .forEach {
+ manager.remove(it.mediaItem)
+ completedMediaItems.remove(it.mediaItem)
+ }
candidatesByKey.clear()
candidatesByKey.putAll(nextCandidates)
+ candidatesByRanking.clear()
+ candidatesByKey.values.forEach { candidate -> candidatesByRanking[candidate.rankingIndex] = candidate }
+ val adjacentCompletedItems = candidatesByKey.values
+ .filter { abs(it.rankingIndex - stableCurrentIndex) == 1 }
+ .mapTo(mutableSetOf()) { it.mediaItem }
+ completedMediaItems.retainAll(adjacentCompletedItems)
+ foregroundMediaItems.retainAll(candidatesByKey.values.mapTo(mutableSetOf()) { it.mediaItem })
+ currentIndex = stableCurrentIndex
+ manager.setCurrentPlayingIndex(stableCurrentIndex)
mediaItemsByStreamIdentity.clear()
candidatesByKey.values.forEach { candidate ->
mediaItemsByStreamIdentity[candidate.streamIdentity] = candidate.mediaItem
}
manager.invalidate()
safeLog(
- "preload-window accepted currentIndex=${normalized.currentIndex} " +
+ "preload-window accepted currentIndex=$stableCurrentIndex " +
"sourceCount=${candidatesByKey.size}"
)
}
- fun getMediaSource(streamInfo: StreamInfo): MediaSource? {
+ fun getMediaSource(streamInfo: StreamInfo): ManagedMediaSource? {
val manager = preloadManager ?: return null
if (released) return null
val mediaItem = mediaItemsByStreamIdentity[preloadStreamIdentity(streamInfo)] ?: return null
- return manager.getMediaSource(mediaItem)
+ val candidate = candidatesByKey.values.firstOrNull { it.mediaItem == mediaItem } ?: return null
+ completedMediaItems.remove(mediaItem)
+ foregroundMediaItems += mediaItem
+ val mediaSource = manager.getMediaSource(mediaItem) ?: return null
+ candidate.wasHandedToPlayback.set(true)
+ if (candidate.retryPolicy.hasPendingLoadRecovery) onForegroundRecoveryChanged()
+ return ManagedMediaSource(mediaSource, candidate.retryPolicy)
+ }
+
+ fun updateForegroundPlayback(
+ state: PlaybackState,
+ isPlaying: Boolean,
+ bufferedDurationMs: Long,
+ recovering: Boolean
+ ) {
+ if (released) return
+ val allowed = shouldAllowNeighborPreload(
+ readsAllowed, state, isPlaying, bufferedDurationMs, recovering, providerLimitBlocked
+ )
+ if (allowed == readsAllowed) return
+ readsAllowed = allowed
+ // NOT_PRELOADED cancels incomplete media periods. Completed ranges keep their handoff data.
+ preloadManager?.invalidate()
+ safeLog("preload-window readsAllowed=$allowed bufferMs=$bufferedDurationMs state=$state")
}
fun clearWindow() {
@@ -215,7 +297,12 @@ internal class Media3PreloadWindowManager(
if (released) return
manager.removeMediaItems(candidatesByKey.values.map(ManagedCandidate::mediaItem))
candidatesByKey.clear()
+ candidatesByRanking.clear()
mediaItemsByStreamIdentity.clear()
+ completedMediaItems.clear()
+ foregroundMediaItems.clear()
+ readsAllowed = false
+ providerLimitBlocked = false
currentIndex = null
manager.setCurrentPlayingIndex(-1)
manager.invalidate()
@@ -229,7 +316,10 @@ internal class Media3PreloadWindowManager(
preloadManager?.release()
preloadManager = null
candidatesByKey.clear()
+ candidatesByRanking.clear()
mediaItemsByStreamIdentity.clear()
+ completedMediaItems.clear()
+ foregroundMediaItems.clear()
currentIndex = null
safeLog("preload-window manager-released")
}
@@ -248,11 +338,20 @@ internal class Media3PreloadWindowManager(
return null
}
+ val wasHandedToPlayback = AtomicBoolean(false)
val plan = runCatching {
buildPlaybackPreparationPlan(
streamInfo = item.streamInfo,
preload = true,
- playbackStarted = { false }
+ playbackStarted = { wasHandedToPlayback.get() && playbackStarted() },
+ onLoadRecoveryChanged = {
+ // The policy is first used for background preloading, then reused if this
+ // exact source is handed to ExoPlayer. Refresh on either transition; the
+ // query below decides whether this candidate is currently foreground.
+ if (wasHandedToPlayback.get()) {
+ onForegroundRecoveryChanged()
+ }
+ }
)
}.getOrElse {
logSkip(item, "plan-failed")
@@ -282,6 +381,8 @@ internal class Media3PreloadWindowManager(
streamInfo = item.streamInfo,
mediaItem = mediaSource.mediaItem,
mediaSource = mediaSource,
+ retryPolicy = plan.retryPolicy,
+ wasHandedToPlayback = wasHandedToPlayback,
rankingIndex = rankingIndex,
streamIdentity = streamIdentity
)
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
index a2a6870d..473be4da 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
@@ -155,7 +155,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = LOW_MEMORY_PLAYBACK_BUFFER_MS,
rebufferMs = LOW_MEMORY_REBUFFER_MS,
targetBufferBytes = MPEG_TS_LIVE_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
lowMemoryDevice && compatibilityMode && isLive ->
PlaybackBufferPolicy(
@@ -165,7 +165,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = LOW_MEMORY_PLAYBACK_BUFFER_MS,
rebufferMs = LOW_MEMORY_REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
lowMemoryDevice && isLive ->
PlaybackBufferPolicy(
@@ -175,7 +175,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = LOW_MEMORY_PLAYBACK_BUFFER_MS,
rebufferMs = LOW_MEMORY_REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
lowMemoryDevice ->
PlaybackBufferPolicy(
@@ -185,7 +185,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = LOW_MEMORY_PLAYBACK_BUFFER_MS,
rebufferMs = LOW_MEMORY_REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
resolvedStreamType == ResolvedStreamType.MPEG_TS_LIVE ->
PlaybackBufferPolicy(
@@ -195,7 +195,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = PLAYBACK_BUFFER_MS,
rebufferMs = REBUFFER_MS,
targetBufferBytes = MPEG_TS_LIVE_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
compatibilityMode && isLive ->
PlaybackBufferPolicy(
@@ -205,7 +205,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = PLAYBACK_BUFFER_MS,
rebufferMs = REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
isLive ->
PlaybackBufferPolicy(
@@ -215,7 +215,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = PLAYBACK_BUFFER_MS,
rebufferMs = REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
else ->
PlaybackBufferPolicy(
@@ -225,7 +225,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = VOD_PLAYBACK_BUFFER_MS,
rebufferMs = VOD_REBUFFER_MS,
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true
+ prioritizeTimeOverSizeThresholds = false
)
}
@@ -239,8 +239,8 @@ internal object PlaybackBufferPolicies {
maxBufferMs = MEDIUM_LIVE_MAX_BUFFER_MS,
playbackBufferMs = MEDIUM_LIVE_PLAYBACK_BUFFER_MS,
rebufferMs = MEDIUM_LIVE_REBUFFER_MS,
- targetBufferBytes = MEDIUM_LIVE_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true,
+ targetBufferBytes = if (lowMemoryCapped) DEFAULT_TARGET_BUFFER_BYTES else MEDIUM_LIVE_TARGET_BUFFER_BYTES,
+ prioritizeTimeOverSizeThresholds = false,
qualityReason = qualityReason,
lowMemoryCapped = lowMemoryCapped
)
@@ -252,7 +252,7 @@ internal object PlaybackBufferPolicies {
playbackBufferMs = LARGE_LIVE_PLAYBACK_BUFFER_MS,
rebufferMs = LARGE_LIVE_REBUFFER_MS,
targetBufferBytes = LARGE_LIVE_TARGET_BUFFER_BYTES,
- prioritizeTimeOverSizeThresholds = true,
+ prioritizeTimeOverSizeThresholds = false,
qualityReason = qualityReason
)
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackLoadControl.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackLoadControl.kt
new file mode 100644
index 00000000..dcf8b274
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackLoadControl.kt
@@ -0,0 +1,118 @@
+@file:androidx.media3.common.util.UnstableApi
+
+package com.streamvault.player.playback
+
+import androidx.media3.common.C
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.LoadControl
+import androidx.media3.exoplayer.analytics.PlayerId
+import androidx.media3.exoplayer.trackselection.ExoTrackSelection
+import androidx.media3.exoplayer.source.TrackGroupArray
+import androidx.media3.exoplayer.upstream.DefaultAllocator
+
+/**
+ * Keep Media3's loading/start/rebuffer decisions, with a byte target sized for the
+ * selected tracks and this device. Size takes priority when samples stop draining.
+ * A target is not a hard ceiling: an in-flight chunk can overshoot it.
+ */
+internal class PlaybackLoadControl(
+ private val policy: PlaybackBufferPolicy,
+ heapBytes: Long,
+ multiview: Boolean
+) : DefaultLoadControl(
+ DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE),
+ policy.minBufferMs, policy.minBufferMs, policy.maxBufferMs, policy.maxBufferMs,
+ policy.playbackBufferMs, policy.playbackBufferMs, policy.rebufferMs, policy.rebufferMs,
+ C.LENGTH_UNSET, false, false, 0, false
+) {
+ @Volatile private var multiviewMode = multiview
+ // Accessed only on Media3's playback thread.
+ private val selections = mutableMapOf<PlayerId, Array<out ExoTrackSelection?>>()
+ private val appliedModes = mutableMapOf<PlayerId, Boolean>()
+ private val references = mutableMapOf<PlayerId, Int>()
+
+ override fun onPrepared(playerId: PlayerId) {
+ references[playerId] = (references[playerId] ?: 0) + 1
+ super.onPrepared(playerId)
+ }
+
+ fun setMultiview(multiview: Boolean) {
+ multiviewMode = multiview
+ }
+
+ override fun onTracksSelected(
+ parameters: LoadControl.Parameters,
+ trackGroups: TrackGroupArray,
+ trackSelections: Array<out ExoTrackSelection?>
+ ) {
+ selections[parameters.playerId] = trackSelections.copyOf()
+ appliedModes[parameters.playerId] = multiviewMode
+ super.onTracksSelected(parameters, trackGroups, trackSelections)
+ }
+
+ override fun shouldContinueLoading(parameters: LoadControl.Parameters): Boolean {
+ if (appliedModes[parameters.playerId] != multiviewMode) {
+ selections[parameters.playerId]?.let {
+ super.onTracksSelected(parameters, TrackGroupArray.EMPTY, it)
+ appliedModes[parameters.playerId] = multiviewMode
+ }
+ }
+ return super.shouldContinueLoading(parameters)
+ }
+
+ override fun onStopped(playerId: PlayerId) {
+ removeReference(playerId)
+ super.onStopped(playerId)
+ }
+
+ override fun onReleased(playerId: PlayerId) {
+ removeReference(playerId)
+ super.onReleased(playerId)
+ }
+
+ private fun removeReference(playerId: PlayerId) {
+ val remaining = (references[playerId] ?: return) - 1
+ if (remaining > 0) {
+ references[playerId] = remaining
+ } else {
+ references.remove(playerId)
+ selections.remove(playerId)
+ appliedModes.remove(playerId)
+ }
+ }
+ // Reserve half the Java heap for the app, decoder bookkeeping and chunk overshoot.
+ // Multiview has at most four foreground players; each gets one quarter of this pool.
+ // This is a conservative allocation policy, not a guarantee against every OOM.
+ private val deviceBudget = (heapBytes / 2).coerceAtMost(DEFAULT_MAX_BUFFER_SIZE.toLong())
+
+ override fun calculateTargetBufferBytes(
+ parameters: LoadControl.Parameters,
+ trackSelectionArray: Array<out ExoTrackSelection?>
+ ): Int {
+ val preload = parameters.playerId == PlayerId.PRELOAD
+ val sessionBudget = deviceBudget / if (multiviewMode) 4 else 1
+ val preloadBudget = (sessionBudget / 4).coerceAtLeast(C.DEFAULT_BUFFER_SEGMENT_SIZE.toLong())
+ val foregroundBudget = (sessionBudget - preloadBudget)
+ .coerceAtLeast(C.DEFAULT_BUFFER_SEGMENT_SIZE.toLong())
+ val budget = if (preload) preloadBudget else foregroundBudget
+ val durationMs = if (preload) PLAYER_PRELOAD_RANGE_MS else policy.maxBufferMs.toLong()
+ var knownBytes = 0L
+ var unknownBytes = 0L
+ for (selection in trackSelectionArray.filterNotNull()) {
+ // Include only eligible selection tracks, so Auto can move up without
+ // rebuilding the player, while a manual override retains its own sizing.
+ val bitrates = (0 until selection.length()).map { selection.getFormat(it).bitrate }
+ if (bitrates.all { it > 0 }) {
+ // 25% allows for bitrate variation and compressed sample overhead.
+ knownBytes += bitrates.max().toLong() * durationMs / 8_000 * 5 / 4
+ } else {
+ // Missing bitrate is common on IPTV. Use Media3's track-type estimate,
+ // rather than confusing download throughput with encoded media bitrate.
+ unknownBytes += super.calculateTargetBufferBytes(parameters, arrayOf(selection))
+ }
+ }
+ val floor = if (preload) DEFAULT_MIN_BUFFER_SIZE else
+ maxOf(DEFAULT_MIN_BUFFER_SIZE, policy.targetBufferBytes)
+ return (knownBytes + unknownBytes).coerceAtLeast(floor.toLong()).coerceAtMost(budget).toInt()
+ }
+}
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
index b96c6fb5..020907cf 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
@@ -13,7 +13,8 @@ internal fun buildPlaybackPreparationPlan(
streamInfo: StreamInfo,
preload: Boolean,
fastRetryOnTransientFailures: () -> Boolean = { false },
- playbackStarted: () -> Boolean
+ playbackStarted: () -> Boolean,
+ onLoadRecoveryChanged: () -> Unit = {}
): PlaybackPreparationPlan {
val resolvedStreamType = StreamTypeResolver.resolve(streamInfo)
val timeoutProfile = PlayerTimeoutProfile.resolve(streamInfo, resolvedStreamType, preload = preload)
@@ -29,6 +30,7 @@ internal fun buildPlaybackPreparationPlan(
retryPolicy = PlayerRetryPolicy(
streamContext = retryContext,
fastRetryOnTransientFailures = fastRetryOnTransientFailures,
+ onLoadRecoveryChanged = onLoadRecoveryChanged,
playbackStarted = playbackStarted
)
)
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicy.kt
index 1d631831..b73749b6 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicy.kt
@@ -1,7 +1,11 @@
package com.streamvault.player.playback
import com.streamvault.domain.model.PlaybackContentKind
-import com.streamvault.player.PlaybackState
+
+internal fun shouldDeferAppStallRecovery(
+ activeMediaLoadRetry: Boolean,
+ sourceRetryPending: Boolean
+): Boolean = activeMediaLoadRetry || sourceRetryPending
internal fun shouldRecoverReadyStalls(resolvedStreamType: ResolvedStreamType): Boolean =
true
@@ -15,13 +19,3 @@ internal fun shouldRecoverFrameSilentReadyStalls(
resolvedStreamType: ResolvedStreamType,
playbackContentKind: PlaybackContentKind = PlaybackContentKind.UNKNOWN
): Boolean = isLivePlayback(playbackContentKind, resolvedStreamType)
-
-internal fun shouldReconnectLiveStall(
- playbackState: PlaybackState,
- resolvedStreamType: ResolvedStreamType,
- recoveryAttempt: Int,
- playbackContentKind: PlaybackContentKind = PlaybackContentKind.UNKNOWN
-): Boolean =
- recoveryAttempt == 1 &&
- isLivePlayback(playbackContentKind, resolvedStreamType) &&
- (playbackState == PlaybackState.BUFFERING || playbackState == PlaybackState.READY)
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibility.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibility.kt
new file mode 100644
index 00000000..c542ffc5
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibility.kt
@@ -0,0 +1,35 @@
+package com.streamvault.player.playback
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.mediacodec.MediaCodecInfo
+import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
+
+@UnstableApi
+internal class PlaybackVideoCodecCompatibility(
+ private val delegate: MediaCodecSelector,
+ private val emulatorWorkaroundEligible: Boolean
+) : MediaCodecSelector {
+ override fun getDecoderInfos(
+ mimeType: String,
+ requiresSecureDecoder: Boolean,
+ requiresTunnelingDecoder: Boolean
+ ): MutableList<MediaCodecInfo> = delegate.getDecoderInfos(
+ mimeType, requiresSecureDecoder, requiresTunnelingDecoder
+ ).map { info ->
+ // Goldfish advertises seamless AVC adaptation but can retain the old output crop.
+ // Keep Media3's renderer and let its nonseamless adaptation recreate the codec.
+ if (emulatorWorkaroundEligible && mimeType == "video/avc" &&
+ info.mimeType == "video/avc" && info.name == "c2.goldfish.h264.decoder" &&
+ info.adaptive
+ ) {
+ MediaCodecInfo.newInstance(
+ info.name, info.mimeType, info.codecMimeType, info.capabilities,
+ info.hardwareAccelerated, info.softwareOnly, info.vendor,
+ /* forceDisableAdaptive = */ true,
+ /* forceSecure = */ info.secure
+ )
+ } else {
+ info
+ }
+ }.toMutableList()
+}
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
index f5909590..7571194d 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
@@ -19,17 +19,12 @@ import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Protocol
-internal fun shouldUsePlatformHttpDataSource(resolvedStreamType: ResolvedStreamType): Boolean =
- false
-
@UnstableApi
class PlayerDataSourceFactoryProvider(
private val context: Context,
private val baseClient: OkHttpClient,
/** Receives byte counts for foreground (non-preload) playback; used for measured bitrate stats. */
- private val transferListener: TransferListener? = null,
- /** Receives the same foreground transfers for Media3's adaptive bandwidth estimate. */
- private val additionalTransferListener: TransferListener? = null
+ private val transferListener: TransferListener? = null
) {
private companion object {
private const val TAG = "PlayerDataSource"
@@ -114,7 +109,7 @@ class PlayerDataSourceFactoryProvider(
}
val defaultFactory = DefaultDataSource.Factory(context, upstreamFactory)
if (!preload) {
- playbackTransferListener()?.let(defaultFactory::setTransferListener)
+ transferListener?.let(defaultFactory::setTransferListener)
}
val factory = if (shouldWrapDataSourceReadStats(resolvedStreamType)) {
PlayerDataSourceReadStatsFactory(
@@ -128,12 +123,6 @@ class PlayerDataSourceFactoryProvider(
return profile to factory
}
- private fun playbackTransferListener(): TransferListener? = when {
- transferListener == null -> additionalTransferListener
- additionalTransferListener == null -> transferListener
- else -> CompositeTransferListener(transferListener, additionalTransferListener)
- }
-
internal fun clientCacheSizeForTests(): Int = clientsByKey.size()
private fun logRequestShape(
@@ -174,43 +163,6 @@ class PlayerDataSourceFactoryProvider(
}
}
-private class CompositeTransferListener(
- private vararg val listeners: TransferListener
-) : TransferListener {
- override fun onTransferInitializing(
- source: DataSource,
- dataSpec: androidx.media3.datasource.DataSpec,
- isNetwork: Boolean
- ) {
- listeners.forEach { it.onTransferInitializing(source, dataSpec, isNetwork) }
- }
-
- override fun onTransferStart(
- source: DataSource,
- dataSpec: androidx.media3.datasource.DataSpec,
- isNetwork: Boolean
- ) {
- listeners.forEach { it.onTransferStart(source, dataSpec, isNetwork) }
- }
-
- override fun onBytesTransferred(
- source: DataSource,
- dataSpec: androidx.media3.datasource.DataSpec,
- isNetwork: Boolean,
- bytesTransferred: Int
- ) {
- listeners.forEach { it.onBytesTransferred(source, dataSpec, isNetwork, bytesTransferred) }
- }
-
- override fun onTransferEnd(
- source: DataSource,
- dataSpec: androidx.media3.datasource.DataSpec,
- isNetwork: Boolean
- ) {
- listeners.forEach { it.onTransferEnd(source, dataSpec, isNetwork) }
- }
-}
-
internal fun effectivePlaybackRequestProperties(
headers: Map<String, String>,
userAgent: String?
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt b/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
index 35011791..d9553091 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
@@ -15,6 +15,7 @@ import javax.net.ssl.SSLHandshakeException
enum class PlaybackErrorCategory {
NETWORK,
HTTP_AUTH,
+ HTTP_NOT_FOUND,
HTTP_SERVER,
PROVIDER_LIMIT,
EMPTY_RESPONSE,
@@ -46,6 +47,7 @@ object PlayerErrorClassifier {
playbackException?.errorCode == PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW ->
PlaybackErrorCategory.LIVE_WINDOW
httpCode == 401 || httpCode == 403 || httpCode == 456 -> PlaybackErrorCategory.HTTP_AUTH
+ httpCode == 404 -> PlaybackErrorCategory.HTTP_NOT_FOUND
httpCode == 509 -> PlaybackErrorCategory.PROVIDER_LIMIT
httpCode == 204 -> PlaybackErrorCategory.EMPTY_RESPONSE
httpCode in setOf(408, 429, 500, 502, 503, 504) -> PlaybackErrorCategory.HTTP_SERVER
@@ -79,7 +81,7 @@ object PlayerErrorClassifier {
}
private fun parseHttpStatus(message: String?): Int? {
- return Regex("""\b(204|401|403|408|429|456|500|502|503|504|509)\b""").find(message.orEmpty())
+ return Regex("""\b(204|401|403|404|408|429|456|500|502|503|504|509)\b""").find(message.orEmpty())
?.groupValues
?.getOrNull(1)
?.toIntOrNull()
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
index dca4fdc0..1f1e36ec 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
@@ -1,17 +1,21 @@
package com.streamvault.player.playback
+import android.util.Log
import androidx.media3.common.C
import androidx.media3.common.PlaybackException
import androidx.media3.common.util.UnstableApi
import androidx.media3.datasource.HttpDataSource
import androidx.media3.exoplayer.source.BehindLiveWindowException
+import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy
import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
import com.streamvault.domain.model.PlaybackContentKind
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.net.UnknownHostException
+import java.util.concurrent.ConcurrentHashMap
private const val FAST_TRANSIENT_RETRY_DELAY_MS = 500L
+private const val MAX_WHOLE_SOURCE_RETRIES_PER_OUTAGE = 1
private const val LIVE_TRANSIENT_RETRY_ATTEMPTS = 10
private const val LIVE_HLS_MALFORMED_RETRY_ATTEMPTS_AFTER_START = 12
@@ -28,8 +32,16 @@ data class PlaybackRetryContext(
class PlayerRetryPolicy(
private val streamContext: PlaybackRetryContext,
private val fastRetryOnTransientFailures: () -> Boolean = { false },
+ private val onLoadRecoveryChanged: () -> Unit = {},
private val playbackStarted: () -> Boolean
) : LoadErrorHandlingPolicy {
+ private val defaultFallbackPolicy = DefaultLoadErrorHandlingPolicy()
+ private val pendingLoadRecoveryTaskIds = ConcurrentHashMap.newKeySet<Long>()
+
+ /** True while Media3 still owns a retry or fallback for a failed load task. */
+ val hasPendingLoadRecovery: Boolean
+ get() = pendingLoadRecoveryTaskIds.isNotEmpty()
+
fun maxAttempts(error: Throwable, playbackStarted: Boolean): Int {
return maxAttemptsFor(error, streamContext, playbackStarted)
}
@@ -48,6 +60,23 @@ class PlayerRetryPolicy(
return attempt <= maxAttempts && maxAttempts > 0
}
+ /**
+ * App-level source replacement is a last resort after Media3 has exhausted its
+ * per-load retry and fallback handling. Allow one replacement per outage episode.
+ */
+ fun shouldRetryWholeSource(error: Throwable, playbackStarted: Boolean, attempt: Int): Boolean =
+ attempt <= MAX_WHOLE_SOURCE_RETRIES_PER_OUTAGE &&
+ shouldRetry(error, streamContext, playbackStarted, attempt)
+
+ fun maxWholeSourceRetryAttempts(error: Throwable, playbackStarted: Boolean): Int =
+ if (maxAttempts(error, playbackStarted) > 0) MAX_WHOLE_SOURCE_RETRIES_PER_OUTAGE else 0
+
+ fun clearPendingLoadRecovery() {
+ val hadPendingRecovery = pendingLoadRecoveryTaskIds.isNotEmpty()
+ pendingLoadRecoveryTaskIds.clear()
+ if (hadPendingRecovery) onLoadRecoveryChanged()
+ }
+
fun retryDelayMs(error: Throwable, attempt: Int): Long {
val category = PlayerErrorClassifier.classify(error)
if (fastRetryOnTransientFailures() && isFastRetryEligible(category)) {
@@ -75,6 +104,7 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.SOURCE_MALFORMED ->
streamContext.isLive && streamContext.resolvedStreamType == ResolvedStreamType.HLS
PlaybackErrorCategory.HTTP_AUTH,
+ PlaybackErrorCategory.HTTP_NOT_FOUND,
PlaybackErrorCategory.SSL,
PlaybackErrorCategory.CLEAR_TEXT_BLOCKED,
PlaybackErrorCategory.DRM,
@@ -88,6 +118,7 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.LIVE_WINDOW -> "refresh-live-window"
PlaybackErrorCategory.NETWORK -> "transient-network"
PlaybackErrorCategory.HTTP_SERVER -> "server-retryable"
+ PlaybackErrorCategory.HTTP_NOT_FOUND -> "source-not-found"
PlaybackErrorCategory.PROVIDER_LIMIT -> "terminal-provider-limit"
PlaybackErrorCategory.EMPTY_RESPONSE -> "terminal-empty-response"
PlaybackErrorCategory.SOURCE_MALFORMED ->
@@ -114,7 +145,27 @@ class PlayerRetryPolicy(
override fun getFallbackSelectionFor(
fallbackOptions: LoadErrorHandlingPolicy.FallbackOptions,
loadErrorInfo: LoadErrorHandlingPolicy.LoadErrorInfo
- ): LoadErrorHandlingPolicy.FallbackSelection? = null
+ ): LoadErrorHandlingPolicy.FallbackSelection? {
+ val adaptiveSource = when (streamContext.resolvedStreamType) {
+ ResolvedStreamType.HLS,
+ ResolvedStreamType.DASH,
+ ResolvedStreamType.SMOOTH_STREAMING -> true
+ else -> false
+ }
+ if (!adaptiveSource) return null
+
+ val category = PlayerErrorClassifier.classify(loadErrorInfo.exception)
+ if (category != PlaybackErrorCategory.HTTP_SERVER &&
+ category != PlaybackErrorCategory.HTTP_NOT_FOUND &&
+ category != PlaybackErrorCategory.UNKNOWN
+ ) return null
+
+ val selection = defaultFallbackPolicy.getFallbackSelectionFor(fallbackOptions, loadErrorInfo)
+ if (selection != null) {
+ markLoadRecoveryPending(loadErrorInfo.loadEventInfo.loadTaskId)
+ }
+ return selection
+ }
override fun getMinimumLoadableRetryCount(dataType: Int): Int {
return when {
@@ -130,13 +181,37 @@ class PlayerRetryPolicy(
val attempt = loadErrorInfo.errorCount
val error = loadErrorInfo.exception
val started = playbackStarted()
- if (!shouldRetry(error, streamContext, started, attempt)) {
- return C.TIME_UNSET
+ val category = PlayerErrorClassifier.classify(error)
+ val retryDelayMs = if (shouldRetry(error, streamContext, started, attempt)) {
+ retryDelayMs(error, attempt)
+ } else {
+ C.TIME_UNSET
+ }
+ if (Log.isLoggable("PlaybackPerf", Log.DEBUG)) {
+ val causeTypes = generateSequence<Throwable>(error) { it.cause }
+ .map { it.javaClass.simpleName }
+ .distinct()
+ .joinToString(">")
+ Log.d(
+ "PlaybackPerf",
+ "load-retry category=$category attempt=$attempt delayMs=$retryDelayMs " +
+ "started=$started streamType=${streamContext.resolvedStreamType} " +
+ "contentKind=${streamContext.playbackContentKind} causes=$causeTypes"
+ )
+ }
+ if (retryDelayMs != C.TIME_UNSET) {
+ markLoadRecoveryPending(loadErrorInfo.loadEventInfo.loadTaskId)
}
- return retryDelayMs(error, attempt)
+ return retryDelayMs
}
- override fun onLoadTaskConcluded(loadTaskId: Long) = Unit
+ override fun onLoadTaskConcluded(loadTaskId: Long) {
+ if (pendingLoadRecoveryTaskIds.remove(loadTaskId)) onLoadRecoveryChanged()
+ }
+
+ private fun markLoadRecoveryPending(loadTaskId: Long) {
+ if (pendingLoadRecoveryTaskIds.add(loadTaskId)) onLoadRecoveryChanged()
+ }
private fun maxAttemptsFor(
error: Throwable,
@@ -148,7 +223,8 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.DECODER,
PlaybackErrorCategory.CLEAR_TEXT_BLOCKED,
PlaybackErrorCategory.SSL,
- PlaybackErrorCategory.HTTP_AUTH -> 0
+ PlaybackErrorCategory.HTTP_AUTH,
+ PlaybackErrorCategory.HTTP_NOT_FOUND -> 0
PlaybackErrorCategory.FORMAT_UNSUPPORTED -> if (playbackStarted) 1 else 0
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.kt
index f0e92603..d395d1e0 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.kt
@@ -39,14 +39,28 @@ internal fun resolveRetryAttemptAfterPlaybackStarted(currentAttempt: Int): Int {
return 0
}
-internal fun resolveRetryAttemptForCategory(
- currentAttempt: Int,
- lastCategory: PlaybackErrorCategory?,
- nextCategory: PlaybackErrorCategory
-): Int {
- if (currentAttempt <= 0) return 1
- if (lastCategory != nextCategory) return 1
- return currentAttempt + 1
+internal fun resolveNextAppSourceRetryAttempt(currentAttempt: Int): Int =
+ (currentAttempt + 1).coerceAtLeast(1)
+
+internal fun isScheduledAppSourceRetryCurrent(
+ scheduledGeneration: Long,
+ currentGeneration: Long,
+ scheduledMediaId: String,
+ currentMediaId: String?,
+ scheduledAttempt: Int,
+ currentAttempt: Int
+): Boolean = scheduledGeneration == currentGeneration &&
+ scheduledMediaId == currentMediaId &&
+ scheduledAttempt == currentAttempt
+
+internal fun resolveScheduledRetrySeekPositionMs(
+ category: PlaybackErrorCategory,
+ plannedPositionMs: Long?,
+ userSeekOverrideMs: Long?
+): Long? = if (category == PlaybackErrorCategory.LIVE_WINDOW) {
+ null
+} else {
+ userSeekOverrideMs ?: plannedPositionMs
}
private fun Long?.isFiniteMediaDuration(): Boolean {
diff --git a/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt b/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt
deleted file mode 100644
index 6c2ac1f9..00000000
--- a/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt
+++ /dev/null
@@ -1,143 +0,0 @@
-package com.streamvault.player.playback
-
-import android.util.Log
-import androidx.annotation.MainThread
-import androidx.media3.exoplayer.source.MediaSource
-import com.streamvault.domain.model.StreamInfo
-
-/**
- * Main-thread-only cache for a single preloaded media source owned by Media3PlayerEngine.
- */
-@MainThread
-class PreloadCoordinator(
- private val nowMs: () -> Long = { System.currentTimeMillis() }
-) {
- var currentPreloadedMediaId: String? = null
- private set
- var currentPreloadedNormalizedUrl: String? = null
- private set
- var preloadedMediaSource: MediaSource? = null
- private set
- var createdAtMs: Long = 0L
- private set
-
- private var currentResolvedType: ResolvedStreamType? = null
- private var currentDrmKey: String? = null
- private var currentHeadersHash: String? = null
-
- @MainThread
- fun store(mediaId: String, streamInfo: StreamInfo, resolvedType: ResolvedStreamType, mediaSource: MediaSource) {
- currentPreloadedMediaId = mediaId
- currentPreloadedNormalizedUrl = normalizedUrl(streamInfo.url)
- preloadedMediaSource = mediaSource
- currentResolvedType = resolvedType
- currentDrmKey = drmKey(streamInfo)
- currentHeadersHash = headersHash(streamInfo)
- createdAtMs = nowMs()
- safeLog("preload stored mediaId=$mediaId type=$resolvedType target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}")
- }
-
- @MainThread
- fun tryReuse(mediaId: String, streamInfo: StreamInfo, resolvedType: ResolvedStreamType): MediaSource? {
- val result = when {
- preloadedMediaSource == null -> null
- isExpired() -> {
- invalidate("expired")
- null
- }
- currentPreloadedMediaId != mediaId -> {
- invalidate("different-media-id")
- null
- }
- currentPreloadedNormalizedUrl != normalizedUrl(streamInfo.url) -> {
- invalidate("different-url")
- null
- }
- currentResolvedType != resolvedType -> {
- invalidate("different-stream-type")
- null
- }
- currentDrmKey != drmKey(streamInfo) -> {
- invalidate("different-drm")
- null
- }
- currentHeadersHash != headersHash(streamInfo) -> {
- invalidate("different-headers")
- null
- }
- else -> preloadedMediaSource
- }
- if (result != null) {
- safeLog("preload reused mediaId=$mediaId target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}")
- clear()
- }
- return result
- }
-
- @MainThread
- fun onPlaybackStarted(mediaId: String) {
- if (currentPreloadedMediaId != null && currentPreloadedMediaId != mediaId) {
- invalidate("playback-started-different-media")
- }
- }
-
- @MainThread
- fun invalidate(reason: String) {
- if (preloadedMediaSource != null) {
- safeLog("preload invalidated reason=$reason mediaId=$currentPreloadedMediaId")
- }
- clear()
- }
-
- @MainThread
- fun release() {
- invalidate("release")
- }
-
- @MainThread
- fun isExpired(): Boolean = preloadedMediaSource != null && nowMs() - createdAtMs > PRELOAD_EXPIRY_MS
-
- private fun clear() {
- currentPreloadedMediaId = null
- currentPreloadedNormalizedUrl = null
- preloadedMediaSource = null
- currentResolvedType = null
- currentDrmKey = null
- currentHeadersHash = null
- createdAtMs = 0L
- }
-
- private fun normalizedUrl(url: String): String {
- return url.trim().substringBefore('#')
- }
-
- private fun drmKey(streamInfo: StreamInfo): String? {
- return streamInfo.drmInfo?.let {
- // Sort header keys for a deterministic fingerprint across JVM restarts.
- val headersPart = it.headers.entries
- .sortedBy { e -> e.key }
- .joinToString("&") { e -> "${e.key}=${e.value}" }
- "${it.scheme}:${it.staticClearKeyLicense?.fingerprint ?: stableHash(it.licenseUrl)}:${stableHash(headersPart)}"
- }
- }
-
- private fun headersHash(streamInfo: StreamInfo): String {
- // Build a sorted, deterministic string representation of the effective headers so that
- // two identical header maps always produce the same fingerprint after a JVM restart.
- // hashCode() is NOT content-stable across restarts and must not be used here.
- val effectiveHeaders = (streamInfo.headers.toSortedMap() + ("User-Agent" to (streamInfo.userAgent ?: "")))
- val canonical = effectiveHeaders.entries.joinToString("&") { "${it.key}=${it.value}" }
- return stableHash(canonical)
- }
-
-
-
- companion object {
- private const val TAG = "PreloadCoordinator"
- private const val PRELOAD_EXPIRY_MS = 2 * 60 * 1000L
- }
-
- private fun safeLog(message: String) {
- runCatching { Log.i(TAG, message) }
- }
-}
diff --git a/player/src/main/java/com/streamvault/player/playback/StableHash.kt b/player/src/main/java/com/streamvault/player/playback/StableHash.kt
index fa98a798..8152614f 100644
--- a/player/src/main/java/com/streamvault/player/playback/StableHash.kt
+++ b/player/src/main/java/com/streamvault/player/playback/StableHash.kt
@@ -2,7 +2,7 @@ package com.streamvault.player.playback
import java.security.MessageDigest
-// Cached instance — safe because all callers (PreloadCoordinator) are Main-thread-only.
+// Reused for media-source and preload identity fingerprints.
private val sha256: MessageDigest = MessageDigest.getInstance("SHA-256")
/** SHA-256 fingerprint truncated to 16 hex chars — stable across JVM restarts. */
diff --git a/player/src/main/java/com/streamvault/player/playback/VideoStallDetector.kt b/player/src/main/java/com/streamvault/player/playback/VideoStallDetector.kt
index b355f9b8..0b037afb 100644
--- a/player/src/main/java/com/streamvault/player/playback/VideoStallDetector.kt
+++ b/player/src/main/java/com/streamvault/player/playback/VideoStallDetector.kt
@@ -16,6 +16,14 @@ class VideoStallDetector(
private var lastPositionCheckMs: Long = 0L
private var stalled = false
+ @Synchronized
+ fun restartAfterRecoveryAttempt() {
+ startedAtMs = nowMs()
+ lastPositionCheckMs = startedAtMs
+ stalled = false
+ // Retain lastFrameAtMs: a seek attempt is not evidence of a rendered frame.
+ }
+
@Synchronized
fun reset() {
val now = nowMs()
diff --git a/player/src/main/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracks.kt b/player/src/main/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracks.kt
new file mode 100644
index 00000000..f85e7620
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracks.kt
@@ -0,0 +1,67 @@
+package com.streamvault.player.tracks
+
+import androidx.media3.common.Format
+import androidx.media3.common.C
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.TrackSelectionOverride
+import androidx.media3.common.Tracks
+import com.streamvault.player.playback.DecodePressureRendition
+
+internal data class DecodePressureTrackContext(val group: TrackGroup, val indices: List<Int>, val renditions: List<DecodePressureRendition>)
+internal class AdaptiveDecodePressureTracks {
+ private var ownedOverride: TrackSelectionOverride? = null
+
+ fun context(tracks: Tracks, selected: Format?, parameters: TrackSelectionParameters, automatic: Boolean): DecodePressureTrackContext? {
+ if (!automatic || selected == null || parameters.disabledTrackTypes.contains(C.TRACK_TYPE_VIDEO)) return null
+ if (parameters.overrides.values.any { it.type == C.TRACK_TYPE_VIDEO && it != ownedOverride }) return null
+ val current = tracks.groups.singleOrNull {
+ it.type == C.TRACK_TYPE_VIDEO && it.isSelected && it.isAdaptiveSupported
+ } ?: return null
+ if (ownedOverride != null && ownedOverride?.mediaTrackGroup != current.mediaTrackGroup) return null
+ val indices = (0 until current.length).filter { index ->
+ val f = current.mediaTrackGroup.getFormat(index)
+ current.isTrackSupported(index, false) && f.sampleMimeType == selected.sampleMimeType &&
+ f.height > 0 && f.bitrate > 0 && f.height <= parameters.maxVideoHeight &&
+ f.width <= parameters.maxVideoWidth && f.bitrate <= parameters.maxVideoBitrate &&
+ f.height >= parameters.minVideoHeight && f.width >= parameters.minVideoWidth &&
+ f.bitrate >= parameters.minVideoBitrate &&
+ (f.frameRate == Format.NO_VALUE.toFloat() ||
+ f.frameRate in parameters.minVideoFrameRate.toFloat()..parameters.maxVideoFrameRate.toFloat()) &&
+ fitsViewport(f, parameters)
+ }
+ if (indices.size < 2) return null
+ return DecodePressureTrackContext(current.mediaTrackGroup, indices, indices.map {
+ val f = current.mediaTrackGroup.getFormat(it)
+ DecodePressureRendition(f.height, f.bitrate)
+ })
+ }
+
+ fun constrain(parameters: TrackSelectionParameters, context: DecodePressureTrackContext, height: Int?, bitrate: Int = Int.MAX_VALUE): TrackSelectionParameters {
+ if (height == null) return clear(parameters)
+ val indices = context.indices.filter {
+ val format = context.group.getFormat(it)
+ format.height <= height && format.bitrate <= bitrate
+ }
+ if (indices.isEmpty()) return parameters
+ val override = TrackSelectionOverride(context.group, indices)
+ ownedOverride = override
+ // A multiple-track override leaves Media3 ABR within this exact supported subset.
+ return parameters.buildUpon().setOverrideForType(override).build()
+ }
+
+ fun clear(parameters: TrackSelectionParameters): TrackSelectionParameters {
+ val own = ownedOverride
+ ownedOverride = null
+ return if (own != null && parameters.overrides[own.mediaTrackGroup] == own) {
+ parameters.buildUpon().clearOverride(own.mediaTrackGroup).build()
+ } else parameters
+ }
+
+ // Conservative eligibility: decline pressure adaptation when the viewport cannot
+ // contain two candidates, rather than bypass the selector's viewport preferences.
+ private fun fitsViewport(format: Format, parameters: TrackSelectionParameters): Boolean =
+ (format.width <= parameters.viewportWidth && format.height <= parameters.viewportHeight) ||
+ (parameters.viewportOrientationMayChange && format.height <= parameters.viewportWidth &&
+ format.width <= parameters.viewportHeight)
+}
diff --git a/player/src/main/java/com/streamvault/player/tracks/PlayerTrackController.kt b/player/src/main/java/com/streamvault/player/tracks/PlayerTrackController.kt
index 33639bbd..163bd6f9 100644
--- a/player/src/main/java/com/streamvault/player/tracks/PlayerTrackController.kt
+++ b/player/src/main/java/com/streamvault/player/tracks/PlayerTrackController.kt
@@ -31,6 +31,7 @@ class PlayerTrackController(
val availableVideoTracks: StateFlow<List<PlayerTrack>> = _availableVideoTracks.asStateFlow()
private var selectedVideoTrackId: String = PLAYER_TRACK_AUTO_ID
+ internal val isVideoAutoSelected: Boolean get() = selectedVideoTrackId == PLAYER_TRACK_AUTO_ID
private var preferredAudioLanguageTag: String? = null
private var preferredWifiMaxVideoHeight: Int? = null
private var preferredEthernetMaxVideoHeight: Int? = null
@@ -140,7 +141,7 @@ class PlayerTrackController(
if (isAudio || isText || isVideo) {
for (index in 0 until group.length) {
val format = group.mediaTrackGroup.getFormat(index)
- val id = format.id ?: "${group.mediaTrackGroup.hashCode()}_$index"
+ val id = playerTrackId(format, type, group.mediaTrackGroup.hashCode(), index)
val track = PlayerTrack(
id = id,
name = buildTrackName(format, type, index),
@@ -238,7 +239,7 @@ class PlayerTrackController(
if (group.mediaTrackGroup.type != trackType) continue
for (index in 0 until group.length) {
val format = group.mediaTrackGroup.getFormat(index)
- val id = format.id ?: "${group.mediaTrackGroup.hashCode()}_$index"
+ val id = playerTrackId(format, trackType, group.mediaTrackGroup.hashCode(), index)
if (id == trackId) {
return TrackSelectionOverride(group.mediaTrackGroup, listOf(index))
}
@@ -324,9 +325,31 @@ internal fun normalizeSelectedVideoTrackId(
selectedTrackId: String,
availableTrackIds: List<String>
): String = when {
- availableTrackIds.isEmpty() -> PLAYER_TRACK_AUTO_ID
selectedTrackId == PLAYER_TRACK_AUTO_ID -> PLAYER_TRACK_AUTO_ID
+ availableTrackIds.isEmpty() -> selectedTrackId
selectedTrackId in availableTrackIds -> selectedTrackId
availableTrackIds.size == 1 -> availableTrackIds.first()
else -> PLAYER_TRACK_AUTO_ID
}
+
+internal fun playerTrackId(format: Format, trackType: Int, trackGroupHash: Int, index: Int): String =
+ format.id ?: if (trackType == C.TRACK_TYPE_VIDEO) {
+ listOf(
+ "video",
+ format.sampleMimeType.orEmpty(),
+ format.codecs.orEmpty(),
+ "${format.width}x${format.height}",
+ format.bitrate,
+ format.averageBitrate,
+ format.frameRate.toBits(),
+ format.rotationDegrees,
+ format.roleFlags,
+ format.selectionFlags,
+ format.language.orEmpty(),
+ format.label.orEmpty(),
+ format.colorInfo?.hashCode() ?: 0,
+ index
+ ).joinToString(":")
+ } else {
+ "${trackGroupHash}_$index"
+ }
diff --git a/player/src/test/java/com/streamvault/player/Media3PlayerEngineAudioAnalyticsTest.kt b/player/src/test/java/com/streamvault/player/Media3PlayerEngineAudioAnalyticsTest.kt
new file mode 100644
index 00000000..4c8f0f9e
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/Media3PlayerEngineAudioAnalyticsTest.kt
@@ -0,0 +1,85 @@
+package com.streamvault.player
+
+import androidx.media3.common.Timeline
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackCompatibilityKey
+import com.streamvault.domain.repository.PlaybackCompatibilityRepository
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import okhttp3.OkHttpClient
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@UnstableApi
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+class Media3PlayerEngineAudioAnalyticsTest {
+
+ private val engine = Media3PlayerEngine(
+ context = RuntimeEnvironment.getApplication(),
+ okHttpClient = OkHttpClient(),
+ playbackCompatibilityRepository = NoOpPlaybackCompatibilityRepository,
+ audioCompatibilityMemoryStore = AudioCompatibilityMemoryStore(RuntimeEnvironment.getApplication()),
+ playbackSupportSnapshotStore = PlaybackSupportSnapshotStore(RuntimeEnvironment.getApplication())
+ )
+
+ @After
+ fun tearDown() {
+ engine.release()
+ }
+
+ @Test
+ fun `nonfatal audio analytics errors do not emit playback failures`() = runTest {
+ val observedErrors = mutableListOf<PlayerError?>()
+ backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
+ engine.error.collect(observedErrors::add)
+ }
+ val listener = analyticsListener()
+ val eventTime = AnalyticsListener.EventTime(
+ 0L,
+ Timeline.EMPTY,
+ 0,
+ null,
+ 0L,
+ Timeline.EMPTY,
+ 0,
+ null,
+ 0L,
+ 0L
+ )
+
+ listener.onAudioSinkError(eventTime, IllegalStateException("timestamp discontinuity"))
+ listener.onAudioCodecError(eventTime, IllegalStateException("codec diagnostic"))
+
+ assertThat(observedErrors).isEmpty()
+ }
+
+ private fun analyticsListener(): AnalyticsListener {
+ val method = Media3PlayerEngine::class.java.getDeclaredMethod("createAnalyticsListener")
+ method.isAccessible = true
+ return method.invoke(engine) as AnalyticsListener
+ }
+
+ private object NoOpPlaybackCompatibilityRepository : PlaybackCompatibilityRepository {
+ override suspend fun getKnownBadRecords(
+ deviceFingerprint: String,
+ streamType: String,
+ videoMimeType: String,
+ resolutionBucket: String
+ ) = emptyList<com.streamvault.domain.model.PlaybackCompatibilityRecord>()
+
+ override suspend fun recordFailure(key: PlaybackCompatibilityKey, failureType: String, at: Long) = Unit
+
+ override suspend fun recordSuccess(key: PlaybackCompatibilityKey, at: Long) = Unit
+
+ override suspend fun prune(maxRecords: Int, olderThanMs: Long) = Unit
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/Media3PlayerEngineDecodePressureTest.kt b/player/src/test/java/com/streamvault/player/Media3PlayerEngineDecodePressureTest.kt
new file mode 100644
index 00000000..f53d4aad
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/Media3PlayerEngineDecodePressureTest.kt
@@ -0,0 +1,110 @@
+package com.streamvault.player
+
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.Player
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.DecoderCounters
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackCompatibilityKey
+import com.streamvault.domain.repository.PlaybackCompatibilityRepository
+import com.streamvault.player.playback.ResolvedStreamType
+import java.lang.reflect.Proxy
+import okhttp3.OkHttpClient
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class Media3PlayerEngineDecodePressureTest {
+ private val context = RuntimeEnvironment.getApplication()
+ private val engine = Media3PlayerEngine(context, OkHttpClient(), NoOpRepository,
+ AudioCompatibilityMemoryStore(context), PlaybackSupportSnapshotStore(context))
+ private val formats = listOf(format("high", 2160, 41_000_000), format("mid", 1080, 9_000_000), format("low", 720, 3_000_000))
+ private val group = TrackGroup("ladder", *formats.toTypedArray())
+ private val tracks = Tracks(listOf(Tracks.Group(group, true, IntArray(3) { C.FORMAT_HANDLED }, booleanArrayOf(true, false, false))))
+ private val counters = DecoderCounters()
+ private var params = TrackSelectionParameters.Builder(context).setViewportSize(3840, 2160, true).build()
+ private val player = Proxy.newProxyInstance(ExoPlayer::class.java.classLoader, arrayOf(ExoPlayer::class.java)) { _, method, args ->
+ when (method.name) {
+ "getCurrentTracks" -> tracks
+ "getVideoFormat" -> formats[0]
+ "getTrackSelectionParameters" -> params
+ "setTrackSelectionParameters" -> { params = args!![0] as TrackSelectionParameters; null }
+ "getVideoDecoderCounters" -> counters
+ "isPlaying", "getPlayWhenReady" -> true
+ "getPlaybackState" -> Player.STATE_READY
+ "getTotalBufferedDuration" -> 5_000L
+ "getApplicationLooper" -> android.os.Looper.getMainLooper()
+ else -> when (method.returnType) {
+ java.lang.Boolean.TYPE -> false
+ java.lang.Integer.TYPE -> 0
+ java.lang.Long.TYPE -> 0L
+ java.lang.Float.TYPE -> 0f
+ else -> null
+ }
+ }
+ } as ExoPlayer
+ private fun format(id: String, height: Int, bitrate: Int) = Format.Builder().setId(id).setSampleMimeType("video/avc")
+ .setHeight(height).setWidth(height * 16 / 9).setAverageBitrate(bitrate).build()
+ private fun field(name: String) = Media3PlayerEngine::class.java.getDeclaredField(name).apply { isAccessible = true }
+ private fun install(type: ResolvedStreamType = ResolvedStreamType.HLS) {
+ field("exoPlayer").set(engine, player)
+ field("currentResolvedStreamType").set(engine, type)
+ }
+ private fun tick(t: Long) {
+ counters.renderedOutputBufferCount = (t * 10).toInt()
+ counters.droppedBufferCount = (t * 50).toInt()
+ Media3PlayerEngine::class.java.getDeclaredMethod("updateAdaptiveDecodePressure", Long::class.javaPrimitiveType)
+ .apply { isAccessible = true }.invoke(engine, t * 1_000)
+ }
+ @After fun close() { engine.release() }
+
+ @Test fun `pressure changes selection on the existing player for adaptive formats`() {
+ for (type in listOf(ResolvedStreamType.HLS, ResolvedStreamType.DASH, ResolvedStreamType.SMOOTH_STREAMING)) {
+ install(type)
+ (0L..21).forEach(::tick)
+ assertThat(params.overrides[group]?.trackIndices.orEmpty()).containsExactly(1, 2)
+ assertThat(field("exoPlayer").get(engine)).isSameInstanceAs(player)
+ engine.stop()
+ assertThat(params.overrides).isEmpty()
+ }
+ }
+
+ @Test fun `progressive raw TS RTSP and unresolved sources do not get quality constraints`() {
+ for (type in listOf(ResolvedStreamType.PROGRESSIVE, ResolvedStreamType.MPEG_TS_LIVE, ResolvedStreamType.RTSP, ResolvedStreamType.UNKNOWN)) {
+ install(type)
+ (0L..35).forEach(::tick)
+ assertThat(params.overrides).isEmpty()
+ engine.stop()
+ }
+ }
+
+ @Test fun `manual choice removes policy subset and survives further pressure`() {
+ install()
+ (0L..21).forEach(::tick)
+ engine.selectVideoTrack("high")
+ (22L..55).forEach(::tick)
+ assertThat(params.overrides[group]?.trackIndices).containsExactly(0)
+ }
+
+ @Test fun `seek discards incomplete observation windows`() {
+ install()
+ (0L..15).forEach(::tick)
+ engine.seekTo(20_000)
+ (16L..24).forEach(::tick)
+ assertThat(params.overrides).isEmpty()
+ }
+
+ private object NoOpRepository : PlaybackCompatibilityRepository {
+ override suspend fun getKnownBadRecords(deviceFingerprint: String, streamType: String, videoMimeType: String, resolutionBucket: String) = emptyList<com.streamvault.domain.model.PlaybackCompatibilityRecord>()
+ override suspend fun recordFailure(key: PlaybackCompatibilityKey, failureType: String, at: Long) = Unit
+ override suspend fun recordSuccess(key: PlaybackCompatibilityKey, at: Long) = Unit
+ override suspend fun prune(maxRecords: Int, olderThanMs: Long) = Unit
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/Media3PlayerEnginePreloadTest.kt b/player/src/test/java/com/streamvault/player/Media3PlayerEnginePreloadTest.kt
index 7d131bf5..cc524003 100644
--- a/player/src/test/java/com/streamvault/player/Media3PlayerEnginePreloadTest.kt
+++ b/player/src/test/java/com/streamvault/player/Media3PlayerEnginePreloadTest.kt
@@ -52,6 +52,7 @@ class Media3PlayerEnginePreloadTest {
assertThat(pendingField.get(engine)).isNull()
}
+
private object NoOpPlaybackCompatibilityRepository : PlaybackCompatibilityRepository {
override suspend fun getKnownBadRecords(
deviceFingerprint: String,
diff --git a/player/src/test/java/com/streamvault/player/Media3PlayerEngineRetryContextTest.kt b/player/src/test/java/com/streamvault/player/Media3PlayerEngineRetryContextTest.kt
new file mode 100644
index 00000000..fa4614ab
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/Media3PlayerEngineRetryContextTest.kt
@@ -0,0 +1,70 @@
+package com.streamvault.player
+
+import android.content.Context
+import androidx.media3.common.C
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackCompatibilityKey
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.model.PlaybackCompatibilityRecord
+import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
+import com.streamvault.domain.repository.PlaybackCompatibilityRepository
+import com.streamvault.player.playback.PlaybackPreparationPlan
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import okhttp3.OkHttpClient
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+class Media3PlayerEngineRetryContextTest {
+
+ private val context: Context = RuntimeEnvironment.getApplication()
+ private val engine = Media3PlayerEngine(
+ context = context,
+ okHttpClient = OkHttpClient(),
+ playbackCompatibilityRepository = NoOpPlaybackCompatibilityRepository,
+ audioCompatibilityMemoryStore = AudioCompatibilityMemoryStore(context),
+ playbackSupportSnapshotStore = PlaybackSupportSnapshotStore(context)
+ )
+
+ @After
+ fun tearDown() {
+ engine.release()
+ }
+
+ @Test
+ fun `explicit HLS VOD intent selects the VOD retry budget in the engine`() {
+ val streamInfo = StreamInfo(
+ url = "https://example.test/movie/master.m3u8",
+ streamType = StreamType.HLS,
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ )
+ val planBuilder = Media3PlayerEngine::class.java.declaredMethods.single {
+ it.name == "buildPlaybackPreparationPlan" && it.parameterCount == 3
+ }.apply { isAccessible = true }
+
+ val plan = planBuilder.invoke(engine, streamInfo, false, { false }) as PlaybackPreparationPlan
+
+ assertThat(plan.retryContext.isLive).isFalse()
+ assertThat(plan.retryPolicy.getMinimumLoadableRetryCount(C.DATA_TYPE_MANIFEST)).isEqualTo(3)
+ }
+
+ private object NoOpPlaybackCompatibilityRepository : PlaybackCompatibilityRepository {
+ override suspend fun getKnownBadRecords(
+ deviceFingerprint: String,
+ streamType: String,
+ videoMimeType: String,
+ resolutionBucket: String
+ ): List<PlaybackCompatibilityRecord> = emptyList()
+
+ override suspend fun recordFailure(key: PlaybackCompatibilityKey, failureType: String, at: Long) = Unit
+
+ override suspend fun recordSuccess(key: PlaybackCompatibilityKey, at: Long) = Unit
+
+ override suspend fun prune(maxRecords: Int, olderThanMs: Long) = Unit
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/Media3PlayerEngineVideoCompatibilityTest.kt b/player/src/test/java/com/streamvault/player/Media3PlayerEngineVideoCompatibilityTest.kt
new file mode 100644
index 00000000..b5a1ce10
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/Media3PlayerEngineVideoCompatibilityTest.kt
@@ -0,0 +1,77 @@
+package com.streamvault.player
+
+import androidx.media3.common.Timeline
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackCompatibilityKey
+import com.streamvault.domain.repository.PlaybackCompatibilityRepository
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import okhttp3.OkHttpClient
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@UnstableApi
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+class Media3PlayerEngineVideoCompatibilityTest {
+
+ private val engine = Media3PlayerEngine(
+ context = RuntimeEnvironment.getApplication(),
+ okHttpClient = OkHttpClient(),
+ playbackCompatibilityRepository = NoOpPlaybackCompatibilityRepository,
+ audioCompatibilityMemoryStore = AudioCompatibilityMemoryStore(RuntimeEnvironment.getApplication()),
+ playbackSupportSnapshotStore = PlaybackSupportSnapshotStore(RuntimeEnvironment.getApplication())
+ )
+
+ @After
+ fun tearDown() {
+ engine.release()
+ }
+
+ @Test
+ fun `auto video renderer receives compatibility selector with and without av sync`() {
+ for (sync in listOf(false, true)) {
+ engine.setAudioVideoSyncEnabled(sync)
+ val method = Media3PlayerEngine::class.java.getDeclaredMethod("buildRenderersFactory")
+ method.isAccessible = true
+ val factory = method.invoke(engine) as androidx.media3.exoplayer.DefaultRenderersFactory
+ val renderers = factory.createRenderers(
+ android.os.Handler(android.os.Looper.getMainLooper()),
+ object : androidx.media3.exoplayer.video.VideoRendererEventListener {},
+ object : androidx.media3.exoplayer.audio.AudioRendererEventListener {},
+ androidx.media3.exoplayer.text.TextOutput {},
+ androidx.media3.exoplayer.metadata.MetadataOutput {}
+ )
+ val video = renderers.filterIsInstance<androidx.media3.exoplayer.video.MediaCodecVideoRenderer>().single()
+ val field = androidx.media3.exoplayer.mediacodec.MediaCodecRenderer::class.java
+ .getDeclaredField("mediaCodecSelector").apply { isAccessible = true }
+ assertThat(field.get(video)).isInstanceOf(
+ com.streamvault.player.playback.PlaybackVideoCodecCompatibility::class.java
+ )
+ renderers.forEach { it.release() }
+ }
+ }
+
+ private object NoOpPlaybackCompatibilityRepository : PlaybackCompatibilityRepository {
+ override suspend fun getKnownBadRecords(
+ deviceFingerprint: String,
+ streamType: String,
+ videoMimeType: String,
+ resolutionBucket: String
+ ) = emptyList<com.streamvault.domain.model.PlaybackCompatibilityRecord>()
+
+ override suspend fun recordFailure(key: PlaybackCompatibilityKey, failureType: String, at: Long) = Unit
+
+ override suspend fun recordSuccess(key: PlaybackCompatibilityKey, at: Long) = Unit
+
+ override suspend fun prune(maxRecords: Int, olderThanMs: Long) = Unit
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt b/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt
index 8ae9c415..de6df8f7 100644
--- a/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt
+++ b/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt
@@ -15,4 +15,12 @@ class PlayerErrorTest {
"Provider rejected playback, likely max connections or bandwidth limit (HTTP 509)."
)
}
+
+ @Test
+ fun `404 becomes a source error that can enter alternate stream recovery`() {
+ val error = PlayerError.fromException(IOException("HTTP 404"))
+
+ assertThat(error).isInstanceOf(PlayerError.SourceError::class.java)
+ assertThat(error.message).contains("HTTP 404")
+ }
}
diff --git a/player/src/test/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicyTest.kt
new file mode 100644
index 00000000..738ec9ab
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/AdaptiveDecodePressurePolicyTest.kt
@@ -0,0 +1,220 @@
+package com.streamvault.player.playback
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class AdaptiveDecodePressurePolicyTest {
+ private val ladder = listOf(DecodePressureRendition(720, 3_000_000), DecodePressureRendition(1080, 9_000_000), DecodePressureRendition(2160, 41_000_000))
+ private fun sample(t: Long, drops: Int = (t * 50).toInt(), rendered: Int = (t * 10).toInt(),
+ buffer: Long = 5_000, eligible: Boolean = true, playing: Boolean = true,
+ height: Int = 2160, group: Any = "ladder", renditions: List<DecodePressureRendition> = ladder
+ ) = DecodePressureSample(t * 1_000, group, eligible, playing, buffer, rendered, drops,
+ height, ladder.firstOrNull { it.height == height }?.bitrate ?: 41_000_000, renditions)
+
+ private fun firstChange(
+ policy: AdaptiveDecodePressurePolicy,
+ samples: LongRange,
+ height: Int,
+ pressure: Boolean
+ ): Pair<Long, DecodePressureChange>? {
+ for (time in samples) {
+ val observation = if (pressure) {
+ sample(time, drops = (100_000 + (time - samples.first) * 50).toInt(),
+ rendered = (200_000 + (time - samples.first) * 10).toInt(), height = height)
+ } else {
+ sample(time, drops = 100_000,
+ rendered = (200_000 + (time - samples.first) * 60).toInt(), height = height)
+ }
+ policy.observe(observation)?.let { return time to it }
+ }
+ return null
+ }
+
+ private fun policyAfterRapidRecurrence(): Pair<AdaptiveDecodePressurePolicy, Long> {
+ val policy = AdaptiveDecodePressurePolicy()
+ val down = firstChange(policy, 0L..40L, height = 2160, pressure = true)!!
+ val restored = firstChange(policy, down.first + 1..down.first + 150,
+ height = 1080, pressure = false)!!
+ val rapidDown = firstChange(policy, restored.first + 1..restored.first + 70,
+ height = 2160, pressure = true)!!
+ assertThat(rapidDown.second.maxHeight).isEqualTo(1080)
+ return policy to rapidDown.first
+ }
+
+ @Test fun `sustained pressure narrows one supported step without repeated poll actions`() {
+ val p = AdaptiveDecodePressurePolicy()
+ val changes = (0L..29).mapNotNull { p.observe(sample(it)) }
+ assertThat(changes.map { it.maxHeight }).containsExactly(1080)
+ assertThat(changes.single().maxBitrate).isEqualTo(9_000_000)
+ }
+
+ @Test fun `restoration bitrate belongs to the next height not an expensive smaller track`() {
+ val p = AdaptiveDecodePressurePolicy()
+ val odd = ladder + DecodePressureRendition(360, 20_000_000)
+ (0L..20).forEach { p.observe(sample(it, height = 1080, renditions = odd)) }
+ val changes = (21L..105).mapNotNull {
+ p.observe(sample(it, drops = 1000, rendered = (200 + (it - 20) * 60).toInt(), height = 720, renditions = odd))
+ }
+ assertThat(changes.single().maxHeight).isEqualTo(1080)
+ assertThat(changes.single().maxBitrate).isEqualTo(9_000_000)
+ }
+
+ @Test fun `a single burst is insufficient`() {
+ val p = AdaptiveDecodePressurePolicy()
+ val changes = (0L..30).mapNotNull { p.observe(sample(it, if (it >= 12) 100 else 0, (it * 60).toInt())) }
+ assertThat(changes).isEmpty()
+ }
+
+ @Test fun `buffer drain and ineligible or inactive playback cannot constrain`() {
+ for (mode in 0..3) {
+ val p = AdaptiveDecodePressurePolicy()
+ assertThat((0L..30).mapNotNull { p.observe(sample(it,
+ buffer = if (mode == 0) 500 else 5_000,
+ eligible = mode != 1, playing = mode !in 2..3)) }).isEmpty()
+ }
+ }
+
+ @Test fun `single rendition and unknown or higher bitrate alternatives cannot constrain`() {
+ for (r in listOf(listOf(ladder.last()), listOf(ladder.last(), DecodePressureRendition(1080, 0)),
+ listOf(ladder.last(), DecodePressureRendition(1080, 50_000_000)))) {
+ val p = AdaptiveDecodePressurePolicy()
+ assertThat((0L..35).mapNotNull { p.observe(sample(it, renditions = r)) }).isEmpty()
+ }
+ }
+
+ @Test fun `new session discards pressure history and pending restoration`() {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..20).forEach { p.observe(sample(it)) }
+ p.reset()
+ assertThat((21L..30).mapNotNull { p.observe(sample(it, group = "new")) }).isEmpty()
+ }
+
+ @Test fun `seek counter reset and long observation gap cannot join pressure windows`() {
+ for (mode in 0..2) {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..15).forEach { p.observe(sample(it)) }
+ if (mode == 0) p.discontinuity()
+ val changes = (16L..24).mapNotNull {
+ p.observe(when (mode) {
+ 1 -> sample(it, drops = (it - 16).toInt() * 50, rendered = (it - 16).toInt() * 10)
+ 2 -> sample(it + 10)
+ else -> sample(it)
+ })
+ }
+ assertThat(changes).isEmpty()
+ }
+ }
+
+ @Test fun `manual selection or group replacement clears only the active policy constraint`() {
+ for (mode in 0..1) {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..20).forEach { p.observe(sample(it)) }
+ assertThat(p.observe(sample(21, eligible = mode != 0, group = if (mode == 1) "other" else "ladder")))
+ .isEqualTo(DecodePressureChange(null))
+ }
+ }
+
+ @Test fun `stable playback waits for cooldown before restoring unconstrained Auto`() {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..20).forEach { p.observe(sample(it)) }
+ val changes = (21L..105).mapNotNull {
+ p.observe(sample(it, drops = 1_000, rendered = (200 + (it - 20) * 60).toInt(), height = 1080))
+ ?.let { change -> it to change.maxHeight }
+ }
+ assertThat(changes).containsExactly(91L to null)
+ }
+
+ @Test fun `restoration climbs one available step rather than jumping from lowest to highest`() {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..20).forEach { p.observe(sample(it, height = 1080)) }
+ val changes = (21L..105).mapNotNull {
+ p.observe(sample(it, drops = 1_000, rendered = (200 + (it - 20) * 60).toInt(), height = 720))
+ ?.let { change -> change.maxHeight }
+ }
+ assertThat(changes).containsExactly(1080)
+ }
+
+ @Test fun `paused or buffering time does not count toward stable restoration`() {
+ val p = AdaptiveDecodePressurePolicy()
+ (0L..20).forEach { p.observe(sample(it)) }
+ (21L..120).forEach { assertThat(p.observe(sample(it, playing = false))).isNull() }
+ assertThat((121L..150).mapNotNull {
+ p.observe(sample(it, drops = 1_000, rendered = (it * 60).toInt(), height = 1080))
+ }).isEmpty()
+ }
+
+ @Test fun `rapid restoration recurrence lengthens the stable wait then returns to baseline`() {
+ val p = AdaptiveDecodePressurePolicy()
+ val firstDown = firstChange(p, 0L..40L, height = 2160, pressure = true)!!
+ assertThat(firstDown.second.maxHeight).isEqualTo(1080)
+
+ val firstRestore = firstChange(p, firstDown.first + 1..firstDown.first + 150,
+ height = 1080, pressure = false)!!
+ assertThat(firstRestore.second.maxHeight).isNull()
+ assertThat(firstRestore.second.restorationStableMs).isEqualTo(60_000L)
+ assertThat(firstRestore.first - firstDown.first).isAtLeast(60)
+
+ // A rendition transition can briefly buffer; it must not count as stable time or
+ // erase the source's recent restoration history.
+ (firstRestore.first + 1..firstRestore.first + 3).forEach {
+ p.observe(sample(it, playing = false))
+ }
+ val rapidDown = firstChange(p, firstRestore.first + 4..firstRestore.first + 70,
+ height = 2160, pressure = true)!!
+ assertThat(rapidDown.second.maxHeight).isEqualTo(1080)
+ assertThat(rapidDown.first - firstRestore.first).isAtMost(60)
+
+ val backedOffRestore = firstChange(p, rapidDown.first + 1..rapidDown.first + 160,
+ height = 1080, pressure = false)!!
+ assertThat(backedOffRestore.second.maxHeight).isNull()
+ assertThat(backedOffRestore.second.restorationStableMs).isEqualTo(90_000L)
+ assertThat(backedOffRestore.first - rapidDown.first).isAtLeast(90)
+ assertThat(backedOffRestore.first - rapidDown.first).isLessThan(130)
+
+ val repeatedRapidDown = firstChange(p, backedOffRestore.first + 1..backedOffRestore.first + 70,
+ height = 2160, pressure = true)!!
+ val repeatedBackedOffRestore = firstChange(p,
+ repeatedRapidDown.first + 1..repeatedRapidDown.first + 160,
+ height = 1080, pressure = false)!!
+ assertThat(repeatedBackedOffRestore.second.maxHeight).isNull()
+ assertThat(repeatedBackedOffRestore.second.restorationStableMs).isEqualTo(90_000L)
+ assertThat(repeatedBackedOffRestore.first - repeatedRapidDown.first).isAtLeast(90)
+
+ // A full minute of healthy restored playback clears the recurrence history.
+ for (time in repeatedBackedOffRestore.first + 1..repeatedBackedOffRestore.first + 65) {
+ p.observe(sample(time, drops = 100_000, rendered = 300_000 + (time * 60).toInt(), height = 2160))
+ }
+ val laterDown = firstChange(p, repeatedBackedOffRestore.first + 66..repeatedBackedOffRestore.first + 130,
+ height = 2160, pressure = true)!!
+ val baselineRestore = firstChange(p, laterDown.first + 1..laterDown.first + 130,
+ height = 1080, pressure = false)!!
+ assertThat(baselineRestore.second.maxHeight).isNull()
+ assertThat(baselineRestore.second.restorationStableMs).isEqualTo(60_000L)
+ assertThat(baselineRestore.first - laterDown.first).isAtLeast(60)
+ assertThat(baselineRestore.first - laterDown.first).isLessThan(90)
+ }
+
+ @Test fun `seek reset and manual selection clear restoration backoff`() {
+ for (boundary in 0..2) {
+ val (p, lastTime) = policyAfterRapidRecurrence()
+ if (boundary == 0) {
+ p.discontinuity()
+ val restore = firstChange(p, lastTime + 1..lastTime + 130,
+ height = 1080, pressure = false)!!
+ assertThat(restore.second.restorationStableMs).isEqualTo(60_000L)
+ } else {
+ if (boundary == 1) {
+ assertThat(p.observe(sample(lastTime + 1, eligible = false)))
+ .isEqualTo(DecodePressureChange(null))
+ } else {
+ p.reset()
+ }
+ val down = firstChange(p, lastTime + 2..lastTime + 50,
+ height = 2160, pressure = true)!!
+ val restore = firstChange(p, down.first + 1..down.first + 130,
+ height = 1080, pressure = false)!!
+ assertThat(restore.second.restorationStableMs).isEqualTo(60_000L)
+ }
+ }
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/ForegroundPreloadPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/ForegroundPreloadPolicyTest.kt
new file mode 100644
index 00000000..0b93db58
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/ForegroundPreloadPolicyTest.kt
@@ -0,0 +1,33 @@
+package com.streamvault.player.playback
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.player.PlaybackState
+import org.junit.Test
+
+class ForegroundPreloadPolicyTest {
+ @Test fun `startup cannot borrow bandwidth before foreground has headroom`() {
+ assertThat(shouldAllowNeighborPreload(false, PlaybackState.READY, true, 1_000, false)).isFalse()
+ assertThat(shouldAllowNeighborPreload(false, PlaybackState.READY, true, 9_999, false)).isFalse()
+ assertThat(shouldAllowNeighborPreload(false, PlaybackState.READY, true, 10_000, false)).isTrue()
+ }
+
+ @Test fun `buffer depletion suspends reads and recovery requires new headroom`() {
+ assertThat(shouldAllowNeighborPreload(true, PlaybackState.READY, true, 5_001, false)).isTrue()
+ assertThat(shouldAllowNeighborPreload(true, PlaybackState.READY, true, 5_000, false)).isFalse()
+ assertThat(shouldAllowNeighborPreload(false, PlaybackState.READY, true, 7_000, false)).isFalse()
+ }
+
+ @Test fun `buffering recovery pause and inactive states override a full buffer`() {
+ for (state in PlaybackState.entries.filter { it != PlaybackState.READY }) {
+ assertThat(shouldAllowNeighborPreload(true, state, true, 60_000, false)).isFalse()
+ }
+ assertThat(shouldAllowNeighborPreload(true, PlaybackState.READY, false, 60_000, false)).isFalse()
+ assertThat(shouldAllowNeighborPreload(true, PlaybackState.READY, true, 60_000, true)).isFalse()
+ }
+
+ @Test fun `provider connection limit disables neighbor reads for this window`() {
+ assertThat(
+ shouldAllowNeighborPreload(false, PlaybackState.READY, true, 60_000, false, providerLimitBlocked = true)
+ ).isFalse()
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactoryTest.kt b/player/src/test/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactoryTest.kt
new file mode 100644
index 00000000..a1853d73
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/LivePlaybackSpeedControlFactoryTest.kt
@@ -0,0 +1,30 @@
+package com.streamvault.player.playback
+
+import androidx.media3.common.MediaItem
+import androidx.media3.exoplayer.DefaultLivePlaybackSpeedControl
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class LivePlaybackSpeedControlFactoryTest {
+
+ @Test
+ fun `live control catches up when current offset exceeds target and media sets no speed bounds`() {
+ val control = createLivePlaybackSpeedControl()
+ control.setLiveConfiguration(
+ MediaItem.LiveConfiguration.Builder()
+ .setTargetOffsetMs(3_000L)
+ .build()
+ )
+
+ val speed = control.getAdjustedPlaybackSpeed(
+ /* liveOffsetUs= */ 5_000_000L,
+ /* bufferedDurationUs= */ 1_000_000L
+ )
+
+ assertThat(speed > 1.0f).isTrue()
+ assertThat(speed <= DefaultLivePlaybackSpeedControl.DEFAULT_FALLBACK_MAX_PLAYBACK_SPEED).isTrue()
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/LiveTsFallbackUrlTest.kt b/player/src/test/java/com/streamvault/player/playback/LiveTsFallbackUrlTest.kt
deleted file mode 100644
index 6a0d2884..00000000
--- a/player/src/test/java/com/streamvault/player/playback/LiveTsFallbackUrlTest.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-package com.streamvault.player.playback
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-
-class LiveTsFallbackUrlTest {
-
- @Test
- fun `live hls path is converted to transport stream path`() {
- val fallback = buildLiveTsFallbackUrl("https://example.test/live/user/pass/61351.m3u8")
-
- assertThat(fallback).isEqualTo("https://example.test/live/user/pass/61351.ts")
- }
-
- @Test
- fun `live hls query extension is converted to transport stream query extension`() {
- val fallback = buildLiveTsFallbackUrl("https://example.test/live/user/pass/61351?ext=m3u8")
-
- assertThat(fallback).isEqualTo("https://example.test/live/user/pass/61351?ext=ts")
- }
-
- @Test
- fun `non hls live url is not converted`() {
- assertThat(buildLiveTsFallbackUrl("https://example.test/live/user/pass/61351.ts")).isNull()
- }
-
- @Test
- fun `non live hls url is not converted`() {
- assertThat(buildLiveTsFallbackUrl("https://example.test/movie/user/pass/61351.m3u8")).isNull()
- }
-
- @Test
- fun `malformed hls does not use transport stream fallback`() {
- assertThat(
- shouldFallbackMalformedHlsToLiveTs(
- category = PlaybackErrorCategory.SOURCE_MALFORMED,
- resolvedStreamType = ResolvedStreamType.HLS,
- playbackStarted = false
- )
- ).isFalse()
- assertThat(
- shouldFallbackMalformedHlsToLiveTs(
- category = PlaybackErrorCategory.SOURCE_MALFORMED,
- resolvedStreamType = ResolvedStreamType.HLS,
- playbackStarted = true
- )
- ).isFalse()
- }
-
- @Test
- fun `stalled hls does not use transport stream fallback`() {
- assertThat(
- shouldFallbackStalledHlsToLiveTs(
- resolvedStreamType = ResolvedStreamType.HLS,
- recoveryAttempt = 2
- )
- ).isFalse()
- assertThat(
- shouldFallbackStalledHlsToLiveTs(
- resolvedStreamType = ResolvedStreamType.HLS,
- recoveryAttempt = 1
- )
- ).isFalse()
- assertThat(
- shouldFallbackStalledHlsToLiveTs(
- resolvedStreamType = ResolvedStreamType.MPEG_TS_LIVE,
- recoveryAttempt = 3
- )
- ).isFalse()
- }
-}
diff --git a/player/src/test/java/com/streamvault/player/playback/LiveVideoStallRecoveryTest.kt b/player/src/test/java/com/streamvault/player/playback/LiveVideoStallRecoveryTest.kt
new file mode 100644
index 00000000..f7d2afc8
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/LiveVideoStallRecoveryTest.kt
@@ -0,0 +1,130 @@
+@file:androidx.media3.common.util.UnstableApi
+
+package com.streamvault.player.playback
+
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.Player
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.Tracks
+import androidx.media3.common.MediaItem
+import androidx.media3.exoplayer.source.SinglePeriodTimeline
+import com.google.common.truth.Truth.assertThat
+import java.lang.reflect.Proxy
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class LiveVideoStallRecoveryTest {
+ @Test
+ fun `confirmed live video stall seeks once then stops a persistently stalled source`() {
+ val fake = Playback()
+ val recovery = LiveVideoStallRecovery()
+ assertThat(recovery.recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.SEEKED)
+ assertThat(fake.seeks).isEqualTo(1)
+ assertThat(fake.stops).isEqualTo(0)
+ assertThat(recovery.recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.STOPPED)
+ assertThat(fake.seeks).isEqualTo(1)
+ assertThat(fake.stops).isEqualTo(1)
+ assertThat(fake.prepares).isEqualTo(0)
+ }
+
+ @Test
+ fun `reset gives a new playback session its own single recovery attempt`() {
+ val fake = Playback()
+ val recovery = LiveVideoStallRecovery()
+ recovery.recover(fake.player, true, false)
+ recovery.reset()
+ assertThat(recovery.recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.SEEKED)
+ assertThat(fake.seeks).isEqualTo(2)
+ }
+
+ @Test
+ fun `active Media3 retry retains ownership without consuming the seek attempt`() {
+ val fake = Playback()
+ val recovery = LiveVideoStallRecovery()
+ assertThat(recovery.recover(fake.player, true, true)).isEqualTo(LiveVideoStallRecovery.Result.NONE)
+ assertThat(fake.seeks).isEqualTo(0)
+ assertThat(recovery.recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.SEEKED)
+ }
+
+ @Test
+ fun `buffering pause and audio-only playback do not trigger this recovery`() {
+ for (fake in listOf(Playback(state = Player.STATE_BUFFERING), Playback(playing = false), Playback(video = false))) {
+ assertThat(LiveVideoStallRecovery().recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.NONE)
+ assertThat(fake.seeks + fake.stops).isEqualTo(0)
+ }
+ }
+
+ @Test
+ fun `finite HLS and catch-up retain their positions`() {
+ for ((fake, liveIntent) in listOf(Playback(live = false) to true, Playback() to false)) {
+ assertThat(LiveVideoStallRecovery().recover(fake.player, liveIntent, false)).isEqualTo(LiveVideoStallRecovery.Result.NONE)
+ assertThat(fake.seeks + fake.stops).isEqualTo(0)
+ }
+ }
+
+ @Test
+ fun `unseekable live stall stops loading rather than requesting an invalid seek`() {
+ val fake = Playback(seekable = false)
+ assertThat(LiveVideoStallRecovery().recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.STOPPED)
+ assertThat(fake.seeks).isEqualTo(0)
+ assertThat(fake.stops).isEqualTo(1)
+ }
+
+ @Test
+ fun `a seek followed by persistent buffering stops the source`() {
+ val fake = Playback()
+ val recovery = LiveVideoStallRecovery()
+ recovery.recover(fake.player, true, false)
+ fake.state = Player.STATE_BUFFERING
+ assertThat(recovery.recover(fake.player, true, false)).isEqualTo(LiveVideoStallRecovery.Result.STOPPED)
+ assertThat(fake.stops).isEqualTo(1)
+ }
+
+ @Test
+ fun `recovery uses a different position when already at the timeline default`() {
+ val fake = Playback()
+ LiveVideoStallRecovery().recover(fake.player, true, false)
+ assertThat(fake.seekPositionMs).isEqualTo(1L)
+ }
+
+ private class Playback(
+ state: Int = Player.STATE_READY,
+ playing: Boolean = true,
+ video: Boolean = true,
+ live: Boolean = true,
+ seekable: Boolean = true
+ ) {
+ var state = state
+ var seeks = 0
+ var stops = 0
+ var prepares = 0
+ var seekPositionMs = -1L
+ private val timeline = SinglePeriodTimeline(
+ 300_000_000L, true, false, false, null, MediaItem.fromUri("https://example.invalid/live.m3u8")
+ )
+ private val tracks = Tracks(listOf(Tracks.Group(
+ TrackGroup(Format.Builder().setSampleMimeType("video/avc").build()),
+ false, intArrayOf(C.FORMAT_HANDLED), booleanArrayOf(video)
+ )))
+ val player = Proxy.newProxyInstance(Player::class.java.classLoader, arrayOf(Player::class.java)) { _, method, args ->
+ when (method.name) {
+ "getPlaybackState" -> this.state
+ "getPlayWhenReady" -> playing
+ "getCurrentTracks" -> tracks
+ "isCurrentMediaItemLive" -> live
+ "isCurrentMediaItemSeekable" -> seekable
+ "getCurrentTimeline" -> timeline
+ "getCurrentMediaItemIndex" -> 0
+ "getCurrentPosition" -> 0L
+ "seekToDefaultPosition" -> { seeks++; null }
+ "seekTo" -> { seeks++; seekPositionMs = args.last() as Long; null }
+ "stop" -> { stops++; null }
+ "prepare" -> { prepares++; null }
+ else -> error("Unexpected player call: ${method.name}")
+ }
+ } as Player
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/Media3PreloadWindowManagerTest.kt b/player/src/test/java/com/streamvault/player/playback/Media3PreloadWindowManagerTest.kt
index daa0e621..c56f3ef3 100644
--- a/player/src/test/java/com/streamvault/player/playback/Media3PreloadWindowManagerTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/Media3PreloadWindowManagerTest.kt
@@ -1,11 +1,16 @@
package com.streamvault.player.playback
import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.DataSpec
import androidx.media3.exoplayer.DefaultLoadControl
import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.source.LoadEventInfo
+import androidx.media3.exoplayer.source.MediaLoadData
import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter
import androidx.media3.exoplayer.source.preload.DefaultPreloadManager
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
import com.google.common.truth.Truth.assertThat
+import androidx.media3.common.C
import com.streamvault.domain.model.StreamType
import com.streamvault.player.PlayerPreloadContentType
import com.streamvault.player.PlayerPreloadItem
@@ -15,10 +20,19 @@ import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
+import java.net.SocketTimeoutException
@RunWith(RobolectricTestRunner::class)
class Media3PreloadWindowManagerTest {
+ @Test
+ fun `suspension cancels incomplete reads but keeps completed neighbor handoff`() {
+ assertThat(playerPreloadTargetStatus(1, 2, readsAllowed = false, completed = false)).isNull()
+ assertThat(playerPreloadTargetStatus(1, 2, readsAllowed = false, completed = true))
+ .isEqualTo(DefaultPreloadManager.PreloadStatus.specifiedRangeLoaded(0L, 3_000L))
+ assertThat(playerPreloadTargetStatus(1, 1, readsAllowed = false, completed = true)).isNull()
+ }
+
@Test
fun `target status preloads only immediate neighbors`() {
val adjacent = DefaultPreloadManager.PreloadStatus.specifiedRangeLoaded(0L, 3_000L)
@@ -128,10 +142,13 @@ class Media3PreloadWindowManagerTest {
)
)
- val currentSource = manager.getMediaSource(current)
- val nextSource = manager.getMediaSource(next)
+ val currentSource = manager.getMediaSource(current)?.mediaSource
+ val nextSource = manager.getMediaSource(next)?.mediaSource
assertThat(currentSource).isNotNull()
assertThat(nextSource).isNotNull()
+ manager.updateForegroundPlayback(com.streamvault.player.PlaybackState.READY, true, 20_000L, false)
+ manager.updateForegroundPlayback(com.streamvault.player.PlaybackState.BUFFERING, false, 0L, true)
+ assertThat(manager.getMediaSource(next)?.mediaSource).isSameInstanceAs(nextSource)
assertThat(
manager.getMediaSource(
StreamInfo(url = "file:///not-managed.mp4", streamType = StreamType.PROGRESSIVE)
@@ -153,9 +170,70 @@ class Media3PreloadWindowManagerTest {
)
)
- assertThat(manager.getMediaSource(current)).isSameInstanceAs(currentSource)
+ assertThat(manager.getMediaSource(current)?.mediaSource).isSameInstanceAs(currentSource)
assertThat(manager.getMediaSource(next)).isNull()
- assertThat(manager.getMediaSource(changedNext)).isNotNull()
+ assertThat(manager.getMediaSource(changedNext)?.mediaSource).isNotNull()
+
+ player.release()
+ manager.release()
+ }
+
+ @Test
+ fun `handed off source retains its retry policy and reports foreground recovery changes`() {
+ val context = RuntimeEnvironment.getApplication()
+ val dataSourceProvider = PlayerDataSourceFactoryProvider(
+ context = context,
+ baseClient = okhttp3.OkHttpClient()
+ )
+ var playbackStarted = false
+ var recoveryNotifications = 0
+ val manager = Media3PreloadWindowManager(
+ context = context,
+ mediaSourceFactory = PlayerMediaSourceFactory(dataSourceProvider),
+ dataSourceFactoryProvider = dataSourceProvider,
+ bandwidthMeter = DefaultBandwidthMeter.Builder(context).build(),
+ onForegroundRecoveryChanged = { recoveryNotifications++ },
+ playbackStarted = { playbackStarted }
+ )
+ val player = manager.createPlayer(
+ renderersFactory = DefaultRenderersFactory(context),
+ loadControl = DefaultLoadControl(),
+ preloadDataSourceFactory = DefaultDataSource.Factory(context)
+ ) {
+ it.setReleaseTimeoutMs(0L)
+ }
+ val stream = StreamInfo(
+ url = "file:///managed-retry.mp4",
+ streamType = StreamType.PROGRESSIVE
+ )
+ manager.updateWindow(
+ PlayerPreloadWindow(
+ items = listOf(PlayerPreloadItem("retry", stream, PlayerPreloadContentType.VOD)),
+ currentIndex = 0
+ )
+ )
+
+ val managed = manager.getMediaSource(stream)!!
+ assertThat(manager.getMediaSource(stream)?.retryPolicy).isSameInstanceAs(managed.retryPolicy)
+ val dataSpec = DataSpec.Builder().setUri("https://example.com/movie.mp4").build()
+ fun timeoutAtAttempt(attempt: Int): LoadErrorHandlingPolicy.LoadErrorInfo {
+ val event = LoadEventInfo.Builder(LoadEventInfo.getNewId(), dataSpec, 0L).build()
+ return LoadErrorHandlingPolicy.LoadErrorInfo(
+ event,
+ MediaLoadData(C.DATA_TYPE_MEDIA),
+ SocketTimeoutException("timed out"),
+ attempt
+ )
+ }
+
+ assertThat(managed.retryPolicy.getRetryDelayMsFor(timeoutAtAttempt(attempt = 3)))
+ .isEqualTo(C.TIME_UNSET)
+ playbackStarted = true
+ val foregroundTimeout = timeoutAtAttempt(attempt = 3)
+ assertThat(managed.retryPolicy.getRetryDelayMsFor(foregroundTimeout)).isEqualTo(5_000L)
+ assertThat(recoveryNotifications).isEqualTo(1)
+ managed.retryPolicy.onLoadTaskConcluded(foregroundTimeout.loadEventInfo.loadTaskId)
+ assertThat(recoveryNotifications).isEqualTo(2)
player.release()
manager.release()
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
index e95e6aca..245c040b 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
@@ -5,10 +5,200 @@ import com.streamvault.domain.model.PlaybackBufferMode
import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.model.StreamType
+import org.junit.Assert.assertEquals
import org.junit.Test
class PlaybackBufferPoliciesTest {
+ @Test
+ fun `low-memory adaptive live delegates byte sizing to selected tracks`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ compatibilityMode = false,
+ lowMemoryDevice = true,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.invalid/live/index.m3u8",
+ streamType = StreamType.HLS,
+ playbackContentKind = PlaybackContentKind.LIVE
+ )
+ )
+
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
+ }
+
+ @Test
+ fun `low-memory automatic UHD live delegates byte sizing to selected tracks`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ compatibilityMode = false,
+ lowMemoryDevice = true,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.invalid/live/2160p/index.m3u8",
+ streamType = StreamType.HLS,
+ playbackContentKind = PlaybackContentKind.LIVE
+ )
+ )
+
+ assertThat(policy.lowMemoryCapped).isTrue()
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
+ }
+
+ @Test
+ fun `buffer policy matrix keeps content intent and explicit modes predictable`() {
+ val resolvedTypes = listOf(
+ ResolvedStreamType.HLS to StreamType.HLS,
+ ResolvedStreamType.DASH to StreamType.DASH,
+ ResolvedStreamType.SMOOTH_STREAMING to StreamType.SMOOTH_STREAMING,
+ ResolvedStreamType.PROGRESSIVE to StreamType.PROGRESSIVE,
+ ResolvedStreamType.MPEG_TS_LIVE to StreamType.MPEG_TS,
+ ResolvedStreamType.RTSP to StreamType.RTSP
+ )
+ val kinds = PlaybackContentKind.entries
+ val modes = PlaybackBufferMode.entries
+
+ for (kind in kinds) {
+ for ((resolvedType, declaredType) in resolvedTypes) {
+ for (lowMemory in listOf(false, true)) {
+ for (mode in modes) {
+ val context = "$kind / $resolvedType / lowMemory=$lowMemory / $mode"
+ val info = StreamInfo(
+ url = "https://example.invalid/content/index.m3u8",
+ streamType = declaredType,
+ playbackContentKind = kind
+ )
+ val actual = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = resolvedType,
+ compatibilityMode = false,
+ lowMemoryDevice = lowMemory,
+ bufferMode = mode,
+ streamInfo = info
+ )
+
+ assertEquals("$context policy", expectedPolicy(kind, resolvedType, lowMemory, mode), actual)
+ }
+ }
+ }
+ }
+ }
+
+ private fun expectedPolicy(
+ kind: PlaybackContentKind,
+ resolvedType: ResolvedStreamType,
+ lowMemory: Boolean,
+ mode: PlaybackBufferMode
+ ): PlaybackBufferPolicy {
+ val live = when (kind) {
+ PlaybackContentKind.LIVE -> true
+ PlaybackContentKind.ON_DEMAND, PlaybackContentKind.CATCH_UP -> false
+ PlaybackContentKind.UNKNOWN -> resolvedType in setOf(
+ ResolvedStreamType.HLS,
+ ResolvedStreamType.SMOOTH_STREAMING,
+ ResolvedStreamType.MPEG_TS_LIVE,
+ ResolvedStreamType.RTSP
+ )
+ }
+
+ if (live && mode == PlaybackBufferMode.MEDIUM) {
+ return PlaybackBufferPolicy(
+ label = "medium-live",
+ minBufferMs = 15_000,
+ maxBufferMs = 45_000,
+ playbackBufferMs = 3_000,
+ rebufferMs = 10_000,
+ targetBufferBytes = 32 * 1024 * 1024,
+ prioritizeTimeOverSizeThresholds = false,
+ qualityReason = "user-medium"
+ )
+ }
+ if (live && mode == PlaybackBufferMode.LARGE) {
+ return PlaybackBufferPolicy(
+ label = "large-live",
+ minBufferMs = 30_000,
+ maxBufferMs = 90_000,
+ playbackBufferMs = 5_000,
+ rebufferMs = 15_000,
+ targetBufferBytes = 64 * 1024 * 1024,
+ prioritizeTimeOverSizeThresholds = false,
+ qualityReason = "user-large"
+ )
+ }
+
+ if (!live && resolvedType == ResolvedStreamType.HLS) {
+ return PlaybackBufferPolicy(
+ label = "vod-hls-initial",
+ minBufferMs = if (lowMemory) 4_000 else 8_000,
+ maxBufferMs = if (lowMemory) 12_000 else 30_000,
+ playbackBufferMs = if (lowMemory) 1_000 else 1_500,
+ rebufferMs = if (lowMemory) 3_000 else 5_000,
+ targetBufferBytes = -1,
+ prioritizeTimeOverSizeThresholds = false,
+ qualityReason = "finite-content"
+ )
+ }
+
+ if (resolvedType == ResolvedStreamType.MPEG_TS_LIVE) {
+ return PlaybackBufferPolicy(
+ label = if (lowMemory) "lowmem-mpeg-ts-live" else "mpeg-ts-live",
+ minBufferMs = if (lowMemory) 4_000 else 5_000,
+ maxBufferMs = if (lowMemory) 12_000 else 10_000,
+ playbackBufferMs = if (lowMemory) 1_000 else 1_500,
+ rebufferMs = if (lowMemory) 3_000 else 5_000,
+ targetBufferBytes = 16 * 1024 * 1024,
+ prioritizeTimeOverSizeThresholds = false
+ )
+ }
+
+ if (lowMemory && live) {
+ return PlaybackBufferPolicy(
+ label = "lowmem-live",
+ minBufferMs = 4_000,
+ maxBufferMs = 12_000,
+ playbackBufferMs = 1_000,
+ rebufferMs = 3_000,
+ targetBufferBytes = -1,
+ prioritizeTimeOverSizeThresholds = false
+ )
+ }
+
+ if (lowMemory) {
+ return PlaybackBufferPolicy(
+ label = if (live) "lowmem-live" else "lowmem-vod",
+ minBufferMs = if (live) 4_000 else 15_000,
+ maxBufferMs = if (live) 12_000 else 45_000,
+ playbackBufferMs = 1_000,
+ rebufferMs = 3_000,
+ targetBufferBytes = -1,
+ prioritizeTimeOverSizeThresholds = false
+ )
+ }
+
+ return if (live) {
+ PlaybackBufferPolicy(
+ label = "stable-live",
+ minBufferMs = 8_000,
+ maxBufferMs = 30_000,
+ playbackBufferMs = 1_500,
+ rebufferMs = 5_000,
+ targetBufferBytes = -1,
+ prioritizeTimeOverSizeThresholds = false
+ )
+ } else {
+ PlaybackBufferPolicy(
+ label = "stable-vod",
+ minBufferMs = 90_000,
+ maxBufferMs = 240_000,
+ playbackBufferMs = 8_000,
+ rebufferMs = 18_000,
+ targetBufferBytes = -1,
+ prioritizeTimeOverSizeThresholds = false
+ )
+ }
+ }
+
@Test
fun `normal live uses production live buffer baseline`() {
val policy = PlaybackBufferPolicies.forPlayback(isLive = true, compatibilityMode = false)
@@ -19,7 +209,7 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.playbackBufferMs).isEqualTo(1_500)
assertThat(policy.rebufferMs).isEqualTo(5_000)
assertThat(policy.targetBufferBytes).isEqualTo(-1)
- assertThat(policy.prioritizeTimeOverSizeThresholds).isTrue()
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
}
@Test
@@ -165,6 +355,26 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.minBufferMs).isEqualTo(4_000)
assertThat(policy.maxBufferMs).isEqualTo(12_000)
assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
+ }
+
+ @Test
+ fun `low-memory compatibility live policy enforces its byte budget`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ compatibilityMode = true,
+ lowMemoryDevice = true,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.invalid/live/index.m3u8",
+ streamType = StreamType.HLS,
+ playbackContentKind = PlaybackContentKind.LIVE
+ )
+ )
+
+ assertThat(policy.label).isEqualTo("lowmem-compat-live")
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
}
@Test
@@ -207,7 +417,7 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.maxBufferMs).isEqualTo(45_000)
assertThat(policy.playbackBufferMs).isEqualTo(3_000)
assertThat(policy.rebufferMs).isEqualTo(10_000)
- assertThat(policy.targetBufferBytes).isEqualTo(32 * 1024 * 1024)
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
assertThat(policy.lowMemoryCapped).isTrue()
assertThat(policy.qualityReason).isEqualTo("metadata-uhd")
}
@@ -222,7 +432,7 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.playbackBufferMs).isEqualTo(1_500)
assertThat(policy.rebufferMs).isEqualTo(5_000)
assertThat(policy.targetBufferBytes).isEqualTo(-1)
- assertThat(policy.prioritizeTimeOverSizeThresholds).isTrue()
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
}
@Test
@@ -241,7 +451,7 @@ class PlaybackBufferPoliciesTest {
}
@Test
- fun `mpeg ts live prioritizes playable time over byte target`() {
+ fun `mpeg ts live lets the device budget bound loading`() {
val policy = PlaybackBufferPolicies.forPlayback(
resolvedStreamType = ResolvedStreamType.MPEG_TS_LIVE,
compatibilityMode = false
@@ -253,7 +463,7 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.playbackBufferMs).isEqualTo(1_500)
assertThat(policy.rebufferMs).isEqualTo(5_000)
assertThat(policy.targetBufferBytes).isEqualTo(16 * 1024 * 1024)
- assertThat(policy.prioritizeTimeOverSizeThresholds).isTrue()
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
}
@Test
@@ -297,6 +507,6 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.playbackBufferMs).isEqualTo(8_000)
assertThat(policy.rebufferMs).isEqualTo(18_000)
assertThat(policy.targetBufferBytes).isEqualTo(-1)
- assertThat(policy.prioritizeTimeOverSizeThresholds).isTrue()
+ assertThat(policy.prioritizeTimeOverSizeThresholds).isFalse()
}
}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
index 3d433075..7a60f272 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
@@ -2,6 +2,7 @@ package com.streamvault.player.playback
import androidx.media3.common.Format
import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
import androidx.media3.exoplayer.DecoderReuseEvaluation
import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.DecoderMode
@@ -65,6 +66,40 @@ class PlaybackCodecSelectorTest {
assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
}
+ @Test
+ fun `factory settings pass renderer order and decoder initialization fallback`() {
+ val autoPlan = buildPlaybackRendererPlan(
+ requestedMode = DecoderMode.AUTO,
+ activeDecoderMode = DecoderMode.AUTO,
+ decoderPolicy = ActiveDecoderPolicy.AUTO,
+ useAudioVideoSyncSink = false,
+ useVideoRendererWorkaround = false
+ )
+ val autoSettings = buildPlaybackRendererFactorySettings(autoPlan)
+ assertThat(autoSettings.audioExtensionRendererMode)
+ .isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON)
+ assertThat(autoSettings.videoExtensionRendererMode)
+ .isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON)
+ assertThat(autoSettings.enableDecoderFallback).isTrue()
+
+ val softwarePlan = buildPlaybackRendererPlan(
+ requestedAudioMode = DecoderMode.SOFTWARE,
+ activeAudioDecoderMode = DecoderMode.SOFTWARE,
+ audioDecoderPolicy = ActiveDecoderPolicy.SOFTWARE_PREFERRED,
+ requestedVideoMode = DecoderMode.SOFTWARE,
+ activeVideoDecoderMode = DecoderMode.SOFTWARE,
+ videoDecoderPolicy = ActiveDecoderPolicy.SOFTWARE_PREFERRED,
+ useAudioVideoSyncSink = false,
+ useVideoRendererWorkaround = false
+ )
+ val softwareSettings = buildPlaybackRendererFactorySettings(softwarePlan)
+ assertThat(softwareSettings.audioExtensionRendererMode)
+ .isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
+ assertThat(softwareSettings.videoExtensionRendererMode)
+ .isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
+ assertThat(softwareSettings.enableDecoderFallback).isTrue()
+ }
+
@Test
fun `auto ignores decoder reuse workaround when compatibility profile requests it`() {
val plan = buildPlaybackRendererPlan(
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackLoadControlTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackLoadControlTest.kt
new file mode 100644
index 00000000..398eee8a
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackLoadControlTest.kt
@@ -0,0 +1,141 @@
+@file:androidx.media3.common.util.UnstableApi
+
+package com.streamvault.player.playback
+
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.MediaItem
+import androidx.media3.common.TrackGroup
+import androidx.media3.exoplayer.LoadControl
+import androidx.media3.exoplayer.analytics.PlayerId
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.SinglePeriodTimeline
+import androidx.media3.exoplayer.source.TrackGroupArray
+import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection
+import androidx.media3.exoplayer.trackselection.ExoTrackSelection
+import androidx.media3.exoplayer.trackselection.FixedTrackSelection
+import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class PlaybackLoadControlTest {
+ private val policy = PlaybackBufferPolicies.forPlayback(
+ ResolvedStreamType.HLS, compatibilityMode = false, lowMemoryDevice = true
+ )
+ private val timeline = SinglePeriodTimeline(
+ 300_000_000L, true, false, false, null,
+ MediaItem.fromUri("https://example.invalid/fixture.m3u8")
+ )
+
+ @Test
+ fun `high bitrate playback keeps loading past the old 32 MiB restriction`() {
+ assertThat(loadingAfter(48, 192, fixedVideo(80_000_000))).isTrue()
+ }
+
+ @Test
+ fun `byte target increases with the selected stream bitrate`() {
+ assertThat(loadingAfter(40, 192, fixedVideo(20_000_000))).isFalse()
+ assertThat(loadingAfter(40, 192, fixedVideo(40_000_000))).isTrue()
+ }
+
+ @Test
+ fun `memory protection stops loading even when buffered time is missing`() {
+ assertThat(loadingAfter(73, 192, fixedVideo(80_000_000))).isFalse()
+ }
+
+ @Test
+ fun `larger device heap permits a larger high bitrate buffer`() {
+ assertThat(loadingAfter(100, 192, fixedVideo(80_000_000))).isFalse()
+ assertThat(loadingAfter(100, 384, fixedVideo(80_000_000))).isTrue()
+ }
+
+ @Test
+ fun `unknown bitrate uses a bounded Media3 track target`() {
+ assertThat(loadingAfter(48, 192, fixedVideo(C.RATE_UNSET_INT))).isTrue()
+ assertThat(loadingAfter(73, 192, fixedVideo(C.RATE_UNSET_INT))).isFalse()
+ }
+
+ @Test
+ fun `adaptive sizing allows the eligible higher rendition without a player restart`() {
+ val group = TrackGroup(video(20_000_000), video(80_000_000))
+ val selection = AdaptiveTrackSelection(
+ group, intArrayOf(0, 1), DefaultBandwidthMeter.Builder(RuntimeEnvironment.getApplication()).build()
+ )
+ assertThat(loadingAfter(48, 192, selection)).isTrue()
+ // A manual selection of the lower track does not allocate for an unselected alternative.
+ assertThat(loadingAfter(40, 192, FixedTrackSelection(group, 0))).isFalse()
+ }
+
+ @Test
+ fun `multiview shares the device budget across four players`() {
+ assertThat(loadingAfter(20, 192, fixedVideo(80_000_000), multiview = true)).isFalse()
+ assertThat(loadingAfter(20, 192, fixedVideo(80_000_000))).isTrue()
+ }
+
+ @Test
+ fun `preloading cannot consume the foreground memory allowance`() {
+ assertThat(loadingAfter(25, 192, fixedVideo(80_000_000), playerId = PlayerId.PRELOAD)).isFalse()
+ }
+
+ @Test
+ fun `an existing player updates its budget when moving into or out of multiview`() {
+ assertThat(loadingAfter(20, 192, fixedVideo(80_000_000), updateMultiview = true)).isFalse()
+ assertThat(loadingAfter(20, 192, fixedVideo(80_000_000), multiview = true, updateMultiview = false)).isTrue()
+ }
+
+ @Test
+ fun `releasing one shared preload keeps surviving budget responsive to multiview`() {
+ assertThat(loadingAfter(10, 192, fixedVideo(80_000_000),
+ playerId = PlayerId.PRELOAD, updateMultiview = true, releaseSharedPreload = true)).isFalse()
+ }
+
+ @Test
+ fun `stopping one shared preload keeps surviving budget responsive to multiview`() {
+ assertThat(loadingAfter(10, 192, fixedVideo(80_000_000),
+ playerId = PlayerId.PRELOAD, updateMultiview = true, stopSharedPreload = true)).isFalse()
+ }
+
+ private fun loadingAfter(
+ allocatedMiB: Int,
+ heapMiB: Int,
+ selection: ExoTrackSelection,
+ multiview: Boolean = false,
+ playerId: PlayerId = PlayerId.UNSET,
+ updateMultiview: Boolean? = null,
+ releaseSharedPreload: Boolean = false,
+ stopSharedPreload: Boolean = false
+ ): Boolean {
+ val control = PlaybackLoadControl(policy, heapMiB.toLong() * MIB, multiview)
+ control.onPrepared(playerId)
+ if (releaseSharedPreload || stopSharedPreload) control.onPrepared(playerId)
+ val parameters = LoadControl.Parameters(
+ playerId, timeline, MediaSource.MediaPeriodId(timeline.getUidOfPeriod(0)),
+ 0L, 0L, 1f, true, false, C.TIME_UNSET, C.TIME_UNSET
+ )
+ control.onTracksSelected(parameters, TrackGroupArray(selection.trackGroup), arrayOf(selection))
+ control.shouldContinueLoading(parameters)
+ val allocator = control.getAllocator(playerId)
+ val blocks = List(allocatedMiB * MIB / allocator.individualAllocationLength) { allocator.allocate() }
+ if (releaseSharedPreload) control.onReleased(playerId)
+ if (stopSharedPreload) control.onStopped(playerId)
+ updateMultiview?.let(control::setMultiview)
+ return try {
+ control.shouldContinueLoading(parameters)
+ } finally {
+ blocks.forEach(allocator::release)
+ control.onReleased(playerId)
+ }
+ }
+
+ private fun fixedVideo(bitrate: Int) = FixedTrackSelection(TrackGroup(video(bitrate)), 0)
+ private fun video(bitrate: Int) = Format.Builder().setSampleMimeType("video/avc")
+ .setWidth(3840).setHeight(2160).setAverageBitrate(bitrate).build()
+
+ private companion object {
+ const val MIB = 1024 * 1024
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicyTest.kt
index 51890dcb..742709ea 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackStallRecoveryPolicyTest.kt
@@ -2,10 +2,39 @@ package com.streamvault.player.playback
import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.PlaybackContentKind
-import com.streamvault.player.PlaybackState
import org.junit.Test
class PlaybackStallRecoveryPolicyTest {
+ @Test
+ fun `pending Media3 load retry defers app level stall recovery`() {
+ assertThat(
+ shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = true,
+ sourceRetryPending = false
+ )
+ ).isTrue()
+ }
+
+ @Test
+ fun `scheduled source retry defers app level stall recovery`() {
+ assertThat(
+ shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = false,
+ sourceRetryPending = true
+ )
+ ).isTrue()
+ }
+
+ @Test
+ fun `stall recovery is eligible when no retry owns the source`() {
+ assertThat(
+ shouldDeferAppStallRecovery(
+ activeMediaLoadRetry = false,
+ sourceRetryPending = false
+ )
+ ).isFalse()
+ }
+
@Test
fun `ready stalls are recovered for live transport streams`() {
assertThat(shouldRecoverReadyStalls(ResolvedStreamType.MPEG_TS_LIVE)).isTrue()
@@ -38,48 +67,4 @@ class PlaybackStallRecoveryPolicyTest {
).isTrue()
}
- @Test
- fun `live ready stalls reconnect the current stream`() {
- assertThat(
- shouldReconnectLiveStall(
- playbackState = PlaybackState.READY,
- resolvedStreamType = ResolvedStreamType.MPEG_TS_LIVE,
- recoveryAttempt = 1
- )
- ).isTrue()
- }
-
- @Test
- fun `live ready stalls stop reconnecting after first recovery attempt`() {
- assertThat(
- shouldReconnectLiveStall(
- playbackState = PlaybackState.READY,
- resolvedStreamType = ResolvedStreamType.MPEG_TS_LIVE,
- recoveryAttempt = 2
- )
- ).isFalse()
- }
-
- @Test
- fun `vod ready stalls do not reconnect as live streams`() {
- assertThat(
- shouldReconnectLiveStall(
- playbackState = PlaybackState.READY,
- resolvedStreamType = ResolvedStreamType.PROGRESSIVE,
- recoveryAttempt = 1
- )
- ).isFalse()
- }
-
- @Test
- fun `vod hls stalls do not reconnect through the live recovery path`() {
- assertThat(
- shouldReconnectLiveStall(
- playbackState = PlaybackState.READY,
- resolvedStreamType = ResolvedStreamType.HLS,
- recoveryAttempt = 1,
- playbackContentKind = PlaybackContentKind.ON_DEMAND
- )
- ).isFalse()
- }
}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibilityTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibilityTest.kt
new file mode 100644
index 00000000..64d0e228
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackVideoCodecCompatibilityTest.kt
@@ -0,0 +1,113 @@
+package com.streamvault.player.playback
+
+import android.media.MediaCodecInfo.CodecCapabilities
+import android.media.MediaFormat
+import androidx.media3.common.Format
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DecoderReuseEvaluation
+import androidx.media3.exoplayer.mediacodec.MediaCodecInfo
+import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.MediaCodecInfoBuilder.CodecCapabilitiesBuilder
+
+@UnstableApi
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class PlaybackVideoCodecCompatibilityTest {
+ @Test
+ fun `affected decoder rejects resolution reuse but retains same resolution reuse`() {
+ val original = codec()
+ assertThat(original.adaptive).isTrue()
+ val patched = select(listOf(original)).single()
+ val small = format(1280, 720)
+ val large = format(3840, 2160)
+ assertThat(patched.canReuseCodec(small, large).result)
+ .isEqualTo(DecoderReuseEvaluation.REUSE_RESULT_NO)
+ assertThat(patched.canReuseCodec(large, small).result)
+ .isEqualTo(DecoderReuseEvaluation.REUSE_RESULT_NO)
+ assertThat(patched.canReuseCodec(small, small).result)
+ .isEqualTo(original.canReuseCodec(small, small).result)
+ }
+
+ @Test
+ fun `wrapper preserves ordering and unrelated decoder entries`() {
+ val affected = codec()
+ val vendor = codec("c2.vendor.avc.decoder")
+ val hevc = codec("c2.goldfish.hevc.decoder", "video/hevc")
+ val software = codec("c2.android.avc.decoder")
+ val actual = select(listOf(vendor, affected, hevc, software))
+ assertThat(actual.map { it.name }).containsExactly(
+ vendor.name, affected.name, hevc.name, software.name
+ ).inOrder()
+ assertThat(actual[0]).isSameInstanceAs(vendor)
+ assertThat(actual[2]).isSameInstanceAs(hevc)
+ assertThat(actual[3]).isSameInstanceAs(software)
+ }
+
+ @Test
+ fun `real device and non avc query retain original entries`() {
+ val original = codec()
+ assertThat(select(listOf(original), eligible = false).single()).isSameInstanceAs(original)
+ assertThat(select(listOf(original), mime = "audio/mp4a-latm").single()).isSameInstanceAs(original)
+ }
+
+ @Test
+ fun `patched entry preserves capability and security information`() {
+ val original = codec(secure = true)
+ val actual = select(listOf(original), secure = true, tunneling = true).single()
+ assertThat(actual.adaptive).isFalse()
+ assertThat(actual.capabilities).isSameInstanceAs(original.capabilities)
+ assertThat(actual.codecMimeType).isEqualTo(original.codecMimeType)
+ assertThat(actual.mimeType).isEqualTo(original.mimeType)
+ assertThat(actual.hardwareAccelerated).isEqualTo(original.hardwareAccelerated)
+ assertThat(actual.softwareOnly).isEqualTo(original.softwareOnly)
+ assertThat(actual.vendor).isEqualTo(original.vendor)
+ assertThat(actual.secure).isTrue()
+ assertThat(actual.tunneling).isEqualTo(original.tunneling)
+ assertThat(actual.detachedSurfaceSupported).isEqualTo(original.detachedSurfaceSupported)
+ }
+
+ @Test
+ fun `already nonadaptive codec retains original entry`() {
+ val original = codec(nonadaptive = true)
+ assertThat(select(listOf(original)).single()).isSameInstanceAs(original)
+ }
+
+ private fun select(
+ entries: List<MediaCodecInfo>, eligible: Boolean = true,
+ mime: String = "video/avc", secure: Boolean = false, tunneling: Boolean = false
+ ): List<MediaCodecInfo> {
+ val delegate = MediaCodecSelector { queryMime, querySecure, queryTunneling ->
+ assertThat(queryMime).isEqualTo(mime)
+ assertThat(querySecure).isEqualTo(secure)
+ assertThat(queryTunneling).isEqualTo(tunneling)
+ entries.toMutableList()
+ }
+ return PlaybackVideoCodecCompatibility(delegate, eligible)
+ .getDecoderInfos(mime, secure, tunneling)
+ }
+
+ private fun format(width: Int, height: Int) = Format.Builder()
+ .setSampleMimeType("video/avc").setWidth(width).setHeight(height).build()
+
+ private fun codec(
+ name: String = "c2.goldfish.h264.decoder", mime: String = "video/avc",
+ secure: Boolean = false, nonadaptive: Boolean = false
+ ): MediaCodecInfo {
+ val mediaFormat = MediaFormat.createVideoFormat(mime, 3840, 2160).apply {
+ setFeatureEnabled(CodecCapabilities.FEATURE_AdaptivePlayback, true)
+ setFeatureEnabled(CodecCapabilities.FEATURE_TunneledPlayback, true)
+ }
+ val capabilities = CodecCapabilitiesBuilder.newBuilder()
+ .setMediaFormat(mediaFormat)
+ .setColorFormats(intArrayOf(CodecCapabilities.COLOR_FormatSurface))
+ .setProfileLevels(emptyArray()).build()
+ return MediaCodecInfo.newInstance(
+ name, mime, mime, capabilities, true, false, true, nonadaptive, secure
+ )
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerDataSourceFactoryProviderTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerDataSourceFactoryProviderTest.kt
index fd8c1811..45b9bf15 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerDataSourceFactoryProviderTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerDataSourceFactoryProviderTest.kt
@@ -68,16 +68,6 @@ class PlayerDataSourceFactoryProviderTest {
)
}
- @Test
- fun `mpeg ts live keeps okhttp data source`() {
- assertThat(shouldUsePlatformHttpDataSource(ResolvedStreamType.MPEG_TS_LIVE)).isFalse()
- }
-
- @Test
- fun `hls keeps okhttp data source`() {
- assertThat(shouldUsePlatformHttpDataSource(ResolvedStreamType.HLS)).isFalse()
- }
-
@Test
fun `read stats wrap only live stream types`() {
assertThat(shouldWrapDataSourceReadStats(ResolvedStreamType.HLS)).isTrue()
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
index 18fdb1d9..7e93c051 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
@@ -20,6 +20,12 @@ class PlayerErrorClassifierTest {
.isEqualTo(PlaybackErrorCategory.HTTP_SERVER)
}
+ @Test
+ fun `404 maps to a missing source`() {
+ assertThat(PlayerErrorClassifier.classify(IOException("HTTP 404")))
+ .isEqualTo(PlaybackErrorCategory.HTTP_NOT_FOUND)
+ }
+
@Test
fun `456 maps to auth`() {
assertThat(PlayerErrorClassifier.classify(IOException("HTTP 456")))
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
index 15b8f32f..0be77b90 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
@@ -4,14 +4,23 @@ import android.os.Bundle
import androidx.media3.common.C
import androidx.media3.common.ParserException
import androidx.media3.common.PlaybackException
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.HttpDataSource
import androidx.media3.exoplayer.source.BehindLiveWindowException
+import androidx.media3.exoplayer.source.LoadEventInfo
+import androidx.media3.exoplayer.source.MediaLoadData
+import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.PlaybackContentKind
import java.io.IOException
import java.net.SocketTimeoutException
import javax.net.ssl.SSLHandshakeException
import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+@RunWith(RobolectricTestRunner::class)
class PlayerRetryPolicyTest {
private val liveContext = PlaybackRetryContext(
@@ -31,6 +40,71 @@ class PlayerRetryPolicyTest {
fastRetryOnTransientFailures = { true }
)
+ @Test
+ fun `retrying Media3 load owns recovery until load task concludes`() {
+ val errorInfo = loadError(responseCode = 503)
+
+ assertThat(policy.hasPendingLoadRecovery).isFalse()
+ assertThat(policy.getRetryDelayMsFor(errorInfo)).isEqualTo(1_000L)
+ assertThat(policy.hasPendingLoadRecovery).isTrue()
+
+ policy.onLoadTaskConcluded(errorInfo.loadEventInfo.loadTaskId)
+
+ assertThat(policy.hasPendingLoadRecovery).isFalse()
+ }
+
+ @Test
+ fun `load recovery transitions notify foreground priority immediately`() {
+ var notifications = 0
+ val observed = PlayerRetryPolicy(
+ streamContext = liveContext,
+ onLoadRecoveryChanged = { notifications++ },
+ playbackStarted = { true }
+ )
+ val errorInfo = loadError(responseCode = 503)
+
+ observed.getRetryDelayMsFor(errorInfo)
+ observed.onLoadTaskConcluded(errorInfo.loadEventInfo.loadTaskId)
+
+ assertThat(notifications).isEqualTo(2)
+ }
+
+ @Test
+ fun `Media3 fallback owns recovery until load task concludes`() {
+ val errorInfo = loadError(responseCode = 503)
+
+ assertThat(
+ policy.getFallbackSelectionFor(
+ fallbackOptions(locations = 2, tracks = 1),
+ errorInfo
+ )
+ ).isNotNull()
+ assertThat(policy.hasPendingLoadRecovery).isTrue()
+
+ policy.onLoadTaskConcluded(errorInfo.loadEventInfo.loadTaskId)
+
+ assertThat(policy.hasPendingLoadRecovery).isFalse()
+ }
+
+ @Test
+ fun `whole source retries are capped after Media3 has exhausted load retry`() {
+ val error = SocketTimeoutException("timed out")
+
+ assertThat(policy.shouldRetryWholeSource(error, playbackStarted = true, attempt = 1)).isTrue()
+ assertThat(policy.shouldRetryWholeSource(error, playbackStarted = true, attempt = 2)).isFalse()
+ }
+
+ @Test
+ fun `terminal errors never use whole source retry budget`() {
+ assertThat(
+ policy.shouldRetryWholeSource(
+ IOException("HTTP 403"),
+ playbackStarted = true,
+ attempt = 1
+ )
+ ).isFalse()
+ }
+
@Test
fun `live server errors retry 10 times with bounded backoff`() {
val error = IOException("HTTP 500")
@@ -155,6 +229,69 @@ class PlayerRetryPolicyTest {
assertThat(progressivePolicy.retryReason(error)).isEqualTo("server-retryable")
}
+ @Test
+ fun `eligible server error falls back to an available location`() {
+ val selection = policy.getFallbackSelectionFor(
+ fallbackOptions(locations = 2, tracks = 1),
+ loadError(responseCode = 503)
+ )
+
+ assertThat(selection?.type).isEqualTo(LoadErrorHandlingPolicy.FALLBACK_TYPE_LOCATION)
+ assertThat(selection?.exclusionDurationMs)
+ .isEqualTo(DefaultLoadErrorHandlingPolicy.DEFAULT_LOCATION_EXCLUSION_MS)
+ }
+
+ @Test
+ fun `404 skips retrying the missing resource but uses an available adaptive fallback`() {
+ val errorInfo = loadError(responseCode = 404)
+ val error = errorInfo.exception
+
+ assertThat(PlayerErrorClassifier.classify(error)).isEqualTo(PlaybackErrorCategory.HTTP_NOT_FOUND)
+ assertThat(policy.shouldRetry(error, liveContext, playbackStarted = true, attempt = 1)).isFalse()
+ assertThat(policy.shouldRetryWholeSource(error, playbackStarted = true, attempt = 1)).isFalse()
+
+ val fallback = policy.getFallbackSelectionFor(
+ fallbackOptions(locations = 2, tracks = 1),
+ errorInfo
+ )
+ assertThat(fallback?.type).isEqualTo(LoadErrorHandlingPolicy.FALLBACK_TYPE_LOCATION)
+ }
+
+ @Test
+ fun `eligible server error falls back to an available track when no alternate location exists`() {
+ val selection = policy.getFallbackSelectionFor(
+ fallbackOptions(locations = 1, tracks = 2),
+ loadError(responseCode = 503)
+ )
+
+ assertThat(selection?.type).isEqualTo(LoadErrorHandlingPolicy.FALLBACK_TYPE_TRACK)
+ assertThat(selection?.exclusionDurationMs)
+ .isEqualTo(DefaultLoadErrorHandlingPolicy.DEFAULT_TRACK_EXCLUSION_MS)
+ }
+
+ @Test
+ fun `authentication error does not fall back and a single option has no fallback`() {
+ val options = fallbackOptions(locations = 2, tracks = 2)
+
+ assertThat(policy.getFallbackSelectionFor(options, loadError(responseCode = 403))).isNull()
+ assertThat(
+ policy.getFallbackSelectionFor(
+ fallbackOptions(locations = 1, tracks = 1),
+ loadError(responseCode = 503)
+ )
+ ).isNull()
+ }
+
+ @Test
+ fun `progressive source does not use adaptive fallback even when an alternate location exists`() {
+ assertThat(
+ progressivePolicy.getFallbackSelectionFor(
+ fallbackOptions(locations = 2, tracks = 1),
+ loadError(responseCode = 503)
+ )
+ ).isNull()
+ }
+
@Test
fun `explicit hls vod uses finite source retry treatment`() {
val vodHlsContext = PlaybackRetryContext(
@@ -266,4 +403,28 @@ class PlayerRetryPolicyTest {
message: String,
errorCode: Int
) : PlaybackException(message, null, errorCode, Bundle.EMPTY, 0L)
+
+ private fun fallbackOptions(locations: Int, tracks: Int) =
+ LoadErrorHandlingPolicy.FallbackOptions(locations, 0, tracks, 0, false)
+
+ private fun loadError(responseCode: Int): LoadErrorHandlingPolicy.LoadErrorInfo {
+ val dataSpec = DataSpec.Builder()
+ .setUri("https://example.com/manifest.m3u8")
+ .build()
+ val exception = HttpDataSource.InvalidResponseCodeException(
+ responseCode,
+ null,
+ null,
+ emptyMap(),
+ dataSpec,
+ byteArrayOf()
+ )
+ val loadEventInfo = LoadEventInfo.Builder(LoadEventInfo.getNewId(), dataSpec, 0L).build()
+ return LoadErrorHandlingPolicy.LoadErrorInfo(
+ loadEventInfo,
+ MediaLoadData(C.DATA_TYPE_MEDIA),
+ exception,
+ 1
+ )
+ }
}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicyTest.kt
index 8737d919..4feb1637 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicyTest.kt
@@ -104,24 +104,72 @@ class PlayerRetrySeekPositionPolicyTest {
}
@Test
- fun `new retry category starts its own attempt budget`() {
- val nextAttempt = resolveRetryAttemptForCategory(
- currentAttempt = 1,
- lastCategory = PlaybackErrorCategory.LIVE_WINDOW,
- nextCategory = PlaybackErrorCategory.SOURCE_MALFORMED
- )
+ fun `whole source retry budget continues across changing error categories`() {
+ assertThat(resolveNextAppSourceRetryAttempt(currentAttempt = 1)).isEqualTo(2)
+ }
- assertThat(nextAttempt).isEqualTo(1)
+ @Test
+ fun `first whole source retry starts at one`() {
+ assertThat(resolveNextAppSourceRetryAttempt(currentAttempt = 0)).isEqualTo(1)
}
@Test
- fun `same retry category increments current attempt`() {
- val nextAttempt = resolveRetryAttemptForCategory(
- currentAttempt = 2,
- lastCategory = PlaybackErrorCategory.SOURCE_MALFORMED,
- nextCategory = PlaybackErrorCategory.SOURCE_MALFORMED
- )
+ fun `scheduled source retry is rejected after the source generation changes`() {
+ assertThat(
+ isScheduledAppSourceRetryCurrent(
+ scheduledGeneration = 4L,
+ currentGeneration = 5L,
+ scheduledMediaId = "old-item",
+ currentMediaId = "new-item",
+ scheduledAttempt = 1,
+ currentAttempt = 1
+ )
+ ).isFalse()
+ }
- assertThat(nextAttempt).isEqualTo(3)
+ @Test
+ fun `scheduled source retry remains valid only for its media item and attempt`() {
+ assertThat(
+ isScheduledAppSourceRetryCurrent(
+ scheduledGeneration = 4L,
+ currentGeneration = 4L,
+ scheduledMediaId = "same-item",
+ currentMediaId = "same-item",
+ scheduledAttempt = 1,
+ currentAttempt = 1
+ )
+ ).isTrue()
+ assertThat(
+ isScheduledAppSourceRetryCurrent(
+ scheduledGeneration = 4L,
+ currentGeneration = 4L,
+ scheduledMediaId = "same-item",
+ currentMediaId = "same-item",
+ scheduledAttempt = 1,
+ currentAttempt = 2
+ )
+ ).isFalse()
+ }
+
+ @Test
+ fun `user seek during a pending retry replaces the captured stale position`() {
+ assertThat(
+ resolveScheduledRetrySeekPositionMs(
+ category = PlaybackErrorCategory.NETWORK,
+ plannedPositionMs = 120_000L,
+ userSeekOverrideMs = 540_000L
+ )
+ ).isEqualTo(540_000L)
+ }
+
+ @Test
+ fun `behind live window retry always uses the live default position`() {
+ assertThat(
+ resolveScheduledRetrySeekPositionMs(
+ category = PlaybackErrorCategory.LIVE_WINDOW,
+ plannedPositionMs = 120_000L,
+ userSeekOverrideMs = 540_000L
+ )
+ ).isNull()
}
}
diff --git a/player/src/test/java/com/streamvault/player/playback/PreloadCoordinatorTest.kt b/player/src/test/java/com/streamvault/player/playback/PreloadCoordinatorTest.kt
deleted file mode 100644
index af053450..00000000
--- a/player/src/test/java/com/streamvault/player/playback/PreloadCoordinatorTest.kt
+++ /dev/null
@@ -1,73 +0,0 @@
-package com.streamvault.player.playback
-
-import com.google.common.truth.Truth.assertThat
-import com.streamvault.domain.model.DrmInfo
-import com.streamvault.domain.model.DrmScheme
-import com.streamvault.domain.model.StreamInfo
-import java.lang.reflect.Proxy
-import androidx.media3.exoplayer.source.MediaSource
-import org.junit.Test
-
-class PreloadCoordinatorTest {
-
- @Test
- fun `same item same url under two minutes reuses`() {
- var now = 1_000L
- val coordinator = PreloadCoordinator { now }
- val source = fakeMediaSource()
- val info = StreamInfo(url = "http://example.com/movie.mp4")
- coordinator.store("1", info, ResolvedStreamType.PROGRESSIVE, source)
-
- assertThat(coordinator.tryReuse("1", info, ResolvedStreamType.PROGRESSIVE)).isSameInstanceAs(source)
- }
-
- @Test
- fun `different url invalidates`() {
- var now = 1_000L
- val coordinator = PreloadCoordinator { now }
- coordinator.store("1", StreamInfo(url = "http://example.com/a.mp4"), ResolvedStreamType.PROGRESSIVE, fakeMediaSource())
-
- assertThat(coordinator.tryReuse("1", StreamInfo(url = "http://example.com/b.mp4"), ResolvedStreamType.PROGRESSIVE)).isNull()
- }
-
- @Test
- fun `different stream type invalidates`() {
- var now = 1_000L
- val coordinator = PreloadCoordinator { now }
- val info = StreamInfo(url = "http://example.com/live/channel.ts")
- coordinator.store("1", info, ResolvedStreamType.MPEG_TS_LIVE, fakeMediaSource())
-
- assertThat(coordinator.tryReuse("1", info, ResolvedStreamType.HLS)).isNull()
- }
-
- @Test
- fun `older than two minutes expires`() {
- var now = 1_000L
- val coordinator = PreloadCoordinator { now }
- val info = StreamInfo(
- url = "http://example.com/movie.mp4",
- drmInfo = DrmInfo(DrmScheme.WIDEVINE, "http://license")
- )
- coordinator.store("1", info, ResolvedStreamType.PROGRESSIVE, fakeMediaSource())
- now += 121_000L
-
- assertThat(coordinator.tryReuse("1", info, ResolvedStreamType.PROGRESSIVE)).isNull()
- }
-
- private fun fakeMediaSource(): MediaSource {
- return Proxy.newProxyInstance(
- MediaSource::class.java.classLoader,
- arrayOf(MediaSource::class.java)
- ) { _, method, _ ->
- when (method.returnType) {
- Boolean::class.javaPrimitiveType -> false
- Int::class.javaPrimitiveType -> 0
- Long::class.javaPrimitiveType -> 0L
- Float::class.javaPrimitiveType -> 0f
- Double::class.javaPrimitiveType -> 0.0
- Unit::class.java -> Unit
- else -> null
- }
- } as MediaSource
- }
-}
diff --git a/player/src/test/java/com/streamvault/player/playback/VideoStallDetectorTest.kt b/player/src/test/java/com/streamvault/player/playback/VideoStallDetectorTest.kt
index 89b1555e..c4bc708a 100644
--- a/player/src/test/java/com/streamvault/player/playback/VideoStallDetectorTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/VideoStallDetectorTest.kt
@@ -7,6 +7,31 @@ import org.junit.Test
class VideoStallDetectorTest {
private var nowMs = 0L
+ @Test
+ fun `unsuccessful recovery is reported again after grace without inventing a rendered frame`() {
+ val detector = detector()
+ detector.reset()
+ nowMs = 1_000L
+ detector.onVideoFrameRendered(500L)
+ nowMs = 9_000L
+ assertThat(detector.shouldReportStall(
+ PlaybackState.READY, true, true, 9_000L, 5_000L,
+ recoverFrameSilentReadyStalls = true
+ )).isTrue()
+ detector.restartAfterRecoveryAttempt()
+ assertThat(detector.lastVideoFrameAgoMs()).isEqualTo(8_000L)
+ nowMs = 12_000L
+ assertThat(detector.shouldReportStall(
+ PlaybackState.READY, true, true, 12_000L, 5_000L,
+ recoverFrameSilentReadyStalls = true
+ )).isFalse()
+ nowMs = 18_000L
+ assertThat(detector.shouldReportStall(
+ PlaybackState.READY, true, true, 18_000L, 5_000L,
+ recoverFrameSilentReadyStalls = true
+ )).isTrue()
+ }
+
@Test
fun `does not report before initial grace`() {
val detector = detector()
diff --git a/player/src/test/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracksTest.kt b/player/src/test/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracksTest.kt
new file mode 100644
index 00000000..a792b5d6
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/tracks/AdaptiveDecodePressureTracksTest.kt
@@ -0,0 +1,87 @@
+package com.streamvault.player.tracks
+
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.TrackSelectionOverride
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.player.playback.DecodePressureRendition
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class AdaptiveDecodePressureTracksTest {
+ private val formats = listOf(format("high", 2160, 41_000_000), format("mid", 1080, 9_000_000), format("low", 720, 3_000_000))
+ private val group = TrackGroup("video", *formats.toTypedArray())
+ private fun format(id: String, height: Int, bitrate: Int) = Format.Builder().setId(id).setSampleMimeType("video/avc")
+ .setHeight(height).setWidth(height * 16 / 9).setAverageBitrate(bitrate).build()
+ private fun parameters() = TrackSelectionParameters.Builder(RuntimeEnvironment.getApplication()).setViewportSize(3840, 2160, true).build()
+ private fun tracks(adaptive: Boolean = true, support: IntArray = intArrayOf(C.FORMAT_HANDLED, C.FORMAT_HANDLED, C.FORMAT_HANDLED)) =
+ Tracks(listOf(Tracks.Group(group, adaptive, support, booleanArrayOf(true, false, false))))
+ private val context get() = DecodePressureTrackContext(group, listOf(0, 1, 2), listOf(
+ DecodePressureRendition(2160, 41_000_000), DecodePressureRendition(1080, 9_000_000), DecodePressureRendition(720, 3_000_000)))
+
+ @Test fun `narrowing keeps ABR inside the original group and preserves other parameters`() {
+ val binding = AdaptiveDecodePressureTracks()
+ val audio = TrackSelectionOverride(TrackGroup("audio", Format.Builder().setSampleMimeType("audio/aac").build()), 0)
+ val original = parameters().buildUpon().setOverrideForType(audio).setPreferredTextLanguage("es").setMaxVideoBitrate(45_000_000).build()
+ val narrowed = binding.constrain(original, context, 1080)
+ assertThat(narrowed.overrides[group]?.trackIndices).containsExactly(1, 2).inOrder()
+ assertThat(narrowed.overrides[audio.mediaTrackGroup]).isEqualTo(audio)
+ assertThat(narrowed.preferredTextLanguages).containsExactly("es")
+ assertThat(narrowed.maxVideoBitrate).isEqualTo(45_000_000)
+ assertThat(binding.context(tracks(), formats[1], narrowed, true)).isNotNull()
+ assertThat(binding.clear(narrowed)).isEqualTo(original)
+ }
+
+ @Test fun `manual override is neither narrowed nor removed on cleanup`() {
+ val binding = AdaptiveDecodePressureTracks()
+ val manual = TrackSelectionOverride(group, 0)
+ assertThat(binding.context(tracks(), formats[0], parameters().buildUpon().setOverrideForType(manual).build(), true)).isNull()
+ assertThat(binding.context(tracks(), formats[0], parameters(), false)).isNull()
+ val narrowed = binding.constrain(parameters(), context, 1080)
+ val selected = narrowed.buildUpon().setOverrideForType(manual).build()
+ assertThat(binding.clear(selected)).isEqualTo(selected)
+ }
+
+ @Test fun `unsupported alternatives and nonadaptive groups are excluded`() {
+ val binding = AdaptiveDecodePressureTracks()
+ assertThat(binding.context(tracks(), formats[0], parameters(), true)?.indices).containsExactly(0, 1, 2)
+ assertThat(binding.context(tracks(false), formats[0], parameters(), true)).isNull()
+ assertThat(binding.context(tracks(support = intArrayOf(C.FORMAT_HANDLED, C.FORMAT_EXCEEDS_CAPABILITIES, C.FORMAT_UNSUPPORTED_SUBTYPE)), formats[0], parameters(), true)).isNull()
+ }
+
+ @Test fun `saved quality limits still bound the eligible adaptive subset`() {
+ val binding = AdaptiveDecodePressureTracks()
+ val params = parameters().buildUpon().setMaxVideoSize(Int.MAX_VALUE, 1080).build()
+ assertThat(binding.context(tracks(), formats[1], params, true)?.indices).containsExactly(1, 2)
+ val narrowed = binding.constrain(params, binding.context(tracks(), formats[1], params, true)!!, 720)
+ assertThat(narrowed.overrides[group]?.trackIndices).containsExactly(2)
+ assertThat(narrowed.maxVideoHeight).isEqualTo(1080)
+ assertThat(binding.clear(narrowed).maxVideoHeight).isEqualTo(1080)
+ }
+
+ @Test fun `nonmonotonic bitrate ladder excludes more expensive lower resolution`() {
+ val odd = TrackGroup("odd", format("high", 2160, 10_000_000), format("mid", 1080, 8_000_000), format("low", 720, 20_000_000))
+ val ctx = DecodePressureTrackContext(odd, listOf(0, 1, 2), emptyList())
+ val narrowed = AdaptiveDecodePressureTracks().constrain(parameters(), ctx, 1080, 8_000_000)
+ assertThat(narrowed.overrides[odd]?.trackIndices.orEmpty()).containsExactly(1)
+ }
+
+ @Test fun `frame rate minimums and explicit viewport remain eligibility constraints`() {
+ val binding = AdaptiveDecodePressureTracks()
+ val fast = formats[1].buildUpon().setFrameRate(120f).build()
+ val g = TrackGroup("fps", formats[0].buildUpon().setFrameRate(60f).build(), fast, formats[2].buildUpon().setFrameRate(60f).build())
+ val t = Tracks(listOf(Tracks.Group(g, true, IntArray(3) { C.FORMAT_HANDLED }, booleanArrayOf(true, false, false))))
+ val params = parameters().buildUpon().setViewportSize(3840, 2160, true).setMaxVideoFrameRate(60).build()
+ assertThat(binding.context(t, g.getFormat(0), params, true)?.indices.orEmpty()).containsExactly(0, 2)
+ val minimum = parameters().buildUpon().setMinVideoSize(1920, 1080).build()
+ assertThat(binding.context(tracks(), formats[0], minimum, true)?.indices.orEmpty()).containsExactly(0, 1)
+ val viewport = parameters().buildUpon().setViewportSize(1280, 720, true).build()
+ assertThat(binding.context(tracks(), formats[0], viewport, true)).isNull()
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/tracks/PlayerTrackControllerSelectionTest.kt b/player/src/test/java/com/streamvault/player/tracks/PlayerTrackControllerSelectionTest.kt
index 8e0c8521..82b75c70 100644
--- a/player/src/test/java/com/streamvault/player/tracks/PlayerTrackControllerSelectionTest.kt
+++ b/player/src/test/java/com/streamvault/player/tracks/PlayerTrackControllerSelectionTest.kt
@@ -1,11 +1,39 @@
package com.streamvault.player.tracks
+import androidx.media3.common.C
+import androidx.media3.common.Format
import com.google.common.truth.Truth.assertThat
import com.streamvault.player.PLAYER_TRACK_AUTO_ID
import org.junit.Test
class PlayerTrackControllerSelectionTest {
+ @Test
+ fun `video track id survives a rebuilt group with the same representation`() {
+ val format = Format.Builder()
+ .setSampleMimeType("video/avc")
+ .setWidth(1920)
+ .setHeight(1080)
+ .setAverageBitrate(9_500_000)
+ .setFrameRate(25f)
+ .setCodecs("avc1.640028")
+ .build()
+
+ val before = playerTrackId(format, C.TRACK_TYPE_VIDEO, 112233, 1)
+ val rebuilt = playerTrackId(format.buildUpon().build(), C.TRACK_TYPE_VIDEO, 998877, 1)
+
+ assertThat(rebuilt).isEqualTo(before)
+ }
+
+ @Test
+ fun `nonvideo fallback track id remains group scoped`() {
+ val format = Format.Builder().setSampleMimeType("audio/aac").build()
+
+ assertThat(playerTrackId(format, C.TRACK_TYPE_AUDIO, 112233, 0)).isNotEqualTo(
+ playerTrackId(format, C.TRACK_TYPE_AUDIO, 998877, 0)
+ )
+ }
+
@Test
fun `stale selected video track falls back to auto when multiple tracks remain`() {
assertThat(
@@ -35,4 +63,14 @@ class PlayerTrackControllerSelectionTest {
)
).isEqualTo("720p")
}
-}
\ No newline at end of file
+
+ @Test
+ fun `current selected video track survives a temporary empty track list`() {
+ assertThat(
+ normalizeSelectedVideoTrackId(
+ selectedTrackId = "1080p",
+ availableTrackIds = emptyList()
+ )
+ ).isEqualTo("1080p")
+ }
+}
diff --git a/tools/v11_playback_fixture_server.py b/tools/v11_playback_fixture_server.py
new file mode 100644
index 00000000..708ad126
--- /dev/null
+++ b/tools/v11_playback_fixture_server.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Local Xtream-style auth rollover fixture for V11 playback instrumentation."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+
+OLD = ("old-user", "old-pass")
+NEXT = ("next-user", "next-pass")
+THIRD = ("third-user", "third-pass")
+LABELS = {OLD: "old", NEXT: "next", THIRD: "third"}
+MOVIES = {
+ 801: ("V11 HLS Adaptive Fixture", "m3u8", "99999801"),
+ 802: ("V11 Progressive Tracks Fixture", "mp4", "99999802"),
+}
+
+lock = threading.Lock()
+accepted = {OLD}
+events: list[dict] = []
+active: dict[int, dict] = {}
+sequence = 0
+peak_active = 0
+hls_root: Path
+progressive_file: Path
+
+
+def label_for(pair: tuple[str, str]) -> str:
+ return LABELS.get(pair, "invalid")
+
+
+def record(event: str, **data: object) -> None:
+ row = {"time": time.time(), "event": event, **data}
+ with lock:
+ events.append(row)
+
+
+def movie(stream_id: int) -> dict:
+ name, extension, tmdb = MOVIES[stream_id]
+ return {
+ "stream_id": stream_id,
+ "name": name,
+ "category_id": "1",
+ "container_extension": extension,
+ "rating": "8",
+ "tmdb": tmdb,
+ }
+
+
+class Handler(BaseHTTPRequestHandler):
+ protocol_version = "HTTP/1.1"
+
+ def log_message(self, *_args: object) -> None:
+ pass
+
+ def reply(self, body: bytes | dict, content_type: str = "application/json", status: int = 200) -> None:
+ payload = body if isinstance(body, bytes) else json.dumps(body).encode("utf-8")
+ self.send_response(status)
+ self.send_header("Content-Type", content_type)
+ self.send_header("Content-Length", str(len(payload)))
+ self.send_header("Cache-Control", "no-store")
+ self.end_headers()
+ try:
+ self.wfile.write(payload)
+ except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+ pass
+
+ @staticmethod
+ def credential(query: dict[str, list[str]]) -> tuple[str, str]:
+ return query.get("username", [""])[0], query.get("password", [""])[0]
+
+ def do_GET(self) -> None:
+ global accepted, sequence, peak_active
+ parsed = urllib.parse.urlsplit(self.path)
+ query = urllib.parse.parse_qs(parsed.query)
+
+ if parsed.path == "/control":
+ selected = set(query.get("accept", ["old"])[0].split(","))
+ pairs = {name: pair for pair, name in LABELS.items()}
+ with lock:
+ accepted = {pairs[name] for name in selected if name in pairs}
+ if query.get("reset", ["0"])[0] == "1":
+ events.clear()
+ peak_active = len(active)
+ record("control", accepted=sorted(selected))
+ return self.reply({"accepted": sorted(selected)})
+
+ if parsed.path == "/events":
+ with lock:
+ snapshot = {"events": list(events), "active": dict(active), "peakActive": peak_active}
+ return self.reply(snapshot)
+
+ if parsed.path == "/player_api.php":
+ pair = self.credential(query)
+ with lock:
+ allowed = pair in accepted
+ record("api", credential=label_for(pair), action=query.get("action", [""])[0])
+ if not allowed:
+ return self.reply({"user_info": {"auth": 0, "status": "Expired"}}, status=401)
+ action = query.get("action", [""])[0]
+ if not action:
+ data = {
+ "user_info": {
+ "username": pair[0], "password": pair[1], "auth": 1,
+ "status": "Active", "max_connections": "5",
+ },
+ "server_info": {
+ "url": "10.0.2.2", "port": "18774", "server_protocol": "http",
+ "timezone": "UTC", "timestamp_now": int(time.time()),
+ },
+ }
+ elif action == "get_vod_categories":
+ data = [{"category_id": "1", "category_name": "V11 Auth Rollover", "parent_id": 0}]
+ elif action == "get_vod_streams":
+ data = [movie(stream_id) for stream_id in MOVIES]
+ elif action == "get_vod_info":
+ stream_id = int(query.get("vod_id", ["0"])[0])
+ if stream_id not in MOVIES:
+ return self.reply({}, status=404)
+ data = {
+ "info": {
+ "name": MOVIES[stream_id][0], "duration_secs": 240,
+ "duration": "00:04:00", "tmdb_id": int(MOVIES[stream_id][2]),
+ },
+ "movie_data": movie(stream_id),
+ }
+ else:
+ data = []
+ return self.reply(data)
+
+ path_parts = [urllib.parse.unquote(part) for part in parsed.path.split("/") if part]
+ if len(path_parts) < 4 or path_parts[0] != "movie":
+ return self.reply({"error": "not found"}, status=404)
+
+ pair = (path_parts[1], path_parts[2])
+ credential = label_for(pair)
+ suffix = path_parts[3:]
+ with lock:
+ allowed = pair in accepted
+ if not allowed:
+ record("media", credential=credential, path="/".join(suffix), status=401)
+ return self.reply(b"expired credentials", "text/plain", 401)
+
+ if suffix == ["801.m3u8"]:
+ target = hls_root / "master.m3u8"
+ elif suffix == ["802.mp4"]:
+ target = progressive_file
+ else:
+ target = (hls_root / Path(*suffix)).resolve()
+ if not target.is_relative_to(hls_root.resolve()):
+ return self.reply({"error": "not found"}, status=404)
+ if not target.is_file():
+ record("media", credential=credential, path="/".join(suffix), status=404)
+ return self.reply({"error": "not found"}, status=404)
+
+ raw_size = target.stat().st_size
+ start = 0
+ end = raw_size - 1
+ status = 200
+ range_value = self.headers.get("Range")
+ if range_value:
+ import re
+
+ match = re.fullmatch(r"bytes=(\d+)-(\d*)", range_value)
+ if not match:
+ return self.reply(b"invalid range", "text/plain", 416)
+ start = int(match.group(1))
+ end = min(int(match.group(2)) if match.group(2) else end, end)
+ if start > end:
+ return self.reply(b"invalid range", "text/plain", 416)
+ status = 206
+
+ with lock:
+ sequence += 1
+ request_id = sequence
+ active[request_id] = {"credential": credential, "path": "/".join(suffix)}
+ peak_active = max(peak_active, len(active))
+ record("open", id=request_id, credential=credential, path="/".join(suffix), range=range_value, status=status)
+
+ if target.suffix == ".m3u8":
+ content_type = "application/vnd.apple.mpegurl"
+ elif target.suffix == ".ts":
+ content_type = "video/mp2t"
+ else:
+ content_type = "video/mp4"
+ length = end - start + 1
+ self.send_response(status)
+ self.send_header("Content-Type", content_type)
+ self.send_header("Content-Length", str(length))
+ self.send_header("Cache-Control", "no-store")
+ self.send_header("Accept-Ranges", "bytes")
+ if status == 206:
+ self.send_header("Content-Range", f"bytes {start}-{end}/{raw_size}")
+ self.end_headers()
+ sent = 0
+ try:
+ with target.open("rb") as media:
+ media.seek(start)
+ remaining = length
+ while remaining:
+ block = media.read(min(64 * 1024, remaining))
+ if not block:
+ break
+ self.wfile.write(block)
+ sent += len(block)
+ remaining -= len(block)
+ except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+ pass
+ finally:
+ with lock:
+ active.pop(request_id, None)
+ active_snapshot = dict(active)
+ record("close", id=request_id, credential=credential, sent=sent, active=active_snapshot)
+
+
+def main() -> None:
+ global hls_root, progressive_file
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--port", type=int, default=18774)
+ parser.add_argument("--hls-root", type=Path, required=True)
+ parser.add_argument("--progressive-file", type=Path, required=True)
+ args = parser.parse_args()
+ hls_root = args.hls_root.resolve()
+ progressive_file = args.progressive_file.resolve()
+ if not (hls_root / "master.m3u8").is_file() or not progressive_file.is_file():
+ raise SystemExit("fixture media files are missing")
+ server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
+ server.daemon_threads = True
+ record("started", port=args.port)
+ server.serve_forever()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tools/v12_sustained_bandwidth_fixture.py b/tools/v12_sustained_bandwidth_fixture.py
new file mode 100644
index 00000000..e86eb197
--- /dev/null
+++ b/tools/v12_sustained_bandwidth_fixture.py
@@ -0,0 +1,251 @@
+"""Private Xtream-style V12 bandwidth fixture.
+
+The media files are supplied outside the repository. This server only exposes
+the controlled catalogue/media routes needed by the opt-in normal UI test,
+applies one aggregate delivery rate to every response, and records request
+bytes/timing so the measured delivery can be compared with player telemetry.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import re
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--hls-root", type=pathlib.Path, required=True)
+parser.add_argument("--progressive", type=pathlib.Path, required=True)
+parser.add_argument("--state-dir", type=pathlib.Path, required=True)
+parser.add_argument("--port", type=int, default=18786)
+args = parser.parse_args()
+
+HLS_ROOT = args.hls_root.resolve()
+PROGRESSIVE = args.progressive.resolve()
+STATE = args.state_dir.resolve()
+STATE.mkdir(parents=True, exist_ok=True)
+if not (HLS_ROOT / "long-master.m3u8").is_file():
+ parser.error("--hls-root must contain long-master.m3u8")
+if not PROGRESSIVE.is_file():
+ parser.error("--progressive file is missing")
+
+
+def extend_variant(name: str, copies: int = 480) -> None:
+ """Create a long finite VOD playlist by repeating real fixture segments."""
+ source = HLS_ROOT / name / "long.m3u8"
+ target = HLS_ROOT / name / "v12.m3u8"
+ lines = source.read_text(encoding="utf-8").splitlines()
+ segment_names = [line for line in lines if line.endswith(".ts")]
+ if not segment_names:
+ raise SystemExit(f"no segments in {source}")
+ header = [line for line in lines if not line.endswith(".ts") and line != "#EXT-X-ENDLIST"]
+ output = header[:]
+ for index in range(copies):
+ if index and index % len(segment_names) == 0:
+ output.append("#EXT-X-DISCONTINUITY")
+ output.extend(["#EXTINF:2.000000,", segment_names[index % len(segment_names)]])
+ output.append("#EXT-X-ENDLIST")
+ target.write_text("\n".join(output) + "\n", encoding="utf-8")
+
+
+for _variant in ("v0", "v1", "v2"):
+ extend_variant(_variant)
+(HLS_ROOT / "v12-master.m3u8").write_text(
+ "\n".join([
+ "#EXTM3U", "#EXT-X-VERSION:3", "#EXT-X-INDEPENDENT-SEGMENTS",
+ '#EXT-X-STREAM-INF:BANDWIDTH=15075344,AVERAGE-BANDWIDTH=14439089,RESOLUTION=3840x2160,CODECS="avc1.42c033"',
+ "v0/v12.m3u8",
+ '#EXT-X-STREAM-INF:BANDWIDTH=5441472,AVERAGE-BANDWIDTH=5177833,RESOLUTION=1920x1080,CODECS="avc1.42c028"',
+ "v1/v12.m3u8",
+ '#EXT-X-STREAM-INF:BANDWIDTH=2675616,AVERAGE-BANDWIDTH=2614515,RESOLUTION=1280x720,CODECS="avc1.42c01f"',
+ "v2/v12.m3u8", "",
+ ]), encoding="utf-8")
+
+MOVIES = {
+ 1201: ("V12 Adaptive Sustainable", "v12-master.m3u8", "m3u8"),
+ 1202: ("V12 Adaptive Unsustainable", "v12-master.m3u8", "m3u8"),
+ 1203: ("V12 Progressive Control", "progressive.mp4", "mp4"),
+}
+
+lock = threading.Lock()
+rate_bps = 120_000_000
+next_slot = 0.0
+sequence = 0
+events: list[dict[str, object]] = []
+
+
+def record(event: str, **data: object) -> None:
+ row = {"time": time.time(), "event": event, **data}
+ with lock:
+ events.append(row)
+ (STATE / "events.jsonl").open("a", encoding="utf-8").write(json.dumps(row) + "\n")
+
+
+def status() -> dict[str, object]:
+ with lock:
+ return {"rateBps": rate_bps, "nextSlot": next_slot, "eventCount": len(events)}
+
+
+def shape(byte_count: int) -> None:
+ global next_slot
+ with lock:
+ now = time.monotonic()
+ due = max(now, next_slot) + byte_count * 8 / max(1, rate_bps)
+ next_slot = due
+ delay = due - time.monotonic()
+ if delay > 0:
+ time.sleep(delay)
+
+
+def media_path(route: str) -> pathlib.Path | None:
+ if route == "/asset/progressive.mp4":
+ return PROGRESSIVE
+ movie_match = re.fullmatch(r"/movie/validation/validation/(1201|1202|1203)\.(?:m3u8|mp4)", route)
+ if movie_match:
+ stream_id = int(movie_match.group(1))
+ return HLS_ROOT / "v12-master.m3u8" if stream_id in (1201, 1202) else PROGRESSIVE
+ if route.startswith("/asset/"):
+ rel = pathlib.PurePosixPath(urllib.parse.unquote(route.removeprefix("/asset/")))
+ target = (HLS_ROOT / pathlib.Path(*rel.parts)).resolve()
+ if target.is_relative_to(HLS_ROOT) and target.is_file():
+ return target
+ return None
+
+
+class Handler(BaseHTTPRequestHandler):
+ protocol_version = "HTTP/1.1"
+
+ def log_message(self, *_args: object) -> None:
+ pass
+
+ def reply(self, body: bytes | dict[str, object], content_type: str = "application/json", status: int = 200) -> None:
+ payload = body if isinstance(body, bytes) else json.dumps(body).encode("utf-8")
+ self.send_response(status)
+ self.send_header("Content-Type", content_type)
+ self.send_header("Content-Length", str(len(payload)))
+ self.send_header("Cache-Control", "no-store")
+ self.end_headers()
+ try:
+ self.wfile.write(payload)
+ except (BrokenPipeError, ConnectionResetError):
+ pass
+
+ def do_GET(self) -> None:
+ global rate_bps, next_slot, sequence
+ parsed = urllib.parse.urlsplit(self.path)
+ query = urllib.parse.parse_qs(parsed.query)
+ route = parsed.path
+
+ if route == "/control":
+ if "rate" in query:
+ rate_bps = max(1, int(query["rate"][0]))
+ with lock:
+ next_slot = time.monotonic()
+ if query.get("reset", ["0"])[0] == "1":
+ with lock:
+ events.clear()
+ (STATE / "events.jsonl").write_text("", encoding="utf-8")
+ row = {"event": "control", "rateBps": rate_bps, "label": query.get("label", [""])[0]}
+ record(**row)
+ return self.reply({"rateBps": rate_bps})
+
+ if route == "/status":
+ return self.reply(status())
+ if route == "/events":
+ with lock:
+ snapshot = {
+ "events": list(events),
+ "status": {"rateBps": rate_bps, "nextSlot": next_slot, "eventCount": len(events)},
+ }
+ return self.reply(snapshot)
+
+ if route == "/player_api.php":
+ action = query.get("action", [""])[0]
+ if not action:
+ body = {"user_info": {"username": "validation", "password": "validation", "auth": 1,
+ "status": "Active", "max_connections": "5"},
+ "server_info": {"url": "10.0.2.2", "port": str(args.port),
+ "server_protocol": "http", "timezone": "UTC",
+ "timestamp_now": int(time.time())}}
+ elif action == "get_vod_categories":
+ body = [{"category_id": "1", "category_name": "V12 Bandwidth", "parent_id": 0}]
+ elif action == "get_vod_streams":
+ body = [self.movie(stream_id) for stream_id in MOVIES]
+ elif action == "get_vod_info":
+ stream_id = int(query.get("vod_id", ["0"])[0])
+ body = {"info": {"name": MOVIES[stream_id][0], "duration_secs": 384,
+ "duration": "00:06:24", "tmdb_id": 99999000 + stream_id},
+ "movie_data": self.movie(stream_id)}
+ else:
+ body = []
+ record("api", action=action)
+ return self.reply(body)
+
+ target = media_path(route)
+ if target is None:
+ return self.reply(b"not found", "text/plain", 404)
+ return self.stream(target, route)
+
+ @staticmethod
+ def movie(stream_id: int) -> dict[str, object]:
+ name, _asset, extension = MOVIES[stream_id]
+ direct = f"http://10.0.2.2:{args.port}/asset/{_asset}?expires={int(time.time()) + 7200}"
+ return {"stream_id": stream_id, "name": name, "category_id": "1", "container_extension": extension,
+ "rating": "8", "tmdb": str(99999000 + stream_id), "direct_source": direct}
+
+ def stream(self, target: pathlib.Path, route: str) -> None:
+ global sequence
+ size = target.stat().st_size
+ start, end, response_status = 0, size - 1, 200
+ range_value = self.headers.get("Range")
+ if range_value:
+ match = re.fullmatch(r"bytes=(\d+)-(\d*)", range_value)
+ if not match:
+ return self.reply(b"invalid range", "text/plain", 416)
+ start = int(match.group(1))
+ end = min(int(match.group(2)) if match.group(2) else end, end)
+ if start > end or start >= size:
+ return self.reply(b"invalid range", "text/plain", 416)
+ response_status = 206
+ content_type = "application/vnd.apple.mpegurl" if target.suffix == ".m3u8" else (
+ "video/mp4" if target.suffix == ".mp4" else "video/mp2t")
+ self.send_response(response_status)
+ self.send_header("Content-Type", content_type)
+ self.send_header("Content-Length", str(end - start + 1))
+ self.send_header("Accept-Ranges", "bytes")
+ self.send_header("Cache-Control", "no-store")
+ if response_status == 206:
+ self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+ self.end_headers()
+ began = time.monotonic()
+ sent = 0
+ try:
+ with target.open("rb") as stream:
+ stream.seek(start)
+ remaining = end - start + 1
+ while remaining:
+ block = stream.read(min(64 * 1024, remaining))
+ if not block:
+ break
+ shape(len(block))
+ self.wfile.write(block)
+ sent += len(block)
+ remaining -= len(block)
+ except (BrokenPipeError, ConnectionResetError, OSError):
+ pass
+ with lock:
+ sequence += 1
+ request_id = sequence
+ elapsed = max(0.001, time.monotonic() - began)
+ record("media", id=request_id, path=route, status=response_status, range=range_value,
+ bytes=sent, elapsedMs=round(elapsed * 1000, 1), measuredBps=round(sent * 8 / elapsed))
+
+
+if __name__ == "__main__":
+ record("started", port=args.port, hlsRoot=str(HLS_ROOT), progressive=str(PROGRESSIVE))
+ ThreadingHTTPServer(("0.0.0.0", args.port), Handler).serve_forever()
diff --git a/tools/v4_adaptive_fallback_fixture.py b/tools/v4_adaptive_fallback_fixture.py
new file mode 100644
index 00000000..04859d6b
--- /dev/null
+++ b/tools/v4_adaptive_fallback_fixture.py
@@ -0,0 +1,108 @@
+"""Opt-in local V4 fixture; private aligned media and generated DRM assets stay outside Git.
+
+Run on the emulator host with --hls-root and --state-dir; the normal UI driver
+uses port 18784. Credentials and license keys below belong only to this fixture.
+"""
+import argparse,http.server,json,pathlib,urllib.parse,time,threading
+parser=argparse.ArgumentParser(description=__doc__)
+parser.add_argument('--hls-root', type=pathlib.Path, required=True)
+parser.add_argument('--state-dir', type=pathlib.Path, required=True)
+args=parser.parse_args()
+ROOT=args.state_dir.resolve()
+ROOT.mkdir(parents=True,exist_ok=True)
+MEDIA=args.hls_root.resolve()
+# This fixture uses the existing aligned ladder; reject another layout before
+# serving a master that might silently remove the wrong representation.
+master_lines=(MEDIA/'master.m3u8').read_text().splitlines()
+if not (len(master_lines)==9 and master_lines[:3]==['#EXTM3U','#EXT-X-VERSION:3','#EXT-X-INDEPENDENT-SEGMENTS']
+ and master_lines[4::2]==['high/index.m3u8','hd/index.m3u8','sd/index.m3u8']
+ and all(master_lines[i].startswith('#EXT-X-STREAM-INF:') for i in (3,5,7))):
+ parser.error('Expected the aligned high/hd/sd fixture master layout')
+adaptive_master=('\n'.join(master_lines[:3]+master_lines[5:])+'\n').encode()
+lock=threading.Lock(); failed=None; code=503; license_mode='invalid'
+MOVIES={701:('V4 Adaptive UI Fixture','master.m3u8'),702:('V4 Direct 4K UI Fixture','high/index.m3u8'),703:('V4 Same 1080 UI Fixture','hd/index.m3u8')}
+def log(**data):
+ with lock:
+ with (ROOT/'server-events.jsonl').open('a') as f:f.write(json.dumps({'time':time.time(),**data})+'\n')
+def movie(i):
+ return {'stream_id':i,'name':MOVIES[i][0],'category_id':'1','container_extension':'m3u8','rating':'8','tmdb':str(99999700+i),'direct_source':f'http://10.0.2.2:18784/asset/{MOVIES[i][1]}?expires={int(time.time())+7200}'}
+class Handler(http.server.BaseHTTPRequestHandler):
+ protocol_version='HTTP/1.1'
+ def log_message(self,*args):pass
+ def reply(self,data,kind='application/json',status=200):
+ raw=data if isinstance(data,bytes) else json.dumps(data).encode()
+ self.send_response(status);self.send_header('Content-Type',kind);self.send_header('Content-Length',str(len(raw)));self.send_header('Cache-Control','no-store');self.end_headers()
+ try:self.wfile.write(raw)
+ except (BrokenPipeError,ConnectionResetError,ConnectionAbortedError):pass
+ def do_GET(self):
+ global failed,code,license_mode
+ p=urllib.parse.urlparse(self.path);q=urllib.parse.parse_qs(p.query)
+ if p.path=='/control':
+ failed=q.get('fail',[None])[0];code=int(q.get('code',['503'])[0]);license_mode=q.get('license',['invalid'])[0];log(event='control',failed=failed,code=code,licenseMode=license_mode)
+ return self.reply({'failed':failed,'code':code})
+ if p.path=='/drm-playlist.m3u':return self.reply((ROOT/'drm-playlist.m3u').read_bytes(),'audio/x-mpegurl')
+ if p.path.startswith('/movie/'):
+ name=p.path.removeprefix('/movie/')
+ if name not in ('drm.mpd','protected720.mp4','clear1080.mp4'):return self.reply(b'',status=404)
+ path=ROOT/name
+ raw=path.read_bytes();size=len(raw);start=0;end=size-1
+ value=self.headers.get('Range')
+ if value:
+ import re
+ match=re.fullmatch(r'bytes=(\d+)-(\d*)',value)
+ if not match:return self.reply(b'',status=416)
+ start=int(match[1]);end=min(int(match[2]) if match[2] else end,end)
+ if start>end:return self.reply(b'',status=416)
+ raw=raw[start:end+1]
+ log(event='drm-media',path=name,range=value,bytes=len(raw))
+ if not value:return self.reply(raw,'application/dash+xml' if name.endswith('.mpd') else 'video/mp4')
+ self.send_response(206);self.send_header('Content-Type','video/mp4');self.send_header('Content-Length',str(len(raw)))
+ self.send_header('Content-Range',f'bytes {start}-{end}/{size}');self.end_headers()
+ try:self.wfile.write(raw)
+ except (BrokenPipeError,ConnectionResetError,ConnectionAbortedError):pass
+ return
+ if p.path=='/player_api.php':
+ action=q.get('action',[''])[0]
+ if not action:data={'user_info':{'username':'validation','password':'validation','auth':1,'status':'Active','max_connections':'5'},'server_info':{'url':'10.0.2.2','port':'18784','server_protocol':'http','timezone':'UTC','timestamp_now':int(time.time())}}
+ elif action=='get_vod_categories':data=[{'category_id':'1','category_name':'V4 UI Validation','parent_id':0}]
+ elif action=='get_vod_streams':data=[movie(i) for i in MOVIES]
+ elif action=='get_vod_info':
+ i=int(q['vod_id'][0]);data={'info':{'name':MOVIES[i][0],'duration_secs':300,'duration':'00:05:00','tmdb_id':99999700+i},'movie_data':movie(i)}
+ else:data=[]
+ log(event='api',action=action);return self.reply(data)
+ if not p.path.startswith('/asset/'):return self.reply(b'',status=404)
+ rel=p.path.removeprefix('/asset/')
+ path=(MEDIA/rel).resolve()
+ if not path.is_relative_to(MEDIA.resolve()) or not path.is_file():return self.reply(b'',status=404)
+ if rel.startswith(str(failed)+'/') and path.suffix=='.ts':
+ log(event='failure',path=rel,status=code);return self.reply(b'Controlled rendition failure',status=code)
+ raw=path.read_bytes()
+ if rel=='master.m3u8':
+ raw=adaptive_master
+ status=200;size=len(raw);start=0;end=size-1
+ value=self.headers.get('Range')
+ if value:
+ import re
+ m=re.fullmatch(r'bytes=(\d+)-(\d*)',value)
+ if not m:return self.reply(b'',status=416)
+ start=int(m[1]);end=min(int(m[2]) if m[2] else end,end)
+ if start>end:return self.reply(b'',status=416)
+ raw=raw[start:end+1];status=206
+ log(event='request',path=rel,status=status,bytes=len(raw))
+ if status==200:return self.reply(raw,'application/vnd.apple.mpegurl' if path.suffix=='.m3u8' else 'video/mp2t')
+ self.send_response(status);self.send_header('Content-Type','video/mp2t');self.send_header('Content-Length',str(len(raw)));self.send_header('Content-Range',f'bytes {start}-{end}/{size}');self.end_headers()
+ try:self.wfile.write(raw)
+ except (BrokenPipeError,ConnectionResetError,ConnectionAbortedError):pass
+ def do_POST(self):
+ if self.path!='/license':return self.reply(b'',status=404)
+ raw=self.rfile.read(int(self.headers.get('Content-Length','0')))
+ log(event='license',mode=license_mode,requestBytes=len(raw))
+ if license_mode in ('invalid','malformed'):
+ return self.reply(b'not-json','application/json')
+ if license_mode=='valid':
+ import base64
+ enc=lambda x:base64.urlsafe_b64encode(bytes.fromhex(x)).decode().rstrip('=')
+ body={'keys':[{'kty':'oct','kid':enc('11223344556677889900aabbccddeeff'),'k':enc('00112233445566778899aabbccddeeff')}],'type':'temporary'}
+ else:body={'keys':[],'type':'temporary'}
+ return self.reply(body)
+http.server.ThreadingHTTPServer(('127.0.0.1',18784),Handler).serve_forever()
diff --git a/tools/v5_dynamic_live_fixture_server.py b/tools/v5_dynamic_live_fixture_server.py
new file mode 100644
index 00000000..4f416d13
--- /dev/null
+++ b/tools/v5_dynamic_live_fixture_server.py
@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""Controlled dynamic HLS live-window fixture for V5 playback validation.
+
+The fixture deliberately serves a non-ENDLIST sliding playlist from existing
+two-second H.264/AAC transport-stream segments. ``jump=1`` advances the
+playlist media sequence beyond the old window without returning a transport
+error; this is the controlled behind-live-window stimulus. ``reset=1``
+starts a new run. The private segment directory is supplied at runtime and
+is never copied into the repository.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+
+SEGMENT_SECONDS = 2.0
+WINDOW_SIZE = 6
+JUMP_SEGMENTS = 40
+MEDIA_ASSET_COUNT = 300
+# Keep media sequence numbers advancing beyond the private asset set. The
+# fixture reuses those finite segments modulo their count so a two-minute,
+# two-channel validation never presents a stuck playlist at an artificial cap.
+MAX_SEQUENCE = 10_000
+CHANNELS = {
+ "1001": "V5 Dynamic Live Alpha",
+ "1002": "V5 Dynamic Live Beta",
+}
+
+lock = threading.Lock()
+events: list[dict] = []
+origins: dict[str, float] = {}
+wall_origins: dict[str, float] = {}
+jump_offsets: dict[str, int] = {key: 0 for key in CHANNELS}
+sequence = 0
+
+
+def record(event: str, **values: object) -> None:
+ row = {"time": time.time(), "event": event, **values}
+ with lock:
+ events.append(row)
+
+
+def json_reply(handler: BaseHTTPRequestHandler, body: object, status: int = 200) -> None:
+ payload = json.dumps(body).encode("utf-8")
+ handler.send_response(status)
+ handler.send_header("Content-Type", "application/json")
+ handler.send_header("Content-Length", str(len(payload)))
+ handler.send_header("Cache-Control", "no-store")
+ handler.end_headers()
+ try:
+ handler.wfile.write(payload)
+ except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+ pass
+
+
+def text_reply(handler: BaseHTTPRequestHandler, body: str, content_type: str) -> None:
+ payload = body.encode("utf-8")
+ handler.send_response(200)
+ handler.send_header("Content-Type", content_type)
+ handler.send_header("Content-Length", str(len(payload)))
+ handler.send_header("Cache-Control", "no-store")
+ handler.end_headers()
+ try:
+ handler.wfile.write(payload)
+ except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+ pass
+
+
+def current_sequence(channel: str) -> int:
+ with lock:
+ # Start with a complete six-segment live window; the server has no
+ # future media and therefore never advertises segments ahead of wall
+ # clock time.
+ origin = origins.setdefault(channel, time.monotonic() - SEGMENT_SECONDS * WINDOW_SIZE)
+ wall_origins.setdefault(channel, time.time() - SEGMENT_SECONDS * WINDOW_SIZE)
+ offset = jump_offsets[channel]
+ return max(0, int((time.monotonic() - origin) / SEGMENT_SECONDS) + offset)
+
+
+def manifest(channel: str, host: str, port: int) -> str:
+ end = min(MAX_SEQUENCE - 1, current_sequence(channel))
+ start = max(0, end - WINDOW_SIZE + 1)
+ with lock:
+ wall_origin = wall_origins[channel]
+ rows = [
+ "#EXTM3U",
+ "#EXT-X-VERSION:3",
+ "#EXT-X-TARGETDURATION:2",
+ f"#EXT-X-MEDIA-SEQUENCE:{start}",
+ ]
+ for number in range(start, end + 1):
+ program_date_time = time.strftime(
+ "%Y-%m-%dT%H:%M:%S",
+ time.gmtime(wall_origin + number * SEGMENT_SECONDS),
+ ) + ".%03dZ" % int((wall_origin + number * SEGMENT_SECONDS) % 1 * 1000)
+ rows.extend((
+ f"#EXT-X-PROGRAM-DATE-TIME:{program_date_time}",
+ "#EXTINF:2.000000,",
+ f"http://{host}:{port}/asset/{channel}/{number:03d}.ts",
+ ))
+ return "\n".join(rows) + "\n"
+
+
+class Handler(BaseHTTPRequestHandler):
+ protocol_version = "HTTP/1.1"
+
+ def log_message(self, *_args: object) -> None:
+ pass
+
+ def do_GET(self) -> None: # noqa: N802 - stdlib handler API
+ global sequence
+ parsed = urllib.parse.urlsplit(self.path)
+ query = urllib.parse.parse_qs(parsed.query)
+
+ if parsed.path == "/health":
+ return json_reply(self, {"ok": True, "port": self.server.server_port})
+
+ if parsed.path == "/control":
+ jump_event: tuple[str, int] | None = None
+ with lock:
+ if query.get("reset", ["0"])[0] == "1":
+ events.clear()
+ origins.clear()
+ wall_origins.clear()
+ jump_offsets.update({key: 0 for key in CHANNELS})
+ selected = query.get("channel", list(CHANNELS))[0]
+ if query.get("jump", ["0"])[0] == "1":
+ if selected not in CHANNELS:
+ selected = list(CHANNELS)[0]
+ jump_offsets[selected] += JUMP_SEGMENTS
+ origin = origins.setdefault(selected, time.monotonic() - SEGMENT_SECONDS * WINDOW_SIZE)
+ jump_event = (selected, max(0, int((time.monotonic() - origin) / SEGMENT_SECONDS) + jump_offsets[selected]))
+ wall_origins[selected] = time.time() - jump_event[1] * SEGMENT_SECONDS
+ state = {"origins": dict(origins), "jumpOffsets": dict(jump_offsets)}
+ if jump_event is not None:
+ record("window-jump", channel=jump_event[0], jumpSegments=JUMP_SEGMENTS,
+ sequence=jump_event[1])
+ return json_reply(self, state)
+
+ if parsed.path == "/events":
+ with lock:
+ return json_reply(self, {"events": list(events), "origins": dict(origins),
+ "jumpOffsets": dict(jump_offsets)})
+
+ if parsed.path == "/player_api.php":
+ action = query.get("action", [""])[0]
+ if not action:
+ body = {
+ "user_info": {"username": "v5-fixture", "password": "v5-fixture", "auth": 1,
+ "status": "Active", "max_connections": "5",
+ "allowed_output_formats": ["m3u8"]},
+ "server_info": {"url": "10.0.2.2", "port": str(self.server.server_port),
+ "server_protocol": "http", "timezone": "UTC",
+ "timestamp_now": int(time.time())},
+ }
+ elif action == "get_live_categories":
+ body = [{"category_id": "501", "category_name": "V5 Dynamic Live", "parent_id": 0}]
+ elif action == "get_live_streams":
+ body = [{"stream_id": int(channel), "name": name, "category_id": "501",
+ "epg_channel_id": f"V5_{channel}", "tv_archive": 0,
+ "container_extension": "m3u8",
+ "direct_source": f"http://10.0.2.2:{self.server.server_port}/live/v5/v5/{channel}.m3u8"}
+ for channel, name in CHANNELS.items()]
+ elif action in ("get_short_epg", "get_simple_data_table"):
+ body = {"epg_listings": []}
+ else:
+ body = []
+ record("api", action=action or "account")
+ return json_reply(self, body)
+
+ parts = [urllib.parse.unquote(part) for part in parsed.path.split("/") if part]
+ # Xtream URL normalization may rebuild the direct source as
+ # /live/{username}/{password}/{stream_id}.m3u8, so accept the
+ # credential path while identifying the channel only by its id.
+ if len(parts) >= 2 and parts[0] == "live" and parts[-1].endswith(".m3u8"):
+ channel = parts[-1].removesuffix(".m3u8")
+ if channel not in CHANNELS:
+ return json_reply(self, {"error": "unknown channel"}, status=404)
+ record("manifest", channel=channel, sequence=current_sequence(channel))
+ return text_reply(self, manifest(channel, "10.0.2.2", self.server.server_port),
+ "application/vnd.apple.mpegurl")
+
+ if len(parts) == 3 and parts[0] == "asset" and parts[1] in CHANNELS:
+ channel, name = parts[1], parts[2]
+ if not name.endswith(".ts"):
+ return json_reply(self, {"error": "not found"}, status=404)
+ try:
+ number = int(name[:-3])
+ except ValueError:
+ return json_reply(self, {"error": "not found"}, status=404)
+ asset_number = number % MEDIA_ASSET_COUNT
+ target = self.server.segment_root / f"segment_{asset_number:03d}.ts"
+ if number < 0 or number >= MAX_SEQUENCE or not target.is_file():
+ record("segment-missing", channel=channel, sequence=number)
+ return json_reply(self, {"error": "not found"}, status=404)
+ with lock:
+ sequence += 1
+ request_id = sequence
+ record("segment", id=request_id, channel=channel, sequence=number)
+ payload = target.read_bytes()
+ self.send_response(200)
+ self.send_header("Content-Type", "video/mp2t")
+ self.send_header("Content-Length", str(len(payload)))
+ self.send_header("Cache-Control", "no-store")
+ self.end_headers()
+ try:
+ self.wfile.write(payload)
+ except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+ pass
+ return
+
+ return json_reply(self, {"error": "not found"}, status=404)
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--port", type=int, default=18785)
+ parser.add_argument("--segment-root", required=True, type=pathlib.Path)
+ args = parser.parse_args()
+ if not all((args.segment_root / f"segment_{number:03d}.ts").is_file() for number in range(MEDIA_ASSET_COUNT)):
+ raise SystemExit(f"expected {MEDIA_ASSET_COUNT} two-second segments in {args.segment_root}")
+ server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
+ server.segment_root = args.segment_root.resolve()
+ print(f"V5 dynamic-live fixture listening on 0.0.0.0:{args.port}", flush=True)
+ server.serve_forever()
+
+
+if __name__ == "__main__":
+ main()