StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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.ktindex 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.DatabaseTransactionRunnerimport com.streamvault.data.local.dao.BackupRestoreCheckpointDaoimport com.streamvault.data.local.dao.ChannelDaoimport com.streamvault.data.local.dao.ChannelPreferenceDao+import com.streamvault.data.local.dao.ChannelEpgMappingDao+import com.streamvault.data.local.dao.M3uClassificationDaoimport com.streamvault.data.local.dao.CombinedM3uProfileDaoimport com.streamvault.data.local.dao.CombinedM3uProfileMemberDaoimport com.streamvault.data.local.dao.EpisodeDao@@ -24,6 +26,7 @@ import com.streamvault.data.local.dao.FavoriteDaoimport com.streamvault.data.local.dao.MovieDaoimport com.streamvault.data.local.dao.PlaybackHistoryDaoimport com.streamvault.data.local.dao.ProviderDao+import com.streamvault.data.local.dao.ProviderEpgSourceDaoimport com.streamvault.data.local.dao.ProviderSnapshotDaoimport com.streamvault.data.local.dao.RecordingScheduleDaoimport com.streamvault.data.local.dao.SeriesDao@@ -33,6 +36,10 @@ import com.streamvault.data.local.entity.ProviderAccountRuntimeEntityimport com.streamvault.data.local.entity.ProviderConfigEntityimport com.streamvault.data.local.entity.BackupRestoreCheckpointEntityimport 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.M3uCategoryClassificationRuleEntityimport com.streamvault.data.local.entity.CombinedM3uProfileEntityimport com.streamvault.data.local.entity.CombinedM3uProfileMemberEntityimport com.streamvault.data.local.entity.RecordingScheduleEntity@@ -59,6 +66,14 @@ import com.streamvault.domain.manager.BackupPreviewimport com.streamvault.domain.manager.RecordingScheduleImportDispositionimport com.streamvault.domain.manager.RecordingScheduleImportOutcomeimport 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.Programimport com.streamvault.domain.manager.ProtectedCategoryBackupimport com.streamvault.domain.manager.BackupProviderReferenceimport 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 groupsval 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.PARTIALcheckpoint = 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>>? = nullvar protectedCategories: List<ProtectedCategoryBackup>? = nullvar scheduledRecordings: List<ScheduledRecordingBackup>? = null+ var recordingStorage: RecordingStorageBackup? = nullvar portableProviderPreferences: PortableProviderPreferencesBackup? = nullvar 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>? = nullvar combinedM3uProfiles: List<CombinedM3uProfileBackup>? = nullvar activeLiveSource: ActiveLiveSourceBackup? = nullval 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 = falseval 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 = guideCategoryReferenceval 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 = trueval 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.typeval 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 falseRecordingChannelConflictKey(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): Stringprivate 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.toScheduledRecordingBackpaddingAfterMs = 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 = 13private 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.VirtualGroupprivate val PLAYBACK_HISTORY_TYPE: Type = com.streamvault.domain.model.PlaybackHistory::class.javaprivate val PROTECTED_CATEGORY_TYPE: Type = ProtectedCategoryBackup::class.javaprivate val SCHEDULED_RECORDING_TYPE: Type = ScheduledRecordingBackup::class.java+private val RECORDING_STORAGE_TYPE: Type = RecordingStorageBackup::class.javaprivate val BACKUP_PROVIDER_REFERENCE_TYPE: Type = BackupProviderReference::class.javaprivate val PORTABLE_CATEGORY_REFERENCE_TYPE: Type = PortableCategoryReference::class.javaprivate val PORTABLE_CATEGORY_SORT_REFERENCE_TYPE: Type = PortableCategorySortReference::class.java@@ -4010,6 +4815,21 @@ private val PROVIDER_CREDENTIALS_LIST_TYPE: Type = object : TypeToken<List<Proviprivate val EPG_SOURCE_TYPE: Type = com.streamvault.domain.model.EpgSource::class.javaprivate 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>>() {}.typeprivate val FAVORITE_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.Favorite>>() {}.typeprivate val VIRTUAL_GROUP_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.VirtualGroup>>() {}.typeprivate val PLAYBACK_HISTORY_LIST_TYPE: Type = object : TypeToken<List<com.streamvault.domain.model.PlaybackHistory>>() {}.typediff --git a/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.kt b/data/src/test/java/com/streamvault/data/manager/BackupManagerImplTest.ktindex 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.PortableCategorySortReferenceimport com.streamvault.domain.manager.PortableChannelReferenceimport com.streamvault.domain.manager.PortableEpgTimeShiftReferenceimport com.streamvault.domain.manager.PortableProviderPreferencesBackup+import com.streamvault.domain.manager.PortableVariantSelectionReferenceimport com.streamvault.domain.manager.PortableVirtualGroupReferenceimport com.streamvault.domain.manager.CombinedM3uProfileBackupimport com.streamvault.domain.manager.CombinedM3uProfileMemberBackupimport 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.RecordingStorageBackupimport com.streamvault.domain.manager.RecordingManagerimport com.streamvault.domain.manager.RecordingScheduleImportDispositionimport com.streamvault.domain.manager.ScheduledRecordingBackup@@ -65,6 +72,7 @@ import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.RecordingItemimport com.streamvault.domain.model.RecordingRecurrenceimport com.streamvault.domain.model.RecordingStatus+import com.streamvault.domain.model.RecordingStorageStateimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.StalkerTransportModeimport com.streamvault.domain.model.StalkerConfig@@ -95,6 +103,56 @@ import org.mockito.kotlin.wheneverclass 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")+ }+@Testfun `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+ }+@Testfun `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())+ }+@Testfun `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 = 0whenever(context.contentResolver).thenReturn(contentResolver)whenever(providerDao.getAllSync()).thenReturn(listOf(targetProvider.toEntity()))doAnswer {insertCalls += 1targetProvider.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.ktindex 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 StableProviderimport com.streamvault.domain.model.PlaybackHistoryimport com.streamvault.domain.model.LegacyProvider as Providerimport com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.RecordingRecurrenceimport kotlinx.coroutines.flow.Flowimport com.streamvault.domain.model.Result@@ -14,7 +15,7 @@ import com.streamvault.domain.model.StalkerConfigimport com.streamvault.domain.model.JellyfinConfigdata 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.ktindex 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. */