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 'develop' into integrate/pr116-pr123-sdk25

David Nashashb06b6a7cd746
diff --cc app/build.gradle.kts
index 108d9d25,6c10208e..639fd382
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@@ -55,10 -55,10 +55,10 @@@ android
defaultConfig {
applicationId = "com.streamvault.app"
- minSdk = 27
+ minSdk = 25
targetSdk = 36
- versionCode = 15
- versionName = "1.0.14"
+ versionCode = 16
+ versionName = "1.0.15"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
buildConfigField("String", "OFFICIAL_APPLICATION_ID", "\"com.streamvault.app\"")
buildConfigField("String", "OFFICIAL_SIGNING_CERT_SHA256", "\"$officialSigningCertSha256\"")
diff --cc app/src/main/java/com/streamvault/app/ui/screens/player/PlayerMovieFallbackSupport.kt
index ecead50e,00000000..f55c17dc
mode 100644,000000..100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerMovieFallbackSupport.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerMovieFallbackSupport.kt
@@@ -1,81 -1,0 +1,83 @@@
+package com.streamvault.app.ui.screens.player
+
+import com.streamvault.domain.model.Movie
++import com.streamvault.domain.model.VodMovieVariant
+import com.streamvault.domain.util.movieVariantQualityScore
+import java.util.Locale
+
+private val AVC_CODEC_TOKENS = listOf("avc", "h264", "x264")
+private val HEVC_CODEC_TOKENS = listOf("hevc", "h265", "x265", "hev1", "hvc1")
+private val MOVIE_CODEC_TOKEN_REGEX = Regex("""[^a-z0-9]+""")
+
+internal suspend fun PlayerViewModel.tryFallbackToAvcMovieVariant(
+ requestVersion: Long,
+ playbackUrl: String
+): Boolean {
+ if (currentContentType != com.streamvault.domain.model.ContentType.MOVIE) return false
+ if (currentProviderId <= 0L || currentContentId <= 0L) return false
+ if (hasRetriedWithAvcMovieVariant) return false
+ if (!isActivePlaybackSession(requestVersion, playbackUrl)) return false
+
+ val currentMovie = movieRepository.getMovie(currentContentId) ?: return false
+ val variants = movieRepository.getMovieVariants(currentContentId)
- val fallbackMovie = selectAvcMovieFallbackVariant(currentMovie, variants) ?: return false
++ val fallbackVariant = selectAvcMovieFallbackVariant(currentMovie, variants) ?: return false
++ val fallbackMovie = movieRepository.getMovie(fallbackVariant.rawMovieId) ?: return false
+ val fallbackStreamInfo = movieRepository.getStreamInfo(fallbackMovie).getOrNull() ?: return false
+
+ if (!isActivePlaybackSession(requestVersion, playbackUrl)) return false
+
+ hasRetriedWithAvcMovieVariant = true
+ currentContentId = fallbackMovie.id
+ currentStreamUrl = fallbackMovie.streamUrl
+ currentTitle = fallbackMovie.name
+ playbackTitleFlow.value = fallbackMovie.name
+ currentArtworkUrl = fallbackMovie.posterUrl ?: fallbackMovie.backdropUrl ?: currentArtworkUrl
+
+ val resolvedStreamInfo = fallbackStreamInfo.copy(title = fallbackStreamInfo.title ?: fallbackMovie.name)
+ setLastFailureReason("HEVC playback failed. Retrying with an AVC/H.264 movie variant.")
+ appendRecoveryAction("Switched to AVC/H.264 movie variant")
+ showPlayerNotice(
+ message = "Retrying with an AVC/H.264 movie variant.",
+ recoveryType = PlayerRecoveryType.DECODER,
+ actions = buildRecoveryActions(PlayerRecoveryType.DECODER)
+ )
+ if (!preparePlayer(resolvedStreamInfo, requestVersion)) return false
+ playerEngine.play()
+ return true
+}
+
+internal fun selectAvcMovieFallbackVariant(
+ currentMovie: Movie,
- variants: List<Movie>
- ): Movie? {
++ variants: List<VodMovieVariant>
++): VodMovieVariant? {
+ val candidateVariants = variants.asSequence()
- .filter { it.id != currentMovie.id }
++ .filter { it.rawMovieId != currentMovie.id }
+ .filter { it.streamUrl.isNotBlank() }
+ .sortedWith(
- compareByDescending<Movie> { movieCodecFallbackPriority(it.name) }
++ compareByDescending<VodMovieVariant> { movieCodecFallbackPriority(it.name) }
+ .thenByDescending { movieVariantQualityScore(it.name) }
+ .thenByDescending { it.addedAt }
+ .thenByDescending { it.rating }
+ .thenBy { it.name.lowercase(Locale.ROOT) }
- .thenBy { it.id }
++ .thenBy { it.rawMovieId }
+ )
+
+ return candidateVariants.firstOrNull { movieCodecFallbackPriority(it.name) > 0 }
+}
+
+private fun movieCodecFallbackPriority(title: String): Int {
+ val normalized = normalizeMovieVariantCodecText(title)
+ val hasHevc = HEVC_CODEC_TOKENS.any { token -> normalized.contains(" $token ") }
+ if (hasHevc) return 0
+
+ val hasAvc = AVC_CODEC_TOKENS.any { token -> normalized.contains(" $token ") }
+ return if (hasAvc) 2 else 1
+}
+
+private fun normalizeMovieVariantCodecText(value: String): String {
+ val normalized = value.lowercase(Locale.ROOT)
+ .replace(MOVIE_CODEC_TOKEN_REGEX, " ")
+ .replace(Regex("""\s+"""), " ")
+ .trim()
+ return " $normalized "
+}
diff --cc app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt
index ed04b0c7,2c6f3dd0..b2e81f57
--- 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
@@@ -61,8 -63,8 +61,9 @@@ import com.streamvault.player.timeshift
import com.streamvault.player.timeshift.LiveTimeshiftState
import com.streamvault.player.timeshift.LiveTimeshiftStatus
import com.streamvault.player.timeshift.TimeshiftConfig
+ import com.streamvault.player.playback.applyUnsafeTlsBypass
import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
@@@ -71,8 -73,9 +72,10 @@@ import kotlinx.coroutines.flow.
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlinx.coroutines.Dispatchers
+import android.content.Context
import javax.inject.Inject
+ import java.net.InetSocketAddress
+ import java.net.Proxy
import okhttp3.OkHttpClient
import okhttp3.Request
@@@ -746,63 -767,40 +751,64 @@@ class PlayerViewModel @Inject construct
recoveryJob?.cancel()
if (error is PlayerError.DecoderError && !hasRetriedWithSoftwareDecoder) {
if (!isActivePlaybackSession(requestVersion, playbackUrl)) return
+ if (currentContentType == ContentType.LIVE) {
+ val currentLiveHlsSession = currentResolvedStreamInfo?.streamType == StreamType.HLS
+ if (currentLiveHlsSession) {
+ val channel = currentChannelFlow.value?.sanitizedForPlayer()
+ if (channel != null &&
+ tryAlternateStreamInternal(
+ channel = channel,
+ preferXtreamTsFallback = false,
+ allowXtreamTsFallback = false
+ )
+ ) {
+ return
+ }
+ android.util.Log.w(
+ "PlayerVM",
+ "Decoder error on live HLS. Keeping hardware path to match Sparkle-like playback on ${appContext.packageName}."
+ )
- } else {
- hasRetriedWithSoftwareDecoder = true
- android.util.Log.w("PlayerVM", "Decoder error detected. Retrying with software decoder mode.")
- playerEngine.setDecoderMode(DecoderMode.SOFTWARE)
- updateDecoderMode(DecoderMode.SOFTWARE)
- setLastFailureReason(error.message)
- appendRecoveryAction("Switched to software decoder")
- playerEngine.play()
- showPlayerNotice(
- message = "Retrying with software decoding for this stream.",
- recoveryType = PlayerRecoveryType.DECODER,
- actions = buildRecoveryActions(PlayerRecoveryType.DECODER)
- )
- return
+ }
+ }
+ hasRetriedWithSoftwareDecoder = true
+ android.util.Log.w("PlayerVM", "Decoder error detected. Retrying with software decoder mode.")
+ playerEngine.setDecoderMode(DecoderMode.SOFTWARE)
+ updateDecoderMode(DecoderMode.SOFTWARE)
+ setLastFailureReason(error.message)
+ appendRecoveryAction("Switched to software decoder")
+ playerEngine.play()
+ showPlayerNotice(
+ message = "Retrying with software decoding for this stream.",
+ recoveryType = PlayerRecoveryType.DECODER,
+ actions = buildRecoveryActions(PlayerRecoveryType.DECODER)
+ )
+ return
+ }
+ recordMovieVariantFailureObservation(error)
+ // After software decoder retry fails, also try an alternate stream format
+ // (e.g. HLS→MPEG-TS or MPEG-TS→HLS) before giving up.
- if (error is PlayerError.DecoderError && hasRetriedWithSoftwareDecoder) {
++ if (error is PlayerError.DecoderError && hasRetriedWithSoftwareDecoder && currentContentType == ContentType.LIVE) {
+ if (!isActivePlaybackSession(requestVersion, playbackUrl)) return
+ val channel = currentChannelFlow.value?.sanitizedForPlayer() ?: return
+ val switched = tryAlternateStreamInternal(channel)
+ if (switched) {
+ appendRecoveryAction("Trying alternate stream format after decoder error")
+ showPlayerNotice(
+ message = "Trying alternate stream format for ${channel.name}.",
+ recoveryType = PlayerRecoveryType.DECODER,
+ actions = buildRecoveryActions(PlayerRecoveryType.DECODER),
+ isRetryNotice = true
+ )
+ return
+ }
}
recoveryJob = viewModelScope.launch {
if (!isActivePlaybackSession(requestVersion, playbackUrl)) return@launch
+ if (error is PlayerError.DecoderError && currentContentType == ContentType.MOVIE && !hasRetriedWithAvcMovieVariant) {
+ if (tryFallbackToAvcMovieVariant(requestVersion, playbackUrl)) {
+ return@launch
+ }
+ }
- if (error is PlayerError.DecoderError && !hasRetriedWithSoftwareDecoder && currentContentType != ContentType.LIVE) {
- if (!isActivePlaybackSession(requestVersion, playbackUrl)) return@launch
- hasRetriedWithSoftwareDecoder = true
- android.util.Log.w("PlayerVM", "Decoder error detected. Retrying with software decoder mode.")
- playerEngine.setDecoderMode(DecoderMode.SOFTWARE)
- updateDecoderMode(DecoderMode.SOFTWARE)
- setLastFailureReason(error.message)
- appendRecoveryAction("Switched to software decoder")
- playerEngine.play()
- showPlayerNotice(
- message = "Retrying with software decoding for this stream.",
- recoveryType = PlayerRecoveryType.DECODER,
- actions = buildRecoveryActions(PlayerRecoveryType.DECODER)
- )
- return@launch
- }
if (tryRefreshXtreamPlaybackAfterAuthError(error, requestVersion, playbackUrl)) {
return@launch
}
@@@ -991,8 -992,11 +997,9 @@@
thumbnailPreloadJob?.cancel()
hasRetriedXtreamAuthRefresh = false
lastRecordedVariantObservationSignature = null
+ lastRecordedVodVariantObservationSignature = null
livePlaybackReadyForCurrentSession = false
readySideEffectsRequestVersion = null
- currentResolvedPlaybackUrl = ""
- currentResolvedStreamInfo = null
playerEngine.setScrubbingMode(false)
return ++prepareRequestVersion
}
diff --cc app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
index dde96f36,8e6f50ce..9fbe4310
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt
@@@ -46,8 -46,8 +46,9 @@@ import com.streamvault.domain.model.Com
import com.streamvault.domain.model.GroupedChannelLabelMode
import com.streamvault.domain.model.AudioOutputPreference
import com.streamvault.domain.model.LiveChannelGroupingMode
+import com.streamvault.domain.model.LiveStreamFormatMode
import com.streamvault.domain.model.LiveVariantPreferenceMode
+ import com.streamvault.domain.model.VodDuplicateHandlingMode
import com.streamvault.domain.model.VodHttpProtocolMode
import com.streamvault.domain.model.ProviderStatus
import com.streamvault.domain.model.RecordingItem
diff --cc data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
index adc27851,2b3a91ea..9050c0c5
--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
@@@ -27,9 -27,11 +27,12 @@@ import com.streamvault.domain.model.App
import com.streamvault.domain.model.AppTimeFormat
import com.streamvault.domain.model.LiveChannelGroupingMode
import com.streamvault.domain.model.LiveChannelObservedQuality
+import com.streamvault.domain.model.LiveStreamFormatMode
import com.streamvault.domain.model.LiveVariantPreferenceMode
+ import com.streamvault.domain.model.VodDuplicateHandlingMode
import com.streamvault.domain.model.VodHttpProtocolMode
+ import com.streamvault.domain.model.VodVariantObservation
+ import com.streamvault.domain.model.VodVariantPreferenceMode
import com.streamvault.domain.model.PlayerSurfaceMode
import com.streamvault.domain.model.RemoteColorButton
import com.streamvault.domain.model.RemoteShortcutPreferences
diff --cc data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
index bb3e545c,7b51fa35..2dbea406
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
@@@ -2,7 -2,7 +2,8 @@@ package com.streamvault.data.remote.xtr
import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.entity.ProviderEntity
+import com.streamvault.data.preferences.PreferencesRepository
+ import com.streamvault.data.remote.jellyfin.buildJellyfinAuthorizationHeader
import com.streamvault.data.remote.http.toGenericRequestProfile
import com.streamvault.data.remote.stalker.StalkerProvider
import com.streamvault.data.remote.stalker.StalkerApiService
@@@ -252,20 -265,31 +271,45 @@@ class XtreamStreamUrlResolver @Inject c
)
}
+ private suspend fun resolveLiveContainerExtension(
+ kind: XtreamStreamKind,
+ containerExtension: String?
+ ): String? {
+ if (kind != XtreamStreamKind.LIVE) {
+ return containerExtension
+ }
+ return when (preferencesRepository.playerLiveStreamFormatMode.first()) {
+ LiveStreamFormatMode.AUTO -> containerExtension
+ LiveStreamFormatMode.HLS -> "m3u8"
+ LiveStreamFormatMode.MPEG_TS -> "ts"
+ }
+ }
+
+ private fun resolveDirectJellyfinUrl(
+ provider: ProviderEntity,
+ url: String,
+ fallbackContainerExtension: String?
+ ): ResolvedStreamUrl? {
+ if (url.isBlank()) {
+ return null
+ }
+ val decryptedPassword = credentialCrypto.decryptIfNeeded(provider.password)
+ return provider.applyPlaybackRequestProfile(
+ ResolvedStreamUrl(
+ url = url,
+ expirationTime = extractStreamExpirationTime(url),
+ containerExtension = fallbackContainerExtension,
+ headers = mapOf(
+ "Authorization" to buildJellyfinAuthorizationHeader(
+ provider.serverUrl,
+ provider.username,
+ decryptedPassword
+ )
+ )
+ )
+ )
+ }
+
private suspend fun resolveDirectStalkerUrl(
provider: ProviderEntity,
url: String,