StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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.playbackimport com.streamvault.domain.model.PlaybackBufferMode+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.StreamInfoimport com.streamvault.domain.model.VideoFormatimport 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.ktnew file mode 100644index 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.ktindex 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.ktindex 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.UnstableApiimport androidx.media3.datasource.HttpDataSourceimport androidx.media3.exoplayer.source.BehindLiveWindowExceptionimport androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy+import com.streamvault.domain.model.PlaybackContentKindimport java.net.ConnectExceptionimport java.net.SocketTimeoutExceptionimport java.net.UnknownHostException@@ -16,13 +17,11 @@ private const val LIVE_HLS_MALFORMED_RETRY_ATTEMPTS_AFTER_START = 12data 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.HLSPlaybackErrorCategory.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_STARTplaybackStarted -> 0else -> 1diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.kt b/player/src/main/java/com/streamvault/player/playback/PlayerTimeoutProfile.ktindex 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.PlaybackContentKindimport com.streamvault.domain.model.StreamInfoimport 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 LIVEreturn when {- resolvedStreamType == ResolvedStreamType.HLS -> LIVE- resolvedStreamType == ResolvedStreamType.SMOOTH_STREAMING -> LIVE- resolvedStreamType == ResolvedStreamType.MPEG_TS_LIVE -> LIVE- resolvedStreamType == ResolvedStreamType.RTSP -> LIVEresolvedStreamType == ResolvedStreamType.PROGRESSIVE -> PROGRESSIVEstreamInfo.streamType == StreamType.PROGRESSIVE -> PROGRESSIVEelse -> VODdiff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackBufferPoliciesTest.ktindex 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.playbackimport com.google.common.truth.Truth.assertThatimport com.streamvault.domain.model.PlaybackBufferMode+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.StreamInfo+import com.streamvault.domain.model.StreamTypeimport com.streamvault.domain.model.VideoFormatimport 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)+ }+@Testfun `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.ktnew file mode 100644index 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.ktindex 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.playbackimport com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.StreamInfoimport 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.ktindex 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.ParserExceptionimport androidx.media3.common.PlaybackExceptionimport androidx.media3.exoplayer.source.BehindLiveWindowExceptionimport com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.PlaybackContentKindimport java.io.IOExceptionimport java.net.SocketTimeoutExceptionimport 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)+ }+@Testfun `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.ktindex 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.playbackimport com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.PlaybackContentKindimport com.streamvault.domain.model.StreamInfoimport 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)+ }}