StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Release 1.0.4 - security fixes, EPG improvements, player stability
David Nashash7c38f4f4026b
diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex 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 Releaseuses: softprops/action-gh-release@v2with: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.apkmake_latest: true- generate_release_notes: true+ generate_release_notes: falsediff --git a/LICENSE b/LICENSEnew file mode 100644index 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 filediff --git a/README.md b/README.mdindex 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.ktsindex ec5d63b7..a8feb7fb 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -1,5 +1,7 @@import java.util.Propertiesimport java.io.FileInputStream+import java.security.KeyStore+import java.security.MessageDigestplugins {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 = 4versionName = "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.ktindex 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.ktindex 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.diimport com.streamvault.data.local.DatabaseTransactionRunnerimport com.streamvault.data.local.RoomDatabaseTransactionRunnerimport com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.security.AndroidKeystoreCredentialCrypto+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.data.sync.ProviderSyncStateReaderImplimport com.streamvault.data.validation.ProviderSetupInputValidatorImplimport com.streamvault.domain.manager.ParentalPinVerifier@@ -79,6 +81,9 @@ abstract class RepositoryModule {@Binds @Singletonabstract fun bindProviderSyncStateReader(impl: ProviderSyncStateReaderImpl): ProviderSyncStateReader+ @Binds @Singleton+ abstract fun bindCredentialCrypto(impl: AndroidKeystoreCredentialCrypto): CredentialCrypto+companion object {@Provides@Singletondiff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.ktindex 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.ktindex 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.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepositoryimport com.streamvault.domain.usecase.GetRecommendations+import kotlinx.coroutines.Dispatchersimport dagger.hilt.android.qualifiers.ApplicationContextimport kotlinx.coroutines.flow.first+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContextimport java.io.OutputStreamimport javax.inject.Injectimport 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 * 1000Lconst 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.ktindex 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.setValueimport androidx.compose.ui.Modifierimport androidx.compose.ui.graphics.Brushimport androidx.compose.ui.graphics.Color+import androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.unit.dpimport 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.ktindex 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.clipimport androidx.compose.ui.focus.FocusRequesterimport androidx.compose.ui.focus.focusRequesterimport androidx.compose.ui.graphics.Color+import androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.unit.dpimport androidx.compose.ui.window.Dialogimport 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.ktindex 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 AndroidKeyEventimport androidx.compose.foundation.BorderStrokeimport androidx.compose.foundation.backgroundimport androidx.compose.foundation.layout.Arrangement@@ -13,6 +14,7 @@ import androidx.compose.foundation.layout.paddingimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.runtime.Composableimport androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.compositionLocalOfimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOfimport androidx.compose.runtime.remember@@ -22,6 +24,8 @@ import androidx.compose.ui.Modifierimport kotlinx.coroutines.delayimport androidx.compose.ui.graphics.Brushimport androidx.compose.ui.graphics.Color+import androidx.compose.ui.input.key.KeyEvent+import androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.unit.dpimport androidx.compose.ui.window.Dialogimport androidx.compose.ui.window.DialogProperties@@ -36,6 +40,23 @@ import com.streamvault.app.ui.interaction.mouseClickableimport com.streamvault.app.ui.design.AppColorsimport 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+ }+ }+}+@Composablefun 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.currentval 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.currentval 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.TextPrimaryButton(- 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.ktindex 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.KeyboardOptionsimport androidx.compose.material.icons.Iconsimport androidx.compose.material.icons.filled.Searchimport androidx.compose.runtime.Composable+import androidx.compose.runtime.CompositionLocalProviderimport androidx.compose.runtime.LaunchedEffectimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOf@@ -31,6 +32,7 @@ import androidx.compose.runtime.rememberimport androidx.compose.runtime.rememberCoroutineScopeimport androidx.compose.runtime.saveable.rememberSaveableimport androidx.compose.runtime.setValue+import androidx.compose.runtime.staticCompositionLocalOfimport androidx.compose.ui.Alignmentimport androidx.compose.ui.Modifierimport androidx.compose.ui.focus.FocusRequester@@ -71,6 +73,8 @@ import java.util.Localeimport kotlinx.coroutines.delayimport kotlinx.coroutines.launch+private val LocalGuideNow = staticCompositionLocalOf { 0L }+@Composableinternal 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+@Composableinternal 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.ktindex 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.rememberScrollStateimport androidx.compose.foundation.shape.CircleShapeimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.runtime.Composable+import androidx.compose.runtime.derivedStateOfimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOfimport 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.dpGuideDensity.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.endTimeval 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)) % 60diff --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.ktindex 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.widthInimport androidx.compose.foundation.shape.RoundedCornerShapeimport androidx.compose.material3.LinearProgressIndicatorimport androidx.compose.runtime.Composable+import androidx.compose.runtime.derivedStateOfimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOfimport 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+ )+}+@Composableinternal 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.ktindex 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 = nullfocusedProgram = 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 = selectedProgramif (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 = nullif (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.ktindex 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.xmltvChannelIdTvClickableSurface(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.ktindex 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.CombinedM3uRepositoryimport com.streamvault.domain.repository.EpgRepositoryimport com.streamvault.domain.repository.EpgSourceRepositoryimport com.streamvault.domain.repository.FavoriteRepository+import com.streamvault.domain.repository.LiveStreamProgramRequestimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.usecase.GetCustomCategoriesimport 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.ktindex 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.LiveSourceSwitcherimport com.streamvault.app.ui.components.shell.ContentMetadataStripimport com.streamvault.app.ui.components.shell.LiveChannelRowSurfaceimport com.streamvault.app.ui.components.shell.StatusPill+import com.streamvault.app.ui.components.TvEmptyStateimport com.streamvault.app.ui.components.dialogs.CategoryOptionsDialogimport com.streamvault.app.ui.components.dialogs.PinDialogimport 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 = Modifierdiff --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.ktindex 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.ChannelRepositoryimport com.streamvault.domain.repository.CombinedM3uRepositoryimport com.streamvault.domain.repository.EpgRepositoryimport com.streamvault.domain.repository.FavoriteRepository+import com.streamvault.domain.repository.LiveStreamProgramRequestimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport 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.ktindex 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()?.iddiff --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.ktindex 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.ktindex 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.RecordingItemimport com.streamvault.domain.model.RecordingRecurrenceimport com.streamvault.domain.model.RecordingRequestimport com.streamvault.domain.model.RecordingStatus+import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.Seriesimport 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 = falseinternal var lastRecordedLivePlaybackKey: Pair<Long, Long>? = nullprivate 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 = falsereturn ++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 falsesetLastFailureReason(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.ktindex 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.launchfun 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.ktindex 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.Injectimport javax.inject.Singletonimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.withContext+import kotlinx.coroutines.withTimeoutOrNullimport kotlin.math.roundToInt@Singleton@@ -19,6 +20,12 @@ class SeekThumbnailProvider @Inject constructor(companion object {private const val FRAME_BUCKET_MS = 10_000Lprivate 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 thisval 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.ktindex 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.BackHandlerimport androidx.compose.animation.animateColorAsStateimport androidx.compose.animation.AnimatedVisibilityimport androidx.compose.animation.core.animateFloatAsState@@ -40,6 +41,7 @@ import androidx.compose.ui.graphics.drawscope.Strokeimport androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.platform.LocalContextimport androidx.compose.ui.platform.LocalSoftwareKeyboardController+import androidx.compose.ui.res.stringResourceimport androidx.compose.ui.semantics.contentDescriptionimport androidx.compose.ui.semantics.semanticsimport androidx.compose.ui.text.AnnotatedString@@ -80,6 +82,7 @@ private enum class SourceType { XTREAM, M3U_URL, M3U_FILE }@Composablefun 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 = trueinputFocusRequester.requestFocus()@@ -1058,6 +1104,20 @@ private fun ProviderTextField(}val cursor = fieldValue.selection.endwhen (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.ktindex 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.providerimport androidx.lifecycle.ViewModelimport 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.CredentialDecryptionExceptionimport com.streamvault.domain.model.ActiveLiveSourceimport com.streamvault.domain.model.ProviderEpgSyncModeimport com.streamvault.domain.model.ProviderType@@ -19,6 +25,14 @@ import kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.updateimport 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@HiltViewModelclass 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.ktindex 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()?.iddiff --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.ktindex 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.ktindex 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.focusRequesterimport androidx.compose.ui.focus.onFocusChangedimport androidx.compose.ui.graphics.Colorimport androidx.compose.ui.graphics.SolidColor+import androidx.compose.ui.input.key.onPreviewKeyEventimport androidx.compose.ui.platform.LocalSoftwareKeyboardControllerimport androidx.compose.ui.res.stringResourceimport androidx.compose.ui.text.TextRange@@ -40,6 +41,7 @@ import com.streamvault.app.localization.supportedAppLanguageTagsimport com.streamvault.app.ui.components.dialogs.PremiumDialogimport com.streamvault.app.ui.components.dialogs.PremiumDialogActionButtonimport com.streamvault.app.ui.components.dialogs.PremiumDialogFooterButton+import com.streamvault.app.ui.components.dialogs.rememberDialogOpenGestureBlockerimport com.streamvault.app.ui.design.FocusSpecimport com.streamvault.app.ui.interaction.TvButtonimport 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.ktindex 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) ?: beforeMetadataval 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.ktindex 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.DocumentFileimport com.streamvault.app.ui.interaction.TvClickableSurfaceimport com.streamvault.app.ui.interaction.TvButtonimport com.streamvault.app.ui.interaction.TvIconButton+import com.streamvault.app.util.OfficialBuildStatus+import com.streamvault.app.util.OfficialBuildVerifierimport com.streamvault.app.ui.components.dialogs.PinDialogimport com.streamvault.app.ui.components.dialogs.PremiumDialog@@ -122,6 +124,10 @@ fun SettingsScreen(val scope = rememberCoroutineScope()val context = androidx.compose.ui.platform.LocalContext.currentval 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? = thiswhile (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.ktindex 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.ktindex 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.BackupConflictStrategyimport com.streamvault.domain.manager.BackupImportPlanimport com.streamvault.domain.manager.BackupManagerimport com.streamvault.domain.manager.BackupPreview+import com.streamvault.domain.manager.ParentalControlManagerimport com.streamvault.domain.manager.RecordingManagerimport com.streamvault.domain.model.Categoryimport 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.ktindex 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.ktindex 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.isActiveimport kotlinx.coroutines.launchimport kotlinx.coroutines.withContextimport java.io.File+import java.net.URIimport javax.inject.Injectimport 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.ktindex 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.Dispatchersimport kotlinx.coroutines.withContextimport okhttp3.OkHttpClientimport okhttp3.Request+import okhttp3.ResponseBodyimport org.json.JSONObject+import java.io.ByteArrayOutputStreamimport java.io.IOException+import java.net.URIimport javax.inject.Injectimport 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 nullvar fallback: String? = null@@ -81,6 +122,7 @@ class GitHubReleaseChecker @Inject constructor(val asset = assets.optJSONObject(index) ?: continueval name = asset.optString("name")val url = asset.optString("browser_download_url").takeIf { it.isNotBlank() } ?: continue+ if (!isHttpsUrl(url)) continueif (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.ktnew file mode 100644index 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.xmlindex 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.xmlindex 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.ktindex 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.ktindex 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): Longdiff --git a/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt b/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.ktindex 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.managerimport android.content.Contextimport android.net.Uriimport com.google.gson.Gson+import com.google.gson.reflect.TypeToken+import com.google.gson.stream.JsonWriterimport com.streamvault.data.local.dao.EpisodeDaoimport com.streamvault.data.local.dao.FavoriteDaoimport com.streamvault.data.local.dao.MovieDao@@ -32,8 +34,11 @@ import dagger.hilt.android.qualifiers.ApplicationContextimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.withContext+import java.io.OutputStreamimport java.io.InputStreamReaderimport java.io.OutputStreamWriter+import java.io.Writer+import java.lang.reflect.Typeimport java.security.MessageDigestimport java.util.zip.CRC32import javax.inject.Inject@@ -43,6 +48,7 @@ import javax.inject.Singletonclass 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 URIcontext.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 verificationval 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>>() {}.typediff --git a/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.kt b/data/src/main/java/com/streamvault/data/manager/RecordingConflictDetector.ktindex 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.RecordingRunEntityimport com.streamvault.domain.model.RecordingItem+import com.streamvault.domain.model.RecordingFailureCategoryimport com.streamvault.domain.model.RecordingStatusinternal 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.ktindex 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.Resultimport dagger.hilt.android.qualifiers.ApplicationContextimport java.io.Fileimport java.io.FileInputStream+import java.time.Duration+import java.time.Instant+import java.time.ZoneIdimport java.util.UUIDimport javax.inject.Injectimport javax.inject.Singleton@@ -58,6 +61,8 @@ import kotlinx.coroutines.sync.Muteximport kotlinx.coroutines.sync.withLockimport kotlinx.coroutines.withContext+private const val TAG = "RecordingManager"+@Singletonclass 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.ktindex 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()) continuewhen {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.ktindex 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.ktindex 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 nullval 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 nullval 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 nullval 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.ktindex 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(@Singletonclass 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 nullval ext = token?.containerExtension ?: fallbackContainerExtensionval 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.ktindex 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.ktindex 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 remainingdiff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.ktindex 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.ktindex 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.DatabaseTransactionRunnerimport com.streamvault.data.local.dao.EpisodeDaoimport com.streamvault.data.local.dao.MovieDaoimport 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.ktindex 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.DatabaseTransactionRunnerimport com.streamvault.data.local.dao.*import com.streamvault.data.local.entity.ProviderEntityimport com.streamvault.data.mapper.*+import com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamProviderimport com.streamvault.data.security.CredentialCrypto@@ -12,12 +14,17 @@ import com.streamvault.data.util.ProviderInputSanitizerimport com.streamvault.data.util.UrlSecurityPolicyimport com.streamvault.domain.model.*import com.streamvault.domain.provider.IptvProvider+import com.streamvault.domain.repository.LiveStreamProgramRequestimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.async+import kotlinx.coroutines.awaitAllimport kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.SupervisorJob+import kotlinx.coroutines.coroutineScopeimport kotlinx.coroutines.flow.Flow+import kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.mapimport kotlinx.coroutines.launchimport 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.ktindex 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.ktindex 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.Cipherimport javax.crypto.KeyGeneratorimport javax.crypto.SecretKeyimport 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 valuereturn try {@@ -40,7 +52,7 @@ object CredentialCrypto {}}- fun decryptIfNeeded(value: String): String {+ override fun decryptIfNeeded(value: String): String {if (!value.startsWith(PREFIX)) return valuereturn try {diff --git a/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt b/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.ktindex 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 falseif (stats.mainDbBytes < MIN_DATABASE_BYTES) return falsediff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.ktindex 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@withProviderLockval 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] = jobjob.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.ktindex 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) returnif (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.ktindex 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.ktindex 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 filediff --git a/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.kt b/data/src/main/java/com/streamvault/data/util/UrlSecurityPolicy.ktindex 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.StreamEntryUrlPolicyimport java.net.URIimport 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.ktindex 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.managerimport 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.RecordingSourceTypeimport com.streamvault.domain.model.RecordingItemimport com.streamvault.domain.model.RecordingStatusimport 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.ktindex 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")+ }+@Testfun `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.ktindex 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.xtreamimport com.google.common.truth.Truth.assertThatimport com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ProviderTypeimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.runBlockingimport org.junit.Testclass XtreamStreamUrlResolverTest {+ private val credentialCrypto = object : CredentialCrypto {+ override fun encryptIfNeeded(value: String): String = value+ override fun decryptIfNeeded(value: String): String = value+ }+@Testfun 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? = nulloverride 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.idoverride suspend fun update(provider: ProviderEntity) = Unitoverride suspend fun delete(id: Long) = Unitdiff --git a/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/EpgSourceRepositoryImplTest.ktindex 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.ContentResolverimport android.content.Context+import android.net.Uriimport com.google.common.truth.Truth.assertThatimport com.streamvault.data.epg.EpgResolutionEngineimport com.streamvault.data.local.dao.ChannelEpgMappingDao@@ -16,6 +18,7 @@ import com.streamvault.data.parser.XmltvParserimport com.streamvault.domain.model.EpgMatchTypeimport com.streamvault.domain.model.EpgSourceTypeimport com.streamvault.domain.model.Result+import java.io.ByteArrayInputStreamimport kotlinx.coroutines.test.runTestimport okhttp3.OkHttpClientimport org.junit.Before@@ -31,6 +34,7 @@ import org.mockito.kotlin.wheneverclass 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 {@Beforefun 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 filediff --git a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.ktindex 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.XtreamCategoryimport com.streamvault.data.remote.dto.XtreamStreamimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolver+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.ProviderStatusimport 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 {@Testfun `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.ktindex 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.XtreamSeriesItemimport com.streamvault.data.remote.xtream.XtreamParsingExceptionimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolver+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ProviderStatusimport com.streamvault.domain.model.ProviderTypeimport 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+ }@Testfun `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 {@Testfun `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 {@Testfun `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 = seriesCategoryHydrationDaodiff --git a/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.kt b/data/src/test/java/com/streamvault/data/security/CredentialCryptoTest.ktindex 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.Testclass 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 filediff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.ktindex 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.ProviderDaoimport com.streamvault.data.local.dao.SeriesDaoimport com.streamvault.data.local.entity.ProviderEntityimport com.streamvault.data.parser.M3uParser+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.SyncStateimport com.streamvault.domain.model.Resultimport 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) = Unitoverride 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 {@Testfun `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()}@Testfun `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()}@Testfun `isVodEntry_movieGroupTitle_returnsTrue`() {- val mgr = buildManager()- assertThat(mgr.isVodEntry(entry(group = "Movies HD"))).isTrue()+ assertThat(M3uParser.isVodEntry(entry(group = "Movies HD"))).isTrue()}@Testfun `isVodEntry_vodGroupTitle_returnsTrue`() {- val mgr = buildManager()- assertThat(mgr.isVodEntry(entry(group = "VOD Library"))).isTrue()+ assertThat(M3uParser.isVodEntry(entry(group = "VOD Library"))).isTrue()}@Testfun `isVodEntry_filmGroupTitle_returnsTrue`() {- val mgr = buildManager()- assertThat(mgr.isVodEntry(entry(group = "Film Classics"))).isTrue()+ assertThat(M3uParser.isVodEntry(entry(group = "Film Classics"))).isTrue()}@Testfun `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()}@Testfun `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.ktindex 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()+ }+@Testfun `sanitizeImportedAssetUrl drops unsupported schemes`() {assertThat(UrlSecurityPolicy.sanitizeImportedAssetUrl("ftp://example.com/logo.png")).isNull()diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 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/2026diff --git a/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.kt b/domain/src/main/java/com/streamvault/domain/manager/ParentalControlManager.ktindex 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.MutableStateFlowimport kotlinx.coroutines.flow.StateFlowimport kotlinx.coroutines.flow.asStateFlowimport kotlinx.coroutines.flow.map+import kotlinx.coroutines.flow.updateimport javax.inject.Injectimport javax.inject.Singleton@@ -11,7 +12,6 @@ import javax.inject.Singletonclass 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) == truefun 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.ktindex 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.ktindex 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.ProviderEpgSyncModeimport com.streamvault.domain.model.Resultimport 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.ktindex 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.ContentTypeimport com.streamvault.domain.model.PlaybackHistoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.util.isPlaybackComplete+import com.streamvault.domain.util.shouldRethrowDomainFlowFailureimport javax.inject.Injectimport kotlinx.coroutines.flow.Flowimport 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.ktindex 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.usecaseimport com.streamvault.domain.model.Movieimport com.streamvault.domain.repository.MovieRepository+import com.streamvault.domain.util.shouldRethrowDomainFlowFailureimport java.util.logging.Levelimport java.util.logging.Loggerimport 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.ktindex 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.recurrencediff --git a/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.kt b/domain/src/main/java/com/streamvault/domain/usecase/SearchContent.ktindex 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.Seriesimport com.streamvault.domain.repository.ChannelRepositoryimport com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.util.shouldRethrowDomainFlowFailureimport java.util.logging.Levelimport java.util.logging.Loggerimport 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.ktindex 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.NotXtreamPlaylistval normalizedPath = uri.path.orEmpty().lowercase()- if (!normalizedPath.endsWith("/get.php")) return null+ if (!normalizedPath.endsWith("/get.php")) return ParsedXtreamPlaylistUrlResult.NotXtreamPlaylistval 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 = passworddiff --git a/domain/src/main/java/com/streamvault/domain/util/FlowErrorHandling.kt b/domain/src/main/java/com/streamvault/domain/util/FlowErrorHandling.ktnew file mode 100644index 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 filediff --git a/domain/src/main/java/com/streamvault/domain/util/StreamEntryUrlPolicy.kt b/domain/src/main/java/com/streamvault/domain/util/StreamEntryUrlPolicy.ktnew file mode 100644index 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 filediff --git a/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.kt b/domain/src/test/java/com/streamvault/domain/model/StreamInfoTest.ktindex 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 filediff --git a/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.kt b/domain/src/test/java/com/streamvault/domain/usecase/GetContinueWatchingTest.ktindex 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.PlaybackHistoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.first+import kotlinx.coroutines.flow.flowimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport 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? = nulloverride 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.ktindex 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.StreamInfoimport com.streamvault.domain.repository.MovieRepositoryimport kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.first+import kotlinx.coroutines.flow.flowimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport 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.ktindex 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.ktindex 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.MovieRepositoryimport com.streamvault.domain.repository.SeriesRepositoryimport kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.first+import kotlinx.coroutines.flow.flowimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport 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.ktindex 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.ktindex 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.ktindex 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.CoroutineScopeimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.Jobimport kotlinx.coroutines.SupervisorJob-import kotlinx.coroutines.cancelimport kotlinx.coroutines.delayimport kotlinx.coroutines.flow.Flowimport 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? = nullprivate var mediaSession: MediaSession? = nullprivate var requestedDecoderMode: DecoderMode = DecoderMode.AUTO@@ -343,9 +341,6 @@ class Media3PlayerEngine @Inject constructor(_mediaTitle.value = nulltrackController.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 = isPlayingif (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)}returndiff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.ktindex 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.ConnectExceptionimport java.net.SocketTimeoutExceptionimport 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_000L2 -> 2_500Ldiff --git a/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.kt b/player/src/main/java/com/streamvault/player/playback/PreloadCoordinator.ktindex 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.playbackimport android.util.Log+import androidx.annotation.MainThreadimport androidx.media3.exoplayer.source.MediaSourceimport com.streamvault.domain.model.StreamInfo+/**+ * Main-thread-only cache for a single preloaded media source owned by Media3PlayerEngine.+ */+@MainThreadclass PreloadCoordinator(private val nowMs: () -> Long = { System.currentTimeMillis() }) {var currentPreloadedMediaId: String? = nullprivate set- var currentPreloadedUrlHash: String? = null+ var currentPreloadedNormalizedUrl: String? = nullprivate setvar preloadedMediaSource: MediaSource? = nullprivate set@@ -18,11 +23,12 @@ class PreloadCoordinator(private var currentResolvedType: ResolvedStreamType? = nullprivate var currentDrmKey: String? = null- private var currentHeadersHash: Int? = null+ private var currentHeadersHash: String? = null+ @MainThreadfun store(mediaId: String, streamInfo: StreamInfo, resolvedType: ResolvedStreamType, mediaSource: MediaSource) {currentPreloadedMediaId = mediaId- currentPreloadedUrlHash = normalizedUrlHash(streamInfo.url)+ currentPreloadedNormalizedUrl = normalizedUrl(streamInfo.url)preloadedMediaSource = mediaSourcecurrentResolvedType = resolvedTypecurrentDrmKey = drmKey(streamInfo)@@ -31,6 +37,7 @@ class PreloadCoordinator(safeLog("preload stored mediaId=$mediaId type=$resolvedType target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}")}+ @MainThreadfun 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}+ @MainThreadfun onPlaybackStarted(mediaId: String) {if (currentPreloadedMediaId != null && currentPreloadedMediaId != mediaId) {invalidate("playback-started-different-media")}}+ @MainThreadfun invalidate(reason: String) {if (preloadedMediaSource != null) {safeLog("preload invalidated reason=$reason mediaId=$currentPreloadedMediaId")@@ -80,15 +89,17 @@ class PreloadCoordinator(clear()}+ @MainThreadfun release() {invalidate("release")}+ @MainThreadfun isExpired(): Boolean = preloadedMediaSource != null && nowMs() - createdAtMs > PRELOAD_EXPIRY_MSprivate fun clear() {currentPreloadedMediaId = null- currentPreloadedUrlHash = null+ currentPreloadedNormalizedUrl = nullpreloadedMediaSource = nullcurrentResolvedType = nullcurrentDrmKey = 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.ktindex 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.delayimport kotlinx.coroutines.flow.MutableStateFlowimport kotlinx.coroutines.isActiveimport 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? = nullprivate var playerProvider: (() -> ExoPlayer?)? = nullprivate 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 = formatlastFrameRate = 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 = lastVideoFormatval 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.ktindex 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