Skip to content

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

Adapt live preload to provider limits

David Nashash2ae880c19fa1
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerRecoveryActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerRecoveryActions.kt
index c29a69b0..772ca3bf 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerRecoveryActions.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerRecoveryActions.kt
@@ -7,6 +7,7 @@ import com.streamvault.player.PlaybackState
import com.streamvault.player.PlayerError
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
+import java.util.Locale
private const val PROVIDER_AUTH_RETRY_GRACE_MS = 1_200L
@@ -24,6 +25,28 @@ internal fun shouldAttemptProviderAuthRetry(
): Boolean = contentType == ContentType.LIVE &&
(providerType == ProviderType.XTREAM_CODES || providerType == ProviderType.STALKER_PORTAL)
+internal fun shouldCooldownLivePreloadAfterError(message: String?): Boolean {
+ val normalized = message.orEmpty().lowercase(Locale.ROOT)
+ return "401" in normalized ||
+ "403" in normalized ||
+ "429" in normalized ||
+ "509" in normalized ||
+ "forbidden" in normalized ||
+ "unauthorized" in normalized ||
+ "too many" in normalized ||
+ "max connection" in normalized ||
+ "provider limit" in normalized ||
+ "connection limit" in normalized
+}
+
+internal fun PlayerViewModel.cooldownLivePreloadForCurrentProvider(reason: String) {
+ val providerId = currentProviderId.takeIf { it > 0L } ?: return
+ if (livePreloadCooldownProviderIds.add(providerId)) {
+ appendRecoveryAction("Disabled live preload for provider: $reason")
+ playerEngine.preload(null)
+ }
+}
+
internal suspend fun PlayerViewModel.tryRefreshXtreamPlaybackAfterAuthError(
error: PlayerError,
requestVersion: Long,
@@ -51,6 +74,7 @@ internal suspend fun PlayerViewModel.tryRefreshXtreamPlaybackAfterAuthError(
)
)
setLastFailureReason(error.message)
+ cooldownLivePreloadForCurrentProvider("auth or provider-limit response")
appendRecoveryAction("Retrying provider playback from a fresh live URL")
delay(PROVIDER_AUTH_RETRY_GRACE_MS)
if (!isActivePlaybackSession(requestVersion, playbackUrl)) return true
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
index f769cc50..8ce5dff0 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
@@ -240,6 +240,7 @@ class PlayerViewModel @Inject constructor(
internal var hasRetriedWithSoftwareDecoder = false
internal var hasRetriedXtreamAuthRefresh = false
internal val probePassedPlaybackKeys = mutableSetOf<String>()
+ internal val livePreloadCooldownProviderIds = mutableSetOf<Long>()
private val notifiedRecordingFailureIds = mutableSetOf<String>()
internal var lastRecordedLivePlaybackKey: Pair<Long, Long>? = null
private var currentStreamClassLabel: String = "Primary"
@@ -797,6 +798,9 @@ class PlayerViewModel @Inject constructor(
return@launch
}
+ if (shouldCooldownLivePreloadAfterError(error.message)) {
+ cooldownLivePreloadForCurrentProvider("playback error")
+ }
markStreamFailure(currentStreamUrl)
setLastFailureReason(error.message)
logRepositoryFailure(
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerZapActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerZapActions.kt
index 3dccb163..9509e7cb 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerZapActions.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerZapActions.kt
@@ -92,8 +92,18 @@ internal fun releaseOutgoingLiveZapPlayback(
internal fun shouldPreloadAdjacentChannel(
streamUrl: String,
- providerType: ProviderType?
-): Boolean = streamUrl.isNotBlank() && providerType == ProviderType.M3U
+ providerType: ProviderType?,
+ maxConnections: Int,
+ preloadCoolingDown: Boolean
+): Boolean {
+ if (streamUrl.isBlank() || preloadCoolingDown) return false
+ return when (providerType) {
+ ProviderType.M3U -> true
+ ProviderType.XTREAM_CODES,
+ ProviderType.STALKER_PORTAL -> maxConnections >= 2
+ null -> false
+ }
+}
fun PlayerViewModel.playNext() {
clearNumericChannelInput()
@@ -269,8 +279,14 @@ internal fun PlayerViewModel.preloadAdjacentChannel(currentIndex: Int) {
return
}
viewModelScope.launch {
- val providerType = providerRepository.getProvider(nextChannel.providerId)?.type
- if (!shouldPreloadAdjacentChannel(nextChannel.streamUrl, providerType)) {
+ val provider = providerRepository.getProvider(nextChannel.providerId)
+ if (!shouldPreloadAdjacentChannel(
+ streamUrl = nextChannel.streamUrl,
+ providerType = provider?.type,
+ maxConnections = provider?.maxConnections ?: 1,
+ preloadCoolingDown = nextChannel.providerId in livePreloadCooldownProviderIds
+ )
+ ) {
playerEngine.preload(null)
return@launch
}
diff --git a/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt
index 656b43ea..925556a4 100644
--- a/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt
+++ b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt
@@ -31,4 +31,16 @@ class PlayerPlaybackRecoverySupportTest {
assertThat(shouldAttemptProviderAuthRetry(ProviderType.XTREAM_CODES, ContentType.MOVIE)).isFalse()
assertThat(shouldAttemptProviderAuthRetry(ProviderType.STALKER_PORTAL, ContentType.SERIES_EPISODE)).isFalse()
}
+
+ @Test
+ fun `live preload cools down after provider connection errors`() {
+ assertThat(shouldCooldownLivePreloadAfterError("HTTP 403 Forbidden")).isTrue()
+ assertThat(shouldCooldownLivePreloadAfterError("Provider rejected playback, likely max connections or bandwidth limit (HTTP 509).")).isTrue()
+ assertThat(shouldCooldownLivePreloadAfterError("Too many connections")).isTrue()
+ }
+
+ @Test
+ fun `live preload does not cool down after generic decoder error`() {
+ assertThat(shouldCooldownLivePreloadAfterError("Decoder initialization failed")).isFalse()
+ }
}
diff --git a/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerZapActionsTest.kt b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerZapActionsTest.kt
index d53d7a23..278ba565 100644
--- a/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerZapActionsTest.kt
+++ b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerZapActionsTest.kt
@@ -71,7 +71,9 @@ class PlayerZapActionsTest {
fun `shouldPreloadAdjacentChannel skips Stalker internal streams`() {
val shouldPreload = shouldPreloadAdjacentChannel(
streamUrl = "stalker://1/live/99?cmd=ffmpeg%20http%3A%2F%2Fportal.example.com%2Fch%2F99",
- providerType = ProviderType.STALKER_PORTAL
+ providerType = ProviderType.STALKER_PORTAL,
+ maxConnections = 1,
+ preloadCoolingDown = false
)
assertThat(shouldPreload).isFalse()
@@ -81,19 +83,47 @@ class PlayerZapActionsTest {
fun `shouldPreloadAdjacentChannel skips Xtream live streams`() {
val shouldPreload = shouldPreloadAdjacentChannel(
streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.XTREAM_CODES
+ providerType = ProviderType.XTREAM_CODES,
+ maxConnections = 1,
+ preloadCoolingDown = false
)
assertThat(shouldPreload).isFalse()
}
+ @Test
+ fun `shouldPreloadAdjacentChannel allows Xtream streams with spare connection budget`() {
+ val shouldPreload = shouldPreloadAdjacentChannel(
+ streamUrl = "http://cdn.example.com/live/stream.ts",
+ providerType = ProviderType.XTREAM_CODES,
+ maxConnections = 2,
+ preloadCoolingDown = false
+ )
+
+ assertThat(shouldPreload).isTrue()
+ }
+
@Test
fun `shouldPreloadAdjacentChannel allows M3U streams`() {
val shouldPreload = shouldPreloadAdjacentChannel(
streamUrl = "http://cdn.example.com/live/stream.ts",
- providerType = ProviderType.M3U
+ providerType = ProviderType.M3U,
+ maxConnections = 1,
+ preloadCoolingDown = false
)
assertThat(shouldPreload).isTrue()
}
+
+ @Test
+ fun `shouldPreloadAdjacentChannel skips streams while provider preload is cooling down`() {
+ val shouldPreload = shouldPreloadAdjacentChannel(
+ streamUrl = "http://cdn.example.com/live/stream.ts",
+ providerType = ProviderType.XTREAM_CODES,
+ maxConnections = 2,
+ preloadCoolingDown = true
+ )
+
+ assertThat(shouldPreload).isFalse()
+ }
}