StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
feat: improve playback resilience and provider compatibility
David Nashasha313c6a0bbb1
diff --git a/.gitignore b/.gitignoreindex c2b98ee0..a7f83127 100644--- a/.gitignore+++ b/.gitignore@@ -44,6 +44,7 @@ domain/bin/.pi/.kotlin/hs_err_pid*.log+replay_pid*.loggradle_build.logksp.log__pycache__/diff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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)SELECTstage.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,+ 0FROM movie_import_stage AS stageWHERE stage.session_id = :sessionIdAND stage.provider_id = :providerIddiff --git a/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.kt b/data/src/main/java/com/streamvault/data/provider/LegacyProviderSnapshotMapper.ktindex 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.ktindex 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 != nullval resolvedUrl = when {+ kind == XtreamStreamKind.LIVE && XtreamUrlFactory.isGeneratedCatchUpUrl(+ request.sourceUrl, config.serverUrl, config.username, config.password, streamId+ ) -> request.sourceUrlrequest.preferStableUrl -> stableUrldirectSource != null -> directSourcesourceIsInternal -> stableUrldiff --git a/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.kt b/data/src/main/java/com/streamvault/data/provider/ProviderConfigRevisionCodec.ktindex 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.ktindex 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)?.preferredLiveStreamFormatreturn 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.ktindex 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.ktindex 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.StalkerRequestDescriptorimport com.streamvault.data.remote.stalker.StalkerResponseMetricsimport com.streamvault.data.remote.stalker.StalkerTrafficCoordinatorimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolver+import com.streamvault.data.security.CredentialDecryptionExceptionimport com.streamvault.data.sync.ContentCachePolicyimport com.streamvault.data.sync.CatalogHydrationCommandsimport com.streamvault.data.util.MoviePresentationSettingsimport com.streamvault.data.util.buildPresentedMovies+import com.streamvault.data.util.movieLogicalGroupIdimport com.streamvault.data.util.rankSearchResultsimport com.streamvault.data.util.toFtsPrefixQueryimport 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) returnrepositoryScope.launch {- val provider = loadCompatibilityProvider(providerId) ?: return@launch+ val provider = loadBackgroundCompatibilityProvider(providerId) ?: return@launchval current = movieCategoryHydrationDao.get(providerId, categoryId)if (current?.isComplete == true) return@launchif (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@launchtry {- val provider = loadCompatibilityProvider(providerId) ?: return@launch+ val provider = loadBackgroundCompatibilityProvider(providerId) ?: return@launchif (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.ktindex 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.PARTIALdiff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.ktindex 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.ContentCachePolicyimport com.streamvault.data.sync.CatalogHydrationCommandsimport com.streamvault.data.util.SeriesPresentationSettingsimport com.streamvault.data.util.buildPresentedSeries+import com.streamvault.data.util.seriesLogicalGroupIdimport com.streamvault.domain.model.*import com.streamvault.domain.model.LegacyProvider as Providerimport 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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.StalkerPortalLearningimport com.streamvault.domain.model.XtreamConfigimport com.streamvault.domain.provider.CapabilityResolutionimport 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.XtreamStreamKindimport org.junit.Testimport kotlinx.coroutines.test.runTestimport 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")+ }+ }+@Testfun `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.ktindex 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 {@Testfun `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.ktnew file mode 100644index 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.ktindex 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.PlaybackHistoryLiteEntityimport com.streamvault.data.local.entity.ProviderEntityimport com.streamvault.data.local.entity.XtreamIndexJobEntityimport com.streamvault.data.mapper.toEntity+import com.streamvault.data.mapper.toDomainimport com.streamvault.data.provider.ProviderCapabilityResolverimport com.streamvault.data.provider.TypedProviderClientFactoryimport com.streamvault.data.provider.toProviderSnapshotimport com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.util.movieLogicalGroupIdimport com.streamvault.data.remote.stalker.StalkerDeviceProfileimport com.streamvault.data.remote.stalker.StalkerProviderProfileimport com.streamvault.data.remote.stalker.StalkerProvider@@ -39,6 +41,7 @@ import com.streamvault.data.remote.stalker.StalkerApiServiceimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport com.streamvault.data.security.CredentialCrypto+import com.streamvault.data.security.CredentialDecryptionExceptionimport com.streamvault.data.sync.SyncManagerimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.LibraryBrowseQuery@@ -80,6 +83,8 @@ import org.mockito.kotlin.neverimport org.mockito.kotlin.timesimport org.mockito.kotlin.verifyimport org.mockito.kotlin.whenever+import java.util.concurrent.CountDownLatch+import java.util.concurrent.TimeUnitclass 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)+ }+ }+@Testfun `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.ktindex 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.repositoryimport android.content.Contextimport com.google.gson.Gson+import com.google.gson.JsonParserimport com.google.common.truth.Truth.assertThatimport com.streamvault.data.local.DatabaseTransactionRunnerimport com.streamvault.data.local.dao.CategoryDao@@ -65,9 +66,11 @@ import com.streamvault.domain.model.StalkerTransportModeimport com.streamvault.domain.model.StalkerTransportOriginimport com.streamvault.domain.model.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.GuideSourcePolicy+import com.streamvault.domain.model.LiveStreamFormatModeimport com.streamvault.domain.model.XtreamConfigimport com.streamvault.domain.model.SyncMetadataimport com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.repository.ProviderSetupRequestimport kotlinx.coroutines.runBlockingimport kotlinx.coroutines.flow.flowOfimport 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)+ }+@Testfun `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.ktindex 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.ktindex 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.Testclass 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)+ }+ }+@Testfun `force latest prefers newest version over older higher quality`() {val older4k = movie(diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 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]### Addeddiff --git a/domain/src/main/java/com/streamvault/domain/model/Provider.kt b/domain/src/main/java/com/streamvault/domain/model/Provider.ktindex 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.ktindex 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_CODESdiff --git a/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/MovieRepository.ktindex 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 = falsesuspend 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.ktindex 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.Resultimport com.streamvault.domain.model.Seriesimport com.streamvault.domain.model.SeriesDetailPresentationHintimport com.streamvault.domain.model.StreamInfo+import com.streamvault.domain.model.VodSeriesVariantimport com.streamvault.domain.model.VodCategoryHydrationimport com.streamvault.domain.model.VodCategoryHydrationRequestimport 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 = truesuspend 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.ktindex 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.usecaseimport com.streamvault.domain.manager.ProviderSetupInputValidatorimport com.streamvault.domain.model.ChannelLogoSourcePolicyimport com.streamvault.domain.model.GuideSourcePolicy+import com.streamvault.domain.model.LiveStreamFormatModeimport com.streamvault.domain.model.LegacyProvider as Providerimport com.streamvault.domain.model.ProviderEpgSyncModeimport 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.ktindex 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.ValidatedXtreamProviderInputimport com.streamvault.domain.model.ChannelLogoSourcePolicyimport com.streamvault.domain.model.GuideSourcePolicyimport com.streamvault.domain.model.JellyfinConfig+import com.streamvault.domain.model.LiveStreamFormatModeimport com.streamvault.domain.model.M3uConfigimport com.streamvault.domain.model.ProviderEpgSyncModeimport 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? = nullvar lastM3uCall: M3uCall? = nullvar lastStalkerCall: StalkerCall? = nullvar 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.ktnew file mode 100644index 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.ktindex 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.Seriesimport com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.model.StreamTypeimport com.streamvault.domain.model.VodMovieVariant+import com.streamvault.domain.model.VodSeriesVariantimport com.streamvault.domain.provider.PlayerCredentialFailureimport com.streamvault.domain.provider.PlayerPlaybackResolutionFailureimport 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.playerimport androidx.lifecycle.viewModelScopeimport com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.StreamInfoimport com.streamvault.player.PlaybackStateimport com.streamvault.player.PlayerEngine-import kotlinx.coroutines.delayimport kotlinx.coroutines.Job+import kotlinx.coroutines.delay+import kotlinx.coroutines.flow.firstimport kotlinx.coroutines.launchprivate 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 } ?: returnval requestVersion = prepareRequestVersion+ val episodeToken = episodeSourceState.tokentokenRenewalJob = 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 = nullplayerThumbnailCoordinator.clearCache()val activeEngine = playerEnginediff --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.ktindex 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.playerimport com.streamvault.domain.model.Movie+import com.streamvault.domain.model.StreamTypeimport 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.Normalizerimport 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 falseif (currentProviderId <= 0L || currentContentId <= 0L) return falseif (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 falseval 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 falseval 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 falseval 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 = currentArtworkUrlplayerRecoveryCoordinator.retriedWithAvcMovieVariant = truecurrentContentId = fallbackMovie.idcurrentStreamUrl = 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 falseplayerEngine.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.ktindex 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.ktindex 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_MSimport com.streamvault.player.AUDIO_VIDEO_OFFSET_MIN_MSimport com.streamvault.player.PlaybackStateimport com.streamvault.player.PlayerError-import kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.delay-import kotlinx.coroutines.ensureActiveimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.updateimport kotlinx.coroutines.launchimport 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 != inFlightPreloadKeyfun 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.ktindex 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): PlaybackProbeFailurelse -> 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: Stringdiff --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.ktindex 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 = wheinternal 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.ktindex 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 nullval items = mutableListOf<PlayerPreloadItem>()+ val currentKey = physicalCurrent?.let(::physicalEpisodePreloadKey) ?: episodePreloadKey(providerId, currentEpisode)neighbors.forEach { episode ->if (!isCurrent()) return nullval 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 nullreturn 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.ktindex 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.ktindex 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 DomainResultimport com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.settings.VodTrackPreferencesimport com.streamvault.player.PlayerEngine+import com.streamvault.player.playback.ResolvedStreamType+import com.streamvault.player.playback.StreamTypeResolver+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.player.playback.applyPlaybackTransportPolicyimport com.streamvault.player.playback.applyUnsafeTlsBypassimport 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.ktindex 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.Logimport com.streamvault.domain.model.Channelimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.DecoderMode+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.StreamInfoimport com.streamvault.player.PlayerEngineimport com.streamvault.player.PlayerError+import com.streamvault.player.playback.ResolvedStreamType+import com.streamvault.player.playback.StreamTypeResolverimport kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.Jobimport kotlinx.coroutines.delay@@ -42,6 +45,9 @@ internal interface PlayerRecoveryExecutionPort {): Booleanfun tryNextCatchUpVariant(): Booleansuspend fun tryFallbackToAvcMovieVariant(requestVersion: Long, playbackUrl: String): Boolean+ suspend fun tryFallbackToAvcEpisodeVariant(requestVersion: Long, playbackUrl: String): EpisodeFallbackResult =+ EpisodeFallbackResult.NotEligible+ fun handleEpisodeReplacementError(error: PlayerError): Boolean = falsesuspend 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 nullif (error is PlayerError.DecoderError && !port.recoveryState.retriedWithSoftwareDecoder) {if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return nullif (request.contentType == ContentType.LIVE) {- val currentLiveHlsSession = request.resolvedStreamInfo?.streamType == com.streamvault.domain.model.StreamType.HLS+ val currentLiveHlsSession = request.isLiveHlsSession()if (currentLiveHlsSession) {val channel = request.channelif (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.ktindex 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: PlayerEngineget() = 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.ktindex 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.ktindex 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.ktindex 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_000Lprivate 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_000Lprivate const val LOW_BANDWIDTH_THRESHOLD_BPS = 500_000Lprivate const val LOW_BANDWIDTH_DURATION_SECONDS = 30internal 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? = nullinternal var lastRecordedVodVariantObservationSignature: String? = nullinternal 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: Longget() = playbackSessionCoordinator.currentId@@ -377,12 +387,9 @@ class PlayerViewModel @Inject constructor(internal var lastVisitedCategoryJob: Job? = nullinternal var controlsHideJob: Job? = nullinternal var seekPreviewJob: Job? = null- internal var thumbnailPreloadJob: Job? = nullprivate var preloadWindowJob: Job? = nullprivate var preloadWindowInFlightFingerprint: String? = nullprivate var acceptedPreloadWindowFingerprint: String? = null- internal var inFlightThumbnailPreloadKey: String? = null- internal var lastCompletedThumbnailPreloadKey: String? = nullprivate var lowBandwidthMonitorJob: Job? = nullinternal var progressTrackingJob: Job? = nullinternal 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 &¤tContentType.isSkippableChapterContent()@@ -955,12 +964,12 @@ class PlayerViewModel @Inject constructor(internal fun beginPlaybackSession(): Long {val sessionId = playbackSessionCoordinator.begin().id+ episodeSourceState.reset(sessionId)lastTriggeredCreditsChapterStartMs = nullcreditsAutoPlayTriggeredForSession = false_skipChapter.value = nullplayerRecoveryCoordinator.beginSession(sessionId)playerRecoveryExecutionCoordinator.cancel()- thumbnailPreloadJob?.cancel()preloadWindowJob?.cancel()preloadWindowJob = nullpreloadWindowInFlightFingerprint = 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 nullval episode = currentEpisode.value ?: return nullval 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.tokenpreloadWindowInFlightFingerprint = fingerprintpreloadWindowJob = 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.tokenreturn when (val result = playerContentResolver.getSeriesDetails(providerId, seriesId)) {is Result.Success -> {- if (!isActivePlaybackSession(requestVersion)) return null+ if (!isActivePlaybackSession(requestVersion) || !episodeSourceState.isCurrent(episodeToken)) return nullval 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 falseif (preparationResult is PlayerPreparationCoordinator.Result.Failure) {- if (!isActivePlaybackSession(requestVersion)) return false+ if (!isCurrent()) return falsesetLastFailureReason(preparationResult.message)if (showFailureNotice) {showPlayerNotice(@@ -1283,7 +1318,7 @@ class PlayerViewModel @Inject constructor(val success = preparationResult as PlayerPreparationCoordinator.Result.Successsuccess.probeCacheKey?.let(probePassedPlaybackKeys::add)- if (!isActivePlaybackSession(requestVersion)) return false+ if (!isCurrent()) return falsecurrentResolvedPlaybackUrl = success.streamInfo.urlcurrentResolvedStreamInfo = success.streamInforeadySideEffectsRequestVersion = 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.ktindex 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.Channelimport com.streamvault.domain.model.ChannelNumberingModeimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackHistory-import com.streamvault.domain.model.ProviderTypeimport kotlinx.coroutines.currentCoroutineContextimport kotlinx.coroutines.delayimport 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.ktindex 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.MediaMetadataRetrieverimport android.net.Uriimport android.util.LruCacheimport dagger.hilt.android.qualifiers.ApplicationContext+import java.util.concurrent.atomic.AtomicBoolean+import java.util.concurrent.atomic.AtomicReferenceimport javax.inject.Injectimport javax.inject.Singletonimport kotlinx.coroutines.Dispatchers-import kotlinx.coroutines.withContext+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.suspendCancellableCoroutineimport kotlinx.coroutines.withTimeoutOrNull+import okhttp3.OkHttpClient+import kotlin.coroutines.resume+import kotlin.coroutines.resumeWithExceptionimport kotlin.math.roundToInt@Singletonclass 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.retrieverwhen (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.ktindex 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktdeleted file mode 100644index 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.ktindex 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.ktindex 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.")+ }+@Testfun `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.ktindex 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.ktindex 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.ProviderRepositoryimport com.streamvault.domain.settings.PlayerPreferencesimport com.streamvault.feature.playback.api.PlaybackStreamPreparerimport com.streamvault.player.PlayerEngine+import com.streamvault.player.playback.ResolvedStreamTypeimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport 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.ktindex 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.assertThatimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.DecoderModeimport com.streamvault.domain.model.Result+import com.streamvault.domain.model.Channel+import com.streamvault.domain.model.StreamInfo+import com.streamvault.domain.model.StreamTypeimport com.streamvault.player.PlayerEngineimport com.streamvault.player.PlayerErrorimport kotlinx.coroutines.test.advanceUntilIdleimport kotlinx.coroutines.test.runTestimport org.junit.Testimport org.mockito.kotlin.mock+import org.mockito.kotlin.neverimport org.mockito.kotlin.verifyclass 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? = nullval 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) = Unitdiff --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.ktindex 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())}@Testdiff --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.ktnew file mode 100644index 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.ktindex 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.playerimport com.google.common.truth.Truth.assertThat-import com.streamvault.domain.model.ProviderTypeimport org.junit.Testclass 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.ktindex 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.ActivityManagerimport android.content.Contextimport android.os.Buildimport android.os.Handler+import android.os.SystemClockimport android.util.Logimport androidx.annotation.MainThreadimport androidx.annotation.OptIn@@ -18,8 +19,6 @@ import androidx.media3.common.Timelineimport androidx.media3.common.Tracksimport androidx.media3.common.util.UnstableApiimport androidx.media3.exoplayer.DecoderReuseEvaluation-import androidx.media3.exoplayer.DefaultLivePlaybackSpeedControl-import androidx.media3.exoplayer.DefaultLoadControlimport androidx.media3.exoplayer.DefaultRenderersFactoryimport androidx.media3.exoplayer.ExoPlayerimport androidx.media3.exoplayer.Renderer@@ -27,6 +26,9 @@ import androidx.media3.exoplayer.ScrubbingModeParametersimport androidx.media3.exoplayer.analytics.AnalyticsListenerimport androidx.media3.exoplayer.audio.AudioSinkimport androidx.media3.exoplayer.audio.AudioRendererEventListener+import androidx.media3.exoplayer.audio.AudioTrackAudioOutputProvider+import androidx.media3.exoplayer.audio.DefaultAudioSink+import androidx.media3.exoplayer.audio.DefaultAudioTrackBufferSizeProviderimport androidx.media3.exoplayer.mediacodec.MediaCodecInfoimport androidx.media3.exoplayer.mediacodec.MediaCodecSelectorimport androidx.media3.exoplayer.video.MediaCodecVideoRenderer@@ -47,21 +49,25 @@ import com.streamvault.domain.model.VideoFormatimport com.streamvault.domain.repository.PlaybackCompatibilityRepositoryimport com.streamvault.player.audio.PlayerAudioFocusControllerimport com.streamvault.player.playback.ActiveDecoderPolicy+import com.streamvault.player.playback.AdaptiveDecodePressurePolicy+import com.streamvault.player.playback.DecodePressureSampleimport com.streamvault.player.playback.DefaultDecoderPreferencePolicyimport com.streamvault.player.playback.DefaultPlaybackCompatibilityProfileimport com.streamvault.player.playback.AudioVideoOffsetAudioSinkimport com.streamvault.player.playback.LiveAudioTapAudioSink+import com.streamvault.player.playback.createLivePlaybackSpeedControlimport com.streamvault.player.playback.PlaybackCodecSelectorimport com.streamvault.player.playback.PlaybackCompatibilityProfileimport com.streamvault.player.playback.PlaybackBufferPoliciesimport com.streamvault.player.playback.PlaybackBufferPolicy+import com.streamvault.player.playback.PlaybackLoadControl+import com.streamvault.player.playback.LiveVideoStallRecoveryimport com.streamvault.player.playback.PlaybackErrorCategoryimport com.streamvault.player.playback.FfmpegAudioFallbackRequestimport com.streamvault.player.playback.FfmpegExtensionSupportimport com.streamvault.player.playback.InitialBitratePolicyimport com.streamvault.player.playback.PlaybackLogSanitizerimport com.streamvault.player.playback.PlaybackPreparationPlan-import com.streamvault.player.playback.PlaybackExtensionRendererModeimport com.streamvault.player.playback.PlaybackRetryContextimport com.streamvault.player.playback.PlayerDataSourceFactoryProviderimport com.streamvault.player.playback.PlayerErrorClassifier@@ -70,28 +76,27 @@ import com.streamvault.player.playback.Media3PreloadWindowManagerimport com.streamvault.player.playback.PlayerRetryPolicyimport com.streamvault.player.playback.PlayerTimeoutProfileimport com.streamvault.player.playback.isLivePlayback-import com.streamvault.player.playback.PreloadCoordinatorimport com.streamvault.player.playback.ResolvedStreamTypeimport com.streamvault.player.playback.resolveRetryAttemptAfterPlaybackStartedimport com.streamvault.player.playback.resolveRetryAttemptAfterReady-import com.streamvault.player.playback.resolveRetryAttemptForCategory+import com.streamvault.player.playback.isScheduledAppSourceRetryCurrent+import com.streamvault.player.playback.resolveNextAppSourceRetryAttemptimport com.streamvault.player.playback.resolveRetrySeekPositionMs+import com.streamvault.player.playback.resolveScheduledRetrySeekPositionMsimport com.streamvault.player.playback.StreamTypeResolverimport com.streamvault.player.playback.VideoStallDetectorimport com.streamvault.player.playback.AutomaticRecoveryAction-import com.streamvault.player.playback.buildLiveTsFallbackStreamInfoimport com.streamvault.player.playback.buildDecoderReuseWorkaroundEvaluationimport com.streamvault.player.playback.buildPlaybackRendererPlan+import com.streamvault.player.playback.buildPlaybackRendererFactorySettingsimport com.streamvault.player.playback.shouldAttemptAutomaticRecoveryimport com.streamvault.player.playback.hasEffectivePlaybackStartedimport com.streamvault.player.playback.shouldArmPlaybackStartedRecovery-import com.streamvault.player.playback.shouldFallbackMalformedHlsToLiveTs-import com.streamvault.player.playback.shouldFallbackStalledHlsToLiveTsimport com.streamvault.player.playback.shouldPreservePlaybackStateForRetryimport com.streamvault.player.playback.shouldRecoverFrameSilentReadyStallsimport com.streamvault.player.playback.shouldRecoverPositionAdvancingReadyStallsimport com.streamvault.player.playback.shouldRecoverReadyStalls-import com.streamvault.player.playback.shouldReconnectLiveStall+import com.streamvault.player.playback.shouldDeferAppStallRecoveryimport com.streamvault.player.playback.shouldForceSoftwareForAmbiguousDecoderFallbackimport com.streamvault.player.stats.FrameRateDetectorimport com.streamvault.player.stats.PlayerStatsCollector@@ -102,6 +107,7 @@ import com.streamvault.player.timeshift.LiveTimeshiftStateimport com.streamvault.player.timeshift.LiveTimeshiftStatusimport com.streamvault.player.timeshift.TimeshiftConfigimport com.streamvault.player.tracks.PlayerTrackController+import com.streamvault.player.tracks.AdaptiveDecodePressureTracksimport com.streamvault.player.ui.PlayerViewBinderimport com.streamvault.player.ui.SubtitleStyleControllerimport 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_000Lprivate const val LEGACY_TEXTURE_VIEW_MAX_SDK = Build.VERSION_CODES.N_MR1private const val FIRE_TV_MEDIATEK_TEXTURE_VIEW_MAX_SDK = Build.VERSION_CODES.Pprivate const val TEXTURE_VIEW_STARTUP_TIMEOUT_MS = 9_000L@@ -220,6 +225,7 @@ class Media3PlayerEngine @Inject constructor(private var currentResolvedStreamType: ResolvedStreamType = ResolvedStreamType.UNKNOWNprivate var currentTimeoutProfile: PlayerTimeoutProfile = PlayerTimeoutProfile.VODprivate var currentRetryPolicy: PlayerRetryPolicy? = null+ private val preloadPriorityHandler = Handler(context.mainLooper)private var currentRetryContext: PlaybackRetryContext? = nullprivate var playbackStarted = falseprivate var liveBufferingRecoveryArmed = false@@ -227,12 +233,13 @@ class Media3PlayerEngine @Inject constructor(private var hasRenderedFirstVideoFrame = falseprivate var prepareStartMs = 0Lprivate var retryAttempt = 0- private var lastRetryCategory: PlaybackErrorCategory? = nullprivate var retryJob: Job? = nullprivate var retryGeneration = 0L+ private var pendingRetrySeekPositionOverrideMs: Long? = nullprivate var currentBufferIsLive: Boolean? = nullprivate var currentBufferPolicyLabel: String? = nullprivate var currentBufferPolicy: PlaybackBufferPolicy? = null+ private var playbackLoadControl: PlaybackLoadControl? = nullprivate var audioCodecUnsupportedReported = falseprivate var lastSupportErrorMessage: String? = nullprivate 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? = nullprivate var pendingPreloadWindow: PlayerPreloadWindow? = nullprivate val compatibilityProfile: PlaybackCompatibilityProfile = DefaultPlaybackCompatibilityProfileprivate 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? = nullprivate var pendingTimeshiftSeekToEnd: Boolean = falseprivate var pendingTimeshiftAutoPlay: Boolean = false- private var lastAudioRendererRecoveryAtMs: Long = 0Lprivate 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) returnscope.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) == trueval 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")) returnval player = exoPlayer ?: return+ retryJob?.cancel()+ retryJob = null+ retryGeneration+++ pendingRetrySeekPositionOverrideMs = null+ _retryStatus.value = nullval playbackPlan = buildPlaybackPreparationPlan(streamInfo = streamInfo,preload = false,@@ -482,7 +545,6 @@ class Media3PlayerEngine @Inject constructor(currentRetryContext = playbackPlan.retryContextcurrentRetryPolicy = playbackPlan.retryPolicyretryAttempt = 0- lastRetryCategory = null_retryStatus.value = nullplaybackStarted = falseliveBufferingRecoveryArmed = false@@ -519,7 +581,12 @@ class Media3PlayerEngine @Inject constructor(}override fun stop() {+ clearAdaptiveDecodePressure()retryJob?.cancel()+ retryJob = null+ retryGeneration+++ pendingRetrySeekPositionOverrideMs = null+ _retryStatus.value = nullexoPlayer?.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 = falseplaybackStartedRecoveryArmed = falseretryAttempt = 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 = nullstatsCollector.stop()audioFocusController.release()mediaSession?.release()@@ -978,7 +1041,6 @@ class Media3PlayerEngine @Inject constructor(playbackStartedRecoveryArmed = falsehasRenderedFirstVideoFrame = falseretryAttempt = 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 = nullretryGeneration+++ pendingRetrySeekPositionOverrideMs = nulllastStreamInfo = streamInfoval 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 = 0videoStallSafeRecoveryPerformed = 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 = nullexisting.release()exoPlayer = null+ playbackLoadControl = nullpreloadWindowManager?.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 = preloadManagerreturn 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 = falseval 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 = trueAudioVideoOffsetAudioSink(@@ -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.ENDEDelse -> 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.positionMssyncTimeshiftState()}@@ -1796,7 +1855,6 @@ class Media3PlayerEngine @Inject constructor(playbackStartedRecoveryArmed = falseretryAttempt = 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+ )) returnvideoStallCount++_playerStats.value = _playerStats.value.copy(videoStallCount = videoStallCount)val wasPlaying = exoPlayer?.playWhenReady ?: trueval 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 = nulllastSupportErrorMessage = 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 = exoPlayerval retrySeekPositionMs = resolveRetrySeekPositionMs(@@ -2557,29 +2533,39 @@ class Media3PlayerEngine @Inject constructor(// (e.g. in tests), convert retryGeneration to AtomicLong.val scheduledRetryGeneration = retryGenerationretryAttempt = 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 = nullif (category == PlaybackErrorCategory.LIVE_WINDOW &¤tResolvedStreamType != 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 = nullLog.e(TAG,diff --git a/player/src/main/java/com/streamvault/player/PlayerEngine.kt b/player/src/main/java/com/streamvault/player/PlayerEngine.ktindex 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() = Unitfun 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.ktnew file mode 100644index 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.ktindex 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.playbackimport androidx.media3.common.Formatimport androidx.media3.common.util.UnstableApi+import androidx.media3.exoplayer.DefaultRenderersFactoryimport androidx.media3.exoplayer.DecoderReuseEvaluationimport androidx.media3.exoplayer.mediacodec.MediaCodecInfoimport 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.ktnew file mode 100644index 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.ktindex 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.ktnew file mode 100644index 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.ktdeleted file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.StreamInfoimport com.streamvault.player.PlayerPreloadContentTypeimport com.streamvault.player.PlayerPreloadItemimport com.streamvault.player.PlayerPreloadWindow+import com.streamvault.player.PlaybackStateimport com.streamvault.player.normalizePlayerPreloadWindow+import java.util.concurrent.atomic.AtomicBooleanimport kotlin.math.absinternal const val PLAYER_PRELOAD_RANGE_MS = 3_000Linternal 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 = falseprivate 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 = falseprivate 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 = falsesafeLog("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.currentIndexval nextCandidates = linkedMapOf<String, ManagedCandidate>()normalized.items.forEachIndexed { rankingIndex, item ->val streamIdentity = preloadStreamIdentity(item.streamInfo)+ val expectedRankingIndex = stableCurrentIndex + rankingIndex - normalized.currentIndexval 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] = existingreturn@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 nullif (released) return nullval 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) returnmanager.removeMediaItems(candidatesByKey.values.map(ManagedCandidate::mediaItem))candidatesByKey.clear()+ candidatesByRanking.clear()mediaItemsByStreamIdentity.clear()+ completedMediaItems.clear()+ foregroundMediaItems.clear()+ readsAllowed = false+ providerLimitBlocked = falsecurrentIndex = nullmanager.setCurrentPlayingIndex(-1)manager.invalidate()@@ -229,7 +316,10 @@ internal class Media3PreloadWindowManager(preloadManager?.release()preloadManager = nullcandidatesByKey.clear()+ candidatesByRanking.clear()mediaItemsByStreamIdentity.clear()+ completedMediaItems.clear()+ foregroundMediaItems.clear()currentIndex = nullsafeLog("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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.ktindex 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.playbackimport com.streamvault.domain.model.PlaybackContentKind-import com.streamvault.player.PlaybackState++internal fun shouldDeferAppStallRecovery(+ activeMediaLoadRetry: Boolean,+ sourceRetryPending: Boolean+): Boolean = activeMediaLoadRetry || sourceRetryPendinginternal 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.ktnew file mode 100644index 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.ktindex 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.Interceptorimport okhttp3.OkHttpClientimport okhttp3.Protocol-internal fun shouldUsePlatformHttpDataSource(resolvedStreamType: ResolvedStreamType): Boolean =- false-@UnstableApiclass 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.ktindex 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.SSLHandshakeExceptionenum 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_WINDOWhttpCode == 401 || httpCode == 403 || httpCode == 456 -> PlaybackErrorCategory.HTTP_AUTH+ httpCode == 404 -> PlaybackErrorCategory.HTTP_NOT_FOUNDhttpCode == 509 -> PlaybackErrorCategory.PROVIDER_LIMIThttpCode == 204 -> PlaybackErrorCategory.EMPTY_RESPONSEhttpCode 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.ktindex 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.Logimport androidx.media3.common.Cimport androidx.media3.common.PlaybackExceptionimport androidx.media3.common.util.UnstableApiimport androidx.media3.datasource.HttpDataSourceimport androidx.media3.exoplayer.source.BehindLiveWindowException+import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicyimport androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicyimport com.streamvault.domain.model.PlaybackContentKindimport java.net.ConnectExceptionimport java.net.SocketTimeoutExceptionimport java.net.UnknownHostException+import java.util.concurrent.ConcurrentHashMapprivate const val FAST_TRANSIENT_RETRY_DELAY_MS = 500L+private const val MAX_WHOLE_SOURCE_RETRIES_PER_OUTAGE = 1private const val LIVE_TRANSIENT_RETRY_ATTEMPTS = 10private 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.HLSPlaybackErrorCategory.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.errorCountval error = loadErrorInfo.exceptionval 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 -> 0PlaybackErrorCategory.FORMAT_UNSUPPORTED -> if (playbackStarted) 1 else 0diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetrySeekPositionPolicy.ktindex 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.ktdeleted file mode 100644index 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.ktindex 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.playbackimport 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.ktindex 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 = 0Lprivate var stalled = false+ @Synchronized+ fun restartAfterRecoveryAttempt() {+ startedAtMs = nowMs()+ lastPositionCheckMs = startedAtMs+ stalled = false+ // Retain lastFrameAtMs: a seek attempt is not evidence of a rendered frame.+ }+@Synchronizedfun 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.ktnew file mode 100644index 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.ktindex 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_IDprivate var preferredAudioLanguageTag: String? = nullprivate var preferredWifiMaxVideoHeight: Int? = nullprivate 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) continuefor (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_IDselectedTrackId == PLAYER_TRACK_AUTO_ID -> PLAYER_TRACK_AUTO_ID+ availableTrackIds.isEmpty() -> selectedTrackIdselectedTrackId in availableTrackIds -> selectedTrackIdavailableTrackIds.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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktdeleted file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.playbackimport androidx.media3.datasource.DefaultDataSource+import androidx.media3.datasource.DataSpecimport androidx.media3.exoplayer.DefaultLoadControlimport androidx.media3.exoplayer.DefaultRenderersFactory+import androidx.media3.exoplayer.source.LoadEventInfo+import androidx.media3.exoplayer.source.MediaLoadDataimport androidx.media3.exoplayer.upstream.DefaultBandwidthMeterimport androidx.media3.exoplayer.source.preload.DefaultPreloadManager+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicyimport com.google.common.truth.Truth.assertThat+import androidx.media3.common.Cimport com.streamvault.domain.model.StreamTypeimport com.streamvault.player.PlayerPreloadContentTypeimport com.streamvault.player.PlayerPreloadItem@@ -15,10 +20,19 @@ import org.junit.Testimport org.junit.runner.RunWithimport org.robolectric.RobolectricTestRunnerimport 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()+ }+@Testfun `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)?.mediaSourceassertThat(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.ktindex 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.PlaybackBufferModeimport com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.model.StreamType+import org.junit.Assert.assertEqualsimport org.junit.Testclass 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+ )+ }+ }+@Testfun `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.ktindex 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.playbackimport androidx.media3.common.Formatimport androidx.media3.common.util.UnstableApi+import androidx.media3.exoplayer.DefaultRenderersFactoryimport androidx.media3.exoplayer.DecoderReuseEvaluationimport com.google.common.truth.Truth.assertThatimport 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()+ }+@Testfun `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.ktnew file mode 100644index 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.ktindex 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.playbackimport com.google.common.truth.Truth.assertThatimport com.streamvault.domain.model.PlaybackContentKind-import com.streamvault.player.PlaybackStateimport org.junit.Testclass 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()+ }+@Testfun `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.ktnew file mode 100644index 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.ktindex 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()- }-@Testfun `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.ktindex 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)+ }+@Testfun `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.ktindex 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.Bundleimport androidx.media3.common.Cimport androidx.media3.common.ParserExceptionimport androidx.media3.common.PlaybackException+import androidx.media3.datasource.DataSpec+import androidx.media3.datasource.HttpDataSourceimport 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.LoadErrorHandlingPolicyimport com.google.common.truth.Truth.assertThatimport com.streamvault.domain.model.PlaybackContentKindimport java.io.IOExceptionimport java.net.SocketTimeoutExceptionimport javax.net.ssl.SSLHandshakeExceptionimport 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()+ }+@Testfun `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()+ }+@Testfun `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.ktindex 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.ktdeleted file mode 100644index 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.ktindex 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.Testclass 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()+ }+@Testfun `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.ktnew file mode 100644index 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.ktindex 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.Formatimport com.google.common.truth.Truth.assertThatimport com.streamvault.player.PLAYER_TRACK_AUTO_IDimport org.junit.Testclass 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)+ )+ }+@Testfun `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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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()