Skip to content

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

Fix portable backup state restore

David Nashash3f79ba10caec
diff --git a/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt b/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt
index e5058891..229602c0 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt
@@ -33,6 +33,12 @@ interface M3uClassificationDao {
@Query("DELETE FROM m3u_classification_overrides WHERE provider_id = :providerId AND source_key = :sourceKey")
suspend fun deleteOverride(providerId: Long, sourceKey: String)
+ @Query("DELETE FROM m3u_classification_overrides WHERE provider_id = :providerId")
+ suspend fun deleteOverridesByProvider(providerId: Long)
+
@Query("DELETE FROM m3u_category_classification_rules WHERE provider_id = :providerId AND group_key = :groupKey")
suspend fun deleteCategoryRule(providerId: Long, groupKey: String)
+
+ @Query("DELETE FROM m3u_category_classification_rules WHERE provider_id = :providerId")
+ suspend fun deleteCategoryRulesByProvider(providerId: Long)
}
diff --git a/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt b/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
index a47f0f71..f735b27b 100644
--- a/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
+++ b/data/src/main/java/com/streamvault/data/manager/BackupManagerImpl.kt
@@ -16,6 +16,8 @@ import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.data.local.dao.BackupRestoreCheckpointDao
import com.streamvault.data.local.dao.ChannelDao
import com.streamvault.data.local.dao.ChannelPreferenceDao
+import com.streamvault.data.local.dao.ChannelEpgMappingDao
+import com.streamvault.data.local.dao.M3uClassificationDao
import com.streamvault.data.local.dao.CombinedM3uProfileDao
import com.streamvault.data.local.dao.CombinedM3uProfileMemberDao
import com.streamvault.data.local.dao.EpisodeDao
@@ -24,6 +26,7 @@ import com.streamvault.data.local.dao.FavoriteDao
import com.streamvault.data.local.dao.MovieDao
import com.streamvault.data.local.dao.PlaybackHistoryDao
import com.streamvault.data.local.dao.ProviderDao
+import com.streamvault.data.local.dao.ProviderEpgSourceDao
import com.streamvault.data.local.dao.ProviderSnapshotDao
import com.streamvault.data.local.dao.RecordingScheduleDao
import com.streamvault.data.local.dao.SeriesDao
@@ -33,6 +36,10 @@ import com.streamvault.data.local.entity.ProviderAccountRuntimeEntity
import com.streamvault.data.local.entity.ProviderConfigEntity
import com.streamvault.data.local.entity.BackupRestoreCheckpointEntity
import com.streamvault.data.local.entity.ChannelPreferenceEntity
+import com.streamvault.data.local.entity.ChannelEpgMappingEntity
+import com.streamvault.data.local.entity.ProviderEpgSourceEntity
+import com.streamvault.data.local.entity.M3uClassificationOverrideEntity
+import com.streamvault.data.local.entity.M3uCategoryClassificationRuleEntity
import com.streamvault.data.local.entity.CombinedM3uProfileEntity
import com.streamvault.data.local.entity.CombinedM3uProfileMemberEntity
import com.streamvault.data.local.entity.RecordingScheduleEntity
@@ -59,6 +66,14 @@ import com.streamvault.domain.manager.BackupPreview
import com.streamvault.domain.manager.RecordingScheduleImportDisposition
import com.streamvault.domain.manager.RecordingScheduleImportOutcome
import com.streamvault.domain.manager.RecordingScheduleImportSummary
+import com.streamvault.domain.manager.RecordingStorageBackup
+import com.streamvault.domain.manager.ProviderEpgAssignmentBackup
+import com.streamvault.domain.manager.ManualEpgMappingBackup
+import com.streamvault.domain.manager.M3uClassificationOverrideBackup
+import com.streamvault.domain.manager.M3uClassificationRuleBackup
+import com.streamvault.domain.manager.ProgramReminderBackup
+import com.streamvault.domain.manager.ProgramReminderManager
+import com.streamvault.domain.model.Program
import com.streamvault.domain.manager.ProtectedCategoryBackup
import com.streamvault.domain.manager.BackupProviderReference
import com.streamvault.domain.manager.ProviderBackupSnapshot
@@ -147,7 +162,11 @@ class BackupManagerImpl @Inject constructor(
private val epgSourceDao: EpgSourceDao? = null,
private val combinedM3uProfileDao: CombinedM3uProfileDao? = null,
private val combinedM3uProfileMemberDao: CombinedM3uProfileMemberDao? = null,
- private val channelPreferenceDao: ChannelPreferenceDao? = null
+ private val channelPreferenceDao: ChannelPreferenceDao? = null,
+ private val providerEpgSourceDao: ProviderEpgSourceDao? = null,
+ private val channelEpgMappingDao: ChannelEpgMappingDao? = null,
+ private val m3uClassificationDao: M3uClassificationDao? = null,
+ private val programReminderManager: ProgramReminderManager? = null
) : BackupManager {
override suspend fun exportConfig(uriString: String): com.streamvault.domain.model.Result<Unit> = withContext(Dispatchers.IO) {
@@ -322,6 +341,14 @@ class BackupManagerImpl @Inject constructor(
val allFavorites = (liveFavs + movieFavs + seriesFavs).map { favorite ->
favorite.withPortableIdentity(channelDao, movieDao, seriesDao)
}
+ val unportableFavorites = allFavorites.filter {
+ it.remoteContentId.isNullOrBlank() && it.contentType != ContentType.VOD
+ }
+ if (unportableFavorites.isNotEmpty()) {
+ return@withContext com.streamvault.domain.model.Result.error(
+ "Cannot export ${unportableFavorites.size} favorite(s) because their synced content identity is missing"
+ )
+ }
// Gather all custom groups
val liveGroups = providerIds.flatMap { providerId ->
@@ -356,6 +383,13 @@ class BackupManagerImpl @Inject constructor(
}
}
}
+ val expectedMultiViewEntries = multiViewPresets.values.sumOf { it.size }
+ val exportedMultiViewEntries = portableMultiViewPresets.values.sumOf { it.size }
+ if (expectedMultiViewEntries != exportedMultiViewEntries) {
+ return@withContext com.streamvault.domain.model.Result.error(
+ "Cannot export split-screen presets because one or more channels are not synced"
+ )
+ }
val protectedCategories = providers.flatMap { provider ->
categoryRepository.getCategories(provider.id).first()
.filter { it.isUserProtected }
@@ -366,10 +400,101 @@ class BackupManagerImpl @Inject constructor(
providerStalkerMacAddress = provider.stalkerMacAddress.takeIf { it.isNotBlank() },
categoryId = category.id,
categoryName = category.name,
- type = category.type
+ type = category.type,
+ providerType = provider.type
+ )
+ }
+ }
+ val providerEpgAssignments = if (providerEpgSourceDao != null && epgSourceDao != null) {
+ providers.flatMap { provider ->
+ providerEpgSourceDao.getForProviderSync(provider.id).mapNotNull { assignment ->
+ epgSourceDao.getById(assignment.epgSourceId)?.let { source ->
+ ProviderEpgAssignmentBackup(
+ provider = provider.toBackupProviderReference(),
+ sourceUrl = source.url,
+ priority = assignment.priority,
+ enabled = assignment.enabled
+ )
+ }
+ }
+ }
+ } else {
+ null
+ }
+ val manualEpgMappings = if (channelEpgMappingDao != null && epgSourceDao != null) {
+ providers.flatMap { provider ->
+ channelEpgMappingDao.getForProvider(provider.id)
+ .filter { it.isManualOverride }
+ .mapNotNull { mapping ->
+ val channel = channelDao.getById(mapping.providerChannelId)
+ ?.takeIf { it.providerId == provider.id }
+ ?: return@mapNotNull null
+ ManualEpgMappingBackup(
+ channel = PortableChannelReference(
+ provider = provider.toBackupProviderReference(),
+ streamId = channel.streamId,
+ name = channel.name,
+ streamUrl = channel.streamUrl
+ ),
+ sourceUrl = mapping.epgSourceId?.let { epgSourceDao.getById(it)?.url },
+ xmltvChannelId = mapping.xmltvChannelId,
+ sourceType = mapping.sourceType,
+ matchType = mapping.matchType,
+ confidence = mapping.confidence,
+ source = mapping.source
+ )
+ }
+ }
+ } else {
+ null
+ }
+ val m3uClassificationOverrides = if (m3uClassificationDao != null) {
+ providers.filter { it.type == ProviderType.M3U }.flatMap { provider ->
+ m3uClassificationDao.getOverrides(provider.id).map { override ->
+ M3uClassificationOverrideBackup(
+ provider = provider.toBackupProviderReference(),
+ sourceKey = override.sourceKey,
+ streamId = override.streamId,
+ targetType = override.targetType,
+ groupKey = override.groupKey,
+ seriesKey = override.seriesKey,
+ seriesName = override.seriesName,
+ seasonNumber = override.seasonNumber,
+ episodeNumber = override.episodeNumber,
+ episodeTitle = override.episodeTitle
)
}
+ }
+ } else {
+ null
}
+ val m3uClassificationRules = if (m3uClassificationDao != null) {
+ providers.filter { it.type == ProviderType.M3U }.flatMap { provider ->
+ m3uClassificationDao.getCategoryRules(provider.id).map { rule ->
+ M3uClassificationRuleBackup(
+ provider = provider.toBackupProviderReference(),
+ groupKey = rule.groupKey,
+ targetType = rule.targetType
+ )
+ }
+ }
+ } else {
+ null
+ }
+ val programReminders = programReminderManager?.observeUpcomingReminders()?.first()
+ ?.filter { it.programStartTime > System.currentTimeMillis() && !it.isDismissed }
+ ?.mapNotNull { reminder ->
+ providersById[reminder.providerId]?.let { provider ->
+ ProgramReminderBackup(
+ provider = provider.toBackupProviderReference(),
+ channelId = reminder.channelId,
+ channelName = reminder.channelName,
+ programTitle = reminder.programTitle,
+ programStartTime = reminder.programStartTime,
+ leadTimeMinutes = reminder.leadTimeMinutes
+ )
+ }
+ }
val scheduledRecordings = recordingManager.observeRecordingItems().first()
.filter { it.status == RecordingStatus.SCHEDULED && it.scheduledEndMs > System.currentTimeMillis() }
.mapNotNull { item ->
@@ -380,6 +505,25 @@ class BackupManagerImpl @Inject constructor(
)
}
.normalizedRecurringBackups()
+ val recordingStorage = recordingManager.observeStorageState().first().let { storage ->
+ RecordingStorageBackup(
+ fileNamePattern = storage.fileNamePattern,
+ retentionDays = storage.retentionDays,
+ maxSimultaneousRecordings = storage.maxSimultaneousRecordings
+ )
+ }
+ val portableProviderPreferences = buildPortableProviderPreferences(providers)
+ if (portableProviderPreferences.unresolvedReferences.isNotEmpty()) {
+ return@withContext com.streamvault.domain.model.Result.error(
+ "Cannot export provider-scoped settings: ${portableProviderPreferences.unresolvedReferences.first()}"
+ )
+ }
+ val unportableHistory = playbackHistory.count { it.remoteContentId.isNullOrBlank() }
+ if (unportableHistory > 0) {
+ return@withContext com.streamvault.domain.model.Result.error(
+ "Cannot export $unportableHistory playback-history item(s) because their synced content identity is missing"
+ )
+ }
val backupData = BackupData(
version = CURRENT_BACKUP_VERSION,
@@ -393,9 +537,15 @@ class BackupManagerImpl @Inject constructor(
portableMultiViewPresets = portableMultiViewPresets,
protectedCategories = protectedCategories,
scheduledRecordings = scheduledRecordings,
- portableProviderPreferences = buildPortableProviderPreferences(providers),
+ portableProviderPreferences = portableProviderPreferences,
+ recordingStorage = recordingStorage,
providerCredentials = providerCredentials.takeIf { it.isNotEmpty() },
epgSources = epgSourceDao?.getAllSync()?.map { it.toDomain() },
+ providerEpgAssignments = providerEpgAssignments,
+ manualEpgMappings = manualEpgMappings,
+ m3uClassificationOverrides = m3uClassificationOverrides,
+ m3uClassificationRules = m3uClassificationRules,
+ programReminders = programReminders,
combinedM3uProfiles = combinedM3uProfiles,
activeLiveSource = activeLiveSource
)
@@ -599,7 +749,7 @@ class BackupManagerImpl @Inject constructor(
if (!checkpoint.roomComplete) {
val roomCheckpoint = checkpoint.copy(
- roomComplete = true,
+ roomComplete = false,
state = RESTORE_STATE_RUNNING,
lastError = null,
updatedAt = System.currentTimeMillis()
@@ -608,8 +758,7 @@ class BackupManagerImpl @Inject constructor(
restoreRoomBackedSections(
backupData = backupData,
plan = plan,
- initialStoredProviders = storedProviders,
- onRoomCommitted = { roomCheckpoint.persist() }
+ initialStoredProviders = storedProviders
)
} catch (error: Exception) {
checkpoint = checkpoint.copy(
@@ -631,7 +780,10 @@ class BackupManagerImpl @Inject constructor(
if (roomRestoreResult.unresolvedReferences.isNotEmpty()) {
failedSections += "Saved library/history: ${roomRestoreResult.unresolvedReferences.size} unresolved"
}
- checkpoint = roomCheckpoint
+ checkpoint = roomCheckpoint.copy(
+ roomComplete = roomRestoreResult.unresolvedReferences.isEmpty(),
+ updatedAt = System.currentTimeMillis()
+ ).persist()
} else {
importedSections += importedRoomSections(backupData, plan)
skippedSections += skippedRoomSections(backupData, plan)
@@ -654,22 +806,25 @@ class BackupManagerImpl @Inject constructor(
preferences?.let {
restorePreferences(it, skipProviderScopedReferences = portablePreferences != null)
}
- portablePreferences?.let { portable ->
- unresolvedReferences += restorePortableProviderPreferences(portable, storedProviders)
- }
- val portableComplete = unresolvedReferences.isEmpty()
+ val preferenceUnresolved = portablePreferences?.let { portable ->
+ restorePortableProviderPreferences(portable, storedProviders)
+ }.orEmpty()
+ unresolvedReferences += preferenceUnresolved
+ val portableComplete = preferenceUnresolved.isEmpty()
if (!portableComplete) {
- failedSections += "Provider-scoped preferences: ${unresolvedReferences.size} unresolved"
+ failedSections += "Provider-scoped preferences: ${preferenceUnresolved.size} unresolved"
}
checkpoint = checkpoint.copy(
preferencesComplete = portableComplete,
preferenceSnapshotJson = checkpoint.preferenceSnapshotJson.takeIf {
!portableComplete ||
- (plan.importMultiViewPresets && backupData.multiViewPresets != null)
+ (plan.importMultiViewPresets &&
+ (backupData.multiViewPresets != null || backupData.portableMultiViewPresets != null))
},
updatedAt = System.currentTimeMillis()
).persist(clearPreferenceSnapshot = portableComplete && !(
- plan.importMultiViewPresets && backupData.multiViewPresets != null
+ plan.importMultiViewPresets &&
+ (backupData.multiViewPresets != null || backupData.portableMultiViewPresets != null)
))
importedSections += "Preferences"
} catch (error: Exception) {
@@ -703,10 +858,12 @@ class BackupManagerImpl @Inject constructor(
preferencesRepository.setMultiViewPreset(2, presets?.get("preset_3").orEmpty())
}
checkpoint = checkpoint.copy(
- presetsComplete = true,
- preferenceSnapshotJson = null,
+ presetsComplete = portableUnresolved.isEmpty(),
+ preferenceSnapshotJson = checkpoint.preferenceSnapshotJson.takeIf {
+ portableUnresolved.isNotEmpty()
+ },
updatedAt = System.currentTimeMillis()
- ).persist(clearPreferenceSnapshot = true)
+ ).persist(clearPreferenceSnapshot = portableUnresolved.isEmpty())
if (portableUnresolved.isNotEmpty()) {
failedSections += "Split Screen Presets: ${portableUnresolved.size} unresolved"
}
@@ -760,6 +917,28 @@ class BackupManagerImpl @Inject constructor(
}
} else skippedSections += "Recording Schedules"
+ backupData.recordingStorage?.let { storage ->
+ try {
+ val current = recordingManager.observeStorageState().first()
+ when (val result = recordingManager.updateStorageConfig(
+ com.streamvault.domain.model.RecordingStorageConfig(
+ treeUri = current.treeUri,
+ displayName = current.displayName,
+ localDirectory = current.localDirectory,
+ fileNamePattern = storage.fileNamePattern,
+ retentionDays = storage.retentionDays,
+ maxSimultaneousRecordings = storage.maxSimultaneousRecordings
+ )
+ )) {
+ is Result.Success -> importedSections.add("Recording Storage Settings")
+ is Result.Error -> failedSections.add("Recording Storage Settings: ${result.message}")
+ Result.Loading -> failedSections.add("Recording Storage Settings: update did not complete")
+ }
+ } catch (error: Exception) {
+ failedSections.add("Recording Storage Settings: ${error.message ?: "restore failed"}")
+ }
+ } ?: skippedSections.add("Recording Storage Settings")
+
val outcome = if (failedSections.isEmpty()) BackupRestoreOutcome.COMPLETE else BackupRestoreOutcome.PARTIAL
checkpoint = checkpoint.copy(
state = if (outcome == BackupRestoreOutcome.COMPLETE) RESTORE_STATE_COMPLETE else RESTORE_STATE_PARTIAL,
@@ -974,6 +1153,7 @@ class BackupManagerImpl @Inject constructor(
)
writeNamedJsonField(jsonWriter, "protectedCategories", backupData.protectedCategories, PROTECTED_CATEGORY_LIST_TYPE)
writeNamedJsonField(jsonWriter, "scheduledRecordings", backupData.scheduledRecordings, SCHEDULED_RECORDING_LIST_TYPE)
+ writeNamedJsonField(jsonWriter, "recordingStorage", backupData.recordingStorage, RECORDING_STORAGE_TYPE)
writeNamedJsonField(
jsonWriter,
"portableProviderPreferences",
@@ -981,6 +1161,36 @@ class BackupManagerImpl @Inject constructor(
PortableProviderPreferencesBackup::class.java
)
writeNamedJsonField(jsonWriter, "epgSources", backupData.epgSources, EPG_SOURCE_LIST_TYPE)
+ writeNamedJsonField(
+ jsonWriter,
+ "providerEpgAssignments",
+ backupData.providerEpgAssignments,
+ PROVIDER_EPG_ASSIGNMENT_LIST_TYPE
+ )
+ writeNamedJsonField(
+ jsonWriter,
+ "manualEpgMappings",
+ backupData.manualEpgMappings,
+ MANUAL_EPG_MAPPING_LIST_TYPE
+ )
+ writeNamedJsonField(
+ jsonWriter,
+ "m3uClassificationOverrides",
+ backupData.m3uClassificationOverrides,
+ M3U_CLASSIFICATION_OVERRIDE_LIST_TYPE
+ )
+ writeNamedJsonField(
+ jsonWriter,
+ "m3uClassificationRules",
+ backupData.m3uClassificationRules,
+ M3U_CLASSIFICATION_RULE_LIST_TYPE
+ )
+ writeNamedJsonField(
+ jsonWriter,
+ "programReminders",
+ backupData.programReminders,
+ PROGRAM_REMINDER_LIST_TYPE
+ )
writeNamedJsonField(
jsonWriter,
"combinedM3uProfiles",
@@ -1092,8 +1302,14 @@ class BackupManagerImpl @Inject constructor(
var portableMultiViewPresets: Map<String, List<PortableChannelReference>>? = null
var protectedCategories: List<ProtectedCategoryBackup>? = null
var scheduledRecordings: List<ScheduledRecordingBackup>? = null
+ var recordingStorage: RecordingStorageBackup? = null
var portableProviderPreferences: PortableProviderPreferencesBackup? = null
var epgSources: List<com.streamvault.domain.model.EpgSource>? = null
+ var providerEpgAssignments: List<ProviderEpgAssignmentBackup>? = null
+ var manualEpgMappings: List<ManualEpgMappingBackup>? = null
+ var m3uClassificationOverrides: List<M3uClassificationOverrideBackup>? = null
+ var m3uClassificationRules: List<M3uClassificationRuleBackup>? = null
+ var programReminders: List<ProgramReminderBackup>? = null
var combinedM3uProfiles: List<CombinedM3uProfileBackup>? = null
var activeLiveSource: ActiveLiveSourceBackup? = null
val seenFields = hashSetOf<String>()
@@ -1143,10 +1359,47 @@ class BackupManagerImpl @Inject constructor(
readLimitedArray(reader, PROTECTED_CATEGORY_TYPE, MAX_SECTION_ITEMS, "protected categories")
"scheduledRecordings" -> scheduledRecordings =
readLimitedArray(reader, SCHEDULED_RECORDING_TYPE, MAX_SECTION_ITEMS, "recording schedules")
+ "recordingStorage" -> recordingStorage =
+ readLegacyAwareValue(reader, RECORDING_STORAGE_TYPE)
"portableProviderPreferences" -> portableProviderPreferences =
readPortableProviderPreferences(reader)
"epgSources" -> epgSources =
readLimitedArray(reader, EPG_SOURCE_TYPE, MAX_EPG_SOURCES, "EPG sources")
+ "providerEpgAssignments" -> providerEpgAssignments =
+ readLimitedArray(
+ reader,
+ PROVIDER_EPG_ASSIGNMENT_TYPE,
+ MAX_SECTION_ITEMS,
+ "provider EPG assignments"
+ )
+ "manualEpgMappings" -> manualEpgMappings =
+ readLimitedArray(
+ reader,
+ MANUAL_EPG_MAPPING_TYPE,
+ MAX_SECTION_ITEMS,
+ "manual EPG mappings"
+ )
+ "m3uClassificationOverrides" -> m3uClassificationOverrides =
+ readLimitedArray(
+ reader,
+ M3U_CLASSIFICATION_OVERRIDE_TYPE,
+ MAX_SECTION_ITEMS,
+ "M3U classification overrides"
+ )
+ "m3uClassificationRules" -> m3uClassificationRules =
+ readLimitedArray(
+ reader,
+ M3U_CLASSIFICATION_RULE_TYPE,
+ MAX_SECTION_ITEMS,
+ "M3U classification rules"
+ )
+ "programReminders" -> programReminders =
+ readLimitedArray(
+ reader,
+ PROGRAM_REMINDER_TYPE,
+ MAX_SECTION_ITEMS,
+ "program reminders"
+ )
"combinedM3uProfiles" -> combinedM3uProfiles =
readLimitedArray(
reader,
@@ -1188,7 +1441,13 @@ class BackupManagerImpl @Inject constructor(
protectedCategories = protectedCategories,
scheduledRecordings = scheduledRecordings,
portableProviderPreferences = portableProviderPreferences,
+ recordingStorage = recordingStorage,
epgSources = epgSources,
+ providerEpgAssignments = providerEpgAssignments,
+ manualEpgMappings = manualEpgMappings,
+ m3uClassificationOverrides = m3uClassificationOverrides,
+ m3uClassificationRules = m3uClassificationRules,
+ programReminders = programReminders,
combinedM3uProfiles = combinedM3uProfiles,
activeLiveSource = activeLiveSource
)
@@ -1242,27 +1501,43 @@ class BackupManagerImpl @Inject constructor(
PROVIDER_SNAPSHOT_TYPE -> listOf(
"provider", "accountRuntime", "xtreamConfig", "m3uConfig", "stalkerConfig", "jellyfinConfig"
)
- BACKUP_PROVIDER_REFERENCE_TYPE -> listOf("serverUrl", "username", "stalkerMacAddress")
+ PROVIDER_CREDENTIALS_TYPE -> listOf("serverUrl", "username", "password", "providerType")
+ BACKUP_PROVIDER_REFERENCE_TYPE -> listOf("serverUrl", "username", "stalkerMacAddress", "providerType")
PORTABLE_CATEGORY_REFERENCE_TYPE -> listOf("provider", "name", "type", "remoteCategoryId")
PORTABLE_CATEGORY_SORT_REFERENCE_TYPE -> listOf("provider", "type", "mode")
PORTABLE_GROUP_REFERENCE_TYPE -> listOf("provider", "name", "contentType")
PORTABLE_CHANNEL_REFERENCE_TYPE -> listOf("provider", "streamId", "name", "streamUrl")
PORTABLE_CHANNEL_PREFERENCE_REFERENCE_TYPE -> listOf("channel", "aspectRatio", "audioVideoOffsetMs")
PORTABLE_EPG_TIME_SHIFT_REFERENCE_TYPE -> listOf("provider", "minutes")
- PORTABLE_VARIANT_SELECTION_REFERENCE_TYPE -> listOf("provider", "logicalGroupId", "rawItemId")
+ PORTABLE_VARIANT_SELECTION_REFERENCE_TYPE -> listOf(
+ "provider", "logicalGroupId", "rawItemId", "remoteItemId", "contentType"
+ )
COMBINED_M3U_PROFILE_TYPE -> listOf("name", "enabled", "members", "createdAt", "updatedAt")
ACTIVE_LIVE_SOURCE_BACKUP_TYPE -> listOf(
"type", "provider", "combinedProfileName", "combinedProfileProviders"
)
PROTECTED_CATEGORY_TYPE -> listOf(
"providerServerUrl", "providerUsername", "providerStalkerMacAddress",
- "categoryId", "categoryName", "type"
+ "categoryId", "categoryName", "type", "providerType"
)
SCHEDULED_RECORDING_TYPE -> listOf(
"providerServerUrl", "providerUsername", "providerStalkerMacAddress", "channelId",
"channelName", "streamUrl", "scheduledStartMs", "scheduledEndMs", "requestedStartMs",
"requestedEndMs", "paddingBeforeMs", "paddingAfterMs", "programTitle", "recurrence",
- "recurringRuleId"
+ "recurringRuleId", "providerType"
+ )
+ RECORDING_STORAGE_TYPE -> listOf("fileNamePattern", "retentionDays", "maxSimultaneousRecordings")
+ PROVIDER_EPG_ASSIGNMENT_TYPE -> listOf("provider", "sourceUrl", "priority", "enabled")
+ MANUAL_EPG_MAPPING_TYPE -> listOf(
+ "channel", "sourceUrl", "xmltvChannelId", "sourceType", "matchType", "confidence", "source"
+ )
+ M3U_CLASSIFICATION_OVERRIDE_TYPE -> listOf(
+ "provider", "sourceKey", "streamId", "targetType", "groupKey", "seriesKey", "seriesName",
+ "seasonNumber", "episodeNumber", "episodeTitle"
+ )
+ M3U_CLASSIFICATION_RULE_TYPE -> listOf("provider", "groupKey", "targetType")
+ PROGRAM_REMINDER_TYPE -> listOf(
+ "provider", "channelId", "channelName", "programTitle", "programStartTime", "leadTimeMinutes"
)
else -> return element
}
@@ -1497,6 +1772,9 @@ class BackupManagerImpl @Inject constructor(
var unresolvedReferences = emptyList<String>()
var channelPreferences = emptyList<PortableChannelPreferenceReference>()
var channelPreferencesSpecified = false
+ var homeDefaultCategory: PortableCategoryReference? = null
+ var homeDefaultVirtualCategoryId: Long? = null
+ var homeDefaultCategorySpecified = false
val seenFields = hashSetOf<String>()
reader.beginObject()
@@ -1600,6 +1878,10 @@ class BackupManagerImpl @Inject constructor(
"channel preferences"
).orEmpty()
"channelPreferencesSpecified", "u" -> channelPreferencesSpecified = reader.nextBoolean()
+ "homeDefaultCategory", "v" -> homeDefaultCategory =
+ readLegacyAwareValue(reader, PORTABLE_CATEGORY_REFERENCE_TYPE)
+ "homeDefaultVirtualCategoryId", "w" -> homeDefaultVirtualCategoryId = reader.nextNullableLong()
+ "homeDefaultCategorySpecified", "x" -> homeDefaultCategorySpecified = reader.nextBoolean()
"i" -> {
val element = gson.fromJson<JsonElement>(reader, JsonElement::class.java)
if (element?.isJsonArray == true && element.asJsonArray.any { it.isJsonObject }) {
@@ -1643,7 +1925,10 @@ class BackupManagerImpl @Inject constructor(
vodVariantSelectionsSpecified = vodVariantSelectionsSpecified,
unresolvedReferences = unresolvedReferences,
channelPreferences = channelPreferences,
- channelPreferencesSpecified = channelPreferencesSpecified
+ channelPreferencesSpecified = channelPreferencesSpecified,
+ homeDefaultCategory = homeDefaultCategory,
+ homeDefaultVirtualCategoryId = homeDefaultVirtualCategoryId,
+ homeDefaultCategorySpecified = homeDefaultCategorySpecified
)
}
@@ -1674,6 +1959,21 @@ class BackupManagerImpl @Inject constructor(
"Backup has too many channel preferences"
}
require(data.epgSources.orEmpty().size <= MAX_EPG_SOURCES) { "Backup has too many EPG sources" }
+ require(data.providerEpgAssignments.orEmpty().size <= MAX_SECTION_ITEMS) {
+ "Backup has too many provider EPG assignments"
+ }
+ require(data.manualEpgMappings.orEmpty().size <= MAX_SECTION_ITEMS) {
+ "Backup has too many manual EPG mappings"
+ }
+ require(data.m3uClassificationOverrides.orEmpty().size <= MAX_SECTION_ITEMS) {
+ "Backup has too many M3U classification overrides"
+ }
+ require(data.m3uClassificationRules.orEmpty().size <= MAX_SECTION_ITEMS) {
+ "Backup has too many M3U classification rules"
+ }
+ require(data.programReminders.orEmpty().size <= MAX_SECTION_ITEMS) {
+ "Backup has too many program reminders"
+ }
require(data.multiViewPresets.orEmpty().values.sumOf { it.size } <= MAX_SECTION_ITEMS) { "Backup has too many preset entries" }
require(data.portableMultiViewPresets.orEmpty().values.sumOf { it.size } <= MAX_SECTION_ITEMS) {
"Backup has too many portable preset entries"
@@ -1775,10 +2075,11 @@ class BackupManagerImpl @Inject constructor(
}
}
- private fun Map<String, Long>.toPortableVariantSelections(
+ private suspend fun Map<String, Long>.toPortableVariantSelections(
referencesById: Map<Long, BackupProviderReference>,
unresolved: MutableList<String>,
- label: String
+ label: String,
+ contentType: ContentType
): List<PortableVariantSelectionReference> = mapNotNull { (key, rawItemId) ->
val separator = key.indexOf('|')
val providerId = key.substringBefore('|').toLongOrNull()
@@ -1787,12 +2088,46 @@ class BackupManagerImpl @Inject constructor(
unresolved += "$label variant selection '$key' is malformed"
return@mapNotNull null
}
- referencesById[providerId]?.let { provider ->
- PortableVariantSelectionReference(provider, logicalGroupId, rawItemId)
- } ?: run {
+ val provider = referencesById[providerId]
+ if (provider == null) {
unresolved += "$label variant selection provider $providerId was not found during export"
- null
+ return@mapNotNull null
+ }
+ val resolvedVariant = when (contentType) {
+ ContentType.LIVE -> channelDao.getById(rawItemId)
+ ?.takeIf { it.providerId == providerId }
+ ?.streamId
+ ?.takeIf { it > 0L }
+ ?.toString()
+ ?.let { it to ContentType.LIVE }
+ ContentType.MOVIE -> movieDao.getById(rawItemId)
+ ?.takeIf { it.providerId == providerId }
+ ?.streamId
+ ?.takeIf { it > 0L }
+ ?.toString()
+ ?.let { it to ContentType.MOVIE }
+ ?: seriesDao.getById(rawItemId)
+ ?.takeIf { it.providerId == providerId }
+ ?.remoteKey()
+ ?.let { it to ContentType.SERIES }
+ ContentType.SERIES -> seriesDao.getById(rawItemId)
+ ?.takeIf { it.providerId == providerId }
+ ?.remoteKey()
+ ?.let { it to ContentType.SERIES }
+ ContentType.SERIES_EPISODE,
+ ContentType.VOD -> null
+ }
+ if (resolvedVariant == null) {
+ unresolved += "$label variant selection $key could not be resolved during export"
+ return@mapNotNull null
}
+ PortableVariantSelectionReference(
+ provider = provider,
+ logicalGroupId = logicalGroupId,
+ rawItemId = rawItemId,
+ remoteItemId = resolvedVariant.first,
+ contentType = resolvedVariant.second
+ )
}
internal suspend fun buildPortableProviderPreferences(
@@ -1851,6 +2186,30 @@ class BackupManagerImpl @Inject constructor(
unresolved += "Guide category id $guideId was not found unambiguously during export"
}
}
+ val homeDefaultId = preferencesRepository.defaultCategoryId.first()
+ val homeDefaultCategory = homeDefaultId
+ ?.takeUnless { it in PORTABLE_VIRTUAL_CATEGORY_IDS }
+ ?.let { categoryId ->
+ val preferredProvider = activeProviderId?.let(categoriesByProvider::get)
+ ?.filter { it.id == categoryId }
+ ?.singleOrNull()
+ val matches = categoriesByProvider.entries.mapNotNull { (providerId, categories) ->
+ categories.firstOrNull { it.id == categoryId }?.let { providerId to it }
+ }
+ val match = preferredProvider ?: matches.singleOrNull()?.second
+ val providerId = if (preferredProvider != null) activeProviderId else matches.singleOrNull()?.first
+ providerId?.let { id ->
+ match?.let { category ->
+ referencesById[id]?.let { provider ->
+ PortableCategoryReference(provider, category.name, category.type, category.id)
+ }
+ }
+ }
+ }.also { reference ->
+ if (homeDefaultId != null && homeDefaultId !in PORTABLE_VIRTUAL_CATEGORY_IDS && reference == null) {
+ unresolved += "Home default category id $homeDefaultId was not found unambiguously during export"
+ }
+ }
val promotedGroups = preferencesRepository.promotedLiveGroupIds.first().mapNotNull { groupId ->
virtualGroupDao.getById(groupId)?.let { group ->
referencesById[group.providerId]?.let { provider ->
@@ -1926,10 +2285,10 @@ class BackupManagerImpl @Inject constructor(
}
val liveVariantSelections = (preferencesRepository.liveVariantSelections ?: flowOf(emptyMap()))
.first()
- .toPortableVariantSelections(referencesById, unresolved, "Live")
+ .toPortableVariantSelections(referencesById, unresolved, "Live", ContentType.LIVE)
val vodVariantSelections = (preferencesRepository.vodVariantSelections ?: flowOf(emptyMap()))
.first()
- .toPortableVariantSelections(referencesById, unresolved, "VOD")
+ .toPortableVariantSelections(referencesById, unresolved, "VOD", ContentType.MOVIE)
val channelPreferences = channelPreferenceDao?.getAllSync().orEmpty().mapNotNull { preference ->
val channel = channels.getById(preference.channelId)
val provider = channel?.let { referencesById[it.providerId] }
@@ -1974,7 +2333,10 @@ class BackupManagerImpl @Inject constructor(
vodVariantSelectionsSpecified = true,
unresolvedReferences = unresolved.distinct(),
channelPreferences = channelPreferences.distinct(),
- channelPreferencesSpecified = channelPreferenceDao != null
+ channelPreferencesSpecified = channelPreferenceDao != null,
+ homeDefaultCategory = homeDefaultCategory,
+ homeDefaultVirtualCategoryId = homeDefaultId?.takeIf { it in PORTABLE_VIRTUAL_CATEGORY_IDS },
+ homeDefaultCategorySpecified = homeDefaultId != null
)
}
@@ -2002,7 +2364,8 @@ class BackupManagerImpl @Inject constructor(
val hydratedProviders = projectedProviders.map { provider ->
val credentials = providerCredentials.orEmpty().firstOrNull { credential ->
normalizeProviderServerUrl(credential.serverUrl) == normalizeProviderServerUrl(provider.serverUrl) &&
- credential.username.trim() == provider.username.trim()
+ credential.username.trim() == provider.username.trim() &&
+ (credential.providerType == null || credential.providerType == provider.type)
}
if (credentials == null || provider.password.isNotBlank()) {
provider
@@ -2032,7 +2395,13 @@ class BackupManagerImpl @Inject constructor(
protectedCategories.isNullOrEmpty() &&
scheduledRecordings.isNullOrEmpty() &&
portableProviderPreferences == null &&
+ recordingStorage == null &&
epgSources.isNullOrEmpty() &&
+ providerEpgAssignments.isNullOrEmpty() &&
+ manualEpgMappings.isNullOrEmpty() &&
+ m3uClassificationOverrides.isNullOrEmpty() &&
+ m3uClassificationRules.isNullOrEmpty() &&
+ programReminders.isNullOrEmpty() &&
combinedM3uProfiles.isNullOrEmpty() &&
activeLiveSource == null
@@ -2214,21 +2583,26 @@ class BackupManagerImpl @Inject constructor(
): List<String> {
val unresolved = mutableListOf<String>()
listOf("preset_1", "preset_2", "preset_3").forEachIndexed { index, presetName ->
+ val presetUnresolved = mutableListOf<String>()
val channelIds = presets[presetName].orEmpty().mapNotNull { reference ->
val provider = storedProviders.findUnambiguousPortableProvider(reference.provider)
if (provider == null) {
- unresolved += reference.unresolvedLabel("Split-screen channel provider")
+ presetUnresolved += reference.unresolvedLabel("Split-screen channel provider")
return@mapNotNull null
}
channelDao.getByProviderSync(provider.id)
.resolvePortableChannel(reference)
?.id
?: run {
- unresolved += reference.unresolvedLabel("Split-screen channel")
+ presetUnresolved += reference.unresolvedLabel("Split-screen channel")
null
}
}
- preferencesRepository.setMultiViewPreset(index, channelIds)
+ if (presetUnresolved.isEmpty()) {
+ preferencesRepository.setMultiViewPreset(index, channelIds)
+ } else {
+ unresolved += presetUnresolved
+ }
}
return unresolved.distinct()
}
@@ -2282,53 +2656,94 @@ class BackupManagerImpl @Inject constructor(
val reference = guideCategoryReference
val provider = resolveProvider(reference.provider)
categories[provider?.id].orEmpty()
- .resolvePortableCategory(reference)
- ?.let { preferencesRepository.setGuideDefaultCategoryId(it.id) }
+ .resolvePortableCategoryId(reference)
+ ?.let { preferencesRepository.setGuideDefaultCategoryId(it) }
?: run { unresolved += reference.unresolvedLabel("Guide category") }
}
!portable.guideDefaultCategorySpecified ->
preferencesRepository.clearGuideDefaultCategoryId()
}
+ when {
+ portable.homeDefaultVirtualCategoryId != null -> {
+ val virtualCategoryId = portable.homeDefaultVirtualCategoryId
+ preferencesRepository.setDefaultCategory(virtualCategoryId!!)
+ }
+ portable.homeDefaultCategory != null -> {
+ val reference = portable.homeDefaultCategory!!
+ val provider = resolveProvider(reference.provider)
+ categories[provider?.id].orEmpty()
+ .resolvePortableCategoryId(reference)
+ ?.let { categoryId -> preferencesRepository.setDefaultCategory(categoryId) }
+ ?: run { unresolved.add(reference.unresolvedLabel("Home default category")) }
+ }
+ }
+ var promotedCanApply = true
val promoted = portable.promotedLiveGroups.mapNotNull { reference ->
- val provider = resolveProvider(reference.provider) ?: return@mapNotNull null
+ val provider = resolveProvider(reference.provider)
+ if (provider == null) {
+ promotedCanApply = false
+ unresolved += reference.unresolvedLabel("Group provider")
+ return@mapNotNull null
+ }
virtualGroupDao.getByType(provider.id, reference.contentType.name).first()
.filter { it.name.equals(reference.name, true) }.singleOrNull()?.id
- ?: run { unresolved += reference.unresolvedLabel("Group"); null }
+ ?: run {
+ promotedCanApply = false
+ unresolved += reference.unresolvedLabel("Group")
+ null
+ }
}.toSet()
- preferencesRepository.setPromotedLiveGroupIds(promoted)
+ if (promotedCanApply) {
+ preferencesRepository.setPromotedLiveGroupIds(promoted)
+ }
resolvedProviders.forEach { (reference, provider) ->
val matchingChannels = portable.hiddenChannels.filter { it.provider == reference }
val providerChannels = channels.getByProviderSync(provider.id)
+ val hiddenChannelUnresolved = mutableListOf<String>()
val channelIds = matchingChannels.mapNotNull { requested ->
providerChannels.resolvePortableChannel(requested)?.id
?: run {
- unresolved += requested.unresolvedLabel("Hidden channel")
+ hiddenChannelUnresolved += requested.unresolvedLabel("Hidden channel")
null
}
}.toSet()
- preferencesRepository.setHiddenChannelIds(provider.id, channelIds)
+ if (hiddenChannelUnresolved.isEmpty()) {
+ preferencesRepository.setHiddenChannelIds(provider.id, channelIds)
+ } else {
+ unresolved += hiddenChannelUnresolved
+ }
ContentType.entries.forEach { type ->
val requested = portable.hiddenCategories.filter { it.provider == reference && it.type == type }
+ val categoryUnresolved = mutableListOf<String>()
val ids = requested.mapNotNull { categoryReference ->
- categories[provider.id].orEmpty().resolvePortableCategory(categoryReference)?.id
+ categories[provider.id].orEmpty().resolvePortableCategoryId(categoryReference)
?: run {
- unresolved += categoryReference.unresolvedLabel("Hidden ${type.name} category")
+ categoryUnresolved += categoryReference.unresolvedLabel("Hidden ${type.name} category")
null
}
}.toSet()
- preferencesRepository.setHiddenCategoryIds(provider.id, type, ids)
+ if (categoryUnresolved.isEmpty()) {
+ preferencesRepository.setHiddenCategoryIds(provider.id, type, ids)
+ } else {
+ unresolved += categoryUnresolved
+ }
}
if (portable.pinnedCategoriesSpecified) {
ContentType.entries.forEach { type ->
val requested = portable.pinnedCategories.filter { it.provider == reference && it.type == type }
+ val categoryUnresolved = mutableListOf<String>()
val ids = requested.mapNotNull { categoryReference ->
- categories[provider.id].orEmpty().resolvePortableCategory(categoryReference)?.id
+ categories[provider.id].orEmpty().resolvePortableCategoryId(categoryReference)
?: run {
- unresolved += categoryReference.unresolvedLabel("Pinned ${type.name} category")
+ categoryUnresolved += categoryReference.unresolvedLabel("Pinned ${type.name} category")
null
}
}.toSet()
- preferencesRepository.setPinnedCategoryIds(provider.id, type, ids)
+ if (categoryUnresolved.isEmpty()) {
+ preferencesRepository.setPinnedCategoryIds(provider.id, type, ids)
+ } else {
+ unresolved += categoryUnresolved
+ }
}
}
if (portable.categorySortModesSpecified) {
@@ -2350,18 +2765,38 @@ class BackupManagerImpl @Inject constructor(
}
if (portable.liveVariantSelectionsSpecified) {
resolvedProviders.forEach { (reference, provider) ->
- val selections = portable.liveVariantSelections
- .filter { it.provider == reference }
- .associate { it.logicalGroupId to it.rawItemId }
- preferencesRepository.replacePreferredLiveVariants(provider.id, selections)
+ val providerSelections = portable.liveVariantSelections.filter { it.provider == reference }
+ val unresolvedForProvider = mutableListOf<String>()
+ val selections = providerSelections.mapNotNull { selection ->
+ val rawItemId = resolvePortableVariantItemId(selection, ContentType.LIVE, provider.id)
+ rawItemId?.let { selection.logicalGroupId to it } ?: run {
+ unresolvedForProvider += selection.unresolvedLabel("Live variant selection")
+ null
+ }
+ }.toMap()
+ if (unresolvedForProvider.isEmpty()) {
+ preferencesRepository.replacePreferredLiveVariants(provider.id, selections)
+ } else {
+ unresolved += unresolvedForProvider
+ }
}
}
if (portable.vodVariantSelectionsSpecified) {
resolvedProviders.forEach { (reference, provider) ->
- val selections = portable.vodVariantSelections
- .filter { it.provider == reference }
- .associate { it.logicalGroupId to it.rawItemId }
- preferencesRepository.replacePreferredVodVariants(provider.id, selections)
+ val providerSelections = portable.vodVariantSelections.filter { it.provider == reference }
+ val unresolvedForProvider = mutableListOf<String>()
+ val selections = providerSelections.mapNotNull { selection ->
+ val rawItemId = resolvePortableVariantItemId(selection, ContentType.MOVIE, provider.id)
+ rawItemId?.let { selection.logicalGroupId to it } ?: run {
+ unresolvedForProvider += selection.unresolvedLabel("VOD variant selection")
+ null
+ }
+ }.toMap()
+ if (unresolvedForProvider.isEmpty()) {
+ preferencesRepository.replacePreferredVodVariants(provider.id, selections)
+ } else {
+ unresolved += unresolvedForProvider
+ }
}
}
if (portable.channelPreferencesSpecified) {
@@ -2388,13 +2823,34 @@ class BackupManagerImpl @Inject constructor(
)
}
}
- preferenceDao.deleteAll()
- resolvedPreferences.forEach { preference -> preferenceDao.upsert(preference) }
+ val preferenceReferenceCount = portable.channelPreferences.size
+ val unresolvedPreferenceCount = unresolved.count { it.startsWith("Channel playback preference") }
+ if (unresolvedPreferenceCount == 0 && resolvedPreferences.size == preferenceReferenceCount) {
+ preferenceDao.deleteAll()
+ resolvedPreferences.forEach { preference -> preferenceDao.upsert(preference) }
+ }
}
}
return unresolved.distinct()
}
+ private suspend fun resolvePortableVariantItemId(
+ selection: PortableVariantSelectionReference,
+ defaultType: ContentType,
+ providerId: Long
+ ): Long? {
+ val remoteItemId = selection.remoteItemId ?: return selection.rawItemId.takeIf { it > 0L }
+ return when (selection.contentType ?: defaultType) {
+ ContentType.LIVE -> remoteItemId.toLongOrNull()
+ ?.let { channelDao.getByStreamId(providerId, it)?.id }
+ ContentType.MOVIE -> remoteItemId.toLongOrNull()
+ ?.let { movieDao.getByStreamId(providerId, it)?.id }
+ ContentType.SERIES -> resolveSeries(providerId, remoteItemId)?.id
+ ContentType.SERIES_EPISODE,
+ ContentType.VOD -> null
+ }
+ }
+
private suspend fun restorePreferences(
prefs: Map<String, String>,
skipProviderScopedReferences: Boolean = false
@@ -2743,8 +3199,7 @@ class BackupManagerImpl @Inject constructor(
private suspend fun restoreRoomBackedSections(
backupData: BackupData,
plan: BackupImportPlan,
- initialStoredProviders: List<Provider>,
- onRoomCommitted: suspend () -> Unit = {}
+ initialStoredProviders: List<Provider>
): RoomRestoreResult {
if (!plan.importProviders && !plan.importSavedLibrary && !plan.importPlaybackHistory) {
return RoomRestoreResult(
@@ -2769,11 +3224,13 @@ class BackupManagerImpl @Inject constructor(
if (plan.importProviders) {
backupData.providers?.let { providers ->
providers.forEach { provider ->
- val existing = storedProviders.findMatchingProvider(
- serverUrl = provider.serverUrl,
- username = provider.username,
- stalkerMacAddress = provider.stalkerMacAddress
- )
+ val existing = storedProviders
+ .filter { it.type == provider.type }
+ .findMatchingProvider(
+ serverUrl = provider.serverUrl,
+ username = provider.username,
+ stalkerMacAddress = provider.stalkerMacAddress
+ )
if (existing != null && plan.conflictStrategy == BackupConflictStrategy.KEEP_EXISTING) {
return@forEach
}
@@ -2825,9 +3282,13 @@ class BackupManagerImpl @Inject constructor(
provider.status
}
)
- val restoredId = providerDao.insert(
- restoredProvider.toSecureEntityForBackup(credentialCrypto)
- )
+ val restoredEntity = restoredProvider.toSecureEntityForBackup(credentialCrypto)
+ val restoredId = if (existing == null) {
+ providerDao.insert(restoredEntity)
+ } else {
+ providerDao.update(restoredEntity)
+ existing.id
+ }
persistRestoredProvider(restoredId, restoredProvider.copy(id = restoredId))
}
storedProviders = loadStoredProviders()
@@ -2874,10 +3335,61 @@ class BackupManagerImpl @Inject constructor(
importedSections += "EPG Sources"
}
}
+ backupData.providerEpgAssignments?.let { assignments ->
+ unresolvedReferences += restoreProviderEpgAssignments(
+ assignments = assignments,
+ backupProviders = backupData.providers.orEmpty(),
+ storedProviders = storedProviders,
+ conflictStrategy = plan.conflictStrategy
+ )
+ importedSections += "Provider EPG Assignments"
+ }
+ backupData.manualEpgMappings?.let { mappings ->
+ unresolvedReferences += restoreManualEpgMappings(
+ mappings = mappings,
+ backupProviders = backupData.providers.orEmpty(),
+ storedProviders = storedProviders,
+ conflictStrategy = plan.conflictStrategy
+ )
+ importedSections += "Manual EPG Mappings"
+ }
+ backupData.m3uClassificationOverrides?.let { overrides ->
+ unresolvedReferences += restoreM3uClassification(
+ overrides = overrides,
+ rules = backupData.m3uClassificationRules.orEmpty(),
+ backupProviders = backupData.providers.orEmpty(),
+ storedProviders = storedProviders,
+ conflictStrategy = plan.conflictStrategy
+ )
+ importedSections += "M3U Classification"
+ } ?: backupData.m3uClassificationRules?.let { rules ->
+ unresolvedReferences += restoreM3uClassification(
+ overrides = emptyList(),
+ rules = rules,
+ backupProviders = backupData.providers.orEmpty(),
+ storedProviders = storedProviders,
+ conflictStrategy = plan.conflictStrategy
+ )
+ importedSections += "M3U Classification"
+ }
+ backupData.programReminders?.let { reminders ->
+ unresolvedReferences += restoreProgramReminders(
+ reminders = reminders,
+ storedProviders = storedProviders,
+ conflictStrategy = plan.conflictStrategy
+ )
+ importedSections += "Program Reminders"
+ }
} else {
skippedSections += "Providers"
if (backupData.combinedM3uProfiles != null) skippedSections += "Combined M3U Profiles"
if (!backupData.epgSources.isNullOrEmpty()) skippedSections += "EPG Sources"
+ if (backupData.providerEpgAssignments != null) skippedSections += "Provider EPG Assignments"
+ if (backupData.manualEpgMappings != null) skippedSections += "Manual EPG Mappings"
+ if (backupData.m3uClassificationOverrides != null || backupData.m3uClassificationRules != null) {
+ skippedSections += "M3U Classification"
+ }
+ if (backupData.programReminders != null) skippedSections += "Program Reminders"
}
if (plan.importSavedLibrary) {
@@ -2904,7 +3416,6 @@ class BackupManagerImpl @Inject constructor(
} else {
skippedSections += "Playback History"
}
- onRoomCommitted()
}
return RoomRestoreResult(
@@ -2915,6 +3426,222 @@ class BackupManagerImpl @Inject constructor(
)
}
+ private suspend fun restoreProviderEpgAssignments(
+ assignments: List<ProviderEpgAssignmentBackup>,
+ backupProviders: List<Provider>,
+ storedProviders: List<Provider>,
+ conflictStrategy: BackupConflictStrategy
+ ): List<String> {
+ val assignmentDao = providerEpgSourceDao
+ ?: return listOf("Provider EPG assignment storage is unavailable")
+ val sourceDao = epgSourceDao
+ ?: return listOf("EPG source storage is unavailable for provider assignments")
+ val unresolved = mutableListOf<String>()
+ val byProvider = assignments.groupBy { it.provider }
+ val providerReferences = (byProvider.keys + backupProviders.map { it.toBackupProviderReference() }).distinct()
+ providerReferences.forEach { reference ->
+ val provider = storedProviders.findUnambiguousPortableProvider(reference)
+ if (provider == null) {
+ if (byProvider[reference].orEmpty().isNotEmpty()) {
+ unresolved += reference.unresolvedLabel("Provider EPG assignment provider")
+ }
+ return@forEach
+ }
+ val resolved = mutableListOf<ProviderEpgSourceEntity>()
+ var providerComplete = true
+ byProvider[reference].orEmpty().forEach { assignment ->
+ val source = sourceDao.getByUrl(assignment.sourceUrl)
+ if (source == null) {
+ providerComplete = false
+ unresolved += "EPG source ${assignment.sourceUrl} was not found for ${reference.serverUrl}"
+ } else {
+ resolved += ProviderEpgSourceEntity(
+ providerId = provider.id,
+ epgSourceId = source.id,
+ priority = assignment.priority,
+ enabled = assignment.enabled
+ )
+ }
+ }
+ if (!providerComplete && conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) return@forEach
+ if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ assignmentDao.deleteByProvider(provider.id)
+ }
+ resolved.forEach { assignmentDao.insert(it) }
+ }
+ return unresolved
+ }
+
+ private suspend fun restoreManualEpgMappings(
+ mappings: List<ManualEpgMappingBackup>,
+ backupProviders: List<Provider>,
+ storedProviders: List<Provider>,
+ conflictStrategy: BackupConflictStrategy
+ ): List<String> {
+ val mappingDao = channelEpgMappingDao
+ ?: return listOf("Manual EPG mapping storage is unavailable")
+ val sourceDao = epgSourceDao
+ ?: return listOf("EPG source storage is unavailable for manual mappings")
+ val unresolved = mutableListOf<String>()
+ val byProvider = mappings.groupBy { it.channel.provider }
+ val providerReferences = (byProvider.keys + backupProviders.map { it.toBackupProviderReference() }).distinct()
+ providerReferences.forEach { reference ->
+ val provider = storedProviders.findUnambiguousPortableProvider(reference)
+ if (provider == null) {
+ if (byProvider[reference].orEmpty().isNotEmpty()) {
+ unresolved += reference.unresolvedLabel("Manual EPG mapping provider")
+ }
+ return@forEach
+ }
+ val localChannels = channelDao.getByProviderSync(provider.id)
+ val resolved = mutableListOf<ChannelEpgMappingEntity>()
+ var providerComplete = true
+ byProvider[reference].orEmpty().forEach { mapping ->
+ val channel = localChannels.resolvePortableChannel(mapping.channel)
+ if (channel == null) {
+ providerComplete = false
+ unresolved += mapping.channel.unresolvedLabel("Manual EPG mapping channel")
+ return@forEach
+ }
+ val sourceId = mapping.sourceUrl?.let { sourceUrl ->
+ sourceDao.getByUrl(sourceUrl)?.id ?: run {
+ providerComplete = false
+ unresolved += "EPG source $sourceUrl was not found for manual mapping"
+ null
+ }
+ }
+ if (mapping.sourceUrl != null && sourceId == null) return@forEach
+ resolved += ChannelEpgMappingEntity(
+ providerChannelId = channel.id,
+ providerId = provider.id,
+ sourceType = mapping.sourceType,
+ epgSourceId = sourceId,
+ xmltvChannelId = mapping.xmltvChannelId,
+ matchType = mapping.matchType,
+ confidence = mapping.confidence,
+ source = mapping.source,
+ isManualOverride = true
+ )
+ }
+ if (providerComplete && conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ mappingDao.getForProvider(provider.id)
+ .filter { it.isManualOverride && it.providerChannelId !in resolved.map { item -> item.providerChannelId } }
+ .forEach { mappingDao.deleteForChannel(provider.id, it.providerChannelId) }
+ } else if (!providerComplete && conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ return@forEach
+ }
+ resolved.forEach { mappingDao.upsert(it) }
+ }
+ return unresolved
+ }
+
+ private suspend fun restoreM3uClassification(
+ overrides: List<M3uClassificationOverrideBackup>,
+ rules: List<M3uClassificationRuleBackup>,
+ backupProviders: List<Provider>,
+ storedProviders: List<Provider>,
+ conflictStrategy: BackupConflictStrategy
+ ): List<String> {
+ val classificationDao = m3uClassificationDao
+ ?: return listOf("M3U classification storage is unavailable")
+ val unresolved = mutableListOf<String>()
+ val providerReferences = (
+ overrides.map { it.provider } +
+ rules.map { it.provider } +
+ backupProviders.filter { it.type == ProviderType.M3U }.map { it.toBackupProviderReference() }
+ ).distinct()
+ val overridesByProvider = overrides.groupBy { it.provider }
+ val rulesByProvider = rules.groupBy { it.provider }
+ providerReferences.forEach { reference ->
+ val provider = storedProviders.findUnambiguousPortableProvider(reference)
+ if (provider == null) {
+ if (overridesByProvider[reference].orEmpty().isNotEmpty() || rulesByProvider[reference].orEmpty().isNotEmpty()) {
+ unresolved += reference.unresolvedLabel("M3U classification provider")
+ }
+ return@forEach
+ }
+ if (provider.type != ProviderType.M3U) {
+ unresolved += "${reference.unresolvedLabel("M3U classification provider")} is not an M3U provider"
+ return@forEach
+ }
+ if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ classificationDao.deleteOverridesByProvider(provider.id)
+ classificationDao.deleteCategoryRulesByProvider(provider.id)
+ }
+ overridesByProvider[reference].orEmpty().forEach { override ->
+ classificationDao.upsertOverride(
+ M3uClassificationOverrideEntity(
+ providerId = provider.id,
+ sourceKey = override.sourceKey,
+ streamId = override.streamId,
+ targetType = override.targetType,
+ groupKey = override.groupKey,
+ seriesKey = override.seriesKey,
+ seriesName = override.seriesName,
+ seasonNumber = override.seasonNumber,
+ episodeNumber = override.episodeNumber,
+ episodeTitle = override.episodeTitle
+ )
+ )
+ }
+ rulesByProvider[reference].orEmpty().forEach { rule ->
+ classificationDao.upsertCategoryRule(
+ M3uCategoryClassificationRuleEntity(
+ providerId = provider.id,
+ groupKey = rule.groupKey,
+ targetType = rule.targetType
+ )
+ )
+ }
+ }
+ return unresolved
+ }
+
+ private suspend fun restoreProgramReminders(
+ reminders: List<ProgramReminderBackup>,
+ storedProviders: List<Provider>,
+ conflictStrategy: BackupConflictStrategy
+ ): List<String> {
+ val reminderManager = programReminderManager
+ ?: return listOf("Program reminder storage is unavailable")
+ val unresolved = mutableListOf<String>()
+ reminders.forEach { reminder ->
+ val provider = storedProviders.findUnambiguousPortableProvider(reminder.provider)
+ if (provider == null) {
+ unresolved += reminder.provider.unresolvedLabel("Program reminder provider")
+ return@forEach
+ }
+ if (reminder.programStartTime <= System.currentTimeMillis()) return@forEach
+ if (conflictStrategy == BackupConflictStrategy.KEEP_EXISTING && reminderManager.isReminderScheduled(
+ providerId = provider.id,
+ channelId = reminder.channelId,
+ programTitle = reminder.programTitle,
+ programStartTime = reminder.programStartTime
+ )
+ ) {
+ return@forEach
+ }
+ when (val result = reminderManager.scheduleReminder(
+ providerId = provider.id,
+ channelId = reminder.channelId,
+ channelName = reminder.channelName,
+ program = Program(
+ channelId = reminder.channelId,
+ title = reminder.programTitle,
+ startTime = reminder.programStartTime,
+ endTime = reminder.programStartTime + 60_000L,
+ providerId = provider.id
+ ),
+ leadTimeMinutes = reminder.leadTimeMinutes
+ )) {
+ is Result.Success -> Unit
+ is Result.Error -> unresolved += "Program reminder '${reminder.programTitle}' could not be restored: ${result.message}"
+ Result.Loading -> unresolved += "Program reminder '${reminder.programTitle}' did not finish restoring"
+ }
+ }
+ return unresolved
+ }
+
private suspend fun restoreCombinedM3uProfiles(
profiles: List<CombinedM3uProfileBackup>,
activeLiveSource: ActiveLiveSourceBackup?,
@@ -3017,6 +3744,27 @@ class BackupManagerImpl @Inject constructor(
val unresolvedReferences = mutableListOf<String>()
val providerIdMap = resolveProviderIdMap(storedProviders, backupData.providers.orEmpty())
val groupIdMap = mutableMapOf<Long, Long>()
+ val blockedReplaceScopes = mutableSetOf<Pair<Long, ContentType>>()
+ if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ backupData.favorites.orEmpty().forEach { favorite ->
+ val resolvedProviderId = providerIdMap[favorite.providerId]
+ if (resolvedProviderId == null) return@forEach
+ val scope = resolvedProviderId to favorite.contentType
+ if (favorite.groupId != null && backupData.virtualGroups.orEmpty().none { it.id == favorite.groupId }) {
+ blockedReplaceScopes += scope
+ unresolvedReferences += "Favorite ${favorite.contentType} refers to missing group ${favorite.groupId}"
+ } else if (resolvePortableContentId(
+ providerId = resolvedProviderId,
+ contentType = favorite.contentType,
+ remoteContentId = favorite.remoteContentId,
+ legacyContentId = favorite.contentId
+ ) == null
+ ) {
+ blockedReplaceScopes += scope
+ unresolvedReferences += "Favorite ${favorite.contentType} ${favorite.remoteContentId} could not be matched"
+ }
+ }
+ }
if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
val replaceScopes = buildSet<Pair<Long, ContentType>> {
backupData.virtualGroups.orEmpty().forEach { group ->
@@ -3030,7 +3778,7 @@ class BackupManagerImpl @Inject constructor(
}
}
}
- replaceScopes.forEach { (providerId, contentType) ->
+ replaceScopes.filterNot { it in blockedReplaceScopes }.forEach { (providerId, contentType) ->
favoriteDao.deleteByProviderAndType(providerId, contentType.name)
if (backupData.virtualGroups != null) {
virtualGroupDao.deleteByProviderAndType(providerId, contentType.name)
@@ -3053,6 +3801,9 @@ class BackupManagerImpl @Inject constructor(
unresolvedReferences += "Group ${group.name} provider ${group.providerId} could not be matched"
return@forEach
}
+ if (resolvedProviderId to group.contentType in blockedReplaceScopes) {
+ return@forEach
+ }
val conflict = existingGroups.firstOrNull {
it.providerId == resolvedProviderId &&
it.name.equals(group.name, ignoreCase = true) &&
@@ -3076,6 +3827,9 @@ class BackupManagerImpl @Inject constructor(
unresolvedReferences += "Favorite provider ${favorite.providerId} could not be matched"
return@forEach
}
+ if (resolvedProviderId to favorite.contentType in blockedReplaceScopes) {
+ return@forEach
+ }
val resolvedGroupId = favorite.groupId?.let { groupId ->
groupIdMap[groupId] ?: run {
unresolvedReferences += "Favorite ${favorite.contentType} refers to missing group $groupId"
@@ -3113,12 +3867,20 @@ class BackupManagerImpl @Inject constructor(
}
val categoriesByProviderId = mutableMapOf<Long, List<com.streamvault.domain.model.Category>>()
+ val protectedByScope = mutableMapOf<Pair<Long, ContentType>, MutableSet<Long>>()
+ val blockedProtectionScopes = mutableSetOf<Pair<Long, ContentType>>()
backupData.protectedCategories?.forEach { protectedCategory ->
val provider = storedProviders.findMatchingProvider(
serverUrl = protectedCategory.providerServerUrl,
username = protectedCategory.providerUsername,
- stalkerMacAddress = protectedCategory.providerStalkerMacAddress
- ) ?: return@forEach
+ stalkerMacAddress = protectedCategory.providerStalkerMacAddress,
+ providerType = protectedCategory.providerType
+ )
+ if (provider == null) {
+ unresolvedReferences += "Protected category provider ${protectedCategory.providerServerUrl} was not found"
+ return@forEach
+ }
+ val scope = provider.id to protectedCategory.type
val categories = categoriesByProviderId.getOrPut(provider.id) {
categoryRepository.getCategories(provider.id).first()
}
@@ -3129,17 +3891,40 @@ class BackupManagerImpl @Inject constructor(
it.name.equals(protectedCategory.categoryName, ignoreCase = true)
}
if (resolvedCategory == null) {
+ blockedProtectionScopes += scope
+ unresolvedReferences += "Protected category '${protectedCategory.categoryName}' was not found for ${provider.serverUrl}"
return@forEach
}
- if (conflictStrategy == BackupConflictStrategy.KEEP_EXISTING && resolvedCategory.isUserProtected) {
+ protectedByScope.getOrPut(scope) { linkedSetOf() } += resolvedCategory.id
+ }
+ protectedByScope.forEach { (scope, categoryIds) ->
+ if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING && scope in blockedProtectionScopes) {
return@forEach
}
- categoryRepository.setCategoryProtection(
- providerId = provider.id,
- categoryId = resolvedCategory.id,
- type = resolvedCategory.type,
- isProtected = true
- )
+ val (providerId, type) = scope
+ val categories = categoriesByProviderId[providerId].orEmpty()
+ if (conflictStrategy == BackupConflictStrategy.REPLACE_EXISTING) {
+ categories.filter { it.type == type && it.isUserProtected && it.id !in categoryIds }
+ .forEach { category ->
+ categoryRepository.setCategoryProtection(
+ providerId = providerId,
+ categoryId = category.id,
+ type = type,
+ isProtected = false
+ )
+ }
+ }
+ categoryIds.forEach { categoryId ->
+ val current = categories.firstOrNull { it.id == categoryId && it.type == type }
+ if (conflictStrategy != BackupConflictStrategy.KEEP_EXISTING || current?.isUserProtected != true) {
+ categoryRepository.setCategoryProtection(
+ providerId = providerId,
+ categoryId = categoryId,
+ type = type,
+ isProtected = true
+ )
+ }
+ }
}
return unresolvedReferences
}
@@ -3171,7 +3956,8 @@ class BackupManagerImpl @Inject constructor(
storedProviders.findMatchingProvider(
serverUrl = provider.serverUrl,
username = provider.username,
- stalkerMacAddress = provider.stalkerMacAddress
+ stalkerMacAddress = provider.stalkerMacAddress,
+ providerType = provider.type
)?.let { stored ->
provider.id to stored.id
}
@@ -3379,7 +4165,9 @@ internal fun countScheduledRecordingConflicts(
RecordingUrlConflictKey(it.providerId, it.scheduledStartMs, it.streamUrl)
}
return incoming.count { recording ->
- val provider = providersByIdentity[recording.backupIdentity()] ?: return@count false
+ val provider = providersByIdentity[recording.backupIdentity()]
+ ?.takeIf { recording.providerType == null || it.type == recording.providerType }
+ ?: return@count false
RecordingChannelConflictKey(provider.id, recording.scheduledStartMs, recording.channelId) in channelKeys ||
RecordingUrlConflictKey(provider.id, recording.scheduledStartMs, recording.streamUrl) in urlKeys
}
@@ -3542,7 +4330,8 @@ private fun Provider.backupIdentity(): Triple<String, String, String> =
private fun Provider.toBackupProviderReference() = BackupProviderReference(
serverUrl = normalizeProviderServerUrl(serverUrl),
username = username.trim(),
- stalkerMacAddress = stalkerMacAddress.takeIf { it.isNotBlank() }
+ stalkerMacAddress = stalkerMacAddress.takeIf { it.isNotBlank() },
+ providerType = type
)
private fun Iterable<Provider>.findUnambiguousPortableProvider(
@@ -3551,6 +4340,7 @@ private fun Iterable<Provider>.findUnambiguousPortableProvider(
val normalizedMac = reference.stalkerMacAddress.normalizedIdentity()
return filter { provider ->
normalizeProviderServerUrl(provider.serverUrl) == normalizeProviderServerUrl(reference.serverUrl) &&
+ (reference.providerType == null || provider.type == reference.providerType) &&
(provider.type == ProviderType.M3U || provider.username.trim() == reference.username.trim()) &&
provider.stalkerMacAddress.normalizedIdentity() == normalizedMac
}.singleOrNull()
@@ -3588,18 +4378,24 @@ private fun List<com.streamvault.domain.model.Category>.resolvePortableCategory(
reference: PortableCategoryReference
): com.streamvault.domain.model.Category? {
val candidates = filter { it.type == reference.type }
- val normalizedName = reference.name.normalizedIdentity()
- val exactMatches = candidates.filter {
- it.id == reference.remoteCategoryId &&
- it.name.normalizedIdentity() == normalizedName
+ reference.remoteCategoryId?.let { remoteId ->
+ candidates.singleOrNull { it.id == remoteId }?.let { return it }
}
- exactMatches.singleOrNull()?.let { return it }
+ val normalizedName = reference.name.normalizedIdentity()
return candidates.filter { it.name.normalizedIdentity() == normalizedName }.singleOrNull()
}
+private fun List<com.streamvault.domain.model.Category>.resolvePortableCategoryId(
+ reference: PortableCategoryReference
+): Long? {
+ if (none { it.type == reference.type }) return reference.remoteCategoryId
+ return resolvePortableCategory(reference)?.id
+}
+
private fun List<com.streamvault.data.local.entity.ChannelEntity>.resolvePortableChannel(
reference: PortableChannelReference
): com.streamvault.data.local.entity.ChannelEntity? {
+ filter { it.streamId == reference.streamId }.singleOrNull()?.let { return it }
val normalizedName = reference.name.normalizedIdentity()
val normalizedUrl = reference.streamUrl.trim()
val exactMatches = filter {
@@ -3626,6 +4422,9 @@ private fun PortableVirtualGroupReference.unresolvedLabel(kind: String): String
private fun PortableChannelReference.unresolvedLabel(kind: String): String =
"$kind ${name} (stream $streamId) at ${provider.serverUrl}"
+private fun PortableVariantSelectionReference.unresolvedLabel(kind: String): String =
+ "$kind ${logicalGroupId} (item ${remoteItemId ?: rawItemId}) at ${provider.serverUrl}"
+
private fun String?.normalizedIdentity(): String = orEmpty().trim().lowercase()
private fun ProtectedCategoryBackup.backupIdentity(): Triple<String, String, String> =
@@ -3665,7 +4464,8 @@ internal fun com.streamvault.domain.model.RecordingItem.toScheduledRecordingBack
paddingAfterMs = paddingAfterMs,
programTitle = programTitle,
recurrence = recurrence,
- recurringRuleId = schedule?.recurringRuleId ?: recurringRuleId
+ recurringRuleId = schedule?.recurringRuleId ?: recurringRuleId,
+ providerType = provider.type
)
}
@@ -3728,7 +4528,8 @@ internal suspend fun importScheduledRecordingBackups(
val provider = storedProviders.findMatchingProvider(
serverUrl = scheduled.providerServerUrl,
username = scheduled.providerUsername,
- stalkerMacAddress = scheduled.providerStalkerMacAddress
+ stalkerMacAddress = scheduled.providerStalkerMacAddress,
+ providerType = scheduled.providerType
)
if (provider == null) {
outcomes += scheduled.toImportOutcome(
@@ -3931,16 +4732,19 @@ private fun Provider.toBackupCredentials(): ProviderCredentials? {
serverUrl = serverUrl,
username = username,
password = password,
+ providerType = type,
)
}
private fun Iterable<Provider>.findMatchingProvider(
serverUrl: String,
username: String,
- stalkerMacAddress: String?
+ stalkerMacAddress: String?,
+ providerType: ProviderType? = null
): Provider? {
val candidates = filter {
normalizeProviderServerUrl(it.serverUrl) == normalizeProviderServerUrl(serverUrl) &&
+ (providerType == null || it.type == providerType) &&
(it.type == ProviderType.M3U || it.username.trim() == username.trim())
}
val normalizedMacAddress = stalkerMacAddress
@@ -3977,7 +4781,7 @@ private const val RESTORE_SNAPSHOT_PRESET_1 = "__restore_snapshot_preset_1"
private const val RESTORE_SNAPSHOT_PRESET_2 = "__restore_snapshot_preset_2"
private const val RESTORE_SNAPSHOT_PRESET_3 = "__restore_snapshot_preset_3"
private const val RESTORE_SNAPSHOT_CHANNEL_PREFERENCES = "__restore_snapshot_channel_preferences"
-private const val CURRENT_BACKUP_VERSION = 12
+private const val CURRENT_BACKUP_VERSION = 13
private const val LEGACY_NO_ACTIVE_PROVIDER_WARNING =
"Active provider id -1 was not found during export"
private const val FILE_URI_SCHEME = "file"
@@ -3991,6 +4795,7 @@ private val VIRTUAL_GROUP_TYPE: Type = com.streamvault.domain.model.VirtualGroup
private val PLAYBACK_HISTORY_TYPE: Type = com.streamvault.domain.model.PlaybackHistory::class.java
private val PROTECTED_CATEGORY_TYPE: Type = ProtectedCategoryBackup::class.java
private val SCHEDULED_RECORDING_TYPE: Type = ScheduledRecordingBackup::class.java
+private val RECORDING_STORAGE_TYPE: Type = RecordingStorageBackup::class.java
private val BACKUP_PROVIDER_REFERENCE_TYPE: Type = BackupProviderReference::class.java
private val PORTABLE_CATEGORY_REFERENCE_TYPE: Type = PortableCategoryReference::class.java
private val PORTABLE_CATEGORY_SORT_REFERENCE_TYPE: Type = PortableCategorySortReference::class.java
@@ -4010,6 +4815,21 @@ private val PROVIDER_CREDENTIALS_LIST_TYPE: Type = object : TypeToken<List<Provi
private val EPG_SOURCE_TYPE: Type = com.streamvault.domain.model.EpgSource::class.java
private val EPG_SOURCE_LIST_TYPE: Type =
object : TypeToken<List<com.streamvault.domain.model.EpgSource>>() {}.type
+private val PROVIDER_EPG_ASSIGNMENT_TYPE: Type = ProviderEpgAssignmentBackup::class.java
+private val PROVIDER_EPG_ASSIGNMENT_LIST_TYPE: Type =
+ object : TypeToken<List<ProviderEpgAssignmentBackup>>() {}.type
+private val MANUAL_EPG_MAPPING_TYPE: Type = ManualEpgMappingBackup::class.java
+private val MANUAL_EPG_MAPPING_LIST_TYPE: Type =
+ object : TypeToken<List<ManualEpgMappingBackup>>() {}.type
+private val M3U_CLASSIFICATION_OVERRIDE_TYPE: Type = M3uClassificationOverrideBackup::class.java
+private val M3U_CLASSIFICATION_OVERRIDE_LIST_TYPE: Type =
+ object : TypeToken<List<M3uClassificationOverrideBackup>>() {}.type
+private val M3U_CLASSIFICATION_RULE_TYPE: Type = M3uClassificationRuleBackup::class.java
+private val M3U_CLASSIFICATION_RULE_LIST_TYPE: Type =
+ object : TypeToken<List<M3uClassificationRuleBackup>>() {}.type
+private val PROGRAM_REMINDER_TYPE: Type = ProgramReminderBackup::class.java
+private val PROGRAM_REMINDER_LIST_TYPE: Type =
+ object : TypeToken<List<ProgramReminderBackup>>() {}.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
diff --git a/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.kt b/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.kt
index 7c9702b7..77345967 100644
--- a/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.kt
@@ -44,10 +44,17 @@ import com.streamvault.domain.manager.PortableCategorySortReference
import com.streamvault.domain.manager.PortableChannelReference
import com.streamvault.domain.manager.PortableEpgTimeShiftReference
import com.streamvault.domain.manager.PortableProviderPreferencesBackup
+import com.streamvault.domain.manager.PortableVariantSelectionReference
import com.streamvault.domain.manager.PortableVirtualGroupReference
import com.streamvault.domain.manager.CombinedM3uProfileBackup
import com.streamvault.domain.manager.CombinedM3uProfileMemberBackup
import com.streamvault.domain.manager.ProviderCredentials
+import com.streamvault.domain.manager.ProviderEpgAssignmentBackup
+import com.streamvault.domain.manager.ManualEpgMappingBackup
+import com.streamvault.domain.manager.M3uClassificationOverrideBackup
+import com.streamvault.domain.manager.M3uClassificationRuleBackup
+import com.streamvault.domain.manager.ProgramReminderBackup
+import com.streamvault.domain.manager.RecordingStorageBackup
import com.streamvault.domain.manager.RecordingManager
import com.streamvault.domain.manager.RecordingScheduleImportDisposition
import com.streamvault.domain.manager.ScheduledRecordingBackup
@@ -65,6 +72,7 @@ import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.RecordingItem
import com.streamvault.domain.model.RecordingRecurrence
import com.streamvault.domain.model.RecordingStatus
+import com.streamvault.domain.model.RecordingStorageState
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.StalkerTransportMode
import com.streamvault.domain.model.StalkerConfig
@@ -95,6 +103,56 @@ import org.mockito.kotlin.whenever
class BackupManagerImplTest {
+ @Test
+ fun `custom backup parser preserves newly portable user state sections`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val provider = BackupProviderReference(
+ serverUrl = "https://example.com",
+ username = "user",
+ providerType = ProviderType.M3U
+ )
+ val backup = BackupData(
+ version = 13,
+ recordingStorage = RecordingStorageBackup("{title}", retentionDays = 14, maxSimultaneousRecordings = 3),
+ providerEpgAssignments = listOf(ProviderEpgAssignmentBackup(provider, "https://example.com/guide.xml")),
+ manualEpgMappings = listOf(
+ ManualEpgMappingBackup(
+ channel = PortableChannelReference(provider, 42L, "News", "https://example.com/news"),
+ sourceUrl = "https://example.com/guide.xml",
+ xmltvChannelId = "news.example"
+ )
+ ),
+ m3uClassificationOverrides = listOf(
+ M3uClassificationOverrideBackup(provider, "news-key", 42L, "LIVE")
+ ),
+ m3uClassificationRules = listOf(M3uClassificationRuleBackup(provider, "News", "LIVE")),
+ programReminders = listOf(
+ ProgramReminderBackup(provider, "42", "News", "Headlines", 4_102_444_800_000L)
+ )
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(contentResolver.openInputStream(anyOrNull())).thenReturn(
+ ByteArrayInputStream(Gson().toJson(backup).toByteArray())
+ )
+
+ val manager = backupManagerForValidation(context)
+ val readMethod = BackupManagerImpl::class.java
+ .getDeclaredMethod("readBackupData", String::class.java)
+ .apply { isAccessible = true }
+ val parsed = readMethod.invoke(manager, "content://portable-state")
+ val dataField = parsed!!::class.java.getDeclaredField("data").apply { isAccessible = true }
+ val parsedData = dataField.get(parsed) as BackupData
+
+ assertThat(parsedData.recordingStorage?.retentionDays).isEqualTo(14)
+ assertThat(parsedData.providerEpgAssignments?.single()?.sourceUrl)
+ .isEqualTo("https://example.com/guide.xml")
+ assertThat(parsedData.manualEpgMappings?.single()?.xmltvChannelId).isEqualTo("news.example")
+ assertThat(parsedData.m3uClassificationOverrides?.single()?.sourceKey).isEqualTo("news-key")
+ assertThat(parsedData.m3uClassificationRules?.single()?.groupKey).isEqualTo("News")
+ assertThat(parsedData.programReminders?.single()?.programTitle).isEqualTo("Headlines")
+ }
+
@Test
fun `release obfuscated backup fields remain importable`() = runBlocking {
val payload = """{"version":12,"portableProviderPreferences":{"a":[{"a":"https://example.com","b":"user"}],"e":false,"f":[],"g":[],"h":[],"i":[{"a":{"a":"https://example.com","b":"user"},"b":"News","c":"LIVE","d":50}],"j":true,"k":[{"a":{"a":"https://example.com","b":"user"},"b":"LIVE","c":"TITLE_ASC"}],"l":true,"m":[{"a":{"a":"https://example.com","b":"user"},"b":30}],"n":true,"o":[{"a":{"a":"https://example.com","b":"user"},"b":"news","c":400}],"p":true,"q":[{"a":{"a":"https://example.com","b":"user"},"b":"movie","c":401}],"r":true,"s":[],"t":[{"a":{"a":{"a":"https://example.com","b":"user"},"b":400,"c":"News","d":"https://example.com/news"},"b":"FIT","c":125}],"u":true}}"""
@@ -301,7 +359,7 @@ class BackupManagerImplTest {
fun `inspectBackup rejects unsupported version before reading sections`() = runBlocking {
val error = inspectAdmissionFailure(
"unsupported-version",
- """{"version":13,"preferences":{"value":"${"x".repeat(8_193)}"}}"""
+ """{"version":14,"preferences":{"value":"${"x".repeat(8_193)}"}}"""
)
assertThat(error.reason).isEqualTo(BackupAdmissionReason.UNSUPPORTED_VERSION)
@@ -1420,6 +1478,325 @@ class BackupManagerImplTest {
Unit
}
+ @Test
+ fun `portable import does not replace hidden channels with a partial resolved subset`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val channelDao: ChannelDao = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ val available = PortableChannelReference(
+ provider = reference,
+ streamId = 400L,
+ name = "World News",
+ streamUrl = "https://example.com/live/400"
+ )
+ val missing = available.copy(streamId = 401L, name = "Missing")
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(channelDao.getByProviderSync(targetProvider.id)).thenReturn(
+ listOf(
+ ChannelEntity(
+ id = 140L,
+ streamId = available.streamId,
+ name = available.name,
+ streamUrl = available.streamUrl,
+ providerId = targetProvider.id
+ )
+ )
+ )
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-hidden-partial"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ hiddenChannels = listOf(available, missing)
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ channelDao = channelDao,
+ storedProviders = listOf(targetProvider)
+ ).importConfig("content://portable-hidden-partial", preferencesOnlyPlan())
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.PARTIAL)
+ assertThat(imported.unresolvedReferences).contains("Hidden channel Missing (stream 401) at https://example.com")
+ verify(preferencesRepository, never()).setHiddenChannelIds(targetProvider.id, setOf(140L))
+ Unit
+ }
+
+ @Test
+ fun `portable category identity prefers a matching remote id when the name changed`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(
+ flowOf(listOf(Category(id = 50L, name = "Renamed News", type = ContentType.LIVE)))
+ )
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-category-renamed"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ hiddenCategories = listOf(
+ PortableCategoryReference(reference, "News", ContentType.LIVE, 50L)
+ )
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ storedProviders = listOf(targetProvider)
+ ).importConfig("content://portable-category-renamed", preferencesOnlyPlan())
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ verify(preferencesRepository).setHiddenCategoryIds(targetProvider.id, ContentType.LIVE, setOf(50L))
+ Unit
+ }
+
+ @Test
+ fun `portable split-screen import does not replace a preset with a partial resolved subset`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val channelDao: ChannelDao = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ val available = PortableChannelReference(
+ provider = reference,
+ streamId = 400L,
+ name = "World News",
+ streamUrl = "https://example.com/live/400"
+ )
+ val missing = available.copy(streamId = 401L, name = "Missing")
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(channelDao.getByProviderSync(targetProvider.id)).thenReturn(
+ listOf(
+ ChannelEntity(
+ id = 140L,
+ streamId = available.streamId,
+ name = available.name,
+ streamUrl = available.streamUrl,
+ providerId = targetProvider.id
+ )
+ )
+ )
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-preset-partial"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableMultiViewPresets = mapOf("preset_1" to listOf(available, missing))
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ channelDao = channelDao,
+ storedProviders = listOf(targetProvider)
+ ).importConfig(
+ "content://portable-preset-partial",
+ BackupImportPlan(
+ importPreferences = false,
+ importProviders = false,
+ importSavedLibrary = false,
+ importPlaybackHistory = false,
+ importMultiViewPresets = true,
+ importRecordingSchedules = false
+ )
+ )
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.PARTIAL)
+ verify(preferencesRepository, never()).setMultiViewPreset(0, listOf(140L))
+ Unit
+ }
+
+ @Test
+ fun `portable variant selection resolves remote item ids instead of restoring local ids`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val channelDao: ChannelDao = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(channelDao.getByStreamId(targetProvider.id, 900L)).thenReturn(
+ ChannelEntity(
+ id = 140L,
+ streamId = 900L,
+ name = "Preferred News",
+ streamUrl = "https://example.com/live/900",
+ providerId = targetProvider.id
+ )
+ )
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-variant-identity"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ liveVariantSelections = listOf(
+ PortableVariantSelectionReference(
+ provider = reference,
+ logicalGroupId = "news",
+ rawItemId = 400L,
+ remoteItemId = "900",
+ contentType = ContentType.LIVE
+ )
+ ),
+ liveVariantSelectionsSpecified = true
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ channelDao = channelDao,
+ storedProviders = listOf(targetProvider)
+ ).importConfig("content://portable-variant-identity", preferencesOnlyPlan())
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ verify(preferencesRepository).replacePreferredLiveVariants(targetProvider.id, mapOf("news" to 140L))
+ Unit
+ }
+
+ @Test
+ fun `replace saved library preserves a scope when one favorite cannot be resolved`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val providerDao: ProviderDao = mock()
+ val favoriteDao: FavoriteDao = mock()
+ val channelDao: ChannelDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val provider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "https://example.com",
+ username = "user"
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(provider.toEntity()))
+ whenever(categoryRepository.getCategories(provider.id)).thenReturn(flowOf(emptyList()))
+ whenever(channelDao.getByStreamId(provider.id, 400L)).thenReturn(
+ ChannelEntity(
+ id = 140L,
+ streamId = 400L,
+ name = "World News",
+ streamUrl = "https://example.com/live/400",
+ providerId = provider.id
+ )
+ )
+ whenever(contentResolver.openInputStream(Uri.parse("content://saved-library-partial"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ providers = listOf(provider),
+ favorites = listOf(
+ Favorite(providerId = provider.id, contentId = 1L, contentType = ContentType.LIVE, remoteContentId = "400"),
+ Favorite(providerId = provider.id, contentId = 2L, contentType = ContentType.LIVE, remoteContentId = "401")
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ providerDao = providerDao,
+ favoriteDao = favoriteDao,
+ channelDao = channelDao,
+ categoryRepository = categoryRepository,
+ storedProviders = listOf(provider)
+ ).importConfig(
+ "content://saved-library-partial",
+ BackupImportPlan(
+ importPreferences = false,
+ importProviders = false,
+ importSavedLibrary = true,
+ importPlaybackHistory = false,
+ importMultiViewPresets = false,
+ importRecordingSchedules = false,
+ conflictStrategy = BackupConflictStrategy.REPLACE_EXISTING
+ )
+ )
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.PARTIAL)
+ verify(favoriteDao, never()).deleteByProviderAndType(provider.id, ContentType.LIVE.name)
+ Unit
+ }
+
@Test
fun `portable export uses semantic identities instead of local provider category group and channel ids`() = runBlocking {
val context: Context = mock()
@@ -1477,16 +1854,39 @@ class BackupManagerImplTest {
providerId = provider.id
)
)
+ whenever(channelDao.getById(400L)).thenReturn(
+ ChannelEntity(
+ id = 400L,
+ streamId = 900L,
+ name = "Preferred News",
+ streamUrl = "https://example.com/live/900",
+ providerId = provider.id
+ )
+ )
+ val movieDao: MovieDao = mock()
+ whenever(movieDao.getById(401L)).thenReturn(
+ MovieEntity(
+ id = 401L,
+ streamId = 801L,
+ name = "Movie",
+ providerId = provider.id
+ )
+ )
val portable = backupManagerForValidation(
context = context,
preferencesRepository = preferencesRepository,
categoryRepository = categoryRepository,
virtualGroupDao = virtualGroupDao,
- channelDao = channelDao
+ channelDao = channelDao,
+ movieDao = movieDao
).buildPortableProviderPreferences(listOf(provider))
- val providerReference = BackupProviderReference(provider.serverUrl, provider.username)
+ val providerReference = BackupProviderReference(
+ provider.serverUrl,
+ provider.username,
+ providerType = provider.type
+ )
assertThat(portable.providers).containsExactly(providerReference)
assertThat(portable.activeProvider).isEqualTo(providerReference)
assertThat(portable.guideDefaultCategory?.remoteCategoryId).isEqualTo(50L)
@@ -1614,6 +2014,242 @@ class BackupManagerImplTest {
verify(preferencesRepository).setLastActiveProviderId(targetProvider.id)
}
+ @Test
+ fun `portable import restores hidden category ids before provider catalog is synced`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-hidden-unsynced"))).thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ hiddenCategories = listOf(
+ PortableCategoryReference(reference, "News", ContentType.LIVE, 50L)
+ )
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ storedProviders = listOf(targetProvider)
+ ).importConfig("content://portable-hidden-unsynced", preferencesOnlyPlan())
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ assertThat(imported.unresolvedReferences).isEmpty()
+ verify(preferencesRepository).setHiddenCategoryIds(7L, ContentType.LIVE, setOf(50L))
+ }
+
+ @Test
+ fun `portable import restores pinned and guide category ids before provider catalog is synced`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val category = PortableCategoryReference(reference, "News", ContentType.LIVE, 50L)
+ val targetProvider = Provider(
+ id = 7L,
+ name = "Target",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
+ whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(contentResolver.openInputStream(Uri.parse("content://portable-category-settings-unsynced")))
+ .thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ guideDefaultCategory = category,
+ guideDefaultCategorySpecified = true,
+ pinnedCategories = listOf(category),
+ pinnedCategoriesSpecified = true
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ storedProviders = listOf(targetProvider)
+ ).importConfig("content://portable-category-settings-unsynced", preferencesOnlyPlan())
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ assertThat(imported.unresolvedReferences).isEmpty()
+ verify(preferencesRepository).setGuideDefaultCategoryId(50L)
+ verify(preferencesRepository).setPinnedCategoryIds(7L, ContentType.LIVE, setOf(50L))
+ }
+
+ @Test
+ fun `replacing an existing provider preserves catalog rows needed by portable preferences`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val preferencesRepository: PreferencesRepository = mock()
+ val providerDao: ProviderDao = mock()
+ val categoryRepository: CategoryRepository = mock()
+ val channelDao: ChannelDao = mock()
+ val credentialCrypto: CredentialCrypto = mock()
+ val reference = BackupProviderReference("https://example.com", "user")
+ val existingProvider = Provider(
+ id = 7L,
+ name = "Existing",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = reference.serverUrl,
+ username = reference.username
+ )
+ val providerChannels = mutableListOf(
+ ChannelEntity(
+ id = 140L,
+ streamId = 400L,
+ name = "World News",
+ streamUrl = "https://example.com/live/400",
+ providerId = existingProvider.id
+ )
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(existingProvider.toEntity()))
+ whenever(providerDao.insert(any())).thenAnswer {
+ providerChannels.clear()
+ existingProvider.id
+ }
+ whenever(channelDao.getByProviderSync(existingProvider.id)).thenAnswer { providerChannels.toList() }
+ whenever(categoryRepository.getCategories(existingProvider.id)).thenReturn(flowOf(emptyList()))
+ whenever(credentialCrypto.encryptIfNeeded(any())).thenAnswer { it.arguments.first() as String }
+ whenever(credentialCrypto.decryptIfNeeded(any())).thenAnswer { it.arguments.first() as String }
+ whenever(contentResolver.openInputStream(Uri.parse("content://replace-provider-portable-preferences")))
+ .thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(
+ BackupData(
+ providers = listOf(existingProvider.copy(id = 2L, name = "Backup")),
+ portableProviderPreferences = PortableProviderPreferencesBackup(
+ providers = listOf(reference),
+ hiddenChannels = listOf(
+ PortableChannelReference(
+ provider = reference,
+ streamId = 400L,
+ name = "World News",
+ streamUrl = "https://example.com/live/400"
+ )
+ )
+ )
+ )
+ ).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ providerDao = providerDao,
+ categoryRepository = categoryRepository,
+ channelDao = channelDao,
+ credentialCrypto = credentialCrypto,
+ storedProviders = listOf(existingProvider)
+ ).importConfig(
+ "content://replace-provider-portable-preferences",
+ BackupImportPlan(
+ importPreferences = true,
+ importProviders = true,
+ importSavedLibrary = false,
+ importPlaybackHistory = false,
+ importMultiViewPresets = false,
+ importRecordingSchedules = false,
+ conflictStrategy = BackupConflictStrategy.REPLACE_EXISTING
+ )
+ )
+
+ val imported = (result as Result.Success).data
+ assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ assertThat(imported.unresolvedReferences).isEmpty()
+ verify(preferencesRepository).setHiddenChannelIds(existingProvider.id, setOf(140L))
+ }
+
+ @Test
+ fun `provider replacement does not retain catalog rows from another provider type`() = runBlocking {
+ val context: Context = mock()
+ val contentResolver: ContentResolver = mock()
+ val providerDao: ProviderDao = mock()
+ val credentialCrypto: CredentialCrypto = mock()
+ val existingProvider = Provider(
+ id = 7L,
+ name = "Existing M3U",
+ type = ProviderType.M3U,
+ serverUrl = "https://example.com",
+ username = "user"
+ )
+ val backupProvider = existingProvider.copy(
+ id = 2L,
+ name = "Backup Xtream",
+ type = ProviderType.XTREAM_CODES
+ )
+ whenever(context.contentResolver).thenReturn(contentResolver)
+ whenever(providerDao.getAllSync()).thenReturn(listOf(existingProvider.toEntity()))
+ whenever(providerDao.insert(any())).thenReturn(8L)
+ whenever(credentialCrypto.encryptIfNeeded(any())).thenAnswer { it.arguments.first() as String }
+ whenever(credentialCrypto.decryptIfNeeded(any())).thenAnswer { it.arguments.first() as String }
+ whenever(contentResolver.openInputStream(Uri.parse("content://replace-provider-different-type")))
+ .thenReturn(
+ ByteArrayInputStream(
+ Gson().toJson(BackupData(providers = listOf(backupProvider))).toByteArray()
+ )
+ )
+
+ val result = backupManagerForValidation(
+ context = context,
+ providerDao = providerDao,
+ credentialCrypto = credentialCrypto,
+ storedProviders = listOf(existingProvider)
+ ).importConfig(
+ "content://replace-provider-different-type",
+ BackupImportPlan(
+ importPreferences = false,
+ importProviders = true,
+ importSavedLibrary = false,
+ importPlaybackHistory = false,
+ importMultiViewPresets = false,
+ importRecordingSchedules = false,
+ conflictStrategy = BackupConflictStrategy.REPLACE_EXISTING
+ )
+ )
+
+ assertThat((result as Result.Success).data.outcome).isEqualTo(BackupRestoreOutcome.COMPLETE)
+ verify(providerDao).insert(any())
+ verify(providerDao, never()).update(any())
+ }
+
@Test
fun `semantic json round trip resolves shifted target ids after room restore`() = runBlocking {
val context: Context = mock()
@@ -1831,7 +2467,7 @@ class BackupManagerImplTest {
assertThat(imported.outcome).isEqualTo(BackupRestoreOutcome.PARTIAL)
assertThat(imported.unresolvedReferences)
.contains("Group News [LIVE] at https://example.com")
- verify(preferencesRepository).setPromotedLiveGroupIds(emptySet())
+ verify(preferencesRepository, never()).setPromotedLiveGroupIds(any())
}
@Test
@@ -1899,12 +2535,17 @@ class BackupManagerImplTest {
val reference = BackupProviderReference(sourceProvider.serverUrl, sourceProvider.username)
val uriString = "content://portable-conflict-${conflictStrategy.name}"
var insertCalls = 0
+ var updateCalls = 0
whenever(context.contentResolver).thenReturn(contentResolver)
whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))
doAnswer {
insertCalls += 1
targetProvider.id
}.whenever(providerDao).insert(any())
+ doAnswer {
+ updateCalls += 1
+ Unit
+ }.whenever(providerDao).update(any())
whenever(credentialCrypto.encryptIfNeeded(any())).thenReturn("")
whenever(categoryRepository.getCategories(targetProvider.id)).thenReturn(flowOf(emptyList()))
whenever(channelDao.getByProviderSync(targetProvider.id)).thenReturn(emptyList())
@@ -1941,7 +2582,8 @@ class BackupManagerImplTest {
assertThat((result as Result.Success).data.outcome)
.isEqualTo(BackupRestoreOutcome.COMPLETE)
verify(preferencesRepository).setHiddenChannelIds(targetProvider.id, emptySet())
- assertThat(insertCalls).isEqualTo(
+ assertThat(insertCalls).isEqualTo(0)
+ assertThat(updateCalls).isEqualTo(
if (conflictStrategy == BackupConflictStrategy.KEEP_EXISTING) 0 else 1
)
}
@@ -2747,31 +3389,38 @@ class BackupManagerImplTest {
context: Context,
preferencesRepository: PreferencesRepository = mock(),
providerDao: ProviderDao = mock(),
+ favoriteDao: FavoriteDao = mock(),
checkpointDao: BackupRestoreCheckpointDao? = null,
channelDao: ChannelDao = mock(),
+ movieDao: MovieDao = mock(),
categoryRepository: CategoryRepository = mock(),
virtualGroupDao: VirtualGroupDao = mock(),
credentialCrypto: CredentialCrypto = mock(),
epgSourceDao: EpgSourceDao? = null,
+ recordingManager: RecordingManager = mock(),
storedProviders: List<Provider> = emptyList(),
- ): BackupManagerImpl = BackupManagerImpl(
- context = context,
- preferencesRepository = preferencesRepository,
- credentialCrypto = credentialCrypto,
- providerDao = providerDao,
- favoriteDao = mock<FavoriteDao>(),
- virtualGroupDao = virtualGroupDao,
- playbackHistoryDao = mock<PlaybackHistoryDao>(),
- movieDao = mock<MovieDao>(),
- episodeDao = mock<EpisodeDao>(),
- categoryRepository = categoryRepository,
- recordingScheduleDao = mock<RecordingScheduleDao>(),
- recordingManager = mock<RecordingManager>(),
- transactionRunner = object : DatabaseTransactionRunner {
- override suspend fun <T> inTransaction(block: suspend () -> T): T = block()
- },
- gson = Gson(),
- providerSnapshotRepository = object : ProviderSnapshotRepository {
+ ): BackupManagerImpl {
+ whenever(preferencesRepository.defaultCategoryId).thenReturn(flowOf(null))
+ whenever(recordingManager.observeRecordingItems()).thenReturn(flowOf(emptyList()))
+ whenever(recordingManager.observeStorageState()).thenReturn(flowOf(RecordingStorageState()))
+ return BackupManagerImpl(
+ context = context,
+ preferencesRepository = preferencesRepository,
+ credentialCrypto = credentialCrypto,
+ providerDao = providerDao,
+ favoriteDao = favoriteDao,
+ virtualGroupDao = virtualGroupDao,
+ playbackHistoryDao = mock<PlaybackHistoryDao>(),
+ movieDao = movieDao,
+ episodeDao = mock<EpisodeDao>(),
+ categoryRepository = categoryRepository,
+ recordingScheduleDao = mock<RecordingScheduleDao>(),
+ recordingManager = recordingManager,
+ transactionRunner = object : DatabaseTransactionRunner {
+ override suspend fun <T> inTransaction(block: suspend () -> T): T = block()
+ },
+ gson = Gson(),
+ providerSnapshotRepository = object : ProviderSnapshotRepository {
override suspend fun getSnapshot(providerId: Long) =
storedProviders.firstOrNull { it.id == providerId }?.toProviderSnapshot()
@@ -2785,14 +3434,15 @@ class BackupManagerImplTest {
layout: com.streamvault.domain.model.CatalogLayout,
detectionVersion: Int
) = Unit
- },
- providerSnapshotDao = acceptingSnapshotDao(),
- providerConfigurationCodec = ProviderConfigurationCodec(Gson(), credentialCrypto),
- backupRestoreCheckpointDao = checkpointDao,
- channelDao = channelDao,
- seriesDao = mock(),
- epgSourceDao = epgSourceDao
- )
+ },
+ providerSnapshotDao = acceptingSnapshotDao(),
+ providerConfigurationCodec = ProviderConfigurationCodec(Gson(), credentialCrypto),
+ backupRestoreCheckpointDao = checkpointDao,
+ channelDao = channelDao,
+ seriesDao = mock(),
+ epgSourceDao = epgSourceDao
+ )
+ }
private fun preferencesOnlyPlan() = BackupImportPlan(
importPreferences = true,
diff --git a/domain/src/main/java/com/streamvault/domain/manager/BackupManager.kt b/domain/src/main/java/com/streamvault/domain/manager/BackupManager.kt
index f0f16e67..4928cc8c 100644
--- a/domain/src/main/java/com/streamvault/domain/manager/BackupManager.kt
+++ b/domain/src/main/java/com/streamvault/domain/manager/BackupManager.kt
@@ -5,6 +5,7 @@ import com.streamvault.domain.model.Provider as StableProvider
import com.streamvault.domain.model.PlaybackHistory
import com.streamvault.domain.model.LegacyProvider as Provider
import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.RecordingRecurrence
import kotlinx.coroutines.flow.Flow
import com.streamvault.domain.model.Result
@@ -14,7 +15,7 @@ import com.streamvault.domain.model.StalkerConfig
import com.streamvault.domain.model.JellyfinConfig
data class BackupData(
- val version: Int = 12,
+ val version: Int = 13,
val checksum: String? = null,
val preferences: Map<String, String>? = null,
val providers: List<Provider>? = null,
@@ -30,7 +31,13 @@ data class BackupData(
val protectedCategories: List<ProtectedCategoryBackup>? = null,
val scheduledRecordings: List<ScheduledRecordingBackup>? = null,
val portableProviderPreferences: PortableProviderPreferencesBackup? = null,
+ val recordingStorage: RecordingStorageBackup? = null,
val epgSources: List<com.streamvault.domain.model.EpgSource>? = null,
+ val providerEpgAssignments: List<ProviderEpgAssignmentBackup>? = null,
+ val manualEpgMappings: List<ManualEpgMappingBackup>? = null,
+ val m3uClassificationOverrides: List<M3uClassificationOverrideBackup>? = null,
+ val m3uClassificationRules: List<M3uClassificationRuleBackup>? = null,
+ val programReminders: List<ProgramReminderBackup>? = null,
/** User-created combined M3U sources, represented by portable provider identities. */
val combinedM3uProfiles: List<CombinedM3uProfileBackup>? = null,
/** The selected live source, represented without local provider/profile IDs. */
@@ -82,13 +89,19 @@ data class PortableProviderPreferencesBackup(
val unresolvedReferences: List<String> = emptyList(),
/** Per-channel playback choices, resolved through portable channel identity on import. */
val channelPreferences: List<PortableChannelPreferenceReference> = emptyList(),
- val channelPreferencesSpecified: Boolean = false
+ val channelPreferencesSpecified: Boolean = false,
+ /** The user's Home start category, resolved by provider/category identity on import. */
+ val homeDefaultCategory: PortableCategoryReference? = null,
+ val homeDefaultVirtualCategoryId: Long? = null,
+ val homeDefaultCategorySpecified: Boolean = false
)
data class BackupProviderReference(
val serverUrl: String,
val username: String,
- val stalkerMacAddress: String? = null
+ val stalkerMacAddress: String? = null,
+ /** Added in v13; null keeps old backups importable. */
+ val providerType: ProviderType? = null
)
data class PortableCategoryReference(
@@ -131,7 +144,11 @@ data class PortableEpgTimeShiftReference(
data class PortableVariantSelectionReference(
val provider: BackupProviderReference,
val logicalGroupId: String,
- val rawItemId: Long
+ /** Legacy local catalog id. Kept for importing backups written before portable ids existed. */
+ val rawItemId: Long,
+ /** Provider/catalog identity used by current backups; never a local Room id. */
+ val remoteItemId: String? = null,
+ val contentType: ContentType? = null
)
data class CombinedM3uProfileBackup(
@@ -162,7 +179,8 @@ data class ProtectedCategoryBackup(
val providerStalkerMacAddress: String? = null,
val categoryId: Long,
val categoryName: String,
- val type: ContentType
+ val type: ContentType,
+ val providerType: ProviderType? = null
)
data class ScheduledRecordingBackup(
@@ -180,7 +198,59 @@ data class ScheduledRecordingBackup(
val paddingAfterMs: Long? = null,
val programTitle: String? = null,
val recurrence: RecordingRecurrence = RecordingRecurrence.NONE,
- val recurringRuleId: String? = null
+ val recurringRuleId: String? = null,
+ val providerType: ProviderType? = null
+)
+
+data class RecordingStorageBackup(
+ val fileNamePattern: String,
+ val retentionDays: Int? = null,
+ val maxSimultaneousRecordings: Int = 2
+)
+
+data class ProviderEpgAssignmentBackup(
+ val provider: BackupProviderReference,
+ val sourceUrl: String,
+ val priority: Int = 0,
+ val enabled: Boolean = true
+)
+
+data class ManualEpgMappingBackup(
+ val channel: PortableChannelReference,
+ val sourceUrl: String? = null,
+ val xmltvChannelId: String? = null,
+ val sourceType: String = "NONE",
+ val matchType: String? = null,
+ val confidence: Float = 0f,
+ val source: String? = null
+)
+
+data class M3uClassificationOverrideBackup(
+ val provider: BackupProviderReference,
+ val sourceKey: String,
+ val streamId: Long,
+ val targetType: String,
+ val groupKey: String = "",
+ val seriesKey: String? = null,
+ val seriesName: String? = null,
+ val seasonNumber: Int? = null,
+ val episodeNumber: Int? = null,
+ val episodeTitle: String? = null
+)
+
+data class M3uClassificationRuleBackup(
+ val provider: BackupProviderReference,
+ val groupKey: String,
+ val targetType: String
+)
+
+data class ProgramReminderBackup(
+ val provider: BackupProviderReference,
+ val channelId: String,
+ val channelName: String,
+ val programTitle: String,
+ val programStartTime: Long,
+ val leadTimeMinutes: Int = 5
)
enum class BackupConflictStrategy {
diff --git a/domain/src/main/java/com/streamvault/domain/manager/DriveBackupSyncManager.kt b/domain/src/main/java/com/streamvault/domain/manager/DriveBackupSyncManager.kt
index 55d8eb9e..74fdcba9 100644
--- a/domain/src/main/java/com/streamvault/domain/manager/DriveBackupSyncManager.kt
+++ b/domain/src/main/java/com/streamvault/domain/manager/DriveBackupSyncManager.kt
@@ -93,12 +93,13 @@ interface DriveBackupSyncManager {
/**
* Cleartext credentials for a single provider, transported alongside the main
* backup JSON. Drive storage relies on the `drive.appdata` scope + Google
- * account ACL for confidentiality. Matching uses `(serverUrl, username)`.
+ * account ACL for confidentiality. Matching uses `(serverUrl, username, providerType)` when available.
*/
data class ProviderCredentials(
val serverUrl: String,
val username: String,
val password: String,
+ val providerType: com.streamvault.domain.model.ProviderType? = null,
)
/** Public Sign-In state for the UI. */