Skip to content

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

fix(playback): select startup policy from playback intent

David Nashash3fc6de407816
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
index 61297b79..0cfd3ef1 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackBufferPolicies.kt
@@ -1,6 +1,7 @@
package com.streamvault.player.playback
import com.streamvault.domain.model.PlaybackBufferMode
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.model.VideoFormat
import java.util.Locale
@@ -105,18 +106,31 @@ internal object PlaybackBufferPolicies {
streamInfo: StreamInfo? = null,
observedVideoFormat: VideoFormat? = null,
qualityReasonOverride: String? = null
- ): PlaybackBufferPolicy = when {
- bufferMode == PlaybackBufferMode.MEDIUM && resolvedStreamType.isLive ->
- mediumLivePolicy(label = "medium-live", qualityReason = "user-medium")
- bufferMode == PlaybackBufferMode.LARGE && resolvedStreamType.isLive ->
- largeLivePolicy(label = "large-live", qualityReason = "user-large")
- bufferMode == PlaybackBufferMode.AUTO && resolvedStreamType == ResolvedStreamType.HLS -> {
+ ): PlaybackBufferPolicy {
+ val kind = streamInfo?.playbackContentKind ?: PlaybackContentKind.UNKNOWN
+ val isLive = isLivePlayback(kind, resolvedStreamType)
+ if (bufferMode == PlaybackBufferMode.MEDIUM && isLive) {
+ return mediumLivePolicy(label = "medium-live", qualityReason = "user-medium")
+ }
+ if (bufferMode == PlaybackBufferMode.LARGE && isLive) {
+ return largeLivePolicy(label = "large-live", qualityReason = "user-large")
+ }
+ if (!isLive && resolvedStreamType == ResolvedStreamType.HLS) {
+ return baselineLivePolicy(
+ resolvedStreamType = resolvedStreamType,
+ compatibilityMode = compatibilityMode,
+ lowMemoryDevice = lowMemoryDevice,
+ isLive = true
+ ).copy(label = "vod-hls-initial", qualityReason = "finite-content")
+ }
+ if (bufferMode == PlaybackBufferMode.AUTO && resolvedStreamType == ResolvedStreamType.HLS) {
val qualityReason = qualityReasonOverride ?: highQualityLiveHlsReason(streamInfo, observedVideoFormat)
- when {
+ return when {
qualityReason == null -> baselineLivePolicy(
resolvedStreamType = resolvedStreamType,
compatibilityMode = compatibilityMode,
- lowMemoryDevice = lowMemoryDevice
+ lowMemoryDevice = lowMemoryDevice,
+ isLive = isLive
)
lowMemoryDevice -> mediumLivePolicy(
label = "auto-uhd-live-hls-capped",
@@ -126,17 +140,19 @@ internal object PlaybackBufferPolicies {
else -> largeLivePolicy(label = "auto-uhd-live-hls", qualityReason = qualityReason)
}
}
- else -> baselineLivePolicy(
+ return baselineLivePolicy(
resolvedStreamType = resolvedStreamType,
compatibilityMode = compatibilityMode,
- lowMemoryDevice = lowMemoryDevice
+ lowMemoryDevice = lowMemoryDevice,
+ isLive = isLive
)
}
private fun baselineLivePolicy(
resolvedStreamType: ResolvedStreamType,
compatibilityMode: Boolean,
- lowMemoryDevice: Boolean
+ lowMemoryDevice: Boolean,
+ isLive: Boolean = resolvedStreamType.isLive
): PlaybackBufferPolicy = when {
lowMemoryDevice && resolvedStreamType == ResolvedStreamType.MPEG_TS_LIVE ->
PlaybackBufferPolicy(
@@ -148,7 +164,7 @@ internal object PlaybackBufferPolicies {
targetBufferBytes = MPEG_TS_LIVE_TARGET_BUFFER_BYTES,
prioritizeTimeOverSizeThresholds = true
)
- lowMemoryDevice && compatibilityMode && resolvedStreamType.isLive ->
+ lowMemoryDevice && compatibilityMode && isLive ->
PlaybackBufferPolicy(
label = "lowmem-compat-live",
minBufferMs = LOW_MEMORY_COMPAT_LIVE_MIN_BUFFER_MS,
@@ -158,7 +174,7 @@ internal object PlaybackBufferPolicies {
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
prioritizeTimeOverSizeThresholds = true
)
- lowMemoryDevice && resolvedStreamType.isLive ->
+ lowMemoryDevice && isLive ->
PlaybackBufferPolicy(
label = "lowmem-live",
minBufferMs = LOW_MEMORY_LIVE_MIN_BUFFER_MS,
@@ -188,7 +204,7 @@ internal object PlaybackBufferPolicies {
targetBufferBytes = MPEG_TS_LIVE_TARGET_BUFFER_BYTES,
prioritizeTimeOverSizeThresholds = true
)
- compatibilityMode && resolvedStreamType.isLive ->
+ compatibilityMode && isLive ->
PlaybackBufferPolicy(
label = "compat-live",
minBufferMs = COMPAT_LIVE_MIN_BUFFER_MS,
@@ -198,7 +214,7 @@ internal object PlaybackBufferPolicies {
targetBufferBytes = DEFAULT_TARGET_BUFFER_BYTES,
prioritizeTimeOverSizeThresholds = true
)
- resolvedStreamType.isLive ->
+ isLive ->
PlaybackBufferPolicy(
label = "stable-live",
minBufferMs = LIVE_MIN_BUFFER_MS,
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackContentKindResolver.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackContentKindResolver.kt
new file mode 100644
index 00000000..b013e18d
--- /dev/null
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackContentKindResolver.kt
@@ -0,0 +1,16 @@
+package com.streamvault.player.playback
+
+import com.streamvault.domain.model.PlaybackContentKind
+
+internal fun isLivePlayback(kind: PlaybackContentKind, type: ResolvedStreamType): Boolean =
+ when (kind) {
+ PlaybackContentKind.LIVE -> true
+ PlaybackContentKind.ON_DEMAND, PlaybackContentKind.CATCH_UP -> false
+ PlaybackContentKind.UNKNOWN -> when (type) {
+ ResolvedStreamType.HLS,
+ ResolvedStreamType.SMOOTH_STREAMING,
+ ResolvedStreamType.MPEG_TS_LIVE,
+ ResolvedStreamType.RTSP -> true
+ else -> false
+ }
+ }
diff --git a/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt b/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
index f8eddfe7..b96c6fb5 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlaybackPreparationPlan.kt
@@ -17,7 +17,11 @@ internal fun buildPlaybackPreparationPlan(
): PlaybackPreparationPlan {
val resolvedStreamType = StreamTypeResolver.resolve(streamInfo)
val timeoutProfile = PlayerTimeoutProfile.resolve(streamInfo, resolvedStreamType, preload = preload)
- val retryContext = PlaybackRetryContext(resolvedStreamType, timeoutProfile)
+ val retryContext = PlaybackRetryContext(
+ resolvedStreamType = resolvedStreamType,
+ timeoutProfile = timeoutProfile,
+ playbackContentKind = streamInfo.playbackContentKind
+ )
return PlaybackPreparationPlan(
resolvedStreamType = resolvedStreamType,
timeoutProfile = timeoutProfile,
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
index d170c362..dca4fdc0 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
@@ -6,6 +6,7 @@ import androidx.media3.common.util.UnstableApi
import androidx.media3.datasource.HttpDataSource
import androidx.media3.exoplayer.source.BehindLiveWindowException
import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import com.streamvault.domain.model.PlaybackContentKind
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.net.UnknownHostException
@@ -16,13 +17,11 @@ private const val LIVE_HLS_MALFORMED_RETRY_ATTEMPTS_AFTER_START = 12
data class PlaybackRetryContext(
val resolvedStreamType: ResolvedStreamType,
- val timeoutProfile: PlayerTimeoutProfile
+ val timeoutProfile: PlayerTimeoutProfile,
+ val playbackContentKind: PlaybackContentKind = PlaybackContentKind.UNKNOWN
) {
val isLive: Boolean
- get() = resolvedStreamType == ResolvedStreamType.HLS ||
- resolvedStreamType == ResolvedStreamType.SMOOTH_STREAMING ||
- resolvedStreamType == ResolvedStreamType.MPEG_TS_LIVE ||
- resolvedStreamType == ResolvedStreamType.RTSP
+ get() = isLivePlayback(playbackContentKind, resolvedStreamType)
}
@UnstableApi
@@ -73,7 +72,8 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.PROVIDER_LIMIT,
PlaybackErrorCategory.EMPTY_RESPONSE,
PlaybackErrorCategory.UNKNOWN -> streamContext.isLive
- PlaybackErrorCategory.SOURCE_MALFORMED -> streamContext.resolvedStreamType == ResolvedStreamType.HLS
+ PlaybackErrorCategory.SOURCE_MALFORMED ->
+ streamContext.isLive && streamContext.resolvedStreamType == ResolvedStreamType.HLS
PlaybackErrorCategory.HTTP_AUTH,
PlaybackErrorCategory.SSL,
PlaybackErrorCategory.CLEAR_TEXT_BLOCKED,
@@ -91,7 +91,7 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.PROVIDER_LIMIT -> "terminal-provider-limit"
PlaybackErrorCategory.EMPTY_RESPONSE -> "terminal-empty-response"
PlaybackErrorCategory.SOURCE_MALFORMED ->
- if (streamContext.resolvedStreamType == ResolvedStreamType.HLS) {
+ if (streamContext.isLive && streamContext.resolvedStreamType == ResolvedStreamType.HLS) {
"malformed-live-hls-refresh"
} else {
"malformed-source"
@@ -177,7 +177,7 @@ class PlayerRetryPolicy(
}
PlaybackErrorCategory.SOURCE_MALFORMED -> when {
- streamContext.resolvedStreamType == ResolvedStreamType.HLS && playbackStarted ->
+ streamContext.isLive && streamContext.resolvedStreamType == ResolvedStreamType.HLS && playbackStarted ->
LIVE_HLS_MALFORMED_RETRY_ATTEMPTS_AFTER_START
playbackStarted -> 0
else -> 1
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.kt b/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.kt
index 1f239a5f..8ebd53ff 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.kt
@@ -1,5 +1,6 @@
package com.streamvault.player.playback
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.model.StreamType
@@ -36,12 +37,13 @@ enum class PlayerTimeoutProfile(
preload: Boolean
): PlayerTimeoutProfile {
if (preload) return PRELOAD
- if (streamInfo.streamType == StreamType.RTSP) return LIVE
+ val isLive = isLivePlayback(streamInfo.playbackContentKind, resolvedStreamType)
+ if (
+ isLive ||
+ (streamInfo.playbackContentKind == PlaybackContentKind.UNKNOWN &&
+ streamInfo.streamType == StreamType.RTSP)
+ ) return LIVE
return when {
- resolvedStreamType == ResolvedStreamType.HLS -> LIVE
- resolvedStreamType == ResolvedStreamType.SMOOTH_STREAMING -> LIVE
- resolvedStreamType == ResolvedStreamType.MPEG_TS_LIVE -> LIVE
- resolvedStreamType == ResolvedStreamType.RTSP -> LIVE
resolvedStreamType == ResolvedStreamType.PROGRESSIVE -> PROGRESSIVE
streamInfo.streamType == StreamType.PROGRESSIVE -> PROGRESSIVE
else -> VOD
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
index 17b4e77c..192e81ed 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt
@@ -2,7 +2,9 @@ package com.streamvault.player.playback
import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.PlaybackBufferMode
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
+import com.streamvault.domain.model.StreamType
import com.streamvault.domain.model.VideoFormat
import org.junit.Test
@@ -97,6 +99,71 @@ class PlaybackBufferPoliciesTest {
assertThat(policy.qualityReason).isEqualTo("metadata-2160p")
}
+ @Test
+ fun `explicit hls vod keeps baseline buffer sizes and skips quality promotion`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ compatibilityMode = false,
+ lowMemoryDevice = false,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.com/live/movie_2160p/index.m3u8",
+ title = "Movie UHD HDR",
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ ),
+ observedVideoFormat = VideoFormat(width = 3_840, height = 2_160, isHdr = true)
+ )
+
+ assertThat(policy.label).isEqualTo("vod-hls-initial")
+ assertThat(policy.minBufferMs).isEqualTo(8_000)
+ assertThat(policy.maxBufferMs).isEqualTo(30_000)
+ assertThat(policy.playbackBufferMs).isEqualTo(1_500)
+ assertThat(policy.rebufferMs).isEqualTo(5_000)
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ assertThat(policy.qualityReason).isEqualTo("finite-content")
+ }
+
+ @Test
+ fun `explicit hls vod keeps low memory hls buffer limits`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ compatibilityMode = false,
+ lowMemoryDevice = true,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.com/movie_uhd.m3u8",
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ )
+ )
+
+ assertThat(policy.label).isEqualTo("vod-hls-initial")
+ assertThat(policy.minBufferMs).isEqualTo(4_000)
+ assertThat(policy.maxBufferMs).isEqualTo(12_000)
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ }
+
+ @Test
+ fun `explicit live dash gets live baseline buffer`() {
+ val policy = PlaybackBufferPolicies.forPlayback(
+ resolvedStreamType = ResolvedStreamType.DASH,
+ compatibilityMode = false,
+ lowMemoryDevice = false,
+ bufferMode = PlaybackBufferMode.AUTO,
+ streamInfo = StreamInfo(
+ url = "https://example.com/channel.mpd",
+ streamType = StreamType.DASH,
+ playbackContentKind = PlaybackContentKind.LIVE
+ )
+ )
+
+ assertThat(policy.label).isEqualTo("stable-live")
+ assertThat(policy.minBufferMs).isEqualTo(8_000)
+ assertThat(policy.maxBufferMs).isEqualTo(30_000)
+ assertThat(policy.playbackBufferMs).isEqualTo(1_500)
+ assertThat(policy.rebufferMs).isEqualTo(5_000)
+ assertThat(policy.targetBufferBytes).isEqualTo(-1)
+ }
+
@Test
fun `auto live hls promotes to large when observed format is uhd`() {
val policy = PlaybackBufferPolicies.forPlayback(
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackContentKindResolverTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackContentKindResolverTest.kt
new file mode 100644
index 00000000..0a284e29
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackContentKindResolverTest.kt
@@ -0,0 +1,28 @@
+package com.streamvault.player.playback
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackContentKind
+import org.junit.Test
+
+class PlaybackContentKindResolverTest {
+
+ @Test
+ fun `explicit playback intent overrides the stream format`() {
+ val cases = listOf(
+ Triple(PlaybackContentKind.ON_DEMAND, ResolvedStreamType.HLS, false),
+ Triple(PlaybackContentKind.CATCH_UP, ResolvedStreamType.HLS, false),
+ Triple(PlaybackContentKind.LIVE, ResolvedStreamType.DASH, true),
+ Triple(PlaybackContentKind.LIVE, ResolvedStreamType.MPEG_TS_LIVE, true)
+ )
+
+ cases.forEach { (kind, streamType, expected) ->
+ assertThat(isLivePlayback(kind, streamType)).isEqualTo(expected)
+ }
+ }
+
+ @Test
+ fun `unknown intent retains legacy format classification`() {
+ assertThat(isLivePlayback(PlaybackContentKind.UNKNOWN, ResolvedStreamType.HLS)).isTrue()
+ assertThat(isLivePlayback(PlaybackContentKind.UNKNOWN, ResolvedStreamType.DASH)).isFalse()
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackPreparationPlanTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackPreparationPlanTest.kt
index 86376b29..3ca9eeed 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackPreparationPlanTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackPreparationPlanTest.kt
@@ -1,6 +1,7 @@
package com.streamvault.player.playback
import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
import org.junit.Test
@@ -43,4 +44,20 @@ class PlaybackPreparationPlanTest {
assertThat(preloadPlan.resolvedStreamType).isEqualTo(ResolvedStreamType.PROGRESSIVE)
assertThat(preloadPlan.timeoutProfile).isEqualTo(PlayerTimeoutProfile.PRELOAD)
}
-}
\ No newline at end of file
+
+ @Test
+ fun `explicit hls vod intent reaches retry context`() {
+ val plan = buildPlaybackPreparationPlan(
+ streamInfo = StreamInfo(
+ url = "https://example.com/live/movie.m3u8",
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ ),
+ preload = false,
+ playbackStarted = { false }
+ )
+
+ assertThat(plan.retryContext.playbackContentKind).isEqualTo(PlaybackContentKind.ON_DEMAND)
+ assertThat(plan.retryContext.isLive).isFalse()
+ assertThat(plan.timeoutProfile).isEqualTo(PlayerTimeoutProfile.VOD)
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
index a0dc3c35..15b8f32f 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
@@ -6,6 +6,7 @@ import androidx.media3.common.ParserException
import androidx.media3.common.PlaybackException
import androidx.media3.exoplayer.source.BehindLiveWindowException
import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackContentKind
import java.io.IOException
import java.net.SocketTimeoutException
import javax.net.ssl.SSLHandshakeException
@@ -154,6 +155,35 @@ class PlayerRetryPolicyTest {
assertThat(progressivePolicy.retryReason(error)).isEqualTo("server-retryable")
}
+ @Test
+ fun `explicit hls vod uses finite source retry treatment`() {
+ val vodHlsContext = PlaybackRetryContext(
+ resolvedStreamType = ResolvedStreamType.HLS,
+ timeoutProfile = PlayerTimeoutProfile.VOD,
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ )
+ val vodHlsPolicy = PlayerRetryPolicy(vodHlsContext) { true }
+ val malformed = ParserException.createForMalformedContainer("bad movie segment", null)
+
+ assertThat(vodHlsContext.isLive).isFalse()
+ assertThat(vodHlsPolicy.maxAttempts(IOException("HTTP 503"), playbackStarted = false)).isEqualTo(2)
+ assertThat(vodHlsPolicy.maxAttempts(malformed, playbackStarted = true)).isEqualTo(0)
+ assertThat(vodHlsPolicy.retryReason(malformed)).isEqualTo("malformed-source")
+ }
+
+ @Test
+ fun `explicit live dash uses live retry treatment`() {
+ val liveDashContext = PlaybackRetryContext(
+ resolvedStreamType = ResolvedStreamType.DASH,
+ timeoutProfile = PlayerTimeoutProfile.LIVE,
+ playbackContentKind = PlaybackContentKind.LIVE
+ )
+ val liveDashPolicy = PlayerRetryPolicy(liveDashContext) { true }
+
+ assertThat(liveDashContext.isLive).isTrue()
+ assertThat(liveDashPolicy.maxAttempts(IOException("HTTP 503"), playbackStarted = false)).isEqualTo(10)
+ }
+
@Test
fun `network errors keep transient retry reason`() {
val error = SocketTimeoutException("timed out")
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerTimeoutProfileTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerTimeoutProfileTest.kt
index dce91632..d9339e13 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerTimeoutProfileTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerTimeoutProfileTest.kt
@@ -1,6 +1,7 @@
package com.streamvault.player.playback
import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.PlaybackContentKind
import com.streamvault.domain.model.StreamInfo
import org.junit.Test
@@ -41,4 +42,44 @@ class PlayerTimeoutProfileTest {
assertThat(profile.connectTimeoutMs).isAtMost(5_000L)
assertThat(profile.readTimeoutMs).isEqualTo(10_000L)
}
+
+ @Test
+ fun `explicit hls vod selects vod timeout profile`() {
+ val profile = PlayerTimeoutProfile.resolve(
+ streamInfo = StreamInfo(
+ url = "https://example.com/live/movie.m3u8",
+ playbackContentKind = PlaybackContentKind.ON_DEMAND
+ ),
+ resolvedStreamType = ResolvedStreamType.HLS,
+ preload = false
+ )
+
+ assertThat(profile).isEqualTo(PlayerTimeoutProfile.VOD)
+ assertThat(profile.readTimeoutMs).isEqualTo(45_000L)
+ }
+
+ @Test
+ fun `explicit live dash selects live timeout profile`() {
+ assertThat(
+ PlayerTimeoutProfile.resolve(
+ streamInfo = StreamInfo(
+ url = "https://example.com/channel.mpd",
+ playbackContentKind = PlaybackContentKind.LIVE
+ ),
+ resolvedStreamType = ResolvedStreamType.DASH,
+ preload = false
+ )
+ ).isEqualTo(PlayerTimeoutProfile.LIVE)
+ }
+
+ @Test
+ fun `unknown intent keeps hls live timeout behavior`() {
+ assertThat(
+ PlayerTimeoutProfile.resolve(
+ streamInfo = StreamInfo(url = "https://example.com/live/channel.m3u8"),
+ resolvedStreamType = ResolvedStreamType.HLS,
+ preload = false
+ )
+ ).isEqualTo(PlayerTimeoutProfile.LIVE)
+ }
}