Skip to content

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

test(playback): add runtime probes for provider movie candidates and playback locations

David Nashash540ec30cc79d
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPairProbeRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPairProbeRuntimeTest.kt
new file mode 100644
index 00000000..77bf0f17
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPairProbeRuntimeTest.kt
@@ -0,0 +1,75 @@
+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 com.streamvault.domain.model.Movie
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import dagger.hilt.internal.GeneratedComponentManager
+import java.net.URI
+import javax.inject.Provider
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Read-only discovery probe for a real provider's duplicate movie candidates. */
+@RunWith(AndroidJUnit4::class)
+class V6aProviderPairProbeRuntimeTest {
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+
+ private fun component(name: String): Any {
+ val generated = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (generated.javaClass.getDeclaredField(name).apply { isAccessible = true }
+ .get(generated) as Provider<*>).get()!!
+ }
+
+ @Test
+ fun discoverDuplicateMovieCandidates() = runBlocking {
+ assumeTrue(InstrumentationRegistry.getArguments().getString("v6aProviderProbe") == "true")
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val activeId = providers.getActiveProvider().first()?.id ?: error("No active provider")
+ val all = movies.getMovies(activeId).first()
+ val candidates = all
+ .groupBy { logicalKey(it) }
+ .values
+ .filter { group -> group.size >= 2 && group.mapNotNull { it.containerExtension?.lowercase() }.toSet().size >= 2 }
+ .sortedWith(compareByDescending<List<Movie>> { it.mapNotNull(Movie::containerExtension).toSet().size }.thenByDescending { it.size })
+ .take(12)
+
+ Log.i("V6aProviderProbe", "activeProvider=$activeId movies=${all.size} groups=${candidates.size}")
+ check(candidates.isNotEmpty()) { "No same-title candidates with distinct containers" }
+ candidates.forEachIndexed { index, group ->
+ val rows = group.take(4).map { movie ->
+ val detail = movies.getMovieDetails(activeId, movie.id).getOrNull() ?: movie
+ val stream = movies.getStreamInfo(detail).getOrNull()
+ val variants = movies.getMovieVariants(movie.id)
+ val safeLocation = stream?.url?.let(::safeLocation) ?: "unresolved"
+ "id=${movie.id},stream=${movie.streamId},ext=${detail.containerExtension},duration=${detail.durationSeconds},year=${detail.year},type=${stream?.streamType},location=$safeLocation,variants=${variants.size}"
+ }
+ Log.i("V6aProviderProbe", "candidate[$index] key=${logicalKey(group.first())} ${rows.joinToString(" || ")}")
+ }
+ }
+
+ private fun logicalKey(movie: Movie): String = buildString {
+ append(movie.name.trim().lowercase())
+ append('|')
+ append(movie.year ?: Regex("(19|20)\\d{2}").find(movie.name)?.value.orEmpty())
+ }
+
+ private fun safeLocation(url: String): String = runCatching {
+ val uri = URI(url)
+ buildString {
+ append(uri.scheme ?: "<scheme>")
+ append("://")
+ append(uri.host ?: "<host>")
+ if (uri.port >= 0) append(':').append(uri.port)
+ append(uri.path ?: "")
+ }
+ }.getOrDefault("<unparseable>")
+}
diff --git a/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPlaybackProbeRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPlaybackProbeRuntimeTest.kt
new file mode 100644
index 00000000..ba35d9c6
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/ui/V6aProviderPlaybackProbeRuntimeTest.kt
@@ -0,0 +1,95 @@
+package com.streamvault.app.ui
+
+import android.app.Activity
+import android.app.Application
+import android.os.SystemClock
+import androidx.test.core.app.ActivityScenario
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.streamvault.app.MainActivity
+import com.streamvault.domain.model.PlaybackContentKind
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.ProviderRepository
+import com.streamvault.player.PlaybackState
+import com.streamvault.player.PlayerEngine
+import dagger.hilt.internal.GeneratedComponentManager
+import java.util.concurrent.atomic.AtomicReference
+import javax.inject.Provider
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Short, read-only playback probe for candidate locations on the active provider. */
+@RunWith(AndroidJUnit4::class)
+class V6aProviderPlaybackProbeRuntimeTest {
+ private val app get() = ApplicationProvider.getApplicationContext<Application>()
+
+ private fun component(name: String): Any {
+ val generated = (app as GeneratedComponentManager<*>).generatedComponent()
+ return (generated.javaClass.getDeclaredField(name).apply { isAccessible = true }
+ .get(generated) as Provider<*>).get()!!
+ }
+
+ @Test
+ fun probeCandidateLocations() = runBlocking {
+ assumeTrue(InstrumentationRegistry.getArguments().getString("v6aProviderProbe") == "true")
+ val ids = requireNotNull(InstrumentationRegistry.getArguments().getString("v6aMovieIds"))
+ .split(',').map(String::trim).filter(String::isNotEmpty).map(String::toLong)
+ require(ids.size in 2..4)
+ val providers = component("providerRepositoryImplProvider") as ProviderRepository
+ val movies = component("movieRepositoryImplProvider") as MovieRepository
+ val providerId = providers.getActiveProvider().first()?.id ?: error("No active provider")
+ val engine = component("provideMainPlayerEngineProvider") as PlayerEngine
+ val instrumentation = InstrumentationRegistry.getInstrumentation()
+ val scenario = ActivityScenario.launch(MainActivity::class.java)
+ var render: android.view.View? = null
+ scenario.onActivity { activity: Activity ->
+ render = engine.createRenderView(activity, com.streamvault.player.PlayerSurfaceResizeMode.FIT)
+ activity.setContentView(render)
+ engine.bindRenderView(render!!, com.streamvault.player.PlayerSurfaceResizeMode.FIT)
+ }
+ try {
+ for (id in ids) {
+ val movie = movies.getMovie(id) ?: error("Missing movie $id")
+ val detail = movies.getMovieDetails(providerId, id).getOrNull() ?: movie
+ val source = movies.getStreamInfo(detail).getOrNull() ?: error("Unresolved movie $id")
+ val started = SystemClock.elapsedRealtime()
+ val main = { action: () -> Unit -> instrumentation.runOnMainSync(action) }
+ main {
+ engine.prepare(source.copy(
+ title = detail.name,
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ ))
+ engine.play()
+ }
+ val result = runCatching {
+ withTimeout(45_000) {
+ while (engine.playerStats.value.ttffMs <= 0L ||
+ engine.playbackState.value != PlaybackState.READY || !engine.isPlaying.value
+ ) delay(100)
+ }
+ val stats = engine.playerStats.value
+ "id=$id,stream=${movie.streamId},name=${detail.name},ext=${detail.containerExtension},duration=${detail.durationSeconds}," +
+ "codec=${stats.videoCodec},audio=${stats.audioCodec},size=${stats.width}x${stats.height},bitrate=${stats.videoBitrate}," +
+ "ttff=${stats.ttffMs},elapsed=${SystemClock.elapsedRealtime() - started},state=${engine.playbackState.value}"
+ }.getOrElse { error ->
+ "id=$id,stream=${movie.streamId},name=${detail.name},ext=${detail.containerExtension},error=${error.javaClass.simpleName}:${error.message}"
+ }
+ android.util.Log.i("V6aProviderPlayback", result)
+ main { engine.stop() }
+ SystemClock.sleep(1_000)
+ }
+ } finally {
+ instrumentation.runOnMainSync {
+ engine.release()
+ render?.let { engine.releaseRenderView(it) }
+ }
+ scenario.close()
+ }
+ }
+}