chore(release): cut 2.14.1

Move the Unreleased fixes (#47, #48, #49, #22) under a 2.14.1 heading, bump
versionName/versionCode to 2.14.1/21401, and sync the F-Droid per-version
changelog.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CHANGELOG.md

@@ -7,7 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.14.1] — 2026-07-13
+
 ### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
 - A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
   app (such as DAVx5), the event colour picker showed every colour the account
   publishes — nearly 150 swatches in alphabetical order, many of them
@@ -888,3 +913,6 @@ automatically, with zero telemetry and no internet permission.
 [#33]: https://codeberg.org/jlmakiola/calendula/issues/33
 [#34]: https://codeberg.org/jlmakiola/calendula/issues/34
 [#37]: https://codeberg.org/jlmakiola/calendula/issues/37
+[#47]: https://codeberg.org/jlmakiola/calendula/issues/47
+[#48]: https://codeberg.org/jlmakiola/calendula/issues/48
+[#49]: https://codeberg.org/jlmakiola/calendula/issues/49

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // which builds this version and then creates the matching vX.Y.Z tag +
         // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
         // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 21400
+        versionCode = 21401
-        versionName = "2.14.0"
+        versionName = "2.14.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/AndroidManifest.xml

@@ -97,58 +97,32 @@
                 <data android:mimeType="time/epoch" />
             </intent-filter>
 
-            <!-- Open a .ics/.vcs file (file manager / email attachment / browser).
+            <!-- Open a .ics file (file manager / email attachment / browser). -->
-                 The three MIME types cover the common labels the same calendar
-                 data arrives under: iCalendar 2.0 (text/calendar), the older
-                 vCalendar 1.0 / .vcs (text/x-vcalendar), and application/ics some
-                 mail apps emit — Android cross-products the scheme and mimeType
-                 tags, so each MIME is accepted on both schemes (matches Etar). -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
-                <data android:scheme="content" />
+                <data android:scheme="content" android:mimeType="text/calendar" />
-                <data android:scheme="file" />
+                <data android:scheme="file" android:mimeType="text/calendar" />
-                <data android:mimeType="text/calendar" />
-                <data android:mimeType="text/x-vcalendar" />
-                <data android:mimeType="application/ics" />
             </intent-filter>
-            <!-- Receive a .ics/.vcs shared from another app (same MIME set). -->
+            <!-- Receive a .ics shared from another app. -->
             <intent-filter>
                 <action android:name="android.intent.action.SEND" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <data android:mimeType="text/calendar" />
-                <data android:mimeType="text/x-vcalendar" />
-                <data android:mimeType="application/ics" />
             </intent-filter>
 
             <!-- Let another app or widget (e.g. the Todo Agenda widget) launch us
                  to create a new event, the way the AOSP calendar accepts it:
                  ACTION_INSERT on the events dir mime type, carrying the new
                  event's fields as CalendarContract extras
-                 (MainActivity.insertFormOrNull, issue #30). ACTION_EDIT on the
+                 (MainActivity.insertFormOrNull, issue #30). -->
-                 dir mime is AOSP's "edit a new event" — i.e. create — so it maps
-                 to the same prefilled create form. -->
             <intent-filter>
                 <action android:name="android.intent.action.INSERT" />
-                <action android:name="android.intent.action.EDIT" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <data android:mimeType="vnd.android.cursor.dir/event" />
             </intent-filter>
 
-            <!-- Edit an existing event another app/assistant/widget points at:
-                 ACTION_EDIT on content://com.android.calendar/events/<id>, the way
-                 AOSP fires it. Opens the occurrence in the edit form (not the
-                 read-only detail — that's the VIEW filter above). Matched by the
-                 provider's item MIME type, like the VIEW filter. The occurrence's
-                 times ride as EXTRA_EVENT_BEGIN_TIME / EXTRA_EVENT_END_TIME when
-                 supplied (MainActivity.editEventKeyOrNull). -->
-            <intent-filter>
-                <action android:name="android.intent.action.EDIT" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="vnd.android.cursor.item/event" />
-            </intent-filter>
-
             <!-- Open an existing event another app/widget points at (e.g. tapping
                  an event in the Todo Agenda widget): ACTION_VIEW on
                  content://com.android.calendar/events/<id>, the way AOSP fires it.

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -70,11 +70,6 @@ class MainActivity : AppCompatActivity() {
     // CalendarHost, which opens it in the create form for review.
     private var requestedInsertForm by mutableStateOf<EventForm?>(null)
 
-    // An external "edit this event" (ACTION_EDIT on content://.../events/<id>):
-    // opens the occurrence in the edit form. Same occurrence-key shape as the
-    // detail channel; consumed once by CalendarHost.
-    private var requestedEditKey by mutableStateOf<LongArray?>(null)
-
     // A captured crash report awaiting the user's decision, surfaced as a dialog
     // over the calendar on the next launch (the single-crash path). A startup
     // crash-loop is handled out of band, before setContent — see below.
@@ -100,7 +95,6 @@ class MainActivity : AppCompatActivity() {
         requestedNav = intent.navRequestOrNull()
         requestedImportUri = intent.importUriOrNull()
         requestedInsertForm = intent.insertFormOrNull()
-        requestedEditKey = intent.editEventKeyOrNull()
         if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
@@ -151,8 +145,6 @@ class MainActivity : AppCompatActivity() {
                             onImportConsumed = { requestedImportUri = null },
                             requestedInsertForm = requestedInsertForm,
                             onInsertConsumed = { requestedInsertForm = null },
-                            requestedEditKey = requestedEditKey,
-                            onEditKeyConsumed = { requestedEditKey = null },
                         )
                     }
                     // A persistent corner marker so a debug build is never
@@ -191,7 +183,6 @@ class MainActivity : AppCompatActivity() {
         intent.navRequestOrNull()?.let { requestedNav = it }
         intent.importUriOrNull()?.let { requestedImportUri = it }
         intent.insertFormOrNull()?.let { requestedInsertForm = it }
-        intent.editEventKeyOrNull()?.let { requestedEditKey = it }
     }
 
     /**
@@ -212,19 +203,13 @@ class MainActivity : AppCompatActivity() {
     }
 
     /**
-     * A prefilled new-event form from an external launch asking us to create an
+     * A prefilled new-event form from an external `ACTION_INSERT` launch — another
-     * event — another app or widget (e.g. Todo Agenda) firing `ACTION_INSERT`
+     * app or widget (e.g. Todo Agenda) asking us to create an event (issue #30).
-     * (issue #30), or `ACTION_EDIT` with no concrete event id (AOSP's "edit a new
+     * The new event's fields ride as CalendarContract extras; anything omitted
-     * event", i.e. create). The new event's fields ride as CalendarContract
+     * falls back to the in-app "new event" defaults in [buildInsertEventForm].
-     * extras; anything omitted falls back to the in-app "new event" defaults in
-     * [buildInsertEventForm].
      */
     private fun Intent.insertFormOrNull(): EventForm? {
-        // ACTION_EDIT on an existing event routes to the edit form instead
+        if (action != Intent.ACTION_INSERT) return null
-        // ([editEventKeyOrNull]); only an id-less EDIT is a create.
-        val isCreate = action == Intent.ACTION_INSERT ||
-            (action == Intent.ACTION_EDIT && editEventKeyOrNull() == null)
-        if (!isCreate) return null
         return buildInsertEventForm(
             beginMillis = longExtraOrNull(CalendarContract.EXTRA_EVENT_BEGIN_TIME),
             endMillis = longExtraOrNull(CalendarContract.EXTRA_EVENT_END_TIME),
@@ -333,31 +318,6 @@ class MainActivity : AppCompatActivity() {
         )
     }
 
-    /**
-     * The occurrence key for an external "edit this event" — `ACTION_EDIT` on
-     * `content://com.android.calendar/events/<id>`, the way AOSP fires it (e.g.
-     * an assistant, task app, or widget that wants to open the event for editing
-     * rather than viewing). Opens it in the edit form. Reuses the same
-     * occurrence-key channel as reminder/view taps; the caller passes the
-     * occurrence's times as `EXTRA_EVENT_BEGIN_TIME` / `EXTRA_EVENT_END_TIME`
-     * when it has them, otherwise we carry [NO_OCCURRENCE_TIME] and
-     * [EventEditViewModel.openForEdit] falls back to the event row's own
-     * DTSTART/DTEND. An id-less `ACTION_EDIT` is a create instead ([insertFormOrNull]).
-     */
-    private fun Intent.editEventKeyOrNull(): LongArray? {
-        if (action != Intent.ACTION_EDIT) return null
-        val uri = data ?: return null
-        if (uri.host != CALENDAR_PROVIDER_HOST) return null
-        val segments = uri.pathSegments
-        if (segments.firstOrNull() != "events") return null
-        val eventId = segments.getOrNull(1)?.toLongOrNull() ?: return null
-        return longArrayOf(
-            eventId,
-            longExtraOrNull(CalendarContract.EXTRA_EVENT_BEGIN_TIME) ?: NO_OCCURRENCE_TIME,
-            longExtraOrNull(CalendarContract.EXTRA_EVENT_END_TIME) ?: NO_OCCURRENCE_TIME,
-        )
-    }
-
     companion object {
         // The calendar provider's authority/host. A date tap arrives as
         // ACTION_VIEW on content://com.android.calendar/time/<epochMillis>.

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt

@@ -979,6 +979,8 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.EVENT_TIMEZONE,
             CalendarContract.Events.DURATION,
             CalendarContract.Events.ALL_DAY,
+            CalendarContract.Events._SYNC_ID,
+            CalendarContract.Events.EXDATE,
         ),
         null, null, null,
     )?.use { c ->
@@ -989,6 +991,8 @@ class AndroidCalendarDataSource @Inject constructor(
                 timezone = c.getString(2),
                 duration = c.getString(3),
                 allDay = c.getInt(4),
+                syncId = c.getString(5),
+                exdate = c.getString(6),
             )
         } else {
             null
@@ -1001,6 +1005,9 @@ class AndroidCalendarDataSource @Inject constructor(
         val timezone: String?,
         val duration: String?,
         val allDay: Int,
+        /** Null on a local calendar (and before a synced event's first push). */
+        val syncId: String? = null,
+        val exdate: String? = null,
     ) {
         /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
         fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
@@ -1191,15 +1198,38 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
-        // A cancelled exception row hides exactly this occurrence; the sync
-        // adapter turns it into an EXDATE/cancelled VEVENT upstream. It has to
-        // carry the full time set (DTSTART + DURATION + zone), not just STATUS:
-        // the provider only demotes the cloned exception to a single instance —
-        // clearing the inherited RRULE — when it can derive that instance from
-        // those columns. A STATUS-only cancel left the RRULE standing and
-        // cancelled the whole series, wiping every other occurrence (#47), the
-        // same trap the edit path documents (Codeberg #16).
         val row = querySeriesRow(eventId)
+        if (row.syncId == null) {
+            // No _sync_id — a local calendar, or a synced event not pushed yet.
+            // A cancelled exception can only attach to its parent through
+            // ORIGINAL_SYNC_ID, so with none the link never forms and the
+            // provider's expansion of the *parent* collapses, taking every other
+            // occurrence with it (#47 on a local calendar). EXDATE needs no link.
+            // Calendula's own contact special-date calendars are local and hold
+            // yearly series, so this path is reached in normal use.
+            val values = buildOccurrenceExdateValues(
+                existingExdate = row.exdate,
+                occurrenceMillis = beginMillis,
+                dtStartMillis = row.dtStartMillis,
+                rrule = row.rrule,
+                duration = row.duration,
+                timezone = row.timezone,
+                allDay = row.allDay,
+            )
+            val updated = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
+            )
+            if (updated == 0) {
+                throw WriteFailedException("exdate occurrence event id=$eventId begin=$beginMillis")
+            }
+            return
+        }
+        // A cancelled exception row hides exactly this occurrence; the sync
+        // adapter turns it into an EXDATE/cancelled VEVENT upstream. It carries
+        // the full time set (DTSTART + DURATION + zone) so the provider derives a
+        // single instance rather than cloning the master's RRULE — the same trap
+        // the edit path documents (Codeberg #16).
         val values = buildOccurrenceCancelValues(
             originalInstanceMillis = beginMillis,
             dtStartMillis = beginMillis,

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapper.kt

@@ -14,6 +14,7 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -36,15 +37,18 @@ internal fun ColumnReader.toEventDetailCore(
     val begin = getLong(EventDetailProjection.IDX_DTSTART)
 
     // Recurring events store DURATION instead of DTEND, so the series row's
-    // DTEND is null. Keep the event (end == begin); callers that opened a
+    // DTEND is null — derive the length from DURATION (as SearchMapper and
-    // specific occurrence supply the real per-occurrence times from
+    // IcsExportMapper do). Callers that opened a specific occurrence overwrite
-    // CalendarContract.Instances. A present-but-backwards DTEND is malformed,
+    // both times with the per-occurrence values from CalendarContract.Instances;
-    // but dropping the row would make the event un-openable — the same trap as
+    // a caller that names no occurrence (a bare content://.../events/<id> VIEW
-    // the pre-1970 DTSTART bug above (issue #34): it would surface as the
+    // intent, issue #48) keeps this row's own times, so the length has to be
-    // generic error screen with no way to open the event and fix it. Clamp to a
+    // right here or the series renders zero-length. A present-but-backwards
-    // zero-length event instead (matching SearchMapper's coerceAtLeast).
+    // DTEND is malformed, but dropping the row would make the event un-openable
+    // — the same trap as the pre-1970 DTSTART bug above (issue #34): it would
+    // surface as the generic error screen with no way to open the event and fix
+    // it. Clamp to a zero-length event instead (matching SearchMapper).
     val end = if (isNull(EventDetailProjection.IDX_DTEND)) {
-        begin
+        begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION))
     } else {
         getLong(EventDetailProjection.IDX_DTEND).coerceAtLeast(begin)
     }

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt

@@ -209,6 +209,73 @@ internal fun buildOccurrenceCancelValues(
     put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
 }
 
+/**
+ * The master-row columns that drop the occurrence at [occurrenceMillis] from a
+ * series by adding it to `EXDATE` — the path for events that have **no
+ * `_sync_id`** (a local calendar, or a synced event not yet pushed).
+ *
+ * A cancelled exception row (see [buildOccurrenceCancelValues]) only attaches to
+ * its parent through `ORIGINAL_SYNC_ID`. Without a `_sync_id` the link never
+ * forms, and the provider's expansion of the *parent* collapses — every other
+ * occurrence disappears (Codeberg #47, reproduced on a local calendar). EXDATE
+ * needs no link, and is the canonical iCalendar way to drop an occurrence, so a
+ * sync adapter carries it upstream unchanged if the calendar later syncs.
+ *
+ * The whole time/recurrence set is rewritten alongside it on purpose. The
+ * provider does **not** treat an EXDATE-only update as a recurrence change: it
+ * leaves the expanded `Instances` rows untouched, so the occurrence stays visible
+ * (and, symmetrically, un-excluding one leaves it hidden). Writing DTSTART with
+ * it forces the re-expansion — but DTSTART *alone* makes the provider recompute
+ * `lastDate` as if the event were a single instance, collapsing the series to its
+ * first occurrence. Passing DTSTART + DURATION + RRULE + zone together is what
+ * re-expands it correctly. All observed on a Pixel; see the #47 notes.
+ *
+ * EXDATE is a comma-separated list, so an existing one is appended to (a repeat
+ * of the same occurrence is folded away). All-day series take the `VALUE=DATE`
+ * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`).
+ */
+internal fun buildOccurrenceExdateValues(
+    existingExdate: String?,
+    occurrenceMillis: Long,
+    dtStartMillis: Long,
+    rrule: String?,
+    duration: String?,
+    timezone: String?,
+    allDay: Int,
+): Map<String, Any?> {
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
+    val existing = existingExdate?.split(',')
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        .orEmpty()
+    val merged = (existing + stamp).distinct().joinToString(",")
+    return mapOf(
+        CalendarContract.Events.EXDATE to merged,
+        CalendarContract.Events.DTSTART to dtStartMillis,
+        CalendarContract.Events.RRULE to rrule,
+        CalendarContract.Events.DURATION to duration,
+        CalendarContract.Events.EVENT_TIMEZONE to timezone,
+        CalendarContract.Events.ALL_DAY to allDay,
+    )
+}
+
+/**
+ * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
+ * 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 {
+    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
+    return if (isAllDay) {
+        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
+    } else {
+        "%04d%02d%02dT%02d%02d%02dZ".format(
+            utc.year, utc.monthValue, utc.dayOfMonth,
+            utc.hour, utc.minute, utc.second,
+        )
+    }
+}
+
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
  * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt

@@ -84,6 +84,9 @@ internal object EventDetailProjection {
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.SELF_ATTENDEE_STATUS,
         CalendarContract.Events.EVENT_COLOR_KEY,
+        // Recurring rows carry DURATION instead of DTEND; the detail screen
+        // needs it to render a series opened without a named occurrence.
+        CalendarContract.Events.DURATION,
     )
 
     const val IDX_EVENT_ID = 0
@@ -104,6 +107,7 @@ internal object EventDetailProjection {
     const val IDX_EVENT_TIMEZONE = 15
     const val IDX_SELF_ATTENDEE_STATUS = 16
     const val IDX_EVENT_COLOR_KEY = 17
+    const val IDX_DURATION = 18
 }
 
 /**

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -75,8 +75,6 @@ fun CalendarHost(
     onImportConsumed: () -> Unit = {},
     requestedInsertForm: EventForm? = null,
     onInsertConsumed: () -> Unit = {},
-    requestedEditKey: LongArray? = null,
-    onEditKeyConsumed: () -> Unit = {},
     viewModel: CalendarHostViewModel = hiltViewModel(),
 ) {
     // Wait for the persisted default view before seeding the stack, so the app
@@ -214,20 +212,6 @@ fun CalendarHost(
         importForm = null
     }
 
-    // An external "edit this event" (ACTION_EDIT, e.g. an assistant/task app or
-    // widget) opens the occurrence straight in the edit form. Drop any covering
-    // overlay first — the edit overlay sits below Settings/import in the Box, so
-    // without this it would open hidden underneath them. Same held-key pattern as
-    // a detail-screen "Edit" tap; a saved edit just returns to the calendar.
-    LaunchedEffect(requestedEditKey) {
-        if (requestedEditKey != null) {
-            dismissCoveringOverlays()
-            heldEditKey = requestedEditKey
-            editKey = requestedEditKey
-            onEditKeyConsumed()
-        }
-    }
-
     // A home-screen widget launch asks to open a date (→ day view), open an
     // event's detail, or start a create. Handled once and cleared, mirroring
     // [requestedDetailKey]. Date/event opens root the stack in the widget's own

app/src/main/java/de/jeanlucmakiola/calendula/ui/RootScreen.kt

@@ -37,8 +37,6 @@ fun RootScreen(
     onImportConsumed: () -> Unit = {},
     requestedInsertForm: de.jeanlucmakiola.calendula.domain.EventForm? = null,
     onInsertConsumed: () -> Unit = {},
-    requestedEditKey: LongArray? = null,
-    onEditKeyConsumed: () -> Unit = {},
 ) {
     val context = LocalContext.current
     var hasPermission by remember {
@@ -90,8 +88,6 @@ fun RootScreen(
                         onImportConsumed = onImportConsumed,
                         requestedInsertForm = requestedInsertForm,
                         onInsertConsumed = onInsertConsumed,
-                        requestedEditKey = requestedEditKey,
-                        onEditKeyConsumed = onEditKeyConsumed,
                     )
                     false -> ReminderOnboardingScreen(
                         onFinished = reminderOnboarding::finish,

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt

@@ -21,7 +21,6 @@ import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.populatedFields
 import de.jeanlucmakiola.calendula.domain.problems
 import de.jeanlucmakiola.calendula.domain.toEditSnapshot
-import de.jeanlucmakiola.calendula.ui.detail.EventDetailViewModel.Companion.NO_OCCURRENCE_TIME
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
@@ -397,12 +396,8 @@ class EventEditViewModel @Inject constructor(
 
     /**
      * Load an existing event into the form. [beginMillis]/[endMillis] are the
-     * tapped occurrence's own times, like on the detail screen. An external
+     * tapped occurrence's own times, like on the detail screen. No-op while a
-     * "edit this event" (`ACTION_EDIT`) that names no occurrence passes
+     * form is open, so user edits survive configuration changes.
-     * [NO_OCCURRENCE_TIME]; the row's own DTSTART/DTEND is used then, so the
-     * form loads the event's real times instead of the epoch (mirrors the
-     * detail screen's #48 fallback). No-op while a form is open, so user edits
-     * survive configuration changes.
      */
     fun openForEdit(eventId: Long, beginMillis: Long, endMillis: Long) {
         if (_form.value != null || _editTarget.value != null) return
@@ -416,12 +411,8 @@ class EventEditViewModel @Inject constructor(
                 return@launch
             }
             val zone = TimeZone.currentSystemDefault()
-            val begin = beginMillis.takeUnless { it == NO_OCCURRENCE_TIME }
+            val snapshot = detail.toEditSnapshot(beginMillis, endMillis, zone)
-                ?: detail.instance.start.toEpochMilliseconds()
+            _editTarget.value = EditTarget(eventId, snapshot, beginMillis, endMillis, zone)
-            val end = endMillis.takeUnless { it == NO_OCCURRENCE_TIME }
-                ?: detail.instance.end.toEpochMilliseconds()
-            val snapshot = detail.toEditSnapshot(begin, end, zone)
-            _editTarget.value = EditTarget(eventId, snapshot, begin, end, zone)
             // Sections holding data must show even when not in the defaults.
             _revealed.value = snapshot.form.populatedFields()
             _form.value = snapshot.form

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapperTest.kt

@@ -32,6 +32,7 @@ class EventDetailMapperTest {
         accessLevel: Any? = null,
         timezone: String? = null,
         selfStatus: Any? = null,
+        duration: String? = null,
     ): MapColumnReader = MapColumnReader(
         EventDetailProjection.IDX_EVENT_ID to eventId,
         EventDetailProjection.IDX_TITLE to title,
@@ -51,6 +52,7 @@ class EventDetailMapperTest {
         EventDetailProjection.IDX_EVENT_TIMEZONE to timezone,
         EventDetailProjection.IDX_SELF_ATTENDEE_STATUS to selfStatus,
         EventDetailProjection.IDX_EVENT_COLOR_KEY to eventColorKey,
+        EventDetailProjection.IDX_DURATION to duration,
     )
 
     private fun attendeeReader(
@@ -134,12 +136,32 @@ class EventDetailMapperTest {
     fun `pre-1970 negative dtstart is kept, not dropped (issue #34)`() {
         // A yearly birthday/anniversary anchored before the epoch has a
         // legitimately negative UTC epoch-millis DTSTART; recurring rows carry
-        // no DTEND (they use DURATION), so it stays end == begin.
+        // no DTEND (they use DURATION), so the length comes from DURATION.
         val begin = -157_766_400_000L // 1965-01-01T00:00:00Z
-        val detail = detailReader(dtstart = begin, dtend = null).toDetail()
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "P1D").toDetail()
         assertThat(detail).isNotNull()
         assertThat(detail!!.instance.start.toEpochMilliseconds()).isEqualTo(begin)
-        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin)
+        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin + 86_400_000L)
+    }
+
+    @Test
+    fun `absent dtend takes its length from DURATION (issue #48)`() {
+        // A recurring series row has no DTEND. Opened without a named
+        // occurrence — a bare content://…/events/<id> VIEW intent — the row's
+        // own times are what render, so DURATION has to supply the length or
+        // the event shows as zero-length (10:00–10:00).
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "PT1H").toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin + 3_600_000L)
+    }
+
+    @Test
+    fun `absent dtend and absent DURATION stays zero-length`() {
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = null).toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt

@@ -260,6 +260,77 @@ class EventWriteMapperTest {
             .isEqualTo(CalendarContract.Events.STATUS_CANCELED)
     }
 
+    // --- buildOccurrenceExdateValues ("delete only this event", no _sync_id) ---
+
+    @Test
+    fun `exdate drop excludes the occurrence and rewrites the recurrence set`() {
+        // 2026-07-15T08:00:00Z.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+        // The whole time/recurrence set rides along: an EXDATE-only update is not
+        // treated as a recurrence change, so the provider would leave the expanded
+        // instances (and the occurrence) in place. DTSTART alone is worse — it
+        // makes the provider recompute lastDate as a single instance and collapse
+        // the series to its first occurrence.
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_783_929_600_000L)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=DAILY;COUNT=5")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("PT1H")
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
+    }
+
+    @Test
+    fun `exdate drop appends to an existing exdate list`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260714T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE])
+            .isEqualTo("20260714T080000Z,20260715T080000Z")
+    }
+
+    @Test
+    fun `exdate drop folds away a repeated occurrence`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260715T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+    }
+
+    @Test
+    fun `all-day exdate drop uses the date-only form`() {
+        // An all-day DTSTART sits at UTC midnight, so the date reads off UTC.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_073_600_000L, // 2026-07-15T00:00:00Z
+            dtStartMillis = 1_783_900_800_000L,
+            rrule = "FREQ=YEARLY",
+            duration = "P1D",
+            timezone = "UTC",
+            allDay = 1,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715")
+        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
+    }
+
     // --- per-event colour ---
 
     @Test

fastlane/metadata/android/en-US/changelogs/21401.txt

@@ -0,0 +1,34 @@
+### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
+- A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
+  app (such as DAVx5), the event colour picker showed every colour the account
+  publishes — nearly 150 swatches in alphabetical order, many of them
+  duplicates or near-identical shades. The picker now shows only visually
+  distinct colours, arranged as a rainbow; near-duplicate shades and the
+  washed-out neutrals are folded away so no two swatches look alike. Picked
+  colours still sync exactly as before, and calendars with hand-picked
+  palettes (like Google's) are unaffected. Thanks to @ptab for the report
+  ([#22]).
+