fix(#147, #411): review round 2 - prune from a ledger of written files, one read per run

This commit is contained in:
makiolaj committed 2026-11-13 16:38:06 +01:00
1 parent 240ed5237a
commit 46818cd0ae
14 files changed
+268 -244

No files matched your search

@@ -26,10 +26,10 @@ import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
import de.jeanlucmakiola.calendula.data.ics.IcsExporter
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.calendula.domain.backup.BackupFilePlan
import de.jeanlucmakiola.calendula.domain.backup.COMBINED_SERIES
import de.jeanlucmakiola.calendula.domain.backup.backupTargets
import de.jeanlucmakiola.calendula.domain.backup.planBackupFiles
import de.jeanlucmakiola.calendula.domain.backup.updatedBackupBases
import de.jeanlucmakiola.calendula.domain.backup.updatedBackupLedger
import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
import de.jeanlucmakiola.floret.android.hasPermission
import kotlinx.coroutines.flow.first
@@ -136,57 +136,62 @@ class BackupWorker(
if (!success && prefs.autoBackupStatus.first().consecutiveFailures >= FAILURE_NOTIFY_THRESHOLD) {
notifyFailure(applicationContext)
}
// A retry rewrites every series, so only a run that wrote nothing is
// retried; a partial one waits for the next interval rather than
// rotating the healthy calendars' history out with near-identical copies.
// Only a run that wrote nothing retries: a retry rewrites every series.
return if (outcome == RunOutcome.Failed) Result.retry() else Result.success()
}
private enum class RunOutcome { Written, PartlyFailed, Failed, NothingSelected }
/**
* Writes each series and prunes it only once its new file has landed, so
* a failed write never costs an older backup.
*/
/** Writes each series and prunes it only once its new file has landed. */
private suspend fun runBackup(deps: Deps, prefs: SettingsPrefs, folder: Uri): RunOutcome {
val repository = deps.repository()
val exporter = deps.exporter()
// Without the calendar permission the list comes back empty.
val all = repository.calendars().first()
// Without the calendar permission the list comes back empty: a failure,
// not an empty selection.
if (all.isEmpty()) return RunOutcome.Failed
val selection = prefs.autoBackupSelection.first()
val previousBases = prefs.autoBackupSeriesNames.first()
val targets = backupTargets(
calendars = all.filter(selection::selects),
combined = prefs.autoBackupCombined.first(),
previousBases = previousBases,
)
val targets = backupTargets(all.filter(selection::selects), combined = prefs.autoBackupCombined.first())
if (targets.isEmpty()) return RunOutcome.NothingSelected
val ledger = prefs.autoBackupLedger.first()
val listing = exporter.listFolder(folder)
val plans = planBackupFiles(
targets = targets,
ledger = ledger,
existing = listing.keys,
at = LocalDateTime.now(),
keep = prefs.autoBackupKeep.first(),
)
val events = repository.exportEvents(targets.flatMap { it.calendarIds }.toSet())
val byCalendar = events.groupBy { it.calendarId }
val stamp = Clock.System.now()
val written = mutableListOf<BackupFilePlan>()
val writtenNames = mutableMapOf<String, String>()
val undeleted = mutableSetOf<String>()
for (plan in plans) {
try {
val events = repository.exportEvents(plan.target.calendarIds)
val content = IcsWriter().writeCalendar(events, stamp, plan.target.calendarName)
exporter.writeToFolder(folder, listing, plan.fileName, content)
written += plan
exporter.deleteDocuments(plan.prune.mapNotNull(listing::get))
val target = plan.target
val content = IcsWriter().writeCalendar(
events = if (target.key == COMBINED_SERIES) events else byCalendar[target.calendarIds.single()].orEmpty(),
dtStamp = stamp,
calendarName = target.calendarName,
)
writtenNames[target.key] = exporter.writeToFolder(folder, listing, plan.fileName, content)
undeleted += exporter.deleteFromFolder(listing, plan.prune)
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
Log.w(TAG, "Backup of one series failed", e)
}
}
prefs.setAutoBackupSeriesNames(updatedBackupBases(previousBases, written))
return when (written.size) {
prefs.setAutoBackupLedger(
updatedBackupLedger(
previous = ledger,
written = plans,
writtenNames = writtenNames,
undeleted = undeleted,
liveKeys = all.map { it.id.toString() }.toSet(),
),
)
return when (writtenNames.size) {
plans.size -> RunOutcome.Written
0 -> RunOutcome.Failed
else -> RunOutcome.PartlyFailed
@@ -789,8 +789,7 @@ class AndroidCalendarDataSource @Inject constructor(
if (names.isEmpty()) return emptyList()
val idList = names.keys.joinToString(",")
// Skip soft-deleted rows and exception rows (modified occurrences /
// cancellations) — v1 exports masters + one-offs only.
// Masters + one-offs only: no soft-deleted or exception rows.
val selection = "${CalendarContract.Events.CALENDAR_ID} IN ($idList) AND " +
"${CalendarContract.Events.DELETED} = 0 AND " +
"${CalendarContract.Events.ORIGINAL_ID} IS NULL"
@@ -801,7 +800,7 @@ class AndroidCalendarDataSource @Inject constructor(
null,
null,
)?.use { c -> c.mapRows { getLong(0) } }.orEmpty()
val reminders = reminderMinutesByEvent(eventIds)
val reminders = resolver.reminderMinutesByEvent(eventIds, alertsOnly = false)
return resolver.query(
CalendarContract.Events.CONTENT_URI,
EventExportProjection.COLUMNS,
@@ -816,30 +815,11 @@ class AndroidCalendarDataSource @Inject constructor(
reminderMinutes = reminders[eventId].orEmpty(),
calendarName = names[calendarId],
allDayReminderTimeMinutes = allDayReminderTimeMinutes,
)
).copy(calendarId = calendarId)
}
} ?: emptyList()
}
/**
* Reminder minutes of [eventIds], a chunked query at a time rather than one
* per event — a synced calendar can hold thousands (#147).
*/
private fun reminderMinutesByEvent(eventIds: List<Long>): Map<Long, List<Int>> {
val byEvent = mutableMapOf<Long, MutableList<Int>>()
eventIds.chunked(REMINDER_QUERY_CHUNK).forEach { chunk ->
resolver.query(
CalendarContract.Reminders.CONTENT_URI,
arrayOf(CalendarContract.Reminders.EVENT_ID, CalendarContract.Reminders.MINUTES),
"${CalendarContract.Reminders.EVENT_ID} IN (${chunk.joinToString(",")})",
null,
null,
)?.use { c ->
while (c.moveToNext()) byEvent.getOrPut(c.getLong(0)) { mutableListOf() } += c.getInt(1)
}
}
return byEvent
}
override fun existingUids(calendarId: Long): Set<String> = resolver.query(
CalendarContract.Events.CONTENT_URI,
@@ -1775,9 +1755,6 @@ class AndroidCalendarDataSource @Inject constructor(
private companion object {
const val TAG = "CalendarDataSource"
/** Ids per `IN (…)` list, well under SQLite's bound-variable and statement limits. */
const val REMINDER_QUERY_CHUNK = 500
/** Normalised key an attendee is matched/deduped on (case-insensitive email). */
fun emailKey(email: String): String = email.trim().lowercase()
@@ -0,0 +1,36 @@
package de.jeanlucmakiola.calendula.data.calendar
import android.content.ContentResolver
import android.provider.CalendarContract
/** Ids per `IN (…)` list: they go into the SQL literally, which SQLite bounds. */
private const val EVENT_ID_BATCH = 50
/**
* Reminder minutes of [eventIds], keyed by event, a batched query at a time
* rather than one per event. [alertsOnly] keeps just the notification ones.
*/
internal fun ContentResolver.reminderMinutesByEvent(
eventIds: Collection<Long>,
alertsOnly: Boolean,
): Map<Long, List<Int>> {
if (eventIds.isEmpty()) return emptyMap()
val out = mutableMapOf<Long, MutableList<Int>>()
val method = if (alertsOnly) {
"${CalendarContract.Reminders.METHOD} = ${CalendarContract.Reminders.METHOD_ALERT} AND "
} else {
""
}
eventIds.distinct().chunked(EVENT_ID_BATCH).forEach { batch ->
query(
CalendarContract.Reminders.CONTENT_URI,
arrayOf(CalendarContract.Reminders.EVENT_ID, CalendarContract.Reminders.MINUTES),
"$method${CalendarContract.Reminders.EVENT_ID} IN (${batch.joinToString(",")})",
null,
null,
)?.use { c ->
while (c.moveToNext()) out.getOrPut(c.getLong(0)) { mutableListOf() } += c.getInt(1)
}
}
return out
}
@@ -60,22 +60,30 @@ class IcsExporter @Inject constructor(
/**
* Write [content] to [fileName] in [folder], overwriting the file of that
* name if [listing] (from [listFolder]) has one. Throws on failure.
* name if [listing] (from [listFolder]) has one. Returns the name the file
* ended up with — a provider may de-duplicate it. Throws on failure.
*/
fun writeToFolder(folder: Uri, listing: Map<String, Uri>, fileName: String, content: String) {
val uri = listing[fileName] ?: DocumentsContract.createDocument(
fun writeToFolder(folder: Uri, listing: Map<String, Uri>, fileName: String, content: String): String {
listing[fileName]?.let { uri ->
writeDocument(uri, content)
return fileName
}
val uri = DocumentsContract.createDocument(
context.contentResolver,
DocumentsContract.buildDocumentUriUsingTree(folder, DocumentsContract.getTreeDocumentId(folder)),
MIME_CALENDAR,
fileName,
) ?: throw IOException("Could not create backup file in the chosen folder")
writeDocument(uri, content)
return DocumentFile.fromSingleUri(context, uri)?.name ?: fileName
}
/** Delete [documents]; one that won't go is left behind. */
fun deleteDocuments(documents: Collection<Uri>) {
documents.forEach { runCatching { DocumentsContract.deleteDocument(context.contentResolver, it) } }
}
/** Delete the [names] files of [listing]; returns the ones that wouldn't go. */
fun deleteFromFolder(listing: Map<String, Uri>, names: Collection<String>): Set<String> =
names.filterTo(mutableSetOf()) { name ->
val uri = listing[name] ?: return@filterTo false
!runCatching { DocumentsContract.deleteDocument(context.contentResolver, uri) }.getOrDefault(false)
}
private fun writableFolder(folder: Uri): DocumentFile {
val dir = DocumentFile.fromTreeUri(context, folder)
@@ -8,8 +8,9 @@ import de.jeanlucmakiola.calendula.domain.FontRole
import de.jeanlucmakiola.calendula.domain.backup.BackupSelection
import de.jeanlucmakiola.calendula.domain.backup.DEFAULT_BACKUP_KEEP
import de.jeanlucmakiola.calendula.domain.backup.normalizeBackupKeep
import de.jeanlucmakiola.calendula.domain.backup.parseBackupBases
import de.jeanlucmakiola.calendula.domain.backup.persistBackupBases
import de.jeanlucmakiola.calendula.domain.backup.BackupLedger
import de.jeanlucmakiola.calendula.domain.backup.parseBackupLedger
import de.jeanlucmakiola.calendula.domain.backup.persistBackupLedger
import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
@@ -190,7 +191,7 @@ class SettingsPrefs @Inject constructor(
val autoBackupSelection: Flow<BackupSelection> = prefs.snapshot { it.autoBackupSelection }
val autoBackupCombined: Flow<Boolean> = prefs.snapshot { it.autoBackupCombined }
val autoBackupKeep: Flow<Int> = prefs.flow(SettingsKeys.autoBackupKeep)
val autoBackupSeriesNames: Flow<Map<Long, Set<String>>> = prefs.flow(SettingsKeys.autoBackupSeriesNames)
val autoBackupLedger: Flow<BackupLedger> = prefs.flow(SettingsKeys.autoBackupLedger)
val specialDatesEnabled: Flow<Boolean> = prefs.flow(SettingsKeys.specialDatesEnabled)
val specialDatesTypes: Flow<Set<SpecialDateType>> = prefs.snapshot { it.specialDatesTypes }
val specialDatesCalendars: Flow<Map<SpecialDateType, Long>> = prefs.snapshot { it.specialDatesCalendars }
@@ -359,8 +360,7 @@ class SettingsPrefs @Inject constructor(
suspend fun setAutoBackupKeep(keep: Int) = prefs.set(SettingsKeys.autoBackupKeep, keep)
suspend fun setAutoBackupSeriesNames(names: Map<Long, Set<String>>) =
prefs.set(SettingsKeys.autoBackupSeriesNames, names)
suspend fun setAutoBackupLedger(ledger: BackupLedger) = prefs.set(SettingsKeys.autoBackupLedger, ledger)
/** Switch [calendar] in or out of the automatic backup (#147). */
suspend fun setAutoBackupCalendar(calendar: CalendarSource, included: Boolean) {
@@ -757,9 +757,9 @@ object SettingsKeys {
val autoBackupKeep: Pref<Int> =
intPref("auto_backup_keep", DEFAULT_BACKUP_KEEP).coerced(::normalizeBackupKeep)
/** Each calendar's backup series name from its last run, so a rename still prunes the old files. */
val autoBackupSeriesNames: Pref<Map<Long, Set<String>>> =
nullableStringPref("auto_backup_series").map(::parseBackupBases, ::persistBackupBases)
/** The files the automatic backup wrote, per series; the only ones it ever prunes (#411). */
val autoBackupLedger: Pref<BackupLedger> =
nullableStringPref("auto_backup_files").map(::parseBackupLedger, ::persistBackupLedger)
/** Master switch for the contact special-dates mirror (issue #15). Opt-in. */
val specialDatesEnabled: Pref<Boolean> = booleanPref("special_dates_enabled", false)
@@ -4,6 +4,7 @@ import android.content.Context
import android.provider.CalendarContract
import dagger.hilt.android.qualifiers.ApplicationContext
import de.jeanlucmakiola.calendula.data.calendar.instancesUri
import de.jeanlucmakiola.calendula.data.calendar.reminderMinutesByEvent
import de.jeanlucmakiola.calendula.domain.reminders.ReminderEventInstance
import javax.inject.Inject
import javax.inject.Singleton
@@ -72,28 +73,8 @@ class ProviderReminderInstanceSource @Inject constructor(
} ?: emptyList()
}
override fun reminderMinutes(eventIds: Collection<Long>): Map<Long, List<Int>> {
if (eventIds.isEmpty()) return emptyMap()
val out = mutableMapOf<Long, MutableList<Int>>()
// Batched: the ids go into the selection literally, and an unbounded
// `IN (...)` would grow the SQL past what SQLite takes.
eventIds.distinct().chunked(EVENT_ID_BATCH).forEach { batch ->
context.contentResolver.query(
CalendarContract.Reminders.CONTENT_URI,
REMINDER_PROJECTION,
"${CalendarContract.Reminders.METHOD} = " +
"${CalendarContract.Reminders.METHOD_ALERT} AND " +
"${CalendarContract.Reminders.EVENT_ID} IN (${batch.joinToString(",")})",
null,
null,
)?.use { c ->
while (c.moveToNext()) {
out.getOrPut(c.getLong(0)) { mutableListOf() } += c.getInt(1)
}
}
}
return out
}
override fun reminderMinutes(eventIds: Collection<Long>): Map<Long, List<Int>> =
context.contentResolver.reminderMinutesByEvent(eventIds, alertsOnly = true)
override fun longestReminderMinutes(): Int = context.contentResolver.query(
CalendarContract.Reminders.CONTENT_URI,
@@ -105,8 +86,6 @@ class ProviderReminderInstanceSource @Inject constructor(
)?.use { c -> if (c.moveToFirst()) c.getInt(0) else 0 } ?: 0
private companion object {
const val EVENT_ID_BATCH = 50
val OCCURRENCE_PROJECTION = arrayOf(
CalendarContract.Instances.EVENT_ID,
CalendarContract.Instances.CALENDAR_ID,
@@ -116,10 +95,5 @@ class ProviderReminderInstanceSource @Inject constructor(
CalendarContract.Instances.EVENT_LOCATION,
CalendarContract.Instances.ALL_DAY,
)
val REMINDER_PROJECTION = arrayOf(
CalendarContract.Reminders.EVENT_ID,
CalendarContract.Reminders.MINUTES,
)
}
}
@@ -51,24 +51,34 @@ data class BackupSelection(
/** One backup file series: the calendars it holds and the name its files start with. */
data class BackupTarget(
/** Stable identity of the series in the [BackupLedger]: the calendar id, or [COMBINED_SERIES]. */
val key: String,
val calendarIds: Set<Long>,
val baseName: String,
/** The calendar name written into the file, or null for a combined file. */
val calendarName: String?,
/** Names this calendar's series went by before a rename; their files are pruned with it. */
val formerBaseNames: Set<String> = emptySet(),
)
/** What one run writes and which earlier files it removes afterwards. */
data class BackupFilePlan(
val target: BackupTarget,
val fileName: String,
/** Earlier files of this series that stay, oldest first. */
val keep: List<String>,
/** Earlier files of this series beyond the retention count, oldest first. */
val prune: List<String>,
/** Former names of the series that still have files after [prune], so they stay tracked. */
val liveFormerBaseNames: Set<String> = emptySet(),
)
/**
* The files the automatic backup has written, per series key, oldest first.
* Pruning only ever deletes names recorded here, so a series is its files, not
* whatever currently matches a calendar's name: renames, same-named calendars
* and the user's own files in the folder can't pull in the wrong ones.
*/
typealias BackupLedger = Map<String, List<String>>
const val COMBINED_SERIES = "combined"
/** The combined file's series name; also the fixed name used before #411. */
const val COMBINED_BACKUP_BASE = "calendula-backup"
@@ -84,7 +94,6 @@ private const val ICS_EXTENSION = ".ics"
private const val MAX_BASE_LENGTH = 60
private const val STAMP_PATTERN = "yyyy-MM-dd_HH-mm-ss"
private val STAMP_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern(STAMP_PATTERN)
private const val STAMP_REGEX = "\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}-\\d{2}"
private val FORBIDDEN_CHARS = Regex("[\\\\/:*?\"<>|\\p{Cntrl}]")
private val WHITESPACE = Regex("\\s+")
@@ -100,7 +109,7 @@ fun sanitizeBackupName(name: String, fallback: String = "calendar"): String {
.replace(WHITESPACE, " ")
.trim()
.trimStart('.')
// Cut by code point, so an emoji at the limit isn't split into a lone surrogate.
// By code point, so an emoji at the limit isn't split into a lone surrogate.
val end = if (cleaned.codePointCount(0, cleaned.length) > MAX_BASE_LENGTH) {
cleaned.offsetByCodePoints(0, MAX_BASE_LENGTH)
} else {
@@ -111,21 +120,16 @@ fun sanitizeBackupName(name: String, fallback: String = "calendar"): String {
/**
* The file series the automatic backup writes: one combined file, or one per
* calendar named after it. Names are compared case-insensitively, as most
* storage is; calendars whose names clash (a local and a synced "Personal")
* take their id as a suffix until every series is distinct, so none prunes
* another's files. [previousBases] — the series names each calendar's files
* still carry from earlier runs — let a renamed calendar keep pruning its old
* files.
* calendar named after it. Calendars whose names clash case-insensitively (a
* local and a synced "Personal") take their id as a suffix until every name in
* the run is distinct, so no two series write the same file.
*/
fun backupTargets(
calendars: List<CalendarSource>,
combined: Boolean,
previousBases: Map<Long, Set<String>> = emptyMap(),
): List<BackupTarget> {
fun backupTargets(calendars: List<CalendarSource>, combined: Boolean): List<BackupTarget> {
if (calendars.isEmpty()) return emptyList()
if (combined) {
return listOf(BackupTarget(calendars.map { it.id }.toSet(), COMBINED_BACKUP_BASE, calendarName = null))
return listOf(
BackupTarget(COMBINED_SERIES, calendars.map { it.id }.toSet(), COMBINED_BACKUP_BASE, calendarName = null),
)
}
val bases = calendars.associateTo(LinkedHashMap()) { it.id to sanitizeBackupName(it.displayName) }
while (true) {
@@ -136,15 +140,12 @@ fun backupTargets(
if (clashing.isEmpty()) break
clashing.forEach { (id, base) -> bases[id] = "$base-$id" }
}
val current = bases.values.map { it.lowercase() }.toSet()
return calendars.map { calendar ->
val base = bases.getValue(calendar.id)
BackupTarget(
key = calendar.id.toString(),
calendarIds = setOf(calendar.id),
baseName = base,
baseName = bases.getValue(calendar.id),
calendarName = calendar.displayName,
formerBaseNames = previousBases[calendar.id].orEmpty()
.filterTo(mutableSetOf()) { it.lowercase() !in current },
)
}
}
@@ -154,75 +155,74 @@ fun backupFileName(baseName: String, at: LocalDateTime): String =
"${baseName}_${at.format(STAMP_FORMAT)}$ICS_EXTENSION"
/**
* Plan one run: a new file per target, and which of that target's earlier files
* fall out of the newest [keep] (the new one included). Only names this app
* writes for the target count — `<base>_<stamp>.ics`, plus the pre-#411
* [LEGACY_BACKUP_FILE] for the combined series, which ranks oldest — so a user's
* own files in the folder are never touched.
* Plan one run: a new file per target, and which of the series' recorded files
* ([ledger]) fall out of the newest [keep], the new one included. Recorded files
* no longer in the folder ([existing]) are forgotten. The pre-#411
* [LEGACY_BACKUP_FILE] joins the combined series as its oldest file.
*/
fun planBackupFiles(
targets: List<BackupTarget>,
existing: Collection<String>,
ledger: BackupLedger,
existing: Set<String>,
at: LocalDateTime,
keep: Int,
): List<BackupFilePlan> {
val retain = keep.coerceAtLeast(1)
return targets.map { target ->
val fileName = backupFileName(target.baseName, at)
val series = (target.formerBaseNames + target.baseName).map { base ->
base to Regex("^${Regex.escape(base)}_($STAMP_REGEX)${Regex.escape(ICS_EXTENSION)}$")
val recorded = ledger[target.key].orEmpty()
val legacy = if (target.key == COMBINED_SERIES && LEGACY_BACKUP_FILE !in recorded) {
listOf(LEGACY_BACKUP_FILE)
} else {
emptyList()
}
val earlier = existing
.filter { it != fileName }
.mapNotNull { name ->
series.firstNotNullOfOrNull { (base, regex) ->
regex.find(name)?.let { SeriesFile(name, base, it.groupValues[1]) }
} ?: if (target.baseName == COMBINED_BACKUP_BASE && name == LEGACY_BACKUP_FILE) {
SeriesFile(name, COMBINED_BACKUP_BASE, stamp = "")
} else {
null
}
}
.sortedByDescending { it.stamp }
val kept = earlier.take(retain - 1)
val earlier = (legacy + recorded).filter { it in existing && it != fileName }.distinct()
val kept = earlier.takeLast(retain - 1)
BackupFilePlan(
target = target,
fileName = fileName,
prune = earlier.drop(retain - 1).reversed().map { it.name },
liveFormerBaseNames = kept.map { it.base }.filterTo(mutableSetOf()) { it in target.formerBaseNames },
keep = kept,
prune = earlier.dropLast(kept.size),
)
}
}
private data class SeriesFile(val name: String, val base: String, val stamp: String)
/**
* The series names each calendar's files carry after a run that wrote
* [written]: its current name plus former ones that still have files. Calendars
* not written this run keep what [previous] had.
* The ledger after a run: each written series records what it kept, what it
* failed to delete ([undeleted]) and the file it just wrote ([writtenNames],
* by key, as the provider named it). Series not written this run keep their
* entry while their calendar still exists ([liveKeys]), so a calendar taken
* out of the backup still has its files pruned if it's ever put back.
*/
fun updatedBackupBases(previous: Map<Long, Set<String>>, written: List<BackupFilePlan>): Map<Long, Set<String>> =
previous + written.filter { it.target.calendarName != null }.associate {
it.target.calendarIds.single() to (it.liveFormerBaseNames + it.target.baseName)
fun updatedBackupLedger(
previous: BackupLedger,
written: List<BackupFilePlan>,
writtenNames: Map<String, String>,
undeleted: Set<String>,
liveKeys: Set<String>,
): BackupLedger {
val next = previous.filterKeys { it in liveKeys || it == COMBINED_SERIES }.toMutableMap()
written.forEach { plan ->
val name = writtenNames[plan.target.key] ?: return@forEach
next[plan.target.key] = plan.prune.filter { it in undeleted } + plan.keep + name
}
return next.filterValues { it.isNotEmpty() }
}
private const val BASES_ENTRY_SEP = "|"
private const val BASES_KEY_SEP = "/"
private const val LEDGER_ENTRY_SEP = "|"
private const val LEDGER_KEY_SEP = "/"
/** Stores the id → series names map; both separators are characters a sanitised name can't hold. */
fun persistBackupBases(bases: Map<Long, Set<String>>): String? =
bases.filterValues { it.isNotEmpty() }.takeIf { it.isNotEmpty() }
/** Stores the ledger; both separators are characters no name this app writes can hold. */
fun persistBackupLedger(ledger: BackupLedger): String? =
ledger.filterValues { it.isNotEmpty() }.takeIf { it.isNotEmpty() }
?.entries?.sortedBy { it.key }
?.joinToString(BASES_ENTRY_SEP) { (id, names) ->
(listOf(id.toString()) + names.sorted()).joinToString(BASES_KEY_SEP)
}
?.joinToString(LEDGER_ENTRY_SEP) { (key, names) -> (listOf(key) + names).joinToString(LEDGER_KEY_SEP) }
fun parseBackupBases(stored: String?): Map<Long, Set<String>> =
stored?.split(BASES_ENTRY_SEP).orEmpty().mapNotNull { entry ->
val parts = entry.split(BASES_KEY_SEP)
val id = parts.first().toLongOrNull() ?: return@mapNotNull null
val names = parts.drop(1).filter { it.isNotEmpty() }.toSet()
names.takeIf { it.isNotEmpty() }?.let { id to it }
fun parseBackupLedger(stored: String?): BackupLedger =
stored?.split(LEDGER_ENTRY_SEP).orEmpty().mapNotNull { entry ->
val parts = entry.split(LEDGER_KEY_SEP)
val names = parts.drop(1).filter { it.isNotEmpty() }
parts.first().takeIf { it.isNotEmpty() && names.isNotEmpty() }?.let { it to names }
}.toMap()
/** Closest offered retention count to [stored], so a stray value still shows a row. */
@@ -36,6 +36,8 @@ data class IcsEvent(
val availability: Availability = Availability.Busy,
/** Source calendar name, emitted as `X-CALENDULA-CALENDAR` so a combined backup can fan back out. */
val calendarName: String? = null,
/** The provider calendar the event was read from; not written to the file. */
val calendarId: Long? = null,
)
/**
@@ -98,8 +98,6 @@ fun BackupScreen(
val snackbarHostState = remember { SnackbarHostState() }
// The one-calendar shortcut; the per-calendar selector owns its own launcher.
// The id is taken at the tap, so a result delivered into a recreated screen
// still knows what to export.
var shortcutExportId by rememberSaveable { mutableStateOf<Long?>(null) }
val createBackup = rememberLauncherForActivityResult(
contract = ActivityResultContracts.CreateDocument("text/calendar"),
@@ -345,7 +343,14 @@ private fun BackupContent(
position = Position.Bottom,
onClick = onEditKeep,
)
GroupedHint(backupStatusText(autoBackup.status), style = MaterialTheme.typography.bodySmall)
GroupedHint(
if (selectedCount == 0) {
stringResource(R.string.calendars_auto_backup_nothing_selected)
} else {
backupStatusText(autoBackup.status)
},
style = MaterialTheme.typography.bodySmall,
)
}
}
@@ -395,7 +400,7 @@ private fun ExportCalendarPicker(
)
Button(
onClick = {
runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
runCatching { createBackup.launch(defaultBackupName()) }
},
enabled = selected.isNotEmpty(),
modifier = Modifier
@@ -37,11 +37,10 @@ sealed interface BackupUiState {
*
* A failure is raised only when *neither* is possible — deliberately not
* [calendarListFailure] on its own, which would call an all-hidden device a
* failure while its calendars are still perfectly exportable. When both
* halves are dead the list itself usually says why (no calendars, everything
* switched off); [FailureReason.NoImportTarget] covers the remaining case, where
* calendars exist and are visible but every one of them is read-only, managed or
* not synced to the device.
* failure while its calendars are still perfectly exportable. Since export
* reads hidden and read-only calendars too, both halves are dead only when there
* is no calendar at all, or every one is managed or not synced to the device
* ([FailureReason.NoImportTarget] unless the list itself says why).
*/
fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
val exportable = calendars.filter { it.isBackupCandidate }
@@ -15,6 +15,7 @@ import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
import de.jeanlucmakiola.calendula.domain.CalendarSource
import de.jeanlucmakiola.calendula.domain.backup.isBackedUpByDefault
import de.jeanlucmakiola.calendula.domain.hasVisibilitySwitch
import de.jeanlucmakiola.calendula.domain.orderedForManager
import de.jeanlucmakiola.calendula.ui.common.CalendarView
@@ -483,7 +484,7 @@ private fun List<CalendarSource>.allHidden(): Boolean =
* A read-only subscription is not a backup, so it does not count.
*/
private fun List<CalendarSource>.backupApplies(): Boolean {
val exportable = any { it.isLocal && it.canModifyContents && !it.isManaged }
val exportable = any { it.isBackedUpByDefault }
val syncedTarget = any { !it.isLocal && it.canModifyContents }
return exportable && !syncedTarget
}
+1
View File
@@ -902,6 +902,7 @@
<item quantity="other">%d calendars</item>
</plurals>
<string name="calendars_auto_backup_calendars_none">No calendar selected</string>
<string name="calendars_auto_backup_nothing_selected">No calendar is selected, so nothing is backed up.</string>
<string name="calendars_auto_backup_calendars_hint">Local calendars are backed up unless you turn them off. Synced calendars already live on their server, so add them here only if you want a copy in the backup folder too.</string>
<string name="calendars_auto_backup_combined">Single file</string>
<string name="calendars_auto_backup_combined_on">All calendars in one file</string>
@@ -80,6 +80,7 @@ class BackupPlanTest {
@Test
fun `combined mode is one target holding every calendar`() {
val target = backupTargets(listOf(cal(1L), cal(2L)), combined = true).single()
assertThat(target.key).isEqualTo(COMBINED_SERIES)
assertThat(target.calendarIds).containsExactly(1L, 2L)
assertThat(target.baseName).isEqualTo(COMBINED_BACKUP_BASE)
assertThat(target.calendarName).isNull()
@@ -91,114 +92,129 @@ class BackupPlanTest {
assertThat(backupFileName("Work", at)).isEqualTo("Work_2026-11-13_14-30-05.ics")
}
private val work = BackupTarget("1", setOf(1L), "Work", "Work")
@Test
fun `pruning keeps the newest files of the series and nothing else`() {
val target = BackupTarget(setOf(1L), "Work", "Work")
val existing = listOf(
"Work_2026-11-10_09-00-00.ics",
"Work_2026-11-12_09-00-00.ics",
"Work_2026-11-11_09-00-00.ics",
"Work notes.ics",
"Work_backup.ics",
"Workshop_2026-11-01_09-00-00.ics",
"Work-7_2026-11-01_09-00-00.ics",
)
val plan = planBackupFiles(listOf(target), existing, at, keep = 3).single()
fun `pruning keeps the newest recorded files and nothing else`() {
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics", "Work_c.ics"))
val existing = setOf("Work_a.ics", "Work_b.ics", "Work_c.ics", "Work_2026-11-01_09-00-00.ics", "Work notes.ics")
val plan = planBackupFiles(listOf(work), ledger, existing, at, keep = 3).single()
assertThat(plan.fileName).isEqualTo("Work_2026-11-13_14-30-05.ics")
assertThat(plan.prune).containsExactly("Work_2026-11-10_09-00-00.ics")
assertThat(plan.keep).containsExactly("Work_b.ics", "Work_c.ics").inOrder()
assertThat(plan.prune).containsExactly("Work_a.ics")
}
@Test
fun `keeping one replaces every earlier file`() {
val target = BackupTarget(setOf(1L), "Work", "Work")
val existing = listOf("Work_2026-11-11_09-00-00.ics", "Work_2026-11-12_09-00-00.ics")
val plan = planBackupFiles(listOf(target), existing, at, keep = 1).single()
assertThat(plan.prune).containsExactly("Work_2026-11-11_09-00-00.ics", "Work_2026-11-12_09-00-00.ics").inOrder()
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"))
val plan = planBackupFiles(listOf(work), ledger, setOf("Work_a.ics", "Work_b.ics"), at, keep = 1).single()
assertThat(plan.keep).isEmpty()
assertThat(plan.prune).containsExactly("Work_a.ics", "Work_b.ics").inOrder()
}
@Test
fun `files gone from the folder are forgotten, not counted`() {
val ledger = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"))
val plan = planBackupFiles(listOf(work), ledger, setOf("Work_b.ics"), at, keep = 2).single()
assertThat(plan.keep).containsExactly("Work_b.ics")
assertThat(plan.prune).isEmpty()
}
@Test
fun `a same-named calendar never prunes another calendar's files`() {
// Local "Work" (id 1) was backed up; the user now backs up a synced "Work" (id 9) instead.
val ledger = mapOf("1" to listOf("Work_a.ics"))
val synced = backupTargets(listOf(cal(9L, "Work")), combined = false).single()
val plan = planBackupFiles(listOf(synced), ledger, setOf("Work_a.ics"), at, keep = 1).single()
assertThat(plan.prune).isEmpty()
}
@Test
fun `a rerun in the same second never prunes the file it writes`() {
val target = BackupTarget(setOf(1L), "Work", "Work")
val plan = planBackupFiles(listOf(target), listOf("Work_2026-11-13_14-30-05.ics"), at, keep = 1).single()
val name = "Work_2026-11-13_14-30-05.ics"
val plan = planBackupFiles(listOf(work), mapOf("1" to listOf(name)), setOf(name), at, keep = 1).single()
assertThat(plan.prune).isEmpty()
}
@Test
fun `the pre-411 backup file is the combined series' oldest member`() {
val target = BackupTarget(setOf(1L, 2L), COMBINED_BACKUP_BASE, null)
val existing = listOf(LEGACY_BACKUP_FILE, "calendula-backup_2026-11-12_09-00-00.ics")
assertThat(planBackupFiles(listOf(target), existing, at, keep = 3).single().prune).isEmpty()
assertThat(planBackupFiles(listOf(target), existing, at, keep = 2).single().prune)
val target = BackupTarget(COMBINED_SERIES, setOf(1L, 2L), COMBINED_BACKUP_BASE, null)
val newer = "calendula-backup_2026-11-12_09-00-00.ics"
val ledger = mapOf(COMBINED_SERIES to listOf(newer))
val existing = setOf(LEGACY_BACKUP_FILE, newer)
assertThat(planBackupFiles(listOf(target), ledger, existing, at, keep = 3).single().prune).isEmpty()
assertThat(planBackupFiles(listOf(target), ledger, existing, at, keep = 2).single().prune)
.containsExactly(LEGACY_BACKUP_FILE)
}
@Test
fun `per-calendar series leave the legacy combined file alone`() {
val target = BackupTarget(setOf(1L), "Work", "Work")
val plan = planBackupFiles(listOf(target), listOf(LEGACY_BACKUP_FILE), at, keep = 1).single()
val plan = planBackupFiles(listOf(work), emptyMap(), setOf(LEGACY_BACKUP_FILE), at, keep = 1).single()
assertThat(plan.prune).isEmpty()
}
@Test
fun `the ledger records what the run kept, failed to delete and wrote`() {
val plan = planBackupFiles(
listOf(work),
mapOf("1" to listOf("Work_a.ics", "Work_b.ics")),
setOf("Work_a.ics", "Work_b.ics"),
at,
keep = 2,
).single()
val next = updatedBackupLedger(
previous = mapOf("1" to listOf("Work_a.ics", "Work_b.ics"), "2" to listOf("Home_a.ics"), "7" to listOf("Gone.ics")),
written = listOf(plan),
writtenNames = mapOf("1" to "Work_new (1).ics"),
undeleted = setOf("Work_a.ics"),
liveKeys = setOf("1", "2"),
)
assertThat(next).containsExactly(
"1", listOf("Work_a.ics", "Work_b.ics", "Work_new (1).ics"),
"2", listOf("Home_a.ics"),
)
}
@Test
fun `a series whose write failed keeps its old entry`() {
val plan = planBackupFiles(listOf(work), mapOf("1" to listOf("Work_a.ics")), setOf("Work_a.ics"), at, keep = 1)
val next = updatedBackupLedger(
previous = mapOf("1" to listOf("Work_a.ics")),
written = plan,
writtenNames = emptyMap(),
undeleted = emptySet(),
liveKeys = setOf("1"),
)
assertThat(next).containsExactly("1", listOf("Work_a.ics"))
}
@Test
fun `the ledger round-trips through storage`() {
val ledger = mapOf("3" to listOf("Work_b.ics", "Work_a (1).ics"), COMBINED_SERIES to listOf("calendula-backup_x.ics"))
assertThat(parseBackupLedger(persistBackupLedger(ledger))).isEqualTo(ledger)
assertThat(persistBackupLedger(emptyMap())).isNull()
assertThat(parseBackupLedger("garbage|/x|4/")).isEmpty()
}
@Test
fun `retention snaps to the offered choices`() {
assertThat(normalizeBackupKeep(0)).isEqualTo(1)
assertThat(normalizeBackupKeep(3)).isEqualTo(3)
assertThat(normalizeBackupKeep(50)).isEqualTo(10)
}
@Test
fun `a suffixed name that meets a real one is told apart again`() {
val targets = backupTargets(
listOf(cal(5L, "Work"), cal(6L, "Work"), cal(9L, "Work-5")),
combined = false,
)
assertThat(targets.map { it.baseName }.toSet()).hasSize(3)
assertThat(targets.map { it.baseName }).containsExactly("Work-5-5", "Work-6", "Work-5-9").inOrder()
}
@Test
fun `an emoji at the length limit is not split`() {
val name = "a".repeat(59) + "\uD83D\uDCC5" + "tail"
val cleaned = sanitizeBackupName(name)
assertThat(cleaned).isEqualTo("a".repeat(59) + "\uD83D\uDCC5")
assertThat(Character.isHighSurrogate(cleaned.last())).isFalse()
}
@Test
fun `a renamed calendar keeps pruning the files of its old name`() {
val target = backupTargets(
listOf(cal(1L, "Job")),
combined = false,
previousBases = mapOf(1L to setOf("Work")),
).single()
assertThat(target.formerBaseNames).containsExactly("Work")
val existing = listOf("Work_2026-11-10_09-00-00.ics", "Work_2026-11-12_09-00-00.ics")
val keepTwo = planBackupFiles(listOf(target), existing, at, keep = 2).single()
assertThat(keepTwo.prune).containsExactly("Work_2026-11-10_09-00-00.ics")
assertThat(keepTwo.liveFormerBaseNames).containsExactly("Work")
assertThat(updatedBackupBases(emptyMap(), listOf(keepTwo))).containsExactly(1L, setOf("Work", "Job"))
val keepOne = planBackupFiles(listOf(target), existing, at, keep = 1).single()
assertThat(keepOne.prune).hasSize(2)
assertThat(updatedBackupBases(mapOf(1L to setOf("Work"), 2L to setOf("X")), listOf(keepOne)))
.containsExactly(1L, setOf("Job"), 2L, setOf("X"))
}
@Test
fun `a former name now used by another calendar is not claimed`() {
val targets = backupTargets(
listOf(cal(1L, "Job"), cal(2L, "Work")),
combined = false,
previousBases = mapOf(1L to setOf("Work")),
)
assertThat(targets.first().formerBaseNames).isEmpty()
}
@Test
fun `series names round-trip through storage`() {
val bases = mapOf(3L to setOf("Work", "Job"), 1L to setOf("Home"))
assertThat(parseBackupBases(persistBackupBases(bases))).isEqualTo(bases)
assertThat(persistBackupBases(emptyMap())).isNull()
assertThat(parseBackupBases("garbage|x/y|4/")).isEmpty()
assertThat(sanitizeBackupName(name)).isEqualTo("a".repeat(59) + "\uD83D\uDCC5")
}
}
+3 -3
View File
@@ -471,9 +471,9 @@ restore runs through the normal import, whose targets stay `isEventTarget`. The
automatic backup writes one `<calendar name>_<date>_<time>.ics` series per
calendar, or one `calendula-backup_…` series in combined mode (#411), and prunes
each series to the retention count after its new file has landed. Pruning only
matches names of that series, so nothing else in the folder is touched (a
renamed calendar's old names are remembered in `auto_backup_series` until their
files are gone); the
deletes names recorded in a per-series ledger of files the backup wrote
(`auto_backup_files`, keyed by calendar id), never whatever happens to match a
name, so renames, same-named calendars and the user's own files are safe; the
pre-#411 fixed `calendula-backup.ics` counts as the combined series' oldest file,
and an install that already had a folder stays on the combined layout.