Skip to content

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

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.xml
new file mode 100644
index 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.java
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
index 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.PlayerNavigationRequest
import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.feature.playback.player.PlayerViewModel
import 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.closeOverlays
import com.streamvault.player.PlaybackState
import dagger.hilt.internal.GeneratedComponentManager
import javax.inject.Provider
import kotlinx.coroutines.flow.MutableStateFlow
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
@@ -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() ?: 130
require(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? = null
var audioSourceProbe: PlaybackAudioSourceProbe? = null
var audioSourceEngine: com.streamvault.player.PlayerEngine? = null
+ var publisherProbe: PlaybackPublisherProbe? = null
+ var overlayData: PlaybackOverlayDataProbe? = null
try {
+ 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.kt
new file mode 100644
index 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.kt
index 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 null
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/PlaybackOverlayDataProbe.kt b/app/src/androidTest/java/com/streamvault/app/ui/PlaybackOverlayDataProbe.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
index 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 = null
scope.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.kt
index 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 = 500
const val CONTENT_PROVIDER_BATCH_SIZE = 200
const val MAX_PROGRAMS_PER_CHANNEL = 24
const val PROGRAM_LOOKBACK_MS = 3 * 60 * 60 * 1000L
diff --git a/app/src/test/java/com/streamvault/app/tvinput/TvInputProgramQueryTest.kt b/app/src/test/java/com/streamvault/app/tvinput/TvInputProgramQueryTest.kt
new file mode 100644
index 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.md
index 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.