Skip to content

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

Release 1.0.4 - security fixes, EPG improvements, player stability

David Nashash7c38f4f4026b
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 620de73b..1d17bbe4 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -148,15 +148,32 @@ jobs:
echo "release_tag=v$VERSION_NAME" >> "$GITHUB_OUTPUT"
echo "apk_name=StreamVault-$VERSION_NAME.apk" >> "$GITHUB_OUTPUT"
+ - name: Extract changelog entry
+ id: changelog
+ shell: bash
+ run: |
+ VERSION="${{ steps.app_version.outputs.version_name }}"
+ echo "Extracting notes for version $VERSION"
+
+ # Extract lines between the header and the next header (or EOF)
+ {
+ echo "notes<<EOF"
+ awk -v ver="$VERSION" '$0 ~ "^## " ver " " {p=1; next} $0 ~ "^## " && p {p=0} p {print}' docs/CHANGELOG.md
+ echo "EOF"
+ } >> "$GITHUB_OUTPUT"
+
- name: Publish GitHub Release
uses: softprops/action-gh-release@v2
with:
tag_name: ${{ steps.app_version.outputs.release_tag }}
name: StreamVault ${{ steps.app_version.outputs.version_name }}
body: |
- Version `${{ steps.app_version.outputs.version_name }}` (code `${{ steps.app_version.outputs.version_code }}`) built from `${{ github.sha }}`.
+ ${{ steps.changelog.outputs.notes }}
+
+ ---
+ Built from `${{ github.sha }}`.
files: |
dist/${{ steps.app_version.outputs.apk_name }}
dist/StreamVault.apk
make_latest: true
- generate_release_notes: true
+ generate_release_notes: false
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..6c5a6155
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,85 @@
+StreamVault Source-Available License (Non-Commercial)
+
+Copyright (c) 2026 David Nashash (Davidona)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software, subject to the following conditions:
+
+1. ATTRIBUTION
+
+ All copies or substantial portions of the Software must include this
+ copyright notice and this permission notice.
+
+ Any modified, compiled, or redistributed versions of the Software must
+ clearly credit "David Nashash" (also known as "Davidona") as the original
+ developer. Attribution must be visible both within the application
+ (for example, in an "About", "Credits", or equivalent screen) and in any
+ accompanying documentation.
+
+2. LINKS PRESERVATION
+
+ The following links must be retained, visible, and accessible to end users
+ in any distributed or modified versions of the Software:
+
+ - Original GitHub repository:
+ https://github.com/Davidona/StreamVault-IPTV
+
+ - Support / donation page:
+ https://ko-fi.com/davidona
+
+ These links may not be removed, hidden, or replaced.
+
+3. NAMING AND DERIVATIVE IDENTIFICATION
+
+ The software is named "StreamVault".
+
+ Any modified or forked version of the Software must clearly state that it is:
+ "Based on StreamVault" or "Derived from StreamVault" in:
+ - The application (e.g., About section)
+ - Any public distribution pages or descriptions
+
+ You may not present modified versions as the original software.
+
+4. NON-COMMERCIAL USE
+
+ The Software and any derivative works may not be used for commercial purposes.
+
+ Commercial use includes, but is not limited to:
+ - Selling the Software
+ - Charging for access to the Software
+ - Including the Software in any paid product or service
+ - Monetizing the Software via advertisements, sponsorships, or subscriptions
+
+ Any commercial use requires explicit prior written permission from
+ the copyright holder.
+
+5. SHARE-ALIKE (COPYLEFT)
+
+ If you modify and distribute the Software or any derivative works,
+ you must:
+
+ - Make the complete corresponding source code publicly available
+ - License the derivative work under this exact same license
+
+ You may not apply additional restrictions or distribute derivative
+ works under a more restrictive or proprietary license.
+
+6. NO ENDORSEMENT
+
+ The name "David Nashash" or "Davidona" may not be used to endorse or
+ promote products derived from this Software without specific prior
+ written permission.
+
+7. TERMINATION
+
+ Any violation of the terms of this license will result in the immediate
+ termination of the rights granted under this license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/README.md b/README.md
index 3601f67f..916778cf 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@
<a href="docs/CHANGELOG.md"><img src="https://img.shields.io/badge/Changelog-View-2563eb?style=for-the-badge" alt="View changelog" /></a>
<a href="https://github.com/Davidona/StreamVault-IPTV/actions/workflows/release.yml"><img src="https://img.shields.io/github/actions/workflow/status/Davidona/StreamVault-IPTV/release.yml?branch=master&style=for-the-badge&label=CI" alt="GitHub Actions status" /></a>
<a href="https://ko-fi.com/davidona"><img src="https://img.shields.io/badge/Support-Ko--fi-ff5f5f?style=for-the-badge&logo=kofi" alt="Support on Ko-fi" /></a>
+ <a href="LICENSE"><img src="https://img.shields.io/badge/License-StreamVault_OSL-0284c7?style=for-the-badge" alt="License" /></a>
</p>
StreamVault is a TV-first IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
@@ -179,3 +180,10 @@ Useful commands:
- StreamVault is an IPTV client, not a content provider.
- Use only playlists, streams, and guide sources you are authorized to access.
- Local configuration and signing files are intentionally excluded from git.
+
+## License
+
+This project was originally released without an explicit license.
+As of April 2026, all usage, modification, and distribution are governed by the StreamVault Source-Available License (Non-Commercial).
+
+Any use of this project must comply with the terms defined in the LICENSE file.
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index ec5d63b7..a8feb7fb 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -1,5 +1,7 @@
import java.util.Properties
import java.io.FileInputStream
+import java.security.KeyStore
+import java.security.MessageDigest
plugins {
alias(libs.plugins.android.application)
@@ -16,6 +18,28 @@ if (keystorePropertiesFile.exists()) {
FileInputStream(keystorePropertiesFile).use(keystoreProperties::load)
}
+fun computeOfficialSigningCertSha256(): String {
+ if (!keystorePropertiesFile.exists()) return ""
+
+ val storePath = keystoreProperties.getProperty("storeFile") ?: return ""
+ val storePassword = keystoreProperties.getProperty("storePassword") ?: return ""
+ val keyAlias = keystoreProperties.getProperty("keyAlias") ?: return ""
+ val storeFile = rootProject.file(storePath)
+ if (!storeFile.exists()) return ""
+
+ val keyStore = KeyStore.getInstance("JKS")
+ storeFile.inputStream().use { input ->
+ keyStore.load(input, storePassword.toCharArray())
+ }
+
+ val certificate = keyStore.getCertificate(keyAlias) ?: return ""
+ return MessageDigest.getInstance("SHA-256")
+ .digest(certificate.encoded)
+ .joinToString(":") { byte -> "%02X".format(byte) }
+}
+
+val officialSigningCertSha256 = computeOfficialSigningCertSha256()
+
android {
namespace = "com.streamvault.app"
compileSdk = 36
@@ -27,6 +51,8 @@ android {
versionCode = 4
versionName = "1.0.3"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+ buildConfigField("String", "OFFICIAL_APPLICATION_ID", "\"com.streamvault.app\"")
+ buildConfigField("String", "OFFICIAL_SIGNING_CERT_SHA256", "\"$officialSigningCertSha256\"")
}
signingConfigs {
diff --git a/app/src/main/java/com/streamvault/app/cast/CastManager.kt b/app/src/main/java/com/streamvault/app/cast/CastManager.kt
index 32781ed5..b2e8e80b 100644
--- a/app/src/main/java/com/streamvault/app/cast/CastManager.kt
+++ b/app/src/main/java/com/streamvault/app/cast/CastManager.kt
@@ -163,8 +163,16 @@ class CastManager @Inject constructor(
}
private fun isRequestSupported(request: CastMediaRequest): Boolean {
+ val normalizedUrl = request.url.trim().lowercase()
val mimeType = request.mimeType.orEmpty().lowercase()
- if (request.url.startsWith("rtsp", ignoreCase = true)) return false
+ if (
+ normalizedUrl.startsWith("rtsp://") ||
+ normalizedUrl.startsWith("rtsps://") ||
+ normalizedUrl.startsWith("rtmp://") ||
+ normalizedUrl.startsWith("rtmps://")
+ ) {
+ return false
+ }
return mimeType.isBlank() || mimeType != "application/x-rtsp"
}
@@ -172,4 +180,4 @@ class CastManager @Inject constructor(
const val TAG = "CastManager"
const val DEFAULT_CONTENT_TYPE = "application/x-mpegURL"
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
index e420683e..bb0416bb 100644
--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt
@@ -3,6 +3,8 @@ package com.streamvault.app.di
import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.RoomDatabaseTransactionRunner
import com.streamvault.data.preferences.PreferencesRepository
+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.data.sync.ProviderSyncStateReaderImpl
import com.streamvault.data.validation.ProviderSetupInputValidatorImpl
import com.streamvault.domain.manager.ParentalPinVerifier
@@ -79,6 +81,9 @@ abstract class RepositoryModule {
@Binds @Singleton
abstract fun bindProviderSyncStateReader(impl: ProviderSyncStateReaderImpl): ProviderSyncStateReader
+ @Binds @Singleton
+ abstract fun bindCredentialCrypto(impl: AndroidKeystoreCredentialCrypto): CredentialCrypto
+
companion object {
@Provides
@Singleton
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
index a3294142..1528550a 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
@@ -282,6 +282,7 @@ fun AppNavigation(mainActivity: MainActivity) {
ProviderSetupScreen(
editProviderId = providerId,
initialImportUri = importUri,
+ onBack = { navController.popBackStack() },
onProviderAdded = dropUnlessResumed {
navController.navigate(Routes.HOME) {
popUpTo(Routes.PROVIDER_SETUP) { inclusive = true }
diff --git a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
index ad98b86b..74d1ad5f 100644
--- a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
+++ b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
@@ -22,8 +22,12 @@ import com.streamvault.domain.repository.PlaybackHistoryRepository
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.repository.SeriesRepository
import com.streamvault.domain.usecase.GetRecommendations
+import kotlinx.coroutines.Dispatchers
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
import java.io.OutputStream
import javax.inject.Inject
import javax.inject.Singleton
@@ -37,38 +41,51 @@ class LauncherRecommendationsManager @Inject constructor(
private val seriesRepository: SeriesRepository
) {
private val getRecommendations = GetRecommendations(movieRepository)
+ private val refreshMutex = Mutex()
+ @Volatile
+ private var lastRefreshAtMs: Long = 0L
- suspend fun refreshRecommendations() {
- if (!context.isTelevisionDevice()) return
- val provider = providerRepository.getActiveProvider().first()
- if (provider == null) {
- deleteAllManagedChannels()
- return
- }
+ suspend fun refreshRecommendations(force: Boolean = false) = withContext(Dispatchers.IO) {
+ if (!context.isTelevisionDevice()) return@withContext
- runCatching {
- val specs = buildChannelSpecs(provider)
- val existingChannels = loadExistingChannels()
- val activeKeys = specs.mapTo(mutableSetOf()) { it.key }
-
- existingChannels
- .filterKeys { it !in activeKeys }
- .values
- .forEach(::deleteChannel)
-
- specs.forEach { spec ->
- if (spec.programs.isEmpty()) {
- existingChannels[spec.key]?.let(::deleteChannel)
- return@forEach
- }
+ refreshMutex.withLock {
+ val now = System.currentTimeMillis()
+ if (!force && lastRefreshAtMs > 0L && now - lastRefreshAtMs < MIN_REFRESH_INTERVAL_MS) {
+ return@withLock
+ }
- val channelId = existingChannels[spec.key] ?: insertChannel(spec) ?: return@forEach
- updateChannel(channelId, spec)
- syncPrograms(channelId, spec)
- requestChannelBrowsable(channelId)
+ val provider = providerRepository.getActiveProvider().first()
+ if (provider == null) {
+ deleteAllManagedChannels()
+ lastRefreshAtMs = now
+ return@withLock
+ }
+
+ runCatching {
+ val specs = buildChannelSpecs(provider)
+ val existingChannels = loadExistingChannels()
+ val activeKeys = specs.mapTo(mutableSetOf()) { it.key }
+
+ existingChannels
+ .filterKeys { it !in activeKeys }
+ .values
+ .forEach(::deleteChannel)
+
+ specs.forEach { spec ->
+ if (spec.programs.isEmpty()) {
+ existingChannels[spec.key]?.let(::deleteChannel)
+ return@forEach
+ }
+
+ val channelId = existingChannels[spec.key] ?: insertChannel(spec) ?: return@forEach
+ updateChannel(channelId, spec)
+ syncPrograms(channelId, spec)
+ requestChannelBrowsable(channelId)
+ }
+ lastRefreshAtMs = now
+ }.onFailure { throwable ->
+ Log.w(TAG, "Launcher recommendation sync failed", throwable)
}
- }.onFailure { throwable ->
- Log.w(TAG, "Launcher recommendation sync failed", throwable)
}
}
@@ -371,6 +388,7 @@ class LauncherRecommendationsManager @Inject constructor(
private companion object {
const val TAG = "LauncherRecommendations"
+ const val MIN_REFRESH_INTERVAL_MS = 15 * 60 * 1000L
const val CHANNEL_CONTINUE_WATCHING = "streamvault_continue_watching"
const val CHANNEL_TOP_MOVIES = "streamvault_top_movies"
const val CHANNEL_FRESH_SERIES = "streamvault_fresh_series"
diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt
index c4083272..531d84c6 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt
@@ -15,6 +15,7 @@ import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
@@ -50,6 +51,7 @@ fun CategoryOptionsDialog(
onReorderChannels: (() -> Unit)? = null
) {
var canInteract by remember { mutableStateOf(false) }
+ val blockOpenGesture = rememberDialogOpenGestureBlocker(canInteract)
LaunchedEffect(Unit) {
delay(500)
canInteract = true
@@ -75,7 +77,9 @@ fun CategoryOptionsDialog(
else -> 0.38f
}
Surface(
- modifier = Modifier.fillMaxWidth(dialogWidth),
+ modifier = Modifier
+ .fillMaxWidth(dialogWidth)
+ .onPreviewKeyEvent(blockOpenGesture),
shape = RoundedCornerShape(24.dp),
colors = SurfaceDefaults.colors(containerColor = SurfaceElevated)
) {
diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
index 7b5163bf..04d1c6f6 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PinDialog.kt
@@ -16,6 +16,7 @@ import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
@@ -48,6 +49,7 @@ fun PinDialog(
var canInteract by remember { mutableStateOf(false) }
val firstKeyFocusRequester = remember { FocusRequester() }
val isTelevisionDevice = rememberIsTelevisionDevice()
+ val blockOpenGesture = rememberDialogOpenGestureBlocker(canInteract)
LaunchedEffect(Unit) {
firstKeyFocusRequester.requestFocusSafely(tag = "PinDialog", target = "PIN keypad")
@@ -78,6 +80,7 @@ fun PinDialog(
val dialogContent: @Composable (Modifier) -> Unit = { resolvedModifier ->
Box(
modifier = resolvedModifier
+ .onPreviewKeyEvent(blockOpenGesture)
.background(SurfaceElevated, RoundedCornerShape(16.dp))
.border(1.dp, Color.White.copy(alpha = 0.1f), RoundedCornerShape(16.dp))
.padding(24.dp),
diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PremiumDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PremiumDialog.kt
index 14219adb..8492d4c8 100644
--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/PremiumDialog.kt
+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/PremiumDialog.kt
@@ -1,5 +1,6 @@
package com.streamvault.app.ui.components.dialogs
+import android.view.KeyEvent as AndroidKeyEvent
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
@@ -13,6 +14,7 @@ import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
@@ -22,6 +24,8 @@ import androidx.compose.ui.Modifier
import kotlinx.coroutines.delay
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
@@ -36,6 +40,23 @@ import com.streamvault.app.ui.interaction.mouseClickable
import com.streamvault.app.ui.design.AppColors
import com.streamvault.app.ui.design.FocusSpec
+internal val LocalDialogCanInteract = compositionLocalOf { true }
+
+@Composable
+internal fun rememberDialogOpenGestureBlocker(canInteract: Boolean): (KeyEvent) -> Boolean = remember(canInteract) {
+ { event ->
+ !canInteract &&
+ event.nativeKeyEvent.action == AndroidKeyEvent.ACTION_UP &&
+ when (event.nativeKeyEvent.keyCode) {
+ AndroidKeyEvent.KEYCODE_DPAD_CENTER,
+ AndroidKeyEvent.KEYCODE_ENTER,
+ AndroidKeyEvent.KEYCODE_NUMPAD_ENTER,
+ AndroidKeyEvent.KEYCODE_BUTTON_A -> true
+ else -> false
+ }
+ }
+}
+
@Composable
fun PremiumDialog(
title: String,
@@ -48,6 +69,7 @@ fun PremiumDialog(
) {
var canInteract by remember { mutableStateOf(false) }
val isTelevisionDevice = rememberIsTelevisionDevice()
+ val blockOpenGesture = rememberDialogOpenGestureBlocker(canInteract)
LaunchedEffect(Unit) { delay(500); canInteract = true }
Dialog(
onDismissRequest = onDismissRequest,
@@ -57,63 +79,12 @@ fun PremiumDialog(
usePlatformDefaultWidth = false
)
) {
- if (isTelevisionDevice) {
- Surface(
- modifier = modifier.fillMaxWidth(widthFraction),
- shape = RoundedCornerShape(28.dp),
- colors = SurfaceDefaults.colors(containerColor = AppColors.SurfaceElevated)
- ) {
- Column(
- modifier = Modifier
- .background(
- Brush.verticalGradient(
- colors = listOf(
- AppColors.BrandMuted.copy(alpha = 0.18f),
- AppColors.SurfaceElevated,
- AppColors.Surface
- )
- )
- )
- .padding(28.dp),
- verticalArrangement = Arrangement.spacedBy(18.dp)
- ) {
- Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
- Text(
- text = title,
- style = MaterialTheme.typography.headlineMedium,
- color = AppColors.TextPrimary
- )
- if (!subtitle.isNullOrBlank()) {
- Text(
- text = subtitle,
- style = MaterialTheme.typography.bodyMedium,
- color = AppColors.TextSecondary
- )
- }
- }
-
- Column(verticalArrangement = Arrangement.spacedBy(12.dp), content = content)
-
- Row(
- modifier = Modifier.fillMaxWidth(),
- horizontalArrangement = Arrangement.spacedBy(10.dp, androidx.compose.ui.Alignment.End),
- content = footer
- )
- }
- }
- } else {
- BoxWithConstraints(
- modifier = Modifier.fillMaxWidth(),
- contentAlignment = Alignment.Center
- ) {
- val resolvedWidthFraction = when {
- maxWidth < 700.dp -> 0.9f
- maxWidth < 1000.dp -> maxOf(widthFraction, 0.62f)
- else -> widthFraction
- }
-
+ androidx.compose.runtime.CompositionLocalProvider(LocalDialogCanInteract provides canInteract) {
+ if (isTelevisionDevice) {
Surface(
- modifier = modifier.fillMaxWidth(resolvedWidthFraction),
+ modifier = modifier
+ .fillMaxWidth(widthFraction)
+ .onPreviewKeyEvent(blockOpenGesture),
shape = RoundedCornerShape(28.dp),
colors = SurfaceDefaults.colors(containerColor = AppColors.SurfaceElevated)
) {
@@ -155,6 +126,63 @@ fun PremiumDialog(
)
}
}
+ } else {
+ BoxWithConstraints(
+ modifier = Modifier.fillMaxWidth(),
+ contentAlignment = Alignment.Center
+ ) {
+ val resolvedWidthFraction = when {
+ maxWidth < 700.dp -> 0.9f
+ maxWidth < 1000.dp -> maxOf(widthFraction, 0.62f)
+ else -> widthFraction
+ }
+
+ Surface(
+ modifier = modifier
+ .fillMaxWidth(resolvedWidthFraction)
+ .onPreviewKeyEvent(blockOpenGesture),
+ shape = RoundedCornerShape(28.dp),
+ colors = SurfaceDefaults.colors(containerColor = AppColors.SurfaceElevated)
+ ) {
+ Column(
+ modifier = Modifier
+ .background(
+ Brush.verticalGradient(
+ colors = listOf(
+ AppColors.BrandMuted.copy(alpha = 0.18f),
+ AppColors.SurfaceElevated,
+ AppColors.Surface
+ )
+ )
+ )
+ .padding(28.dp),
+ verticalArrangement = Arrangement.spacedBy(18.dp)
+ ) {
+ Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text(
+ text = title,
+ style = MaterialTheme.typography.headlineMedium,
+ color = AppColors.TextPrimary
+ )
+ if (!subtitle.isNullOrBlank()) {
+ Text(
+ text = subtitle,
+ style = MaterialTheme.typography.bodyMedium,
+ color = AppColors.TextSecondary
+ )
+ }
+ }
+
+ Column(verticalArrangement = Arrangement.spacedBy(12.dp), content = content)
+
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.spacedBy(10.dp, androidx.compose.ui.Alignment.End),
+ content = footer
+ )
+ }
+ }
+ }
}
}
}
@@ -169,6 +197,7 @@ fun PremiumDialogActionButton(
destructive: Boolean = false,
emphasized: Boolean = false
) {
+ val canInteract = LocalDialogCanInteract.current
val containerColor = when {
destructive -> AppColors.Live.copy(alpha = 0.22f)
emphasized -> AppColors.Brand
@@ -181,9 +210,9 @@ fun PremiumDialogActionButton(
}
Button(
- onClick = onClick,
+ onClick = { if (canInteract) onClick() },
enabled = enabled,
- modifier = modifier.fillMaxWidth().mouseClickable(enabled = enabled, onClick = onClick),
+ modifier = modifier.fillMaxWidth().mouseClickable(enabled = enabled, onClick = { if (canInteract) onClick() }),
colors = ButtonDefaults.colors(
containerColor = containerColor,
contentColor = contentColor,
@@ -214,6 +243,7 @@ fun PremiumDialogFooterButton(
destructive: Boolean = false,
emphasized: Boolean = false
) {
+ val canInteract = LocalDialogCanInteract.current
val containerColor = when {
destructive -> AppColors.Live.copy(alpha = 0.18f)
emphasized -> AppColors.Brand
@@ -222,9 +252,9 @@ fun PremiumDialogFooterButton(
val contentColor = if (emphasized) Color.Black else AppColors.TextPrimary
Button(
- onClick = onClick,
+ onClick = { if (canInteract) onClick() },
enabled = enabled,
- modifier = Modifier.mouseClickable(enabled = enabled, onClick = onClick),
+ modifier = Modifier.mouseClickable(enabled = enabled, onClick = { if (canInteract) onClick() }),
colors = ButtonDefaults.colors(
containerColor = containerColor,
contentColor = contentColor,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgControlComponents.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgControlComponents.kt
index ca349479..314a0cd8 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgControlComponents.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgControlComponents.kt
@@ -23,6 +23,7 @@ import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Search
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
@@ -31,6 +32,7 @@ import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
+import androidx.compose.runtime.staticCompositionLocalOf
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
@@ -71,6 +73,8 @@ import java.util.Locale
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
+private val LocalGuideNow = staticCompositionLocalOf { 0L }
+
@Composable
internal fun rememberGuideNow(): Long {
val currentTime by produceState(initialValue = System.currentTimeMillis()) {
@@ -82,6 +86,17 @@ internal fun rememberGuideNow(): Long {
return currentTime
}
+@Composable
+internal fun GuideNowProvider(content: @Composable () -> Unit) {
+ val now = rememberGuideNow()
+ CompositionLocalProvider(LocalGuideNow provides now) {
+ content()
+ }
+}
+
+@Composable
+internal fun currentGuideNow(): Long = LocalGuideNow.current
+
@Composable
internal fun GuideDensityRow(
selectedDensity: GuideDensity,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgGridComponents.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgGridComponents.kt
index 43828533..7d841eb9 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgGridComponents.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgGridComponents.kt
@@ -22,6 +22,7 @@ import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
@@ -113,7 +114,6 @@ internal fun EpgGrid(
guideWindowStart: Long,
guideWindowEnd: Long,
density: GuideDensity,
- now: Long,
onChannelClick: (Channel) -> Unit,
onProgramClick: (Channel, Program) -> Unit,
onChannelFocused: (Channel, Program?, Boolean) -> Unit,
@@ -148,7 +148,6 @@ internal fun EpgGrid(
GuideTimelineHeader(
windowStart = guideWindowStart,
windowEnd = guideWindowEnd,
- now = now,
channelRailWidth = channelRailWidth,
timelineGap = timelineGap,
timelineViewportWidth = timelineViewportWidth,
@@ -173,7 +172,6 @@ internal fun EpgGrid(
channel = channel,
isFavorite = channel.id in favoriteChannelIds,
programs = programs,
- now = now,
windowStart = guideWindowStart,
windowEnd = guideWindowEnd,
channelRailWidth = channelRailWidth,
@@ -199,7 +197,6 @@ internal fun EpgGrid(
private fun GuideTimelineHeader(
windowStart: Long,
windowEnd: Long,
- now: Long,
channelRailWidth: Dp,
timelineGap: Dp,
timelineViewportWidth: Dp,
@@ -207,6 +204,7 @@ private fun GuideTimelineHeader(
markerStepMs: Long,
scrollState: androidx.compose.foundation.ScrollState
) {
+ val now = currentGuideNow()
val hourFormat = remember { SimpleDateFormat("HH:mm", Locale.getDefault()) }
val totalDuration = (windowEnd - windowStart).coerceAtLeast(1L)
val clampedNow = now.coerceIn(windowStart, windowEnd)
@@ -318,7 +316,6 @@ fun EpgRow(
channel: Channel,
isFavorite: Boolean,
programs: List<Program>,
- now: Long,
windowStart: Long,
windowEnd: Long,
channelRailWidth: Dp,
@@ -335,8 +332,11 @@ fun EpgRow(
onProgramFocused: (Program) -> Unit
) {
var isFocused by remember { mutableStateOf(false) }
+ val now = currentGuideNow()
+ val currentProgram by remember(programs, now) {
+ derivedStateOf { programs.currentProgramAt(now) }
+ }
val totalDuration = (windowEnd - windowStart).coerceAtLeast(1L)
- val currentProgram = programs.firstOrNull { now in it.startTime..it.endTime }
val channelPaddingVertical = when (density) {
GuideDensity.COMPACT -> 3.dp
GuideDensity.COMFORTABLE -> 4.dp
@@ -470,16 +470,6 @@ fun EpgRow(
.background(Color.White.copy(alpha = 0.08f))
)
}
- if (now in windowStart..windowEnd) {
- val nowRatio = ((now - windowStart).toFloat() / totalDuration.toFloat()).coerceIn(0f, 1f)
- Box(
- modifier = Modifier
- .padding(start = totalTimelineWidth * nowRatio)
- .width(2.dp)
- .fillMaxHeight()
- .background(Primary)
- )
- }
if (programs.isEmpty()) {
Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
Text(stringResource(R.string.epg_no_schedule_short), color = OnSurfaceDim)
@@ -489,8 +479,6 @@ fun EpgRow(
ProgramItem(
program = program,
density = density,
- isCurrent = now in program.startTime until program.endTime,
- now = now,
windowStart = windowStart,
windowEnd = windowEnd,
totalTimelineWidth = totalTimelineWidth,
@@ -509,8 +497,6 @@ fun EpgRow(
fun ProgramItem(
program: Program,
density: GuideDensity,
- isCurrent: Boolean,
- now: Long,
windowStart: Long,
windowEnd: Long,
totalTimelineWidth: Dp,
@@ -518,6 +504,8 @@ fun ProgramItem(
onFocused: () -> Unit
) {
var isFocused by remember { mutableStateOf(false) }
+ val now = currentGuideNow()
+ val isCurrent = now in program.startTime until program.endTime
val format = remember { SimpleDateFormat("HH:mm", Locale.getDefault()) }
val startStr = format.format(Date(program.startTime))
@@ -627,6 +615,9 @@ fun ProgramItem(
}
}
+private fun List<Program>.currentProgramAt(now: Long): Program? =
+ firstOrNull { now in it.startTime until it.endTime }
+
internal fun formatWindowDuration(durationMs: Long): String {
val hours = durationMs / (60 * 60 * 1000L)
val minutes = (durationMs / (60 * 1000L)) % 60
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgHeroComponents.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgHeroComponents.kt
index b6d792f0..3dd255b2 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgHeroComponents.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgHeroComponents.kt
@@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
@@ -80,6 +81,41 @@ internal fun resolveGuideHeroSelection(
)
}
+@Composable
+internal fun GuideHeroSection(
+ uiState: EpgUiState,
+ focusedChannel: Channel?,
+ focusedProgram: Program?,
+ modifier: Modifier = Modifier
+) {
+ val now = currentGuideNow()
+ val heroSelection by remember(uiState, focusedChannel, focusedProgram, now) {
+ derivedStateOf {
+ resolveGuideHeroSelection(
+ uiState = uiState,
+ focusedChannel = focusedChannel,
+ focusedProgram = focusedProgram,
+ now = now
+ )
+ }
+ }
+
+ ImmersiveGuideHero(
+ selection = heroSelection,
+ providerLabel = uiState.providerSourceLabel,
+ selectedCategoryName = uiState.categories
+ .firstOrNull { it.id == uiState.selectedCategoryId }
+ ?.name
+ .orEmpty(),
+ isGuideStale = uiState.isGuideStale,
+ channelCount = uiState.totalChannelCount,
+ channelsWithSchedule = uiState.channelsWithSchedule,
+ lastUpdatedAt = uiState.lastUpdatedAt,
+ isRefreshing = uiState.isRefreshing,
+ modifier = modifier
+ )
+}
+
@Composable
internal fun ImmersiveGuideHero(
selection: GuideHeroSelection?,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
index bef7a098..6a770847 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreen.kt
@@ -153,7 +153,6 @@ fun FullEpgScreen(
var pendingLockedAction by remember { mutableStateOf<LockedGuideAction?>(null) }
val scope = rememberCoroutineScope()
val context = LocalContext.current
- val now = rememberGuideNow()
val returnRoute = remember(uiState.selectedCategoryId, uiState.guideAnchorTime, uiState.showFavoritesOnly) {
Routes.epg(
categoryId = uiState.selectedCategoryId.takeIf { it != ChannelRepository.ALL_CHANNELS_ID },
@@ -188,7 +187,7 @@ fun FullEpgScreen(
)
}
- LaunchedEffect(uiState.channels, uiState.programsByChannel, now) {
+ LaunchedEffect(uiState.channels, uiState.programsByChannel) {
if (uiState.channels.isEmpty()) {
focusedChannel = null
focusedProgram = null
@@ -209,16 +208,9 @@ fun FullEpgScreen(
it.endTime == focused.endTime &&
it.title == focused.title
}
- } ?: resolvedPrograms.firstOrNull { now in it.startTime until it.endTime }
- }
-
- val heroSelection = remember(uiState, focusedChannel, focusedProgram, now) {
- resolveGuideHeroSelection(
- uiState = uiState,
- focusedChannel = focusedChannel,
- focusedProgram = focusedProgram,
- now = now
- )
+ } ?: resolvedPrograms.firstOrNull {
+ System.currentTimeMillis() in it.startTime until it.endTime
+ }
}
AppScreenScaffold(
@@ -301,22 +293,16 @@ fun FullEpgScreen(
}
else -> {
- ImmersiveGuideHero(
- selection = heroSelection,
- providerLabel = uiState.providerSourceLabel,
- selectedCategoryName = uiState.categories
- .firstOrNull { it.id == uiState.selectedCategoryId }
- ?.name
- .orEmpty(),
- isGuideStale = uiState.isGuideStale,
- channelCount = uiState.totalChannelCount,
- channelsWithSchedule = uiState.channelsWithSchedule,
- lastUpdatedAt = uiState.lastUpdatedAt,
- isRefreshing = uiState.isRefreshing,
- modifier = Modifier
- .fillMaxWidth()
- .padding(horizontal = 14.dp, vertical = 4.dp)
- )
+ GuideNowProvider {
+ GuideHeroSection(
+ uiState = uiState,
+ focusedChannel = focusedChannel,
+ focusedProgram = focusedProgram,
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 14.dp, vertical = 4.dp)
+ )
+ }
GuideToolbarRow(
selectedCategoryName = uiState.categories
.firstOrNull { it.id == uiState.selectedCategoryId }
@@ -349,43 +335,44 @@ fun FullEpgScreen(
trackColor = SurfaceHighlight
)
}
- EpgGrid(
- modifier = Modifier
- .fillMaxWidth()
- .weight(1f),
- channels = uiState.channels,
- favoriteChannelIds = uiState.favoriteChannelIds,
- programsByChannel = uiState.programsByChannel,
- guideWindowStart = uiState.guideWindowStart,
- guideWindowEnd = uiState.guideWindowEnd,
- density = uiState.selectedDensity,
- now = now,
- onChannelClick = { channel ->
- if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
- requestLockedGuideAction(LockedGuideAction.PlayChannel(channel, returnRoute))
- } else {
- onPlayChannel(channel, returnRoute)
- }
- },
- onProgramClick = { channel, program ->
- topNavVisible = false
- if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
- requestLockedGuideAction(LockedGuideAction.OpenProgram(channel, program))
- } else {
- selectedProgram = channel to program
+ GuideNowProvider {
+ EpgGrid(
+ modifier = Modifier
+ .fillMaxWidth()
+ .weight(1f),
+ channels = uiState.channels,
+ favoriteChannelIds = uiState.favoriteChannelIds,
+ programsByChannel = uiState.programsByChannel,
+ guideWindowStart = uiState.guideWindowStart,
+ guideWindowEnd = uiState.guideWindowEnd,
+ density = uiState.selectedDensity,
+ onChannelClick = { channel ->
+ if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
+ requestLockedGuideAction(LockedGuideAction.PlayChannel(channel, returnRoute))
+ } else {
+ onPlayChannel(channel, returnRoute)
+ }
+ },
+ onProgramClick = { channel, program ->
+ topNavVisible = false
+ if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
+ requestLockedGuideAction(LockedGuideAction.OpenProgram(channel, program))
+ } else {
+ selectedProgram = channel to program
+ }
+ },
+ onChannelFocused = { channel, currentProgram, isFirstRow ->
+ topNavVisible = isFirstRow
+ focusedChannel = channel
+ focusedProgram = currentProgram
+ },
+ onProgramFocused = { channel, program, isFirstRow ->
+ topNavVisible = isFirstRow
+ focusedChannel = channel
+ focusedProgram = program
}
- },
- onChannelFocused = { channel, currentProgram, isFirstRow ->
- topNavVisible = isFirstRow
- focusedChannel = channel
- focusedProgram = currentProgram
- },
- onProgramFocused = { channel, program, isFirstRow ->
- topNavVisible = isFirstRow
- focusedChannel = channel
- focusedProgram = program
- }
- )
+ )
+ }
}
}
}
@@ -481,42 +468,44 @@ fun FullEpgScreen(
val dialogState = selectedProgram
if (dialogState != null) {
- val (channel, program) = dialogState
- CompactGuideProgramDialog(
- channel = channel,
- program = program,
- providerLabel = uiState.providerSourceLabel,
- now = now,
- onDismiss = { selectedProgram = null },
- onWatchLive = {
- selectedProgram = null
- if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
- requestLockedGuideAction(LockedGuideAction.PlayChannel(channel, returnRoute))
- } else {
- onPlayChannel(channel, returnRoute)
- }
- },
- onWatchArchive = if (program.hasArchive || channel.catchUpSupported) {
- {
+ GuideNowProvider {
+ val (channel, program) = dialogState
+ CompactGuideProgramDialog(
+ channel = channel,
+ program = program,
+ providerLabel = uiState.providerSourceLabel,
+ now = currentGuideNow(),
+ onDismiss = { selectedProgram = null },
+ onWatchLive = {
selectedProgram = null
if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
- requestLockedGuideAction(LockedGuideAction.PlayArchive(channel, program, returnRoute))
+ requestLockedGuideAction(LockedGuideAction.PlayChannel(channel, returnRoute))
} else {
- onPlayArchive(channel, program, returnRoute)
+ onPlayChannel(channel, returnRoute)
}
+ },
+ onWatchArchive = if (program.hasArchive || channel.catchUpSupported) {
+ {
+ selectedProgram = null
+ if (isGuideChannelLocked(channel, categoriesById, uiState.parentalControlLevel)) {
+ requestLockedGuideAction(LockedGuideAction.PlayArchive(channel, program, returnRoute))
+ } else {
+ onPlayArchive(channel, program, returnRoute)
+ }
+ }
+ } else {
+ null
+ },
+ onManageEpgMatch = if (channel.providerId > 0L) {
+ {
+ selectedProgram = null
+ viewModel.openEpgOverride(channel)
+ }
+ } else {
+ null
}
- } else {
- null
- },
- onManageEpgMatch = if (channel.providerId > 0L) {
- {
- selectedProgram = null
- viewModel.openEpgOverride(channel)
- }
- } else {
- null
- }
- )
+ )
+ }
}
if (overrideUiState.channel != null) {
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreenDialogs.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreenDialogs.kt
index 3066c691..0a61e476 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreenDialogs.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgScreenDialogs.kt
@@ -516,7 +516,10 @@ internal fun EpgOverrideDialog(
.heightIn(max = 320.dp),
verticalArrangement = Arrangement.spacedBy(10.dp)
) {
- items(state.candidates) { candidate ->
+ items(
+ items = state.candidates,
+ key = { candidate -> "${candidate.epgSourceId}:${candidate.xmltvChannelId}" }
+ ) { candidate ->
val isCurrent = state.currentMapping?.epgSourceId == candidate.epgSourceId &&
state.currentMapping?.xmltvChannelId == candidate.xmltvChannelId
TvClickableSurface(
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
index f501f565..ec485d34 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
@@ -19,6 +19,7 @@ import com.streamvault.domain.repository.CombinedM3uRepository
import com.streamvault.domain.repository.EpgRepository
import com.streamvault.domain.repository.EpgSourceRepository
import com.streamvault.domain.repository.FavoriteRepository
+import com.streamvault.domain.repository.LiveStreamProgramRequest
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.usecase.GetCustomCategories
import com.streamvault.data.preferences.PreferencesRepository
@@ -1081,29 +1082,31 @@ class EpgViewModel @Inject constructor(
return emptyMap()
}
- return coroutineScope {
- missingChannels
- .take(MAX_XTREAM_GUIDE_FALLBACK_CHANNELS)
- .map { channel ->
- async {
- val result = providerRepository.getProgramsForLiveStream(
- providerId = providerId,
- streamId = channel.streamId,
- epgChannelId = channel.epgChannelId,
- limit = 12
- )
- val programs = (result as? com.streamvault.domain.model.Result.Success)?.data
- .orEmpty()
- .filter { program -> program.endTime > windowStart && program.startTime < windowEnd }
- .sortedBy { program -> program.startTime }
- val lookupKey = channel.guideLookupKey() ?: return@async null
- if (programs.isEmpty()) null else lookupKey to programs
- }
- }
- .awaitAll()
- .mapNotNull { it }
- .toMap()
- }
+ val fallbackChannels = missingChannels.take(MAX_XTREAM_GUIDE_FALLBACK_CHANNELS)
+ val programsByRequest = providerRepository.getProgramsForLiveStreams(
+ providerId = providerId,
+ requests = fallbackChannels.map { channel ->
+ LiveStreamProgramRequest(
+ streamId = channel.streamId,
+ epgChannelId = channel.epgChannelId
+ )
+ },
+ limit = 12
+ )
+
+ return fallbackChannels.mapNotNull { channel ->
+ val programs = (programsByRequest[
+ LiveStreamProgramRequest(
+ streamId = channel.streamId,
+ epgChannelId = channel.epgChannelId
+ )
+ ] as? com.streamvault.domain.model.Result.Success)?.data
+ .orEmpty()
+ .filter { program -> program.endTime > windowStart && program.startTime < windowEnd }
+ .sortedBy { program -> program.startTime }
+ val lookupKey = channel.guideLookupKey() ?: return@mapNotNull null
+ if (programs.isEmpty()) null else lookupKey to programs
+ }.toMap()
}
private suspend fun buildGuideDisplaySnapshot(
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
index 0d8db2c0..a9f81b9b 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreen.kt
@@ -53,6 +53,7 @@ import com.streamvault.app.ui.components.LiveSourceSwitcher
import com.streamvault.app.ui.components.shell.ContentMetadataStrip
import com.streamvault.app.ui.components.shell.LiveChannelRowSurface
import com.streamvault.app.ui.components.shell.StatusPill
+import com.streamvault.app.ui.components.TvEmptyState
import com.streamvault.app.ui.components.dialogs.CategoryOptionsDialog
import com.streamvault.app.ui.components.dialogs.PinDialog
import com.streamvault.app.ui.components.dialogs.PremiumDialog
@@ -287,7 +288,19 @@ fun HomeScreen(
)
}
- if (uiState.isCategoriesLoading && uiState.categories.isEmpty()) {
+ if (uiState.allProviders.isEmpty() && !uiState.isCategoriesLoading) {
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .padding(24.dp),
+ contentAlignment = Alignment.Center
+ ) {
+ TvEmptyState(
+ title = stringResource(R.string.home_add_first_provider),
+ subtitle = stringResource(R.string.home_add_first_provider_subtitle)
+ )
+ }
+ } else if (uiState.isCategoriesLoading && uiState.categories.isEmpty()) {
Row(modifier = Modifier.fillMaxSize()) {
Box(
modifier = Modifier
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
index 25199d1a..d46c9e46 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt
@@ -34,6 +34,7 @@ import com.streamvault.domain.repository.ChannelRepository
import com.streamvault.domain.repository.CombinedM3uRepository
import com.streamvault.domain.repository.EpgRepository
import com.streamvault.domain.repository.FavoriteRepository
+import com.streamvault.domain.repository.LiveStreamProgramRequest
import com.streamvault.domain.repository.PlaybackHistoryRepository
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.usecase.GetCustomCategories
@@ -175,7 +176,29 @@ class HomeViewModel @Inject constructor(
observeRecentChannels(provider.id)
preferencesRepository.setLastActiveProviderId(provider.id)
}
- null -> Unit
+ null -> {
+ combinedCategoriesById = emptyMap()
+ _localChannels.value = emptyList()
+ _uiState.update {
+ it.copy(
+ provider = null,
+ activeLiveSource = null,
+ activeLiveSourceTitle = "",
+ isCombinedLiveSource = false,
+ categories = emptyList(),
+ recentChannels = emptyList(),
+ lastVisitedCategory = null,
+ selectedCategory = null,
+ filteredChannels = emptyList(),
+ hasChannels = false,
+ isLoading = false,
+ isCategoriesLoading = false,
+ errorMessage = null,
+ currentCombinedProfileMembers = emptyList(),
+ selectedCombinedSourceProviderId = null
+ )
+ }
+ }
}
}
}
@@ -985,28 +1008,30 @@ class HomeViewModel @Inject constructor(
}
val now = System.currentTimeMillis()
- return coroutineScope {
- missingChannels
- .take(10)
- .map { channel ->
- async {
- val result = providerRepository.getProgramsForLiveStream(
- providerId = providerId,
- streamId = channel.streamId,
- epgChannelId = channel.epgChannelId,
- limit = 6
- )
- val programs = (result as? Result.Success)?.data.orEmpty()
- val currentProgram = programs.firstOrNull { it.startTime <= now && it.endTime > now }
- ?: programs.firstOrNull()
- val lookupKey = channel.guideLookupKey() ?: return@async null
- currentProgram?.let { lookupKey to it }
- }
- }
- .awaitAll()
- .mapNotNull { it }
- .toMap()
- }
+ val fallbackChannels = missingChannels.take(10)
+ val programsByRequest = providerRepository.getProgramsForLiveStreams(
+ providerId = providerId,
+ requests = fallbackChannels.map { channel ->
+ LiveStreamProgramRequest(
+ streamId = channel.streamId,
+ epgChannelId = channel.epgChannelId
+ )
+ },
+ limit = 6
+ )
+
+ return fallbackChannels.mapNotNull { channel ->
+ val programs = (programsByRequest[
+ LiveStreamProgramRequest(
+ streamId = channel.streamId,
+ epgChannelId = channel.epgChannelId
+ )
+ ] as? Result.Success)?.data.orEmpty()
+ val currentProgram = programs.firstOrNull { it.startTime <= now && it.endTime > now }
+ ?: programs.firstOrNull()
+ val lookupKey = channel.guideLookupKey() ?: return@mapNotNull null
+ currentProgram?.let { lookupKey to it }
+ }.toMap()
}
fun updateVisibleChannelWindow(channelIds: List<Long>, focusedChannelId: Long? = null) {
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
index cc97b392..9aa97500 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt
@@ -184,6 +184,20 @@ fun MoviesScreen(
subtitle = uiState.errorMessage ?: ""
)
}
+ } else if (!uiState.hasProviders) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ AppMessageState(
+ title = stringResource(R.string.home_add_first_provider),
+ subtitle = stringResource(R.string.home_add_first_provider_subtitle)
+ )
+ }
+ } else if (!uiState.hasActiveProvider || (uiState.moviesByCategory.isEmpty() && uiState.libraryCount == 0 && uiState.searchQuery.isBlank() && !uiState.isLoadingPreviewRows)) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ AppMessageState(
+ title = stringResource(R.string.vod_sync_needed_title),
+ subtitle = stringResource(R.string.vod_sync_needed_subtitle)
+ )
+ }
} else if (uiState.moviesByCategory.isEmpty() && !uiState.isLoadingPreviewRows) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
AppMessageState(
@@ -390,10 +404,16 @@ private fun MoviesVodContent(
category == null || !isCategoryHidden(category)
}
}
- val catEntries = uiState.moviesByCategory.entries
- .filter { (name, items) ->
- name != uiState.favoriteCategoryName && name in visibleCategoryNames && items.isNotEmpty()
- }.toList()
+ val visibleCategoryNameSet = remember(visibleCategoryNames) {
+ visibleCategoryNames.toSet()
+ }
+ val catEntries = remember(uiState.moviesByCategory, visibleCategoryNameSet, uiState.favoriteCategoryName) {
+ uiState.moviesByCategory.entries
+ .filter { (name, items) ->
+ name != uiState.favoriteCategoryName && name in visibleCategoryNameSet && items.isNotEmpty()
+ }
+ .toList()
+ }
val fallbackMovieId = if (heroMovie == null) {
favoriteMovies.firstOrNull()?.id
?: freshMovies.firstOrNull()?.id
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
index 2e2ec97f..c20cc445 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt
@@ -101,6 +101,31 @@ class MoviesViewModel @Inject constructor(
)
init {
+ viewModelScope.launch {
+ providerRepository.getProviders().collectLatest { providers ->
+ _uiState.update {
+ it.copy(
+ hasProviders = providers.isNotEmpty(),
+ isLoading = if (providers.isEmpty()) false else it.isLoading
+ )
+ }
+ }
+ }
+
+ viewModelScope.launch {
+ providerRepository.getActiveProvider().collectLatest { provider ->
+ activeProviderId = provider?.id
+ _uiState.update {
+ it.copy(
+ hasActiveProvider = provider != null,
+ isLoading = if (provider == null) false else it.isLoading,
+ isLoadingSelectedCategory = if (provider == null) false else it.isLoadingSelectedCategory,
+ isLoadingPreviewRows = if (provider == null) false else it.isLoadingPreviewRows
+ )
+ }
+ }
+ }
+
viewModelScope.launch {
try {
providerRepository.getActiveProvider()
@@ -1171,6 +1196,8 @@ data class MoviesUiState(
val selectedLibrarySortBy: LibrarySortBy = LibrarySortBy.LIBRARY,
val vodViewMode: VodViewMode = VodViewMode.MODERN,
val continueWatching: List<PlaybackHistory> = emptyList(),
+ val hasProviders: Boolean = false,
+ val hasActiveProvider: Boolean = false,
val isLoading: Boolean = true,
val isLoadingPreviewRows: Boolean = false,
val hasMorePreviewRows: Boolean = false,
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 650f6a0e..02dba418 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
@@ -25,6 +25,7 @@ import com.streamvault.domain.model.RecordingItem
import com.streamvault.domain.model.RecordingRecurrence
import com.streamvault.domain.model.RecordingRequest
import com.streamvault.domain.model.RecordingStatus
+import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.Series
import com.streamvault.domain.model.VirtualCategoryIds
@@ -184,6 +185,7 @@ class PlayerViewModel @Inject constructor(
internal val triedAlternativeStreams = mutableSetOf<String>()
private val failedStreamsThisSession = mutableMapOf<String, Int>()
private var hasRetriedWithSoftwareDecoder = false
+ private var hasRetriedXtreamAuthRefresh = false
internal var lastRecordedLivePlaybackKey: Pair<Long, Long>? = null
private var currentStreamClassLabel: String = "Primary"
private var prepareRequestVersion: Long = 0L
@@ -346,21 +348,25 @@ class PlayerViewModel @Inject constructor(
)
return
}
- val recoveryType = classifyPlaybackError(error)
- val channel = currentChannelFlow.value?.sanitizedForPlayer()
-
- if (currentContentType != ContentType.LIVE || channel == null) {
- if (!isActivePlaybackSession(requestVersion, playbackUrl)) return
- showPlayerNotice(
- message = resolvePlaybackErrorMessage(error),
- recoveryType = recoveryType,
- actions = buildRecoveryActions(recoveryType)
- )
- return
- }
-
recoveryJob = viewModelScope.launch {
if (!isActivePlaybackSession(requestVersion, playbackUrl)) return@launch
+ if (tryRefreshXtreamPlaybackAfterAuthError(error, requestVersion, playbackUrl)) {
+ return@launch
+ }
+
+ val recoveryType = classifyPlaybackError(error)
+ val channel = currentChannelFlow.value?.sanitizedForPlayer()
+
+ if (currentContentType != ContentType.LIVE || channel == null) {
+ if (!isActivePlaybackSession(requestVersion, playbackUrl)) return@launch
+ showPlayerNotice(
+ message = resolvePlaybackErrorMessage(error),
+ recoveryType = recoveryType,
+ actions = buildRecoveryActions(recoveryType)
+ )
+ return@launch
+ }
+
if (isCatchUpPlayback()) {
markStreamFailure(currentStreamUrl)
setLastFailureReason(error.message)
@@ -566,6 +572,7 @@ class PlayerViewModel @Inject constructor(
internal fun beginPlaybackSession(): Long {
recoveryJob?.cancel()
+ hasRetriedXtreamAuthRefresh = false
return ++prepareRequestVersion
}
@@ -743,6 +750,23 @@ class PlayerViewModel @Inject constructor(
requestVersion: Long
): Boolean {
if (!isActivePlaybackSession(requestVersion)) return false
+
+ // Fast-path expiry check: if the stream URL already carries an expiration timestamp
+ // that is in the past, skip the network probe entirely and surface a clear message.
+ val expiry = streamInfo.expirationTime
+ if (expiry != null && expiry > 0L && expiry < System.currentTimeMillis()) {
+ if (!isActivePlaybackSession(requestVersion)) return false
+ val expiryMessage = "This stream's subscription has expired. " +
+ "Please renew your subscription with the provider."
+ setLastFailureReason(expiryMessage)
+ showPlayerNotice(
+ message = expiryMessage,
+ recoveryType = PlayerRecoveryType.SOURCE,
+ actions = buildRecoveryActions(PlayerRecoveryType.SOURCE)
+ )
+ return false
+ }
+
probePlaybackUrl(streamInfo.url)?.let { failure ->
if (!isActivePlaybackSession(requestVersion)) return false
setLastFailureReason(failure.message)
@@ -1493,6 +1517,58 @@ class PlayerViewModel @Inject constructor(
}
}
+ private suspend fun tryRefreshXtreamPlaybackAfterAuthError(
+ error: PlayerError,
+ requestVersion: Long,
+ playbackUrl: String
+ ): Boolean {
+ if (hasRetriedXtreamAuthRefresh) return false
+ if (error !is PlayerError.NetworkError) return false
+ if (!isAuthExpiryPlaybackError(error.message)) return false
+ if (!isXtreamPlaybackSession()) return false
+
+ val refreshedStreamInfo = resolvePlaybackStreamInfo(
+ logicalUrl = currentStreamUrl,
+ internalContentId = currentContentId,
+ providerId = currentProviderId,
+ contentType = currentContentType
+ ) ?: return false
+
+ if (!isActivePlaybackSession(requestVersion, playbackUrl)) return false
+
+ hasRetriedXtreamAuthRefresh = true
+ setLastFailureReason(error.message)
+ appendRecoveryAction("Refreshed Xtream playback URL after auth failure")
+ showPlayerNotice(
+ message = "Refreshing the provider playback URL…",
+ recoveryType = PlayerRecoveryType.NETWORK,
+ actions = buildRecoveryActions(PlayerRecoveryType.NETWORK),
+ isRetryNotice = true
+ )
+ if (!preparePlayer(refreshedStreamInfo, requestVersion)) return true
+ playerEngine.play()
+ return true
+ }
+
+ private suspend fun isXtreamPlaybackSession(): Boolean {
+ val providerId = currentProviderId.takeIf { it > 0L } ?: return false
+ val provider = providerRepository.getProvider(providerId) ?: return false
+ if (provider.type != ProviderType.XTREAM_CODES) return false
+ return xtreamStreamUrlResolver.isInternalStreamUrl(currentStreamUrl) ||
+ xtreamStreamUrlResolver.isInternalStreamUrl(currentResolvedPlaybackUrl)
+ }
+
+ private fun isAuthExpiryPlaybackError(message: String?): Boolean {
+ val normalized = message.orEmpty().lowercase(Locale.ROOT)
+ return "401" in normalized ||
+ "403" in normalized ||
+ "unauthorized" in normalized ||
+ "forbidden" in normalized ||
+ "authentication" in normalized ||
+ "token" in normalized ||
+ "expired" in normalized
+ }
+
private fun setLastFailureReason(message: String?) {
_playerDiagnostics.update { it.copy(lastFailureReason = message?.takeIf { reason -> reason.isNotBlank() }) }
}
@@ -2019,6 +2095,7 @@ class PlayerViewModel @Inject constructor(
aspectRatioJob?.cancel()
recentChannelsJob?.cancel()
lastVisitedCategoryJob?.cancel()
+ seekThumbnailProvider.clearCache()
playerEngine.release()
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModelActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModelActions.kt
index 1e1ddc68..688603bc 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModelActions.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModelActions.kt
@@ -14,6 +14,14 @@ import kotlinx.coroutines.launch
fun PlayerViewModel.castCurrentMedia(onRouteSelectionRequired: () -> Unit) {
viewModelScope.launch {
+ if (currentStreamUrl.isCastUnsupportedProtocol()) {
+ showPlayerNotice(
+ message = "RTSP and RTMP streams are not supported for casting.",
+ recoveryType = PlayerRecoveryType.SOURCE
+ )
+ return@launch
+ }
+
val request = buildCastRequest()
if (request == null) {
showPlayerNotice(
@@ -217,3 +225,11 @@ internal fun StreamInfo.inferCastStreamType(): StreamType {
else -> StreamType.PROGRESSIVE
}
}
+
+private fun String.isCastUnsupportedProtocol(): Boolean {
+ val normalizedUrl = trim().lowercase()
+ return normalizedUrl.startsWith("rtsp://") ||
+ normalizedUrl.startsWith("rtsps://") ||
+ normalizedUrl.startsWith("rtmp://") ||
+ normalizedUrl.startsWith("rtmps://")
+}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/SeekThumbnailProvider.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/SeekThumbnailProvider.kt
index c3ab9784..e9bc26cd 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/SeekThumbnailProvider.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/SeekThumbnailProvider.kt
@@ -10,6 +10,7 @@ import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
import kotlin.math.roundToInt
@Singleton
@@ -19,6 +20,12 @@ class SeekThumbnailProvider @Inject constructor(
companion object {
private const val FRAME_BUCKET_MS = 10_000L
private const val MAX_PREVIEW_WIDTH = 480
+ /**
+ * Maximum time to wait for [MediaMetadataRetriever] to open a remote URL and extract
+ * a frame. Without this, [MediaMetadataRetriever.setDataSource] on a slow or live HTTP
+ * stream can block a [kotlinx.coroutines.Dispatchers.IO] thread indefinitely.
+ */
+ private const val RETRIEVER_TIMEOUT_MS = 8_000L
}
private val bitmapCache = object : LruCache<String, Bitmap>((Runtime.getRuntime().maxMemory() / 1024L / 24L).toInt()) {
@@ -45,31 +52,39 @@ class SeekThumbnailProvider @Inject constructor(
val cacheKey = "$streamUrl#$bucketPosition"
bitmapCache.get(cacheKey)?.let { return@withContext it }
- val retriever = MediaMetadataRetriever()
- try {
- val uri = Uri.parse(streamUrl)
- when (uri.scheme?.lowercase()) {
- "content", "file" -> retriever.setDataSource(context, uri)
- else -> retriever.setDataSource(streamUrl, emptyMap())
- }
+ // withTimeoutOrNull guards against MediaMetadataRetriever.setDataSource() hanging
+ // indefinitely on a remote HTTP URL (e.g. a live stream with no file extension).
+ withTimeoutOrNull(RETRIEVER_TIMEOUT_MS) {
+ val retriever = MediaMetadataRetriever()
+ try {
+ val uri = Uri.parse(streamUrl)
+ when (uri.scheme?.lowercase()) {
+ "content", "file" -> retriever.setDataSource(context, uri)
+ else -> retriever.setDataSource(streamUrl, emptyMap())
+ }
- val rawBitmap = retriever.getFrameAtTime(bucketPosition * 1000L, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
- ?: retriever.getFrameAtTime(bucketPosition * 1000L)
- ?: return@withContext null
+ val rawBitmap = retriever.getFrameAtTime(bucketPosition * 1000L, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+ ?: retriever.getFrameAtTime(bucketPosition * 1000L)
+ ?: return@withTimeoutOrNull null
- val scaledBitmap = rawBitmap.scaleDown(MAX_PREVIEW_WIDTH)
- bitmapCache.put(cacheKey, scaledBitmap)
- scaledBitmap
- } catch (_: Exception) {
- null
- } finally {
- runCatching { retriever.release() }
+ val scaledBitmap = rawBitmap.scaleDown(MAX_PREVIEW_WIDTH)
+ bitmapCache.put(cacheKey, scaledBitmap)
+ scaledBitmap
+ } catch (_: Exception) {
+ null
+ } finally {
+ runCatching { retriever.release() }
+ }
}
}
+ fun clearCache() {
+ bitmapCache.evictAll()
+ }
+
private fun Bitmap.scaleDown(maxWidth: Int): Bitmap {
if (width <= maxWidth || width <= 0 || height <= 0) return this
val scaledHeight = (height * (maxWidth.toFloat() / width.toFloat())).roundToInt().coerceAtLeast(1)
return Bitmap.createScaledBitmap(this, maxWidth, scaledHeight, true)
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
index 9ce39642..d07629bc 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupScreen.kt
@@ -1,5 +1,6 @@
package com.streamvault.app.ui.screens.provider
+import androidx.activity.compose.BackHandler
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.core.animateFloatAsState
@@ -40,6 +41,7 @@ import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.AnnotatedString
@@ -80,6 +82,7 @@ private enum class SourceType { XTREAM, M3U_URL, M3U_FILE }
@Composable
fun ProviderSetupScreen(
onProviderAdded: () -> Unit,
+ onBack: () -> Unit,
editProviderId: Long? = null,
initialImportUri: String? = null,
viewModel: ProviderSetupViewModel = hiltViewModel()
@@ -98,6 +101,7 @@ fun ProviderSetupScreen(
var password by rememberSaveable { mutableStateOf("") }
var fileImportError by rememberSaveable { mutableStateOf<String?>(null) }
var handledInitialImportUri by rememberSaveable { mutableStateOf<String?>(null) }
+ var showDiscardDraftDialog by rememberSaveable { mutableStateOf(false) }
// ?? File import helper ????????????????????????????????????????????????????
fun importM3uUri(uri: android.net.Uri) {
@@ -236,6 +240,21 @@ fun ProviderSetupScreen(
}
}
+ val hasUnsavedDraft = !uiState.isEditing && name.isBlank() && (
+ serverUrl.isNotBlank() ||
+ username.isNotBlank() ||
+ password.isNotBlank() ||
+ m3uUrl.isNotBlank()
+ )
+
+ BackHandler {
+ if (hasUnsavedDraft) {
+ showDiscardDraftDialog = true
+ } else {
+ onBack()
+ }
+ }
+
// ?? Layout ????????????????????????????????????????????????????????????????
BoxWithConstraints(
modifier = Modifier
@@ -318,6 +337,29 @@ fun ProviderSetupScreen(
if (uiState.syncProgress != null) {
SyncProgressDialog(message = uiState.syncProgress!!)
}
+
+ if (showDiscardDraftDialog) {
+ androidx.compose.material3.AlertDialog(
+ onDismissRequest = { showDiscardDraftDialog = false },
+ title = { Text(stringResource(R.string.setup_discard_draft_title)) },
+ text = { Text(stringResource(R.string.setup_discard_draft_body), color = OnSurface) },
+ confirmButton = {
+ TextButton(
+ onClick = {
+ showDiscardDraftDialog = false
+ onBack()
+ }
+ ) {
+ Text(stringResource(R.string.setup_discard_draft_confirm), color = Primary)
+ }
+ },
+ dismissButton = {
+ TextButton(onClick = { showDiscardDraftDialog = false }) {
+ Text(stringResource(R.string.setup_discard_draft_cancel), color = OnSurface)
+ }
+ }
+ )
+ }
}
// ??? Form content ?????????????????????????????????????????????????????????????
@@ -917,6 +959,7 @@ private fun ProviderTextField(
var hasInputFocus by remember { mutableStateOf(false) }
var acceptsInput by remember(isTelevisionDevice) { mutableStateOf(!isTelevisionDevice) }
var pendingInputActivation by remember { mutableStateOf(false) }
+ var editBaselineValue by remember { mutableStateOf(value) }
var fieldValue by remember {
mutableStateOf(TextFieldValue(text = value, selection = TextRange(value.length)))
}
@@ -939,6 +982,9 @@ private fun ProviderTextField(
}
fun activateInput() {
+ if (!acceptsInput) {
+ editBaselineValue = value
+ }
if (!isTelevisionDevice) {
acceptsInput = true
inputFocusRequester.requestFocus()
@@ -1058,6 +1104,20 @@ private fun ProviderTextField(
}
val cursor = fieldValue.selection.end
when (event.nativeKeyEvent.keyCode) {
+ android.view.KeyEvent.KEYCODE_BACK -> {
+ fieldValue = TextFieldValue(
+ text = editBaselineValue,
+ selection = TextRange(editBaselineValue.length)
+ )
+ if (editBaselineValue != value) {
+ onValueChange(editBaselineValue)
+ }
+ acceptsInput = false
+ pendingInputActivation = false
+ keyboardController?.hide()
+ containerFocusRequester.requestFocus()
+ true
+ }
android.view.KeyEvent.KEYCODE_DPAD_LEFT -> {
val nextCursor = (cursor - 1).coerceAtLeast(0)
fieldValue = fieldValue.copy(selection = TextRange(nextCursor))
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupViewModel.kt
index d03599e3..a0115bb2 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/provider/ProviderSetupViewModel.kt
@@ -2,6 +2,12 @@ package com.streamvault.app.ui.screens.provider
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
+import com.streamvault.data.remote.xtream.XtreamAuthenticationException
+import com.streamvault.data.remote.xtream.XtreamNetworkException
+import com.streamvault.data.remote.xtream.XtreamParsingException
+import com.streamvault.data.remote.xtream.XtreamRequestException
+import com.streamvault.data.remote.xtream.XtreamResponseTooLargeException
+import com.streamvault.data.security.CredentialDecryptionException
import com.streamvault.domain.model.ActiveLiveSource
import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderType
@@ -19,6 +25,14 @@ import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
+import java.io.InterruptedIOException
+import java.net.ConnectException
+import java.net.NoRouteToHostException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import java.security.cert.CertificateException
+import javax.net.ssl.SSLException
+import javax.net.ssl.SSLPeerUnverifiedException
@HiltViewModel
class ProviderSetupViewModel @Inject constructor(
@@ -128,28 +142,13 @@ class ProviderSetupViewModel @Inject constructor(
}
}
is ValidateAndAddProviderResult.Error -> {
- val normalizedMessage = result.message.lowercase()
- val userMessage = when {
- normalizedMessage.contains("certificate") ||
- normalizedMessage.contains("trust") ->
- "Secure connection failed - the server's TLS certificate is not trusted on this device"
- normalizedMessage.contains("provider login succeeded") ||
- normalizedMessage.contains("initial sync failed") ->
- "Login succeeded, but the initial sync failed while loading the playlist"
- normalizedMessage.contains("authentication failed") ||
- normalizedMessage.contains("invalid credentials") ||
- (normalizedMessage.contains("username") && normalizedMessage.contains("password")) ->
- "Login failed - please check your credentials and server URL"
- normalizedMessage.contains("temporarily busy") ->
- "Server is temporarily busy - try syncing again in a moment"
- normalizedMessage.contains("unable to connect") ||
- normalizedMessage.contains("timeout") ||
- normalizedMessage.contains("network") ->
- "Cannot reach server - check your internet connection and server URL"
- else -> result.message
- }
_uiState.update {
- it.copy(isLoading = false, error = userMessage, validationError = null, syncProgress = null)
+ it.copy(
+ isLoading = false,
+ error = mapXtreamLoginError(result),
+ validationError = null,
+ syncProgress = null
+ )
}
}
}
@@ -244,6 +243,65 @@ class ProviderSetupViewModel @Inject constructor(
)
}
}
+
+ private fun mapXtreamLoginError(result: ValidateAndAddProviderResult.Error): String {
+ val failure = result.exception
+ return when {
+ result.message.startsWith(PROVIDER_LOGIN_SYNC_FAILED_PREFIX, ignoreCase = true) ->
+ "Login succeeded, but the initial sync failed while loading the playlist"
+
+ failure.hasCause<CredentialDecryptionException>() ->
+ failure.findCause<CredentialDecryptionException>()?.message
+ ?: CredentialDecryptionException.MESSAGE
+
+ failure.hasCause<SSLPeerUnverifiedException>() ||
+ failure.hasCause<CertificateException>() ||
+ failure.hasCause<SSLException>() ->
+ "Secure connection failed - the server's TLS certificate is not trusted on this device"
+
+ failure.hasCause<XtreamAuthenticationException>() ->
+ "Login failed - please check your credentials and server URL"
+
+ failure.findCause<XtreamRequestException>()?.statusCode in setOf(403, 408, 429) ->
+ "Server is temporarily busy - try syncing again in a moment"
+
+ failure.findCause<XtreamRequestException>()?.statusCode == 401 ->
+ "Login failed - please check your credentials and server URL"
+
+ failure.findCause<XtreamRequestException>()?.statusCode in 500..599 ->
+ "Server is temporarily busy - try syncing again in a moment"
+
+ failure.hasCause<SocketTimeoutException>() ||
+ failure.hasCause<InterruptedIOException>() ||
+ failure.hasCause<UnknownHostException>() ||
+ failure.hasCause<ConnectException>() ||
+ failure.hasCause<NoRouteToHostException>() ||
+ failure.hasCause<XtreamNetworkException>() ->
+ "Cannot reach server - check your internet connection and server URL"
+
+ failure.hasCause<XtreamResponseTooLargeException>() ->
+ "Server returned an unusually large response - try again later or contact the provider"
+
+ failure.hasCause<XtreamParsingException>() ->
+ "Server returned unreadable data - verify the provider details and try again"
+
+ else -> result.message
+ }
+ }
+
+ private inline fun <reified T : Throwable> Throwable?.findCause(): T? {
+ return generateSequence(this) { it.cause }
+ .filterIsInstance<T>()
+ .firstOrNull()
+ }
+
+ private inline fun <reified T : Throwable> Throwable?.hasCause(): Boolean =
+ findCause<T>() != null
+
+ private companion object {
+ private const val PROVIDER_LOGIN_SYNC_FAILED_PREFIX =
+ "Provider login succeeded, but initial sync failed"
+ }
}
data class ProviderSetupState(
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
index 7a6419b0..86b4b89d 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt
@@ -185,6 +185,20 @@ fun SeriesScreen(
subtitle = uiState.errorMessage ?: ""
)
}
+ } else if (!uiState.hasProviders) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ AppMessageState(
+ title = stringResource(R.string.home_add_first_provider),
+ subtitle = stringResource(R.string.home_add_first_provider_subtitle)
+ )
+ }
+ } else if (!uiState.hasActiveProvider || (uiState.seriesByCategory.isEmpty() && uiState.libraryCount == 0 && uiState.searchQuery.isBlank() && !uiState.isLoadingPreviewRows)) {
+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ AppMessageState(
+ title = stringResource(R.string.vod_sync_needed_title),
+ subtitle = stringResource(R.string.vod_sync_needed_subtitle)
+ )
+ }
} else if (uiState.seriesByCategory.isEmpty() && !uiState.isLoadingPreviewRows) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
AppMessageState(
@@ -389,10 +403,16 @@ private fun SeriesVodContent(
category == null || !isCategoryHidden(category)
}
}
- val catEntries = uiState.seriesByCategory.entries
- .filter { (name, items) ->
- name != uiState.favoriteCategoryName && name in visibleCategoryNames && items.isNotEmpty()
- }.toList()
+ val visibleCategoryNameSet = remember(visibleCategoryNames) {
+ visibleCategoryNames.toSet()
+ }
+ val catEntries = remember(uiState.seriesByCategory, visibleCategoryNameSet, uiState.favoriteCategoryName) {
+ uiState.seriesByCategory.entries
+ .filter { (name, items) ->
+ name != uiState.favoriteCategoryName && name in visibleCategoryNameSet && items.isNotEmpty()
+ }
+ .toList()
+ }
val fallbackSeriesId = if (heroSeries == null) {
favoriteSeries.firstOrNull()?.id
?: freshSeries.firstOrNull()?.id
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
index d195e839..f0a8b9d9 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt
@@ -100,6 +100,31 @@ class SeriesViewModel @Inject constructor(
)
init {
+ viewModelScope.launch {
+ providerRepository.getProviders().collectLatest { providers ->
+ _uiState.update {
+ it.copy(
+ hasProviders = providers.isNotEmpty(),
+ isLoading = if (providers.isEmpty()) false else it.isLoading
+ )
+ }
+ }
+ }
+
+ viewModelScope.launch {
+ providerRepository.getActiveProvider().collectLatest { provider ->
+ activeProviderId = provider?.id
+ _uiState.update {
+ it.copy(
+ hasActiveProvider = provider != null,
+ isLoading = if (provider == null) false else it.isLoading,
+ isLoadingSelectedCategory = if (provider == null) false else it.isLoadingSelectedCategory,
+ isLoadingPreviewRows = if (provider == null) false else it.isLoadingPreviewRows
+ )
+ }
+ }
+ }
+
viewModelScope.launch {
try {
providerRepository.getActiveProvider()
@@ -1178,6 +1203,8 @@ data class SeriesUiState(
val selectedLibrarySortBy: LibrarySortBy = LibrarySortBy.LIBRARY,
val vodViewMode: VodViewMode = VodViewMode.MODERN,
val continueWatching: List<PlaybackHistory> = emptyList(),
+ val hasProviders: Boolean = false,
+ val hasActiveProvider: Boolean = false,
val isLoading: Boolean = true,
val isLoadingPreviewRows: Boolean = false,
val hasMorePreviewRows: Boolean = false,
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsDialogComponents.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsDialogComponents.kt
index 95bfa263..a2089e24 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsDialogComponents.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsDialogComponents.kt
@@ -23,6 +23,7 @@ import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.TextRange
@@ -40,6 +41,7 @@ import com.streamvault.app.localization.supportedAppLanguageTags
import com.streamvault.app.ui.components.dialogs.PremiumDialog
import com.streamvault.app.ui.components.dialogs.PremiumDialogActionButton
import com.streamvault.app.ui.components.dialogs.PremiumDialogFooterButton
+import com.streamvault.app.ui.components.dialogs.rememberDialogOpenGestureBlocker
import com.streamvault.app.ui.design.FocusSpec
import com.streamvault.app.ui.interaction.TvButton
import com.streamvault.app.ui.interaction.TvClickableSurface
@@ -70,13 +72,20 @@ internal fun PremiumSelectionDialog(
content: @Composable ColumnScope.() -> Unit
) {
val isTelevisionDevice = com.streamvault.app.device.rememberIsTelevisionDevice()
- Dialog(onDismissRequest = onDismiss) {
+ var canInteract by remember { mutableStateOf(false) }
+ val blockOpenGesture = rememberDialogOpenGestureBlocker(canInteract)
+ LaunchedEffect(Unit) {
+ kotlinx.coroutines.delay(500)
+ canInteract = true
+ }
+ Dialog(onDismissRequest = { if (canInteract) onDismiss() }) {
val dialogContent: @Composable (Modifier) -> Unit = { resolvedModifier ->
androidx.compose.material3.Surface(
shape = RoundedCornerShape(14.dp),
color = SurfaceElevated,
modifier = resolvedModifier
.border(1.dp, Primary.copy(alpha = 0.4f), RoundedCornerShape(14.dp))
+ .onPreviewKeyEvent(blockOpenGesture)
) {
Column(
modifier = Modifier.padding(18.dp),
@@ -99,7 +108,7 @@ internal fun PremiumSelectionDialog(
horizontalArrangement = Arrangement.End
) {
TvClickableSurface(
- onClick = onDismiss,
+ onClick = { if (canInteract) onDismiss() },
shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(6.dp)),
colors = ClickableSurfaceDefaults.colors(
containerColor = Primary.copy(alpha = 0.2f),
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt
index 5381aad9..ee879a7e 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt
@@ -200,11 +200,19 @@ internal class SettingsProviderActions(
}
private suspend fun runQuickSync(providerId: Long, providerName: String?) {
+ val provider = providerRepository.getProvider(providerId)
+ val pendingXtreamTextRefreshGeneration = provider
+ ?.takeIf { it.type == ProviderType.XTREAM_CODES }
+ ?.let { currentProvider ->
+ val currentGeneration = preferencesRepository.getXtreamTextImportGeneration()
+ val appliedGeneration = preferencesRepository.getXtreamTextImportAppliedGeneration(currentProvider.id)
+ currentGeneration.takeIf { it > appliedGeneration }
+ }
val beforeMetadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)
val result = syncProvider(
SyncProviderCommand(
providerId = providerId,
- force = false,
+ force = pendingXtreamTextRefreshGeneration != null,
movieFastSyncOverride = true,
epgSyncModeOverride = ProviderEpgSyncMode.BACKGROUND
),
@@ -219,6 +227,9 @@ internal class SettingsProviderActions(
)
if (result !is SyncProviderResult.Error) {
+ pendingXtreamTextRefreshGeneration?.let { generation ->
+ preferencesRepository.markXtreamTextImportApplied(providerId, generation)
+ }
val afterMetadata = syncMetadataRepository.getMetadata(providerId) ?: beforeMetadata
val liveRefreshed = afterMetadata.lastLiveSync > beforeMetadata.lastLiveSync ||
afterMetadata.liveCount != beforeMetadata.liveCount
@@ -267,6 +278,7 @@ internal class SettingsProviderActions(
userMessage = when {
result is SyncProviderResult.Error -> "Quick sync failed: ${result.message}"
(result as? SyncProviderResult.Success)?.isPartial == true -> "Quick sync completed with warnings: $warningsMessage"
+ pendingXtreamTextRefreshGeneration != null -> "Quick sync completed and reapplied Xtream text decoding"
!catalogRefreshed -> "Library already up to date"
else -> "Quick sync completed"
},
@@ -280,6 +292,14 @@ internal class SettingsProviderActions(
}
private suspend fun runFullSync(providerId: Long, providerName: String?) {
+ val provider = providerRepository.getProvider(providerId)
+ val pendingXtreamTextRefreshGeneration = provider
+ ?.takeIf { it.type == ProviderType.XTREAM_CODES }
+ ?.let { currentProvider ->
+ val currentGeneration = preferencesRepository.getXtreamTextImportGeneration()
+ val appliedGeneration = preferencesRepository.getXtreamTextImportAppliedGeneration(currentProvider.id)
+ currentGeneration.takeIf { it > appliedGeneration }
+ }
val result = syncProvider(
SyncProviderCommand(
providerId = providerId,
@@ -294,6 +314,9 @@ internal class SettingsProviderActions(
}
)
if (result !is SyncProviderResult.Error) {
+ pendingXtreamTextRefreshGeneration?.let { generation ->
+ preferencesRepository.markXtreamTextImportApplied(providerId, generation)
+ }
tvInputChannelSyncManager.refreshTvInputCatalog()
}
uiState.update { state ->
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
index 21bbce8d..4fd7060e 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreen.kt
@@ -58,6 +58,8 @@ import androidx.documentfile.provider.DocumentFile
import com.streamvault.app.ui.interaction.TvClickableSurface
import com.streamvault.app.ui.interaction.TvButton
import com.streamvault.app.ui.interaction.TvIconButton
+import com.streamvault.app.util.OfficialBuildStatus
+import com.streamvault.app.util.OfficialBuildVerifier
import com.streamvault.app.ui.components.dialogs.PinDialog
import com.streamvault.app.ui.components.dialogs.PremiumDialog
@@ -122,6 +124,10 @@ fun SettingsScreen(
val scope = rememberCoroutineScope()
val context = androidx.compose.ui.platform.LocalContext.current
val mainActivity = context.findMainActivity()
+ val officialBuildVerification = remember(context.packageName) { OfficialBuildVerifier.verify(context) }
+ val buildVerificationLabel = remember(officialBuildVerification.status, context) {
+ formatOfficialBuildStatusLabel(officialBuildVerification.status, context)
+ }
val appLanguageLabel = remember(uiState.appLanguage, context) {
displayLanguageLabel(uiState.appLanguage, context.getString(R.string.settings_system_default))
}
@@ -707,6 +713,29 @@ fun SettingsScreen(
}
}
Spacer(Modifier.height(2.dp))
+ TvClickableSurface(
+ onClick = { viewModel.toggleXtreamBase64TextCompatibility() },
+ shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(8.dp)),
+ colors = ClickableSurfaceDefaults.colors(
+ containerColor = Color.Transparent,
+ focusedContainerColor = Primary.copy(alpha = 0.15f)
+ ),
+ scale = ClickableSurfaceDefaults.scale(focusedScale = 1f),
+ modifier = Modifier.fillMaxWidth()
+ ) {
+ Row(
+ modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Column(modifier = Modifier.weight(1f)) {
+ Text(text = stringResource(R.string.settings_xtream_base64_compatibility), style = MaterialTheme.typography.bodyMedium, color = OnSurface)
+ Text(text = stringResource(R.string.settings_xtream_base64_compatibility_subtitle), style = MaterialTheme.typography.bodySmall, color = OnBackground.copy(alpha = 0.6f))
+ }
+ Switch(checked = uiState.xtreamBase64TextCompatibility, onCheckedChange = { viewModel.toggleXtreamBase64TextCompatibility() })
+ }
+ }
+ Spacer(Modifier.height(2.dp))
TvClickableSurface(
onClick = { showClearHistoryDialog = true },
shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(8.dp)),
@@ -927,6 +956,7 @@ fun SettingsScreen(
item {
SettingsRow(label = stringResource(R.string.settings_build), value = stringResource(R.string.settings_build_desc))
+ SettingsRow(label = stringResource(R.string.settings_build_verification), value = buildVerificationLabel)
SettingsRow(label = stringResource(R.string.settings_developed_by), value = stringResource(R.string.settings_developer_name))
ClickableSettingsRow(
label = stringResource(R.string.settings_github),
@@ -1033,6 +1063,15 @@ fun SettingsScreen(
}
}
+private fun formatOfficialBuildStatusLabel(
+ status: OfficialBuildStatus,
+ context: android.content.Context
+): String = when (status) {
+ OfficialBuildStatus.OFFICIAL -> context.getString(R.string.settings_build_verification_official)
+ OfficialBuildStatus.UNOFFICIAL -> context.getString(R.string.settings_build_verification_unofficial)
+ OfficialBuildStatus.VERIFICATION_UNAVAILABLE -> context.getString(R.string.settings_build_verification_unavailable)
+}
+
private fun android.content.Context.findMainActivity(): MainActivity? {
var current: android.content.Context? = this
while (current is android.content.ContextWrapper) {
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsStateBindings.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsStateBindings.kt
index cefa3ce4..e35671bd 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsStateBindings.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsStateBindings.kt
@@ -67,6 +67,7 @@ internal fun observeSettingsPreferenceSnapshot(
lastSpeedTestEstimated = false,
isIncognitoMode = false,
useXtreamTextClassification = true,
+ xtreamBase64TextCompatibility = false,
liveTvChannelMode = LiveTvChannelMode.PRO,
showLiveSourceSwitcher = false,
liveTvCategoryFilters = emptyList(),
@@ -127,6 +128,8 @@ internal fun observeSettingsPreferenceSnapshot(
snapshot.copy(isIncognitoMode = incognito)
}.combine(preferencesRepository.useXtreamTextClassification) { snapshot, useTextClass ->
snapshot.copy(useXtreamTextClassification = useTextClass)
+ }.combine(preferencesRepository.xtreamBase64TextCompatibility) { snapshot, compatibilityEnabled ->
+ snapshot.copy(xtreamBase64TextCompatibility = compatibilityEnabled)
}.combine(preferencesRepository.liveTvChannelMode) { snapshot, liveTvChannelMode ->
snapshot.copy(liveTvChannelMode = LiveTvChannelMode.fromStorage(liveTvChannelMode))
}.combine(preferencesRepository.showLiveSourceSwitcher) { snapshot, showLiveSourceSwitcher ->
@@ -196,6 +199,7 @@ internal fun SettingsUiState.applyPreferenceSnapshot(snapshot: SettingsPreferenc
},
isIncognitoMode = snapshot.isIncognitoMode,
useXtreamTextClassification = snapshot.useXtreamTextClassification,
+ xtreamBase64TextCompatibility = snapshot.xtreamBase64TextCompatibility,
liveTvChannelMode = snapshot.liveTvChannelMode,
showLiveSourceSwitcher = snapshot.showLiveSourceSwitcher,
liveTvCategoryFilters = snapshot.liveTvCategoryFilters,
diff --git 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
index bb061f38..9df2d398 100644
--- 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
@@ -22,6 +22,7 @@ import com.streamvault.domain.manager.BackupConflictStrategy
import com.streamvault.domain.manager.BackupImportPlan
import com.streamvault.domain.manager.BackupManager
import com.streamvault.domain.manager.BackupPreview
+import com.streamvault.domain.manager.ParentalControlManager
import com.streamvault.domain.manager.RecordingManager
import com.streamvault.domain.model.Category
import com.streamvault.domain.model.CategorySortMode
@@ -73,6 +74,7 @@ class SettingsViewModel @Inject constructor(
private val internetSpeedTestRunner: InternetSpeedTestRunner,
private val backupManager: BackupManager,
private val recordingManager: RecordingManager,
+ private val parentalControlManager: ParentalControlManager,
private val syncManager: SyncManager,
private val syncMetadataRepository: SyncMetadataRepository,
private val playbackHistoryRepository: com.streamvault.domain.repository.PlaybackHistoryRepository,
@@ -550,6 +552,17 @@ class SettingsViewModel @Inject constructor(
}
}
+ fun toggleXtreamBase64TextCompatibility() {
+ viewModelScope.launch {
+ val current = _uiState.value.xtreamBase64TextCompatibility
+ preferencesRepository.setXtreamBase64TextCompatibility(!current)
+ preferencesRepository.bumpXtreamTextImportGeneration()
+ _uiState.update {
+ it.copy(userMessage = "Xtream text decoding changed. Refresh each Xtream provider once to re-import titles.")
+ }
+ }
+ }
+
fun clearHistory() {
viewModelScope.launch {
_uiState.update { it.copy(isSyncing = true) }
@@ -573,6 +586,7 @@ class SettingsViewModel @Inject constructor(
fun changePin(newPin: String) {
viewModelScope.launch {
preferencesRepository.setParentalPin(newPin)
+ parentalControlManager.clearUnlockedCategories()
_uiState.update { it.copy(userMessage = appContext.getString(R.string.settings_pin_changed)) }
}
}
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModelModels.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModelModels.kt
index 66030e40..5817e946 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModelModels.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModelModels.kt
@@ -66,6 +66,7 @@ internal data class SettingsPreferenceSnapshot(
val lastSpeedTestEstimated: Boolean,
val isIncognitoMode: Boolean,
val useXtreamTextClassification: Boolean,
+ val xtreamBase64TextCompatibility: Boolean,
val liveTvChannelMode: LiveTvChannelMode,
val showLiveSourceSwitcher: Boolean,
val liveTvCategoryFilters: List<String>,
@@ -159,6 +160,7 @@ data class SettingsUiState(
val recordingStorageState: RecordingStorageState = RecordingStorageState(),
val isIncognitoMode: Boolean = false,
val useXtreamTextClassification: Boolean = true,
+ val xtreamBase64TextCompatibility: Boolean = false,
val liveTvChannelMode: LiveTvChannelMode = LiveTvChannelMode.PRO,
val showLiveSourceSwitcher: Boolean = false,
val liveTvCategoryFilters: List<String> = emptyList(),
diff --git a/app/src/main/java/com/streamvault/app/update/AppUpdateInstaller.kt b/app/src/main/java/com/streamvault/app/update/AppUpdateInstaller.kt
index 9a1b623f..002da712 100644
--- a/app/src/main/java/com/streamvault/app/update/AppUpdateInstaller.kt
+++ b/app/src/main/java/com/streamvault/app/update/AppUpdateInstaller.kt
@@ -28,6 +28,7 @@ import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.File
+import java.net.URI
import javax.inject.Inject
import javax.inject.Singleton
@@ -151,6 +152,9 @@ class AppUpdateInstaller @Inject constructor(
suspend fun startDownload(releaseInfo: GitHubReleaseInfo): Result<Unit> = withContext(Dispatchers.IO) {
val downloadUrl = releaseInfo.downloadUrl
?: return@withContext Result.error("Update download is unavailable for this release")
+ if (!isHttpsUrl(downloadUrl)) {
+ return@withContext Result.error("Update download is unavailable because the download URL is not HTTPS")
+ }
try {
val targetFile = apkFileForVersion(releaseInfo.versionName)
@@ -195,7 +199,7 @@ class AppUpdateInstaller @Inject constructor(
}
}
- suspend fun installDownloadedUpdate(): Result<Unit> = withContext(Dispatchers.IO) {
+ suspend fun installDownloadedUpdate(expectedSha256: String? = null): Result<Unit> = withContext(Dispatchers.IO) {
val currentState = refreshState()
if (currentState.status != AppUpdateDownloadStatus.Downloaded || currentState.versionName.isNullOrBlank()) {
return@withContext Result.error("No downloaded update is ready to install")
@@ -216,6 +220,25 @@ class AppUpdateInstaller @Inject constructor(
return@withContext Result.error("Downloaded update file is missing")
}
+ // SEC-L02: Verify SHA-256 integrity before handing the APK to the package manager.
+ // This guards against a truncated download, a network MITM, or a tampered file in
+ // the external storage directory (which is world-readable on unencrypted devices).
+ if (!expectedSha256.isNullOrBlank()) {
+ val actualHash = computeSha256Hex(apkFile)
+ if (!actualHash.equals(expectedSha256.trim(), ignoreCase = true)) {
+ android.util.Log.e(
+ "AppUpdateInstaller",
+ "APK SHA-256 mismatch for ${apkFile.name}: expected=${expectedSha256.trim()} actual=$actualHash"
+ )
+ apkFile.delete()
+ preferencesRepository.setDownloadedAppUpdateVersionName(null)
+ return@withContext Result.error(
+ "Downloaded update failed integrity check. The file has been removed; please download again."
+ )
+ }
+ android.util.Log.i("AppUpdateInstaller", "APK SHA-256 verified OK for ${apkFile.name}")
+ }
+
val apkUri = FileProvider.getUriForFile(
context,
"${BuildConfig.APPLICATION_ID}.fileprovider",
@@ -238,6 +261,27 @@ class AppUpdateInstaller @Inject constructor(
}
}
+ private fun isHttpsUrl(url: String): Boolean {
+ val normalized = url.trim()
+ if (normalized.isBlank()) return false
+ return runCatching {
+ val parsed = URI(normalized)
+ parsed.scheme.equals("https", ignoreCase = true) && !parsed.host.isNullOrBlank()
+ }.getOrDefault(false)
+ }
+
+ private fun computeSha256Hex(file: File): String {
+ val digest = java.security.MessageDigest.getInstance("SHA-256")
+ file.inputStream().buffered(DEFAULT_BUFFER_SIZE).use { stream ->
+ val buffer = ByteArray(8192)
+ var read: Int
+ while (stream.read(buffer).also { read = it } != -1) {
+ digest.update(buffer, 0, read)
+ }
+ }
+ return digest.digest().joinToString("") { "%02x".format(it) }
+ }
+
private fun apkFileForVersion(versionName: String): File {
val sanitizedVersion = versionName.replace(Regex("[^A-Za-z0-9._-]"), "_")
val downloadsDir = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
@@ -255,6 +299,15 @@ class AppUpdateInstaller @Inject constructor(
}
}
+ /**
+ * Unregisters the [DownloadManager] broadcast receiver.
+ * Must be called when this singleton is torn down (e.g. in instrumentation tests that
+ * destroy and recreate the DI graph) to prevent duplicate receiver registrations.
+ */
+ fun unregister() {
+ runCatching { context.unregisterReceiver(downloadCompleteReceiver) }
+ }
+
private fun syncPollingForState(state: AppUpdateDownloadState) {
if (state.status != AppUpdateDownloadStatus.Downloading || state.downloadId == null) {
downloadPollingJob?.cancel()
diff --git a/app/src/main/java/com/streamvault/app/update/GitHubReleaseChecker.kt b/app/src/main/java/com/streamvault/app/update/GitHubReleaseChecker.kt
index 4330766c..d5bec712 100644
--- a/app/src/main/java/com/streamvault/app/update/GitHubReleaseChecker.kt
+++ b/app/src/main/java/com/streamvault/app/update/GitHubReleaseChecker.kt
@@ -5,8 +5,11 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.OkHttpClient
import okhttp3.Request
+import okhttp3.ResponseBody
import org.json.JSONObject
+import java.io.ByteArrayOutputStream
import java.io.IOException
+import java.net.URI
import javax.inject.Inject
import javax.inject.Singleton
@@ -25,7 +28,8 @@ class GitHubReleaseChecker @Inject constructor(
) {
private companion object {
private const val RELEASES_LATEST_URL = "https://api.github.com/repos/Davidona/StreamVault-IPTV/releases/latest"
- private val VERSION_CODE_REGEX = Regex("""code\s*`?(\d+)`?""", RegexOption.IGNORE_CASE)
+ private const val MAX_RESPONSE_BYTES = 512 * 1024L
+ private val STRUCTURED_TAG_REGEX = Regex("""^v?(.+?)\+(\d+)$""", RegexOption.IGNORE_CASE)
}
suspend fun fetchLatestRelease(): Result<GitHubReleaseInfo> = withContext(Dispatchers.IO) {
@@ -41,26 +45,35 @@ class GitHubReleaseChecker @Inject constructor(
return@withContext Result.error("Update check failed: HTTP ${response.code}")
}
- val body = response.body?.string().orEmpty()
+ val body = when (val bodyResult = response.body?.let(::readResponseBodyCapped)) {
+ is Result.Success -> bodyResult.data
+ is Result.Error -> return@withContext Result.error(bodyResult.message, bodyResult.exception)
+ null,
+ Result.Loading -> ""
+ }
if (body.isBlank()) {
return@withContext Result.error("Update check failed: empty GitHub release response")
}
val json = JSONObject(body)
- val tagName = json.optString("tag_name").removePrefix("v").trim()
- if (tagName.isBlank()) {
+ val parsedTag = parseTagVersionInfo(json.optString("tag_name"))
+ if (parsedTag.versionName.isBlank()) {
return@withContext Result.error("Update check failed: latest release tag is missing")
}
val notes = json.optString("body").trim()
val assets = json.optJSONArray("assets")
+ val releaseUrl = json.optString("html_url").takeIf(::isHttpsUrl).orEmpty()
+ if (releaseUrl.isBlank()) {
+ return@withContext Result.error("Update check failed: latest release URL is not HTTPS")
+ }
val downloadUrl = findApkAssetUrl(assets)
return@withContext Result.success(
GitHubReleaseInfo(
- versionName = tagName,
- versionCode = VERSION_CODE_REGEX.find(notes)?.groupValues?.getOrNull(1)?.toIntOrNull(),
- releaseUrl = json.optString("html_url"),
+ versionName = parsedTag.versionName,
+ versionCode = parsedTag.versionCode,
+ releaseUrl = releaseUrl,
downloadUrl = downloadUrl,
releaseNotes = notes,
publishedAt = json.optString("published_at").takeIf { it.isNotBlank() }
@@ -74,6 +87,34 @@ class GitHubReleaseChecker @Inject constructor(
}
}
+ private fun readResponseBodyCapped(body: ResponseBody): Result<String> {
+ val contentLength = body.contentLength()
+ if (contentLength > MAX_RESPONSE_BYTES) {
+ return Result.error("Update check failed: GitHub release response exceeded 512 KB")
+ }
+
+ val charset = body.contentType()?.charset(Charsets.UTF_8) ?: Charsets.UTF_8
+ val output = ByteArrayOutputStream()
+ val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+ var totalBytesRead = 0L
+
+ body.byteStream().use { input ->
+ while (true) {
+ val bytesRead = input.read(buffer)
+ if (bytesRead == -1) break
+
+ totalBytesRead += bytesRead
+ if (totalBytesRead > MAX_RESPONSE_BYTES) {
+ return Result.error("Update check failed: GitHub release response exceeded 512 KB")
+ }
+
+ output.write(buffer, 0, bytesRead)
+ }
+ }
+
+ return Result.success(output.toString(charset.name()))
+ }
+
private fun findApkAssetUrl(assets: org.json.JSONArray?): String? {
if (assets == null) return null
var fallback: String? = null
@@ -81,6 +122,7 @@ class GitHubReleaseChecker @Inject constructor(
val asset = assets.optJSONObject(index) ?: continue
val name = asset.optString("name")
val url = asset.optString("browser_download_url").takeIf { it.isNotBlank() } ?: continue
+ if (!isHttpsUrl(url)) continue
if (name.equals("StreamVault.apk", ignoreCase = true)) {
return url
}
@@ -90,4 +132,34 @@ class GitHubReleaseChecker @Inject constructor(
}
return fallback
}
-}
\ No newline at end of file
+
+ private fun parseTagVersionInfo(rawTagName: String): ParsedTagVersion {
+ val normalizedTag = rawTagName.trim()
+ val structuredMatch = STRUCTURED_TAG_REGEX.matchEntire(normalizedTag)
+ if (structuredMatch != null) {
+ return ParsedTagVersion(
+ versionName = structuredMatch.groupValues[1].trim(),
+ versionCode = structuredMatch.groupValues[2].toIntOrNull()
+ )
+ }
+
+ return ParsedTagVersion(
+ versionName = normalizedTag.removePrefix("v").trim(),
+ versionCode = null
+ )
+ }
+
+ private fun isHttpsUrl(url: String): Boolean {
+ val normalized = url.trim()
+ if (normalized.isBlank()) return false
+ return runCatching {
+ val parsed = URI(normalized)
+ parsed.scheme.equals("https", ignoreCase = true) && !parsed.host.isNullOrBlank()
+ }.getOrDefault(false)
+ }
+}
+
+private data class ParsedTagVersion(
+ val versionName: String,
+ val versionCode: Int?
+)
diff --git a/app/src/main/java/com/streamvault/app/util/OfficialBuildVerifier.kt b/app/src/main/java/com/streamvault/app/util/OfficialBuildVerifier.kt
new file mode 100644
index 00000000..529b60fb
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/util/OfficialBuildVerifier.kt
@@ -0,0 +1,78 @@
+package com.streamvault.app.util
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import com.streamvault.app.BuildConfig
+import java.io.ByteArrayInputStream
+import java.security.MessageDigest
+import java.security.cert.CertificateFactory
+import java.util.Locale
+
+enum class OfficialBuildStatus {
+ OFFICIAL,
+ UNOFFICIAL,
+ VERIFICATION_UNAVAILABLE
+}
+
+data class OfficialBuildVerification(
+ val status: OfficialBuildStatus,
+ val packageMatchesOfficialId: Boolean,
+ val signingCertSha256: String?
+)
+
+object OfficialBuildVerifier {
+ fun verify(context: Context): OfficialBuildVerification {
+ val expectedPackageName = BuildConfig.OFFICIAL_APPLICATION_ID.trim()
+ val expectedFingerprint = normalizeFingerprint(BuildConfig.OFFICIAL_SIGNING_CERT_SHA256)
+ val packageMatchesOfficialId = context.packageName == expectedPackageName
+ val signingCertSha256 = runCatching { loadSigningCertSha256(context) }.getOrNull()
+
+ val status = when {
+ expectedPackageName.isBlank() || expectedFingerprint.isBlank() || signingCertSha256 == null ->
+ OfficialBuildStatus.VERIFICATION_UNAVAILABLE
+ packageMatchesOfficialId && normalizeFingerprint(signingCertSha256) == expectedFingerprint ->
+ OfficialBuildStatus.OFFICIAL
+ else -> OfficialBuildStatus.UNOFFICIAL
+ }
+
+ return OfficialBuildVerification(
+ status = status,
+ packageMatchesOfficialId = packageMatchesOfficialId,
+ signingCertSha256 = signingCertSha256
+ )
+ }
+
+ private fun loadSigningCertSha256(context: Context): String? {
+ val packageManager = context.packageManager
+ val packageInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.getPackageInfo(
+ context.packageName,
+ PackageManager.PackageInfoFlags.of(PackageManager.GET_SIGNING_CERTIFICATES.toLong())
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.getPackageInfo(context.packageName, PackageManager.GET_SIGNING_CERTIFICATES)
+ }
+
+ val signingCertificateBytes = packageInfo.signingInfo
+ ?.apkContentsSigners
+ ?.firstOrNull()
+ ?.toByteArray()
+ ?: return null
+
+ val certificate = CertificateFactory.getInstance("X.509")
+ .generateCertificate(ByteArrayInputStream(signingCertificateBytes))
+
+ return MessageDigest.getInstance("SHA-256")
+ .digest(certificate.encoded)
+ .joinToString(":") { byte -> "%02X".format(byte) }
+ }
+
+ private fun normalizeFingerprint(value: String?): String {
+ return value
+ .orEmpty()
+ .uppercase(Locale.ROOT)
+ .filter(Char::isLetterOrDigit)
+ }
+}
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 39311da7..9b020a70 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -52,6 +52,8 @@
<string name="home_last_group_label">Last: %1$s</string>
<string name="home_search_channels">Search channels...</string>
<string name="home_loading">Loading...</string>
+ <string name="home_add_first_provider">Add your first provider</string>
+ <string name="home_add_first_provider_subtitle">Set up a provider to load live channels, movies, series, and guide data.</string>
<string name="home_no_channels_found">No channels found in this category</string>
<string name="home_no_channels_found_subtitle">Try another category or search term.</string>
<string name="home_add_favorites_hint">Add channels to favorites to see them here</string>
@@ -178,6 +180,8 @@
<string name="movies_incorrect_pin">Incorrect PIN</string>
<string name="movies_loading">Loading movies...</string>
+ <string name="vod_sync_needed_title">Sync needed</string>
+ <string name="vod_sync_needed_subtitle">Refresh this provider to import movies and series into the library.</string>
<string name="movies_no_found">No movies found</string>
<string name="movies_no_found_subtitle">Try a different category or return to the full library shelves to surface more titles.</string>
<string name="movies_categories_title">Categories</string>
@@ -434,6 +438,10 @@
<string name="settings_app_version">App Version</string>
<string name="settings_build">Build</string>
<string name="settings_build_desc">StreamVault for Android TV</string>
+ <string name="settings_build_verification">Build Verification</string>
+ <string name="settings_build_verification_official">Official build</string>
+ <string name="settings_build_verification_unofficial">Unofficial build</string>
+ <string name="settings_build_verification_unavailable">Verification unavailable</string>
<string name="settings_enabled">Enabled</string>
<string name="settings_disabled">Disabled</string>
<string name="settings_developed_by">Developed by</string>
@@ -789,6 +797,10 @@
<string name="setup_file_browse_hint">Browse local storage or USB</string>
<string name="setup_file_import_failed">Could not import playlist file. Please try again.</string>
<string name="setup_file_import_storage_full">Storage is full. Free up space and try importing again.</string>
+ <string name="setup_discard_draft_title">Discard setup draft?</string>
+ <string name="setup_discard_draft_body">This provider setup is incomplete. Go back and lose the current draft?</string>
+ <string name="setup_discard_draft_confirm">Discard</string>
+ <string name="setup_discard_draft_cancel">Keep editing</string>
<string name="setup_validating">Validating...</string>
<string name="setup_add">Add Playlist</string>
@@ -1138,6 +1150,8 @@
<string name="settings_clear_history_confirm">Clear History</string>
<string name="settings_xtream_text_classification">Xtream Name-Based Adult Detection</string>
<string name="settings_xtream_text_classification_subtitle">Use category name keywords to flag adult content when the provider doesn\'t set the adult flag explicitly</string>
+ <string name="settings_xtream_base64_compatibility">Xtream Base64 Text Compatibility</string>
+ <string name="settings_xtream_base64_compatibility_subtitle">Broadly decode Xtream names and categories when a provider stores them as Base64. Leave this off unless text looks encoded.</string>
<string name="settings_prevent_standby">Keep Screen On During Playback</string>
<string name="settings_prevent_standby_subtitle">Prevents the TV from showing a standby warning while a channel or video is playing</string>
<string name="settings_clear_history_dialog_title">Clear Watch History?</string>
diff --git a/app/src/main/res/xml/file_paths.xml b/app/src/main/res/xml/file_paths.xml
index e3d5a603..0b7a34b3 100644
--- a/app/src/main/res/xml/file_paths.xml
+++ b/app/src/main/res/xml/file_paths.xml
@@ -1,9 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<paths>
<external-files-path
- name="downloads"
+ name="apk_downloads"
path="Download/" />
- <cache-path
- name="cache"
- path="." />
-</paths>
\ No newline at end of file
+</paths>
diff --git a/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt b/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt
index 55c75a06..0e4c6372 100644
--- a/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt
+++ b/data/src/androidTest/java/com/streamvault/data/local/StreamVaultDatabaseMigrationTest.kt
@@ -83,12 +83,12 @@ class StreamVaultDatabaseMigrationTest {
}
@Test
- fun migrate1To15_fullChainValidatesLatestSchema() {
+ fun migrate1To30_fullChainValidatesLatestSchema() {
migrationTestHelper.createDatabase("streamvault-full-chain-test", 1).close()
migrationTestHelper.runMigrationsAndValidate(
"streamvault-full-chain-test",
- 15,
+ 30,
true,
StreamVaultDatabase.MIGRATION_1_2,
StreamVaultDatabase.MIGRATION_2_3,
@@ -103,7 +103,22 @@ class StreamVaultDatabaseMigrationTest {
StreamVaultDatabase.MIGRATION_11_12,
StreamVaultDatabase.MIGRATION_12_13,
StreamVaultDatabase.MIGRATION_13_14,
- StreamVaultDatabase.MIGRATION_14_15
+ StreamVaultDatabase.MIGRATION_14_15,
+ StreamVaultDatabase.MIGRATION_15_16,
+ StreamVaultDatabase.MIGRATION_16_17,
+ StreamVaultDatabase.MIGRATION_17_18,
+ StreamVaultDatabase.MIGRATION_18_19,
+ StreamVaultDatabase.MIGRATION_19_20,
+ StreamVaultDatabase.MIGRATION_20_21,
+ StreamVaultDatabase.MIGRATION_21_22,
+ StreamVaultDatabase.MIGRATION_22_23,
+ StreamVaultDatabase.MIGRATION_23_24,
+ StreamVaultDatabase.MIGRATION_24_25,
+ StreamVaultDatabase.MIGRATION_25_26,
+ StreamVaultDatabase.MIGRATION_26_27,
+ StreamVaultDatabase.MIGRATION_27_28,
+ StreamVaultDatabase.MIGRATION_28_29,
+ StreamVaultDatabase.MIGRATION_29_30
).close()
}
diff --git a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
index a6c72c4b..b4ddeeb1 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
@@ -23,6 +23,9 @@ abstract class ProviderDao {
@Query("SELECT * FROM providers WHERE id = :id")
abstract suspend fun getById(id: Long): ProviderEntity?
+ @Query("SELECT * FROM providers WHERE id IN (:ids)")
+ abstract suspend fun getByIds(ids: List<Long>): List<ProviderEntity>
+
@Insert(onConflict = OnConflictStrategy.REPLACE)
abstract suspend fun insert(provider: ProviderEntity): Long
diff --git a/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt b/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
index 3e1f19a3..12c342ea 100644
--- a/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
+++ b/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
@@ -3,6 +3,8 @@ package com.streamvault.data.manager
import android.content.Context
import android.net.Uri
import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.google.gson.stream.JsonWriter
import com.streamvault.data.local.dao.EpisodeDao
import com.streamvault.data.local.dao.FavoriteDao
import com.streamvault.data.local.dao.MovieDao
@@ -32,8 +34,11 @@ import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.withContext
+import java.io.OutputStream
import java.io.InputStreamReader
import java.io.OutputStreamWriter
+import java.io.Writer
+import java.lang.reflect.Type
import java.security.MessageDigest
import java.util.zip.CRC32
import javax.inject.Inject
@@ -43,6 +48,7 @@ import javax.inject.Singleton
class BackupManagerImpl @Inject constructor(
@ApplicationContext private val context: Context,
private val preferencesRepository: PreferencesRepository,
+ private val credentialCrypto: CredentialCrypto,
private val providerDao: ProviderDao,
private val favoriteDao: FavoriteDao,
private val virtualGroupDao: VirtualGroupDao,
@@ -155,13 +161,12 @@ class BackupManagerImpl @Inject constructor(
)
// Compute checksum over the data without checksum field
- val jsonWithoutChecksum = gson.toJson(backupData)
- val backupWithChecksum = backupData.copy(checksum = buildSha256Checksum(jsonWithoutChecksum))
+ val backupWithChecksum = backupData.copy(checksum = buildSha256Checksum(backupData))
// 2. Serialize and write to URI
context.contentResolver.openOutputStream(uri)?.use { outputStream ->
OutputStreamWriter(outputStream).use { writer ->
- gson.toJson(backupWithChecksum, writer)
+ writeBackupDataJson(writer, backupWithChecksum)
}
} ?: return@withContext com.streamvault.domain.model.Result.error("Failed to open output stream")
@@ -342,7 +347,7 @@ class BackupManagerImpl @Inject constructor(
}
val entity = provider.copy(
id = existing?.id ?: 0L // 0 = let Room auto-assign PK; avoids ID collision on import
- ).toSecureEntityForBackup()
+ ).toSecureEntityForBackup(credentialCrypto)
providerDao.insert(entity)
}
backupData.preferences
@@ -521,26 +526,79 @@ class BackupManagerImpl @Inject constructor(
private fun verifyChecksum(backupData: BackupData): Boolean {
val storedChecksum = backupData.checksum ?: return true // no checksum = legacy backup, skip verification
val dataWithoutChecksum = backupData.copy(checksum = null)
- val json = gson.toJson(dataWithoutChecksum)
return if (storedChecksum.startsWith(SHA256_PREFIX)) {
- buildSha256Checksum(json) == storedChecksum
+ buildSha256Checksum(dataWithoutChecksum) == storedChecksum
} else {
- verifyLegacyCrc32Checksum(json, storedChecksum)
+ verifyLegacyCrc32Checksum(dataWithoutChecksum, storedChecksum)
}
}
- private fun buildSha256Checksum(json: String): String {
- val digest = MessageDigest.getInstance("SHA-256").digest(json.toByteArray(Charsets.UTF_8))
- return SHA256_PREFIX + digest.joinToString(separator = "") { "%02x".format(it) }
+ private fun buildSha256Checksum(backupData: BackupData): String {
+ val digest = MessageDigest.getInstance("SHA-256")
+ OutputStreamWriter(MessageDigestOutputStream(digest), Charsets.UTF_8).use { writer ->
+ writeBackupDataJson(writer, backupData.copy(checksum = null))
+ }
+ return SHA256_PREFIX + digest.digest().joinToString(separator = "") { "%02x".format(it) }
}
- private fun verifyLegacyCrc32Checksum(json: String, checksum: String): Boolean {
+ private fun verifyLegacyCrc32Checksum(backupData: BackupData, checksum: String): Boolean {
val crc = CRC32()
- crc.update(json.toByteArray(Charsets.UTF_8))
+ OutputStreamWriter(Crc32OutputStream(crc), Charsets.UTF_8).use { writer ->
+ writeBackupDataJson(writer, backupData.copy(checksum = null))
+ }
return crc.value.toString(16) == checksum
}
+ private fun writeBackupDataJson(writer: Writer, backupData: BackupData) {
+ JsonWriter(writer).use { jsonWriter ->
+ jsonWriter.beginObject()
+ jsonWriter.name("version").value(backupData.version.toLong())
+ backupData.checksum?.let { checksum ->
+ jsonWriter.name("checksum").value(checksum)
+ }
+ writeNamedJsonField(jsonWriter, "preferences", backupData.preferences, MAP_STRING_STRING_TYPE)
+ writeNamedJsonField(jsonWriter, "providers", backupData.providers, PROVIDER_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "favorites", backupData.favorites, FAVORITE_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "virtualGroups", backupData.virtualGroups, VIRTUAL_GROUP_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "playbackHistory", backupData.playbackHistory, PLAYBACK_HISTORY_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "multiViewPresets", backupData.multiViewPresets, MULTIVIEW_PRESETS_TYPE)
+ writeNamedJsonField(jsonWriter, "protectedCategories", backupData.protectedCategories, PROTECTED_CATEGORY_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "scheduledRecordings", backupData.scheduledRecordings, SCHEDULED_RECORDING_LIST_TYPE)
+ jsonWriter.endObject()
+ }
+ }
+
+ private fun <T> writeNamedJsonField(jsonWriter: JsonWriter, name: String, value: T?, type: Type) {
+ if (value == null) return
+ jsonWriter.name(name)
+ gson.toJson(value, type, jsonWriter)
+ }
+
+ private class MessageDigestOutputStream(
+ private val digest: MessageDigest
+ ) : OutputStream() {
+ override fun write(b: Int) {
+ digest.update(b.toByte())
+ }
+
+ override fun write(b: ByteArray, off: Int, len: Int) {
+ digest.update(b, off, len)
+ }
+ }
+
+ private class Crc32OutputStream(
+ private val crc32: CRC32
+ ) : OutputStream() {
+ override fun write(b: Int) {
+ crc32.update(b)
+ }
+
+ override fun write(b: ByteArray, off: Int, len: Int) {
+ crc32.update(b, off, len)
+ }
+ }
+
private fun readBackupData(uriString: String): BackupData? {
val uri = Uri.parse(uriString)
return context.contentResolver.openInputStream(uri)?.use { inputStream ->
@@ -551,7 +609,16 @@ class BackupManagerImpl @Inject constructor(
}
}
-private fun com.streamvault.domain.model.Provider.toSecureEntityForBackup() =
- copy(password = CredentialCrypto.encryptIfNeeded(password)).toEntity()
+private fun com.streamvault.domain.model.Provider.toSecureEntityForBackup(
+ credentialCrypto: CredentialCrypto
+) = copy(password = credentialCrypto.encryptIfNeeded(password)).toEntity()
private const val SHA256_PREFIX = "sha256:"
+private val MAP_STRING_STRING_TYPE: Type = object : TypeToken<Map<String, String>>() {}.type
+private val PROVIDER_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.Provider>>() {}.type
+private val FAVORITE_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.Favorite>>() {}.type
+private val VIRTUAL_GROUP_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.VirtualGroup>>() {}.type
+private val PLAYBACK_HISTORY_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.PlaybackHistory>>() {}.type
+private val MULTIVIEW_PRESETS_TYPE: Type = object : TypeToken<Map<String, List<Long>>>() {}.type
+private val PROTECTED_CATEGORY_LIST_TYPE: Type = object : TypeToken<List<ProtectedCategoryBackup>>() {}.type
+private val SCHEDULED_RECORDING_LIST_TYPE: Type = object : TypeToken<List<ScheduledRecordingBackup>>() {}.type
diff --git a/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.kt b/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.kt
index e7cd950a..7a8530e0 100644
--- a/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.kt
+++ b/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.kt
@@ -1,6 +1,8 @@
package com.streamvault.data.manager
+import com.streamvault.data.local.entity.RecordingRunEntity
import com.streamvault.domain.model.RecordingItem
+import com.streamvault.domain.model.RecordingFailureCategory
import com.streamvault.domain.model.RecordingStatus
internal fun Iterable<RecordingItem>.findRecordingConflict(
@@ -14,3 +16,54 @@ internal fun Iterable<RecordingItem>.findRecordingConflict(
item.scheduledEndMs > candidateStartMs
}
}
+
+internal fun Iterable<RecordingRunEntity>.findRecordingRunConflict(
+ candidateStartMs: Long,
+ candidateEndMs: Long,
+ statuses: Set<RecordingStatus>,
+ ignoredRunId: String? = null
+): RecordingRunEntity? {
+ return firstOrNull { item ->
+ item.id != ignoredRunId &&
+ item.scheduleEnabled &&
+ item.status in statuses &&
+ item.scheduledStartMs < candidateEndMs &&
+ item.scheduledEndMs > candidateStartMs
+ }
+}
+
+internal fun RecordingRunEntity.toConflictFailure(
+ conflictStartMs: Long,
+ conflictEndMs: Long,
+ reason: String,
+ nowMs: Long = System.currentTimeMillis()
+): RecordingRunEntity {
+ return copy(
+ id = java.util.UUID.randomUUID().toString(),
+ status = RecordingStatus.FAILED,
+ scheduledStartMs = conflictStartMs,
+ scheduledEndMs = conflictEndMs,
+ sourceType = com.streamvault.domain.model.RecordingSourceType.UNKNOWN,
+ resolvedUrl = null,
+ headersJson = "{}",
+ userAgent = null,
+ expirationTime = null,
+ providerLabel = null,
+ outputUri = null,
+ outputDisplayPath = null,
+ bytesWritten = 0L,
+ averageThroughputBytesPerSecond = 0L,
+ retryCount = 0,
+ lastProgressAtMs = null,
+ failureCategory = RecordingFailureCategory.SCHEDULE_CONFLICT,
+ failureReason = reason,
+ terminalAtMs = nowMs,
+ startedAtMs = null,
+ endedAtMs = nowMs,
+ scheduleEnabled = false,
+ alarmStartAtMs = null,
+ alarmStopAtMs = null,
+ createdAt = nowMs,
+ updatedAt = nowMs
+ )
+}
diff --git a/data/src/main/java/com/streamvault/data/manager/RecordingManagerImpl.kt b/data/src/main/java/com/streamvault/data/manager/RecordingManagerImpl.kt
index 792d6867..2c9f45ab 100644
--- a/data/src/main/java/com/streamvault/data/manager/RecordingManagerImpl.kt
+++ b/data/src/main/java/com/streamvault/data/manager/RecordingManagerImpl.kt
@@ -43,6 +43,9 @@ import com.streamvault.domain.model.Result
import dagger.hilt.android.qualifiers.ApplicationContext
import java.io.File
import java.io.FileInputStream
+import java.time.Duration
+import java.time.Instant
+import java.time.ZoneId
import java.util.UUID
import javax.inject.Inject
import javax.inject.Singleton
@@ -58,6 +61,8 @@ import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
+private const val TAG = "RecordingManager"
+
@Singleton
class RecordingManagerImpl @Inject constructor(
@ApplicationContext private val context: Context,
@@ -592,41 +597,90 @@ class RecordingManagerImpl @Inject constructor(
private suspend fun spawnNextRecurringRunIfNeeded(run: RecordingRunEntity) {
if (run.recurrence == RecordingRecurrence.NONE || run.recurringRuleId.isNullOrBlank()) return
- val interval = recurrenceIntervalMs(run.recurrence)
- val nextStart = run.scheduledStartMs + interval
- val overlappingPending = recordingRunDao.getByStatus(RecordingStatus.SCHEDULED).any {
- it.recurringRuleId == run.recurringRuleId && it.scheduledStartMs == nextStart
+ val scheduledRuns = recordingRunDao.getByStatus(RecordingStatus.SCHEDULED)
+ val activeRuns = (scheduledRuns + recordingRunDao.getRecordingRuns()).distinctBy { it.id }
+ val lookAheadLimit = when (run.recurrence) {
+ RecordingRecurrence.DAILY -> 366
+ RecordingRecurrence.WEEKLY -> 104
+ RecordingRecurrence.NONE -> 0
}
- if (overlappingPending) return
- val nextRun = run.copy(
- id = UUID.randomUUID().toString(),
- status = RecordingStatus.SCHEDULED,
- scheduledStartMs = nextStart,
- scheduledEndMs = run.scheduledEndMs + interval,
- sourceType = RecordingSourceType.UNKNOWN,
- resolvedUrl = null,
- headersJson = "{}",
- userAgent = null,
- expirationTime = null,
- providerLabel = null,
- outputUri = null,
- outputDisplayPath = null,
- bytesWritten = 0L,
- averageThroughputBytesPerSecond = 0L,
- retryCount = 0,
- lastProgressAtMs = null,
- failureCategory = RecordingFailureCategory.NONE,
- failureReason = null,
- terminalAtMs = null,
- startedAtMs = null,
- endedAtMs = null,
- alarmStartAtMs = nextStart,
- alarmStopAtMs = null,
- createdAt = System.currentTimeMillis(),
- updatedAt = System.currentTimeMillis()
- )
- recordingRunDao.insert(nextRun)
- alarmScheduler.scheduleStart(nextRun.id, nextRun.scheduledStartMs)
+
+ for (occurrenceIndex in 1..lookAheadLimit) {
+ val nextWindow = nextRecurringWindow(run, occurrenceIndex) ?: return
+ val nextStart = nextWindow.first
+ val nextEnd = nextWindow.second
+ val overlappingPending = scheduledRuns.any {
+ it.recurringRuleId == run.recurringRuleId && it.scheduledStartMs == nextStart
+ }
+ if (overlappingPending) return
+
+ val conflict = activeRuns.findRecordingRunConflict(
+ candidateStartMs = nextStart,
+ candidateEndMs = nextEnd,
+ statuses = setOf(RecordingStatus.SCHEDULED, RecordingStatus.RECORDING),
+ ignoredRunId = run.id
+ )
+ if (conflict != null) {
+ val conflictTitle = conflict.programTitle ?: conflict.channelName
+ val skippedRun = run.toConflictFailure(
+ conflictStartMs = nextStart,
+ conflictEndMs = nextEnd,
+ reason = "Skipped recurring occurrence because it conflicts with '$conflictTitle'."
+ )
+ recordingRunDao.insert(skippedRun)
+ continue
+ }
+
+ val now = System.currentTimeMillis()
+ val nextRun = run.copy(
+ id = UUID.randomUUID().toString(),
+ status = RecordingStatus.SCHEDULED,
+ scheduledStartMs = nextStart,
+ scheduledEndMs = nextEnd,
+ sourceType = RecordingSourceType.UNKNOWN,
+ resolvedUrl = null,
+ headersJson = "{}",
+ userAgent = null,
+ expirationTime = null,
+ providerLabel = null,
+ outputUri = null,
+ outputDisplayPath = null,
+ bytesWritten = 0L,
+ averageThroughputBytesPerSecond = 0L,
+ retryCount = 0,
+ lastProgressAtMs = null,
+ failureCategory = RecordingFailureCategory.NONE,
+ failureReason = null,
+ terminalAtMs = null,
+ startedAtMs = null,
+ endedAtMs = null,
+ alarmStartAtMs = nextStart,
+ alarmStopAtMs = null,
+ createdAt = now,
+ updatedAt = now
+ )
+ recordingRunDao.insert(nextRun)
+ alarmScheduler.scheduleStart(nextRun.id, nextRun.scheduledStartMs)
+ return
+ }
+
+ Log.w(TAG, "Unable to find a non-conflicting future slot for recurring recording ${run.id}")
+ }
+
+ private fun nextRecurringWindow(run: RecordingRunEntity, occurrencesAhead: Int = 1): Pair<Long, Long>? {
+ if (run.scheduledEndMs <= run.scheduledStartMs) return null
+
+ val zoneId = ZoneId.systemDefault()
+ val startZoned = Instant.ofEpochMilli(run.scheduledStartMs).atZone(zoneId)
+ val nextStartZoned = when (run.recurrence) {
+ RecordingRecurrence.NONE -> return null
+ RecordingRecurrence.DAILY -> startZoned.plusDays(occurrencesAhead.toLong())
+ RecordingRecurrence.WEEKLY -> startZoned.plusWeeks(occurrencesAhead.toLong())
+ }
+ val recordingDuration = Duration.ofMillis(run.scheduledEndMs - run.scheduledStartMs)
+ val nextStartMs = nextStartZoned.toInstant().toEpochMilli()
+ val nextEndMs = nextStartZoned.plus(recordingDuration).toInstant().toEpochMilli()
+ return nextStartMs to nextEndMs
}
private suspend fun validateRecordingWindow(startMs: Long, endMs: Long, providerId: Long): String? {
@@ -700,9 +754,4 @@ class RecordingManagerImpl @Inject constructor(
terminalAtMs = terminalAtMs
)
- private fun recurrenceIntervalMs(recurrence: RecordingRecurrence): Long = when (recurrence) {
- RecordingRecurrence.NONE -> 0L
- RecordingRecurrence.DAILY -> 24L * 60L * 60L * 1000L
- RecordingRecurrence.WEEKLY -> 7L * 24L * 60L * 60L * 1000L
- }
}
diff --git a/data/src/main/java/com/streamvault/data/parser/M3uParser.kt b/data/src/main/java/com/streamvault/data/parser/M3uParser.kt
index 354471d2..d7e7a4d3 100644
--- a/data/src/main/java/com/streamvault/data/parser/M3uParser.kt
+++ b/data/src/main/java/com/streamvault/data/parser/M3uParser.kt
@@ -58,38 +58,35 @@ class M3uParser {
var header = M3uHeader()
var pendingExtinf: ParsedExtinf? = null
+ // lineSequence() streams the InputStream one line at a time — only a single
+ // String is allocated per iteration; prior lines are immediately eligible for GC.
+ // This keeps memory flat regardless of playlist size (e.g. 500 MB feeds).
reader.use {
- while (true) {
- val rawLine = reader.readLine() ?: break
- val line = sanitizeLine(rawLine)
- if (line.isEmpty()) {
- continue
- }
-
- when {
- line.startsWith("#EXTM3U", ignoreCase = true) -> {
- header = parseHeader(line)
- }
- line.startsWith("#EXTINF", ignoreCase = true) -> {
- pendingExtinf = parseExtinf(line)
- }
- line.startsWith("#") -> {
- // Preserve pendingExtinf across known directives that appear
- // between #EXTINF and the stream URL (e.g. #EXTVLCOPT, #EXTGRP,
- // #KODIPROP, #EXTATTRPARAM). Only reset on another #EXTINF.
- }
- pendingExtinf != null -> {
- val extinf = pendingExtinf
- if (extinf != null) {
- parseEntry(extinf, line, header.userAgent)?.let(entries::add)
+ reader.lineSequence()
+ .map { sanitizeLine(it) }
+ .filter { it.isNotEmpty() }
+ .forEach { line ->
+ when {
+ line.startsWith("#EXTM3U", ignoreCase = true) -> {
+ header = parseHeader(line)
+ }
+ line.startsWith("#EXTINF", ignoreCase = true) -> {
+ pendingExtinf = parseExtinf(line)
+ }
+ line.startsWith("#") -> {
+ // Preserve pendingExtinf across known directives that appear
+ // between #EXTINF and the stream URL (e.g. #EXTVLCOPT, #EXTGRP,
+ // #KODIPROP, #EXTATTRPARAM). Only reset on another #EXTINF.
+ }
+ pendingExtinf != null -> {
+ parseEntry(pendingExtinf!!, line, header.userAgent)?.let(entries::add)
+ pendingExtinf = null
+ }
+ else -> {
+ // Non-comment, non-URL line with no pending EXTINF — skip
}
- pendingExtinf = null
- }
- else -> {
- // Non-comment, non-URL line with no pending EXTINF — skip
}
}
- }
}
return ParseResult(header, entries)
@@ -104,13 +101,15 @@ class M3uParser {
var header = M3uHeader()
var pendingExtinf: ParsedExtinf? = null
+ // Use a for-loop over lineSequence() rather than .forEach{} because onHeader and
+ // onEntry are suspend lambdas. Sequence.forEach is not an inline function, so the
+ // compiler cannot allow coroutine suspension inside it. A for-loop over the same
+ // sequence is fully coroutine-compatible and preserves the one-line-at-a-time
+ // memory profile.
reader.use {
- while (true) {
- val rawLine = reader.readLine() ?: break
+ for (rawLine in reader.lineSequence()) {
val line = sanitizeLine(rawLine)
- if (line.isEmpty()) {
- continue
- }
+ if (line.isEmpty()) continue
when {
line.startsWith("#EXTM3U", ignoreCase = true) -> {
@@ -126,10 +125,7 @@ class M3uParser {
// #KODIPROP, #EXTATTRPARAM). Only reset on another #EXTINF.
}
pendingExtinf != null -> {
- val extinf = pendingExtinf
- if (extinf != null) {
- parseEntry(extinf, line, header.userAgent)?.let { onEntry(it) }
- }
+ parseEntry(pendingExtinf!!, line, header.userAgent)?.let { onEntry(it) }
pendingExtinf = null
}
else -> {
diff --git a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
index 65e77adb..8c28f583 100644
--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
@@ -102,6 +102,8 @@ class PreferencesRepository @Inject constructor(
val GUIDE_SCHEDULED_ONLY = intPreferencesKey("guide_scheduled_only")
val RECENT_SEARCH_QUERIES = stringPreferencesKey("recent_search_queries")
val XTREAM_TEXT_CLASSIFICATION = booleanPreferencesKey("xtream_text_classification")
+ val XTREAM_BASE64_TEXT_COMPATIBILITY = booleanPreferencesKey("xtream_base64_text_compatibility")
+ val XTREAM_TEXT_IMPORT_GENERATION = longPreferencesKey("xtream_text_import_generation")
val PREVENT_STANDBY_DURING_PLAYBACK = booleanPreferencesKey("prevent_standby_during_playback")
val AUTO_CHECK_APP_UPDATES = booleanPreferencesKey("auto_check_app_updates")
val LAST_APP_UPDATE_CHECK_TIMESTAMP = longPreferencesKey("last_app_update_check_timestamp")
@@ -161,6 +163,14 @@ class PreferencesRepository @Inject constructor(
preferences[PreferencesKeys.XTREAM_TEXT_CLASSIFICATION] ?: true // default ON
}
+ val xtreamBase64TextCompatibility: Flow<Boolean> = context.dataStore.data.map { preferences ->
+ preferences[PreferencesKeys.XTREAM_BASE64_TEXT_COMPATIBILITY] ?: false
+ }
+
+ val xtreamTextImportGeneration: Flow<Long> = context.dataStore.data.map { preferences ->
+ preferences[PreferencesKeys.XTREAM_TEXT_IMPORT_GENERATION] ?: 0L
+ }
+
val playerMuted: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PLAYER_MUTED] ?: false
}
@@ -313,6 +323,41 @@ class PreferencesRepository @Inject constructor(
}
}
+ suspend fun setXtreamBase64TextCompatibility(enabled: Boolean) {
+ context.dataStore.edit { preferences ->
+ preferences[PreferencesKeys.XTREAM_BASE64_TEXT_COMPATIBILITY] = enabled
+ }
+ }
+
+ suspend fun bumpXtreamTextImportGeneration(): Long {
+ var nextGeneration = 0L
+ context.dataStore.edit { preferences ->
+ nextGeneration = (preferences[PreferencesKeys.XTREAM_TEXT_IMPORT_GENERATION] ?: 0L) + 1L
+ preferences[PreferencesKeys.XTREAM_TEXT_IMPORT_GENERATION] = nextGeneration
+ }
+ return nextGeneration
+ }
+
+ suspend fun getXtreamTextImportGeneration(): Long {
+ return xtreamTextImportGeneration.first()
+ }
+
+ suspend fun getXtreamTextImportAppliedGeneration(providerId: Long): Long {
+ val key = longPreferencesKey(xtreamTextImportAppliedGenerationKey(providerId))
+ return context.dataStore.data.first()[key] ?: 0L
+ }
+
+ suspend fun markXtreamTextImportApplied(providerId: Long, generation: Long) {
+ val key = longPreferencesKey(xtreamTextImportAppliedGenerationKey(providerId))
+ context.dataStore.edit { preferences ->
+ if (generation <= 0L) {
+ preferences.remove(key)
+ } else {
+ preferences[key] = generation
+ }
+ }
+ }
+
val preventStandbyDuringPlayback: Flow<Boolean> = context.dataStore.data.map { preferences ->
preferences[PreferencesKeys.PREVENT_STANDBY_DURING_PLAYBACK] ?: true
}
@@ -1150,6 +1195,9 @@ class PreferencesRepository @Inject constructor(
return !preferences[PreferencesKeys.LEGACY_PARENTAL_PIN].isNullOrBlank()
}
+
+ private fun xtreamTextImportAppliedGenerationKey(providerId: Long): String =
+ "xtream_text_import_applied_generation_$providerId"
}
data class ParentalPinBackupData(
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
index f5928d7c..2d007906 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamProvider.kt
@@ -31,12 +31,19 @@ class XtreamProvider(
private val username: String,
private val password: String,
private val allowedOutputFormats: List<String> = emptyList(),
- private val useTextClassification: Boolean = true
+ private val useTextClassification: Boolean = true,
+ private val enableBase64TextCompatibility: Boolean = false
) : IptvProvider {
companion object {
private const val TAG = "XtreamProvider"
}
+ private enum class XtreamTextDecodeMode {
+ RAW,
+ EPG,
+ METADATA
+ }
+
private data class ResolvedXtreamCategory(
val id: Long?,
val name: String?
@@ -196,16 +203,16 @@ class XtreamProvider(
Result.success(
Movie(
id = movieData.streamId,
- name = decodeXtreamNullableText(movieData.name)?.ifBlank { null } ?: "Movie ${movieData.streamId}",
+ name = decodeXtreamNullableText(movieData.name, XtreamTextDecodeMode.RAW)?.ifBlank { null } ?: "Movie ${movieData.streamId}",
posterUrl = sanitizeAssetValue(info?.movieImage),
backdropUrl = firstUsableAsset(info?.backdropPath),
categoryId = category.id,
categoryName = category.name,
containerExtension = normalizedContainerExtension,
- plot = decodeXtreamNullableText(info?.plot),
- cast = decodeXtreamNullableText(info?.cast),
- director = decodeXtreamNullableText(info?.director),
- genre = decodeXtreamNullableText(info?.genre),
+ plot = decodeXtreamNullableText(info?.plot, XtreamTextDecodeMode.METADATA),
+ cast = decodeXtreamNullableText(info?.cast, XtreamTextDecodeMode.METADATA),
+ director = decodeXtreamNullableText(info?.director, XtreamTextDecodeMode.METADATA),
+ genre = decodeXtreamNullableText(info?.genre, XtreamTextDecodeMode.METADATA),
releaseDate = info?.releaseDate,
duration = info?.duration,
durationSeconds = info?.durationSecs ?: 0,
@@ -299,13 +306,14 @@ class XtreamProvider(
Episode(
id = episodeId,
title = decodeXtreamText(
- ep.title.ifBlank { decodeXtreamNullableText(ep.info?.name) ?: "Episode ${ep.episodeNum}" }
+ ep.title.ifBlank { decodeXtreamNullableText(ep.info?.name, XtreamTextDecodeMode.RAW) ?: "Episode ${ep.episodeNum}" },
+ XtreamTextDecodeMode.RAW
),
episodeNumber = ep.episodeNum,
seasonNumber = ep.season.takeIf { it > 0 } ?: resolvedSeasonNumber,
containerExtension = normalizedExtension,
coverUrl = sanitizeAssetValue(ep.info?.movieImage),
- plot = decodeXtreamNullableText(ep.info?.plot),
+ plot = decodeXtreamNullableText(ep.info?.plot, XtreamTextDecodeMode.METADATA),
duration = ep.info?.duration,
durationSeconds = ep.info?.durationSecs ?: 0,
rating = ep.info?.rating?.toFloatOrNull() ?: 0f,
@@ -634,9 +642,9 @@ class XtreamProvider(
if (streamId <= 0) return null
val category = resolveXtreamCategory(ContentType.LIVE, categoryId, categoryName)
val primaryContainerExtension = preferredLiveContainerExtension(containerExtension)
- val resolvedName = decodeXtreamNullableText(name)?.ifBlank { null } ?: "Channel $streamId"
+ val resolvedName = decodeXtreamNullableText(name, XtreamTextDecodeMode.RAW)?.ifBlank { null } ?: "Channel $streamId"
val sanitizedLogoUrl = sanitizeAssetValue(streamIcon)
- val sanitizedEpgChannelId = decodeXtreamNullableText(epgChannelId)
+ val sanitizedEpgChannelId = decodeXtreamNullableText(epgChannelId, XtreamTextDecodeMode.RAW)
val sanitizedDirectSource = sanitizeAssetValue(directSource)
val streamUrl = buildInternalLiveStreamUrl(
streamId = streamId,
@@ -677,7 +685,7 @@ class XtreamProvider(
private fun XtreamStream.toMovie(adultCategoryIds: Set<Long>): Movie? {
if (streamId <= 0) return null
val category = resolveXtreamCategory(ContentType.MOVIE, categoryId, categoryName)
- val resolvedName = decodeXtreamNullableText(name)?.ifBlank { null } ?: "Movie $streamId"
+ val resolvedName = decodeXtreamNullableText(name, XtreamTextDecodeMode.RAW)?.ifBlank { null } ?: "Movie $streamId"
val normalizedContainerExtension = normalizeContainerExtension(containerExtension)
val sanitizedDirectSource = sanitizeAssetValue(directSource)
return Movie(
@@ -730,7 +738,7 @@ class XtreamProvider(
): Series? {
val resolvedSeriesId = seriesId.takeIf { it > 0 } ?: fallbackSeriesId ?: return null
val category = resolveXtreamCategory(ContentType.SERIES, categoryId, categoryName)
- val resolvedName = decodeXtreamNullableText(name)?.ifBlank { null } ?: "Series $resolvedSeriesId"
+ val resolvedName = decodeXtreamNullableText(name, XtreamTextDecodeMode.RAW)?.ifBlank { null } ?: "Series $resolvedSeriesId"
return Series(
id = 0,
name = resolvedName,
@@ -738,10 +746,11 @@ class XtreamProvider(
backdropUrl = firstUsableAsset(backdropPath),
categoryId = category.id,
categoryName = category.name,
- plot = decodeXtreamNullableText(plot) ?: decodeXtreamNullableText(description),
- cast = decodeXtreamNullableText(cast),
- director = decodeXtreamNullableText(director),
- genre = decodeXtreamNullableText(genre),
+ plot = decodeXtreamNullableText(plot, XtreamTextDecodeMode.METADATA)
+ ?: decodeXtreamNullableText(description, XtreamTextDecodeMode.METADATA),
+ cast = decodeXtreamNullableText(cast, XtreamTextDecodeMode.METADATA),
+ director = decodeXtreamNullableText(director, XtreamTextDecodeMode.METADATA),
+ genre = decodeXtreamNullableText(genre, XtreamTextDecodeMode.METADATA),
releaseDate = releaseDate ?: releaseDateAlt,
rating = normalizeXtreamRatingTenPoint(rating, rating5based),
tmdbId = tmdb?.trim()?.toLongOrNull() ?: tmdbId?.trim()?.toLongOrNull(),
@@ -840,8 +849,8 @@ class XtreamProvider(
private fun XtreamEpgListing.toDomain(): Program {
// Xtream sometimes base64-encodes title and description
- val decodedTitle = decodeXtreamText(title)
- val decodedDescription = decodeXtreamText(description)
+ val decodedTitle = decodeXtreamText(title, XtreamTextDecodeMode.EPG)
+ val decodedDescription = decodeXtreamText(description, XtreamTextDecodeMode.EPG)
return Program(
id = id.toLongOrNull() ?: 0,
@@ -858,8 +867,11 @@ class XtreamProvider(
)
}
- private fun decodeXtreamNullableText(value: String?): String? {
- return value?.let(::decodeXtreamText)?.takeIf { it.isNotBlank() }
+ private fun decodeXtreamNullableText(
+ value: String?,
+ mode: XtreamTextDecodeMode = XtreamTextDecodeMode.RAW
+ ): String? {
+ return value?.let { decodeXtreamText(it, mode) }?.takeIf { it.isNotBlank() }
}
private fun sanitizeAssetValue(value: String?): String? {
@@ -888,14 +900,17 @@ class XtreamProvider(
?: 0f
}
- private fun decodeXtreamText(value: String): String = tryBase64Decode(value).trim()
+ private fun decodeXtreamText(
+ value: String,
+ mode: XtreamTextDecodeMode = XtreamTextDecodeMode.RAW
+ ): String = tryBase64Decode(value, mode).trim()
private fun resolveXtreamCategory(
type: ContentType,
rawCategoryId: String?,
rawCategoryName: String?
): ResolvedXtreamCategory {
- val decodedName = decodeXtreamNullableText(rawCategoryName)
+ val decodedName = decodeXtreamNullableText(rawCategoryName, XtreamTextDecodeMode.RAW)
val parsedId = rawCategoryId?.trim()?.toLongOrNull()
if (parsedId != null) {
return ResolvedXtreamCategory(
@@ -920,9 +935,10 @@ class XtreamProvider(
return (normalized.hashCode().toLong() and 0x7fff_ffffL).coerceAtLeast(1L)
}
- private fun tryBase64Decode(value: String): String = try {
+ private fun tryBase64Decode(value: String, mode: XtreamTextDecodeMode): String = try {
val normalized = value.trim()
if (
+ (mode == XtreamTextDecodeMode.RAW && !enableBase64TextCompatibility) ||
normalized.isBlank() ||
normalized.length % 4 != 0 ||
!XTREAM_BASE64_REGEX.matches(normalized)
@@ -930,11 +946,28 @@ class XtreamProvider(
value
} else {
val decoded = String(Base64.getDecoder().decode(normalized), Charsets.UTF_8)
- if (decoded.any { it.isLetterOrDigit() }) decoded else value
+ if (isPlausibleXtreamDecodedText(decoded)) decoded else value
}
} catch (_: Exception) {
value
}
+
+ private fun isPlausibleXtreamDecodedText(value: String): Boolean {
+ val trimmed = value.trim()
+ if (trimmed.isBlank()) return false
+ if (trimmed.any { it.isISOControl() && !it.isWhitespace() }) return false
+
+ val readableChars = trimmed.count(::isReadableXtreamTextChar)
+ val readableRatio = readableChars.toDouble() / trimmed.length.toDouble()
+ val letterOrDigitCount = trimmed.count(Char::isLetterOrDigit)
+
+ return readableRatio >= XTREAM_DECODED_TEXT_MIN_READABLE_RATIO &&
+ letterOrDigitCount >= XTREAM_DECODED_TEXT_MIN_ALNUM_COUNT
+ }
+
+ private fun isReadableXtreamTextChar(char: Char): Boolean {
+ return char.isLetterOrDigit() || char.isWhitespace() || char in XTREAM_READABLE_TEXT_PUNCTUATION
+ }
}
internal fun parseXtreamExpirationDate(rawValue: String?): Long? {
@@ -999,3 +1032,6 @@ private val XTREAM_LOCAL_DATE_FORMATTERS: List<DateTimeFormatter> = listOf(
)
private val XTREAM_BASE64_REGEX = Regex("^[A-Za-z0-9+/]+={0,2}$")
+private const val XTREAM_DECODED_TEXT_MIN_READABLE_RATIO = 0.85
+private const val XTREAM_DECODED_TEXT_MIN_ALNUM_COUNT = 3
+private val XTREAM_READABLE_TEXT_PUNCTUATION = setOf('\'', '"', '-', '_', '.', '?', '!', '&', ':', '’', ',', ';', '(', ')', '[', ']', '/', '\\')
diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
index f53c46c6..e76e3b18 100644
--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt
@@ -16,7 +16,8 @@ data class ResolvedStreamUrl(
@Singleton
class XtreamStreamUrlResolver @Inject constructor(
- private val providerDao: ProviderDao
+ private val providerDao: ProviderDao,
+ private val credentialCrypto: CredentialCrypto
) {
fun isInternalStreamUrl(url: String?): Boolean = XtreamUrlFactory.isInternalStreamUrl(url)
@@ -64,7 +65,7 @@ class XtreamStreamUrlResolver @Inject constructor(
val streamId = token?.streamId ?: fallbackStreamId?.takeIf { it > 0 } ?: return null
val ext = token?.containerExtension ?: fallbackContainerExtension
val directSource = token?.directSource?.takeIf(UrlSecurityPolicy::isAllowedStreamEntryUrl)
- val decryptedPassword = CredentialCrypto.decryptIfNeeded(provider.password)
+ val decryptedPassword = credentialCrypto.decryptIfNeeded(provider.password)
val fallbackResolvedUrl = XtreamUrlFactory.buildPlaybackUrl(
serverUrl = provider.serverUrl,
@@ -114,4 +115,4 @@ internal fun extractStreamExpirationTime(url: String): Long? {
parseXtreamExpirationDate(decodedValue)
}
.firstOrNull()
-}
\ No newline at end of file
+}
diff --git a/data/src/main/java/com/streamvault/data/repository/CombinedM3uRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/CombinedM3uRepositoryImpl.kt
index 28a42f94..243d93de 100644
--- a/data/src/main/java/com/streamvault/data/repository/CombinedM3uRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/CombinedM3uRepositoryImpl.kt
@@ -67,7 +67,11 @@ class CombinedM3uRepositoryImpl @Inject constructor(
if (distinctProviderIds.isEmpty()) {
return Result.error("Select at least one M3U provider.")
}
- val providers = distinctProviderIds.mapNotNull { providerDao.getById(it)?.toDomain() }
+ val providersById = providerDao.getByIds(distinctProviderIds)
+ .associateBy { it.id }
+ val providers = distinctProviderIds.mapNotNull { providerId ->
+ providersById[providerId]?.toDomain()
+ }
if (providers.size != distinctProviderIds.size || providers.any { it.type != ProviderType.M3U }) {
return Result.error("Combined profiles support M3U providers only.")
}
diff --git a/data/src/main/java/com/streamvault/data/repository/EpgSourceRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/EpgSourceRepositoryImpl.kt
index bc97c556..542b0a60 100644
--- a/data/src/main/java/com/streamvault/data/repository/EpgSourceRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/EpgSourceRepositoryImpl.kt
@@ -232,50 +232,50 @@ class EpgSourceRepositoryImpl @Inject constructor(
return super.read(b, off, len).also { if (it > 0) bytesRead += it }
}
}
- val decompressed = xmltvParser.maybeDecompressGzip(source.url, limited)
-
- xmltvParser.parseStreamingWithChannels(
- inputStream = decompressed,
- onChannel = { xmltvChannel ->
- channelBatch.add(
- EpgChannelEntity(
- epgSourceId = sourceId,
- xmltvChannelId = xmltvChannel.id,
- displayName = xmltvChannel.displayName,
- normalizedName = EpgNameNormalizer.normalize(xmltvChannel.displayName),
- iconUrl = xmltvChannel.iconUrl
+ xmltvParser.maybeDecompressGzip(source.url, limited).use { decompressed ->
+ xmltvParser.parseStreamingWithChannels(
+ inputStream = decompressed,
+ onChannel = { xmltvChannel ->
+ channelBatch.add(
+ EpgChannelEntity(
+ epgSourceId = sourceId,
+ xmltvChannelId = xmltvChannel.id,
+ displayName = xmltvChannel.displayName,
+ normalizedName = EpgNameNormalizer.normalize(xmltvChannel.displayName),
+ iconUrl = xmltvChannel.iconUrl
+ )
)
- )
- channelCount++
- if (channelBatch.size >= CHANNEL_BATCH_SIZE) {
- epgChannelDao.insertAll(channelBatch.toList())
- channelBatch.clear()
- }
- },
- onProgramme = { programme ->
- programmeBatch.add(
- EpgProgrammeEntity(
- epgSourceId = sourceId,
- xmltvChannelId = programme.channelId,
- startTime = programme.startTime,
- endTime = programme.endTime,
- title = programme.title,
- subtitle = programme.subtitle,
- description = programme.description,
- category = programme.category,
- lang = programme.lang,
- rating = programme.rating,
- imageUrl = programme.imageUrl,
- episodeInfo = programme.episodeInfo
+ channelCount++
+ if (channelBatch.size >= CHANNEL_BATCH_SIZE) {
+ epgChannelDao.insertAll(channelBatch.toList())
+ channelBatch.clear()
+ }
+ },
+ onProgramme = { programme ->
+ programmeBatch.add(
+ EpgProgrammeEntity(
+ epgSourceId = sourceId,
+ xmltvChannelId = programme.channelId,
+ startTime = programme.startTime,
+ endTime = programme.endTime,
+ title = programme.title,
+ subtitle = programme.subtitle,
+ description = programme.description,
+ category = programme.category,
+ lang = programme.lang,
+ rating = programme.rating,
+ imageUrl = programme.imageUrl,
+ episodeInfo = programme.episodeInfo
+ )
)
- )
- programmeCount++
- if (programmeBatch.size >= PROGRAMME_BATCH_SIZE) {
- epgProgrammeDao.insertAll(programmeBatch.toList())
- programmeBatch.clear()
+ programmeCount++
+ if (programmeBatch.size >= PROGRAMME_BATCH_SIZE) {
+ epgProgrammeDao.insertAll(programmeBatch.toList())
+ programmeBatch.clear()
+ }
}
- }
- )
+ )
+ }
}
// Flush remaining
diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
index ba4e99f6..8fa2d1ca 100644
--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
@@ -61,6 +61,7 @@ class MovieRepositoryImpl @Inject constructor(
private val categoryDao: CategoryDao,
private val providerDao: ProviderDao,
private val xtreamApiService: XtreamApiService,
+ private val credentialCrypto: CredentialCrypto,
private val preferencesRepository: PreferencesRepository,
private val favoriteDao: FavoriteDao,
private val playbackHistoryDao: PlaybackHistoryDao,
@@ -936,13 +937,19 @@ class MovieRepositoryImpl @Inject constructor(
?: movie.year?.toLongOrNull()
?: 0L
- private fun getOrCreateXtreamProvider(providerId: Long, provider: ProviderEntity): XtreamProvider {
- val signature = listOf(provider.serverUrl, provider.username, provider.password).joinToString("\u0000")
+ private suspend fun getOrCreateXtreamProvider(providerId: Long, provider: ProviderEntity): XtreamProvider {
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
+ val signature = listOf(
+ provider.serverUrl,
+ provider.username,
+ provider.password,
+ enableBase64TextCompatibility.toString()
+ ).joinToString("\u0000")
return xtreamProviderCache.compute(providerId) { _, cached ->
if (cached != null && cached.signature == signature) {
cached
} else {
- val decryptedPassword = CredentialCrypto.decryptIfNeeded(provider.password)
+ val decryptedPassword = credentialCrypto.decryptIfNeeded(provider.password)
CachedXtreamProvider(
signature = signature,
provider = XtreamProvider(
@@ -951,7 +958,8 @@ class MovieRepositoryImpl @Inject constructor(
serverUrl = provider.serverUrl,
username = provider.username,
password = decryptedPassword,
- allowedOutputFormats = provider.toDomain().allowedOutputFormats
+ allowedOutputFormats = provider.toDomain().allowedOutputFormats,
+ enableBase64TextCompatibility = enableBase64TextCompatibility
)
)
}
diff --git a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
index f4f83d30..dec717a6 100644
--- a/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/PlaybackHistoryRepositoryImpl.kt
@@ -1,5 +1,6 @@
package com.streamvault.data.repository
+import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.dao.EpisodeDao
import com.streamvault.data.local.dao.MovieDao
import com.streamvault.data.local.dao.PlaybackHistoryDao
@@ -23,7 +24,8 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
private val dao: PlaybackHistoryDao,
private val preferencesRepository: PreferencesRepository,
private val movieDao: MovieDao,
- private val episodeDao: EpisodeDao
+ private val episodeDao: EpisodeDao,
+ private val transactionRunner: DatabaseTransactionRunner
) : PlaybackHistoryRepository {
override fun getRecentlyWatched(limit: Int): Flow<List<PlaybackHistory>> {
@@ -67,8 +69,10 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
watchedStatus = PlaybackWatchedStatus.COMPLETED_MANUAL,
lastWatchedAt = System.currentTimeMillis()
)
- dao.insertOrUpdate(updatedHistory.toEntity())
- syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ transactionRunner.inTransaction {
+ dao.insertOrUpdate(updatedHistory.toEntity())
+ syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to mark content as watched", e)
@@ -94,8 +98,10 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
),
lastWatchedAt = System.currentTimeMillis()
)
- dao.insertOrUpdate(updatedHistory.toEntity())
- syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ transactionRunner.inTransaction {
+ dao.insertOrUpdate(updatedHistory.toEntity())
+ syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to record playback history", e)
@@ -121,8 +127,10 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
),
lastWatchedAt = System.currentTimeMillis()
)
- dao.insertOrUpdate(updatedHistory.toEntity())
- syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ transactionRunner.inTransaction {
+ dao.insertOrUpdate(updatedHistory.toEntity())
+ syncDenormalizedProgress(updatedHistory.contentId, updatedHistory.contentType, updatedHistory.providerId)
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to update playback resume position", e)
@@ -130,24 +138,30 @@ class PlaybackHistoryRepositoryImpl @Inject constructor(
}
override suspend fun removeFromHistory(contentId: Long, contentType: ContentType, providerId: Long): Result<Unit> = try {
- dao.delete(contentId, contentType.name, providerId)
- syncDenormalizedProgress(contentId, contentType, providerId)
+ transactionRunner.inTransaction {
+ dao.delete(contentId, contentType.name, providerId)
+ syncDenormalizedProgress(contentId, contentType, providerId)
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to remove playback history item", e)
}
override suspend fun clearAllHistory(): Result<Unit> = try {
- dao.deleteAll()
- syncAllDenormalizedProgress()
+ transactionRunner.inTransaction {
+ dao.deleteAll()
+ syncAllDenormalizedProgress()
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to clear playback history", e)
}
override suspend fun clearHistoryForProvider(providerId: Long): Result<Unit> = try {
- dao.deleteByProvider(providerId)
- syncDenormalizedProgressForProvider(providerId)
+ transactionRunner.inTransaction {
+ dao.deleteByProvider(providerId)
+ syncDenormalizedProgressForProvider(providerId)
+ }
Result.success(Unit)
} catch (e: Exception) {
Result.error("Failed to clear provider playback history", e)
diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
index d35e3627..9bfdd3c3 100644
--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
@@ -1,8 +1,10 @@
package com.streamvault.data.repository
+import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.dao.*
import com.streamvault.data.local.entity.ProviderEntity
import com.streamvault.data.mapper.*
+import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamProvider
import com.streamvault.data.security.CredentialCrypto
@@ -12,12 +14,17 @@ import com.streamvault.data.util.ProviderInputSanitizer
import com.streamvault.data.util.UrlSecurityPolicy
import com.streamvault.domain.model.*
import com.streamvault.domain.provider.IptvProvider
+import com.streamvault.domain.repository.LiveStreamProgramRequest
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.repository.SyncMetadataRepository
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
import javax.inject.Inject
@@ -29,8 +36,11 @@ class ProviderRepositoryImpl @Inject constructor(
private val channelDao: ChannelDao,
private val programDao: ProgramDao,
private val xtreamApiService: XtreamApiService,
+ private val credentialCrypto: CredentialCrypto,
+ private val preferencesRepository: PreferencesRepository,
private val syncManager: SyncManager,
- private val syncMetadataRepository: SyncMetadataRepository
+ private val syncMetadataRepository: SyncMetadataRepository,
+ private val transactionRunner: DatabaseTransactionRunner
) : ProviderRepository {
private val repositoryScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
@@ -102,7 +112,7 @@ class ProviderRepositoryImpl @Inject constructor(
}
val effectivePassword = try {
password.takeIf { it.isNotBlank() }
- ?: existingProvider?.password?.let(CredentialCrypto::decryptIfNeeded)
+ ?: existingProvider?.password?.let(credentialCrypto::decryptIfNeeded)
?: ""
} catch (e: CredentialDecryptionException) {
return Result.error(e.message ?: CredentialDecryptionException.MESSAGE, e)
@@ -286,7 +296,108 @@ class ProviderRepositoryImpl @Inject constructor(
epgChannelId: String?,
limit: Int
): Result<List<Program>> {
- if (providerId <= 0L || streamId <= 0L) {
+ return when (val providerContextResult = createXtreamLiveProgramProviderContext(providerId)) {
+ is Result.Success -> fetchXtreamProgramsForLiveStream(
+ providerId = providerId,
+ streamId = streamId,
+ epgChannelId = epgChannelId,
+ limit = limit,
+ xtreamProvider = providerContextResult.data
+ )
+ is Result.Error -> Result.error(providerContextResult.message, providerContextResult.exception)
+ is Result.Loading -> Result.error("Unexpected loading state")
+ }
+ }
+
+ override suspend fun getProgramsForLiveStreams(
+ providerId: Long,
+ requests: List<LiveStreamProgramRequest>,
+ limit: Int
+ ): Map<LiveStreamProgramRequest, Result<List<Program>>> {
+ val normalizedRequests = requests
+ .filter { it.streamId > 0L }
+ .distinct()
+ if (normalizedRequests.isEmpty()) {
+ return emptyMap()
+ }
+
+ return when (val providerContextResult = createXtreamLiveProgramProviderContext(providerId)) {
+ is Result.Success -> coroutineScope {
+ normalizedRequests
+ .map { request ->
+ async {
+ request to fetchXtreamProgramsForLiveStream(
+ providerId = providerId,
+ streamId = request.streamId,
+ epgChannelId = request.epgChannelId,
+ limit = limit,
+ xtreamProvider = providerContextResult.data
+ )
+ }
+ }
+ .awaitAll()
+ .toMap()
+ }
+ is Result.Error -> normalizedRequests.associateWith { request ->
+ Result.error(providerContextResult.message, providerContextResult.exception)
+ }
+ is Result.Loading -> normalizedRequests.associateWith {
+ Result.error("Unexpected loading state")
+ }
+ }
+ }
+
+ override suspend fun buildCatchUpUrl(providerId: Long, streamId: Long, start: Long, end: Long): String? {
+ return buildCatchUpUrls(providerId, streamId, start, end).firstOrNull()
+ }
+
+ override suspend fun buildCatchUpUrls(providerId: Long, streamId: Long, start: Long, end: Long): List<String> {
+ val providerEntity = providerDao.getById(providerId) ?: return emptyList()
+ val provider = providerEntity.toPublicDomain()
+ val providerPassword = credentialCrypto.decryptIfNeeded(providerEntity.password)
+ val channel = channelDao.getById(streamId)
+ val resolvedStreamId = channel?.streamId?.takeIf { it > 0 } ?: streamId
+ return if (provider.type == ProviderType.XTREAM_CODES) {
+ createXtreamProvider(
+ providerId = providerId,
+ serverUrl = provider.serverUrl,
+ username = provider.username,
+ password = providerPassword,
+ allowedOutputFormats = provider.allowedOutputFormats
+ )
+ .buildCatchUpUrls(resolvedStreamId, start, end)
+ } else {
+ // M3U catch-up
+ val source = channel?.catchUpSource ?: return emptyList()
+ buildM3uCatchUpUrls(source, start, end)
+ }
+ }
+
+ suspend fun createXtreamProvider(
+ providerId: Long,
+ serverUrl: String,
+ username: String,
+ password: String,
+ allowedOutputFormats: List<String> = emptyList()
+ ): IptvProvider {
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
+ return XtreamProvider(
+ providerId = providerId,
+ api = xtreamApiService,
+ serverUrl = serverUrl,
+ username = username,
+ password = password,
+ allowedOutputFormats = allowedOutputFormats,
+ enableBase64TextCompatibility = enableBase64TextCompatibility
+ )
+ }
+
+ private fun ProviderEntity.toPublicDomain(): Provider {
+ return toDomain().copy(password = "")
+ }
+
+ private suspend fun createXtreamLiveProgramProviderContext(providerId: Long): Result<XtreamProvider> {
+ if (providerId <= 0L) {
return Result.error("Live stream context is unavailable.")
}
@@ -298,18 +409,32 @@ class ProviderRepositoryImpl @Inject constructor(
}
val providerPassword = try {
- CredentialCrypto.decryptIfNeeded(providerEntity.password)
+ credentialCrypto.decryptIfNeeded(providerEntity.password)
} catch (e: CredentialDecryptionException) {
return Result.error(e.message ?: CredentialDecryptionException.MESSAGE, e)
}
- val xtreamProvider = createXtreamProvider(
- providerId = providerId,
- serverUrl = provider.serverUrl,
- username = provider.username,
- password = providerPassword,
- allowedOutputFormats = provider.allowedOutputFormats
+ return Result.success(
+ createXtreamProvider(
+ providerId = providerId,
+ serverUrl = provider.serverUrl,
+ username = provider.username,
+ password = providerPassword,
+ allowedOutputFormats = provider.allowedOutputFormats
+ ) as XtreamProvider
)
+ }
+
+ private suspend fun fetchXtreamProgramsForLiveStream(
+ providerId: Long,
+ streamId: Long,
+ epgChannelId: String?,
+ limit: Int,
+ xtreamProvider: XtreamProvider
+ ): Result<List<Program>> {
+ if (providerId <= 0L || streamId <= 0L) {
+ return Result.error("Live stream context is unavailable.")
+ }
val shortProgramsResult = xtreamProvider.getShortEpg(
channelId = streamId.toString(),
@@ -355,53 +480,8 @@ class ProviderRepositoryImpl @Inject constructor(
}
}
- override suspend fun buildCatchUpUrl(providerId: Long, streamId: Long, start: Long, end: Long): String? {
- return buildCatchUpUrls(providerId, streamId, start, end).firstOrNull()
- }
-
- override suspend fun buildCatchUpUrls(providerId: Long, streamId: Long, start: Long, end: Long): List<String> {
- val providerEntity = providerDao.getById(providerId) ?: return emptyList()
- val provider = providerEntity.toPublicDomain()
- val providerPassword = CredentialCrypto.decryptIfNeeded(providerEntity.password)
- val channel = channelDao.getById(streamId)
- val resolvedStreamId = channel?.streamId?.takeIf { it > 0 } ?: streamId
- return if (provider.type == ProviderType.XTREAM_CODES) {
- createXtreamProvider(
- providerId = providerId,
- serverUrl = provider.serverUrl,
- username = provider.username,
- password = providerPassword,
- allowedOutputFormats = provider.allowedOutputFormats
- )
- .buildCatchUpUrls(resolvedStreamId, start, end)
- } else {
- // M3U catch-up
- val source = channel?.catchUpSource ?: return emptyList()
- buildM3uCatchUpUrls(source, start, end)
- }
- }
-
- fun createXtreamProvider(
- providerId: Long,
- serverUrl: String,
- username: String,
- password: String,
- allowedOutputFormats: List<String> = emptyList()
- ): IptvProvider = XtreamProvider(
- providerId = providerId,
- api = xtreamApiService,
- serverUrl = serverUrl,
- username = username,
- password = password,
- allowedOutputFormats = allowedOutputFormats
- )
-
- private fun ProviderEntity.toPublicDomain(): Provider {
- return toDomain().copy(password = "")
- }
-
private fun Provider.toSecureEntity(): ProviderEntity {
- val encryptedPassword = CredentialCrypto.encryptIfNeeded(password)
+ val encryptedPassword = credentialCrypto.encryptIfNeeded(password)
return copy(password = encryptedPassword).toEntity()
}
@@ -443,8 +523,10 @@ class ProviderRepositoryImpl @Inject constructor(
private suspend fun cacheProgramsForChannel(providerId: Long, programs: List<Program>) {
val channelId = programs.firstOrNull()?.channelId ?: return
- programDao.deleteForChannel(providerId, channelId)
- programDao.insertAll(programs.map { it.toEntity().copy(providerId = providerId) })
+ transactionRunner.inTransaction {
+ programDao.deleteForChannel(providerId, channelId)
+ programDao.insertAll(programs.map { it.toEntity().copy(providerId = providerId) })
+ }
}
private suspend fun refreshCachedEpgMetadata(providerId: Long) {
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index ed089ae5..2c89a707 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -46,6 +46,7 @@ class SeriesRepositoryImpl @Inject constructor(
private val playbackHistoryDao: PlaybackHistoryDao,
private val providerDao: ProviderDao,
private val xtreamApiService: XtreamApiService,
+ private val credentialCrypto: CredentialCrypto,
private val preferencesRepository: PreferencesRepository,
private val xtreamStreamUrlResolver: XtreamStreamUrlResolver,
private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao
@@ -835,13 +836,19 @@ class SeriesRepositoryImpl @Inject constructor(
?.toLongOrNull()
?: 0L
- private fun getOrCreateXtreamProvider(providerId: Long, provider: ProviderEntity): XtreamProvider {
- val signature = listOf(provider.serverUrl, provider.username, provider.password).joinToString("\u0000")
+ private suspend fun getOrCreateXtreamProvider(providerId: Long, provider: ProviderEntity): XtreamProvider {
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
+ val signature = listOf(
+ provider.serverUrl,
+ provider.username,
+ provider.password,
+ enableBase64TextCompatibility.toString()
+ ).joinToString("\u0000")
return xtreamProviderCache.compute(providerId) { _, cached ->
if (cached != null && cached.signature == signature) {
cached
} else {
- val decryptedPassword = CredentialCrypto.decryptIfNeeded(provider.password)
+ val decryptedPassword = credentialCrypto.decryptIfNeeded(provider.password)
CachedXtreamProvider(
signature = signature,
provider = XtreamProvider(
@@ -850,7 +857,8 @@ class SeriesRepositoryImpl @Inject constructor(
serverUrl = provider.serverUrl,
username = provider.username,
password = decryptedPassword,
- allowedOutputFormats = provider.toDomain().allowedOutputFormats
+ allowedOutputFormats = provider.toDomain().allowedOutputFormats,
+ enableBase64TextCompatibility = enableBase64TextCompatibility
)
)
}
diff --git a/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt b/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
index c90a4827..5e885077 100644
--- a/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
+++ b/data/src/main/java/com/streamvault/data/security/CredentialCrypto.kt
@@ -8,22 +8,34 @@ import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.SecretKey
import javax.crypto.spec.GCMParameterSpec
+import javax.inject.Inject
+import javax.inject.Singleton
/**
- * AES-GCM credential crypto backed by Android Keystore.
+ * Contract for AES-GCM credential encryption backed by Android Keystore.
+ * Expressed as an interface so implementations can be replaced with test fakes.
+ */
+interface CredentialCrypto {
+ fun encryptIfNeeded(value: String): String
+ fun decryptIfNeeded(value: String): String
+}
+
+/**
+ * Production implementation backed by the Android Keystore system.
*
* Values are persisted as: enc:v1:<base64(iv + ciphertext)>
*/
-object CredentialCrypto {
- private const val TAG = "CredentialCrypto"
- private const val KEYSTORE_TYPE = "AndroidKeyStore"
- private const val KEY_ALIAS = "streamvault_credentials"
- private const val TRANSFORMATION = "AES/GCM/NoPadding"
- private const val IV_SIZE_BYTES = 12
- private const val AUTH_TAG_BITS = 128
- private const val PREFIX = "enc:v1:"
+@Singleton
+class AndroidKeystoreCredentialCrypto @Inject constructor() : CredentialCrypto {
+ private val TAG = "CredentialCrypto"
+ private val KEYSTORE_TYPE = "AndroidKeyStore"
+ private val KEY_ALIAS = "streamvault_credentials"
+ private val TRANSFORMATION = "AES/GCM/NoPadding"
+ private val IV_SIZE_BYTES = 12
+ private val AUTH_TAG_BITS = 128
+ private val PREFIX = "enc:v1:"
- fun encryptIfNeeded(value: String): String {
+ override fun encryptIfNeeded(value: String): String {
if (value.isBlank() || value.startsWith(PREFIX)) return value
return try {
@@ -40,7 +52,7 @@ object CredentialCrypto {
}
}
- fun decryptIfNeeded(value: String): String {
+ override fun decryptIfNeeded(value: String): String {
if (!value.startsWith(PREFIX)) return value
return try {
diff --git a/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt b/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt
index c3d4721a..e1ae13e8 100644
--- a/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt
+++ b/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt
@@ -18,7 +18,8 @@ class DatabaseMaintenanceManager @Inject constructor(
private val programDao: ProgramDao,
private val epgProgrammeDao: EpgProgrammeDao,
private val episodeDao: EpisodeDao,
- private val favoriteDao: FavoriteDao
+ private val favoriteDao: FavoriteDao,
+ private val syncManager: SyncManager
) {
suspend fun runDailyMaintenance(now: Long = System.currentTimeMillis()): MaintenanceReport = withContext(Dispatchers.IO) {
@@ -31,9 +32,13 @@ class DatabaseMaintenanceManager @Inject constructor(
favoriteDao.deleteMissingSeriesFavorites()
val statsBeforeVacuum = collectStorageStats()
- val vacuumRan = shouldVacuum(statsBeforeVacuum)
- if (vacuumRan) {
+ val vacuumRan = if (shouldVacuum(statsBeforeVacuum) && !isSyncActive()) {
runVacuum()
+ } else {
+ if (shouldVacuum(statsBeforeVacuum)) {
+ Log.i(TAG, "VACUUM skipped: a provider sync is currently active")
+ }
+ false
}
val statsAfterVacuum = collectStorageStats()
@@ -71,13 +76,31 @@ class DatabaseMaintenanceManager @Inject constructor(
)
}
- private fun runVacuum() {
+ /** Returns true if VACUUM ran, false if skipped due to busy readers. */
+ private suspend fun runVacuum(): Boolean = withContext(Dispatchers.IO) {
val sqliteDb = database.openHelper.writableDatabase
- sqliteDb.query("PRAGMA wal_checkpoint(TRUNCATE)").use { }
- sqliteDb.execSQL("VACUUM")
- Log.i(TAG, "Database VACUUM completed")
+
+ // Check WAL checkpoint result: column 1 = pages not yet checkpointed (busy readers).
+ // If any pages are busy, active read transactions exist — VACUUM would block them all.
+ val busyPages = sqliteDb.query("PRAGMA wal_checkpoint(TRUNCATE)").use { cursor ->
+ if (cursor.moveToFirst()) cursor.getInt(1) else 0
+ }
+
+ if (busyPages > 0) {
+ Log.w(TAG, "wal_checkpoint(TRUNCATE) had $busyPages busy pages; VACUUM skipped this cycle")
+ return@withContext false
+ }
+
+ val durationMs = kotlin.system.measureTimeMillis {
+ sqliteDb.execSQL("VACUUM")
+ }
+ Log.i(TAG, "Database VACUUM completed in ${durationMs}ms")
+ true
}
+ /** Returns true if any provider sync mutex is currently held. */
+ private fun isSyncActive(): Boolean = syncManager.isAnySyncActive()
+
private fun shouldVacuum(stats: DatabaseStorageStats): Boolean {
if (stats.reclaimableBytes < MIN_RECLAIMABLE_BYTES) return false
if (stats.mainDbBytes < MIN_DATABASE_BYTES) return false
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
index b47bc4fb..bdcbc4b0 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
@@ -116,6 +116,7 @@ class SyncManager @Inject constructor(
private val epgRepository: EpgRepository,
private val epgSourceRepository: EpgSourceRepository,
private val okHttpClient: OkHttpClient,
+ private val credentialCrypto: CredentialCrypto,
private val syncMetadataRepository: SyncMetadataRepository,
private val transactionRunner: DatabaseTransactionRunner,
private val preferencesRepository: com.streamvault.data.preferences.PreferencesRepository
@@ -239,17 +240,25 @@ class SyncManager @Inject constructor(
fun currentSyncState(providerId: Long): SyncState =
syncStateTracker.current(providerId)
+ /** Returns true if any provider sync mutex is currently held (used by DatabaseMaintenanceManager). */
+ fun isAnySyncActive(): Boolean = providerSyncMutexes.values.any { it.isLocked }
private suspend fun <T> withProviderLock(providerId: Long, block: suspend () -> T): T {
val mutex = providerSyncMutexes.computeIfAbsent(providerId) { Mutex() }
return mutex.withLock { block() }
}
suspend fun onProviderDeleted(providerId: Long) {
- backgroundEpgJobs.remove(providerId)?.cancel()
- syncStateTracker.reset(providerId)
+ val cancelledEpgJob = backgroundEpgJobs.remove(providerId)
+ if (cancelledEpgJob?.isActive == true) {
+ Log.w(TAG, "onProviderDeleted($providerId): cancelled an active background EPG job; mid-sync delete detected")
+ }
+ cancelledEpgJob?.cancel()
+ withProviderLock(providerId) {
+ syncStateTracker.reset(providerId)
+ xtreamAdaptiveSyncPolicy.forgetProvider(providerId)
+ syncCatalogStore.clearProviderStaging(providerId)
+ }
providerSyncMutexes.remove(providerId)
- xtreamAdaptiveSyncPolicy.forgetProvider(providerId)
- syncCatalogStore.clearProviderStaging(providerId)
}
fun scheduleBackgroundEpgSync(providerId: Long) {
@@ -258,7 +267,7 @@ class SyncManager @Inject constructor(
withProviderLock(providerId) {
val providerEntity = providerDao.getById(providerId) ?: return@withProviderLock
val provider = providerEntity
- .copy(password = CredentialCrypto.decryptIfNeeded(providerEntity.password))
+ .copy(password = credentialCrypto.decryptIfNeeded(providerEntity.password))
.toDomain()
try {
publishSyncState(providerId, SyncState.Syncing("Downloading EPG..."))
@@ -296,10 +305,12 @@ class SyncManager @Inject constructor(
}
}
}
+ // Store the launched job before registering completion cleanup so fast-completing
+ // coroutines cannot finish and race past map registration.
+ backgroundEpgJobs[providerId] = job
job.invokeOnCompletion {
backgroundEpgJobs.remove(providerId, job)
}
- backgroundEpgJobs[providerId] = job
}
private fun shouldSyncEpgUpfront(provider: Provider): Boolean =
@@ -316,7 +327,7 @@ class SyncManager @Inject constructor(
?: return@lock com.streamvault.domain.model.Result.error("Provider $providerId not found")
val provider = providerEntity
- .copy(password = CredentialCrypto.decryptIfNeeded(providerEntity.password))
+ .copy(password = credentialCrypto.decryptIfNeeded(providerEntity.password))
.toDomain()
.let { resolvedProvider ->
resolvedProvider.copy(
@@ -370,7 +381,7 @@ class SyncManager @Inject constructor(
?: return@lock com.streamvault.domain.model.Result.error("Provider $providerId not found")
val provider = providerEntity
- .copy(password = CredentialCrypto.decryptIfNeeded(providerEntity.password))
+ .copy(password = credentialCrypto.decryptIfNeeded(providerEntity.password))
.toDomain()
.let { resolvedProvider ->
movieFastSyncOverride?.let { override ->
@@ -413,8 +424,9 @@ class SyncManager @Inject constructor(
}
progress(provider.id, onProgress, "Connecting to server...")
val useTextClassification = preferencesRepository.useXtreamTextClassification.first()
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()
- val api = createXtreamSyncProvider(provider, useTextClassification)
+ val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)
var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)
val now = System.currentTimeMillis()
@@ -946,8 +958,9 @@ class SyncManager @Inject constructor(
ProviderType.XTREAM_CODES -> {
progress(provider.id, onProgress, "Retrying Live TV...")
val useTextClassification = preferencesRepository.useXtreamTextClassification.first()
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()
- val api = createXtreamSyncProvider(provider, useTextClassification)
+ val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)
val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)
val liveSyncResult = syncXtreamLiveCatalog(
provider = provider,
@@ -1076,7 +1089,8 @@ class SyncManager @Inject constructor(
"Retrying Movies..."
)
val useTextClassification = preferencesRepository.useXtreamTextClassification.first()
- val api = createXtreamSyncProvider(provider, useTextClassification)
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
+ val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)
val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)
val movieSyncResult = syncXtreamMoviesCatalog(
provider = provider,
@@ -1230,7 +1244,8 @@ class SyncManager @Inject constructor(
}
progress(provider.id, onProgress, "Retrying Series...")
val useTextClassification = preferencesRepository.useXtreamTextClassification.first()
- val api = createXtreamSyncProvider(provider, useTextClassification)
+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()
+ val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)
val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)
val seriesSyncResult = syncXtreamSeriesCatalog(
provider = provider,
@@ -1667,7 +1682,11 @@ class SyncManager @Inject constructor(
private const val PROGRESS_INTERVAL = 5_000
}
- private fun createXtreamSyncProvider(provider: Provider, useTextClassification: Boolean = true): XtreamProvider {
+ private fun createXtreamSyncProvider(
+ provider: Provider,
+ useTextClassification: Boolean = true,
+ enableBase64TextCompatibility: Boolean = false
+ ): XtreamProvider {
return XtreamProvider(
providerId = provider.id,
api = xtreamCatalogApiService,
@@ -1675,7 +1694,8 @@ class SyncManager @Inject constructor(
username = provider.username,
password = provider.password,
allowedOutputFormats = provider.allowedOutputFormats,
- useTextClassification = useTextClassification
+ useTextClassification = useTextClassification,
+ enableBase64TextCompatibility = enableBase64TextCompatibility
)
}
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt b/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt
index f1ee0e75..011e3a64 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt
@@ -216,9 +216,19 @@ internal class SyncManagerM3uImporter(
private fun ensureSuccessfulPlaylistResponse(response: Response) {
if (response.isSuccessful) return
if (response.code in 500..599 || response.code == 429) {
+ // Transient — the retry wrapper will attempt again automatically.
throw IOException("Transient HTTP ${response.code}")
}
- throw IllegalStateException("Failed to download M3U: HTTP ${response.code}")
+ // Non-transient failures: produce an actionable message so the user understands
+ // exactly why this source was skipped (especially relevant for CombinedM3U profiles).
+ val reason = when (response.code) {
+ 401 -> "subscription credentials were rejected (HTTP 401 Unauthorized) — check your username and password"
+ 403 -> "access was denied by the provider (HTTP 403 Forbidden) — your subscription may have expired or your IP is banned"
+ 404 -> "the playlist URL was not found on the server (HTTP 404 Not Found) — the provider URL may have changed"
+ 407 -> "a proxy authentication error occurred (HTTP 407) — check your network settings"
+ else -> "the server returned an unexpected error (HTTP ${response.code})"
+ }
+ throw IllegalStateException("Failed to download M3U playlist: $reason")
}
private fun maybeDecompressPlaylist(streamed: StreamedPlaylist): InputStream {
diff --git a/data/src/main/java/com/streamvault/data/util/FtsQueryUtils.kt b/data/src/main/java/com/streamvault/data/util/FtsQueryUtils.kt
index b6b8f4e4..db748755 100644
--- a/data/src/main/java/com/streamvault/data/util/FtsQueryUtils.kt
+++ b/data/src/main/java/com/streamvault/data/util/FtsQueryUtils.kt
@@ -9,11 +9,13 @@ package com.streamvault.data.util
*
* Example: "star wars" → "star* AND wars*"
*/
-internal fun String.toFtsPrefixQuery(): String {
+internal fun String.toFtsPrefixQuery(): String? {
val tokens = trim()
.split(Regex("\\s+"))
.map { token -> token.replace(Regex("[^\\p{L}\\p{N}_]"), "") }
.filter { it.length >= 2 }
+ if (tokens.isEmpty()) return null
+
return tokens.joinToString(" AND ") { "$it*" }
}
diff --git a/data/src/main/java/com/streamvault/data/util/ProviderInputSanitizer.kt b/data/src/main/java/com/streamvault/data/util/ProviderInputSanitizer.kt
index ed8f71de..e84b9793 100644
--- a/data/src/main/java/com/streamvault/data/util/ProviderInputSanitizer.kt
+++ b/data/src/main/java/com/streamvault/data/util/ProviderInputSanitizer.kt
@@ -32,7 +32,7 @@ object ProviderInputSanitizer {
}
private fun sanitizeSingleLine(input: String, maxLength: Int): String {
- return sanitizeRaw(input, maxLength).replace(LINE_BREAK_REGEX, " ")
+ return sanitizeRaw(input, maxLength).replace(WHITESPACE_REGEX, " ")
}
private fun sanitizeRaw(input: String, maxLength: Int): String {
@@ -46,6 +46,5 @@ object ProviderInputSanitizer {
return sanitized.take(maxLength)
}
- private val LINE_BREAK_REGEX = Regex("\\s+")
private val WHITESPACE_REGEX = Regex("\\s+")
}
\ No newline at end of file
diff --git a/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.kt b/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.kt
index ebbfdd31..c0336e15 100644
--- a/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.kt
+++ b/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.kt
@@ -1,5 +1,6 @@
package com.streamvault.data.util
+import com.streamvault.domain.util.StreamEntryUrlPolicy
import java.net.URI
import java.util.Locale
@@ -19,7 +20,7 @@ object UrlSecurityPolicy {
/** Validates individual stream/asset entries inside an imported playlist. HTTP is allowed here
* because the majority of IPTV providers serve streams over plain HTTP. */
fun isAllowedStreamEntryUrl(url: String): Boolean =
- !containsNewlines(url) && hasAllowedScheme(url, streamEntrySchemes)
+ StreamEntryUrlPolicy.isAllowed(url)
fun validateXtreamServerUrl(url: String): String? {
return if (!containsNewlines(url) && hasAllowedScheme(url, xtreamServerSchemes)) {
@@ -65,9 +66,16 @@ object UrlSecurityPolicy {
}
private fun containsNewlines(url: String): Boolean {
- val decoded = url.replace("%0A", "\n", ignoreCase = true)
- .replace("%0D", "\r", ignoreCase = true)
- return decoded.contains('\n') || decoded.contains('\r')
+ // Decode up to two percent-encoding layers to catch double-encoded payloads
+ // (e.g. %250A → %0A → \n). Also checks %09 (tab) which can split log lines.
+ var decoded = url
+ repeat(2) {
+ decoded = decoded
+ .replace("%0A", "\n", ignoreCase = true)
+ .replace("%0D", "\r", ignoreCase = true)
+ .replace("%09", "\t", ignoreCase = true)
+ }
+ return decoded.any { it == '\n' || it == '\r' || it == '\t' }
}
private fun parseScheme(url: String): String? {
diff --git a/data/src/test/java/com/streamvault/data/manager/RecordingConflictDetectorTest.kt b/data/src/test/java/com/streamvault/data/manager/RecordingConflictDetectorTest.kt
index f91a5280..e81fa135 100644
--- a/data/src/test/java/com/streamvault/data/manager/RecordingConflictDetectorTest.kt
+++ b/data/src/test/java/com/streamvault/data/manager/RecordingConflictDetectorTest.kt
@@ -1,6 +1,10 @@
package com.streamvault.data.manager
import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.entity.RecordingRunEntity
+import com.streamvault.domain.model.RecordingFailureCategory
+import com.streamvault.domain.model.RecordingRecurrence
+import com.streamvault.domain.model.RecordingSourceType
import com.streamvault.domain.model.RecordingItem
import com.streamvault.domain.model.RecordingStatus
import org.junit.Test
@@ -61,6 +65,49 @@ class RecordingConflictDetectorTest {
assertThat(conflict).isNull()
}
+ @Test
+ fun `findRecordingRunConflict returns overlapping manual run for recurring candidate`() {
+ val conflict = listOf(
+ recordingRun(
+ id = "manual-1",
+ startMs = 10_000L,
+ endMs = 20_000L,
+ status = RecordingStatus.SCHEDULED,
+ recurrence = RecordingRecurrence.NONE
+ )
+ ).findRecordingRunConflict(
+ candidateStartMs = 12_000L,
+ candidateEndMs = 18_000L,
+ statuses = setOf(RecordingStatus.SCHEDULED, RecordingStatus.RECORDING)
+ )
+
+ assertThat(conflict?.id).isEqualTo("manual-1")
+ }
+
+ @Test
+ fun `toConflictFailure marks skipped recurring run as failed conflict`() {
+ val failed = recordingRun(
+ id = "recurring-1",
+ startMs = 10_000L,
+ endMs = 20_000L,
+ status = RecordingStatus.SCHEDULED,
+ recurrence = RecordingRecurrence.DAILY,
+ recurringRuleId = "rule-1"
+ ).toConflictFailure(
+ conflictStartMs = 30_000L,
+ conflictEndMs = 40_000L,
+ reason = "Skipped recurring occurrence because it conflicts with 'Manual recording'.",
+ nowMs = 25_000L
+ )
+
+ assertThat(failed.id).isNotEqualTo("recurring-1")
+ assertThat(failed.status).isEqualTo(RecordingStatus.FAILED)
+ assertThat(failed.failureCategory).isEqualTo(RecordingFailureCategory.SCHEDULE_CONFLICT)
+ assertThat(failed.scheduleEnabled).isFalse()
+ assertThat(failed.scheduledStartMs).isEqualTo(30_000L)
+ assertThat(failed.scheduledEndMs).isEqualTo(40_000L)
+ }
+
private fun recordingItem(
id: String,
startMs: Long,
@@ -78,4 +125,30 @@ class RecordingConflictDetectorTest {
outputPath = "/tmp/$id.ts",
status = status
)
-}
\ No newline at end of file
+
+ private fun recordingRun(
+ id: String,
+ startMs: Long,
+ endMs: Long,
+ status: RecordingStatus,
+ recurrence: RecordingRecurrence,
+ recurringRuleId: String? = null
+ ) = RecordingRunEntity(
+ id = id,
+ scheduleId = 1L,
+ providerId = 1L,
+ channelId = 100L,
+ channelName = "Sports 1",
+ streamUrl = "https://example.com/live.ts",
+ programTitle = "Match Day",
+ scheduledStartMs = startMs,
+ scheduledEndMs = endMs,
+ recurrence = recurrence,
+ recurringRuleId = recurringRuleId,
+ status = status,
+ sourceType = RecordingSourceType.UNKNOWN,
+ headersJson = "{}",
+ failureCategory = RecordingFailureCategory.NONE,
+ scheduleEnabled = true
+ )
+}
diff --git a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
index b2b09cd8..cf9026ae 100644
--- a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamProviderTest.kt
@@ -144,7 +144,7 @@ class XtreamProviderTest {
}
@Test
- fun `getVodInfo decodes common xtream metadata fields`() = runBlocking {
+ fun `getVodInfo keeps names raw while decoding common xtream metadata fields`() = runBlocking {
val provider = XtreamProvider(
providerId = 42,
api = FakeXtreamApiService(
@@ -173,7 +173,7 @@ class XtreamProviderTest {
val movie = provider.getVodInfo(99).getOrNull()
assertThat(movie).isNotNull()
- assertThat(movie?.name).isEqualTo("Movie Name")
+ assertThat(movie?.name).isEqualTo("TW92aWUgTmFtZQ==")
assertThat(movie?.plot).isEqualTo("Some Plot")
assertThat(movie?.cast).isEqualTo("John Doe")
assertThat(movie?.director).isEqualTo("Jane Doe")
@@ -183,6 +183,100 @@ class XtreamProviderTest {
)
}
+ @Test
+ fun `getSeriesList keeps plain titles that only accidentally look like base64`() = runBlocking {
+ val provider = XtreamProvider(
+ providerId = 42,
+ api = FakeXtreamApiService(
+ seriesList = listOf(
+ XtreamSeriesItem(name = "Asaf", seriesId = 1),
+ XtreamSeriesItem(name = "THEM", seriesId = 2),
+ XtreamSeriesItem(name = "Silo", seriesId = 3)
+ )
+ ),
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass"
+ )
+
+ val names = provider.getSeriesList().getOrNull().orEmpty().map { it.name }
+
+ assertThat(names).containsExactly("Asaf", "THEM", "Silo").inOrder()
+ }
+
+ @Test
+ fun `getSeriesList keeps padded base64 looking titles raw`() {
+ runBlocking {
+ val provider = XtreamProvider(
+ providerId = 42,
+ api = FakeXtreamApiService(
+ seriesList = listOf(
+ XtreamSeriesItem(name = "TW92aWUgTmFtZQ==", seriesId = 77)
+ )
+ ),
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass"
+ )
+
+ val names = provider.getSeriesList().getOrNull().orEmpty().map { it.name }
+
+ assertThat(names).containsExactly("TW92aWUgTmFtZQ==")
+ }
+ }
+
+ @Test
+ fun `getSeriesList decodes padded base64 looking titles when compatibility mode is enabled`() {
+ runBlocking {
+ val provider = XtreamProvider(
+ providerId = 42,
+ api = FakeXtreamApiService(
+ seriesList = listOf(
+ XtreamSeriesItem(name = "TW92aWUgTmFtZQ==", seriesId = 77)
+ )
+ ),
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass",
+ enableBase64TextCompatibility = true
+ )
+
+ val names = provider.getSeriesList().getOrNull().orEmpty().map { it.name }
+
+ assertThat(names).containsExactly("Movie Name")
+ }
+ }
+
+ @Test
+ fun `getFullEpg still decodes base64 title and description`() = runBlocking {
+ val provider = XtreamProvider(
+ providerId = 42,
+ api = FakeXtreamApiService(
+ fullEpg = XtreamEpgResponse(
+ epgListings = listOf(
+ XtreamEpgListing(
+ id = "15",
+ channelId = "news",
+ title = "TmV3cyBIb3Vy",
+ description = "VG9uaWdodCdzIGhlYWRsaW5lcw==",
+ startTimestamp = 1_710_000_000L,
+ stopTimestamp = 1_710_003_600L
+ )
+ )
+ )
+ ),
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass"
+ )
+
+ val programs = provider.getEpg("news").getOrNull().orEmpty()
+
+ assertThat(programs).hasSize(1)
+ assertThat(programs.single().title).isEqualTo("News Hour")
+ assertThat(programs.single().description).isEqualTo("Tonight's headlines")
+ }
+
@Test
fun `getVodStreams still loads when category prefetch fails`() = runBlocking {
val provider = XtreamProvider(
diff --git a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
index c5638de4..5bb75d6e 100644
--- a/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolverTest.kt
@@ -3,12 +3,18 @@ package com.streamvault.data.remote.xtream
import com.google.common.truth.Truth.assertThat
import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.entity.ProviderEntity
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.runBlocking
import org.junit.Test
class XtreamStreamUrlResolverTest {
+ private val credentialCrypto = object : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String = value
+ override fun decryptIfNeeded(value: String): String = value
+ }
+
@Test
fun buildPlaybackUrl_uses_live_container_extension_when_present() {
@@ -51,7 +57,8 @@ class XtreamStreamUrlResolverTest {
username = "alice",
password = "secret"
)
- )
+ ),
+ credentialCrypto = credentialCrypto
)
val url = XtreamUrlFactory.buildInternalStreamUrl(
providerId = 9,
@@ -79,7 +86,8 @@ class XtreamStreamUrlResolverTest {
username = "alice",
password = "secret"
)
- )
+ ),
+ credentialCrypto = credentialCrypto
)
val url = XtreamUrlFactory.buildInternalStreamUrl(
providerId = 9,
@@ -128,6 +136,8 @@ class XtreamStreamUrlResolverTest {
override fun getActive() = flowOf(provider)
override suspend fun getByUrlAndUser(serverUrl: String, username: String): ProviderEntity? = null
override suspend fun getById(id: Long): ProviderEntity? = provider?.takeIf { it.id == id }
+ override suspend fun getByIds(ids: List<Long>): List<ProviderEntity> =
+ listOfNotNull(provider).filter { it.id in ids }
override suspend fun insert(provider: ProviderEntity): Long = provider.id
override suspend fun update(provider: ProviderEntity) = Unit
override suspend fun delete(id: Long) = Unit
diff --git a/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.kt
index 0369a6de..41cb6ff2 100644
--- a/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.kt
@@ -1,6 +1,8 @@
package com.streamvault.data.repository
+import android.content.ContentResolver
import android.content.Context
+import android.net.Uri
import com.google.common.truth.Truth.assertThat
import com.streamvault.data.epg.EpgResolutionEngine
import com.streamvault.data.local.dao.ChannelEpgMappingDao
@@ -16,6 +18,7 @@ import com.streamvault.data.parser.XmltvParser
import com.streamvault.domain.model.EpgMatchType
import com.streamvault.domain.model.EpgSourceType
import com.streamvault.domain.model.Result
+import java.io.ByteArrayInputStream
import kotlinx.coroutines.test.runTest
import okhttp3.OkHttpClient
import org.junit.Before
@@ -31,6 +34,7 @@ import org.mockito.kotlin.whenever
class EpgSourceRepositoryImplTest {
private val context: Context = mock()
+ private val contentResolver: ContentResolver = mock()
private val epgSourceDao: EpgSourceDao = mock()
private val providerEpgSourceDao: ProviderEpgSourceDao = mock()
private val channelEpgMappingDao: ChannelEpgMappingDao = mock()
@@ -44,6 +48,7 @@ class EpgSourceRepositoryImplTest {
@Before
fun setup() {
+ whenever(context.contentResolver).thenReturn(contentResolver)
repository = EpgSourceRepositoryImpl(
context = context,
epgSourceDao = epgSourceDao,
@@ -171,4 +176,34 @@ class EpgSourceRepositoryImplTest {
assertThat(result.map { it.displayName }).containsExactly("BBC One")
assertThat(result.single().epgSourceName).isEqualTo("Primary")
}
+
+ @Test
+ fun `refreshSource_closesDecompressedXmlStream`() = runTest {
+ val source = EpgSourceEntity(
+ id = 10L,
+ name = "Primary",
+ url = "content://epg/source.xml.gz"
+ )
+ val decompressedStream = CloseTrackingInputStream()
+
+ whenever(epgSourceDao.getById(10L)).thenReturn(source)
+ whenever(contentResolver.openInputStream(Uri.parse(source.url))).thenReturn(ByteArrayInputStream(byteArrayOf(1, 2, 3)))
+ whenever(xmltvParser.maybeDecompressGzip(eq(source.url), any())).thenReturn(decompressedStream)
+ whenever(providerEpgSourceDao.getProviderIdsForSourceSync(10L)).thenReturn(emptyList())
+
+ val result = repository.refreshSource(10L)
+
+ assertThat(result is Result.Success).isTrue()
+ assertThat(decompressedStream.closed).isTrue()
+ }
+
+ private class CloseTrackingInputStream : ByteArrayInputStream(byteArrayOf()) {
+ var closed: Boolean = false
+ private set
+
+ override fun close() {
+ closed = true
+ super.close()
+ }
+ }
}
\ No newline at end of file
diff --git a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
index f7065856..7ad8174d 100644
--- a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
@@ -18,6 +18,7 @@ import com.streamvault.data.remote.dto.XtreamCategory
import com.streamvault.data.remote.dto.XtreamStream
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.ProviderStatus
import com.streamvault.domain.model.ProviderType
@@ -44,6 +45,10 @@ class MovieRepositoryImplTest {
private val xtreamStreamUrlResolver: XtreamStreamUrlResolver = mock()
private val movieCategoryHydrationDao: MovieCategoryHydrationDao = mock()
private val syncMetadataRepository: SyncMetadataRepository = mock()
+ private val credentialCrypto = object : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String = value
+ override fun decryptIfNeeded(value: String): String = value
+ }
private val transactionRunner = object : DatabaseTransactionRunner {
override suspend fun <T> inTransaction(block: suspend () -> T): T = block()
}
@@ -72,7 +77,8 @@ class MovieRepositoryImplTest {
rating = 9.5f
)
- whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
whenever(movieDao.getTopRatedPreview(7L, 48)).thenReturn(flowOf(listOf(recommendedMovie, unrelatedMovie, watchedMovie)))
whenever(movieDao.getFreshPreview(7L, 48)).thenReturn(flowOf(listOf(recommendedMovie, unrelatedMovie, watchedMovie)))
whenever(favoriteDao.getAllByType(ContentType.MOVIE.name)).thenReturn(flowOf(emptyList()))
@@ -124,6 +130,7 @@ class MovieRepositoryImplTest {
)
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
whenever(movieDao.getCountByCategory(7L, 10L)).thenReturn(flowOf(1))
whenever(movieDao.getById(targetMovie.id)).thenReturn(
movieRecord(
@@ -147,6 +154,7 @@ class MovieRepositoryImplTest {
@Test
fun `getMoviesByCategory lazily hydrates xtream category when local cache is empty`() = runTest {
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
whenever(movieDao.getCountByCategory(7L, 42L)).thenReturn(flowOf(0))
whenever(movieDao.getByCategory(7L, 42L)).thenReturn(flowOf(emptyList()))
whenever(movieCategoryHydrationDao.get(7L, 42L)).thenReturn(null)
@@ -188,6 +196,7 @@ class MovieRepositoryImplTest {
categoryDao = categoryDao,
providerDao = providerDao,
xtreamApiService = xtreamApiService,
+ credentialCrypto = credentialCrypto,
preferencesRepository = preferencesRepository,
favoriteDao = favoriteDao,
playbackHistoryDao = playbackHistoryDao,
diff --git a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
index 5ea8ec6b..e7565d9a 100644
--- a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
@@ -16,6 +16,7 @@ import com.streamvault.data.remote.dto.XtreamSeriesItem
import com.streamvault.data.remote.xtream.XtreamParsingException
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ProviderStatus
import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.flow.first
@@ -40,10 +41,15 @@ class SeriesRepositoryImplTest {
private val preferencesRepository: PreferencesRepository = mock()
private val xtreamStreamUrlResolver: XtreamStreamUrlResolver = mock()
private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao = mock()
+ private val credentialCrypto = object : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String = value
+ override fun decryptIfNeeded(value: String): String = value
+ }
@Test
fun `getSeriesByCategory lazily hydrates xtream category when local cache is empty`() = runTest {
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
whenever(seriesDao.getCountByCategory(7L, 77L)).thenReturn(flowOf(0))
whenever(seriesDao.getByCategory(7L, 77L)).thenReturn(flowOf(emptyList()))
whenever(providerDao.getById(7L)).thenReturn(
@@ -84,6 +90,7 @@ class SeriesRepositoryImplTest {
@Test
fun `getSeriesDetails falls back to remote series id lookup`() = runTest {
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
val seriesEntity = SeriesEntity(
id = 15L,
seriesId = 301L,
@@ -117,6 +124,7 @@ class SeriesRepositoryImplTest {
@Test
fun `getSeriesDetails returns local series when xtream details fail`() = runTest {
+ whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
val seriesEntity = SeriesEntity(
id = 15L,
seriesId = 301L,
@@ -159,6 +167,7 @@ class SeriesRepositoryImplTest {
playbackHistoryDao = playbackHistoryDao,
providerDao = providerDao,
xtreamApiService = xtreamApiService,
+ credentialCrypto = credentialCrypto,
preferencesRepository = preferencesRepository,
xtreamStreamUrlResolver = xtreamStreamUrlResolver,
seriesCategoryHydrationDao = seriesCategoryHydrationDao
diff --git a/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt
index 18098556..a0258de7 100644
--- a/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt
+++ b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt
@@ -6,12 +6,9 @@ import org.junit.Test
class CredentialCryptoTest {
@Test
- fun `decryptIfNeeded throws credential exception for unreadable encrypted value`() {
- val failure = runCatching {
- CredentialCrypto.decryptIfNeeded("enc:v1:not-valid-base64")
- }.exceptionOrNull()
+ fun `credential decryption exception exposes actionable default message`() {
+ val failure = CredentialDecryptionException()
- assertThat(failure).isInstanceOf(CredentialDecryptionException::class.java)
- assertThat(failure).hasMessageThat().contains("Please re-enter your provider credentials")
+ assertThat(failure.message).contains("Please re-enter your provider credentials")
}
}
\ No newline at end of file
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
index 06c87a88..f94bf0f7 100644
--- a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
@@ -11,6 +11,7 @@ import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.dao.SeriesDao
import com.streamvault.data.local.entity.ProviderEntity
import com.streamvault.data.parser.M3uParser
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.SyncState
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.ProviderType
@@ -65,6 +66,8 @@ class SyncManagerTest {
private val provider: ProviderEntity? = sampleProvider()
) : ProviderDao() {
override suspend fun getById(id: Long): ProviderEntity? = provider
+ override suspend fun getByIds(ids: List<Long>): List<ProviderEntity> =
+ listOfNotNull(provider).filter { it.id in ids }
override suspend fun updateSyncTime(id: Long, timestamp: Long) = Unit
override fun getAll() = kotlinx.coroutines.flow.flowOf(listOfNotNull(provider))
override fun getActive() = kotlinx.coroutines.flow.flowOf(provider)
@@ -168,6 +171,10 @@ class SyncManagerTest {
private val transactionRunner = object : DatabaseTransactionRunner {
override suspend fun <T> inTransaction(block: suspend () -> T): T = block()
}
+ private val credentialCrypto = object : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String = value
+ override fun decryptIfNeeded(value: String): String = value
+ }
private val syncMetadataRepo = FakeSyncMetadataRepository()
@Before
@@ -186,6 +193,7 @@ class SyncManagerTest {
preferencesRepo
)
org.mockito.kotlin.whenever(preferencesRepo.useXtreamTextClassification).thenReturn(flowOf(false))
+ org.mockito.kotlin.whenever(preferencesRepo.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
org.mockito.kotlin.whenever(preferencesRepo.getHiddenCategoryIds(any(), any())).thenReturn(flowOf(emptySet()))
}
@@ -212,6 +220,7 @@ class SyncManagerTest {
epgRepository = epgRepo,
epgSourceRepository = epgSourceRepo,
okHttpClient = xtreamBackend.okHttpClient(),
+ credentialCrypto = credentialCrypto,
syncMetadataRepository = syncMetadataRepo,
transactionRunner = transactionRunner,
preferencesRepository = preferencesRepo
@@ -380,6 +389,7 @@ class SyncManagerTest {
]
""".trimIndent()
)
+ org.mockito.kotlin.whenever(movieDao.getCount(1L)).thenReturn(flowOf(0))
val result = mgr.retrySection(
providerId = 1L,
@@ -549,44 +559,37 @@ class SyncManagerTest {
@Test
fun `isVodEntry_mp4Extension_returnsTrue`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(url = "http://vod.example.com/film.mp4"))).isTrue()
+ assertThat(M3uParser.isVodEntry(entry(url = "http://vod.example.com/film.mp4"))).isTrue()
}
@Test
fun `isVodEntry_mkvExtension_returnsTrue`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(url = "http://vod.example.com/show.mkv"))).isTrue()
+ assertThat(M3uParser.isVodEntry(entry(url = "http://vod.example.com/show.mkv"))).isTrue()
}
@Test
fun `isVodEntry_movieGroupTitle_returnsTrue`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(group = "Movies HD"))).isTrue()
+ assertThat(M3uParser.isVodEntry(entry(group = "Movies HD"))).isTrue()
}
@Test
fun `isVodEntry_vodGroupTitle_returnsTrue`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(group = "VOD Library"))).isTrue()
+ assertThat(M3uParser.isVodEntry(entry(group = "VOD Library"))).isTrue()
}
@Test
fun `isVodEntry_filmGroupTitle_returnsTrue`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(group = "Film Classics"))).isTrue()
+ assertThat(M3uParser.isVodEntry(entry(group = "Film Classics"))).isTrue()
}
@Test
fun `isVodEntry_liveTs_returnsFalse`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(url = "http://live.example.com/cnn.ts", group = "News"))).isFalse()
+ assertThat(M3uParser.isVodEntry(entry(url = "http://live.example.com/cnn.ts", group = "News"))).isFalse()
}
@Test
fun `isVodEntry_liveM3u8_returnsFalse`() {
- val mgr = buildManager()
- assertThat(mgr.isVodEntry(entry(url = "http://live.example.com/sports.m3u8", group = "Sports"))).isFalse()
+ assertThat(M3uParser.isVodEntry(entry(url = "http://live.example.com/sports.m3u8", group = "Sports"))).isFalse()
}
// ── SyncState sealed class properties ───────────────────────────
diff --git a/data/src/test/java/com/streamvault/data/util/UrlSecurityPolicyTest.kt b/data/src/test/java/com/streamvault/data/util/UrlSecurityPolicyTest.kt
index 3261acfc..afc15cdc 100644
--- a/data/src/test/java/com/streamvault/data/util/UrlSecurityPolicyTest.kt
+++ b/data/src/test/java/com/streamvault/data/util/UrlSecurityPolicyTest.kt
@@ -37,6 +37,22 @@ class UrlSecurityPolicyTest {
assertThat(UrlSecurityPolicy.isAllowedStreamEntryUrl("https://example.com/live.ts")).isTrue()
}
+ @Test
+ fun `stream entry urls reject double-encoded newline injection`() {
+ // %250A -> %0A -> \n requires two-pass decode to catch
+ assertThat(UrlSecurityPolicy.isAllowedStreamEntryUrl("https://example.com/live.ts%250AInjected: true")).isFalse()
+ // %250D -> %0D -> \r
+ assertThat(UrlSecurityPolicy.isAllowedStreamEntryUrl("https://example.com/live.ts%250DInjected: true")).isFalse()
+ // Mixed-case double-encoded
+ assertThat(UrlSecurityPolicy.isAllowedStreamEntryUrl("https://example.com/live.ts%250aInjected: true")).isFalse()
+ }
+
+ @Test
+ fun `stream entry urls reject tab injection`() {
+ // %09 (tab) can split structured log entries
+ assertThat(UrlSecurityPolicy.isAllowedStreamEntryUrl("https://example.com/live.ts%09Injected: true")).isFalse()
+ }
+
@Test
fun `sanitizeImportedAssetUrl drops unsupported schemes`() {
assertThat(UrlSecurityPolicy.sanitizeImportedAssetUrl("ftp://example.com/logo.png")).isNull()
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 3244a157..bc547ee6 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -2,23 +2,80 @@
All notable product changes are recorded in this document.
-## 1.0.4 - 09/04/2026
+## 1.0.4 - 11/04/2026
### Changed
- Updated VOD playback preparation to carry richer resolved stream metadata into the shared player path, improving compatibility with provider-resolved movie and episode streams.
- Updated TV Guide category selection so Favorites and custom live groups appear in the guide category list, Favorites becomes the entry default when it has channels, and Settings now lets you choose the guide's default startup category.
- Updated Settings navigation by splitting the crowded Playback tab into separate Playback and Browsing sections, moving guide, Live TV, VOD layout, and category browsing preferences into their own dedicated area.
- Updated Settings provider sync so the default action now runs a lighter quick sync, provider switching only auto-refreshes stale providers, and the sync overlay shows the current provider and live progress text.
+- Updated Xtream text handling with an optional Base64 compatibility toggle in Settings so provider names and categories stay raw by default, while broad Base64 decoding can be enabled for edge-case feeds.
+- Updated Xtream text compatibility toggles so changing them invalidates cached Xtream text imports and forces the next refresh for each Xtream provider once.
+- Updated the About screen with official build verification based on the app id and release signing certificate fingerprint.
+- Massive code refactoring to reduce large files size.
### Fixed
+- Fixed EPG override candidate list stability by adding a stable Compose item key, avoiding unnecessary item churn when override search results update.
+- Fixed multi-source XMLTV refresh to close the decompressed input wrapper explicitly after parsing, matching the provider-native EPG refresh path and avoiding leaked gzip/parser stream wrappers on source refreshes.
+- Fixed DRM metadata validation so invalid or unsafe DRM license URLs are rejected by the shared stream-entry URL policy before they can reach player Media3 DRM configuration.
+- Fixed Xtream Home and guide fallback EPG lookups to batch missing-channel requests through a shared repository path, so provider loading, credential decryption, and Xtream client setup are reused once per fallback burst instead of repeating per channel.
+- Fixed Combined M3U profile creation to batch-load selected providers through `ProviderDao.getByIds(...)` instead of issuing one provider lookup per selected source.
+- Fixed TV launcher recommendation syncing so preview-channel refresh now runs on `Dispatchers.IO`, serializes overlapping refresh calls, and rate-limits repeated syncs to reduce startup and playback-exit `TvContract` churn.
+- Fixed backup export/checksum generation to stream JSON through a writer pipeline instead of materializing large intermediate backup strings before writing or hashing.
+- Fixed EPG guide recomposition scope by moving the shared guide clock out of the top-level guide screen and into smaller hero, grid, and dialog subtrees so routine 30-second time updates no longer invalidate the full guide shell.
+- Fixed `FileProvider` update-install exposure by restricting shared paths to the APK download directory only and removing the broad cache-root grant surface.
+- Fixed in-app updates to require HTTPS release and APK download URLs while leaving HTTP IPTV playback compatibility unchanged.
+- Fixed recurring recording rollover so future daily/weekly occurrences detect conflicts with existing manual or active recordings, mark skipped slots as `SCHEDULE_CONFLICT`, and continue searching for the next free slot.
+- Fixed Cast startup for unsupported `rtsp://` and `rtmp://` streams by rejecting them early and showing a clear in-app notice instead of failing silently on the receiver.
+- Fixed Xtream playback expiry handling so auth-like `401/403` stream failures now trigger a one-time URL refresh and replay attempt before surfacing a playback error.
+- Fixed player teardown to clear cached seek-preview thumbnails when the player screen is destroyed, reducing stale bitmap retention across playback sessions.
+- Fixed recurring DVR rollover to calculate the next daily or weekly occurrence in local time, preventing schedules from drifting by an hour across Daylight Saving Time changes.
+- Fixed offline library launches so Home now shows an “Add your first provider” empty state, while Movies and Series show a clear “Sync needed” state instead of waiting on indefinite loading spinners.
+- Fixed parental PIN changes to immediately clear all in-memory unlocked categories so previously unlocked content requires the new PIN right away.
- Fixed top navigation focus so switching between top-bar destinations no longer snaps focus back to the Home tab.
- Fixed in-app update downloads that could remain stuck on `Downloading...` by improving download tracking and completion handling.
+- Fixed M3U importer to throw descriptive non-transient HTTP errors so CombinedM3U profiles properly skip dead sources gracefully instead of failing silently.
+- Fixed player to immediately identify expired stream URLs and natively return a user-friendly expiration notice instead of triggering empty generic playback failure.
+- Fixed `M3uParser` to use idiomatic Kotlin `.lineSequence()` iteration while preserving its strict one-line-in-memory footprint during massive playlist operations.
- Fixed M3U catch-up detection and replay URL expansion so archive-capable playlists using `catchup-source`, `timeshift`, and common replay placeholders are wired correctly.
- Fixed catch-up and replay handling across M3U and Xtream providers with added regression coverage for archive metadata parsing and replay URL building.
- Fixed player startup stability so normal playback no longer eagerly creates split-screen state that could crash channel and episode opens before playback begins.
- Fixed shared player initialization to defer several constructor-time playback state subscriptions, reducing intermittent crashes when opening Live TV and series episodes.
- Fixed Xtream playback startup handling so provider-auth failures such as `401` and `403` are surfaced as player errors/notices instead of continuing into a broken playback open path.
- Fixed provider setup so Xtream-backed playlist URLs such as `get.php?...type=m3u` and `get.php?...type=m3u_plus` are recognized automatically and imported through the Xtream parser instead of the plain M3U path.
+- Fixed TV provider setup Back behavior so pressing Back while editing a field now cancels that field edit first, and incomplete unnamed drafts prompt before leaving the screen.
+- Fixed TV long-press dialogs so the delayed DPAD/select key release that opens a dialog can no longer immediately trigger the first focused action by accident.
+- Fixed in-app update version parsing to read structured build metadata from GitHub release tags such as `v1.0.4+4` instead of scraping version codes from release-note prose.
+- Fixed background EPG scheduling so fast-completing refresh jobs are tracked and cleaned up reliably instead of leaving stale job entries behind.
+- Fixed provider deletion cleanup so sync teardown now waits on the per-provider lock before dropping sync state and mutex tracking.
+- Fixed player stats collection races by making dropped-frame, format, and bandwidth tracking safe across ExoPlayer callbacks and the polling coroutine.
+- Fixed live-stream retry recovery so behind-live-window errors now wait briefly and jump back to the live edge before retrying.
+- Fixed the in-app update checker to cap GitHub release API response size before JSON parsing, avoiding unbounded memory reads.
+- Fixed preloaded stream reuse to compare exact normalized URLs and marked the preload coordinator as main-thread-only to avoid unsafe cross-thread access assumptions.
+- Fixed FTS search query building so blank or fully stripped search text no longer reaches Room as an empty `MATCH` query and crash search flows.
+- Fixed Xtream text decoding by treating channel, movie, series, episode, and category names as raw provider text by default while limiting automatic base64 decode to EPG and common metadata fields.
+- Fixed database maintenance so daily VACUUM is skipped when active read transactions are open (WAL busy-page check) or a provider sync is in progress, preventing the exclusive DB lock from blocking channel loads, EPG queries, and sync writes during background maintenance.
+- Fixed database maintenance logging to measure and record the actual duration of the sqlite `VACUUM` compaction.
+- Fixed parental control unlock state management to use lock-free `StateFlow.update {}` instead of JVM `synchronized` blocks, eliminating the risk of thread blocking and potential ANR on the main thread when unlock, retain, or clear operations are called from coroutines.
+- Fixed a dead `LINE_BREAK_REGEX` alias in `ProviderInputSanitizer` that was identical to `WHITESPACE_REGEX`; the duplicate constant was removed and the single call site updated to use the canonical name.
+- Fixed a URL injection bypass in `UrlSecurityPolicy` where double-encoded newlines (`%250A`) and tabs (`%09`) could evade the single-pass `containsNewlines()` check; the decoder now runs two passes and also strips tab characters.
+- Fixed `AppUpdateInstaller` to expose an `unregister()` method that safely unregisters the `DownloadManager` broadcast receiver, preventing duplicate receiver registrations when the DI graph is re-created in instrumentation tests.
+- Fixed `AppUpdateInstaller` to verify downloaded APKs against expected SHA-256 hashes (if provided by the release) before launching the system package installer, preventing execution of tampered or truncated updates.
+- Fixed `SyncManager.onProviderDeleted()` to log a warning when a background EPG job is still active at the time of cancellation, making mid-sync provider deletions visible in production logs.
+- Fixed `SeekThumbnailProvider.loadFrame()` to wrap `MediaMetadataRetriever` usage in an 8-second `withTimeoutOrNull` guard, preventing indefinite thread blocking on live IPTV streams served as raw MPEG-TS over HTTP that pass the `.m3u8`/`.mpd` exclusion check.
+- Fixed `PlayerStatsCollector` to run its polling loop on `Dispatchers.Main.immediate` instead of `Dispatchers.Default`, eliminating 2–3 needless thread context switches every 250 ms per active player (up to 12 per second in 4-player multiview). Removed the now-redundant `readPlayerSnapshot` suspend function and its `withContext` wrapper; removed `@Volatile` annotations and `AtomicInteger` usage since ExoPlayer analytics callbacks are delivered on the Main thread.
+- Fixed `CredentialCrypto` so it is now an interface with a concrete Hilt-provided implementation rather than a hardcoded `object` singleton, enabling standard mock injection during viewmodel and repository tests.
+- Fixed `PreloadCoordinator` state invalidation so stream headers and DRM keys are digested using content-stable deterministic SHA-256 hashes instead of JVM memory-address dependent `hashCode()` that breaks across app restarts.
+- Fixed `StreamVaultDatabaseMigrationTest` so the full-chain migration verification now sequentially applies and validates the entire schema history spanning from v1 up through the current v30 database version.
+- Fixed DVR scheduling from stale guide selections so recording setup now rejects programmes that have already ended and prompts the user to refresh the guide instead of building an invalid request.
+- Fixed Xtream playlist auto-import validation so oversized decoded `username` and `password` query parameters are rejected before the playlist URL is converted into an Xtream login request.
+- Fixed audio-only playback retry handling so radio and other no-video streams are treated as started once the player is actually ready and playing, instead of waiting forever for a first video frame callback.
+- Fixed main player-engine release lifecycle so teardown no longer cancels and rebuilds its shared coroutine scope between playback sessions.
+- Fixed Xtream provider setup error handling so the UI now maps login failures from typed exception causes instead of brittle substring checks against arbitrary error text.
+- Fixed provider EPG cache replacement and playback-history denormalization writes to run inside Room transactions, preventing partial multi-step database updates.
+- Fixed domain continue-watching, recommendation, and search flows to stop masking non-IO upstream failures as empty-state content, so critical data/query faults surface instead of silently disappearing.
+- Fixed Movies and Series category browsing to memoize visible-category membership and filtered category rows, reducing repeated list scanning during large-library recompositions.
+- Fixed TV Guide hero and channel-row current-program lookups to use derived state, reducing redundant per-channel program rescans on the shared 30-second guide clock.
## 1.0.3 - 09/04/2026
diff --git a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
index 565965ed..ab42f792 100644
--- a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
+++ b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt
@@ -4,6 +4,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
import javax.inject.Inject
import javax.inject.Singleton
@@ -11,7 +12,6 @@ import javax.inject.Singleton
class ParentalControlManager @Inject constructor(
private val sessionStore: ParentalControlSessionStore
) {
- private val stateLock = Any()
private val _unlockedCategoriesByProvider = MutableStateFlow<Map<Long, Set<Long>>>(emptyMap())
val unlockedCategoriesByProvider: StateFlow<Map<Long, Set<Long>>> =
_unlockedCategoriesByProvider.asStateFlow()
@@ -26,52 +26,37 @@ class ParentalControlManager @Inject constructor(
unlockedCategoriesByProvider.map { it[providerId] ?: emptySet() }
fun unlockCategory(providerId: Long, categoryId: Long) {
- synchronized(stateLock) {
- publishState(
- _unlockedCategoriesByProvider.value + (providerId to setOf(categoryId))
- )
+ _unlockedCategoriesByProvider.update { current ->
+ (current + (providerId to setOf(categoryId)))
+ .filterValues { it.isNotEmpty() }
}
+ sessionStore.writeSessionState(ParentalControlSessionState())
}
- fun isCategoryUnlocked(providerId: Long, categoryId: Long): Boolean {
- synchronized(stateLock) {
- return _unlockedCategoriesByProvider.value[providerId]?.contains(categoryId) == true
- }
- }
+ // StateFlow.value reads are thread-safe without an external lock.
+ fun isCategoryUnlocked(providerId: Long, categoryId: Long): Boolean =
+ _unlockedCategoriesByProvider.value[providerId]?.contains(categoryId) == true
fun retainUnlockedCategory(providerId: Long, categoryId: Long?) {
- synchronized(stateLock) {
+ _unlockedCategoriesByProvider.update { current ->
val retainedCategoryIds = categoryId
- ?.takeIf { unlockedCategoryIds ->
- _unlockedCategoriesByProvider.value[providerId]?.contains(unlockedCategoryIds) == true
- }
+ ?.takeIf { id -> current[providerId]?.contains(id) == true }
?.let(::setOf)
.orEmpty()
- val updatedUnlocks = if (retainedCategoryIds.isEmpty()) {
- _unlockedCategoriesByProvider.value - providerId
+ if (retainedCategoryIds.isEmpty()) {
+ current - providerId
} else {
- _unlockedCategoriesByProvider.value + (providerId to retainedCategoryIds)
+ (current + (providerId to retainedCategoryIds))
+ .filterValues { it.isNotEmpty() }
}
- publishState(updatedUnlocks)
}
+ sessionStore.writeSessionState(ParentalControlSessionState())
}
fun clearUnlockedCategories(providerId: Long? = null) {
- synchronized(stateLock) {
- val updatedUnlocks = if (providerId == null) {
- emptyMap()
- } else {
- _unlockedCategoriesByProvider.value - providerId
- }
- publishState(updatedUnlocks)
+ _unlockedCategoriesByProvider.update { current ->
+ if (providerId == null) emptyMap() else current - providerId
}
- }
-
- private fun publishState(
- state: Map<Long, Set<Long>>
- ) {
- _unlockedCategoriesByProvider.value = state
- .filterValues { it.isNotEmpty() }
sessionStore.writeSessionState(ParentalControlSessionState())
}
}
diff --git a/domain/src/main/java/com/streamvault/domain/model/StreamInfo.kt b/domain/src/main/java/com/streamvault/domain/model/StreamInfo.kt
index b677a44a..afc2ba13 100644
--- a/domain/src/main/java/com/streamvault/domain/model/StreamInfo.kt
+++ b/domain/src/main/java/com/streamvault/domain/model/StreamInfo.kt
@@ -1,5 +1,7 @@
package com.streamvault.domain.model
+import com.streamvault.domain.util.StreamEntryUrlPolicy
+
data class StreamInfo(
val url: String,
val title: String? = null,
@@ -27,6 +29,9 @@ data class DrmInfo(
) {
init {
require(licenseUrl.isNotBlank()) { "DrmInfo licenseUrl must not be blank" }
+ require(StreamEntryUrlPolicy.isAllowed(licenseUrl)) {
+ "DrmInfo licenseUrl must use an allowed stream-entry URL scheme"
+ }
}
}
diff --git a/domain/src/main/java/com/streamvault/domain/repository/ProviderRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/ProviderRepository.kt
index d2dc5caa..e887dea3 100644
--- a/domain/src/main/java/com/streamvault/domain/repository/ProviderRepository.kt
+++ b/domain/src/main/java/com/streamvault/domain/repository/ProviderRepository.kt
@@ -6,6 +6,11 @@ import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.Result
import kotlinx.coroutines.flow.Flow
+data class LiveStreamProgramRequest(
+ val streamId: Long,
+ val epgChannelId: String? = null
+)
+
interface ProviderRepository {
fun getProviders(): Flow<List<Provider>>
fun getActiveProvider(): Flow<Provider?>
@@ -29,6 +34,19 @@ interface ProviderRepository {
epgChannelId: String? = null,
limit: Int = 12
): Result<List<Program>>
+ suspend fun getProgramsForLiveStreams(
+ providerId: Long,
+ requests: List<LiveStreamProgramRequest>,
+ limit: Int = 12
+ ): Map<LiveStreamProgramRequest, Result<List<Program>>> =
+ requests.distinct().associateWith { request ->
+ getProgramsForLiveStream(
+ providerId = providerId,
+ streamId = request.streamId,
+ epgChannelId = request.epgChannelId,
+ limit = limit
+ )
+ }
suspend fun buildCatchUpUrl(providerId: Long, streamId: Long, start: Long, end: Long): String?
suspend fun buildCatchUpUrls(providerId: Long, streamId: Long, start: Long, end: Long): List<String> =
listOfNotNull(buildCatchUpUrl(providerId, streamId, start, end))
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/GetContinueWatching.kt b/domain/src/main/java/com/streamvault/domain/usecase/GetContinueWatching.kt
index f1c38924..d9d29f4f 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/GetContinueWatching.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/GetContinueWatching.kt
@@ -4,6 +4,7 @@ import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.PlaybackHistory
import com.streamvault.domain.repository.PlaybackHistoryRepository
import com.streamvault.domain.util.isPlaybackComplete
+import com.streamvault.domain.util.shouldRethrowDomainFlowFailure
import javax.inject.Inject
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
@@ -40,6 +41,9 @@ class GetContinueWatching @Inject constructor(
.toList()
}
.catch { error ->
+ if (error.shouldRethrowDomainFlowFailure()) {
+ throw error
+ }
logger.log(Level.WARNING, "Failed to build continue watching list", error)
emit(emptyList())
}
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/GetRecommendations.kt b/domain/src/main/java/com/streamvault/domain/usecase/GetRecommendations.kt
index 43a50c6a..86b7c438 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/GetRecommendations.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/GetRecommendations.kt
@@ -2,6 +2,7 @@ package com.streamvault.domain.usecase
import com.streamvault.domain.model.Movie
import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.util.shouldRethrowDomainFlowFailure
import java.util.logging.Level
import java.util.logging.Logger
import javax.inject.Inject
@@ -27,6 +28,9 @@ class GetRecommendations @Inject constructor(
}
}
.catch { error ->
+ if (error.shouldRethrowDomainFlowFailure()) {
+ throw error
+ }
logger.log(Level.WARNING, "Failed to load recommendations", error)
emit(emptyList())
}
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/ScheduleRecording.kt b/domain/src/main/java/com/streamvault/domain/usecase/ScheduleRecording.kt
index e80efb5d..0d742506 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/ScheduleRecording.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/ScheduleRecording.kt
@@ -38,13 +38,18 @@ class ScheduleRecording @Inject constructor(
return Result.error("Recording needs guide timing for the current live channel.")
}
+ val scheduledStartMs = maxOf(command.nowMs, targetProgram.startTime)
+ if (scheduledStartMs >= targetProgram.endTime) {
+ return Result.error("The selected program has already ended. Refresh the guide and try again.")
+ }
+
return recordingManager.scheduleRecording(
RecordingRequest(
providerId = command.providerId,
channelId = channel.id,
channelName = channel.name,
streamUrl = command.streamUrl,
- scheduledStartMs = maxOf(command.nowMs, targetProgram.startTime),
+ scheduledStartMs = scheduledStartMs,
scheduledEndMs = targetProgram.endTime,
programTitle = targetProgram.title,
recurrence = command.recurrence
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.kt b/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.kt
index 900e6cb4..b18d69bb 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.kt
@@ -6,6 +6,7 @@ import com.streamvault.domain.model.Series
import com.streamvault.domain.repository.ChannelRepository
import com.streamvault.domain.repository.MovieRepository
import com.streamvault.domain.repository.SeriesRepository
+import com.streamvault.domain.util.shouldRethrowDomainFlowFailure
import java.util.logging.Level
import java.util.logging.Logger
import javax.inject.Inject
@@ -68,6 +69,9 @@ class SearchContent @Inject constructor(
series = series.take(maxResultsPerSection)
)
}.catch { error ->
+ if (error.shouldRethrowDomainFlowFailure()) {
+ throw error
+ }
logger.log(Level.WARNING, "Failed to build search results", error)
emit(SearchContentResult())
}
diff --git a/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt b/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
index a8ac692d..4e4be3b7 100644
--- a/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
+++ b/domain/src/main/java/com/streamvault/domain/usecase/ValidateAndAddProvider.kt
@@ -38,6 +38,11 @@ class ValidateAndAddProvider @Inject constructor(
private val providerSetupInputValidator: ProviderSetupInputValidator,
private val providerRepository: ProviderRepository
) {
+ companion object {
+ private const val MAX_XTREAM_PLAYLIST_USERNAME_LENGTH = 128
+ private const val MAX_XTREAM_PLAYLIST_PASSWORD_LENGTH = 256
+ }
+
suspend fun loginXtream(
command: XtreamProviderSetupCommand,
onProgress: ((String) -> Unit)? = null
@@ -77,27 +82,33 @@ class ValidateAndAddProvider @Inject constructor(
) {
is Result.Success -> {
val validatedInput = validated.data
- val parsedXtream = parseXtreamPlaylistUrl(validatedInput.url)
- if (parsedXtream != null) {
- providerRepository.loginXtream(
- serverUrl = parsedXtream.serverUrl,
- username = parsedXtream.username,
- password = parsedXtream.password,
- name = validatedInput.name,
- xtreamFastSyncEnabled = true,
- epgSyncMode = command.epgSyncMode,
- onProgress = onProgress,
- id = command.existingProviderId
- ).toUseCaseResult()
- } else {
- providerRepository.validateM3u(
- url = validatedInput.url,
- name = validatedInput.name,
- epgSyncMode = command.epgSyncMode,
- m3uVodClassificationEnabled = command.m3uVodClassificationEnabled,
- onProgress = onProgress,
- id = command.existingProviderId
- ).toUseCaseResult()
+ when (val parsedXtream = parseXtreamPlaylistUrl(validatedInput.url)) {
+ is ParsedXtreamPlaylistUrlResult.ValidationError ->
+ ValidateAndAddProviderResult.ValidationError(parsedXtream.message)
+
+ is ParsedXtreamPlaylistUrlResult.Success -> {
+ providerRepository.loginXtream(
+ serverUrl = parsedXtream.serverUrl,
+ username = parsedXtream.username,
+ password = parsedXtream.password,
+ name = validatedInput.name,
+ xtreamFastSyncEnabled = true,
+ epgSyncMode = command.epgSyncMode,
+ onProgress = onProgress,
+ id = command.existingProviderId
+ ).toUseCaseResult()
+ }
+
+ ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist -> {
+ providerRepository.validateM3u(
+ url = validatedInput.url,
+ name = validatedInput.name,
+ epgSyncMode = command.epgSyncMode,
+ m3uVodClassificationEnabled = command.m3uVodClassificationEnabled,
+ onProgress = onProgress,
+ id = command.existingProviderId
+ ).toUseCaseResult()
+ }
}
}
@@ -112,28 +123,43 @@ class ValidateAndAddProvider @Inject constructor(
is Result.Loading -> ValidateAndAddProviderResult.Error("Unexpected loading state")
}
- private data class ParsedXtreamPlaylistUrl(
- val serverUrl: String,
- val username: String,
- val password: String
- )
+ private sealed interface ParsedXtreamPlaylistUrlResult {
+ data object NotXtreamPlaylist : ParsedXtreamPlaylistUrlResult
+ data class ValidationError(val message: String) : ParsedXtreamPlaylistUrlResult
+ data class Success(
+ val serverUrl: String,
+ val username: String,
+ val password: String
+ ) : ParsedXtreamPlaylistUrlResult
+ }
- private fun parseXtreamPlaylistUrl(url: String): ParsedXtreamPlaylistUrl? {
- val uri = runCatching { URI(url) }.getOrNull() ?: return null
- val scheme = uri.scheme?.lowercase() ?: return null
- if (scheme != "http" && scheme != "https") return null
+ private fun parseXtreamPlaylistUrl(url: String): ParsedXtreamPlaylistUrlResult {
+ val uri = runCatching { URI(url) }.getOrNull() ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ val scheme = uri.scheme?.lowercase() ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ if (scheme != "http" && scheme != "https") return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
val normalizedPath = uri.path.orEmpty().lowercase()
- if (!normalizedPath.endsWith("/get.php")) return null
+ if (!normalizedPath.endsWith("/get.php")) return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
val query = parseQueryParameters(uri.rawQuery)
- val username = query["username"]?.takeIf { it.isNotBlank() } ?: return null
- val password = query["password"]?.takeIf { it.isNotBlank() } ?: return null
- val type = query["type"]?.lowercase()?.takeIf { it.isNotBlank() } ?: return null
- if (type != "m3u" && type != "m3u_plus") return null
+ val username = query["username"]?.takeIf { it.isNotBlank() }
+ ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ val password = query["password"]?.takeIf { it.isNotBlank() }
+ ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ val type = query["type"]?.lowercase()?.takeIf { it.isNotBlank() }
+ ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ if (type != "m3u" && type != "m3u_plus") return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+
+ if (username.length > MAX_XTREAM_PLAYLIST_USERNAME_LENGTH) {
+ return ParsedXtreamPlaylistUrlResult.ValidationError("Playlist username is too long.")
+ }
+ if (password.length > MAX_XTREAM_PLAYLIST_PASSWORD_LENGTH) {
+ return ParsedXtreamPlaylistUrlResult.ValidationError("Playlist password is too long.")
+ }
- val authority = uri.rawAuthority?.takeIf { it.isNotBlank() } ?: return null
- return ParsedXtreamPlaylistUrl(
+ val authority = uri.rawAuthority?.takeIf { it.isNotBlank() }
+ ?: return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylist
+ return ParsedXtreamPlaylistUrlResult.Success(
serverUrl = "$scheme://$authority",
username = username,
password = password
diff --git a/domain/src/main/java/com/streamvault/domain/util/FlowErrorHandling.kt b/domain/src/main/java/com/streamvault/domain/util/FlowErrorHandling.kt
new file mode 100644
index 00000000..42bdbd1a
--- /dev/null
+++ b/domain/src/main/java/com/streamvault/domain/util/FlowErrorHandling.kt
@@ -0,0 +1,13 @@
+package com.streamvault.domain.util
+
+import java.io.IOException
+import kotlinx.coroutines.CancellationException
+
+fun Throwable.shouldRethrowDomainFlowFailure(): Boolean = when (this) {
+ is CancellationException,
+ is VirtualMachineError,
+ is ThreadDeath,
+ is LinkageError -> true
+ is IOException -> false
+ else -> true
+}
\ No newline at end of file
diff --git a/domain/src/main/java/com/streamvault/domain/util/StreamEntryUrlPolicy.kt b/domain/src/main/java/com/streamvault/domain/util/StreamEntryUrlPolicy.kt
new file mode 100644
index 00000000..0a3e5f48
--- /dev/null
+++ b/domain/src/main/java/com/streamvault/domain/util/StreamEntryUrlPolicy.kt
@@ -0,0 +1,29 @@
+package com.streamvault.domain.util
+
+import java.net.URI
+import java.util.Locale
+
+object StreamEntryUrlPolicy {
+ private val allowedSchemes = setOf("http", "https", "rtsp", "rtsps", "rtmp", "file", "content")
+
+ fun isAllowed(url: String): Boolean = !containsControlSeparators(url) && hasAllowedScheme(url)
+
+ private fun hasAllowedScheme(url: String): Boolean {
+ val scheme = runCatching { URI(url.trim()).scheme }
+ .getOrNull()
+ ?.lowercase(Locale.ROOT)
+ ?: return false
+ return scheme in allowedSchemes
+ }
+
+ private fun containsControlSeparators(url: String): Boolean {
+ var decoded = url
+ repeat(2) {
+ decoded = decoded
+ .replace("%0A", "\n", ignoreCase = true)
+ .replace("%0D", "\r", ignoreCase = true)
+ .replace("%09", "\t", ignoreCase = true)
+ }
+ return decoded.any { it == '\n' || it == '\r' || it == '\t' }
+ }
+}
\ No newline at end of file
diff --git a/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.kt b/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.kt
index 69c1eef2..d5155a47 100644
--- a/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.kt
@@ -38,4 +38,20 @@ class StreamInfoTest {
assertThat(streamInfo.drmInfo?.forceDefaultLicenseUrl).isTrue()
assertThat(streamInfo.drmInfo?.playClearContentWithoutKey).isTrue()
}
+
+ @Test
+ fun drmInfo_rejects_disallowed_license_url() {
+ val error = try {
+ DrmInfo(
+ scheme = DrmScheme.WIDEVINE,
+ licenseUrl = "javascript:alert(1)"
+ )
+ null
+ } catch (e: IllegalArgumentException) {
+ e
+ }
+
+ assertThat(error).isNotNull()
+ assertThat(error!!.message).contains("allowed stream-entry URL scheme")
+ }
}
\ No newline at end of file
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.kt
index 605f3209..ab3fca23 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.kt
@@ -6,6 +6,7 @@ import com.streamvault.domain.model.PlaybackHistory
import com.streamvault.domain.repository.PlaybackHistoryRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
@@ -65,6 +66,26 @@ class GetContinueWatchingTest {
assertThat(result.map { it.contentId }).containsExactly(2L, 4L).inOrder()
}
+ @Test
+ fun rethrows_non_io_upstream_failures() = runTest {
+ val expected = IllegalStateException("database broken")
+ val useCase = GetContinueWatching(
+ playbackHistoryRepository = FakePlaybackHistoryRepository(
+ historyFlow = flow { throw expected }
+ )
+ )
+
+ val thrown = try {
+ useCase(providerId = 1L).first()
+ null
+ } catch (error: IllegalStateException) {
+ error
+ }
+
+ assertThat(thrown).isNotNull()
+ assertThat(thrown?.message).isEqualTo(expected.message)
+ }
+
private suspend fun Flow<List<PlaybackHistory>>.collectOnce(): List<PlaybackHistory> = first()
private fun history(
@@ -86,10 +107,11 @@ class GetContinueWatchingTest {
)
private class FakePlaybackHistoryRepository(
- private val history: List<PlaybackHistory>
+ private val history: List<PlaybackHistory> = emptyList(),
+ private val historyFlow: Flow<List<PlaybackHistory>>? = null
) : PlaybackHistoryRepository {
- override fun getRecentlyWatched(limit: Int): Flow<List<PlaybackHistory>> = flowOf(history.take(limit))
- override fun getRecentlyWatchedByProvider(providerId: Long, limit: Int): Flow<List<PlaybackHistory>> = flowOf(history.take(limit))
+ override fun getRecentlyWatched(limit: Int): Flow<List<PlaybackHistory>> = historyFlow ?: flowOf(history.take(limit))
+ override fun getRecentlyWatchedByProvider(providerId: Long, limit: Int): Flow<List<PlaybackHistory>> = historyFlow ?: flowOf(history.take(limit))
override fun getUnwatchedCount(providerId: Long, seriesId: Long): Flow<Int> = flowOf(0)
override suspend fun getPlaybackHistory(contentId: Long, contentType: ContentType, providerId: Long): PlaybackHistory? = null
override suspend fun markAsWatched(history: PlaybackHistory) = com.streamvault.domain.model.Result.success(Unit)
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/GetRecommendationsTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/GetRecommendationsTest.kt
index b4f50f07..6050ce9e 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/GetRecommendationsTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/GetRecommendationsTest.kt
@@ -10,6 +10,7 @@ import com.streamvault.domain.model.StreamInfo
import com.streamvault.domain.repository.MovieRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
@@ -50,12 +51,36 @@ class GetRecommendationsTest {
assertThat(result.map(Movie::id)).containsExactly(10L, 11L).inOrder()
}
+ @Test
+ fun rethrows_non_io_upstream_failures() = runTest {
+ val expected = IllegalStateException("recommendations query failed")
+ val useCase = GetRecommendations(
+ movieRepository = FakeMovieRepository(
+ recommendations = emptyList(),
+ topRated = emptyList(),
+ recommendationsFlow = flow { throw expected }
+ )
+ )
+
+ val thrown = try {
+ useCase(providerId = 7L, limit = 2).first()
+ null
+ } catch (error: IllegalStateException) {
+ error
+ }
+
+ assertThat(thrown).isNotNull()
+ assertThat(thrown?.message).isEqualTo(expected.message)
+ }
+
private class FakeMovieRepository(
private val recommendations: List<Movie>,
- private val topRated: List<Movie>
+ private val topRated: List<Movie>,
+ private val recommendationsFlow: Flow<List<Movie>>? = null,
+ private val topRatedFlow: Flow<List<Movie>>? = null
) : MovieRepository {
- override fun getRecommendations(providerId: Long, limit: Int): Flow<List<Movie>> = flowOf(recommendations.take(limit))
- override fun getTopRatedPreview(providerId: Long, limit: Int): Flow<List<Movie>> = flowOf(topRated.take(limit))
+ override fun getRecommendations(providerId: Long, limit: Int): Flow<List<Movie>> = recommendationsFlow ?: flowOf(recommendations.take(limit))
+ override fun getTopRatedPreview(providerId: Long, limit: Int): Flow<List<Movie>> = topRatedFlow ?: flowOf(topRated.take(limit))
override fun getMovies(providerId: Long): Flow<List<Movie>> = unsupported()
override fun getMoviesByCategory(providerId: Long, categoryId: Long): Flow<List<Movie>> = unsupported()
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/ScheduleRecordingTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/ScheduleRecordingTest.kt
index 8c9350c5..90f1e130 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/ScheduleRecordingTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/ScheduleRecordingTest.kt
@@ -85,6 +85,29 @@ class ScheduleRecordingTest {
assertThat(manager.lastScheduledRequest?.scheduledEndMs).isEqualTo(4_000L)
}
+ @Test
+ fun returns_error_when_program_has_already_ended() = runTest {
+ val manager = FakeRecordingManager()
+ val useCase = ScheduleRecording(manager)
+
+ val result = useCase(
+ ScheduleRecordingCommand(
+ contentType = ContentType.LIVE,
+ providerId = 7L,
+ channel = channel(),
+ streamUrl = "https://example.com/live.ts",
+ currentProgram = program(title = "Ended", startTime = 1_000L, endTime = 2_000L),
+ nextProgram = null,
+ recurrence = RecordingRecurrence.NONE,
+ nowMs = 2_000L
+ )
+ )
+
+ assertThat((result as Result.Error).message)
+ .isEqualTo("The selected program has already ended. Refresh the guide and try again.")
+ assertThat(manager.lastScheduledRequest).isNull()
+ }
+
private fun channel() = Channel(
id = 11L,
name = "Channel 11",
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/SearchContentTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/SearchContentTest.kt
index d92c5d63..7f0f58d0 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/SearchContentTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/SearchContentTest.kt
@@ -14,6 +14,7 @@ import com.streamvault.domain.repository.MovieRepository
import com.streamvault.domain.repository.SeriesRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
@@ -86,12 +87,36 @@ class SearchContentTest {
assertThat(result.movies).isEmpty()
assertThat(result.series).isEmpty()
}
+
+ @Test
+ fun rethrows_non_io_upstream_failures() = runTest {
+ val expected = IllegalStateException("channel search failed")
+ val useCase = SearchContent(
+ channelRepository = FakeChannelRepository(
+ searchResults = emptyList(),
+ searchFlow = flow { throw expected }
+ ),
+ movieRepository = FakeMovieRepository(searchResults = emptyList()),
+ seriesRepository = FakeSeriesRepository(searchResults = emptyList())
+ )
+
+ val thrown = try {
+ useCase(providerId = 99L, query = "star").first()
+ null
+ } catch (error: IllegalStateException) {
+ error
+ }
+
+ assertThat(thrown).isNotNull()
+ assertThat(thrown?.message).isEqualTo(expected.message)
+ }
}
private class FakeChannelRepository(
- private val searchResults: List<Channel>
+ private val searchResults: List<Channel>,
+ private val searchFlow: Flow<List<Channel>>? = null
) : ChannelRepository {
- override fun searchChannels(providerId: Long, query: String): Flow<List<Channel>> = flowOf(searchResults)
+ override fun searchChannels(providerId: Long, query: String): Flow<List<Channel>> = searchFlow ?: flowOf(searchResults)
override fun getChannels(providerId: Long): Flow<List<Channel>> = unsupported()
override fun getChannelsByCategory(providerId: Long, categoryId: Long): Flow<List<Channel>> = unsupported()
override fun getChannelsByNumber(providerId: Long, categoryId: Long): Flow<List<Channel>> = unsupported()
@@ -107,9 +132,10 @@ private class FakeChannelRepository(
}
private class FakeMovieRepository(
- private val searchResults: List<Movie>
+ private val searchResults: List<Movie>,
+ private val searchFlow: Flow<List<Movie>>? = null
) : MovieRepository {
- override fun searchMovies(providerId: Long, query: String): Flow<List<Movie>> = flowOf(searchResults)
+ override fun searchMovies(providerId: Long, query: String): Flow<List<Movie>> = searchFlow ?: flowOf(searchResults)
override fun getMovies(providerId: Long): Flow<List<Movie>> = unsupported()
override fun getMoviesByCategory(providerId: Long, categoryId: Long): Flow<List<Movie>> = unsupported()
override fun getMoviesByCategoryPage(providerId: Long, categoryId: Long, limit: Int, offset: Int): Flow<List<Movie>> = unsupported()
@@ -132,9 +158,10 @@ private class FakeMovieRepository(
}
private class FakeSeriesRepository(
- private val searchResults: List<Series>
+ private val searchResults: List<Series>,
+ private val searchFlow: Flow<List<Series>>? = null
) : SeriesRepository {
- override fun searchSeries(providerId: Long, query: String): Flow<List<Series>> = flowOf(searchResults)
+ override fun searchSeries(providerId: Long, query: String): Flow<List<Series>> = searchFlow ?: flowOf(searchResults)
override fun getSeries(providerId: Long): Flow<List<Series>> = unsupported()
override fun getSeriesByCategory(providerId: Long, categoryId: Long): Flow<List<Series>> = unsupported()
override fun getSeriesByCategoryPage(providerId: Long, categoryId: Long, limit: Int, offset: Int): Flow<List<Series>> = unsupported()
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/SyncProviderTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/SyncProviderTest.kt
index 28b4db50..9a69353c 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/SyncProviderTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/SyncProviderTest.kt
@@ -126,6 +126,7 @@ private class FakeSyncProviderRepository(
providerId: Long,
force: Boolean,
movieFastSyncOverride: Boolean?,
+ epgSyncModeOverride: ProviderEpgSyncMode?,
onProgress: ((String) -> Unit)?
): Result<Unit> {
lastRefreshCall = RefreshCall(providerId, force)
diff --git a/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
index 4be183f9..a0880d9b 100644
--- a/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
+++ b/domain/src/test/java/com/streamvault/domain/usecase/ValidateAndAddProviderTest.kt
@@ -158,6 +158,37 @@ class ValidateAndAddProviderTest {
)
)
}
+
+ @Test
+ fun rejects_xtream_playlist_with_oversized_decoded_password() = runTest {
+ val repository = FakeProviderRepository()
+ val oversizedPassword = "p".repeat(257)
+ val encodedPassword = java.net.URLEncoder.encode(oversizedPassword, java.nio.charset.StandardCharsets.UTF_8.name())
+ val useCase = ValidateAndAddProvider(
+ providerSetupInputValidator = FakeProviderSetupInputValidator(
+ m3uResult = Result.success(
+ ValidatedM3uProviderInput(
+ url = "https://example.com/get.php?username=user&password=$encodedPassword&type=m3u_plus",
+ name = "Imported Playlist"
+ )
+ )
+ ),
+ providerRepository = repository
+ )
+
+ val result = useCase.addM3u(
+ M3uProviderSetupCommand(
+ url = "https://example.com/get.php?username=user&password=$encodedPassword&type=m3u_plus",
+ name = "Imported Playlist"
+ )
+ )
+
+ assertThat(result).isInstanceOf(ValidateAndAddProviderResult.ValidationError::class.java)
+ assertThat((result as ValidateAndAddProviderResult.ValidationError).message)
+ .isEqualTo("Playlist password is too long.")
+ assertThat(repository.lastXtreamCall).isNull()
+ assertThat(repository.lastM3uCall).isNull()
+ }
}
private class FakeProviderSetupInputValidator(
@@ -253,6 +284,7 @@ private class FakeProviderRepository : ProviderRepository {
providerId: Long,
force: Boolean,
movieFastSyncOverride: Boolean?,
+ epgSyncModeOverride: ProviderEpgSyncMode?,
onProgress: ((String) -> Unit)?
): Result<Unit> = error("Not used in test")
diff --git a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
index a7b3b008..39709156 100644
--- a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
@@ -52,7 +52,6 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
@@ -95,8 +94,7 @@ class Media3PlayerEngine @Inject constructor(
}
}
- private var supervisorJob = SupervisorJob()
- private var scope = CoroutineScope(Dispatchers.Main.immediate + supervisorJob)
+ private val scope = CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
private var exoPlayer: ExoPlayer? = null
private var mediaSession: MediaSession? = null
private var requestedDecoderMode: DecoderMode = DecoderMode.AUTO
@@ -343,9 +341,6 @@ class Media3PlayerEngine @Inject constructor(
_mediaTitle.value = null
trackController.resetSelections()
statsCollector.reset()
- supervisorJob.cancel()
- supervisorJob = SupervisorJob()
- scope = CoroutineScope(Dispatchers.Main.immediate + supervisorJob)
}
private fun prepareInternal(
@@ -563,11 +558,7 @@ class Media3PlayerEngine @Inject constructor(
output: Any,
renderTimeMs: Long
) {
- playbackStarted = true
- Log.i(
- TAG,
- "first-frame-success streamType=$currentResolvedStreamType timeoutProfile=$currentTimeoutProfile target=${PlaybackLogSanitizer.sanitizeUrl(lastStreamInfo?.url)}"
- )
+ markPlaybackStarted("first-frame-success")
}
}
}
@@ -589,11 +580,17 @@ class Media3PlayerEngine @Inject constructor(
if (_playbackState.value == PlaybackState.READY) {
_retryStatus.value = null
}
+ if (_playbackState.value == PlaybackState.READY && _isPlaying.value) {
+ markPlaybackStarted("ready-while-playing")
+ }
}
override fun onIsPlayingChanged(isPlaying: Boolean) {
_isPlaying.value = isPlaying
if (isPlaying) {
+ if (_playbackState.value == PlaybackState.READY) {
+ markPlaybackStarted("playing-ready")
+ }
statsCollector.start()
audioFocusController.onPlaybackStarted()
} else {
@@ -623,6 +620,15 @@ class Media3PlayerEngine @Inject constructor(
}
}
+ private fun markPlaybackStarted(reason: String) {
+ if (playbackStarted) return
+ playbackStarted = true
+ Log.i(
+ TAG,
+ "$reason streamType=$currentResolvedStreamType timeoutProfile=$currentTimeoutProfile target=${PlaybackLogSanitizer.sanitizeUrl(lastStreamInfo?.url)}"
+ )
+ }
+
private fun handlePlaybackError(error: PlaybackException) {
retryJob?.cancel()
retryJob = null
@@ -676,6 +682,9 @@ class Media3PlayerEngine @Inject constructor(
return@launch
}
retryJob = null
+ if (category == PlaybackErrorCategory.LIVE_WINDOW) {
+ exoPlayer?.seekToDefaultPosition()
+ }
prepareInternal(streamInfo, preserveRetryState = true, seekPositionMs = null, autoPlay = true)
}
return
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 4bd4719b..8c441975 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
@@ -10,6 +10,8 @@ import java.net.ConnectException
import java.net.SocketTimeoutException
import java.net.UnknownHostException
+private const val LIVE_WINDOW_RETRY_DELAY_MS = 500L
+
data class PlaybackRetryContext(
val resolvedStreamType: ResolvedStreamType,
val timeoutProfile: PlayerTimeoutProfile
@@ -47,7 +49,9 @@ class PlayerRetryPolicy(
}
fun retryDelayMs(error: Throwable, attempt: Int): Long {
- if (PlayerErrorClassifier.classify(error) == PlaybackErrorCategory.LIVE_WINDOW) return 0L
+ if (PlayerErrorClassifier.classify(error) == PlaybackErrorCategory.LIVE_WINDOW) {
+ return LIVE_WINDOW_RETRY_DELAY_MS
+ }
return when (attempt) {
1 -> 1_000L
2 -> 2_500L
diff --git a/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt b/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt
index ab809667..534deaa1 100644
--- a/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt
@@ -1,15 +1,20 @@
package com.streamvault.player.playback
import android.util.Log
+import androidx.annotation.MainThread
import androidx.media3.exoplayer.source.MediaSource
import com.streamvault.domain.model.StreamInfo
+/**
+ * Main-thread-only cache for a single preloaded media source owned by Media3PlayerEngine.
+ */
+@MainThread
class PreloadCoordinator(
private val nowMs: () -> Long = { System.currentTimeMillis() }
) {
var currentPreloadedMediaId: String? = null
private set
- var currentPreloadedUrlHash: String? = null
+ var currentPreloadedNormalizedUrl: String? = null
private set
var preloadedMediaSource: MediaSource? = null
private set
@@ -18,11 +23,12 @@ class PreloadCoordinator(
private var currentResolvedType: ResolvedStreamType? = null
private var currentDrmKey: String? = null
- private var currentHeadersHash: Int? = null
+ private var currentHeadersHash: String? = null
+ @MainThread
fun store(mediaId: String, streamInfo: StreamInfo, resolvedType: ResolvedStreamType, mediaSource: MediaSource) {
currentPreloadedMediaId = mediaId
- currentPreloadedUrlHash = normalizedUrlHash(streamInfo.url)
+ currentPreloadedNormalizedUrl = normalizedUrl(streamInfo.url)
preloadedMediaSource = mediaSource
currentResolvedType = resolvedType
currentDrmKey = drmKey(streamInfo)
@@ -31,6 +37,7 @@ class PreloadCoordinator(
safeLog("preload stored mediaId=$mediaId type=$resolvedType target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}")
}
+ @MainThread
fun tryReuse(mediaId: String, streamInfo: StreamInfo, resolvedType: ResolvedStreamType): MediaSource? {
val result = when {
preloadedMediaSource == null -> null
@@ -42,7 +49,7 @@ class PreloadCoordinator(
invalidate("different-media-id")
null
}
- currentPreloadedUrlHash != normalizedUrlHash(streamInfo.url) -> {
+ currentPreloadedNormalizedUrl != normalizedUrl(streamInfo.url) -> {
invalidate("different-url")
null
}
@@ -67,12 +74,14 @@ class PreloadCoordinator(
return result
}
+ @MainThread
fun onPlaybackStarted(mediaId: String) {
if (currentPreloadedMediaId != null && currentPreloadedMediaId != mediaId) {
invalidate("playback-started-different-media")
}
}
+ @MainThread
fun invalidate(reason: String) {
if (preloadedMediaSource != null) {
safeLog("preload invalidated reason=$reason mediaId=$currentPreloadedMediaId")
@@ -80,15 +89,17 @@ class PreloadCoordinator(
clear()
}
+ @MainThread
fun release() {
invalidate("release")
}
+ @MainThread
fun isExpired(): Boolean = preloadedMediaSource != null && nowMs() - createdAtMs > PRELOAD_EXPIRY_MS
private fun clear() {
currentPreloadedMediaId = null
- currentPreloadedUrlHash = null
+ currentPreloadedNormalizedUrl = null
preloadedMediaSource = null
currentResolvedType = null
currentDrmKey = null
@@ -96,16 +107,34 @@ class PreloadCoordinator(
createdAtMs = 0L
}
- private fun normalizedUrlHash(url: String): String {
- return url.trim().substringBefore('#').hashCode().toString()
+ private fun normalizedUrl(url: String): String {
+ return url.trim().substringBefore('#')
}
private fun drmKey(streamInfo: StreamInfo): String? {
- return streamInfo.drmInfo?.let { "${it.scheme}:${it.licenseUrl}:${it.headers.hashCode()}" }
+ return streamInfo.drmInfo?.let {
+ // Sort header keys for a deterministic fingerprint across JVM restarts.
+ val headersPart = it.headers.entries
+ .sortedBy { e -> e.key }
+ .joinToString("&") { e -> "${e.key}=${e.value}" }
+ "${it.scheme}:${it.licenseUrl}:${stableHash(headersPart)}"
+ }
+ }
+
+ private fun headersHash(streamInfo: StreamInfo): String {
+ // Build a sorted, deterministic string representation of the effective headers so that
+ // two identical header maps always produce the same fingerprint after a JVM restart.
+ // hashCode() is NOT content-stable across restarts and must not be used here.
+ val effectiveHeaders = (streamInfo.headers.toSortedMap() + ("User-Agent" to (streamInfo.userAgent ?: "")))
+ val canonical = effectiveHeaders.entries.joinToString("&") { "${it.key}=${it.value}" }
+ return stableHash(canonical)
}
- private fun headersHash(streamInfo: StreamInfo): Int {
- return (streamInfo.headers.toSortedMap() + ("User-Agent" to (streamInfo.userAgent ?: ""))).hashCode()
+ /** SHA-256 fingerprint truncated to 16 hex chars — stable across JVM restarts. */
+ private fun stableHash(input: String): String {
+ val digest = java.security.MessageDigest.getInstance("SHA-256")
+ .digest(input.toByteArray(Charsets.UTF_8))
+ return digest.take(8).joinToString("") { "%02x".format(it) }
}
companion object {
diff --git a/player/src/main/java/com/streamvault/player/stats/PlayerStatsCollector.kt b/player/src/main/java/com/streamvault/player/stats/PlayerStatsCollector.kt
index df488b7c..3e94c8ed 100644
--- a/player/src/main/java/com/streamvault/player/stats/PlayerStatsCollector.kt
+++ b/player/src/main/java/com/streamvault/player/stats/PlayerStatsCollector.kt
@@ -11,8 +11,27 @@ import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+/**
+ * Collects playback position, duration, and diagnostic statistics from an [ExoPlayer] instance
+ * and exposes them as [MutableStateFlow]s for Compose UI observation.
+ *
+ * ## Threading Model
+ * **All public methods must be called on the Main/UI thread.** This is safe because:
+ * - ExoPlayer delivers all [androidx.media3.exoplayer.analytics.AnalyticsListener] callbacks
+ * on the application looper (Main thread).
+ * - [androidx.media3.common.Player.Listener] callbacks are also delivered on Main.
+ * - The polling coroutine runs on [Dispatchers.Main.immediate], which dispatches
+ * synchronously if already on Main and never bounces to a background thread pool.
+ *
+ * This design removes the original cross-dispatcher hop pattern
+ * (`launch(Dispatchers.Default)` → `withContext(Dispatchers.Main.immediate)` → back),
+ * which caused 2–3 unnecessary thread context switches every 250 ms per active player.
+ * For a 4-player multiview layout, that was up to 12 wasted thread hops per second.
+ *
+ * Because everything runs on one thread, fields are plain `var`s with no `@Volatile`
+ * or `AtomicInteger` overhead.
+ */
class PlayerStatsCollector(
private val scopeProvider: () -> CoroutineScope,
private val currentPosition: MutableStateFlow<Long>,
@@ -20,12 +39,7 @@ class PlayerStatsCollector(
private val videoFormat: MutableStateFlow<VideoFormat>,
private val playerStats: MutableStateFlow<PlayerStats>
) {
- private data class PlayerSnapshot(
- val currentPosition: Long,
- val duration: Long,
- val bufferedDurationMs: Long?
- )
-
+ // All fields are Main-thread-only. No @Volatile or AtomicInteger required.
private var pollingJob: Job? = null
private var playerProvider: (() -> ExoPlayer?)? = null
private var lastVideoFormat: Format? = null
@@ -50,90 +64,105 @@ class PlayerStatsCollector(
playerStats.value = PlayerStats()
}
+ /** Called by [androidx.media3.exoplayer.analytics.AnalyticsListener] — always on Main. */
fun onVideoFormatChanged(format: Format) {
lastVideoFormat = format
lastFrameRate = format.frameRate.takeIf { it > 0f } ?: lastFrameRate
}
+ /** Called by [androidx.media3.exoplayer.analytics.AnalyticsListener] — always on Main. */
fun onAudioFormatChanged(format: Format) {
lastAudioFormat = format
}
+ /** Called by [androidx.media3.exoplayer.analytics.AnalyticsListener] — always on Main. */
fun onDroppedFrames(count: Int) {
droppedFrames += count
}
+ /** Called by [androidx.media3.exoplayer.analytics.AnalyticsListener] — always on Main. */
fun onBandwidthEstimate(bitrateEstimate: Long) {
if (bitrateEstimate > 0L) {
lastBandwidthEstimate = bitrateEstimate
}
}
+ /** Called by [androidx.media3.common.Player.Listener] — always on Main. */
fun incrementRebufferCount() {
playerStats.value = playerStats.value.copy(rebufferCount = playerStats.value.rebufferCount + 1)
}
+ /**
+ * Starts the stat polling loop on [Dispatchers.Main.immediate].
+ *
+ * Updates are throttled into three tiers so we don't emit more StateFlow updates
+ * than the UI can meaningfully display:
+ *
+ * | Data | Interval |
+ * |---|---|
+ * | `currentPosition` / `duration` | Every 250 ms |
+ * | `bufferedDurationMs` | Every 500 ms (every 2 ticks) |
+ * | Codec / bitrate / dropped frames | Every 1 000 ms (every 4 ticks) |
+ */
fun start() {
stop()
- pollingJob = scopeProvider().launch(Dispatchers.Default) {
- var bufferedUpdateElapsedMs = BUFFERED_UPDATE_INTERVAL_MS
- var statsUpdateElapsedMs = STATS_UPDATE_INTERVAL_MS
- while (isActive) {
- val shouldUpdateBuffered = bufferedUpdateElapsedMs >= BUFFERED_UPDATE_INTERVAL_MS
- val shouldUpdateStats = statsUpdateElapsedMs >= STATS_UPDATE_INTERVAL_MS
- val snapshot = readPlayerSnapshot(shouldUpdateBuffered)
+ pollingJob = scopeProvider().launch(Dispatchers.Main.immediate) {
+ // Initialise to their trigger thresholds so the very first tick emits
+ // buffered and stats updates immediately (consistent with player-start UX).
+ var ticksSinceBufferedUpdate = BUFFERED_UPDATE_TICKS
+ var ticksSinceStatsUpdate = STATS_UPDATE_TICKS
- if (snapshot != null) {
- currentPosition.value = snapshot.currentPosition
- duration.value = snapshot.duration
-
- snapshot.bufferedDurationMs?.let { bufferedDuration ->
- playerStats.value = playerStats.value.copy(bufferedDurationMs = bufferedDuration)
- bufferedUpdateElapsedMs = 0L
+ while (isActive) {
+ val player = playerProvider?.invoke()
+
+ if (player != null) {
+ // --- Tier 1: Position + duration (every tick) ------------------
+ currentPosition.value = player.currentPosition
+ duration.value = player.duration.coerceAtLeast(0L)
+
+ // --- Tier 2: Buffered duration (every 500 ms) ------------------
+ if (ticksSinceBufferedUpdate >= BUFFERED_UPDATE_TICKS) {
+ val buffered = (player.bufferedPosition - player.currentPosition)
+ .coerceAtLeast(0L)
+ playerStats.value = playerStats.value.copy(bufferedDurationMs = buffered)
+ ticksSinceBufferedUpdate = 0
}
- if (shouldUpdateStats) {
+ // --- Tier 3: Codec / bitrate / dropped frames (every 1 000 ms) -
+ if (ticksSinceStatsUpdate >= STATS_UPDATE_TICKS) {
val video = lastVideoFormat
val audio = lastAudioFormat
+ val dropped = droppedFrames
+
videoFormat.value = VideoFormat(
- width = video?.width?.takeIf { it > 0 } ?: 0,
+ width = video?.width?.takeIf { it > 0 } ?: 0,
height = video?.height?.takeIf { it > 0 } ?: 0,
frameRate = lastFrameRate,
- bitrate = video?.bitrate?.takeIf { it > 0 } ?: 0,
+ bitrate = video?.bitrate?.takeIf { it > 0 } ?: 0,
codecV = video?.sampleMimeType ?: video?.codecs,
codecA = audio?.sampleMimeType ?: audio?.codecs
)
playerStats.value = playerStats.value.copy(
- videoCodec = video?.sampleMimeType ?: video?.codecs ?: playerStats.value.videoCodec,
- audioCodec = audio?.sampleMimeType ?: audio?.codecs ?: playerStats.value.audioCodec,
- videoBitrate = video?.bitrate?.takeIf { it > 0 } ?: playerStats.value.videoBitrate,
- droppedFrames = droppedFrames,
- width = video?.width?.takeIf { it > 0 } ?: playerStats.value.width,
- height = video?.height?.takeIf { it > 0 } ?: playerStats.value.height,
+ videoCodec = video?.sampleMimeType ?: video?.codecs
+ ?: playerStats.value.videoCodec,
+ audioCodec = audio?.sampleMimeType ?: audio?.codecs
+ ?: playerStats.value.audioCodec,
+ videoBitrate = video?.bitrate?.takeIf { it > 0 }
+ ?: playerStats.value.videoBitrate,
+ droppedFrames = dropped,
+ width = video?.width?.takeIf { it > 0 }
+ ?: playerStats.value.width,
+ height = video?.height?.takeIf { it > 0 }
+ ?: playerStats.value.height,
bandwidthEstimate = lastBandwidthEstimate
)
- statsUpdateElapsedMs = 0L
+ ticksSinceStatsUpdate = 0
}
}
- delay(POSITION_UPDATE_INTERVAL_MS)
- bufferedUpdateElapsedMs += POSITION_UPDATE_INTERVAL_MS
- statsUpdateElapsedMs += POSITION_UPDATE_INTERVAL_MS
- }
- }
- }
- private suspend fun readPlayerSnapshot(includeBufferedDuration: Boolean): PlayerSnapshot? {
- return withContext(Dispatchers.Main.immediate) {
- playerProvider?.invoke()?.let { player ->
- PlayerSnapshot(
- currentPosition = player.currentPosition,
- duration = player.duration.coerceAtLeast(0L),
- bufferedDurationMs = if (includeBufferedDuration) {
- (player.bufferedPosition - player.currentPosition).coerceAtLeast(0L)
- } else {
- null
- }
- )
+ delay(POSITION_UPDATE_INTERVAL_MS)
+ ticksSinceBufferedUpdate++
+ ticksSinceStatsUpdate++
}
}
}
@@ -144,8 +173,13 @@ class PlayerStatsCollector(
}
private companion object {
+ /** Base polling interval. All other intervals are multiples of this. */
private const val POSITION_UPDATE_INTERVAL_MS = 250L
- private const val BUFFERED_UPDATE_INTERVAL_MS = 500L
- private const val STATS_UPDATE_INTERVAL_MS = 1000L
+
+ /** Buffered duration sampled every 2 ticks = 500 ms. */
+ private const val BUFFERED_UPDATE_TICKS = 2
+
+ /** Heavy stats (codec / bitrate / dropped frames) every 4 ticks = 1 000 ms. */
+ private const val STATS_UPDATE_TICKS = 4
}
}
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 716c2b70..e746dc85 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
@@ -44,7 +44,7 @@ class PlayerRetryPolicyTest {
val error = BehindLiveWindowException()
assertThat(policy.shouldRetry(error, liveContext, playbackStarted = false, attempt = 1)).isTrue()
assertThat(policy.shouldRetry(error, liveContext, playbackStarted = false, attempt = 2)).isFalse()
- assertThat(policy.retryDelayMs(error, 1)).isEqualTo(0L)
+ assertThat(policy.retryDelayMs(error, 1)).isEqualTo(500L)
}
@Test