Merge feat/325-copy-events into release/2.25.0

# Conflicts:
#	floret-kit
This commit is contained in:
makiolaj committed 2026-11-18 16:15:43 +01:00
commit 3bc2240407
25 files changed
+1882 -285

No files matched your search

@@ -30,6 +30,9 @@ import de.jeanlucmakiola.calendula.domain.Reminder
import de.jeanlucmakiola.calendula.domain.SearchCandidate
import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX
import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
import de.jeanlucmakiola.calendula.domain.ics.CalendarRows
import de.jeanlucmakiola.calendula.domain.ics.OverrideRow
import de.jeanlucmakiola.calendula.domain.ics.MasterRow
import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
import de.jeanlucmakiola.calendula.domain.ics.semanticReminderMinutes
@@ -91,15 +94,15 @@ interface CalendarDataSource {
fun publishedEventColors(calendarId: Long): List<EventColorOption>
/**
* Every master/one-off event of [calendarIds], whatever kind of calendar
* they are (local, synced, read-only), mapped to [IcsEvent]s. A plain read:
* which calendars may be read for what is the caller's call. Modified-
* occurrence and cancelled-exception rows are excluded (see
* [EventExportProjection]). [allDayReminderTimeMinutes]: needed to write
* all-day reminders as whole-day lead times rather than raw provider
* Every event row of [calendarIds], whatever kind of calendar they are
* (local, synced, read-only): the masters/one-offs and the modified and
* cancelled exception rows, each with the keys that link it to its series
* and tagged with its calendar's name. A plain read: which calendars may be
* read for what is the caller's call. [allDayReminderTimeMinutes]: needed to
* write all-day reminders as whole-day lead times rather than raw provider
* offsets (see [toIcsEvent]).
*/
fun calendarEvents(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): List<IcsEvent>
fun calendarRows(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): CalendarRows
/**
* The non-empty `Events.UID_2445` values present in [calendarId] — used to
@@ -777,24 +780,67 @@ class AndroidCalendarDataSource @Inject constructor(
?: emptyList()
}
override fun calendarEvents(
calendarIds: Set<Long>,
allDayReminderTimeMinutes: Int,
): List<IcsEvent> {
if (calendarIds.isEmpty()) return emptyList()
// Id → display name for the X-CALENDULA-CALENDAR tag a restore uses to
// fan back out; an id that no longer exists drops out here.
val names = calendars()
.filter { it.id in calendarIds }
.associate { it.id to it.displayName }
if (names.isEmpty()) return emptyList()
override fun calendarRows(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): CalendarRows {
if (calendarIds.isEmpty()) return CalendarRows(emptyList(), emptyList())
// The name tags each event for a combined backup's restore to fan back
// out; an id that no longer exists drops out here.
val calendars = calendars().filter { it.id in calendarIds }.associateBy { it.id }
if (calendars.isEmpty()) return CalendarRows(emptyList(), emptyList())
val idList = names.keys.joinToString(",")
// 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 AND " +
"${CalendarContract.Events.ORIGINAL_SYNC_ID} IS NULL"
val selection = "${CalendarContract.Events.CALENDAR_ID} IN (${calendars.keys.joinToString(",")}) AND " +
"${CalendarContract.Events.DELETED} = 0"
val series = mutableListOf<MasterRow>()
val overrides = mutableListOf<OverrideRow>()
forEachExportRow(selection, allDayReminderTimeMinutes) { event ->
val calendarId = getLong(EventExportProjection.IDX_CALENDAR_ID)
val calendar = calendars[calendarId]
// An adapter may stamp the calendar colour on every row; a palette key means it was chosen.
val color = getIntOrNull(EventExportProjection.IDX_EVENT_COLOR)?.takeIf {
it != calendar?.color || !getString(EventExportProjection.IDX_EVENT_COLOR_KEY).isNullOrEmpty()
}
val mapped = event(calendar?.displayName).copy(color = color)
val selfStatus = getIntOrNull(EventExportProjection.IDX_SELF_ATTENDEE_STATUS)
val declined = selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED
val originalId = getLongOrNull(EventExportProjection.IDX_ORIGINAL_ID)
val originalSyncId = getString(EventExportProjection.IDX_ORIGINAL_SYNC_ID)?.takeIf { it.isNotEmpty() }
// Without a link the provider shows the row as an event of its own.
if (originalId == null && originalSyncId == null) {
series += MasterRow(
eventId = getLong(EventExportProjection.IDX_ID),
calendarId = calendarId,
syncId = getString(EventExportProjection.IDX_SYNC_ID)?.takeIf { it.isNotEmpty() },
event = mapped,
declined = declined,
)
} else {
// An exception without its occurrence time can't name what it replaces.
val originalInstance = getLongOrNull(EventExportProjection.IDX_ORIGINAL_INSTANCE_TIME)
?: return@forEachExportRow
overrides += OverrideRow(
calendarId = calendarId,
originalId = originalId,
originalSyncId = originalSyncId,
originalInstance = originalInstance.toKotlinInstantFromEpochMillis(),
event = mapped,
declined = declined,
accepted = selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_ACCEPTED ||
selfStatus == CalendarContract.Attendees.ATTENDEE_STATUS_TENTATIVE,
)
}
}
return CalendarRows(series, overrides)
}
/**
* Hand each Events row matching [selection], oldest first, to [row] with a
* mapper to [IcsEvent] that takes the calendar name to tag it with.
* Reminders are read in one batched pass ahead of the rows.
*/
private fun forEachExportRow(
selection: String,
allDayReminderTimeMinutes: Int,
row: ColumnReader.(event: (calendarName: String?) -> IcsEvent) -> Unit,
) {
val eventIds = resolver.query(
CalendarContract.Events.CONTENT_URI,
arrayOf(CalendarContract.Events._ID),
@@ -803,23 +849,25 @@ class AndroidCalendarDataSource @Inject constructor(
null,
)?.use { c -> c.mapRows { getLong(0) } }.orEmpty()
val reminders = resolver.reminderMinutesByEvent(eventIds, alertsOnly = false)
return resolver.query(
resolver.query(
CalendarContract.Events.CONTENT_URI,
EventExportProjection.COLUMNS,
selection,
null,
CalendarContract.Events.DTSTART + " ASC",
)?.use { c ->
c.mapRows {
val eventId = getLong(EventExportProjection.IDX_ID)
val calendarId = getLong(EventExportProjection.IDX_CALENDAR_ID)
toIcsEvent(
reminderMinutes = reminders[eventId].orEmpty(),
calendarName = names[calendarId],
allDayReminderTimeMinutes = allDayReminderTimeMinutes,
)
val reader = CursorColumnReader(c)
while (c.moveToNext()) {
val eventId = reader.getLong(EventExportProjection.IDX_ID)
reader.row { calendarName ->
reader.toIcsEvent(
reminderMinutes = reminders[eventId].orEmpty(),
calendarName = calendarName,
allDayReminderTimeMinutes = allDayReminderTimeMinutes,
)
}
}
} ?: emptyList()
}
}
override fun existingUids(calendarId: Long): Set<String> = resolver.query(
@@ -868,18 +916,25 @@ class AndroidCalendarDataSource @Inject constructor(
} else {
null
}
event.semanticReminderMinutes().forEach { minutes ->
val providerMinutes = if (reminderDate != null) {
toProviderAllDayMinutes(
semanticMinutes = minutes,
startDate = reminderDate,
zone = zone,
timeOfDayMinutes = allDayReminderTimeMinutes,
)
} else {
minutes
// All or nothing: a row whose reminders failed would count as not added
// and still be there.
try {
event.semanticReminderMinutes().forEach { minutes ->
val providerMinutes = if (reminderDate != null) {
toProviderAllDayMinutes(
semanticMinutes = minutes,
startDate = reminderDate,
zone = zone,
timeOfDayMinutes = allDayReminderTimeMinutes,
)
} else {
minutes
}
insertReminderRow(eventId, providerMinutes)
}
insertReminderRow(eventId, providerMinutes)
} catch (t: Throwable) {
runCatching { resolver.delete(eventUri(eventId), null, null) }
throw t
}
return eventId
}
@@ -62,17 +62,40 @@ interface CalendarRepository {
/**
* Every event of [calendarIds], ready to serialise into an `.ics` backup
* (see [CalendarDataSource.calendarEvents]). Any calendar can be read,
* synced and read-only ones included (#147).
* (see [CalendarDataSource.calendarRows]). Any calendar can be read,
* synced and read-only ones included (#147). Exception rows come out
* flattened ([de.jeanlucmakiola.calendula.domain.ics.flattenOverrides]),
* so a restore keeps moved and deleted occurrences of a series.
*/
suspend fun exportEvents(calendarIds: Set<Long>): List<IcsEvent>
/**
* Bulk-import parsed `.ics` [events] into [targetCalendarId]. Events whose
* UID already exists in the target are skipped (idempotent restore); the
* rest are inserted. See [CalendarDataSource.insertImportedEvent].
* rest are inserted, as is a standalone occurrence whose series is already
* there ([ParsedIcsEvent.overrideOf]). See [CalendarDataSource.insertImportedEvent].
* [onProgress] gets the count of events handled so far before each event
* after the first and once more when all were handled; it may throw to stop
* the import between events.
*/
suspend fun importEvents(targetCalendarId: Long, events: List<ParsedIcsEvent>): IcsImportSummary
suspend fun importEvents(
targetCalendarId: Long,
events: List<ParsedIcsEvent>,
onProgress: (done: Int) -> Unit = {},
): IcsImportSummary
/**
* Copy every event of [sourceCalendarId] into [targetCalendarId] (#325),
* exceptions included (see
* [de.jeanlucmakiola.calendula.domain.ics.planCalendarCopy]). The source is only read. Runs
* through [importEvents], so a re-run skips what an earlier one copied.
* [onProgress] gets (done, total) once the source is read and after each event.
*/
suspend fun copyEvents(
sourceCalendarId: Long,
targetCalendarId: Long,
onProgress: (done: Int, total: Int) -> Unit = { _, _ -> },
): IcsImportSummary
/** Create a new event from a validated form; returns the new `Events._ID`. */
suspend fun createEvent(form: EventForm): Long
@@ -14,6 +14,8 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
import de.jeanlucmakiola.calendula.domain.SearchCandidate
import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
import de.jeanlucmakiola.calendula.domain.ics.flattenOverrides
import de.jeanlucmakiola.calendula.domain.ics.planCalendarCopy
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.Flow
@@ -30,6 +32,8 @@ import kotlinx.coroutines.flow.onStart
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.currentCoroutineContext
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.withContext
import java.util.concurrent.atomic.AtomicLong
import kotlin.time.Instant
@@ -247,12 +251,33 @@ class CalendarRepositoryImpl @Inject constructor(
}
}
override suspend fun exportEvents(calendarIds: Set<Long>) =
withContext(io) { dataSource.calendarEvents(calendarIds, allDayReminderTimeMinutes()) }
override suspend fun exportEvents(calendarIds: Set<Long>) = withContext(io) {
flattenOverrides(dataSource.calendarRows(calendarIds, allDayReminderTimeMinutes()), ::formatExdateStamp)
}
override suspend fun copyEvents(
sourceCalendarId: Long,
targetCalendarId: Long,
onProgress: (done: Int, total: Int) -> Unit,
): IcsImportSummary {
val events = withContext(io) {
planCalendarCopy(
dataSource.calendarRows(setOf(sourceCalendarId), allDayReminderTimeMinutes()),
::formatExdateStamp,
)
}
onProgress(0, events.size)
val context = currentCoroutineContext()
return importEvents(targetCalendarId, events) { done ->
if (done < events.size) context.ensureActive()
onProgress(done, events.size)
}
}
override suspend fun importEvents(
targetCalendarId: Long,
events: List<ParsedIcsEvent>,
onProgress: (done: Int) -> Unit,
): IcsImportSummary = write {
val existing = dataSource.existingUids(targetCalendarId)
// Both are per-calendar, not per-event: looking them up once keeps a
@@ -265,15 +290,21 @@ class CalendarRepositoryImpl @Inject constructor(
var skipped = 0
var failed = 0
var notAttempted = 0
for ((index, event) in events.withIndex()) {
// Occurrences whose standalone copy didn't land, by series UID: the series
// keeps them instead of excluding them for good.
val unexcluded = mutableMapOf<String, MutableList<Instant>>()
// Standalone occurrences ahead of the series they were cut from, however the file is ordered.
val ordered = events.sortedBy { it.overrideOf == null }
for ((index, event) in ordered.withIndex()) {
if (index > 0) onProgress(index)
// A known UID means the event is already in this calendar — skip,
// keeping a restore idempotent (no overwrite this pass).
if (event.uid != null && event.uid in existing) {
if (event.isAlreadyIn(existing)) {
skipped++
continue
}
try {
dataSource.insertImportedEvent(event, targetCalendarId, allDayMinutes, palette)
dataSource.insertImportedEvent(event.keeping(unexcluded), targetCalendarId, allDayMinutes, palette)
imported++
} catch (e: CancellationException) {
throw e
@@ -283,8 +314,8 @@ class CalendarRepositoryImpl @Inject constructor(
Log.w(TAG, "Import stopped: the calendar is no longer writable", e)
// A known UID would have been skipped whatever happened, so it is
// no part of what a retry still has to import.
val remaining = events.drop(index)
val duplicates = remaining.count { it.uid?.let { uid -> uid in existing } == true }
val remaining = ordered.drop(index)
val duplicates = remaining.count { it.isAlreadyIn(existing) }
skipped += duplicates
notAttempted = remaining.size - duplicates
break
@@ -293,9 +324,13 @@ class CalendarRepositoryImpl @Inject constructor(
// rest of the file — foreign exports do carry rows it rejects
// outright (a malformed RRULE throws straight out of insert).
failed++
if (event.overrideOf != null && event.overrideAt != null) {
unexcluded.getOrPut(event.overrideOf) { mutableListOf() } += event.overrideAt
}
Log.w(TAG, "Skipped an unimportable event", e)
}
}
if (notAttempted == 0) onProgress(events.size)
IcsImportSummary(
imported = imported,
skippedDuplicate = skipped,
@@ -376,3 +411,18 @@ class CalendarRepositoryImpl @Inject constructor(
private fun <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = flow {
collect { emit(block()) }
}
/**
* Whether [existing] UIDs already hold this event: its own UID, or — for a
* standalone occurrence of a backed-up or copied series — the series, which
* there carries the override itself.
*/
private fun ParsedIcsEvent.isAlreadyIn(existing: Set<String>): Boolean =
(uid != null && uid in existing) || (overrideOf != null && overrideOf in existing)
/** This series without the exclusions of [unexcluded] occurrences whose standalone copy failed. */
private fun ParsedIcsEvent.keeping(unexcluded: Map<String, List<Instant>>): ParsedIcsEvent {
val kept = uid?.let(unexcluded::get) ?: return this
val stamps = kept.map { formatExdateStamp(it.toEpochMilliseconds(), isAllDay) }.toSet()
return copy(exDates = exDates.filterNot { it in stamps })
}
@@ -684,7 +684,7 @@ private const val TZID_PREFIX = "TZID="
* are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
* reads off the UTC calendar day.
*/
private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String =
internal fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String =
formatExdateStamp(
local = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC).toLocalDateTime(),
isAllDay = isAllDay,
@@ -851,10 +851,12 @@ internal fun buildImportedEventValues(
put(CalendarContract.Events.TITLE, event.summary.trim())
put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
put(CalendarContract.Events.DTSTART, startMillis)
if (event.recurrenceRule == null) {
if (event.recurrenceRule == null && event.recurrenceDates.isEmpty()) {
put(CalendarContract.Events.DTEND, endMillis)
} else {
put(CalendarContract.Events.RRULE, event.recurrenceRule)
event.recurrenceRule?.let { put(CalendarContract.Events.RRULE, it) }
event.recurrenceDates.takeIf { it.isNotEmpty() }
?.let { put(CalendarContract.Events.RDATE, it.joinToString(",")) }
put(
CalendarContract.Events.DURATION,
importDuration(startMillis, endMillis, event.isAllDay),
@@ -866,6 +868,9 @@ internal fun buildImportedEventValues(
// timed rows keep the event's own zone.
put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
if (event.accessLevel != AccessLevel.Default) {
put(CalendarContract.Events.ACCESS_LEVEL, event.accessLevel.toProviderValue())
}
put(CalendarContract.Events.STATUS, event.status.forNewEvent().toProviderStatus())
event.location?.trim()?.takeIf { it.isNotEmpty() }
?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
@@ -1,9 +1,13 @@
package de.jeanlucmakiola.calendula.data.calendar
import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
import de.jeanlucmakiola.calendula.domain.AccessLevel
import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneId
import java.time.format.DateTimeFormatter
/**
* Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
@@ -28,6 +32,8 @@ internal fun ColumnReader.toIcsEvent(
val dtStart = getLong(EventExportProjection.IDX_DTSTART)
val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0
val timezone = getString(EventExportProjection.IDX_EVENT_TIMEZONE)
val rdates = exportRecurrenceDates(getString(EventExportProjection.IDX_RDATE), isAllDay, timezone, dtStart)
// Unclamped: the writer renders DTEND as stored.
val end = endMillis(dtStart, EventExportProjection.IDX_DTEND, EventExportProjection.IDX_DURATION)
@@ -38,17 +44,12 @@ internal fun ColumnReader.toIcsEvent(
start = dtStart.toKotlinInstantFromEpochMillis(),
end = end.toKotlinInstantFromEpochMillis(),
isAllDay = isAllDay,
zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
?: "UTC",
zoneId = timezone?.takeIf { it.isNotBlank() } ?: "UTC",
recurrenceRule = rrule,
exDates = if (rrule == null) {
exDates = if (rrule == null && rdates.isEmpty()) {
emptyList()
} else {
exportExDates(
getString(EventExportProjection.IDX_EXDATE),
isAllDay,
getString(EventExportProjection.IDX_EVENT_TIMEZONE),
)
exportExDates(getString(EventExportProjection.IDX_EXDATE), isAllDay, timezone, dtStart)
},
location = getString(EventExportProjection.IDX_LOCATION),
description = getString(EventExportProjection.IDX_DESCRIPTION),
@@ -63,6 +64,8 @@ internal fun ColumnReader.toIcsEvent(
status = eventStatus(EventExportProjection.IDX_STATUS),
availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
calendarName = calendarName,
recurrenceDates = rdates,
accessLevel = getIntOrNull(EventExportProjection.IDX_ACCESS_LEVEL)?.let(::mapAccessLevel) ?: AccessLevel.Default,
)
}
@@ -94,16 +97,53 @@ internal fun exportExDates(
exdate: String?,
isAllDay: Boolean,
eventTimezone: String? = null,
seriesStartMillis: Long? = null,
): List<String> {
if (exdate.isNullOrBlank()) return emptyList()
val zone = exdateListZone(exdate, eventTimezone)
return exdateStamps(exdate)
.map { stamp ->
if (isAllDay) {
stamp.substringBefore('T')
} else {
canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp
// Several properties are stored one per line, each with its own zone prefix.
return exdate.lines().filter { it.isNotBlank() }.flatMap { line ->
val zone = exdateListZone(line, eventTimezone)
exdateStamps(line).mapNotNull { stamp ->
when {
isAllDay -> stamp.substringBefore('T')
// A bare day on a timed series means the occurrence at the series' time of day.
seriesStartMillis != null && BARE_DAY.matches(stamp) -> atSeriesTime(stamp, seriesStartMillis, zone)
else -> canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp
}
}
}
.filter { (if (isAllDay) BARE_DAY else UTC_STAMP).matches(it) }
.distinct()
}
/**
* The row's `RDATE` in the same shape [exportExDates] gives `EXDATE` — the list
* shares its `<zone>;<stamps>` form. A `PERIOD` entry (`start/end`) keeps only its
* start: the occurrence then runs the series' own length. Anything that still
* isn't a date or a UTC stamp is dropped, since a file can't name it.
*/
internal fun exportRecurrenceDates(
rdate: String?,
isAllDay: Boolean,
eventTimezone: String? = null,
seriesStartMillis: Long? = null,
): List<String> {
if (rdate.isNullOrBlank()) return emptyList()
// The zone prefix may hold a '/' of its own (Europe/Berlin), so only the stamps lose their period end.
val starts = rdate.lines().joinToString("\n") { line ->
val stamps = line.withoutExdateParameters()
line.dropLast(stamps.length) + stamps.split(',').joinToString(",") { it.substringBefore('/') }
}
return exportExDates(starts, isAllDay, eventTimezone, seriesStartMillis)
}
/** [day] (`yyyyMMdd`) at the wall-clock time the series starts at in [zone], as a UTC stamp. */
private fun atSeriesTime(day: String, seriesStartMillis: Long, zone: ZoneId): String? {
val date = runCatching { LocalDate.parse(day, DateTimeFormatter.BASIC_ISO_DATE) }.getOrNull() ?: return null
val time = Instant.ofEpochMilli(seriesStartMillis).atZone(zone).toLocalTime()
return formatExdateStamp(date.atTime(time).atZone(zone).toInstant().toEpochMilli(), isAllDay = false)
}
private val BARE_DAY = Regex("""\d{8}""")
private val UTC_STAMP = Regex("""\d{8}T\d{6}Z""")
@@ -152,14 +152,13 @@ internal object EventDetailProjection {
}
/**
* Master/one-off Events rows for a whole-calendar backup. Unlike
* Every Events row of a whole-calendar backup or copy. Unlike
* [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
* backups) and `DURATION` (recurring rows carry it instead of DTEND), plus
* `EXDATE` so a series exports the occurrences deleted from it. Modified-
* occurrence and cancelled-exception rows are filtered out by the query
* (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides aren't exported — a
* documented v1 limit (import skips them too). EXDATE is unaffected by that
* filter: it lives on the master row, not on an exception of its own.
* `EXDATE` so a series exports the occurrences deleted from it. Exception rows
* are read too and told apart by their series-link columns; see
* [de.jeanlucmakiola.calendula.domain.ics.flattenOverrides] for how they are
* written out.
*/
internal object EventExportProjection {
val COLUMNS: Array<String> = arrayOf(
@@ -178,6 +177,15 @@ internal object EventExportProjection {
CalendarContract.Events.STATUS,
CalendarContract.Events.AVAILABILITY,
CalendarContract.Events.CALENDAR_ID,
CalendarContract.Events.EVENT_COLOR,
CalendarContract.Events._SYNC_ID,
CalendarContract.Events.ORIGINAL_ID,
CalendarContract.Events.ORIGINAL_SYNC_ID,
CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
CalendarContract.Events.RDATE,
CalendarContract.Events.ACCESS_LEVEL,
CalendarContract.Events.EVENT_COLOR_KEY,
CalendarContract.Events.SELF_ATTENDEE_STATUS,
)
const val IDX_ID = 0
@@ -195,6 +203,15 @@ internal object EventExportProjection {
const val IDX_STATUS = 12
const val IDX_AVAILABILITY = 13
const val IDX_CALENDAR_ID = 14
const val IDX_EVENT_COLOR = 15
const val IDX_SYNC_ID = 16
const val IDX_ORIGINAL_ID = 17
const val IDX_ORIGINAL_SYNC_ID = 18
const val IDX_ORIGINAL_INSTANCE_TIME = 19
const val IDX_RDATE = 20
const val IDX_ACCESS_LEVEL = 21
const val IDX_EVENT_COLOR_KEY = 22
const val IDX_SELF_ATTENDEE_STATUS = 23
}
/**
@@ -0,0 +1,74 @@
package de.jeanlucmakiola.calendula.domain.ics
import de.jeanlucmakiola.calendula.domain.EventStatus
import kotlin.time.Duration.Companion.days
/**
* The events a calendar copy (#325) inserts into its target, in the shape
* `importEvents` takes: the source's rows flattened as [flattenOverrides] does
* for a backup, minus cancelled series and one-offs, which would arrive live
* (an insert can't be cancelled), and declined invitations and occurrences. Attendees and organizer are never read.
*
* Idempotent per snapshot: `importEvents` skips a UID the target already holds,
* and an [IcsEvent.overrideOf] occurrence whose series it holds, so a re-run
* keeps the earlier copy of an occurrence changed since rather than adding a
* second one beside it.
*/
fun planCalendarCopy(
rows: CalendarRows,
exdateStamp: (occurrenceMillis: Long, isAllDay: Boolean) -> String,
): List<ParsedIcsEvent> {
val declinedSeries = rows.series.filter { it.declined }
val declinedIds = declinedSeries.map { it.eventId }.toSet()
val declinedSyncIds = declinedSeries.filter { it.syncId != null }.map { it.calendarId to it.syncId }.toSet()
fun OverrideRow.ofDeclinedSeries() =
originalId in declinedIds || (originalSyncId != null && (calendarId to originalSyncId) in declinedSyncIds)
val live = CalendarRows(
series = rows.series.filterNot { it.event.status == EventStatus.Cancelled },
// A declined occurrence is as good as deleted here, and so is one of a
// declined series the user didn't accept on its own.
overrides = rows.overrides.map {
if (it.declined || (it.ofDeclinedSeries() && !it.accepted)) {
it.copy(event = it.event.copy(status = EventStatus.Cancelled))
} else {
it
}
},
)
// A declined series still hands its accepted occurrences on before it goes.
// The flattened series follow the standalone occurrences, one per row in order.
val flat = flattenOverrides(live, exdateStamp)
val standalone = flat.size - live.series.size
return flat.filterIndexed { i, _ -> i < standalone || live.series[i - standalone].eventId !in declinedIds }
.map { it.toParsedIcsEvent() }
}
/**
* [IcsEvent] read back as if [IcsWriter] had written it and [IcsParser] had read
* it, without the text in between. Unlike that round trip it keeps a one-off's
* own time zone (the writer pins it to UTC) and the event's colour (not part of
* the file format).
*/
fun IcsEvent.toParsedIcsEvent(): ParsedIcsEvent = ParsedIcsEvent(
uid = uid,
summary = summary,
start = start,
// RFC 5545 §3.6.1: an all-day event lasts at least its one day; zero-length
// it expands into no instance at all.
end = if (isAllDay && end <= start) start + 1.days else end,
isAllDay = isAllDay,
zoneId = zoneId,
recurrenceRule = recurrenceRule?.takeIf { it.isNotBlank() }?.removePrefix("RRULE:"),
recurrenceDates = recurrenceDates.filter { it.isNotBlank() }.distinct(),
location = location,
description = description,
// The writer emits only lead times; a negative one would be an alarm after the start.
reminderMinutes = reminderMinutes.filter { it >= 0 }.distinct(),
status = status,
availability = availability,
accessLevel = accessLevel,
color = color,
overrideOf = overrideOf,
overrideAt = overrideAt,
exDates = if (recurs) exDates.filter { it.isNotBlank() }.distinct() else emptyList(),
)
@@ -0,0 +1,99 @@
package de.jeanlucmakiola.calendula.domain.ics
import de.jeanlucmakiola.calendula.domain.EventStatus
import kotlin.time.Instant
/**
* A master or one-off Events row of a calendar being backed up or copied, with
* the provider keys its exception rows point back through.
*/
data class MasterRow(
val eventId: Long,
val calendarId: Long,
val syncId: String?,
val event: IcsEvent,
/** The user declined this invitation. */
val declined: Boolean = false,
)
/**
* An exception row: a modified or cancelled occurrence of the series named by
* [originalId] / [originalSyncId] in [calendarId], standing in for the
* occurrence that would have started at [originalInstance].
*/
data class OverrideRow(
val calendarId: Long,
val originalId: Long?,
val originalSyncId: String?,
val originalInstance: Instant,
val event: IcsEvent,
/** The user declined this occurrence. */
val declined: Boolean = false,
/** The user accepted (or tentatively accepted) this occurrence on its own. */
val accepted: Boolean = false,
) {
val isCancelled: Boolean get() = event.status == EventStatus.Cancelled
}
/** Every event row a backup or copy reads: series/one-offs and their exception rows. */
data class CalendarRows(
val series: List<MasterRow>,
val overrides: List<OverrideRow>,
)
/**
* [rows] as plain events with no exception rows left, the shape both a backup
* file and a copied calendar need: neither can hold an exception row, since one
* only attaches to its series through a `_sync_id` (and an `.ics` restore skips
* `RECURRENCE-ID` overrides).
*
* Every override excludes its occurrence from the series (`EXDATE`), and a
* modified one comes along as a standalone event at its own times, marked
* [IcsEvent.overrideOf] its series — what Calendula itself writes for "only this
* event" on an unsynced series. Its UID is derived from the series' UID and the
* occurrence, so it is the same on every run. Overrides whose series isn't
* among the rows are left out; the provider doesn't show them either.
*
* Standalone occurrences come first; `importEvents` enforces that order for
* any file, so an import cut short leaves at worst an occurrence missing its
* series, never a series missing an occurrence.
*
* [exdateStamp] formats an occurrence as an `EXDATE` entry in the provider's
* shape, the same one Calendula's own exclusions use. A cancelled series'
* modified occurrences stay cancelled.
*/
fun flattenOverrides(
rows: CalendarRows,
exdateStamp: (occurrenceMillis: Long, isAllDay: Boolean) -> String,
): List<IcsEvent> {
val byId = rows.series.associateBy { it.eventId }
// Sync ids are only unique within an account, so the link is per calendar.
val bySyncId = rows.series.filter { it.syncId != null }.associateBy { it.calendarId to it.syncId }
val excluded = mutableMapOf<Long, MutableList<String>>()
val detached = mutableListOf<Pair<Long, IcsEvent>>()
for (override in rows.overrides) {
val parent = override.originalId?.let(byId::get)?.takeIf { it.calendarId == override.calendarId }
?: override.originalSyncId?.let { bySyncId[override.calendarId to it] }
?: continue
// An exception to a one-off overrides nothing a plain event could carry.
if (!parent.event.recurs) continue
val occurrence = override.originalInstance.toEpochMilliseconds()
excluded.getOrPut(parent.eventId) { mutableListOf() } += exdateStamp(occurrence, parent.event.isAllDay)
if (override.isCancelled || parent.event.status == EventStatus.Cancelled) continue
detached += override.calendarId to override.event.copy(
uid = "$occurrence-${parent.event.uid}",
recurrenceRule = null,
recurrenceDates = emptyList(),
exDates = emptyList(),
overrideOf = parent.event.uid,
overrideAt = override.originalInstance,
)
}
// Two exception rows for one occurrence would derive the same UID; the same
// series in two calendars legitimately does.
return detached.distinctBy { (calendarId, event) -> calendarId to event.uid }.map { it.second } +
rows.series.map { s ->
val extra = excluded[s.eventId].orEmpty()
if (extra.isEmpty()) s.event else s.event.copy(exDates = (s.event.exDates + extra).distinct())
}
}
@@ -1,5 +1,6 @@
package de.jeanlucmakiola.calendula.domain.ics
import de.jeanlucmakiola.calendula.domain.AccessLevel
import de.jeanlucmakiola.calendula.domain.Availability
import de.jeanlucmakiola.calendula.domain.EventStatus
import kotlin.time.Instant
@@ -36,8 +37,25 @@ 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,
/** Extra occurrences (`RDATE`), in the same shape as [exDates]. */
val recurrenceDates: List<String> = emptyList(),
/** Carried by a calendar copy, not written to a file. */
val accessLevel: AccessLevel = AccessLevel.Default,
/** The event's own colour, null when it shows its calendar's; carried by a calendar copy, not written to a file. */
val color: Int? = null,
/**
* For a modified occurrence written out on its own ([flattenOverrides]): the
* UID of the series it replaces an occurrence of, as `X-CALENDULA-OVERRIDE-OF`.
*/
val overrideOf: String? = null,
/** The occurrence of [overrideOf] this event replaces, as `X-CALENDULA-OVERRIDE-AT`. */
val overrideAt: Instant? = null,
)
/** Whether this is a series: by rule, or by listed dates alone. */
val IcsEvent.recurs: Boolean
get() = !recurrenceRule.isNullOrBlank() || recurrenceDates.isNotEmpty()
/**
* The UID to export for a provider event. A row that already carries a UID
* (`Events.UID_2445`) keeps it; otherwise we synthesise a **stable** one from
@@ -1,5 +1,6 @@
package de.jeanlucmakiola.calendula.domain.ics
import de.jeanlucmakiola.calendula.domain.AccessLevel
import de.jeanlucmakiola.calendula.domain.Availability
import de.jeanlucmakiola.calendula.domain.EventStatus
import de.jeanlucmakiola.calendula.domain.zoneOrNull
@@ -45,6 +46,17 @@ data class ParsedIcsEvent(
val exDates: List<String> = emptyList(),
/** True when this came from a `VTODO` rather than a `VEVENT`. */
val isTask: Boolean = false,
/**
* The UID of the series this standalone occurrence replaces one occurrence
* of (`X-CALENDULA-OVERRIDE-OF`). An import skips it where that series
* already is, since the series there carries its own override.
*/
val overrideOf: String? = null,
/** The occurrence of [overrideOf] this event replaces (`X-CALENDULA-OVERRIDE-AT`). */
val overrideAt: Instant? = null,
/** Extra occurrences (`RDATE`), in the same shape as [exDates]. */
val recurrenceDates: List<String> = emptyList(),
val accessLevel: AccessLevel = AccessLevel.Default,
)
/**
@@ -212,7 +224,10 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
var calendarColor: Int? = null
val reminders = mutableListOf<Int>()
val exDateLines = mutableListOf<IcsContentLine>()
val rDateLines = mutableListOf<IcsContentLine>()
var skipAsOverride = false
var overrideOf: String? = null
var overrideAt: Instant? = null
var i = 0
while (i < body.size) {
@@ -233,6 +248,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
"DURATION" -> duration = line.value.trim()
"RRULE" -> rrule = line.value.trim().ifEmpty { null }
"EXDATE" -> exDateLines.add(line)
"RDATE" -> rDateLines.add(line)
"LOCATION" -> location = unescapeText(line.value).ifEmpty { null }
"DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null }
"STATUS" -> status = mapIcsStatus(line.value)
@@ -241,6 +257,8 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
else Availability.Busy
"RECURRENCE-ID" -> skipAsOverride = true
"ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored)
"X-CALENDULA-OVERRIDE-OF" -> overrideOf = unescapeText(line.value).trim().ifEmpty { null }
"X-CALENDULA-OVERRIDE-AT" -> overrideAt = parseBasicDateTime(line.value.trim())?.toInstant(TimeZone.UTC)
"X-CALENDULA-CALENDAR" ->
calendarName = unescapeText(line.value).trim().ifEmpty { calendarName }
// Fossify names the source calendar per event; it never writes
@@ -279,6 +297,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
val recurrence = sanitizeRrule(rrule)
if (recurrence.repaired) warnings.add(IcsParseWarning.RecurrenceRuleRepaired)
val end = resolveEnd(start, dtEnd, duration)
val recurrenceDates = normalizeExDates(rDateLines, start)
return ParsedIcsEvent(
uid = uid,
summary = summary,
@@ -294,12 +313,15 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
availability = availability,
calendarName = calendarName ?: category,
color = eventColor ?: calendarColor,
exDates = if (recurrence.rule == null) {
exDates = if (recurrence.rule == null && recurrenceDates.isEmpty()) {
emptyList()
} else {
normalizeExDates(exDateLines, start)
},
recurrenceDates = recurrenceDates,
isTask = isTask,
overrideOf = overrideOf,
overrideAt = overrideAt,
)
}
@@ -334,13 +356,16 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
* still means the day it spells out; resolving it to an instant first and
* reading *that* back in UTC would roll a midnight east of UTC onto the day
* before and exclude an occurrence that doesn't exist.
*
* `RDATE` shares the value form and is read here too.
*/
private fun normalizeExDates(lines: List<IcsContentLine>, start: IcsDateTime): List<String> {
if (lines.isEmpty()) return emptyList()
val startZone = zoneOrNull(start.zoneId) ?: deviceZone
val startTime = start.instant.toLocalDateTime(startZone).time
return lines
.flatMap { line -> line.value.split(',').map { line to it.trim() } }
// An RDATE PERIOD (`start/end`) counts by its start.
.flatMap { line -> line.value.split(',').map { line to it.trim().substringBefore('/') } }
.mapNotNull { (line, token) ->
when {
token.isEmpty() -> null
@@ -47,6 +47,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
appendTimes(event)
event.recurrenceRule?.takeIf { it.isNotBlank() }
?.let { add("RRULE:${it.removePrefix("RRULE:")}") }
appendRecurrenceDates(event)
appendExDates(event)
event.location?.takeIf { it.isNotBlank() }
?.let { add("LOCATION:${escapeText(it)}") }
@@ -56,6 +57,9 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
add("TRANSP:${transpValue(event.availability)}")
event.calendarName?.takeIf { it.isNotBlank() }
?.let { add("X-CALENDULA-CALENDAR:${escapeText(it)}") }
event.overrideOf?.takeIf { it.isNotBlank() }
?.let { add("X-CALENDULA-OVERRIDE-OF:${escapeText(it)}") }
event.overrideAt?.let { add("X-CALENDULA-OVERRIDE-AT:${it.toUtcBasic()}") }
event.reminderMinutes.filter { it >= 0 }.distinct().forEach { minutes ->
appendAlarm(minutes, event.summary)
}
@@ -68,7 +72,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
add("DTEND;VALUE=DATE:${event.end.toLocalDateTime(TimeZone.UTC).date.toBasic()}")
}
// Recurring: anchor to wall-clock in the event's own zone.
event.recurrenceRule?.isNotBlank() == true -> {
event.recurs -> {
val zone = zoneOrNull(event.zoneId)
if (zone != null) {
add("DTSTART;TZID=${event.zoneId}:${event.start.toLocalDateTime(zone).toBasic()}")
@@ -85,6 +89,14 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
}
}
/** Extra occurrences: the same UTC stamps / `VALUE=DATE` days as [appendExDates]. */
private fun MutableList<String>.appendRecurrenceDates(event: IcsEvent) {
val stamps = event.recurrenceDates.filter { it.isNotBlank() }.distinct()
if (stamps.isEmpty()) return
val prefix = if (event.isAllDay) "RDATE;VALUE=DATE:" else "RDATE:"
add(prefix + stamps.joinToString(","))
}
/**
* The series' deleted occurrences. RFC 5545 ties `EXDATE`'s value type to
* `DTSTART`'s, so an all-day series needs the explicit `VALUE=DATE` — without
@@ -92,7 +104,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
* recurring event: an exclusion names an occurrence, and a one-off has none.
*/
private fun MutableList<String>.appendExDates(event: IcsEvent) {
if (event.recurrenceRule.isNullOrBlank()) return
if (!event.recurs) return
val stamps = event.exDates.filter { it.isNotBlank() }.distinct()
if (stamps.isEmpty()) return
val prefix = if (event.isAllDay) "EXDATE;VALUE=DATE:" else "EXDATE:"
@@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ContentCopy
import androidx.compose.material.icons.filled.FileDownload
import androidx.compose.material.icons.filled.FileUpload
import androidx.compose.material.icons.filled.Schedule
@@ -89,8 +90,11 @@ fun BackupScreen(
onImport: (Uri) -> Unit,
visible: Boolean = true,
viewModel: CalendarsViewModel = hiltViewModel(),
copyViewModel: CopyEventsViewModel = hiltViewModel(),
) {
val state by viewModel.backupState.collectAsStateWithLifecycle()
val copyRun by copyViewModel.run.collectAsStateWithLifecycle()
var showCopy by rememberSaveable { mutableStateOf(false) }
val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle()
@@ -158,6 +162,9 @@ fun BackupScreen(
is BackupUiState.Ready -> BackupContent(
exportable = s.exportable,
canImport = s.canImport,
canCopy = s.canCopy,
copyRun = copyRun,
onCopy = { showCopy = true },
autoBackup = autoBackup,
viewModel = viewModel,
onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
@@ -177,6 +184,25 @@ fun BackupScreen(
}
}
// Not gated on Ready: a running copy keeps its progress and Cancel whatever the list does.
if (showCopy) {
val calendars by copyViewModel.calendars.collectAsStateWithLifecycle()
val selection by copyViewModel.selection.collectAsStateWithLifecycle()
CopyEventsScreen(
calendars = calendars,
selection = selection,
run = copyRun,
onSelectSource = copyViewModel::setSource,
onSelectTarget = copyViewModel::setTarget,
onStart = copyViewModel::start,
onCancel = copyViewModel::cancel,
onClearFinished = copyViewModel::clearFinished,
onDismiss = {
showCopy = false
copyViewModel.clearFinished()
},
)
}
// Gated on Ready rather than resetting the flag when the state leaves it:
// flipping it here would be a write during composition.
(state as? BackupUiState.Ready)?.let { ready ->
@@ -249,6 +275,9 @@ private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.i
private fun BackupContent(
exportable: List<CalendarSource>,
canImport: Boolean,
canCopy: Boolean,
copyRun: CopyRunState,
onCopy: () -> Unit,
autoBackup: AutoBackupUiState,
viewModel: CalendarsViewModel,
onRestore: () -> Unit,
@@ -274,10 +303,11 @@ private fun BackupContent(
GroupedHint(restoreSummary, style = MaterialTheme.typography.bodySmall)
GroupedRow(
title = stringResource(R.string.calendars_restore_action),
position = Position.Alone,
position = if (copyRun != CopyRunState.Idle) Position.Top else Position.Alone,
leading = { LeadingAvatar(Icons.Default.FileUpload) },
onClick = onRestoreClick,
)
if (copyRun != CopyRunState.Idle) CopyEventsRow(copyRun, Position.Bottom, onCopy)
return
}
@@ -296,6 +326,8 @@ private fun BackupContent(
leading = { LeadingAvatar(Icons.Default.FileUpload) },
onClick = onRestoreClick,
)
// A running or finished copy keeps its row, the way back to its sheet.
if (canCopy || copyRun != CopyRunState.Idle) CopyEventsRow(copyRun, Position.Middle, onCopy)
GroupedRow(
title = stringResource(R.string.calendars_auto_backup),
summary = stringResource(R.string.calendars_auto_backup_hint),
@@ -361,6 +393,23 @@ private fun BackupContent(
}
}
@Composable
private fun CopyEventsRow(copyRun: CopyRunState, position: Position, onClick: () -> Unit) {
GroupedRow(
title = stringResource(R.string.calendars_copy_action),
summary = when (copyRun) {
is CopyRunState.Running -> copyProgressText(copyRun)
is CopyRunState.Done -> stringResource(copyRun.titleRes)
CopyRunState.Cancelled -> stringResource(R.string.calendars_copy_cancelled)
CopyRunState.Failed -> stringResource(R.string.calendars_copy_failed)
CopyRunState.Idle -> stringResource(R.string.calendars_copy_summary)
},
position = position,
leading = { LeadingAvatar(Icons.Default.ContentCopy) },
onClick = onClick,
)
}
/**
* Choose which calendars to include in a one-time `.ics` export. Starts on the
* calendars a backup covers by default, or on all of them when none is; the Export action opens the SAF save dialog and hands back
@@ -24,6 +24,8 @@ sealed interface BackupUiState {
data class Ready(
val exportable: List<CalendarSource>,
val canImport: Boolean,
/** Some calendar can be copied into a different one (#325). */
val canCopy: Boolean = false,
) : BackupUiState
}
@@ -50,5 +52,24 @@ fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
calendarListFailure(calendars) ?: FailureReason.NoImportTarget,
)
}
return BackupUiState.Ready(exportable = exportable, canImport = canImport)
return BackupUiState.Ready(
exportable = exportable,
canImport = canImport,
canCopy = copySources(calendars).isNotEmpty(),
)
}
/**
* Calendars a copy can read from: any a backup can (#325), synced and read-only
* ones included, as long as some other calendar can take their events.
*/
fun copySources(calendars: List<CalendarSource>): List<CalendarSource> {
val targets = calendars.filter { it.isEventTarget }
val onlyTarget = targets.singleOrNull()?.id
if (targets.isEmpty()) return emptyList()
return calendars.filter { it.isBackupCandidate && it.id != onlyTarget }
}
/** Calendars a copy from [sourceId] can write into: the import targets, minus the source itself. */
fun copyTargets(calendars: List<CalendarSource>, sourceId: Long?): List<CalendarSource> =
calendars.filter { it.isEventTarget && it.id != sourceId }
@@ -0,0 +1,386 @@
package de.jeanlucmakiola.calendula.ui.calendars
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ColumnScope
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.outlined.Info
import androidx.compose.material.icons.rounded.ArrowDownward
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
import androidx.compose.material3.Icon
import androidx.compose.material3.LinearWavyProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.TextButton
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.pluralStringResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.domain.CalendarSource
import de.jeanlucmakiola.calendula.domain.FailureReason
import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups
import de.jeanlucmakiola.calendula.ui.common.ImportSummaryStats
import de.jeanlucmakiola.calendula.ui.common.ResultBadge
import de.jeanlucmakiola.calendula.ui.common.ResultMessage
import de.jeanlucmakiola.calendula.ui.common.importSummaryNotes
import de.jeanlucmakiola.floret.components.OnboardingPrimaryButton
import de.jeanlucmakiola.floret.components.ResultBadge as FloretResultBadge
import de.jeanlucmakiola.calendula.ui.common.orUnnamed
import de.jeanlucmakiola.floret.components.FullScreenPicker
import de.jeanlucmakiola.floret.components.GroupedHint
import de.jeanlucmakiola.floret.components.GroupedListInset
import de.jeanlucmakiola.floret.components.IconInfoCard
/**
* Copy every event of one calendar into another (#325), in the import flow's
* steps: pick the source, pick the target and copy, watch it run, see the result.
* The run lives in [CopyEventsViewModel], so the screen can be closed and
* reopened mid-copy.
*/
@Composable
fun CopyEventsScreen(
calendars: CopyCalendars,
selection: CopySelection,
run: CopyRunState,
onSelectSource: (Long) -> Unit,
onSelectTarget: (Long) -> Unit,
onStart: () -> Unit,
onCancel: () -> Unit,
onClearFinished: () -> Unit,
onDismiss: () -> Unit,
) {
val list = (calendars as? CopyCalendars.Ready)?.calendars.orEmpty()
val sources = remember(list) { copySources(list) }
val source = sources.firstOrNull { it.id == selection.sourceId }
val targets = remember(list, source?.id) { copyTargets(list, source?.id) }
val target = targets.firstOrNull { it.id == selection.targetId }
var step by rememberSaveable { mutableStateOf(CopyStep.Source) }
val idle = run == CopyRunState.Idle
// The run's ends, held once seen so a calendar gone or a list reloading mid-run doesn't blank them.
val runSource = rememberLastSeen(selection.sourceId, list)
val runTarget = rememberLastSeen(selection.targetId, list)
// A source that stopped qualifying sends the target step back to the start.
// Keyed on the chosen id too: right after a pick the selection may not have arrived yet.
LaunchedEffect(step, selection.sourceId, source, calendars) {
val gone = selection.sourceId != null && source == null && calendars is CopyCalendars.Ready
if (step == CopyStep.Target && gone) step = CopyStep.Source
}
FullScreenPicker(
title = stringResource(
when {
!idle -> R.string.calendars_copy_action
step == CopyStep.Source -> R.string.calendars_copy_from_title
else -> R.string.calendars_copy_to_title
},
),
onDismiss = { if (idle && step == CopyStep.Target) step = CopyStep.Source else onDismiss() },
// The target step's back only steps back, so it mustn't preview closing the screen.
predictiveBack = !(idle && step == CopyStep.Target),
scrollable = idle,
actions = {
if (idle && step == CopyStep.Target) {
Button(
onClick = onStart,
enabled = source != null && target != null,
modifier = Modifier.padding(end = 12.dp),
) {
Text(stringResource(R.string.calendars_copy_start))
}
}
},
) {
if (!idle) {
val copyMore = {
onClearFinished()
step = CopyStep.Source
}
CopyRun(
run = run,
source = runSource,
target = runTarget,
onCancel = onCancel,
// A retry only where the picker would still offer both ends; otherwise pick again.
onRetry = if (source != null && target != null) onStart else copyMore,
onCopyMore = copyMore,
onClose = onDismiss,
)
return@FullScreenPicker
}
when (calendars) {
CopyCalendars.Loading -> {
Box(Modifier.fillMaxWidth().padding(32.dp), contentAlignment = Alignment.Center) {
CircularProgressIndicator()
}
return@FullScreenPicker
}
CopyCalendars.Failure -> {
CalendarFailure(reason = FailureReason.ProviderUnavailable, onRetry = onDismiss)
return@FullScreenPicker
}
is CopyCalendars.Ready -> Unit
}
if (sources.isEmpty()) {
GroupedHint(stringResource(R.string.calendars_copy_none))
return@FullScreenPicker
}
when (step) {
CopyStep.Source -> {
IconInfoCard(
icon = Icons.Outlined.Info,
iconContentDescription = null,
modifier = Modifier.padding(horizontal = GroupedListInset),
) {
Text(stringResource(R.string.calendars_copy_hint), style = MaterialTheme.typography.bodyMedium)
}
Spacer(Modifier.height(16.dp))
CalendarPickerGroups(
calendars = sources,
selectedId = source?.id,
onSelect = {
onSelectSource(it)
step = CopyStep.Target
},
)
}
CopyStep.Target -> {
CopyRouteCard(source, target, Modifier.padding(horizontal = GroupedListInset))
Spacer(Modifier.height(16.dp))
CalendarPickerGroups(
calendars = targets,
selectedId = target?.id,
onSelect = onSelectTarget,
)
}
}
}
}
private enum class CopyStep { Source, Target }
/** Progress while the copy runs, then its outcome; both under the route it took. */
@Composable
private fun ColumnScope.CopyRun(
run: CopyRunState,
source: CalendarSource?,
target: CalendarSource?,
onCancel: () -> Unit,
onRetry: () -> Unit,
onCopyMore: () -> Unit,
onClose: () -> Unit,
) {
// Centred where it fits, scrolling where it doesn't (landscape, large fonts).
BoxWithConstraints(Modifier.fillMaxWidth().weight(1f)) {
Column(
Modifier
.fillMaxWidth()
.verticalScroll(rememberScrollState())
.heightIn(min = maxHeight)
.padding(horizontal = GroupedListInset)
.padding(top = 8.dp, bottom = 24.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.SpaceBetween,
) {
CopyRouteCard(source, target, pickable = false)
Column(Modifier.fillMaxWidth().padding(vertical = 24.dp), horizontalAlignment = Alignment.CenterHorizontally) {
when (run) {
is CopyRunState.Running -> CopyProgress(run)
is CopyRunState.Done -> CopyDone(run)
CopyRunState.Cancelled -> {
FloretResultBadge(
Icons.Default.Close,
MaterialTheme.colorScheme.secondaryContainer,
MaterialTheme.colorScheme.onSecondaryContainer,
)
ResultMessage(stringResource(R.string.calendars_copy_cancelled))
}
CopyRunState.Failed -> {
ResultBadge(error = true)
ResultMessage(stringResource(R.string.calendars_copy_failed))
}
CopyRunState.Idle -> Unit
}
}
when (run) {
is CopyRunState.Running -> TextButton(onClick = onCancel, modifier = Modifier.fillMaxWidth()) {
Text(stringResource(R.string.dialog_cancel))
}
is CopyRunState.Done -> CopyEndButtons(
primary = stringResource(R.string.import_close),
onPrimary = onClose,
secondary = stringResource(R.string.calendars_copy_more),
onSecondary = onCopyMore,
)
CopyRunState.Cancelled, CopyRunState.Failed -> CopyEndButtons(
primary = stringResource(R.string.state_retry),
onPrimary = onRetry,
secondary = stringResource(R.string.import_close),
onSecondary = onClose,
)
CopyRunState.Idle -> Unit
}
}
}
}
/** The calendar with [id] in [list], or the last one seen under that id while it is missing. */
@Composable
private fun rememberLastSeen(id: Long?, list: List<CalendarSource>): CalendarSource? {
val held = remember(id) { mutableStateOf<CalendarSource?>(null) }
list.firstOrNull { it.id == id }?.let { held.value = it }
return held.value
}
@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
private fun CopyProgress(run: CopyRunState.Running) {
val total = run.total
if (total == null || total == 0) {
LinearWavyProgressIndicator(modifier = Modifier.fillMaxWidth())
} else {
LinearWavyProgressIndicator(progress = { run.done.toFloat() / total }, modifier = Modifier.fillMaxWidth())
}
Spacer(Modifier.height(16.dp))
Text(
text = copyProgressText(run),
style = MaterialTheme.typography.titleMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
/** "Reading events…" until the source is read, then "120 of 2,400 events". */
@Composable
fun copyProgressText(run: CopyRunState.Running): String {
val total = run.total ?: return stringResource(R.string.calendars_copy_reading)
return pluralStringResource(R.plurals.calendars_copy_progress, total, run.done, total)
}
@Composable
private fun CopyDone(run: CopyRunState.Done) {
val summary = run.summary
// As on the import: only a run the target cut short reads as an error.
ResultBadge(error = run.stopped)
ResultMessage(
title = stringResource(run.titleRes),
notes = importSummaryNotes(
summary,
stoppedNote = if (run.stopped) {
pluralStringResource(R.plurals.calendars_copy_stopped, summary.notAttempted, summary.notAttempted)
} else {
null
},
),
)
Spacer(Modifier.height(24.dp))
ImportSummaryStats(summary)
}
/** The way on ([secondary], e.g. Copy more) above the way out (Close). */
@Composable
private fun CopyEndButtons(primary: String, onPrimary: () -> Unit, secondary: String, onSecondary: () -> Unit) {
Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(4.dp)) {
OnboardingPrimaryButton(text = primary, onClick = onPrimary)
TextButton(onClick = onSecondary, modifier = Modifier.fillMaxWidth()) { Text(secondary) }
}
}
/**
* Where the events come from and go to, with an arrow between. A missing end
* reads "Choose a calendar" while [pickable], or as unnamed on the run screens.
*/
@Composable
private fun CopyRouteCard(
source: CalendarSource?,
target: CalendarSource?,
modifier: Modifier = Modifier,
pickable: Boolean = true,
) {
Surface(
modifier = modifier.fillMaxWidth(),
shape = RoundedCornerShape(24.dp),
color = MaterialTheme.colorScheme.surfaceContainerHigh,
) {
Column(Modifier.padding(16.dp)) {
CopyRouteEnd(stringResource(R.string.calendars_copy_from), source, pickable)
Box(Modifier.width(40.dp).padding(vertical = 4.dp), contentAlignment = Alignment.Center) {
Surface(shape = CircleShape, color = MaterialTheme.colorScheme.primaryContainer) {
Icon(
Icons.Rounded.ArrowDownward,
contentDescription = null,
tint = MaterialTheme.colorScheme.onPrimaryContainer,
modifier = Modifier.padding(6.dp).size(20.dp),
)
}
}
CopyRouteEnd(stringResource(R.string.calendars_copy_to), target, pickable)
}
}
}
@Composable
private fun CopyRouteEnd(label: String, calendar: CalendarSource?, pickable: Boolean) {
Row(verticalAlignment = Alignment.CenterVertically) {
if (calendar != null) {
CalendarColorChip(calendar.color)
} else {
Surface(
modifier = Modifier.size(40.dp),
shape = CircleShape,
color = MaterialTheme.colorScheme.surfaceContainerHigh,
border = BorderStroke(1.dp, MaterialTheme.colorScheme.outlineVariant),
) {}
}
Spacer(Modifier.width(16.dp))
Column {
Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
Text(
calendar?.displayName?.orUnnamed()
?: if (pickable) stringResource(R.string.calendars_copy_choose) else "".orUnnamed(),
style = MaterialTheme.typography.titleMedium,
color = if (calendar != null) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
if (calendar != null) {
Text(
if (calendar.isLocal) stringResource(R.string.calendars_local_header) else calendar.accountName,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
}
}
@@ -0,0 +1,150 @@
package de.jeanlucmakiola.calendula.ui.calendars
import android.util.Log
import androidx.annotation.StringRes
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
import de.jeanlucmakiola.calendula.domain.CalendarSource
import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
import de.jeanlucmakiola.floret.android.stateWhileSubscribed
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import kotlin.coroutines.cancellation.CancellationException
import javax.inject.Inject
/**
* Copy events from one calendar into another (#325). Scoped to the activity, so
* a copy keeps running across rotation and while the Backup screen is closed;
* finishing the activity or losing the process stops it like [cancel] does,
* and a re-run picks up where it ended.
*/
@HiltViewModel
class CopyEventsViewModel @Inject constructor(
private val repository: CalendarRepository,
private val savedState: SavedStateHandle,
) : ViewModel() {
val calendars: StateFlow<CopyCalendars> =
repository.calendars()
.map<List<CalendarSource>, CopyCalendars> { CopyCalendars.Ready(it) }
.catch { emit(CopyCalendars.Failure) }
.stateWhileSubscribed(scope = viewModelScope, initialValue = CopyCalendars.Loading)
val selection: StateFlow<CopySelection> = combine(
savedState.getStateFlow<Long?>(KEY_SOURCE, null),
savedState.getStateFlow<Long?>(KEY_TARGET, null),
) { source, target -> CopySelection(source, target) }
.stateIn(viewModelScope, SharingStarted.Eagerly, CopySelection())
private val _run = MutableStateFlow<CopyRunState>(CopyRunState.Idle)
val run: StateFlow<CopyRunState> = _run.asStateFlow()
private var job: Job? = null
private val busy: Boolean get() = job?.isCompleted == false
private fun current() = CopySelection(savedState[KEY_SOURCE], savedState[KEY_TARGET])
private fun select(selection: CopySelection) {
savedState[KEY_SOURCE] = selection.sourceId
savedState[KEY_TARGET] = selection.targetId
}
fun setSource(id: Long) {
if (busy) return
select(current().withSource(id))
clearFinished()
}
fun setTarget(id: Long) {
if (busy) return
select(current().copy(targetId = id))
clearFinished()
}
fun start() {
val source = current().sourceId ?: return
val target = current().targetId ?: return
if (busy) return
_run.value = CopyRunState.Running(done = 0, total = null)
job = viewModelScope.launch {
try {
val summary = repository.copyEvents(source, target) { done, total ->
if (done == 0 || done == total || done % (total / 200).coerceAtLeast(1) == 0) {
_run.value = CopyRunState.Running(done, total)
}
}
_run.value = CopyRunState.Done(summary)
} catch (e: CancellationException) {
_run.value = CopyRunState.Cancelled
throw e
} catch (e: Exception) {
Log.w(TAG, "Copy events failed", e)
_run.value = CopyRunState.Failed
}
}
}
fun cancel() {
job?.cancel()
}
/** Back to idle once a finished run's outcome has been seen. */
fun clearFinished() {
if (!busy) _run.value = CopyRunState.Idle
}
private companion object {
const val KEY_SOURCE = "copy_source"
const val KEY_TARGET = "copy_target"
const val TAG = "CopyEvents"
}
}
/** The calendars a copy runs between. */
data class CopySelection(val sourceId: Long? = null, val targetId: Long? = null) {
/** A target equal to the new source is dropped: a calendar is never copied into itself. */
fun withSource(id: Long): CopySelection =
CopySelection(sourceId = id, targetId = targetId?.takeIf { it != id })
}
/** The calendar list the copy screen picks from. */
sealed interface CopyCalendars {
data object Loading : CopyCalendars
data object Failure : CopyCalendars
data class Ready(val calendars: List<CalendarSource>) : CopyCalendars
}
sealed interface CopyRunState {
data object Idle : CopyRunState
/** [total] is null while the source calendar is still being read. */
data class Running(val done: Int, val total: Int?) : CopyRunState
data class Done(val summary: IcsImportSummary) : CopyRunState {
/** The target stopped taking events part way, so some were never tried. */
val stopped: Boolean get() = summary.notAttempted > 0
/** How the run ended, the same words on the row and on the result screen. */
@get:StringRes
val titleRes: Int get() = when {
stopped -> R.string.calendars_copy_stopped_title
summary.failed > 0 -> R.string.calendars_copy_partial
else -> R.string.calendars_copy_done
}
}
data object Cancelled : CopyRunState
data object Failed : CopyRunState
}
@@ -0,0 +1,135 @@
package de.jeanlucmakiola.calendula.ui.common
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.RowScope
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.PriorityHigh
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.pluralStringResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.clearAndSetSemantics
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
import de.jeanlucmakiola.floret.components.ResultBadge as FloretResultBadge
/** floret's [FloretResultBadge] as a check on success, or an exclamation mark in the error colours. */
@Composable
fun ResultBadge(error: Boolean) {
val scheme = MaterialTheme.colorScheme
if (error) {
FloretResultBadge(Icons.Default.PriorityHigh, scheme.errorContainer, scheme.onErrorContainer)
} else {
FloretResultBadge(Icons.Default.Check, scheme.primaryContainer, scheme.onPrimaryContainer)
}
}
/** A result screen's headline under its badge, then its notes; an error note takes the error colour. */
@Composable
fun ResultMessage(title: String, notes: List<ResultNote> = emptyList()) {
Spacer(Modifier.height(24.dp))
Text(
title,
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.onSurface,
textAlign = TextAlign.Center,
)
notes.forEach { note ->
Spacer(Modifier.height(8.dp))
Text(
note.text,
style = MaterialTheme.typography.bodyMedium,
color = if (note.error) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center,
)
}
}
data class ResultNote(val text: String, val error: Boolean = false)
/** The notes an import summary carries: failures, skipped duplicates, then [stoppedNote] when part was never tried. */
@Composable
fun importSummaryNotes(summary: IcsImportSummary, stoppedNote: String?): List<ResultNote> = buildList {
if (summary.failed > 0) add(ResultNote(stringResource(R.string.import_done_failed_note)))
if (summary.skippedDuplicate > 0) add(ResultNote(stringResource(R.string.import_done_dedup_note)))
if (stoppedNote != null) add(ResultNote(stoppedNote, error = true))
}
/** Added / skipped / failed as big-number tiles, the latter two only when non-zero. */
@Composable
fun ImportSummaryStats(summary: IcsImportSummary, modifier: Modifier = Modifier) {
Row(modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
ResultStatCard(
count = summary.imported,
label = stringResource(R.string.import_done_added_label),
contentDescription = pluralStringResource(R.plurals.import_done_imported, summary.imported, summary.imported),
container = MaterialTheme.colorScheme.secondaryContainer,
onContainer = MaterialTheme.colorScheme.onSecondaryContainer,
)
if (summary.skippedDuplicate > 0) {
ResultStatCard(
count = summary.skippedDuplicate,
label = stringResource(R.string.import_done_skipped_label),
contentDescription = pluralStringResource(
R.plurals.import_done_skipped,
summary.skippedDuplicate,
summary.skippedDuplicate,
),
container = MaterialTheme.colorScheme.surfaceContainerHighest,
onContainer = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
if (summary.failed > 0) {
ResultStatCard(
count = summary.failed,
label = stringResource(R.string.import_done_failed_label),
contentDescription = pluralStringResource(R.plurals.import_done_failed, summary.failed, summary.failed),
container = MaterialTheme.colorScheme.errorContainer,
onContainer = MaterialTheme.colorScheme.onErrorContainer,
)
}
}
}
/** A big-number tonal tile summarising one outcome. */
@Composable
private fun RowScope.ResultStatCard(
count: Int,
label: String,
contentDescription: String,
container: Color,
onContainer: Color,
) {
Surface(
modifier = Modifier
.weight(1f)
.clearAndSetSemantics { this.contentDescription = contentDescription },
shape = RoundedCornerShape(24.dp),
color = container,
) {
Column(
Modifier.padding(vertical = 20.dp, horizontal = 12.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(2.dp),
) {
Text(count.toString(), style = MaterialTheme.typography.displaySmall, color = onContainer)
Text(label, style = MaterialTheme.typography.labelLarge, color = onContainer.copy(alpha = 0.85f))
}
}
}
@@ -1,15 +1,9 @@
package de.jeanlucmakiola.calendula.ui.imports
import android.net.Uri
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.Spring
import androidx.compose.animation.core.spring
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.RowScope
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
@@ -17,13 +11,9 @@ import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.PriorityHigh
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
@@ -31,34 +21,31 @@ import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.semantics.clearAndSetSemantics
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.res.pluralStringResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import de.jeanlucmakiola.floret.components.OnboardingPrimaryButton
import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.domain.EventForm
import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning
import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups
import de.jeanlucmakiola.calendula.ui.common.ImportSummaryStats
import de.jeanlucmakiola.calendula.ui.common.ResultBadge
import de.jeanlucmakiola.calendula.ui.common.ResultMessage
import de.jeanlucmakiola.calendula.ui.common.importSummaryNotes
import de.jeanlucmakiola.floret.identity.predictiveBack
/**
@@ -211,18 +198,6 @@ private fun ManyContent(
@Composable
private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
// A little expressive pop on the success badge — springs in on first show.
val badgeScale = remember { Animatable(0.7f) }
LaunchedEffect(Unit) {
badgeScale.animateTo(
targetValue = 1f,
animationSpec = spring(
dampingRatio = Spring.DampingRatioMediumBouncy,
stiffness = Spring.StiffnessLow,
),
)
}
// Part of the file never reached the calendar, so the screen doesn't get to
// read as a plain success.
val stopped = state.summary.notAttempted > 0
@@ -232,160 +207,28 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
horizontalAlignment = Alignment.CenterHorizontally,
) {
Spacer(Modifier.weight(1f))
Box(
Modifier
.size(112.dp)
.graphicsLayer {
scaleX = badgeScale.value
scaleY = badgeScale.value
}
.clip(CircleShape)
.background(
if (stopped) {
MaterialTheme.colorScheme.errorContainer
} else {
MaterialTheme.colorScheme.primaryContainer
},
),
contentAlignment = Alignment.Center,
) {
Icon(
if (stopped) Icons.Default.PriorityHigh else Icons.Default.Check,
contentDescription = null,
tint = if (stopped) {
MaterialTheme.colorScheme.onErrorContainer
} else {
MaterialTheme.colorScheme.onPrimaryContainer
},
modifier = Modifier.size(56.dp),
)
}
Spacer(Modifier.height(24.dp))
Text(
stringResource(
ResultBadge(error = stopped)
ResultMessage(
title = stringResource(
if (stopped) R.string.import_done_stopped_title else R.string.import_done_title,
),
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.onSurface,
// The counts cover the part of the file that was tried, so say how much never was.
notes = importSummaryNotes(
state.summary,
stoppedNote = if (stopped) {
pluralStringResource(R.plurals.import_done_stopped, state.summary.notAttempted, state.summary.notAttempted)
} else {
null
},
),
)
if (state.summary.failed > 0) {
Spacer(Modifier.height(8.dp))
Text(
stringResource(R.string.import_done_failed_note),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center,
)
}
if (state.summary.skippedDuplicate > 0) {
Spacer(Modifier.height(8.dp))
Text(
stringResource(R.string.import_done_dedup_note),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center,
)
}
// The one note that isn't about individual events: the counts below cover
// the part of the file that was tried, so say how much never was.
if (stopped) {
Spacer(Modifier.height(8.dp))
Text(
pluralStringResource(
R.plurals.import_done_stopped,
state.summary.notAttempted,
state.summary.notAttempted,
),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center,
)
}
Spacer(Modifier.height(24.dp))
Row(
Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(12.dp),
) {
ImportStatCard(
count = state.summary.imported,
label = stringResource(R.string.import_done_added_label),
contentDescription = pluralStringResource(
R.plurals.import_done_imported,
state.summary.imported,
state.summary.imported,
),
container = MaterialTheme.colorScheme.secondaryContainer,
onContainer = MaterialTheme.colorScheme.onSecondaryContainer,
)
if (state.summary.skippedDuplicate > 0) {
ImportStatCard(
count = state.summary.skippedDuplicate,
label = stringResource(R.string.import_done_skipped_label),
contentDescription = pluralStringResource(
R.plurals.import_done_skipped,
state.summary.skippedDuplicate,
state.summary.skippedDuplicate,
),
container = MaterialTheme.colorScheme.surfaceContainerHighest,
onContainer = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
if (state.summary.failed > 0) {
ImportStatCard(
count = state.summary.failed,
label = stringResource(R.string.import_done_failed_label),
contentDescription = pluralStringResource(
R.plurals.import_done_failed,
state.summary.failed,
state.summary.failed,
),
container = MaterialTheme.colorScheme.errorContainer,
onContainer = MaterialTheme.colorScheme.onErrorContainer,
)
}
}
ImportSummaryStats(state.summary)
Spacer(Modifier.weight(1f))
Button(
OnboardingPrimaryButton(
text = stringResource(R.string.import_close),
onClick = onClose,
modifier = Modifier.fillMaxWidth(),
) {
Text(stringResource(R.string.import_close))
}
}
}
/** A big-number tonal tile summarising one import outcome (added / skipped / failed). */
@Composable
private fun RowScope.ImportStatCard(
count: Int,
label: String,
contentDescription: String,
container: Color,
onContainer: Color,
) {
Surface(
modifier = Modifier
.weight(1f)
.clearAndSetSemantics { this.contentDescription = contentDescription },
shape = RoundedCornerShape(24.dp),
color = container,
) {
Column(
Modifier.padding(vertical = 20.dp, horizontal = 12.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(2.dp),
) {
Text(
count.toString(),
style = MaterialTheme.typography.displaySmall,
color = onContainer,
)
Text(
label,
style = MaterialTheme.typography.labelLarge,
color = onContainer.copy(alpha = 0.85f),
)
}
)
}
}
+25
View File
@@ -963,6 +963,31 @@
<string name="calendars_restore_action">Restore from .ics file</string>
<string name="calendars_restore_hint">Import events from a backup or another calendar app.</string>
<string name="calendars_restore_unavailable">No calendar can take the imported events yet.</string>
<string name="calendars_copy_action">Copy events</string>
<string name="calendars_copy_summary">Copy one calendar\'s events into another, for example to move off Google.</string>
<string name="calendars_copy_hint">The original calendar stays as it is. Guests and invitations you declined are left out.</string>
<string name="calendars_copy_from">From</string>
<string name="calendars_copy_to">To</string>
<string name="calendars_copy_choose">Choose a calendar</string>
<string name="calendars_copy_from_title">Copy from</string>
<string name="calendars_copy_to_title">Copy into</string>
<string name="calendars_copy_start">Copy</string>
<string name="calendars_copy_more">Copy more</string>
<string name="calendars_copy_reading">Reading events…</string>
<plurals name="calendars_copy_progress">
<item quantity="one">%1$d of %2$d event</item>
<item quantity="other">%1$d of %2$d events</item>
</plurals>
<string name="calendars_copy_done">Copy complete</string>
<string name="calendars_copy_stopped_title">Copy stopped</string>
<string name="calendars_copy_partial">Copy finished, some events couldn\'t be added</string>
<string name="calendars_copy_none">No calendar can be copied into another one right now.</string>
<string name="calendars_copy_cancelled">Copy cancelled. Run it again to finish: events that were already copied are skipped.</string>
<string name="calendars_copy_failed">Couldn\'t copy the events.</string>
<plurals name="calendars_copy_stopped">
<item quantity="one">The target calendar stopped accepting events part way through. %d event was never copied.</item>
<item quantity="other">The target calendar stopped accepting events part way through. %d events were never copied.</item>
</plurals>
<string name="calendars_auto_backup">Automatic backup</string>
<string name="calendars_auto_backup_hint">Periodically export your calendars to a folder as .ics files.</string>
<string name="calendars_auto_backup_folder">Backup folder</string>
@@ -8,6 +8,13 @@ import de.jeanlucmakiola.calendula.domain.EventForm
import de.jeanlucmakiola.calendula.domain.EventInstance
import de.jeanlucmakiola.calendula.domain.FormTime
import de.jeanlucmakiola.calendula.domain.SearchCandidate
import de.jeanlucmakiola.calendula.domain.EventStatus
import de.jeanlucmakiola.calendula.domain.ics.CalendarRows
import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
import de.jeanlucmakiola.calendula.domain.ics.IcsParser
import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
import de.jeanlucmakiola.calendula.domain.ics.OverrideRow
import de.jeanlucmakiola.calendula.domain.ics.MasterRow
import de.jeanlucmakiola.calendula.testEvent
import de.jeanlucmakiola.calendula.testPrefs
import de.jeanlucmakiola.calendula.testRepository
@@ -946,7 +953,7 @@ class CalendarRepositoryImplTest {
repo.exportEvents(calendarIds = setOf(1L, 4L))
assertThat(fake.lastCalendarEventsIds).containsExactly(1L, 4L)
assertThat(fake.lastCalendarRowsIds).containsExactly(1L, 4L)
}
@Test
@@ -958,7 +965,141 @@ class CalendarRepositoryImplTest {
repo.exportEvents(calendarIds = setOf(2L))
assertThat(fake.lastCalendarEventsIds).containsExactly(2L)
assertThat(fake.lastCalendarRowsIds).containsExactly(2L)
}
@Test
fun `copyEvents reports progress and skips what an earlier run copied`(
@TempDir tempDir: Path,
) = runTest {
fun icsEvent(uid: String) = IcsEvent(
uid = uid,
summary = uid,
start = Instant.fromEpochMilliseconds(1_000_000_000L),
end = Instant.fromEpochMilliseconds(1_000_003_600L),
isAllDay = false,
zoneId = "UTC",
)
val fake = FakeCalendarDataSource().apply {
existingUidsResult = setOf("a")
calendarRowsResult = CalendarRows(
series = listOf(MasterRow(1, 1, null, icsEvent("a")), MasterRow(2, 1, null, icsEvent("b"))),
overrides = emptyList(),
)
}
val repo = testRepository(fake, tempDir, Dispatchers.Unconfined)
val progress = mutableListOf<Pair<Int, Int>>()
val summary = repo.copyEvents(sourceCalendarId = 1L, targetCalendarId = 3L) { done, total ->
progress += done to total
}
assertThat(summary.imported).isEqualTo(1)
assertThat(summary.skippedDuplicate).isEqualTo(1)
assertThat(fake.importedEvents.map { it.first.uid to it.second }).containsExactly("b" to 3L)
assertThat(progress.first()).isEqualTo(0 to 2)
assertThat(progress.last()).isEqualTo(2 to 2)
}
@Test
fun `a backup restores a series' moved and deleted occurrences, and skips them where the series is`(
@TempDir tempDir: Path,
) = runTest {
val start = Instant.parse("2026-01-05T09:00:00Z")
fun at(week: Int) = Instant.fromEpochMilliseconds(start.toEpochMilliseconds() + week * 7 * 86_400_000L)
fun event(at: Instant, status: EventStatus = EventStatus.Confirmed, rrule: String? = null) = IcsEvent(
uid = "s@x",
summary = "Standup",
start = at,
end = Instant.fromEpochMilliseconds(at.toEpochMilliseconds() + 3_600_000L),
isAllDay = false,
zoneId = "Europe/Berlin",
recurrenceRule = rrule,
status = status,
)
val moved = Instant.fromEpochMilliseconds(at(1).toEpochMilliseconds() + 3_600_000L)
val source = FakeCalendarDataSource().apply {
calendarRowsResult = CalendarRows(
series = listOf(MasterRow(1, 1, "sync-1", event(start, rrule = "FREQ=WEEKLY"))),
overrides = listOf(
OverrideRow(1, null, "sync-1", at(1), event(moved)),
OverrideRow(1, null, "sync-1", at(2), event(at(2), EventStatus.Cancelled)),
),
)
}
val file = IcsWriter().writeCalendar(
testRepository(source, tempDir.resolve("a"), Dispatchers.Unconfined).exportEvents(setOf(1L)),
start,
)
val parsed = IcsParser().parse(file).events
val empty = FakeCalendarDataSource()
testRepository(empty, tempDir.resolve("b"), Dispatchers.Unconfined).importEvents(3L, parsed)
val (detached, series) = empty.importedEvents.map { it.first }
assertThat(detached.start).isEqualTo(moved)
assertThat(detached.recurrenceRule).isNull()
assertThat(series.exDates).containsExactly("20260112T090000Z", "20260119T090000Z")
val original = FakeCalendarDataSource().apply { existingUidsResult = setOf("s@x") }
val summary = testRepository(original, tempDir.resolve("c"), Dispatchers.Unconfined).importEvents(3L, parsed)
assertThat(original.importedEvents).isEmpty()
assertThat(summary.skippedDuplicate).isEqualTo(2)
}
@Test
fun `a series keeps an occurrence whose standalone copy didn't land`(
@TempDir tempDir: Path,
) = runTest {
val fake = FakeCalendarDataSource().apply { failingImportSummaries += "moved" }
val repo = testRepository(fake, tempDir, Dispatchers.Unconfined)
val at = Instant.parse("2026-01-12T09:00:00Z")
val summary = repo.importEvents(
3L,
listOf(
parsedEvent("1-s", summary = "moved").copy(overrideOf = "s", overrideAt = at),
parsedEvent("s").copy(recurrenceRule = "FREQ=WEEKLY", exDates = listOf("20260112T090000Z", "20260119T090000Z")),
),
)
assertThat(summary.failed).isEqualTo(1)
assertThat(fake.importedEvents.single().first.exDates).containsExactly("20260119T090000Z")
}
@Test
fun `a standalone occurrence listed after its series still goes first`(
@TempDir tempDir: Path,
) = runTest {
val fake = FakeCalendarDataSource()
val repo = testRepository(fake, tempDir, Dispatchers.Unconfined)
repo.importEvents(3L, listOf(parsedEvent("s"), parsedEvent("1-s").copy(overrideOf = "s")))
assertThat(fake.importedEvents.map { it.first.uid }).containsExactly("1-s", "s").inOrder()
}
@Test
fun `a backup keeps an RDATE-only series and its exceptions`(
@TempDir tempDir: Path,
) = runTest {
val start = Instant.parse("2026-01-05T09:00:00Z")
val other = Instant.parse("2026-01-12T09:00:00Z")
val event = IcsEvent(
"s", "S", start, Instant.parse("2026-01-05T10:00:00Z"), false, "UTC",
recurrenceDates = listOf("20260112T090000Z", "20260119T090000Z"),
)
val fake = FakeCalendarDataSource().apply {
calendarRowsResult = CalendarRows(
listOf(MasterRow(1, 1, null, event)),
listOf(OverrideRow(1, 1, null, other, event.copy(recurrenceDates = emptyList(), status = EventStatus.Cancelled))),
)
}
val exported = testRepository(fake, tempDir, Dispatchers.Unconfined).exportEvents(setOf(1L))
val restored = IcsParser().parse(IcsWriter().writeCalendar(exported, start)).events.single()
assertThat(restored.recurrenceDates).containsExactly("20260112T090000Z", "20260119T090000Z")
assertThat(restored.exDates).containsExactly("20260112T090000Z")
}
private fun parsedEvent(uid: String?, summary: String = "E") =
@@ -8,6 +8,7 @@ import de.jeanlucmakiola.calendula.domain.EventForm
import de.jeanlucmakiola.calendula.domain.EventInstance
import de.jeanlucmakiola.calendula.domain.SearchCandidate
import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
import de.jeanlucmakiola.calendula.domain.ics.CalendarRows
import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
import java.time.ZoneId
@@ -23,9 +24,9 @@ internal class FakeCalendarDataSource : CalendarDataSource {
var searchResult: (String) -> List<SearchCandidate> = { _ -> emptyList() }
var eventDetailResult: (Long) -> EventDetail? = { null }
var publishedEventColorsResult: (Long) -> List<EventColorOption> = { emptyList() }
var calendarEventsResult: List<IcsEvent> = emptyList()
/** The [calendarIds] the last [calendarEvents] call received. */
var lastCalendarEventsIds: Set<Long>? = null
var calendarRowsResult: CalendarRows = CalendarRows(emptyList(), emptyList())
/** The [calendarIds] the last [calendarRows] call received. */
var lastCalendarRowsIds: Set<Long>? = null
/** UIDs the target calendar already holds, for import dedup. */
var existingUidsResult: Set<String> = emptySet()
/** Set to make the next write call throw. */
@@ -81,12 +82,9 @@ internal class FakeCalendarDataSource : CalendarDataSource {
eventDetailResult(eventId)
override fun publishedEventColors(calendarId: Long): List<EventColorOption> =
publishedEventColorsResult(calendarId)
override fun calendarEvents(
calendarIds: Set<Long>,
allDayReminderTimeMinutes: Int,
): List<IcsEvent> {
lastCalendarEventsIds = calendarIds
return calendarEventsResult
override fun calendarRows(calendarIds: Set<Long>, allDayReminderTimeMinutes: Int): CalendarRows {
lastCalendarRowsIds = calendarIds
return calendarRowsResult
}
override fun existingUids(calendarId: Long): Set<String> = existingUidsResult
@@ -294,4 +294,39 @@ class IcsExportMapperTest {
assertThat(event.exDates).isEmpty()
}
@Test
fun `a zoned RDATE list is written as UTC stamps, a period by its start`() {
assertThat(exportRecurrenceDates("Europe/Berlin;20260110T100000,20260111T100000/PT1H", isAllDay = false))
.containsExactly("20260110T090000Z", "20260111T090000Z").inOrder()
}
@Test
fun `an all-day RDATE keeps its days, junk is dropped`() {
assertThat(exportRecurrenceDates("20260110T000000Z,20260111,garbage", isAllDay = true))
.containsExactly("20260110", "20260111").inOrder()
}
@Test
fun `an RDATE stored over several lines keeps every line's dates`() {
assertThat(exportRecurrenceDates("Europe/Berlin;20260110T100000\nAmerica/New_York;20260112T090000", isAllDay = false))
.containsExactly("20260110T090000Z", "20260112T140000Z").inOrder()
}
@Test
fun `an EXDATE stored over several lines keeps every line, unreadable stamps go`() {
assertThat(exportExDates("Europe/Berlin;20260110T100000\nEurope/Berlin;20260117T100000,junk", isAllDay = false))
.containsExactly("20260110T090000Z", "20260117T090000Z").inOrder()
}
@Test
fun `a bare day on a timed series is read at the series' time of day`() {
val tenBerlin = java.time.ZonedDateTime.of(2026, 1, 5, 10, 0, 0, 0, java.time.ZoneId.of("Europe/Berlin"))
.toInstant().toEpochMilli()
assertThat(exportExDates("20260112", isAllDay = false, "Europe/Berlin", tenBerlin))
.containsExactly("20260112T090000Z")
assertThat(exportRecurrenceDates("20260712", isAllDay = false, "Europe/Berlin", tenBerlin))
.containsExactly("20260712T080000Z")
}
}
@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.calendar
import android.provider.CalendarContract
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.calendula.domain.AccessLevel
import de.jeanlucmakiola.calendula.domain.EventColorOption
import de.jeanlucmakiola.calendula.domain.EventStatus
import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
@@ -123,4 +124,21 @@ class ImportedEventValuesTest {
assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P900S")
assertThat(v[CalendarContract.Events.ALL_DAY]).isEqualTo(0)
}
@Test
fun `a copied RDATE-only series recurs by its dates`() {
val v = values(allDay().copy(recurrenceDates = listOf("20260820"), exDates = listOf("20260820")))
assertThat(v).doesNotContainKey(CalendarContract.Events.DTEND)
assertThat(v).doesNotContainKey(CalendarContract.Events.RRULE)
assertThat(v[CalendarContract.Events.RDATE]).isEqualTo("20260820")
assertThat(v[CalendarContract.Events.EXDATE]).isEqualTo("20260820")
assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P1D")
}
@Test
fun `a private event stays private, a default one leaves the calendar's say`() {
assertThat(values(allDay().copy(accessLevel = AccessLevel.Private))[CalendarContract.Events.ACCESS_LEVEL])
.isEqualTo(CalendarContract.Events.ACCESS_PRIVATE)
assertThat(values(allDay())).doesNotContainKey(CalendarContract.Events.ACCESS_LEVEL)
}
}
@@ -0,0 +1,287 @@
package de.jeanlucmakiola.calendula.domain.ics
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.calendula.data.calendar.formatExdateStamp
import de.jeanlucmakiola.calendula.domain.EventStatus
import org.junit.jupiter.api.Test
import kotlin.time.Instant
/** How a calendar's exception rows are written out for a backup (#147) or a copy (#325). */
class CalendarRowsTest {
private val start = Instant.parse("2026-01-05T09:00:00Z")
private val week = 7 * 24 * 3_600_000L
private fun event(
uid: String,
rrule: String? = null,
allDay: Boolean = false,
at: Instant = start,
status: EventStatus = EventStatus.Confirmed,
exDates: List<String> = emptyList(),
reminders: List<Int> = emptyList(),
color: Int? = null,
) = IcsEvent(
uid = uid,
summary = uid,
start = at,
end = Instant.fromEpochMilliseconds(at.toEpochMilliseconds() + 3_600_000L),
isAllDay = allDay,
zoneId = "Europe/Berlin",
recurrenceRule = rrule,
exDates = exDates,
reminderMinutes = reminders,
status = status,
color = color,
calendarName = "Work",
)
private fun occurrence(n: Int) = Instant.fromEpochMilliseconds(start.toEpochMilliseconds() + n * week)
private fun series(uid: String, rrule: String? = "FREQ=WEEKLY", id: Long = 1, calendar: Long = 1, syncId: String? = null, status: EventStatus = EventStatus.Confirmed) =
MasterRow(id, calendar, syncId, event(uid, rrule = rrule, status = status))
private fun flatten(series: List<MasterRow>, overrides: List<OverrideRow>) =
flattenOverrides(CalendarRows(series, overrides), ::formatExdateStamp)
@Test
fun `a cancelled occurrence becomes an EXDATE on the series`() {
val flat = flatten(
listOf(MasterRow(1, 1, "sync-1", event("s", rrule = "FREQ=WEEKLY", exDates = listOf("20260112T080000Z")))),
listOf(OverrideRow(1, null, "sync-1", occurrence(2), event("s", at = occurrence(2), status = EventStatus.Cancelled))),
)
assertThat(flat.single().exDates).containsExactly("20260112T080000Z", "20260119T090000Z").inOrder()
}
@Test
fun `a modified occurrence is excluded from the series and written on its own, first`() {
val moved = Instant.fromEpochMilliseconds(occurrence(1).toEpochMilliseconds() + 3_600_000L)
val flat = flatten(
listOf(series("s")),
listOf(OverrideRow(1, 1, null, occurrence(1), event("s", rrule = "FREQ=WEEKLY", at = moved))),
)
assertThat(flat).hasSize(2)
val detached = flat[0]
assertThat(detached.uid).isEqualTo("${occurrence(1).toEpochMilliseconds()}-s")
assertThat(detached.overrideOf).isEqualTo("s")
assertThat(detached.recurrenceRule).isNull()
assertThat(detached.start).isEqualTo(moved)
assertThat(detached.calendarName).isEqualTo("Work")
assertThat(flat[1].exDates).containsExactly("20260112T090000Z")
}
@Test
fun `an all-day series excludes the occurrence by its day`() {
val day = Instant.parse("2026-01-05T00:00:00Z")
val flat = flatten(
listOf(MasterRow(1, 1, null, event("s", rrule = "FREQ=DAILY", allDay = true, at = day))),
listOf(OverrideRow(1, 1, null, Instant.parse("2026-01-07T00:00:00Z"), event("s", allDay = true, status = EventStatus.Cancelled))),
)
assertThat(flat.single().exDates).containsExactly("20260107")
}
@Test
fun `exceptions without their series are left out`() {
val flat = flatten(
emptyList(),
listOf(
OverrideRow(1, 5, null, occurrence(1), event("x")),
OverrideRow(1, 5, null, occurrence(2), event("y", status = EventStatus.Cancelled)),
),
)
assertThat(flat).isEmpty()
}
@Test
fun `a sync id links an exception only within its own calendar`() {
val flat = flatten(
listOf(series("a", calendar = 1, syncId = "same"), series("b", id = 2, calendar = 2, syncId = "same")),
listOf(OverrideRow(2, null, "same", occurrence(1), event("x", status = EventStatus.Cancelled))),
)
assertThat(flat.first { it.uid == "a" }.exDates).isEmpty()
assertThat(flat.first { it.uid == "b" }.exDates).containsExactly("20260112T090000Z")
}
@Test
fun `an exception to a one-off is ignored`() {
val flat = flatten(
listOf(series("o", rrule = null)),
listOf(OverrideRow(1, 1, null, occurrence(0), event("x"))),
)
assertThat(flat.map { it.uid }).containsExactly("o")
}
@Test
fun `an RDATE-only series keeps its dates and takes its exceptions`() {
val flat = flatten(
listOf(MasterRow(1, 1, null, event("s").copy(recurrenceDates = listOf("20260112T090000Z")))),
listOf(OverrideRow(1, 1, null, occurrence(1), event("s", status = EventStatus.Cancelled))),
)
assertThat(flat.single().recurrenceDates).containsExactly("20260112T090000Z")
assertThat(flat.single().exDates).containsExactly("20260112T090000Z")
}
@Test
fun `two exception rows for one occurrence are written once`() {
val flat = flatten(
listOf(series("s")),
listOf(OverrideRow(1, 1, null, occurrence(1), event("x")), OverrideRow(1, 1, null, occurrence(1), event("y"))),
)
assertThat(flat.map { it.summary }).containsExactly("x", "s").inOrder()
}
@Test
fun `the output is stable, so a re-run dedups every event`() {
val rows = CalendarRows(listOf(series("s")), listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))))
assertThat(flattenOverrides(rows, ::formatExdateStamp).map { it.uid })
.isEqualTo(flattenOverrides(rows, ::formatExdateStamp).map { it.uid })
}
@Test
fun `a backup keeps a cancelled series, a copy leaves it out with its exceptions`() {
val rows = CalendarRows(
listOf(series("s", status = EventStatus.Cancelled)),
listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))),
)
assertThat(flattenOverrides(rows, ::formatExdateStamp).map { it.uid }).contains("s")
assertThat(planCalendarCopy(rows, ::formatExdateStamp)).isEmpty()
}
@Test
fun `a copy keeps the zone, colour and override link`() {
val rows = CalendarRows(
listOf(MasterRow(1, 1, null, event("s", rrule = "FREQ=WEEKLY", reminders = listOf(10, -5, 10), color = 0xFF112233.toInt()))),
listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))),
)
val (detached, copied) = planCalendarCopy(rows, ::formatExdateStamp)
assertThat(detached.overrideOf).isEqualTo("s")
assertThat(copied.zoneId).isEqualTo("Europe/Berlin")
assertThat(copied.color).isEqualTo(0xFF112233.toInt())
assertThat(copied.reminderMinutes).containsExactly(10)
}
@Test
fun `a zero-length all-day event lasts its day`() {
val day = Instant.parse("2026-01-05T00:00:00Z")
val parsed = event("a", allDay = true, at = day).copy(end = day).toParsedIcsEvent()
assertThat(parsed.end).isEqualTo(Instant.parse("2026-01-06T00:00:00Z"))
}
@Test
fun `the override link survives the file`() {
val text = IcsWriter().writeCalendar(listOf(event("d").copy(overrideOf = "s;1", overrideAt = occurrence(1))), start)
val parsed = IcsParser().parse(text).events.single()
assertThat(parsed.overrideOf).isEqualTo("s;1")
assertThat(parsed.overrideAt).isEqualTo(occurrence(1))
}
@Test
fun `a cancelled series' moved occurrence isn't brought back`() {
val flat = flatten(
listOf(series("s", status = EventStatus.Cancelled)),
listOf(OverrideRow(1, 1, null, occurrence(1), event("x"))),
)
assertThat(flat.map { it.uid }).containsExactly("s")
}
@Test
fun `the same series in two calendars keeps each calendar's moved occurrence`() {
val flat = flatten(
listOf(series("s", id = 1, calendar = 1), series("s", id = 2, calendar = 2)),
listOf(
OverrideRow(1, 1, null, occurrence(1), event("x")),
OverrideRow(2, 2, null, occurrence(1), event("x")),
),
)
assertThat(flat.count { it.overrideOf == "s" }).isEqualTo(2)
}
@Test
fun `a copy leaves declined invitations out but keeps an occurrence accepted on its own`() {
val rows = CalendarRows(
listOf(series("d").copy(declined = true), series("k", id = 2)),
listOf(
OverrideRow(1, 1, null, occurrence(1), event("accepted"), accepted = true),
OverrideRow(1, 1, null, occurrence(2), event("moved by the organizer")),
),
)
val plan = planCalendarCopy(rows, ::formatExdateStamp)
assertThat(plan.map { it.summary }).containsExactly("accepted", "k")
}
@Test
fun `a copy treats a declined occurrence as deleted`() {
val rows = CalendarRows(
listOf(series("s")),
listOf(OverrideRow(1, 1, null, occurrence(1), event("x"), declined = true)),
)
val plan = planCalendarCopy(rows, ::formatExdateStamp)
assertThat(plan.map { it.uid }).containsExactly("s")
assertThat(plan.single().exDates).containsExactly("20260112T090000Z")
}
@Test
fun `RDATE and its exclusions survive the file`() {
val timed = event("t").copy(
recurrenceDates = listOf("20260112T090000Z", "20260120T090000Z"),
exDates = listOf("20260112T090000Z"),
)
val day = Instant.parse("2026-01-05T00:00:00Z")
val allDay = event("a", allDay = true, at = day).copy(
end = Instant.parse("2026-01-06T00:00:00Z"),
recurrenceDates = listOf("20260110"),
exDates = listOf("20260110"),
)
val text = IcsWriter().writeCalendar(listOf(timed, allDay), start)
assertThat(text).contains("RDATE;VALUE=DATE:20260110")
assertThat(text).contains("DTSTART;TZID=Europe/Berlin:20260105T100000")
val (t, a) = IcsParser().parse(text).events
assertThat(t.recurrenceDates).containsExactly("20260112T090000Z", "20260120T090000Z")
assertThat(t.exDates).containsExactly("20260112T090000Z")
assertThat(a.recurrenceDates).containsExactly("20260110")
assertThat(a.exDates).containsExactly("20260110")
}
@Test
fun `a foreign RDATE is read in its own zone, a period by its start`() {
val text = """
BEGIN:VCALENDAR
BEGIN:VEVENT
UID:f
DTSTART;TZID=Europe/Berlin:20260105T100000
DTEND;TZID=Europe/Berlin:20260105T110000
RDATE;TZID=America/New_York:20260110T090000
RDATE;VALUE=PERIOD:20260111T090000Z/PT1H
END:VEVENT
END:VCALENDAR
""".trimIndent().replace("\n", "\r\n")
assertThat(IcsParser().parse(text).events.single().recurrenceDates)
.containsExactly("20260110T140000Z", "20260111T090000Z")
}
@Test
fun `a declined row takes no other row with its UID along`() {
val rows = CalendarRows(listOf(series("u").copy(declined = true), series("u", id = 2)), emptyList())
assertThat(planCalendarCopy(rows, ::formatExdateStamp)).hasSize(1)
}
}
@@ -97,4 +97,48 @@ class BackupUiStateTest {
assertThat(state.exportable.map { it.id }).containsExactly(1L, 2L)
assertThat(state.canImport).isTrue()
}
@Test
fun `a read-only calendar can be copied into a writable one`() {
val readOnly = cal(1, writable = false)
val local = cal(2, local = true)
val state = ready(backupUiState(listOf(readOnly, local)))
assertThat(state.canCopy).isTrue()
assertThat(copySources(listOf(readOnly, local)).map { it.id }).containsExactly(1L)
assertThat(copyTargets(listOf(readOnly, local), 1L).map { it.id }).containsExactly(2L)
}
@Test
fun `a single writable calendar has nothing to copy into`() {
val only = cal(1, local = true)
assertThat(ready(backupUiState(listOf(only))).canCopy).isFalse()
assertThat(copyTargets(listOf(only), 1L)).isEmpty()
}
@Test
fun `the only writable calendar is not offered as a source`() {
val local = cal(1, local = true)
val holidays = cal(2, writable = false)
assertThat(copySources(listOf(local, holidays)).map { it.id }).containsExactly(2L)
}
@Test
fun `a copy never targets a managed or switched-off calendar`() {
val source = cal(1)
val calendars = listOf(source, cal(2, managed = true), cal(3, visible = false))
assertThat(copyTargets(calendars, source.id)).isEmpty()
}
@Test
fun `choosing the target as source drops it`() {
assertThat(CopySelection(sourceId = 1, targetId = 2).withSource(2))
.isEqualTo(CopySelection(sourceId = 2, targetId = null))
assertThat(CopySelection(sourceId = 1, targetId = 2).withSource(3))
.isEqualTo(CopySelection(sourceId = 3, targetId = 2))
}
}
+56 -9
View File
@@ -586,15 +586,62 @@ of the backup keeps its last one. The pre-#411 fixed `calendula-backup.ics` is
the combined series' stable copy for the install that wrote it, and an
install that already had a folder stays on the combined layout.
**A backup carries the series' deleted occurrences.** `EXDATE` lives on the
master row, so the export query's `ORIGINAL_ID IS NULL` filter — which does drop
`RECURRENCE-ID` overrides — never hid it; it simply wasn't read. It is now part
of `EventExportProjection`, and `IcsWriter` marks an all-day series' exclusions
`VALUE=DATE`, because RFC 5545 ties `EXDATE`'s value type to `DTSTART`'s and a
bare day code without it reads as a malformed DATE-TIME. Sync adapters disagree
on whether an all-day exclusion is `yyyyMMdd` or a padded midnight stamp, so
`exportExDates` drops the time part on the way out. Without this, an in-app
backup→restore resurrected every occurrence the user had deleted.
**A backup carries the series' deleted and moved occurrences.** `EXDATE` lives on
the master row and is part of `EventExportProjection`; `IcsWriter` marks an
all-day series' exclusions `VALUE=DATE`, because RFC 5545 ties `EXDATE`'s value
type to `DTSTART`'s and a bare day code without it reads as a malformed
DATE-TIME. Sync adapters disagree on whether an all-day exclusion is `yyyyMMdd`
or a padded midnight stamp, so `exportExDates` drops the time part on the way
out.
A synced calendar records a deleted or moved occurrence as an *exception row*
(`ORIGINAL_ID` / `ORIGINAL_SYNC_ID` = the series, `ORIGINAL_INSTANCE_TIME` = the
occurrence) instead, and neither a backup file nor a copied calendar can hold
one: an `.ics` restore skips `RECURRENCE-ID` overrides, and an inserted row has
no `_sync_id` for an exception to attach through. `CalendarDataSource.calendarRows`
therefore reads every row, exceptions included, and `flattenOverrides` — the one
place this mapping lives, shared by the backup (`exportEvents`) and Copy events
(#325, `planCalendarCopy`) — writes them the way Calendula writes "only this
event" on an unsynced series: every exception adds its occurrence to the
series' `EXDATE`, and a modified one becomes a standalone event at its own
times. Its UID is derived from the series UID and the occurrence, so it is the
same in every backup, and it carries the series UID as `X-CALENDULA-OVERRIDE-OF`.
`importEvents` skips such an occurrence wherever its series already is — that
series there has the override itself — so restoring into the calendar a backup
came from adds nothing twice, while a restore into an empty one gets both. The
standalone event also names its occurrence (`X-CALENDULA-OVERRIDE-AT`); if it
fails to insert, the series is inserted without that exclusion, so the
occurrence stays at its original time rather than vanishing for good. The
import inserts every such event ahead of the series, whatever order the file
lists them in.
Exceptions whose series isn't among the rows are left out, a cancelled
series' moved occurrences stay cancelled, and sync ids link only within their
own calendar. Backups made before this carry no exceptions and restore exactly
as before.
**`RDATE` travels like `EXDATE` (#515).** A series can repeat by listed dates
alone. The provider stores `RDATE` in the same `<zone>;<stamps>` form as
`EXDATE`, so `exportRecurrenceDates` resolves it the same way to UTC stamps (or
bare days for an all-day series), line by line where several `RDATE`s were
stored; a `PERIOD` entry keeps its start, and a bare day on a timed series
becomes the occurrence at the series' time of day, so the copy (which never
goes through the parser) and a file get the same stamps. `IcsWriter`
writes it as `RDATE:` / `RDATE;VALUE=DATE:`, anchors such a series to its zone
like an RRULE series, and writes its `EXDATE` too; `IcsParser` reads `RDATE`
through the same normalisation as `EXDATE`, so a foreign `TZID` or floating
value lands on the right instant. Older backups wrote such a series as a single
event and still restore as one.
**Copying a calendar.** Backup & restore → Copy events (#325) runs the source's
flattened rows straight into `importEvents`, so the UID dedup makes a re-run skip
what landed before. It skips the `.ics` text: the writer pins a timed one-off to
UTC and carries no colour or visibility; the direct mapping keeps them.
Attendees and organizer are never read, and cancelled events and declined
invitations are left out (an insert can't be cancelled; it would arrive live, and
a declined occurrence counts as deleted, as does one of a declined series the
user didn't accept on its own). A re-run is idempotent per
snapshot: a series already in the target keeps its overrides, so an occurrence
changed since keeps its earlier copy rather than gaining a second one.
That re-encode is sampled where the reminder will actually *fire*, not at
`DTSTART` (`importedAllDayReminderDate`). An imported series' `DTSTART` is only an