Skip to content

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

Merge branch 'pr-64-review' into develop

David Nashashba5527ffe766
diff --cc data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
index 648e977e,d184c14c..59a37173
--- a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
@@@ -67,7 -63,7 +67,8 @@@ class XtreamStreamUrlResolverTest
}
@Test
-- fun resolveWithMetadata_prefers_allowed_direct_source_for_vod() = runBlocking {
++ fun resolveWithMetadata_prefers_allowed_direct_source_for_vod() {
++ runBlocking {
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
ProviderEntity(
@@@ -94,10 -90,10 +95,12 @@@
assertThat(resolved?.url).isEqualTo("http://edge.example.com/movie/456/index.mp4?exp=1774017000")
assertThat(resolved?.expirationTime).isEqualTo(1_774_017_000_000L)
++ }
}
@Test
-- fun resolveWithMetadata_ignores_live_direct_source_and_uses_portal_url() = runBlocking {
++ fun resolveWithMetadata_ignores_live_direct_source_and_uses_portal_url() {
++ runBlocking {
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
ProviderEntity(
@@@ -126,12 -120,10 +129,14 @@@
assertThat(resolved?.url).isEqualTo("https://portal.example.com/live/alice/secret/456.ts")
assertThat(resolved?.expirationTime).isNull()
+ assertThat(resolved?.userAgent).isEqualTo("ProviderAgent/2.0")
+ assertThat(resolved?.headers).containsEntry("Referer", "https://portal.example.com/player")
++ }
}
@Test
-- fun resolveWithMetadata_ignores_unsupported_direct_source_scheme() = runBlocking {
++ fun resolveWithMetadata_ignores_unsupported_direct_source_scheme() {
++ runBlocking {
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
ProviderEntity(
@@@ -157,36 -149,6 +162,39 @@@
val resolved = resolver.resolveWithMetadata(url)
assertThat(resolved?.url).isEqualTo("https://portal.example.com/live/alice/secret/456.m3u8")
++ }
+ }
+
+ @Test
- fun resolveWithMetadata_applies_provider_request_profile_to_direct_m3u_urls() = runBlocking {
++ fun resolveWithMetadata_applies_provider_request_profile_to_direct_m3u_urls() {
++ runBlocking {
+ val resolver = XtreamStreamUrlResolver(
+ providerDao = FakeProviderDao(
+ ProviderEntity(
+ id = 21,
+ name = "Playlist",
+ type = ProviderType.M3U,
+ serverUrl = "https://playlist.example.com",
+ httpUserAgent = "PlaylistAgent/5.0",
+ httpHeaders = "Referer: https://playlist.example.com/app | Origin: https://playlist.example.com"
+ )
+ ),
+ credentialCrypto = credentialCrypto,
+ stalkerApiService = stalkerApiService
+ )
+
+ val resolved = resolver.resolveWithMetadata(
+ url = "https://cdn.example.com/live/news/index.m3u8",
+ fallbackProviderId = 21
+ )
+
+ assertThat(resolved?.url).isEqualTo("https://cdn.example.com/live/news/index.m3u8")
+ assertThat(resolved?.userAgent).isEqualTo("PlaylistAgent/5.0")
+ assertThat(resolved?.headers).containsExactly(
+ "Referer", "https://playlist.example.com/app",
+ "Origin", "https://playlist.example.com"
+ )
++ }
}
@Test
@@@ -217,7 -179,7 +225,8 @@@
}
@Test
-- fun resolveWithMetadata_resolves_stalker_internal_url_via_cached_provider() = runBlocking {
++ fun resolveWithMetadata_resolves_stalker_internal_url_via_cached_provider() {
++ runBlocking {
val fakeStalkerApiService = FakeStalkerApiService()
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
@@@ -262,10 -224,10 +271,12 @@@
assertThat(secondResolved?.url).isEqualTo("http://edge.example.com/live/77.m3u8")
assertThat(fakeStalkerApiService.authenticateCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(0)
++ }
}
@Test
-- fun resolveWithMetadata_uses_direct_stalker_absolute_cmd_without_create_link() = runBlocking {
++ fun resolveWithMetadata_uses_direct_stalker_absolute_cmd_without_create_link() {
++ runBlocking {
val fakeStalkerApiService = FakeStalkerApiService()
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
@@@ -300,10 -262,10 +311,12 @@@
assertThat(resolved?.userAgent).contains("MAG250 stbapp")
assertThat(fakeStalkerApiService.authenticateCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(0)
++ }
}
@Test
-- fun resolveWithMetadata_uses_wrapped_direct_stalker_live_cmd_without_create_link() = runBlocking {
++ fun resolveWithMetadata_uses_wrapped_direct_stalker_live_cmd_without_create_link() {
++ runBlocking {
val fakeStalkerApiService = FakeStalkerApiService().apply {
createLinkResponse = "http://line.trxdnscloud.ru/play/live.php?mac=00:1A:79:40:8B:D7&stream=&extension=ts&play_token=broken"
}
@@@ -337,14 -299,14 +350,16 @@@
"http://line.trxdnscloud.ru/play/live.php?mac=00:1A:79:40:8B:D7&stream=978715&extension=ts&play_token=R7KbxtDJj3"
)
assertThat(resolved?.headers?.get("Referer")).isEqualTo("https://portal.example.com/c/")
-- assertThat(resolved?.headers?.get("Authorization")).isEqualTo("Bearer token")
++ assertThat(resolved?.headers?.get("Authorization")).isNull()
assertThat(resolved?.userAgent).contains("MAG250 stbapp")
assertThat(fakeStalkerApiService.authenticateCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(0)
++ }
}
@Test
-- fun resolveWithMetadata_passes_stalker_episode_series_selector_to_create_link() = runBlocking {
++ fun resolveWithMetadata_passes_stalker_episode_series_selector_to_create_link() {
++ runBlocking {
val fakeStalkerApiService = FakeStalkerApiService().apply {
createLinkResponse = "http://portal.example.com/play/movie.php?stream=1672828.mkv"
}
@@@ -379,62 -341,10 +394,66 @@@
assertThat(fakeStalkerApiService.authenticateCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.lastCreateLinkSeriesNumber).isEqualTo(11)
++ }
+ }
+
+ @Test
- fun resolveWithMetadata_uses_ranked_stalker_multi_command_candidates() = runBlocking {
++ fun resolveWithMetadata_uses_ranked_stalker_multi_command_candidates() {
++ runBlocking {
+ val fakeStalkerApiService = FakeStalkerApiService()
+ val resolver = XtreamStreamUrlResolver(
+ providerDao = FakeProviderDao(
+ ProviderEntity(
+ id = 14,
+ name = "Stalker",
+ type = ProviderType.STALKER_PORTAL,
+ serverUrl = "https://portal.example.com",
+ stalkerMacAddress = "00:1A:79:12:34:56",
+ stalkerDeviceProfile = "MAG250",
+ stalkerDeviceTimezone = "UTC",
+ stalkerDeviceLocale = "en"
+ )
+ ),
+ credentialCrypto = credentialCrypto,
+ stalkerApiService = fakeStalkerApiService
+ )
+ val descriptor = StalkerPlaybackDescriptor(
+ primaryMode = StalkerPlaybackMode.MULTI_CMD,
+ candidates = listOf(
+ StalkerCommandVariant(
+ cmd = "ffmpeg http://localhost/ch/77_",
+ playbackMode = StalkerPlaybackMode.LOCALHOST_CMD,
+ sourceKey = "cmd",
+ priority = 2
+ ),
+ StalkerCommandVariant(
+ cmd = "http://edge.example.com/live/77.m3u8",
+ playbackMode = StalkerPlaybackMode.DIRECT_URL,
+ sourceKey = "cmd_1",
+ priority = 1
+ )
+ ),
+ capabilities = StalkerPortalCapabilities()
+ )
+ val internalUrl = StalkerUrlFactory.buildInternalStreamUrl(
+ providerId = 14,
+ kind = StalkerStreamKind.LIVE,
+ itemId = 77,
+ cmd = "ffmpeg http://localhost/ch/77_",
+ containerExtension = "ts",
+ playbackDescriptor = descriptor
+ )
+
+ val resolved = resolver.resolveWithMetadata(internalUrl)
+
+ assertThat(resolved?.url).isEqualTo("http://edge.example.com/live/77.m3u8")
+ assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(0)
++ }
}
@Test
-- fun resolveWithMetadata_repairs_stale_direct_stalker_live_url_and_applies_headers() = runBlocking {
++ fun resolveWithMetadata_repairs_stale_direct_stalker_live_url_and_applies_headers() {
++ runBlocking {
val fakeStalkerApiService = FakeStalkerApiService()
val resolver = XtreamStreamUrlResolver(
providerDao = FakeProviderDao(
@@@ -465,10 -375,10 +484,11 @@@
"http://portal.example.com/play/live.php?mac=00:1A:79:12:34:56&stream=978715&extension=ts&play_token=abc123"
)
assertThat(resolved?.headers?.get("Referer")).isEqualTo("https://portal.example.com/c/")
-- assertThat(resolved?.headers?.get("Authorization")).isEqualTo("Bearer token")
++ assertThat(resolved?.headers?.get("Authorization")).isNull()
assertThat(resolved?.userAgent).contains("MAG250 stbapp")
assertThat(fakeStalkerApiService.authenticateCalls).isEqualTo(1)
assertThat(fakeStalkerApiService.createLinkCalls).isEqualTo(0)
++ }
}
private class FakeProviderDao(
diff --cc player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
index 803ae6e4,f7a3b865..ac5f3183
--- a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt
@@@ -9,18 -11,22 +11,27 @@@ import com.streamvault.domain.model.Str
import java.net.URI
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.TimeUnit
+import okhttp3.Interceptor
import okhttp3.OkHttpClient
+ import okhttp3.Protocol
+ @UnstableApi
class PlayerDataSourceFactoryProvider(
private val context: Context,
private val baseClient: OkHttpClient
) {
+ private companion object {
+ private const val TAG = "PlayerDataSource"
+ }
+
- private val clientsByProfile = ConcurrentHashMap<PlayerTimeoutProfile, OkHttpClient>()
+ private data class ClientKey(
+ val profile: PlayerTimeoutProfile,
+ val forceHttp1: Boolean,
+ val port: Int
+ )
+
+ private val addressHealthStore = PlayerAddressHealthStore()
+ private val clientsByKey = ConcurrentHashMap<ClientKey, OkHttpClient>()
fun createFactory(
streamInfo: StreamInfo,
@@@ -29,10 -36,13 +41,15 @@@
): Pair<PlayerTimeoutProfile, DataSource.Factory> {
val profile = PlayerTimeoutProfile.resolve(streamInfo, resolvedStreamType, preload)
val headers = streamInfo.headers
+ logRequestShape(streamInfo, headers, preload)
- val client = clientsByProfile.computeIfAbsent(profile) {
+ val forceHttp1 = PlayerHttpProtocolPolicy.forceHttp1(
+ resolvedStreamType = resolvedStreamType,
+ vodHttpProtocolMode = vodHttpProtocolMode
+ )
+ val port = streamPort(streamInfo.url)
+ val client = clientsByKey.computeIfAbsent(ClientKey(profile, forceHttp1, port)) {
baseClient.newBuilder()
+ .addInterceptor(StalkerPlaybackRequestLoggingInterceptor)
.connectTimeout(profile.connectTimeoutMs, TimeUnit.MILLISECONDS)
.readTimeout(profile.readTimeoutMs, TimeUnit.MILLISECONDS)
.writeTimeout(profile.writeTimeoutMs, TimeUnit.MILLISECONDS)
@@@ -48,69 -68,17 +75,78 @@@
return profile to factory
}
+ private fun logRequestShape(
+ streamInfo: StreamInfo,
+ headers: Map<String, String>,
+ preload: Boolean
+ ) {
+ val hasStalkerHeaders = headers.containsKey("X-User-Agent") ||
+ headers.containsKey("Authorization") ||
+ headers["Cookie"]?.contains("mac=", ignoreCase = true) == true
+ if (!hasStalkerHeaders) {
+ return
+ }
+ val uri = runCatching { URI(streamInfo.url) }.getOrNull()
+ Log.d(
+ TAG,
+ "Playback request headers preload=$preload host=${uri?.host.orEmpty()} path=${uri?.path.orEmpty()} " +
+ "ua=${!streamInfo.userAgent.isNullOrBlank()} referer=${headers.containsKey("Referer")} " +
+ "cookie=${headers.containsKey("Cookie")} auth=${headers.containsKey("Authorization")} " +
+ "xua=${headers.containsKey("X-User-Agent")}"
+ )
+ }
++
+ private fun streamPort(url: String): Int {
+ val uri = runCatching { URI(url) }.getOrNull()
+ uri?.port?.takeIf { it > 0 }?.let { return it }
+ return when (uri?.scheme?.lowercase()) {
+ "http" -> 80
+ "https" -> 443
+ else -> -1
+ }
+ }
+}
+
+private object StalkerPlaybackRequestLoggingInterceptor : Interceptor {
+ private const val TAG = "PlayerDataSource"
+
+ override fun intercept(chain: Interceptor.Chain): okhttp3.Response {
+ val request = chain.request()
+ if (!request.hasStalkerPlaybackShape()) {
+ return chain.proceed(request)
+ }
+ Log.d(
+ TAG,
+ "Playback request actual method=${request.method} target=${PlaybackLogSanitizer.sanitizeUrl(request.url.toString())} " +
+ "ua=${request.header("User-Agent") != null} referer=${request.header("Referer") != null} " +
+ "cookie=${request.header("Cookie") != null} auth=${request.header("Authorization") != null} " +
+ "xua=${request.header("X-User-Agent") != null} range=${request.header("Range") != null} " +
+ "acceptEncoding=${request.header("Accept-Encoding")?.take(24).orEmpty()} cookieKeys=${request.cookieKeySummary()}"
+ )
+ val response = chain.proceed(request)
+ Log.d(
+ TAG,
+ "Playback response actual target=${PlaybackLogSanitizer.sanitizeUrl(request.url.toString())} " +
+ "code=${response.code} length=${response.header("Content-Length").orEmpty()} " +
+ "type=${response.header("Content-Type").orEmpty()}"
+ )
+ return response
+ }
- private companion object {
- const val TAG = "PlayerDataSourceFactory"
+ private fun okhttp3.Request.hasStalkerPlaybackShape(): Boolean {
+ val path = url.encodedPath.lowercase()
+ return header("X-User-Agent") != null ||
+ header("Authorization") != null ||
+ header("Cookie")?.contains("mac=", ignoreCase = true) == true ||
+ path.endsWith("/play/live.php") ||
+ path.endsWith("/play/movie.php")
+ }
+
+ private fun okhttp3.Request.cookieKeySummary(): String {
+ val cookie = header("Cookie") ?: return ""
+ return cookie.split(';')
+ .mapNotNull { part -> part.substringBefore('=', missingDelimiterValue = "").trim().takeIf(String::isNotBlank) }
+ .take(12)
+ .joinToString("|")
}
}
-
diff --cc player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
index 056900af,c8197dcd..d5de56e7
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
@@@ -115,8 -117,11 +118,12 @@@ class PlayerRetryPolicy
else -> 1
}
- PlaybackErrorCategory.EMPTY_RESPONSE,
- PlaybackErrorCategory.SOURCE_MALFORMED -> if (playbackStarted) 0 else 1
++ PlaybackErrorCategory.EMPTY_RESPONSE -> if (playbackStarted) 0 else 1
+ PlaybackErrorCategory.SOURCE_MALFORMED -> when {
+ streamContext.isLive && playbackStarted -> 3
+ playbackStarted -> 0
+ else -> 1
+ }
PlaybackErrorCategory.UNKNOWN -> if (playbackStarted) 0 else 1
}
}