diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/ReminderStatePrefs.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/ReminderStatePrefs.kt index 47c008f8..730d40d0 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/ReminderStatePrefs.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/ReminderStatePrefs.kt @@ -4,6 +4,8 @@ import androidx.datastore.core.DataStore import androidx.datastore.preferences.core.Preferences import de.jeanlucmakiola.floret.prefs.PrefStore import de.jeanlucmakiola.floret.prefs.nullableLongPref +import de.jeanlucmakiola.floret.prefs.nullableStringPref +import java.time.LocalDate import javax.inject.Inject import javax.inject.Singleton @@ -27,7 +29,13 @@ class ReminderStatePrefs @Inject constructor( suspend fun setLastScanMillis(millis: Long) = prefs.set(LAST_SCAN, millis) + /** The day the last daily summary listed (#459), so a re-run scan never posts it twice. */ + suspend fun lastDigestDay(): LocalDate? = prefs.get(LAST_DIGEST_DAY)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } + + suspend fun setLastDigestDay(day: LocalDate) = prefs.set(LAST_DIGEST_DAY, day.toString()) + private companion object { val LAST_SCAN = nullableLongPref("reminder_last_scan_millis") + val LAST_DIGEST_DAY = nullableStringPref("reminder_last_digest_day") } } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt index dee44f99..20f8f02d 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt @@ -1,10 +1,12 @@ package de.jeanlucmakiola.calendula.data.prefs import androidx.datastore.core.DataStore +import androidx.datastore.preferences.core.MutablePreferences import androidx.datastore.preferences.core.Preferences import de.jeanlucmakiola.calendula.domain.EventFormField import de.jeanlucmakiola.calendula.domain.FontRole import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType +import de.jeanlucmakiola.calendula.domain.reminders.DEFAULT_DIGEST_TIME_MINUTES import de.jeanlucmakiola.calendula.domain.reminders.DailyDigestSettings import de.jeanlucmakiola.calendula.domain.reminders.DigestDay import de.jeanlucmakiola.calendula.domain.reminders.FixedTimeReminder @@ -190,7 +192,8 @@ class SettingsPrefs @Inject constructor( */ val knownFixedTimeReminders: Flow> = prefs.snapshot { setOfNotNull(it[SettingsKeys.defaultFixedTimeReminder]) + - it[SettingsKeys.perCalendarFixedTimeReminderOverride].values.filterNotNull() + it[SettingsKeys.perCalendarFixedTimeReminderOverride].values.filterNotNull() + + it[SettingsKeys.recentFixedTimeReminders] } val dailyDigest: Flow = prefs.snapshot { it.dailyDigest } val autoBackupEnabled: Flow = prefs.flow(SettingsKeys.autoBackupEnabled) @@ -359,12 +362,28 @@ class SettingsPrefs @Inject constructor( } } - suspend fun setDailyDigestEnabled(enabled: Boolean) = prefs.set(SettingsKeys.dailyDigestEnabled, enabled) + suspend fun setDailyDigestEnabled(enabled: Boolean) = editDigest { it[SettingsKeys.dailyDigestEnabled] = enabled } suspend fun setDailyDigestTimeMinutes(minutesOfDay: Int) = - prefs.set(SettingsKeys.dailyDigestTimeMinutes, minutesOfDay) + editDigest { it[SettingsKeys.dailyDigestTimeMinutes] = minutesOfDay } - suspend fun setDailyDigestDay(day: DigestDay) = prefs.set(SettingsKeys.dailyDigestDay, day) + suspend fun setDailyDigestDay(day: DigestDay) = editDigest { it[SettingsKeys.dailyDigestDay] = day } + + /** + * Change when the summary arrives, stamping the moment: a summary whose time + * had already passed today is not owed by the change itself. + */ + private suspend fun editDigest(change: (MutablePreferences) -> Unit) { + prefs.edit { + change(it) + it[SettingsKeys.dailyDigestArmedAt] = System.currentTimeMillis() + } + } + + /** Remember a fixed-time reminder picked by hand, so it reads back as one later (#459). */ + suspend fun addRecentFixedTimeReminder(reminder: FixedTimeReminder) { + prefs.update(SettingsKeys.recentFixedTimeReminders) { (listOf(reminder) + it).distinct() } + } suspend fun setCalendarInDailyDigest(calendarId: Long, included: Boolean) { prefs.update(SettingsKeys.digestExcludedCalendarIds) { if (included) it - calendarId else it + calendarId } @@ -419,8 +438,7 @@ class SettingsPrefs @Inject constructor( /** 09:00 as minutes from midnight; the default all-day reminder fire time. */ internal const val DEFAULT_ALLDAY_REMINDER_TIME = 540 internal const val MINUTES_PER_DAY = 1_440 - /** 20:00, when the daily summary arrives until changed. */ - internal const val DEFAULT_DIGEST_TIME = 1_200 + internal const val MAX_RECENT_FIXED_TIME_REMINDERS = 5 /** Default snooze delay for the notification "Snooze" action. */ const val DEFAULT_SNOOZE_MINUTES = 10 const val DEFAULT_MULTI_DAY_COUNT = 3 @@ -757,7 +775,7 @@ object SettingsKeys { /** The daily summary notification (#459): opt-in, and which day it lists at what time. */ val dailyDigestEnabled: Pref = booleanPref("daily_digest_enabled", false) val dailyDigestTimeMinutes: Pref = - intPref("daily_digest_time_minutes", SettingsPrefs.DEFAULT_DIGEST_TIME).coerced { + intPref("daily_digest_time_minutes", DEFAULT_DIGEST_TIME_MINUTES).coerced { it.coerceIn(0, SettingsPrefs.MINUTES_PER_DAY - 1) } val dailyDigestDay: Pref = enumPref("daily_digest_day", DigestDay.Tomorrow) @@ -765,6 +783,19 @@ object SettingsKeys { /** Calendars left out of the daily summary; every other one is in. */ val digestExcludedCalendarIds: Pref> = idSetPref("digest_excluded_calendar_ids") + /** When the summary's switch, time or day last changed; a moment before it is never owed. */ + val dailyDigestArmedAt: Pref = longPref("daily_digest_armed_at", 0L) + + /** + * Fixed-time reminders last picked by hand in the editor, newest first — + * with the defaults, the patterns a stored offset is recognised as. + */ + val recentFixedTimeReminders: Pref> = + nullableStringPref("recent_fixed_time_reminders").map( + { stored -> stored?.split(LIST_SEP).orEmpty().mapNotNull(FixedTimeReminder::parse).distinct() }, + { reminders -> reminders.take(SettingsPrefs.MAX_RECENT_FIXED_TIME_REMINDERS).joinToString(LIST_SEP) { it.toToken() } }, + ) + /** Whether periodic automatic `.ics` export of local calendars is on (issue #8). */ val autoBackupEnabled: Pref = booleanPref("auto_backup_enabled", false) @@ -968,6 +999,7 @@ internal val Preferences.dailyDigest: DailyDigestSettings timeMinutes = this[SettingsKeys.dailyDigestTimeMinutes], day = this[SettingsKeys.dailyDigestDay], excludedCalendarIds = this[SettingsKeys.digestExcludedCalendarIds], + armedAtMillis = this[SettingsKeys.dailyDigestArmedAt], ) /** A calendar's choice for the fixed-time default, as a picker returns it. */ diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/DailyDigestNotifier.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/DailyDigestNotifier.kt index 483b7d9d..3684678a 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/DailyDigestNotifier.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/DailyDigestNotifier.kt @@ -1,22 +1,18 @@ package de.jeanlucmakiola.calendula.data.reminders -import android.Manifest import android.app.NotificationChannel import android.app.NotificationManager import android.app.PendingIntent import android.content.Context -import android.os.Build import android.util.Log import androidx.core.app.NotificationCompat import androidx.core.app.NotificationManagerCompat import dagger.hilt.android.qualifiers.ApplicationContext import de.jeanlucmakiola.calendula.MainActivity import de.jeanlucmakiola.calendula.R -import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs import de.jeanlucmakiola.calendula.data.prefs.is24Hour import de.jeanlucmakiola.calendula.domain.reminders.ReminderEventInstance -import de.jeanlucmakiola.floret.android.hasPermission import kotlinx.coroutines.flow.first import kotlinx.datetime.toKotlinLocalDate import java.time.DayOfWeek @@ -36,23 +32,13 @@ import javax.inject.Singleton class DailyDigestNotifier @Inject constructor( @ApplicationContext private val context: Context, private val settingsPrefs: SettingsPrefs, - private val calendarPrefs: CalendarPrefs, ) { - /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */ - fun canPost(): Boolean { - val granted = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU || - context.hasPermission(Manifest.permission.POST_NOTIFICATIONS) - return granted && NotificationManagerCompat.from(context).areNotificationsEnabled() - } - /** - * Post the summary of [day] listing [entries], or withdraw the last one when + * Post the summary of [day] listing [listed], or withdraw the last one when * there is nothing to list — yesterday's would otherwise stand in for it. */ - suspend fun post(day: LocalDate, entries: List) { - val switchedOff = calendarPrefs.pendingDisabledCalendarIds.first() - val listed = entries.filter { it.calendarId !in switchedOff } + suspend fun post(day: LocalDate, listed: List) { val manager = NotificationManagerCompat.from(context) if (listed.isEmpty()) { manager.cancel(TAG_DIGEST, NOTIFICATION_ID) @@ -69,8 +55,11 @@ class DailyDigestNotifier @Inject constructor( today.plusDays(1) -> context.getString(R.string.reminder_day_tomorrow) else -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale).format(day) } + val allDay = context.getString(R.string.event_detail_all_day) val lines = listed.map { entry -> - val time = reminderTimeText( + // Read against the listed day, so a timed event on it shows its bare + // range and one crossing midnight its dates; the week start never shows. + val time = if (entry.isAllDay) allDay else reminderTimeText( beginMillis = entry.beginMillis, endMillis = entry.endMillis, isAllDay = entry.isAllDay, @@ -78,9 +67,8 @@ class DailyDigestNotifier @Inject constructor( locale = locale, is24Hour = is24Hour, today = day, - // Only cross-day spans name a date, so the week start never shows. firstDayOfWeek = DayOfWeek.MONDAY, - todayLabel = context.getString(R.string.event_detail_all_day), + todayLabel = allDay, tomorrowLabel = context.getString(R.string.reminder_day_tomorrow), yesterdayLabel = context.getString(R.string.reminder_day_yesterday), ) @@ -115,9 +103,9 @@ class DailyDigestNotifier @Inject constructor( return CHANNEL_ID } + /** Creates the channel, or renames it after a language change; the user's settings on it stay. */ private fun ensureChannel() { val manager = context.getSystemService(NotificationManager::class.java) - if (manager.getNotificationChannel(CHANNEL_ID) != null) return manager.createNotificationChannel( NotificationChannel( CHANNEL_ID, diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderScanner.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderScanner.kt index 04e098ff..c6721d4e 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderScanner.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderScanner.kt @@ -6,6 +6,7 @@ import android.util.Log import dagger.hilt.android.qualifiers.ApplicationContext import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource import de.jeanlucmakiola.calendula.data.calendar.withoutProviderDefaults +import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs import de.jeanlucmakiola.calendula.data.prefs.ReminderStatePrefs import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs import de.jeanlucmakiola.calendula.domain.reminders.DailyDigestSettings @@ -51,6 +52,7 @@ class ReminderScanner @Inject constructor( private val snoozes: ReminderSnoozeScheduler, private val alarms: ReminderAlarmScheduler, private val state: ReminderStatePrefs, + private val calendarPrefs: CalendarPrefs, private val settingsPrefs: SettingsPrefs, @IoDispatcher private val io: kotlinx.coroutines.CoroutineDispatcher, ) { @@ -138,17 +140,30 @@ class ReminderScanner @Inject constructor( */ private suspend fun postDigest(settings: DailyDigestSettings, lastFired: Long, now: Long): Long { val zone = ZoneId.systemDefault() - val schedule = scheduleDigest(settings.timeMinutes, settings.day, zone, lastFired, now) + val schedule = scheduleDigest( + timeMinutes = settings.timeMinutes, + day = settings.day, + zone = zone, + // A moment that passed before the summary was set up is not owed. + lastFiredMillis = maxOf(lastFired, settings.armedAtMillis), + nowMillis = now, + lastPostedDay = state.lastDigestDay(), + ) val day = schedule.dueDay ?: return schedule.nextAlarmMillis // A failed summary must not cost the event reminders this pass owes. - if (digestNotifier.canPost()) runCatching { - // A day either side: all-day occurrences sit at UTC midnight, which - // can fall outside the local day they stand for. - val from = day.minusDays(1).atStartOfDay(zone).toInstant().toEpochMilli() - val to = day.plusDays(2).atStartOfDay(zone).toInstant().toEpochMilli() - val entries = digestEntries(source.occurrences(from, to), day, zone, settings.excludedCalendarIds) - digestNotifier.post(day, entries) - }.onFailure { Log.w(TAG, "Daily summary failed", it) } + if (notifier.canPost()) { + try { + // A day either side: all-day occurrences sit at UTC midnight, which + // can fall outside the local day they stand for. + val from = day.minusDays(1).atStartOfDay(zone).toInstant().toEpochMilli() + val to = day.plusDays(2).atStartOfDay(zone).toInstant().toEpochMilli() + val left = settings.excludedCalendarIds + calendarPrefs.pendingDisabledCalendarIds.first() + digestNotifier.post(day, digestEntries(source.occurrences(from, to), day, zone, left)) + state.setLastDigestDay(day) + } catch (e: Exception) { + Log.w(TAG, "Daily summary failed", e) + } + } return schedule.nextAlarmMillis } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventForm.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventForm.kt index ff98cde7..45d925f8 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventForm.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventForm.kt @@ -44,7 +44,8 @@ data class EventForm( val reminders: List = emptyList(), /** * "N days before at HH:MM" reminders of a timed event (#459), written as lead - * times measured from [start] at save time. Always empty on an all-day event. + * times measured from [start] at save time. Ignored while [isAllDay], so a + * round trip through all-day keeps them. */ val fixedReminders: List = emptyList(), val availability: Availability = Availability.Busy, @@ -293,7 +294,7 @@ fun EventForm.populatedFields(): Set = buildSet { if (location.isNotBlank()) add(EventFormField.Location) if (description.isNotBlank()) add(EventFormField.Description) if (timezone != null) add(EventFormField.Timezone) - if (reminders.isNotEmpty() || fixedReminders.isNotEmpty()) add(EventFormField.Reminders) + if (reminders.isNotEmpty() || (!isAllDay && fixedReminders.isNotEmpty())) add(EventFormField.Reminders) if (rrule != null) add(EventFormField.Recurrence) if (availability != Availability.Busy) add(EventFormField.Availability) if (status != EventStatus.Confirmed) add(EventFormField.Status) diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigest.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigest.kt index 658ecacb..cdfc642d 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigest.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigest.kt @@ -9,12 +9,19 @@ import java.time.ZoneOffset /** Which day the daily summary (#459) lists, counted from the day it arrives. */ enum class DigestDay(val daysAhead: Long) { Today(0), Tomorrow(1) } -/** The daily summary's settings. Calendars in [excludedCalendarIds] are left out of it. */ +/** 20:00, when the daily summary arrives until changed. */ +const val DEFAULT_DIGEST_TIME_MINUTES = 1_200 + +/** + * The daily summary's settings. Calendars in [excludedCalendarIds] are left out + * of it; [armedAtMillis] is when its switch, time or day last changed. + */ data class DailyDigestSettings( val enabled: Boolean = false, - val timeMinutes: Int = 1_200, + val timeMinutes: Int = DEFAULT_DIGEST_TIME_MINUTES, val day: DigestDay = DigestDay.Tomorrow, val excludedCalendarIds: Set = emptySet(), + val armedAtMillis: Long = 0L, ) /** @@ -30,7 +37,8 @@ data class DigestSchedule( * When the summary is owed, measured against the same watermark as the event * reminders: a moment in `(lastFiredMillis, nowMillis]` is due. Only the latest * such moment counts — a phone off for three evenings gets one summary, not - * three — and only while the day it lists has not passed. + * three — and only while the day it lists has not passed and is not + * [lastPostedDay], so a pass that failed after posting can't post it again. */ fun scheduleDigest( timeMinutes: Int, @@ -38,13 +46,16 @@ fun scheduleDigest( zone: ZoneId, lastFiredMillis: Long, nowMillis: Long, + lastPostedDay: LocalDate? = null, ): DigestSchedule { val time = LocalTime.of(timeMinutes / 60, timeMinutes % 60) val fireAt = { date: LocalDate -> date.atTime(time).atZone(zone).toInstant().toEpochMilli() } val today = Instant.ofEpochMilli(nowMillis).atZone(zone).toLocalDate() val latestDate = if (fireAt(today) <= nowMillis) today else today.minusDays(1) val listed = latestDate.plusDays(day.daysAhead) - val dueDay = listed.takeIf { fireAt(latestDate) > lastFiredMillis && !it.isBefore(today) } + val dueDay = listed.takeIf { + fireAt(latestDate) > lastFiredMillis && !it.isBefore(today) && it != lastPostedDay + } return DigestSchedule(dueDay = dueDay, nextAlarmMillis = fireAt(latestDate.plusDays(1))) } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminder.kt b/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminder.kt index fde11695..a277fd34 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminder.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminder.kt @@ -16,7 +16,7 @@ import kotlin.time.Instant * The provider only knows lead times, so it is stored as an ordinary `Reminders` * row whose offset is the distance from that wall-clock moment to the start * ([offsetMinutes]) — it fires on every device and in every app. The pattern is - * only known to Calendula while it can be read back ([splitTimedReminders]); the + * only known to Calendula while it can be read back ([classifyTimedReminder]); the * editor then re-derives the offset whenever the start moves. */ data class FixedTimeReminder(val daysBefore: Int, val minuteOfDay: Int) { @@ -41,7 +41,6 @@ data class FixedTimeReminder(val daysBefore: Int, val minuteOfDay: Int) { companion object { const val MAX_DAYS_BEFORE = 28 - private const val MINUTES_PER_DAY = 1_440 private const val TOKEN_SEP = "@" /** [toToken] read back; null for anything malformed or out of range. */ @@ -77,35 +76,33 @@ data class TimedReminders( ) /** - * Sort a timed event's raw offsets into lead times and "N days before at HH:MM" - * reminders. The provider can't say which an offset was meant as, so: - * - * - one landing on a pattern in [known] (the configured defaults) is fixed-time; - * - otherwise one reaching back past the start's own day is fixed-time, unless it - * is a whole number of days or one of [plainLeadMinutes] — those read as the - * lead time they look like. - * - * The cost of guessing wrong is small: the reminder fires at the same moment - * either way, and only a later change of the start's time of day treats it - * differently. A hand-entered "3 hours before" on an event at 01:00 does read as - * "1 day before at 22:00". + * The fixed-time reminder [offsetMinutes] stands for on an event starting at + * [start], or null when it reads as a plain lead time. The provider can't say + * which an offset was meant as, so only the patterns in [known] — the configured + * defaults and the ones picked by hand on this device — are recognised: guessing + * from the offset's shape alone would turn ordinary leads ("12 hours before") + * into fixed-time ones. A wrong reading never moves an alarm; it only changes + * what a later edit of the start's time does. */ +fun classifyTimedReminder( + offsetMinutes: Int, + start: Instant, + zone: TimeZone, + known: Set, +): FixedTimeReminder? = fixedTimeReminderAt(offsetMinutes, start, zone)?.takeIf { it in known } + +/** Sort a timed event's raw offsets into lead times and fixed-time reminders ([classifyTimedReminder]). */ fun splitTimedReminders( offsets: List, start: Instant, zone: TimeZone, known: Set, - plainLeadMinutes: Collection = PLAIN_LEAD_MINUTES, ): TimedReminders { val leads = mutableListOf() val fixed = mutableListOf() offsets.distinct().forEach { offset -> - val pattern = fixedTimeReminderAt(offset, start, zone) - val isFixed = pattern != null && ( - pattern in known || - (offset % MINUTES_PER_DAY != 0 && offset !in plainLeadMinutes) - ) - if (isFixed) fixed += pattern!! else leads += offset + val pattern = classifyTimedReminder(offset, start, zone, known) + if (pattern != null) fixed += pattern else leads += offset } return TimedReminders(leads.sorted(), fixed.distinct().sortedWith(FIXED_ORDER)) } @@ -114,7 +111,4 @@ fun splitTimedReminders( val FIXED_ORDER: Comparator = compareByDescending { it.daysBefore }.thenBy { it.minuteOfDay } -/** Lead times offered as presets: always read as what they look like. */ -private val PLAIN_LEAD_MINUTES = setOf(5, 10, 15, 30, 45, 60, 90, 120) - private const val MINUTES_PER_DAY = 1_440 diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModel.kt index 5f860685..ff30b4ad 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModel.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModel.kt @@ -1,7 +1,7 @@ package de.jeanlucmakiola.calendula.ui.detail import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs -import de.jeanlucmakiola.calendula.domain.reminders.splitTimedReminders +import de.jeanlucmakiola.calendula.domain.reminders.classifyTimedReminder import de.jeanlucmakiola.calendula.domain.withFixedTimeRemindersRead import android.net.Uri import androidx.lifecycle.ViewModel @@ -169,8 +169,7 @@ class EventDetailViewModel @Inject constructor( } else { val zone = zoneSource.current() corrected.reminders.map { it.minutes }.distinct().mapNotNull { minutes -> - splitTimedReminders(listOf(minutes), corrected.instance.start, zone, knownFixed) - .fixed.firstOrNull()?.let { minutes to it } + classifyTimedReminder(minutes, corrected.instance.start, zone, knownFixed)?.let { minutes to it } }.toMap() } val description = corrected.description diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt index c24c4bbe..32f5419a 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt @@ -880,7 +880,7 @@ private fun EventEditContent( Spacer(Modifier.height(gap)) RemindersSection( reminders = form.reminders, - fixedReminders = form.fixedReminders, + fixedReminders = if (form.isAllDay) emptyList() else form.fixedReminders, onRemove = viewModel::removeReminder, onRemoveFixed = viewModel::removeFixedReminder, onAdd = { sheet = EditSheet.Reminder }, diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt index a2253ab0..98e8cfc2 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt @@ -448,7 +448,7 @@ class EventEditViewModel @Inject constructor( if (source.ownsDuration) _durationTouched.value = true else applyDefaultDuration() when (source) { ImportSource.Insert, ImportSource.InsertOpenEnded -> - if (form.reminders.isNotEmpty()) _remindersTouched.value = true + if (form.reminders.isNotEmpty() || form.fixedReminders.isNotEmpty()) _remindersTouched.value = true else applyDefaultReminder() ImportSource.File -> { @@ -491,14 +491,21 @@ class EventEditViewModel @Inject constructor( } /** Snapshot the settings-default reminder flows into one value. */ - private suspend fun reminderDefaults(): ReminderDefaults = ReminderDefaults( - timed = settingsPrefs.defaultReminderMinutes.first(), - allDay = settingsPrefs.defaultAllDayReminderMinutes.first(), - timedOverrides = settingsPrefs.perCalendarReminderOverride.first(), - allDayOverrides = settingsPrefs.perCalendarAllDayReminderOverride.first(), - fixed = settingsPrefs.defaultFixedTimeReminder.first(), - fixedOverrides = settingsPrefs.perCalendarFixedTimeReminderOverride.first(), - ) + private suspend fun reminderDefaults(): ReminderDefaults = combine( + combine( + settingsPrefs.defaultReminderMinutes, + settingsPrefs.defaultAllDayReminderMinutes, + settingsPrefs.perCalendarReminderOverride, + settingsPrefs.perCalendarAllDayReminderOverride, + ::Quadruple, + ), + settingsPrefs.defaultFixedTimeReminder, + settingsPrefs.perCalendarFixedTimeReminderOverride, + ) { (timed, allDay, timedOv, allDayOv), fixed, fixedOv -> + ReminderDefaults(timed, allDay, timedOv, allDayOv, fixed, fixedOv) + }.first() + + private data class Quadruple(val a: A, val b: B, val c: C, val d: D) /** * Stretch a new timed event to the configured default length (#54) — the @@ -658,11 +665,7 @@ class EventEditViewModel @Inject constructor( // A kept pass of a repeated hour stays, so switching back out of all-day // lands where the event was — unless dropping the pin changed the zone. edit { - if (value) { - it.withTimezone(null, zoneSource.current()).copy(isAllDay = true, fixedReminders = emptyList()) - } else { - it.copy(isAllDay = false) - } + if (value) it.withTimezone(null, zoneSource.current()).copy(isAllDay = true) else it.copy(isAllDay = false) } // The default reminder differs for all-day vs timed; re-apply the // type-appropriate default unless the user has hand-edited it (guarded). @@ -728,6 +731,8 @@ class EventEditViewModel @Inject constructor( edit { if (it.isAllDay) it else it.copy(fixedReminders = (it.fixedReminders + reminder).distinct().sortedWith(FIXED_ORDER)) } + // Remembered so the row reads back as this reminder when reopened. + viewModelScope.launch { withContext(io) { settingsPrefs.addRecentFixedTimeReminder(reminder) } } } fun removeFixedReminder(reminder: FixedTimeReminder) { diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt index 98ad4ec4..d1694b6c 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt @@ -82,18 +82,9 @@ internal fun NotificationsScreen( val launcher = rememberLauncherForActivityResult( contract = ActivityResultContracts.RequestPermission(), ) { /* The pref is already on; a denial just leaves the OS gate shut. */ } - val toggleReminders: (Boolean) -> Unit = { enabled -> - viewModel.setRemindersEnabled(enabled) - val needsPermission = enabled && - Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && - !context.hasPermission(Manifest.permission.POST_NOTIFICATIONS) - if (needsPermission) { - launcher.launch(Manifest.permission.POST_NOTIFICATIONS) - } - } - - val toggleDigest: (Boolean) -> Unit = { enabled -> - viewModel.setDailyDigestEnabled(enabled) + // Turning either kind of notification on asks for the permission if missing. + fun askingPermission(set: (Boolean) -> Unit): (Boolean) -> Unit = { enabled -> + set(enabled) val needsPermission = enabled && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && !context.hasPermission(Manifest.permission.POST_NOTIFICATIONS) @@ -101,6 +92,8 @@ internal fun NotificationsScreen( launcher.launch(Manifest.permission.POST_NOTIFICATIONS) } } + val toggleReminders = askingPermission(viewModel::setRemindersEnabled) + val toggleDigest = askingPermission(viewModel::setDailyDigestEnabled) var showDefaultReminder by remember { mutableStateOf(false) } var showAllDayReminder by remember { mutableStateOf(false) } @@ -174,9 +167,7 @@ internal fun NotificationsScreen( Spacer(Modifier.height(24.dp)) DailyDigestRows( digest = state.dailyDigest, - onEnable = { enabled -> - toggleDigest(enabled) - }, + onEnable = toggleDigest, onPickDay = { showDigestDay = true }, onPickTime = { showDigestTime = true }, onOpenSound = { diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt index 22d02732..43d2df23 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt @@ -748,6 +748,9 @@ class SettingsPrefsTest { assertThat(resolveDefaultFixedTimeReminder(FixedTimeReminder(1, 1_200), overrides, 3L)) .isEqualTo(FixedTimeReminder(1, 1_200)) assertThat(prefs.knownFixedTimeReminders.first()).containsExactly(FixedTimeReminder(1, 1_200), morning) + val picked = FixedTimeReminder(3, 600) + prefs.addRecentFixedTimeReminder(picked) + assertThat(prefs.knownFixedTimeReminders.first()).contains(picked) prefs.setCalendarFixedTimeReminderOverride(2L, FixedTimeOverride.Inherit) assertThat(prefs.perCalendarFixedTimeReminderOverride.first().containsKey(2L)).isFalse() @@ -761,9 +764,11 @@ class SettingsPrefsTest { prefs.setDailyDigestTimeMinutes(420) prefs.setDailyDigestDay(DigestDay.Today) prefs.setCalendarInDailyDigest(5L, included = false) - assertThat(prefs.dailyDigest.first()).isEqualTo( + val digest = prefs.dailyDigest.first() + assertThat(digest.copy(armedAtMillis = 0L)).isEqualTo( DailyDigestSettings(enabled = true, timeMinutes = 420, day = DigestDay.Today, excludedCalendarIds = setOf(5L)), ) + assertThat(digest.armedAtMillis).isGreaterThan(0L) prefs.setCalendarInDailyDigest(5L, included = true) assertThat(prefs.dailyDigest.first().excludedCalendarIds).isEmpty() } diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/domain/FixedTimeReminderFormTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/domain/FixedTimeReminderFormTest.kt index 62e8079a..6046e87d 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/FixedTimeReminderFormTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/FixedTimeReminderFormTest.kt @@ -22,7 +22,7 @@ class FixedTimeReminderFormTest { @Test fun `a moved start re-derives the offset so the wall clock stays`() { val loaded = form("2026-06-10T10:00", reminders = listOf(10, 840)) - .withFixedTimeRemindersRead(known = emptySet(), deviceZone = zone) + .withFixedTimeRemindersRead(known = setOf(evening), deviceZone = zone) assertThat(loaded.reminders).containsExactly(10) assertThat(loaded.fixedReminders).containsExactly(evening) assertThat(loaded.fixedReminderOffsets(zone)).containsExactly(840) @@ -34,13 +34,14 @@ class FixedTimeReminderFormTest { @Test fun `all-day forms keep their reminders and store no fixed ones`() { val allDay = form("2026-06-10T00:00", reminders = listOf(840), allDay = true) - assertThat(allDay.withFixedTimeRemindersRead(emptySet(), zone)).isEqualTo(allDay) + assertThat(allDay.withFixedTimeRemindersRead(setOf(evening), zone)).isEqualTo(allDay) assertThat(allDay.copy(fixedReminders = listOf(evening)).fixedReminderOffsets(zone)).isEmpty() } @Test - fun `fixed reminders count as a populated reminders section`() { + fun `fixed reminders count as a populated reminders section on a timed event only`() { val withFixed = form("2026-06-10T10:00").copy(fixedReminders = listOf(evening)) assertThat(withFixed.populatedFields()).contains(EventFormField.Reminders) + assertThat(withFixed.copy(isAllDay = true).populatedFields()).doesNotContain(EventFormField.Reminders) } } diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigestTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigestTest.kt index 30b73c26..cf30cd10 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigestTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/DailyDigestTest.kt @@ -28,6 +28,15 @@ class DailyDigestTest { assertThat(schedule.dueDay).isNull() } + @Test + fun `a day already listed is not listed again`() { + val schedule = scheduleDigest( + eight, DigestDay.Tomorrow, zone, millis("2026-06-10T19:00"), millis("2026-06-10T20:01"), + lastPostedDay = LocalDate.of(2026, 6, 11), + ) + assertThat(schedule.dueDay).isNull() + } + @Test fun `before the moment it only arms the alarm`() { val schedule = scheduleDigest(eight, DigestDay.Tomorrow, zone, millis("2026-06-10T08:00"), millis("2026-06-10T09:00")) diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminderTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminderTest.kt index 748135db..31caa113 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminderTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/reminders/FixedTimeReminderTest.kt @@ -42,11 +42,16 @@ class FixedTimeReminderTest { } @Test - fun `split keeps presets and whole days as lead times`() { + fun `only known patterns read as fixed-time`() { val start = at("2026-06-10T10:00") - val split = splitTimedReminders(listOf(10, 1_440, 840, 2 * 1_440), start, berlin, known = emptySet()) - assertThat(split.leadMinutes).containsExactly(10, 1_440, 2_880).inOrder() - assertThat(split.fixed).containsExactly(eveningBefore) + // 840 is "1 day before at 20:00" here, but also a plain "14 hours before". + val unknown = splitTimedReminders(listOf(10, 1_440, 840), start, berlin, known = emptySet()) + assertThat(unknown.leadMinutes).containsExactly(10, 840, 1_440).inOrder() + assertThat(unknown.fixed).isEmpty() + + val known = splitTimedReminders(listOf(10, 1_440, 840), start, berlin, known = setOf(eveningBefore)) + assertThat(known.leadMinutes).containsExactly(10, 1_440).inOrder() + assertThat(known.fixed).containsExactly(eveningBefore) } @Test @@ -67,7 +72,7 @@ class FixedTimeReminderTest { listOf(eveningBefore.offsetMinutes(start, berlin), twoDays.offsetMinutes(start, berlin)), start, berlin, - known = emptySet(), + known = setOf(eveningBefore, twoDays), ) assertThat(split.fixed).containsExactly(twoDays, eveningBefore).inOrder() } diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt index 61480efb..7b6fc20f 100644 --- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt +++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt @@ -779,5 +779,46 @@ class EventEditViewModelTest { assertThat(fake.updatedEvents.single().third.fixedReminders).containsExactly(evening) job.cancel() } + + @Test + fun `a round trip through all-day keeps set-time reminders`( + @TempDir tempDir: Path, + ) = runTest(dispatcher) { + val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) } + val s = settings(tempDir) + s.setDefaultFixedTimeReminder(FixedTimeReminder(1, 1_200)) + val vm = viewModel(tempDir, fake, s) + val job = activate(vm) + + vm.openNew(LocalDate(2030, 1, 15), startMinutes = 600) + advanceUntilIdle() + vm.addFixedReminder(FixedTimeReminder(2, 480)) + vm.setAllDay(true) + vm.setAllDay(false) + advanceUntilIdle() + assertThat(vm.state.value!!.form!!.fixedReminders) + .containsExactly(FixedTimeReminder(2, 480), FixedTimeReminder(1, 1_200)) + job.cancel() + } + + @Test + fun `a copy carrying only set-time reminders keeps them`( + @TempDir tempDir: Path, + ) = runTest(dispatcher) { + val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) } + val s = settings(tempDir) + s.setDefaultReminderMinutes(listOf(15)) + val vm = viewModel(tempDir, fake, s) + val job = activate(vm) + + val copy = importedForm(end = LocalDateTime(2030, 1, 15, 10, 0)) + .copy(reminders = emptyList(), fixedReminders = listOf(FixedTimeReminder(1, 1_200))) + vm.openImported(copy, ImportSource.Insert) + advanceUntilIdle() + val form = vm.state.value!!.form!! + assertThat(form.fixedReminders).containsExactly(FixedTimeReminder(1, 1_200)) + assertThat(form.reminders).isEmpty() + job.cancel() + } } diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index da1f8c9b..d4b0a7dd 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -415,11 +415,12 @@ moment (device zone) to the start, so it syncs and fires everywhere — the scan plans it like any lead time. Only the editor knows it as a pattern (`EventForm.fixedReminders`), and it re-derives the offset from the start it saves with, so moving the event, in the form or by drag, keeps the wall clock. -Reading a row back is a guess, made in one place (`splitTimedReminders`): an -offset landing on a configured default's pattern is fixed-time; otherwise one -reaching back past the start's day is, unless it is a whole number of days or a -short preset. Guessing wrong never moves an alarm, only how a later time change -treats it. Limits: a recurring series stores one offset, so an occurrence whose +Reading a row back is a guess, made in one place (`classifyTimedReminder`): an +offset is fixed-time only when it lands on a known pattern — a configured +default, or one picked by hand on this device (`recentFixedTimeReminders`). +Guessing from the offset's shape alone would turn ordinary leads ("12 hours +before") into fixed ones; guessing wrong never moves an alarm, only how a later +time change treats it. Limits: a recurring series stores one offset, so an occurrence whose lead spans a DST change fires an hour off the named time (as in every other app reading that row), and on another device or app the row is just a lead time. New timed events get the default (`SettingsKeys.defaultFixedTimeReminder`, with @@ -431,6 +432,10 @@ counts after a long gap, and it is dropped once the day it lists has passed. It is independent of the event-reminder switch, posts on its own channel (`DailyDigestNotifier`), lists switched-on calendars minus its own exclusions, and replaces the previous summary — or withdraws it when the day is empty. +Two guards keep it to one per day: the day last listed is recorded right after +posting (`ReminderStatePrefs.lastDigestDay`), so a pass failing later can't post +it twice, and changing the switch, time or day stamps `dailyDigestArmedAt`, so a +moment that passed before the change is not owed by it. The per-calendar reminder mute does not apply: a calendar too noisy to ping per event can still belong in the overview, and the summary has its own per-calendar switch next to it.