StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Add tests for raw transport stream backpressure and split HLS timestamp fixture server
David Nashasha0bc361c83f3
diff --git a/app/src/androidTest/AndroidManifest.xml b/app/src/androidTest/AndroidManifest.xmlnew file mode 100644index 00000000..c7c23652--- /dev/null+++ b/app/src/androidTest/AndroidManifest.xml@@ -0,0 +1,10 @@+<manifest xmlns:android="http://schemas.android.com/apk/res/android">+ <application>+ <activity+ android:name="com.streamvault.app.tv.IndependentTvHostActivity"+ android:exported="true"+ android:process=":tif_death_host"+ android:launchMode="singleTop"+ android:theme="@android:style/Theme.Material.NoActionBar.Fullscreen" />+ </application>+</manifest>diff --git a/app/src/androidTest/java/com/streamvault/app/tv/IndependentTvHostActivity.java b/app/src/androidTest/java/com/streamvault/app/tv/IndependentTvHostActivity.javanew file mode 100644index 00000000..adc20584--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/tv/IndependentTvHostActivity.java@@ -0,0 +1,93 @@+package com.streamvault.app.tv;++import android.app.Activity;+import android.content.Intent;+import android.media.tv.TvView;+import android.net.Uri;+import android.os.Bundle;+import android.os.Process;+import android.os.SystemClock;+import android.util.Log;+import android.view.SurfaceView;+import android.view.WindowManager;+import org.json.JSONObject;+import java.io.File;+import java.io.FileOutputStream;+import java.nio.charset.StandardCharsets;++/** Plain platform host in the test APK: remains alive when the product is SIGKILLed. */+public final class IndependentTvHostActivity extends Activity {+ private TvView view;+ private File events;+ private String run;+ private Uri channel;+ private String input;+ private int tunes;+ private boolean available;++ private void event(String name, String detail) {+ try {+ JSONObject row = new JSONObject().put("event", name).put("detail", detail)+ .put("elapsedMs", SystemClock.elapsedRealtime()).put("pid", Process.myPid())+ .put("tunes", tunes).put("available", available);+ try (FileOutputStream out = new FileOutputStream(events, true)) {+ out.write((row.toString() + "\n").getBytes(StandardCharsets.UTF_8));+ }+ Log.i("IndependentTvHost", row.toString());+ } catch (Exception error) { throw new IllegalStateException(error); }+ }++ @Override public void onCreate(Bundle saved) {+ super.onCreate(saved);+ Intent intent = getIntent();+ run = intent.getStringExtra("runId");+ if (!getPackageName().equals("com.streamvault.app.debug.test") ||+ !intent.getBooleanExtra("tvDeathFixture", false) || run == null ||+ !run.matches("[A-Za-z0-9_-]{1,40}")) { finish(); return; }+ channel = Uri.parse(intent.getStringExtra("channelUri"));+ if (!"content".equals(channel.getScheme()) || !"android.media.tv".equals(channel.getAuthority())) {+ finish(); return;+ }+ input = "com.streamvault.app.debug/com.streamvault.app.tvinput.StreamVaultTvInputService";+ events = new File(getFilesDir(), "independent-tif-" + run + ".jsonl");+ getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);+ view = new TvView(this);+ view.setCallback(new TvView.TvInputCallback() {+ @Override public void onVideoAvailable(String id) { available = true; event("available", ""); }+ @Override public void onVideoUnavailable(String id, int reason) { available = false; event("unavailable", Integer.toString(reason)); }+ @Override public void onConnectionFailed(String id) { available = false; event("connection-failed", ""); }+ @Override public void onDisconnected(String id) { available = false; event("disconnected", ""); }+ @Override public void onChannelRetuned(String id, Uri uri) { event("retuned", uri.toString()); }+ });+ // Only this opted-in clear loopback fixture permits screenshots.+ ((SurfaceView) view.getChildAt(0)).setSecure(false);+ setContentView(view);+ event("host-created", "");+ tune("initial-tune");+ }++ private void tune(String reason) {+ available = false; tunes++;+ event(reason, channel.toString());+ view.tune(input, channel);+ }++ @Override public void onNewIntent(Intent intent) {+ super.onNewIntent(intent);+ if (events == null || !run.equals(intent.getStringExtra("runId"))) return;+ String command = intent.getStringExtra("command");+ if ("retune".equals(command)) {+ view.reset();+ // reset() replaces TvView's SurfaceView and restores its default secure flag.+ ((SurfaceView) view.getChildAt(0)).setSecure(false);+ tune("explicit-retune");+ }+ else if ("capture-begin".equals(command) || "capture-end".equals(command) || "checkpoint".equals(command)) event(command, "");+ else if ("release".equals(command)) { event("release-start", ""); view.reset(); available = false; event("release-return", ""); finish(); }+ }++ @Override public void onDestroy() {+ if (events != null) { if (view != null) view.reset(); event("host-destroyed", ""); }+ super.onDestroy();+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/tv/TvInputProcessDeathFixtureTest.kt b/app/src/androidTest/java/com/streamvault/app/tv/TvInputProcessDeathFixtureTest.ktnew file mode 100644index 00000000..d417b608--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/tv/TvInputProcessDeathFixtureTest.kt@@ -0,0 +1,104 @@+package com.streamvault.app.tv++import android.app.Application+import android.content.ContentValues+import android.media.tv.TvContract+import android.net.Uri+import androidx.datastore.core.DataStore+import androidx.datastore.preferences.core.*+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.test.platform.app.InstrumentationRegistry+import com.streamvault.app.benchmark.XtreamSyncBenchmarkEntryPoint+import com.streamvault.app.ui.PlaybackInflightEpgProbe+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.ProviderConfigEntity+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.domain.model.M3uConfig+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.sync.AutomaticSyncActivity+import com.streamvault.domain.sync.AutomaticSyncSettings+import dagger.hilt.android.EntryPointAccessors+import dagger.hilt.internal.GeneratedComponentManager+import kotlinx.coroutines.delay+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.runBlocking+import org.json.JSONArray+import org.json.JSONObject+import org.junit.Assume.assumeTrue+import org.junit.Test+import org.junit.runner.RunWith++@RunWith(AndroidJUnit4::class)+class TvInputProcessDeathFixtureTest {+ @Test fun prepareOrCleanup() = runBlocking {+ val args = InstrumentationRegistry.getArguments()+ assumeTrue(args.getString("tvInputDeathFixture") == "true")+ val app = ApplicationProvider.getApplicationContext<Application>()+ require(app.packageName == "com.streamvault.app.debug")+ val run = requireNotNull(args.getString("runId"))+ require(run.matches(Regex("[A-Za-z0-9_-]{1,40}")))+ val file = app.filesDir.resolve("tif-death-$run-owned.json")+ val graph = EntryPointAccessors.fromApplication(app, XtreamSyncBenchmarkEntryPoint::class.java)+ val db = graph.database()+ val component = (app as GeneratedComponentManager<*>).generatedComponent()+ val emit: (JSONObject) -> Unit = { row ->+ app.filesDir.resolve("tif-death-$run-guide.jsonl").appendText(row.toString() + "\n")+ }+ @Suppress("UNCHECKED_CAST")+ val store = graph.preferences().javaClass.getDeclaredMethod("getPreferencesDataStore")+ .apply { isAccessible = true }.invoke(graph.preferences()) as DataStore<Preferences>+ when (args.getString("deathFixturePhase")) {+ "prepare" -> {+ check(!AutomaticSyncActivity.hasPlayback && !file.exists())+ val url = requireNotNull(args.getString("fixtureUrl"))+ require(Uri.parse(url).host in setOf("127.0.0.1", "localhost"))+ val id = db.providerDao().insert(ProviderEntity(name="TIF death fixture $run", type=ProviderType.M3U, isActive=false))+ check(graph.preferences().automaticSyncConfiguration.first().providers[id] == null)+ val keys = setOf("automatic_sync_status_$id", "catalog_sync_upgrade_started_$id", "catalog_sync_engine_$id")+ check(store.data.first().asMap().keys.none { it.name in keys })+ val saved = JSONObject().put("providerId", id).put("pid", android.os.Process.myPid())+ .put("run", run).put("guide", args.getString("inflightFixtureBase") != null)+ file.writeText(saved.toString(2)) // Recover ownership even if later setup fails.+ graph.preferences().setAutomaticSyncSettings(id, AutomaticSyncSettings(enabled=false, live=false, movies=false, series=false, epg=false))+ db.providerSnapshotDao().commitConfiguration(ProviderConfigEntity(providerId=id, type=ProviderType.M3U,+ schemaVersion=1, configurationGeneration=1, identityKey="tif-death-$run",+ encryptedConfigJson=com.google.gson.Gson().toJson(M3uConfig(playlistUrl=url)), updatedAt=System.currentTimeMillis()))+ val channel = db.channelDao().insert(ChannelEntity(name="TIF death fixture $run",providerId=id,streamId=1,streamUrl=url))+ val uri = requireNotNull(app.contentResolver.insert(TvContract.Channels.CONTENT_URI, ContentValues().apply {+ put(TvContract.Channels.COLUMN_INPUT_ID, "${app.packageName}/com.streamvault.app.tvinput.StreamVaultTvInputService")+ put(TvContract.Channels.COLUMN_TYPE, TvContract.Channels.TYPE_OTHER)+ put(TvContract.Channels.COLUMN_DISPLAY_NAME, "TIF death fixture $run")+ put(TvContract.Channels.COLUMN_DISPLAY_NUMBER, "9980")+ put(TvContract.Channels.COLUMN_INTERNAL_PROVIDER_DATA, "$id:$channel")+ }))+ saved.put("channelUri", uri.toString()); file.writeText(saved.toString(2))+ val guide = PlaybackInflightEpgProbe.start(app,component,args,run,emit)+ guide?.checkpointForProcessDeath()+ saved.put("ready", true); file.writeText(saved.toString(2))+ delay(180_000L)+ error("Host did not kill the fixture process")+ }+ "cleanup" -> {+ check(!AutomaticSyncActivity.hasPlayback)+ val saved = JSONObject(file.readText()); val id = saved.getLong("providerId")+ check(saved.getString("run") == run && db.providerDao().getById(id)?.name == "TIF death fixture $run")+ if (saved.getBoolean("guide")) {+ val (probe, guideSaved) = PlaybackInflightEpgProbe.resumeAfterProcessDeath(app,component,run,emit)+ probe.verifyExternallyRecoveredGuide(guideSaved)+ }+ if (saved.has("channelUri")) app.contentResolver.delete(Uri.parse(saved.getString("channelUri")),null,null)+ graph.providers().deleteProvider(id)+ graph.preferences().setAutomaticSyncSettings(id,null)+ store.edit { values ->+ values.remove(stringPreferencesKey("automatic_sync_status_$id"))+ values.remove(longPreferencesKey("catalog_sync_upgrade_started_$id"))+ values.remove(intPreferencesKey("catalog_sync_engine_$id"))+ }+ check(db.providerDao().getById(id) == null)+ app.filesDir.resolve("tif-death-$run-cleanup.json").writeText(JSONObject().put("removed",true).put("providerId",id).toString())+ }+ else -> error("Explicit phase required")+ }+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/ui/GuideProcessDeathRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/GuideProcessDeathRuntimeTest.ktnew file mode 100644index 00000000..5c01a572--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/ui/GuideProcessDeathRuntimeTest.kt@@ -0,0 +1,47 @@+package com.streamvault.app.ui++import android.app.Application+import android.util.Log+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.test.platform.app.InstrumentationRegistry+import dagger.hilt.internal.GeneratedComponentManager+import kotlinx.coroutines.delay+import kotlinx.coroutines.runBlocking+import org.json.JSONObject+import org.junit.Assume.assumeTrue+import org.junit.Test+import org.junit.runner.RunWith++/** Host-coordinated SIGKILL test; never runs without the explicit fixture opt-in. */+@RunWith(AndroidJUnit4::class)+class GuideProcessDeathRuntimeTest {+ @Test fun checkpointOrResume() = runBlocking {+ val args = InstrumentationRegistry.getArguments()+ assumeTrue(args.getString("guideProcessDeathFixture") == "true")+ val run = requireNotNull(args.getString("runId"))+ require(run.matches(Regex("[A-Za-z0-9_-]{1,40}")))+ val app = ApplicationProvider.getApplicationContext<Application>()+ val component = (app as GeneratedComponentManager<*>).generatedComponent()+ val phase = requireNotNull(args.getString("processDeathPhase"))+ require(phase in setOf("prepare", "resume", "cleanup"))+ val file = app.filesDir.resolve("process-death-$run-$phase.jsonl")+ file.writeText("")+ val emit: (JSONObject) -> Unit = { row ->+ row.put("elapsedMs", android.os.SystemClock.elapsedRealtime())+ .put("pid", android.os.Process.myPid())+ file.appendText(row.toString() + "\n")+ Log.i("GuideProcessDeath", row.toString())+ }+ if (phase == "prepare") {+ val probe = checkNotNull(PlaybackInflightEpgProbe.start(app, component, args, run, emit))+ probe.checkpointForProcessDeath()+ // Host kills the process while the actual worker/socket are still running.+ delay(180_000L)+ error("Host did not kill the checkpointed process")+ } else {+ val (probe, saved) = PlaybackInflightEpgProbe.resumeAfterProcessDeath(app, component, run, emit)+ probe.observeAfterProcessDeath(saved, cleanupOnly = phase == "cleanup")+ }+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/ui/HiddenControlsPlaybackRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/HiddenControlsPlaybackRuntimeTest.ktindex 2830c75b..5e854874 100644--- a/app/src/androidTest/java/com/streamvault/app/ui/HiddenControlsPlaybackRuntimeTest.kt+++ b/app/src/androidTest/java/com/streamvault/app/ui/HiddenControlsPlaybackRuntimeTest.kt@@ -17,12 +17,16 @@ import com.streamvault.core.navigation.PlayerNavigationRequestimport com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.feature.playback.player.PlayerViewModelimport com.streamvault.feature.playback.player.toggleControls+import com.streamvault.feature.playback.player.cancelControlsAutoHide+import com.streamvault.feature.playback.player.openEpgOverlay+import com.streamvault.feature.playback.player.closeOverlaysimport com.streamvault.player.PlaybackStateimport dagger.hilt.internal.GeneratedComponentManagerimport javax.inject.Providerimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.runBlocking+import kotlinx.coroutines.withTimeoutimport org.json.JSONArrayimport org.json.JSONObjectimport org.junit.Assume.assumeTrue@@ -41,6 +45,10 @@ class HiddenControlsPlaybackRuntimeTest {require(urls.all { Uri.parse(it).host in setOf("127.0.0.1", "localhost") })val seconds = args.getString("durationSeconds")?.toInt() ?: 130require(seconds in 10..160)+ val overlayMode = args.getString("overlayMode")+ require(overlayMode == null || overlayMode in setOf("hidden", "controls", "epg", "captions"))+ val fixtureSurfaceMode = args.getString("fixtureSurfaceMode")+ require(fixtureSurfaceMode == null || overlayMode == "hidden")val app = ApplicationProvider.getApplicationContext<Application>()val component = (app as GeneratedComponentManager<*>).generatedComponent()val prefs = (component.javaClass.getDeclaredField("preferencesRepositoryProvider").apply {@@ -80,13 +88,17 @@ class HiddenControlsPlaybackRuntimeTest {var workerEngine: com.streamvault.player.PlayerEngine? = nullvar audioSourceProbe: PlaybackAudioSourceProbe? = nullvar audioSourceEngine: com.streamvault.player.PlayerEngine? = null+ var publisherProbe: PlaybackPublisherProbe? = null+ var overlayData: PlaybackOverlayDataProbe? = nulltry {+ overlayData = PlaybackOverlayDataProbe.start(app, args, run, ::emit)+ publisherProbe = PlaybackPublisherProbe.start(app, args, run, ::emit)inflightProbe = PlaybackInflightEpgProbe.start(app, component, args, run, ::emit)catalogProbe = PlaybackInflightCatalogProbe.start(app, args, run, ::emit)indexProbe = PlaybackIndexWorkProbe.start(app, args, run, ::emit)scenario = ActivityScenario.launch(MainActivity::class.java)urls.forEachIndexed { index, url ->- val navigation = indexProbe?.navigation(url) ?: inflightProbe?.navigation(url) ?: PlayerNavigationRequest(+ val navigation = overlayData?.navigation() ?: publisherProbe?.navigation() ?: indexProbe?.navigation(url) ?: inflightProbe?.navigation(url) ?: PlayerNavigationRequest(streamUrl = url, title = "Local live fixture $index", contentType = "LIVE")scenario.onActivity { it.openPlayer(navigation) }var vm: PlayerViewModel? = null@@ -158,6 +170,7 @@ class HiddenControlsPlaybackRuntimeTest {val audioMode = engine.javaClass.getDeclaredField("requestedAudioDecoderMode").apply { isAccessible = true }.get(engine).toString()row = JSONObject().put("event", stage).put("channelIndex", index)+ .put("overlayMode", overlayMode ?: JSONObject.NULL).put("state", engine.playbackState.value.name).put("playing", engine.isPlaying.value).put("error", native.playerError?.errorCode ?: JSONObject.NULL).put("isLoading", native.isLoading)@@ -192,12 +205,20 @@ class HiddenControlsPlaybackRuntimeTest {.put("rebufferCount", engine.playerStats.value.rebufferCount).put("mainCpuMs", SystemClock.currentThreadTimeMillis()).put("processCpuMs", android.os.Process.getElapsedCpuTime())+ appendOverlaySnapshot(row, model, engine, overlayMode)}return row}visibility(false)Thread.sleep(1_000)check(!model.showDiagnostics.value)+ publisherProbe?.awaitBaselineReady()+ overlayData?.awaitBaselineReady()+ if (overlayMode != null) {+ workerEngine = engine+ configureOverlay(model, engine, overlayMode, ::main)+ }+ if (fixtureSurfaceMode != null) verifySurfaceSample(snapshot("surface-preflight"), fixtureSurfaceMode)emit(snapshot("capture-begin"))check(engine.javaClass.getDeclaredField("requestedVideoDecoderMode").apply {isAccessible = true@@ -207,7 +228,8 @@ class HiddenControlsPlaybackRuntimeTest {}.get(engine).toString() == "AUTO") { "Expected default AUTO audio decoder mode" }val workload = PlaybackImportWorkload.start(app, component, args, run, ::emit)workerProbe = PlaybackWorkerAdmissionProbe.start(app, args, run, ::emit)- if (workerProbe != null || inflightProbe != null || catalogProbe != null || indexProbe != null) workerEngine = engine+ if (workerProbe != null || inflightProbe != null || catalogProbe != null || indexProbe != null || publisherProbe != null) workerEngine = engine+ publisherProbe?.playbackReady()inflightProbe?.verifyPlaybackContext(model.javaClass.methods.single {it.name.substringBefore('$') == "getCurrentProviderId" && it.parameterCount == 0}.invoke(model) as Long)@@ -220,7 +242,11 @@ class HiddenControlsPlaybackRuntimeTest {try {repeat(seconds) {Thread.sleep(1_000)- emit(snapshot("sample"))+ advanceCaption(engine, overlayMode, it, ::main)+ val sample = snapshot("sample")+ emit(sample)+ verifyOverlaySample(sample, overlayMode)+ verifySurfaceSample(sample, fixtureSurfaceMode)audioSourceProbe?.drain()check(!engine.playerStats.value.isTimeshiftPlayback)}@@ -230,7 +256,9 @@ class HiddenControlsPlaybackRuntimeTest {inflightProbe?.finishWhilePlaying()catalogProbe?.finishWhilePlaying()indexProbe?.finishWhilePlaying()+ publisherProbe?.finishWhilePlaying()}+ if (overlayMode != null) main { engine.setInjectedSubtitleText(null); model.closeOverlays() }visibility(true)Thread.sleep(700)emit(snapshot("controls-open"))@@ -261,12 +289,89 @@ class HiddenControlsPlaybackRuntimeTest {catalogProbe?.finishAfterPlayback()indexProbe?.finishAfterPlayback()} finally {- try { indexProbe?.close() } finally { try { catalogProbe?.close() } finally {+ closeDataProbes(overlayData, publisherProbe, indexProbe, catalogProbe) {prefs.setPlayerTimeshiftEnabled(originalTimeshift)app.filesDir.resolve("hidden-controls-$run.json").writeText(events.toString(2))}+ }+ }+ }+ private fun appendOverlaySnapshot(row: JSONObject, model: PlayerViewModel, engine: com.streamvault.player.PlayerEngine, mode: String?) {+ if (mode == null) return+ val binder = engine.javaClass.getDeclaredField("viewBinder").apply { isAccessible = true }.get(engine)+ val bound = binder.javaClass.getDeclaredField("boundPlayerView").apply { isAccessible = true }.get(binder) as androidx.media3.ui.PlayerView+ val view = checkNotNull(bound.subtitleView)+ val cues = view.javaClass.getDeclaredField("cues").apply { isAccessible = true }.get(view) as List<*>+ row.put("epgVisible", model.showEpgOverlay.value)+ .put("currentProgramPresent", model.currentProgram.value != null)+ .put("upcomingProgramCount", model.upcomingPrograms.value.size)+ .put("renderedSubtitleCueCount", cues.size)+ .put("subtitleViewVisibility", view.visibility)+ .put("subtitleViewShown", view.isShown)+ val video = bound.videoSurfaceView+ row.put("actualVideoViewClass", video?.javaClass?.name ?: JSONObject.NULL)+ .put("requestedSurfaceMode", engine.javaClass.getDeclaredField("requestedSurfaceMode").apply { isAccessible = true }.get(engine).toString())+ .put("videoOutputReady", when (video) {+ is android.view.TextureView -> video.isAvailable+ is android.view.SurfaceView -> video.holder.surface.isValid+ else -> false+ })+ }++ private suspend fun configureOverlay(model: PlayerViewModel, engine: com.streamvault.player.PlayerEngine, mode: String, main: (() -> Unit) -> Unit) {+ withTimeout(15_000) {+ while (model.currentProgram.value == null || model.upcomingPrograms.value.size < 2) kotlinx.coroutines.delay(100)+ }+ main {+ engine.setInjectedSubtitleText(null)+ if (mode == "controls") model.toggleControls()+ if (mode == "epg") model.openEpgOverlay()+ if (mode == "captions") engine.setInjectedSubtitleText("Overlay caption 0: The quick brown fox crosses the screen.")+ }+ Thread.sleep(2_000)+ main {+ model.cancelControlsAutoHide()+ Class.forName("com.streamvault.feature.playback.player.PlayerOverlayActionsKt").declaredMethods+ .single { it.name.substringBefore('$') == "clearLiveOverlayAutoHide" }.invoke(null, model)+ }+ Thread.sleep(1_000)+ }++ private fun advanceCaption(engine: com.streamvault.player.PlayerEngine, mode: String?, second: Int, main: (() -> Unit) -> Unit) {+ if (mode == "captions" && second % 2 == 0) main {+ engine.setInjectedSubtitleText("Overlay caption ${second / 2 + 1}: The quick brown fox crosses the screen.")+ }+ }++ private fun verifyOverlaySample(sample: JSONObject, mode: String?) {+ if (mode == null) return+ check(sample.getBoolean("controlsVisible") == (mode == "controls"))+ check(sample.getBoolean("epgVisible") == (mode == "epg"))+ check(sample.getBoolean("currentProgramPresent") && sample.getInt("upcomingProgramCount") >= 2)+ check(sample.getInt("renderedSubtitleCueCount") == if (mode == "captions") 1 else 0)+ if (mode == "captions") check(sample.getBoolean("subtitleViewShown"))+ }++ private fun verifySurfaceSample(sample: JSONObject, mode: String?) {+ if (mode == null) return+ val expected = if (mode == "TEXTURE_VIEW") "TEXTURE_VIEW" else "SURFACE_VIEW"+ val expectedClass = if (mode == "TEXTURE_VIEW") "android.view.TextureView" else "android.view.SurfaceView"+ check(sample.getString("requestedSurfaceMode") == mode)+ check(sample.getString("renderSurfaceType") == expected) { "Production surface guard/fallback selected another path" }+ check(sample.getString("actualVideoViewClass") == expectedClass && sample.getBoolean("videoOutputReady"))+ }++ private suspend fun closeDataProbes(+ overlay: PlaybackOverlayDataProbe?, publisher: PlaybackPublisherProbe?,+ index: PlaybackIndexWorkProbe?, catalog: PlaybackInflightCatalogProbe?, finish: suspend () -> Unit+ ) {+ try { overlay?.close() } finally {+ try { publisher?.close() } finally {+ try { index?.close() } finally {+ try { catalog?.close() } finally { finish() }}}}}+}diff --git a/app/src/androidTest/java/com/streamvault/app/ui/MainPlayerProcessDeathRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/MainPlayerProcessDeathRuntimeTest.ktnew file mode 100644index 00000000..90f23dcd--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/ui/MainPlayerProcessDeathRuntimeTest.kt@@ -0,0 +1,153 @@+package com.streamvault.app.ui++import android.app.Application+import android.media.tv.TvContract+import android.net.Uri+import androidx.datastore.core.DataStore+import androidx.datastore.preferences.core.*+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.test.platform.app.InstrumentationRegistry+import com.streamvault.app.benchmark.XtreamSyncBenchmarkEntryPoint+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.ProviderConfigEntity+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.domain.model.M3uConfig+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.sync.AutomaticSyncSettings+import dagger.hilt.android.EntryPointAccessors+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.runBlocking+import org.json.JSONArray+import org.json.JSONObject+import org.junit.Assume.assumeTrue+import org.junit.Test+import org.junit.runner.RunWith++/** Data setup only: the actual PlayerScreen/kill/launcher return run without instrumentation. */+@RunWith(AndroidJUnit4::class)+class MainPlayerProcessDeathRuntimeTest {+ @Test fun removeAuditedFixtureNavigationPreferences() = runBlocking {+ val args=InstrumentationRegistry.getArguments()+ assumeTrue(args.getString("mainPreferenceCleanup")=="true")+ require(args.getString("originalLastActiveAbsent")=="true")+ val runs=requireNotNull(args.getString("mainPreferenceRuns")).split(',')+ require(runs.isNotEmpty() && runs.all { it.matches(Regex("[A-Za-z0-9_-]{1,40}")) })+ val app=ApplicationProvider.getApplicationContext<Application>()+ require(app.packageName=="com.streamvault.app.debug")+ val graph=EntryPointAccessors.fromApplication(app,XtreamSyncBenchmarkEntryPoint::class.java)+ val ids=runs.map { run ->+ val saved=JSONObject(app.filesDir.resolve("main-death-$run-owned.json").readText())+ check(saved.getString("run")==run)+ // Older measured fixtures rely on the explicit host-audited absence flag.+ if(saved.has("lastActiveProvider")) check(saved.isNull("lastActiveProvider"))+ saved.getLong("providerId").also { check(graph.database().providerDao().getById(it)==null) }+ }+ @Suppress("UNCHECKED_CAST")+ val store=graph.preferences().javaClass.getDeclaredMethod("getPreferencesDataStore").apply { isAccessible=true }+ .invoke(graph.preferences()) as DataStore<Preferences>+ store.edit { values ->+ ids.forEach { id ->+ val key=longPreferencesKey("last_live_category_id_$id")+ check(values[key]==-1_000_000L) { "Fixture navigation changed since cleanup audit" }+ values.remove(key)+ }+ val lastActive=longPreferencesKey("last_active_provider_id")+ check(values[lastActive]==ids.last()) { "Active provider preference changed since cleanup audit" }+ values.remove(lastActive)+ }+ app.filesDir.resolve("main-navigation-cleanup.json").writeText(JSONObject().put("ownedProviderIds",JSONArray(ids)).put("removedAuditedKeys",ids.size+1).toString())+ }++ @Test fun prepareOrCleanup() = runBlocking {+ val args=InstrumentationRegistry.getArguments()+ assumeTrue(args.getString("mainProcessDeathFixture")=="true")+ val run=requireNotNull(args.getString("runId"))+ require(run.matches(Regex("[A-Za-z0-9_-]{1,40}")))+ val app=ApplicationProvider.getApplicationContext<Application>()+ require(app.packageName=="com.streamvault.app.debug")+ val graph=EntryPointAccessors.fromApplication(app,XtreamSyncBenchmarkEntryPoint::class.java)+ val db=graph.database()+ val prefs=graph.preferences()+ @Suppress("UNCHECKED_CAST")+ val store=prefs.javaClass.getDeclaredMethod("getPreferencesDataStore").apply { isAccessible=true }.invoke(prefs) as DataStore<Preferences>+ val observationKey=stringPreferencesKey("live_variant_observations")+ val savedFile=app.filesDir.resolve("main-death-$run-owned.json")+ when(args.getString("mainDeathPhase")) {+ "prepare" -> {+ val url=requireNotNull(args.getString("fixtureUrl"))+ require(Uri.parse(url).host in setOf("127.0.0.1","localhost"))+ check(!savedFile.exists())+ check(!prefs.playerTimeshiftEnabled.first()) { "This fixture requires the existing timeshift-off setting" }+ val activeIds=db.providerDao().getAllSync().filter { it.isActive }.map { it.id }+ val id=db.providerDao().insert(ProviderEntity(name="Main death fixture $run",type=ProviderType.M3U,isActive=false))+ check(prefs.automaticSyncConfiguration.first().providers[id]==null)+ val ownedKeys=setOf("automatic_sync_status_$id","catalog_sync_upgrade_started_$id","catalog_sync_engine_$id","last_live_category_id_$id")+ check(store.data.first().asMap().keys.none { it.name in ownedKeys })+ val saved=JSONObject().put("run",run).put("providerId",id).put("url",url)+ .put("title","Main live fixture $run").put("activeIds",JSONArray(activeIds))+ .put("variantObservation",store.data.first()[observationKey] ?: JSONObject.NULL)+ .put("lastActiveProvider",store.data.first()[longPreferencesKey("last_active_provider_id")] ?: JSONObject.NULL)+ savedFile.writeText(saved.toString(2))+ prefs.setAutomaticSyncSettings(id,AutomaticSyncSettings(enabled=false,live=false,movies=false,series=false,epg=false))+ db.providerSnapshotDao().commitConfiguration(ProviderConfigEntity(providerId=id,type=ProviderType.M3U,+ schemaVersion=1,configurationGeneration=1,identityKey="main-death-$run",+ encryptedConfigJson=com.google.gson.Gson().toJson(M3uConfig(playlistUrl=url.substringBefore("/live/")+"/unused.m3u")),updatedAt=System.currentTimeMillis()))+ val channel=db.channelDao().insert(ChannelEntity(name=saved.getString("title"),providerId=id,+ streamId=if(url.contains("1002")) 1002 else 1001,streamUrl=url,number=1))+ saved.put("channelId",channel);savedFile.writeText(saved.toString(2))+ db.providerDao().setActive(id)+ saved.put("ready",true);savedFile.writeText(saved.toString(2))+ }+ "cleanup" -> {+ val saved=JSONObject(savedFile.readText());val id=saved.getLong("providerId")+ check(saved.getString("run")==run && db.providerDao().getById(id)?.name=="Main death fixture $run")+ val rows=mutableListOf<Uri>()+ app.contentResolver.query(TvContract.buildChannelsUriForInput("${app.packageName}/com.streamvault.app.tvinput.StreamVaultTvInputService"),+ arrayOf("_id","internal_provider_data"),null,null,null)?.use { cursor ->+ while(cursor.moveToNext()) if(cursor.getString(1)?.startsWith("$id:")==true)+ rows+=TvContract.buildChannelUri(cursor.getLong(0))+ }+ rows.forEach { app.contentResolver.delete(it,null,null) }+ val activeId=db.providerDao().getActive().first()?.id+ graph.providers().deleteProvider(id)+ if(activeId==id) {+ db.providerDao().deactivateAll()+ val previous=saved.getJSONArray("activeIds")+ for(index in 0 until previous.length()) {+ val previousId=previous.getLong(index)+ check(db.providerDao().getById(previousId)!=null)+ db.providerDao().activate(previousId)+ }+ }+ prefs.setAutomaticSyncSettings(id,null)+ store.edit { values ->+ values.remove(stringPreferencesKey("automatic_sync_status_$id"))+ values.remove(longPreferencesKey("catalog_sync_upgrade_started_$id"))+ values.remove(intPreferencesKey("catalog_sync_engine_$id"))+ values.remove(longPreferencesKey("last_live_category_id_$id"))+ val lastActive=longPreferencesKey("last_active_provider_id")+ if(values[lastActive]==id && saved.has("lastActiveProvider")) {+ if(saved.isNull("lastActiveProvider")) values.remove(lastActive)+ else values[lastActive]=saved.getLong("lastActiveProvider")+ }+ val current=values[observationKey]+ val previous=if(saved.isNull("variantObservation")) null else saved.getString("variantObservation")+ if(current!=previous) {+ val channelId=saved.getLong("channelId")+ val remaining=current.orEmpty().lineSequence().filter {+ it.substringBefore('|').toLongOrNull()!=channelId+ }.filter { it.isNotEmpty() }.toList()+ val original=previous.orEmpty().lineSequence().filter { it.isNotEmpty() }.toList()+ if(remaining==original) {+ if(previous==null) values.remove(observationKey) else values[observationKey]=previous+ } else values[observationKey]=remaining.joinToString("\n")+ }+ }+ check(db.providerDao().getById(id)==null)+ app.filesDir.resolve("main-death-$run-cleanup.json").writeText(JSONObject().put("providerRemoved",true).put("frameworkRowsRemoved",rows.size).toString())+ }+ else -> error("Explicit phase required")+ }+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackInflightEpgProbe.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackInflightEpgProbe.ktindex ec50fd8a..066d526b 100644--- a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackInflightEpgProbe.kt+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackInflightEpgProbe.kt@@ -360,7 +360,102 @@ internal class PlaybackInflightEpgProbe private constructor(emit(JSONObject().put("event", "inflight-cleanup").put("providersRemoved", ids.size))}+ /** Persist only disposable fixture ownership before the host kills this process. */+ suspend fun checkpointForProcessDeath() {+ val ownedKeys = ids.flatMap { id -> listOf("automatic_sync_status_$id",+ "catalog_sync_upgrade_started_$id", "catalog_sync_engine_$id") }.toSet()+ check(originalPreferences.asMap().keys.none { it.name in ownedKeys })+ check(previousOverrides.values.all { it == null })+ val info = networkSnapshot("process-death-checkpoint")+ check(info.state == WorkInfo.State.RUNNING)+ if (providerKind == "stalker") {+ check(graph.database().programDao().countByProvider(guideId) >= 5001 && retainedSeedRows() == 1)+ } else {+ check(graph.database().programDao().countByProvider(guideId) == 1)+ check(graph.database().programDao().countByProvider(-guideId) >= 5000)+ }+ val saved = JSONObject().put("base", base).put("kind", providerKind).put("run", run)+ .put("providerIds", JSONArray(ids)).put("guideId", guideId)+ .put("requestId", checkNotNull(guideRequestId).toString())+ .put("lastEpgSuccess", prefixMetadata?.lastEpgSuccess ?: 0L)+ .put("workIds", JSONArray(infos(guideId).map { it.id.toString() }))+ .put("pid", android.os.Process.myPid())+ app.filesDir.resolve("process-death-$run-owned.json").writeText(saved.toString(2))+ emit(JSONObject().put("event", "process-death-ready").put("pid", android.os.Process.myPid()))+ }++ suspend fun observeAfterProcessDeath(saved: JSONObject, cleanupOnly: Boolean) {+ try {+ check(saved.getInt("pid") != android.os.Process.myPid()) { "Process did not restart" }+ check(!AutomaticSyncActivity.hasPlayback)+ val initial = networkSnapshot("process-restart-initial")+ check(initial.state == WorkInfo.State.ENQUEUED || initial.state == WorkInfo.State.RUNNING)+ check((graph.syncMetadata().getMetadata(guideId)?.lastEpgSuccess ?: 0L) == saved.getLong("lastEpgSuccess"))+ if (cleanupOnly) return+ URL("$base/release?run=$run").openConnection().apply { connectTimeout=5000; readTimeout=5000 }+ .getInputStream().use { it.readBytes() }+ withTimeout(300_000L) {+ while (true) {+ val info = networkSnapshot("process-restart-poll")+ if (info.state.isFinished) {+ check(info.state == WorkInfo.State.SUCCEEDED)+ break+ }+ delay(2000L)+ }+ }+ val rows = graph.database().programDao().countByProvider(guideId)+ val stage = graph.database().programDao().countByProvider(-guideId)+ val metadata = graph.syncMetadata().getMetadata(guideId)+ check(rows == 100_000 && stage == 0)+ check((metadata?.lastEpgSuccess ?: 0L) > saved.getLong("lastEpgSuccess"))+ if (providerKind == "stalker") check(retainedSeedRows() == 0 && metadata?.epgCount == 100_000)+ val beforeIds = saved.getJSONArray("workIds").let { array ->+ (0 until array.length()).map { array.getString(it) }.toSet()+ }+ check(infos(guideId).map { it.id.toString() }.toSet() == beforeIds)+ emit(JSONObject().put("event", "process-restart-recovered").put("sameRequest", true)+ .put("programs", rows).put("stagedPrograms", stage).put("resubmitted", false))+ } finally { cleanup() }+ }++ /** The independent TV host observed recovery without restarting instrumentation in the player. */+ suspend fun verifyExternallyRecoveredGuide(saved: JSONObject) {+ try {+ check(!AutomaticSyncActivity.hasPlayback)+ val info = networkSnapshot("external-guide-final")+ check(info.state == WorkInfo.State.SUCCEEDED)+ check(graph.database().programDao().countByProvider(guideId) == 100_000)+ check(graph.database().programDao().countByProvider(-guideId) == 0)+ check((graph.syncMetadata().getMetadata(guideId)?.lastEpgSuccess ?: 0L) > saved.getLong("lastEpgSuccess"))+ val beforeIds = saved.getJSONArray("workIds").let { array ->+ (0 until array.length()).map { array.getString(it) }.toSet()+ }+ check(infos(guideId).map { it.id.toString() }.toSet() == beforeIds)+ if (providerKind == "stalker") check(retainedSeedRows() == 0)+ } finally { cleanup() }+ }+companion object {+ suspend fun resumeAfterProcessDeath(app: Application, component: Any, run: String,+ emit: (JSONObject) -> Unit): Pair<PlaybackInflightEpgProbe, JSONObject> {+ val saved = JSONObject(app.filesDir.resolve("process-death-$run-owned.json").readText())+ require(saved.getString("run") == run && app.packageName.endsWith(".debug"))+ require(Uri.parse(saved.getString("base")).host in setOf("127.0.0.1", "localhost"))+ val probe = PlaybackInflightEpgProbe(app, component, saved.getString("base"), run, emit, saved.getString("kind"))+ probe.guideId = saved.getLong("guideId")+ probe.guideRequestId = UUID.fromString(saved.getString("requestId"))+ probe.originalPreferences = emptyPreferences()+ val ids = saved.getJSONArray("providerIds")+ for (index in 0 until ids.length()) {+ val id = ids.getLong(index)+ check(probe.graph.database().providerDao().getById(id)?.name == "In-flight guide fixture $run ${if (id == probe.guideId) "background" else "manual"}")+ probe.ids.add(id)+ probe.previousOverrides[id] = null+ }+ return probe to saved+ }+suspend fun start(app: Application, component: Any, args: Bundle, run: String,emit: (JSONObject) -> Unit): PlaybackInflightEpgProbe? {val base = args.getString("inflightFixtureBase") ?: return nulldiff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackOverlayDataProbe.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackOverlayDataProbe.ktnew file mode 100644index 00000000..a0c22236--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackOverlayDataProbe.kt@@ -0,0 +1,151 @@+package com.streamvault.app.ui++import android.app.Application+import android.media.tv.TvContract+import android.net.Uri+import android.os.Bundle+import android.os.SystemClock+import androidx.datastore.core.DataStore+import androidx.datastore.preferences.core.*+import androidx.work.WorkManager+import androidx.work.WorkInfo+import com.streamvault.app.benchmark.XtreamSyncBenchmarkEntryPoint+import com.streamvault.app.tvinput.TvInputCatalogRefreshWorker+import com.streamvault.core.navigation.PlayerNavigationRequest+import com.streamvault.data.local.entity.*+import com.streamvault.domain.model.M3uConfig+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.PlayerSurfaceMode+import com.streamvault.domain.sync.AutomaticSyncSettings+import dagger.hilt.android.EntryPointAccessors+import kotlinx.coroutines.*+import kotlinx.coroutines.flow.first+import org.json.JSONObject++/** One real local channel/guide, identical in every opt-in overlay comparison. */+internal class PlaybackOverlayDataProbe private constructor(+ private val app: Application, private val run: String,+ private val url: String, private val emit: (JSONObject) -> Unit,+ private val surfaceMode: PlayerSurfaceMode?+) {+ private val graph = EntryPointAccessors.fromApplication(app, XtreamSyncBenchmarkEntryPoint::class.java)+ private val db = graph.database()+ private val prefs = graph.preferences()+ private val manager = EntryPointAccessors.fromApplication(app, TvInputCatalogRefreshWorker.Entry::class.java)+ .tvInputChannelSyncManager()+ private var providerId = 0L+ private var channelId = 0L+ private var ownsPreferences = false+ private val saved = JSONObject().put("run", run)+ @Suppress("UNCHECKED_CAST")+ private val store = prefs.javaClass.getDeclaredMethod("getPreferencesDataStore").apply { isAccessible = true }+ .invoke(prefs) as DataStore<Preferences>+ private fun persist() = app.filesDir.resolve("overlay-$run-owned.json").writeText(saved.toString(2))+ private fun count(uri: Uri, selection: String? = null, args: Array<String>? = null): Int =+ app.contentResolver.query(uri, arrayOf("_id"), selection, args, null)!!.use { it.count }+ private fun frameworkPrograms() = count(TvContract.Programs.CONTENT_URI)++ private suspend fun prepare() {+ // Publishing refreshes all managed rows; require a clean isolated TV catalog.+ check(db.providerDao().getAllSync().isEmpty()) { "Overlay probe requires an empty provider database" }+ check(count(TvContract.Channels.CONTENT_URI) == 0 && frameworkPrograms() == 0)+ check(!prefs.playerTimeshiftEnabled.first())+ saved.put("lastActiveProvider", store.data.first()[longPreferencesKey("last_active_provider_id")] ?: JSONObject.NULL)+ .put("variantObservation", store.data.first()[stringPreferencesKey("live_variant_observations")] ?: JSONObject.NULL)+ .put("originalSurfacePreference", store.data.first()[stringPreferencesKey("player_surface_mode")] ?: JSONObject.NULL)+ .put("fixtureSurfaceMode", surfaceMode?.name ?: JSONObject.NULL)+ providerId = db.providerDao().insert(ProviderEntity(name = "Overlay fixture $run", type = ProviderType.M3U, isActive = false))+ saved.put("providerId", providerId); persist()+ check(prefs.automaticSyncConfiguration.first().providers[providerId] == null)+ val ownedKeys = setOf("automatic_sync_status_$providerId", "catalog_sync_upgrade_started_$providerId",+ "catalog_sync_engine_$providerId", "last_live_category_id_$providerId")+ check(store.data.first().asMap().keys.none { it.name in ownedKeys }) { "Fixture preference key already exists" }+ ownsPreferences = true+ surfaceMode?.let { prefs.setPlayerSurfaceMode(it) }+ prefs.setAutomaticSyncSettings(providerId, AutomaticSyncSettings(enabled = false, live = false, movies = false, series = false, epg = false))+ db.providerSnapshotDao().commitConfiguration(ProviderConfigEntity(providerId = providerId, type = ProviderType.M3U,+ schemaVersion = 1, configurationGeneration = 1, identityKey = "overlay-$run",+ encryptedConfigJson = com.google.gson.Gson().toJson(M3uConfig(playlistUrl = url.substringBefore("/live/") + "/unused.m3u")),+ updatedAt = System.currentTimeMillis()))+ db.channelDao().insertAll((1..1).map { i -> ChannelEntity(providerId = providerId, streamId = i.toLong(),+ name = "Overlay live fixture", number = i, epgChannelId = "overlay-$i", streamUrl = url) })+ channelId = db.channelDao().getByProviderSync(providerId).single { it.streamId == 1L }.id+ saved.put("channelId", channelId); persist()+ val start = System.currentTimeMillis() / 3_600_000L * 3_600_000L - 3_600_000L+ for (chunk in (1..1).chunked(100)) {+ db.programDao().insertAll(chunk.flatMap { i -> (0..47).map { j -> ProgramEntity(providerId = providerId,+ channelId = "overlay-$i", title = "Overlay programme $i/$j", description = "Fixture schedule entry $i/$j",+ startTime = start + j * 900_000L, endTime = start + (j + 1) * 900_000L) } })+ }+ db.providerDao().setActive(providerId)+ manager.refreshTvInputCatalogResult().getOrThrow()+ check(count(TvContract.Channels.CONTENT_URI) == 1 && frameworkPrograms() == 24)+ emit(JSONObject().put("event", "overlay-prepared").put("providerId", providerId)+ .put("channels", 1).put("programs", 48))+ }++ fun navigation() = PlayerNavigationRequest(streamUrl = url, title = "Overlay live fixture",+ channelId = "overlay-1", internalId = channelId, providerId = providerId, contentType = "LIVE")++ suspend fun awaitBaselineReady() {+ // Serialize behind startup's refresh; complete the same no-op pass in both arms.+ manager.refreshTvInputCatalogResult().getOrThrow()+ delay(2_000)+ emit(JSONObject().put("event", "overlay-baseline-ready").put("frameworkPrograms", frameworkPrograms()))+ }++ suspend fun close() {+ if (providerId == 0L) return+ check(db.providerDao().getById(providerId)?.name == "Overlay fixture $run")+ if (!ownsPreferences) {+ // Guard failed before any config/channel/preferences were created. Remove+ // only the newly inserted row; repository runtime cleanup could erase the+ // stale preference key which caused the preflight refusal.+ db.providerDao().delete(providerId)+ return+ }+ val deleted = graph.providers().deleteProvider(providerId)+ check(deleted is com.streamvault.domain.model.Result.Success && db.providerDao().getById(providerId) == null)+ db.providerDao().deactivateAll()+ manager.refreshTvInputCatalogResult().getOrThrow()+ prefs.setAutomaticSyncSettings(providerId, null)+ store.edit { values ->+ if (surfaceMode != null) {+ val surfaceKey = stringPreferencesKey("player_surface_mode")+ check(values[surfaceKey] == surfaceMode.name) { "Surface preference changed outside fixture" }+ if (saved.isNull("originalSurfacePreference")) values.remove(surfaceKey)+ else values[surfaceKey] = saved.getString("originalSurfacePreference")+ }+ values.remove(stringPreferencesKey("automatic_sync_status_$providerId"))+ values.remove(longPreferencesKey("catalog_sync_upgrade_started_$providerId"))+ values.remove(intPreferencesKey("catalog_sync_engine_$providerId"))+ values.remove(longPreferencesKey("last_live_category_id_$providerId"))+ val active = longPreferencesKey("last_active_provider_id")+ if (values[active] == providerId) {+ if (saved.isNull("lastActiveProvider")) values.remove(active) else values[active] = saved.getLong("lastActiveProvider")+ }+ val key = stringPreferencesKey("live_variant_observations")+ val remaining = values[key].orEmpty().lineSequence().filter { it.isNotEmpty() && it.substringBefore('|').toLongOrNull() != channelId }.toList()+ val before = if (saved.isNull("variantObservation")) null else saved.getString("variantObservation")+ if (remaining == before.orEmpty().lineSequence().filter(String::isNotEmpty).toList()) {+ if (before == null) values.remove(key) else values[key] = before+ } else values[key] = remaining.joinToString("\n")+ }+ emit(JSONObject().put("event", "overlay-cleanup").put("providerId", providerId)+ .put("frameworkChannels", count(TvContract.Channels.CONTENT_URI)).put("frameworkPrograms", frameworkPrograms()))+ }++ companion object {+ suspend fun start(app: Application, args: Bundle, run: String, emit: (JSONObject) -> Unit): PlaybackOverlayDataProbe? {+ if (args.getString("overlayMode") == null) return null+ check(app.packageName == "com.streamvault.app.debug")+ val urls = requireNotNull(args.getString("fixtureUrls")).split(','); check(urls.size == 1)+ require(Uri.parse(urls.single()).host in setOf("127.0.0.1", "localhost"))+ val surfaceMode = args.getString("fixtureSurfaceMode")?.let(PlayerSurfaceMode::valueOf)+ require(surfaceMode == null || surfaceMode in setOf(PlayerSurfaceMode.AUTO, PlayerSurfaceMode.TEXTURE_VIEW))+ val probe = PlaybackOverlayDataProbe(app, run, urls.single(), emit, surfaceMode)+ try { probe.prepare() } catch (error: Throwable) { probe.close(); throw error }+ return probe+ }+ }+}diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackPublisherProbe.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackPublisherProbe.ktnew file mode 100644index 00000000..67410701--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackPublisherProbe.kt@@ -0,0 +1,196 @@+package com.streamvault.app.ui++import android.app.Application+import android.media.tv.TvContract+import android.net.Uri+import android.os.Bundle+import android.os.SystemClock+import androidx.datastore.core.DataStore+import androidx.datastore.preferences.core.*+import androidx.work.WorkManager+import androidx.work.WorkInfo+import com.streamvault.app.benchmark.XtreamSyncBenchmarkEntryPoint+import com.streamvault.app.tvinput.TvInputCatalogRefreshWorker+import com.streamvault.core.navigation.PlayerNavigationRequest+import com.streamvault.data.local.entity.*+import com.streamvault.domain.model.M3uConfig+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.sync.AutomaticSyncSettings+import dagger.hilt.android.EntryPointAccessors+import kotlinx.coroutines.*+import kotlinx.coroutines.flow.first+import org.json.JSONObject++/** Opt-in real TV-provider publication alongside the normal live PlayerScreen. */+internal class PlaybackPublisherProbe private constructor(+ private val app: Application, private val run: String, private val publish: Boolean,+ private val url: String, private val emit: (JSONObject) -> Unit+) {+ private val graph = EntryPointAccessors.fromApplication(app, XtreamSyncBenchmarkEntryPoint::class.java)+ private val db = graph.database()+ private val prefs = graph.preferences()+ private val work = WorkManager.getInstance(app)+ private val manager = EntryPointAccessors.fromApplication(app, TvInputCatalogRefreshWorker.Entry::class.java)+ .tvInputChannelSyncManager()+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)+ private var task: Deferred<Unit>? = null+ private var providerId = 0L+ private var channelId = 0L+ private var ownsPreferences = false+ private val saved = JSONObject().put("run", run)+ @Suppress("UNCHECKED_CAST")+ private val store = prefs.javaClass.getDeclaredMethod("getPreferencesDataStore").apply { isAccessible = true }+ .invoke(prefs) as DataStore<Preferences>+ private fun persist() = app.filesDir.resolve("publisher-$run-owned.json").writeText(saved.toString(2))+ private fun count(uri: Uri, selection: String? = null, args: Array<String>? = null): Int =+ app.contentResolver.query(uri, arrayOf("_id"), selection, args, null)!!.use { it.count }+ private fun frameworkPrograms() = count(TvContract.Programs.CONTENT_URI)++ private suspend fun prepare() {+ // Publishing refreshes all managed rows; require a clean isolated TV catalog.+ check(db.providerDao().getAllSync().isEmpty()) { "Publisher probe requires an empty provider database" }+ check(count(TvContract.Channels.CONTENT_URI) == 0 && frameworkPrograms() == 0)+ check(!prefs.playerTimeshiftEnabled.first())+ saved.put("lastActiveProvider", store.data.first()[longPreferencesKey("last_active_provider_id")] ?: JSONObject.NULL)+ .put("variantObservation", store.data.first()[stringPreferencesKey("live_variant_observations")] ?: JSONObject.NULL)+ providerId = db.providerDao().insert(ProviderEntity(name = "Publisher fixture $run", type = ProviderType.M3U, isActive = false))+ saved.put("providerId", providerId); persist()+ check(prefs.automaticSyncConfiguration.first().providers[providerId] == null)+ val ownedKeys = setOf("automatic_sync_status_$providerId", "catalog_sync_upgrade_started_$providerId",+ "catalog_sync_engine_$providerId", "last_live_category_id_$providerId")+ check(store.data.first().asMap().keys.none { it.name in ownedKeys }) { "Fixture preference key already exists" }+ ownsPreferences = true+ prefs.setAutomaticSyncSettings(providerId, AutomaticSyncSettings(enabled = false, live = false, movies = false, series = false, epg = false))+ db.providerSnapshotDao().commitConfiguration(ProviderConfigEntity(providerId = providerId, type = ProviderType.M3U,+ schemaVersion = 1, configurationGeneration = 1, identityKey = "publisher-$run",+ encryptedConfigJson = com.google.gson.Gson().toJson(M3uConfig(playlistUrl = url.substringBefore("/live/") + "/unused.m3u")),+ updatedAt = System.currentTimeMillis()))+ db.channelDao().insertAll((1..2000).map { i -> ChannelEntity(providerId = providerId, streamId = i.toLong(),+ name = "Publisher channel $i", number = i, epgChannelId = "publisher-$i", streamUrl = url) })+ channelId = db.channelDao().getByProviderSync(providerId).single { it.streamId == 1L }.id+ saved.put("channelId", channelId); persist()+ val start = System.currentTimeMillis() / 3_600_000L * 3_600_000L - 3_600_000L+ for (chunk in (1..2000).chunked(100)) {+ db.programDao().insertAll(chunk.flatMap { i -> (0..23).map { j -> ProgramEntity(providerId = providerId,+ channelId = "publisher-$i", title = "Publisher programme $i/$j", description = "Fixture schedule entry $i/$j",+ startTime = start + j * 1_800_000L, endTime = start + (j + 1) * 1_800_000L) } })+ }+ db.providerDao().setActive(providerId)+ manager.refreshTvInputCatalogResult().getOrThrow()+ check(count(TvContract.Channels.CONTENT_URI) == 2000 && frameworkPrograms() == 48000)+ emit(JSONObject().put("event", "publisher-prepared").put("providerId", providerId)+ .put("channels", 2000).put("programs", 48000).put("publishArm", publish))+ }++ fun navigation() = PlayerNavigationRequest(streamUrl = url, title = "Publisher live fixture $run",+ channelId = "publisher-1", internalId = channelId, providerId = providerId, contentType = "LIVE")++ suspend fun awaitBaselineReady() {+ // Serialize behind startup's refresh; complete the same no-op pass in both arms.+ manager.refreshTvInputCatalogResult().getOrThrow()+ delay(2_000)+ emit(JSONObject().put("event", "publisher-baseline-ready").put("frameworkPrograms", frameworkPrograms()))+ }++ fun playbackReady() {+ check(task == null)+ check(com.streamvault.domain.sync.AutomaticSyncActivity.hasPlayback)+ task = scope.async {+ delay(10_000)+ emit(JSONObject().put("event", "publisher-guide-update-begin").put("publishArm", publish))+ db.openHelper.writableDatabase.execSQL("UPDATE programs SET title = title || ' revised' WHERE provider_id = ?", arrayOf(providerId))+ emit(JSONObject().put("event", "publisher-guide-update-end").put("rows", db.programDao().countByProvider(providerId)))+ if (publish) {+ val previous = work.getWorkInfosForUniqueWork("tv-input-catalog-refresh").get()+ check(previous.none { !it.state.isFinished }) { "Unrelated publication already running" }+ TvInputCatalogRefreshWorker.enqueue(app)+ val info = withTimeout(10_000) {+ var created: WorkInfo? = null+ while (created == null) {+ created = work.getWorkInfosForUniqueWork("tv-input-catalog-refresh").get()+ .singleOrNull { row -> previous.none { it.id == row.id } }+ if (created == null) delay(50)+ }+ created+ }+ val workerId = checkNotNull(info).id+ saved.put("workerId", workerId.toString()); persist()+ emit(JSONObject().put("event", "publisher-work-enqueue").put("workerId", workerId))+ withTimeout(300_000) {+ while (true) {+ val info = work.getWorkInfoById(workerId).get()+ if (info != null && info.state.isFinished) {+ check(info.state == WorkInfo.State.SUCCEEDED) { "Publisher worker ended ${info.state}" }+ break+ }+ delay(200)+ }+ }+ emit(JSONObject().put("event", "publisher-work-complete").put("workerId", workerId)+ .put("frameworkPrograms", frameworkPrograms()))+ } else emit(JSONObject().put("event", "publisher-control-no-publication"))+ }+ }++ suspend fun finishWhilePlaying() {+ task?.await()+ check(frameworkPrograms() == 48000)+ val changed = app.contentResolver.query(TvContract.Programs.CONTENT_URI, arrayOf("title"),+ null, null, null)!!.use { cursor ->+ var revised = 0+ while (cursor.moveToNext()) if (cursor.getString(0).endsWith(" revised")) revised+++ revised+ }+ check(changed == if (publish) 48000 else 0) { "Unexpected framework revision count $changed" }+ emit(JSONObject().put("event", "publisher-verified").put("frameworkRevisedPrograms", changed).put("publishArm", publish))+ }++ suspend fun close() {+ task?.cancelAndJoin(); scope.cancel()+ if (saved.has("workerId")) work.cancelWorkById(java.util.UUID.fromString(saved.getString("workerId"))).result.get()+ if (providerId == 0L) return+ check(db.providerDao().getById(providerId)?.name == "Publisher fixture $run")+ if (!ownsPreferences) {+ // Guard failed before any config/channel/preferences were created. Remove+ // only the newly inserted row; repository runtime cleanup could erase the+ // stale preference key which caused the preflight refusal.+ db.providerDao().delete(providerId)+ return+ }+ val deleted = graph.providers().deleteProvider(providerId)+ check(deleted is com.streamvault.domain.model.Result.Success && db.providerDao().getById(providerId) == null)+ db.providerDao().deactivateAll()+ manager.refreshTvInputCatalogResult().getOrThrow()+ prefs.setAutomaticSyncSettings(providerId, null)+ store.edit { values ->+ values.remove(stringPreferencesKey("automatic_sync_status_$providerId"))+ values.remove(longPreferencesKey("catalog_sync_upgrade_started_$providerId"))+ values.remove(intPreferencesKey("catalog_sync_engine_$providerId"))+ values.remove(longPreferencesKey("last_live_category_id_$providerId"))+ val active = longPreferencesKey("last_active_provider_id")+ if (values[active] == providerId) {+ if (saved.isNull("lastActiveProvider")) values.remove(active) else values[active] = saved.getLong("lastActiveProvider")+ }+ val key = stringPreferencesKey("live_variant_observations")+ val remaining = values[key].orEmpty().lineSequence().filter { it.isNotEmpty() && it.substringBefore('|').toLongOrNull() != channelId }.toList()+ val before = if (saved.isNull("variantObservation")) null else saved.getString("variantObservation")+ if (remaining == before.orEmpty().lineSequence().filter(String::isNotEmpty).toList()) {+ if (before == null) values.remove(key) else values[key] = before+ } else values[key] = remaining.joinToString("\n")+ }+ emit(JSONObject().put("event", "publisher-cleanup").put("providerId", providerId)+ .put("frameworkChannels", count(TvContract.Channels.CONTENT_URI)).put("frameworkPrograms", frameworkPrograms()))+ }++ companion object {+ suspend fun start(app: Application, args: Bundle, run: String, emit: (JSONObject) -> Unit): PlaybackPublisherProbe? {+ if (args.getString("publisherFixture") != "true") return null+ check(app.packageName == "com.streamvault.app.debug")+ val urls = requireNotNull(args.getString("fixtureUrls")).split(','); check(urls.size == 1)+ require(Uri.parse(urls.single()).host in setOf("127.0.0.1", "localhost"))+ val probe = PlaybackPublisherProbe(app, run, args.getString("publisherArm") == "publish", urls.single(), emit)+ try { probe.prepare() } catch (error: Throwable) { probe.close(); throw error }+ return probe+ }+ }+}diff --git a/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt b/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.ktindex 8a4aa87c..609361cd 100644--- a/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt+++ b/app/src/main/java/com/streamvault/app/tvinput/StreamVaultTvInputService.kt@@ -161,7 +161,9 @@ class StreamVaultTvInputService : TvInputService() {" bufferedMs=${player.totalBufferedDuration} firstFrame=$firstVideoFrame" +" rendered=${counters?.renderedOutputBufferCount ?: 0}" +" dropped=${counters?.droppedBufferCount ?: 0}" +- " error=${player.playerError?.errorCode}")+ " error=${player.playerError?.errorCode}" ++ " owned=${tunedProviderId?.let { AutomaticSyncActivity.isProviderPlaybackActive(it) } ?: false}" ++ " globalOwned=${AutomaticSyncActivity.hasPlayback}")}if (surfaceRecovery.isPending) {when (surfaceRecovery.evaluate(@@ -291,7 +293,8 @@ class StreamVaultTvInputService : TvInputService() {endRecoveryGeneration = nullscope.cancel()player.release()- if (Log.isLoggable(TAG, Log.DEBUG)) Log.d(TAG, "lifecycle event=release-end")+ if (Log.isLoggable(TAG, Log.DEBUG)) Log.d(TAG,+ "lifecycle event=release-end owned=${tunedProviderId?.let { AutomaticSyncActivity.isProviderPlaybackActive(it) } ?: false} globalOwned=${AutomaticSyncActivity.hasPlayback}")}private suspend fun tune(channelUri: Uri, generation: Long) {diff --git a/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt b/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.ktindex a53bb5e1..706bfc49 100644--- a/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt+++ b/app/src/main/java/com/streamvault/app/tvinput/TvInputChannelSyncManager.kt@@ -160,20 +160,22 @@ class TvInputChannelSyncManager @Inject constructor(private fun loadExistingPrograms(channelIds: Set<Long>): Map<String, Long> {if (channelIds.isEmpty()) return emptyMap()val result = linkedMapOf<String, Long>()- channelIds.chunked(PROGRAM_QUERY_CHANNEL_CHUNK_SIZE).forEach { chunk ->- val placeholders = chunk.joinToString(",") { "?" }- context.contentResolver.query(- TvContract.Programs.CONTENT_URI,- arrayOf(BaseColumns._ID, PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA),- "$PROGRAM_COLUMN_CHANNEL_ID IN ($placeholders)",- chunk.map(Long::toString).toTypedArray(),- null- )?.use { cursor ->- val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)- val dataIndex = cursor.getColumnIndexOrThrow(PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA)- while (cursor.moveToNext()) {- cursor.getString(dataIndex)?.let { result[it] = cursor.getLong(idIndex) }- }+ // TvProvider rejects SQL selection for ordinary TV inputs. It already scopes+ // this query to our package; filter the replaceable channels in one cursor+ // instead of sending an unsupported IN clause (or one Binder call/channel).+ context.contentResolver.query(+ TvContract.Programs.CONTENT_URI,+ arrayOf(BaseColumns._ID, PROGRAM_COLUMN_CHANNEL_ID, PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA),+ null,+ null,+ null+ )?.use { cursor ->+ val idIndex = cursor.getColumnIndexOrThrow(BaseColumns._ID)+ val channelIdIndex = cursor.getColumnIndexOrThrow(PROGRAM_COLUMN_CHANNEL_ID)+ val dataIndex = cursor.getColumnIndexOrThrow(PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA)+ while (cursor.moveToNext()) {+ if (cursor.getLong(channelIdIndex) !in channelIds) continue+ cursor.getString(dataIndex)?.let { result[it] = cursor.getLong(idIndex) }}}return result@@ -310,7 +312,6 @@ class TvInputChannelSyncManager @Inject constructor(const val PROGRAM_COLUMN_END_TIME_UTC_MILLIS = "end_time_utc_millis"const val PROGRAM_COLUMN_INTERNAL_PROVIDER_DATA = "internal_provider_data"const val EPG_QUERY_CHUNK_SIZE = 200- const val PROGRAM_QUERY_CHANNEL_CHUNK_SIZE = 500const val CONTENT_PROVIDER_BATCH_SIZE = 200const val MAX_PROGRAMS_PER_CHANNEL = 24const val PROGRAM_LOOKBACK_MS = 3 * 60 * 60 * 1000Ldiff --git a/app/src/test/java/com/streamvault/app/tvinput/TvInputProgramQueryTest.kt b/app/src/test/java/com/streamvault/app/tvinput/TvInputProgramQueryTest.ktnew file mode 100644index 00000000..e68e7076--- /dev/null+++ b/app/src/test/java/com/streamvault/app/tvinput/TvInputProgramQueryTest.kt@@ -0,0 +1,150 @@+package com.streamvault.app.tvinput++import android.content.ContentProvider+import android.content.ContentValues+import android.content.pm.ProviderInfo+import android.database.Cursor+import android.database.MatrixCursor+import android.media.tv.TvContract+import android.net.Uri+import android.provider.BaseColumns+import com.streamvault.domain.repository.ChannelRepository+import com.streamvault.domain.repository.EpgRepository+import com.streamvault.domain.repository.ProviderRepository+import org.junit.Assert.assertEquals+import org.junit.Assert.assertNull+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment+import org.robolectric.annotation.Config+import org.robolectric.shadows.ShadowContentResolver+import org.mockito.kotlin.mock++@RunWith(RobolectricTestRunner::class)+@Config(sdk = [35])+class TvInputProgramQueryTest {+ private lateinit var provider: SelectionRejectingTvProgramsProvider+ private lateinit var manager: TvInputChannelSyncManager++ @Before+ fun setUp() {+ val context = RuntimeEnvironment.getApplication()+ provider = SelectionRejectingTvProgramsProvider()+ provider.attachInfo(context, ProviderInfo().apply { authority = TvContract.AUTHORITY })+ ShadowContentResolver.registerProviderInternal(TvContract.AUTHORITY, provider)+ manager = TvInputChannelSyncManager(+ context = context,+ providerRepository = mock<ProviderRepository>(),+ channelRepository = mock<ChannelRepository>(),+ epgRepository = mock<EpgRepository>()+ )+ }++ @Test+ fun loadExistingPrograms_usesNullSelectionAndKeepsOnlyEligibleRowsWithFingerprints() {+ provider.rows = listOf(+ ProgramRow(id = 11L, channelId = 5L, fingerprint = "eligible-5"),+ ProgramRow(id = 12L, channelId = 7L, fingerprint = null),+ ProgramRow(id = 13L, channelId = 999L, fingerprint = "other-channel"),+ ProgramRow(id = 14L, channelId = 7L, fingerprint = "eligible-7")+ )++ val actual = manager.loadExistingProgramsForTest(setOf(5L, 7L))++ assertEquals(mapOf("eligible-5" to 11L, "eligible-7" to 14L), actual)+ assertEquals(1, provider.queryCount)+ assertNull(provider.lastSelection)+ assertEquals(+ listOf(BaseColumns._ID, "channel_id", "internal_provider_data"),+ provider.lastProjection?.toList()+ )+ }++ @Test+ fun loadExistingPrograms_emptyChannelSetSkipsProviderQuery() {+ assertEquals(emptyMap<String, Long>(), manager.loadExistingProgramsForTest(emptySet()))+ assertEquals(0, provider.queryCount)+ }++ @Test+ fun loadExistingPrograms_manyChannelIdsStillUsesOneSelectionFreeQuery() {+ provider.rows = listOf(+ ProgramRow(id = 1L, channelId = 1L, fingerprint = "first"),+ ProgramRow(id = 2L, channelId = 1200L, fingerprint = "last"),+ ProgramRow(id = 3L, channelId = 1201L, fingerprint = "outside")+ )++ val actual = manager.loadExistingProgramsForTest((1L..1200L).toSet())++ assertEquals(mapOf("first" to 1L, "last" to 2L), actual)+ assertEquals(1, provider.queryCount)+ assertNull(provider.lastSelection)+ }++ private fun TvInputChannelSyncManager.loadExistingProgramsForTest(+ channelIds: Set<Long>+ ): Map<String, Long> {+ val method = javaClass.getDeclaredMethod("loadExistingPrograms", Set::class.java)+ method.isAccessible = true+ @Suppress("UNCHECKED_CAST")+ return method.invoke(this, channelIds) as Map<String, Long>+ }++ private data class ProgramRow(+ val id: Long,+ val channelId: Long,+ val fingerprint: String?+ )++ /** Models TvProvider's rejection of SQL selection on this public programs URI. */+ private class SelectionRejectingTvProgramsProvider : ContentProvider() {+ var rows: List<ProgramRow> = emptyList()+ var queryCount: Int = 0+ var lastSelection: String? = null+ var lastProjection: Array<out String>? = null++ override fun onCreate(): Boolean = true++ override fun query(+ uri: Uri,+ projection: Array<out String>?,+ selection: String?,+ selectionArgs: Array<out String>?,+ sortOrder: String?+ ): Cursor {+ queryCount+++ lastSelection = selection+ lastProjection = projection+ if (selection != null) {+ throw SecurityException("Selection not allowed for $uri")+ }+ val columns = projection ?: arrayOf(+ BaseColumns._ID,+ "channel_id",+ "internal_provider_data"+ )+ return MatrixCursor(columns).apply {+ rows.forEach { row ->+ addRow(arrayOf(row.id, row.channelId, row.fingerprint))+ }+ }+ }++ override fun getType(uri: Uri): String? = null++ override fun insert(uri: Uri, values: ContentValues?): Uri? =+ error("Insert is not used by this query regression test")++ override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int =+ error("Delete is not used by this query regression test")++ override fun update(+ uri: Uri,+ values: ContentValues?,+ selection: String?,+ selectionArgs: Array<out String>?+ ): Int = error("Update is not used by this query regression test")+ }+}diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 06805c28..1c15ffd9 100644--- a/docs/CHANGELOG.md+++ b/docs/CHANGELOG.md@@ -16,6 +16,7 @@ All notable product changes are recorded in this document.- Improved playback interruption diagnostics to distinguish rebuffering from dropped frames and track interruption durations more accurately.### Fixed+- Fixed Android TV guide publication failing when the platform rejects SQL filters on programme queries.- Fixed eligible live MPEG-TS channels remaining unavailable after an Android TV-input video surface was recreated; playback now makes one safe recovery attempt.- Fixed interrupted Stalker guide downloads being marked fresh and losing automatic retry; useful partial guide data is retained until a complete refresh succeeds.- Fixed automatic guide refreshes stopping after temporary HTTP errors such as 429 and 503; they now retain cached guide data and retry, while authentication failures remain terminal.