StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktnew file mode 100644index 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.ktnew file mode 100644index 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()+ }+ }+}