diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt index f75b69a4..c99dd887 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt @@ -81,7 +81,7 @@ class CalendarPrefs @Inject constructor( } /** A comma-joined id set; non-numeric tokens are dropped, and an empty set removes the key. */ -private fun idSetPref(name: String): Pref> = nullableStringPref(name).map( +internal fun idSetPref(name: String): Pref> = nullableStringPref(name).map( { stored -> stored.orEmpty().split(',').mapNotNull { it.trim().toLongOrNull() }.toSet() }, { ids -> if (ids.isEmpty()) null else ids.sorted().joinToString(",") }, ) 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 793c01e9..13e6c7b3 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 @@ -166,6 +166,8 @@ class SettingsPrefs @Inject constructor( val defaultEventDurationMinutes: Flow = prefs.flow(SettingsKeys.defaultEventDurationMinutes) val perCalendarEventDuration: Flow> = prefs.flow(SettingsKeys.perCalendarEventDuration) val remindersEnabled: Flow = prefs.flow(SettingsKeys.remindersEnabled) + val mutedReminderCalendarIds: Flow> = prefs.flow(SettingsKeys.mutedReminderCalendarIds) + val notificationCategoryHintDismissed: Flow = prefs.flow(SettingsKeys.notificationCategoryHintDismissed) val allowColorOnUnsupportedCalendars: Flow = prefs.flow(SettingsKeys.allowColorOnUnsupportedCalendars) val defaultReminderMinutes: Flow> = prefs.flow(SettingsKeys.defaultReminderMinutes) @@ -273,6 +275,12 @@ class SettingsPrefs @Inject constructor( suspend fun setRemindersEnabled(enabled: Boolean) = prefs.set(SettingsKeys.remindersEnabled, enabled) + suspend fun dismissNotificationCategoryHint() = prefs.set(SettingsKeys.notificationCategoryHintDismissed, true) + + suspend fun setCalendarRemindersEnabled(calendarId: Long, enabled: Boolean) { + prefs.update(SettingsKeys.mutedReminderCalendarIds) { if (enabled) it - calendarId else it + calendarId } + } + suspend fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) = prefs.set(SettingsKeys.allowColorOnUnsupportedCalendars, enabled) @@ -594,6 +602,18 @@ object SettingsKeys { */ val remindersEnabled: Pref = booleanPref("reminders_enabled", true) + /** + * Calendars whose reminders Calendula doesn't post (#272), independent of + * `Calendars.VISIBLE`: the events still show, only the notifications stop. + */ + val mutedReminderCalendarIds: Pref> = idSetPref("muted_reminder_calendar_ids") + + /** + * Whether the one-time hint that some skins (Samsung) start new notification + * categories switched off has been dismissed (#145). + */ + val notificationCategoryHintDismissed: Pref = booleanPref("notification_category_hint_dismissed", false) + /** * Whether to offer a custom event colour on calendars that publish no colour * palette; synced ones without a palette (some CalDAV) may drop or overwrite diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlan.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlan.kt new file mode 100644 index 00000000..e67a7727 --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlan.kt @@ -0,0 +1,161 @@ +package de.jeanlucmakiola.calendula.data.reminders + +import de.jeanlucmakiola.calendula.domain.CalendarSource +import de.jeanlucmakiola.calendula.ui.common.groupByAccount + +/** The single channel every reminder posted on before they moved per calendar (#145). */ +const val LEGACY_REMINDER_CHANNEL_ID = "reminders" + +private const val CHANNEL_PREFIX = "reminders.calendar." +private const val GROUP_PREFIX = "reminders.account." +private const val LOCAL_GROUP_ID = GROUP_PREFIX + "local" + +/** The notification channel [calendarId]'s reminders post on. */ +fun reminderChannelId(calendarId: Long): String = CHANNEL_PREFIX + calendarId + +/** Whether [channelId] is one of the per-calendar reminder channels. */ +fun isReminderChannelId(channelId: String): Boolean = channelId.startsWith(CHANNEL_PREFIX) + +/** Whether [groupId] is one of the per-account reminder channel groups. */ +fun isReminderGroupId(groupId: String): Boolean = groupId.startsWith(GROUP_PREFIX) + +/** + * One account's channel group, labelled as the calendar manager labels it. The + * app's own device calendars share a single group ([isLocal]); [ambiguous] + * marks a [label] another group shows too, so it should name the source app. + */ +data class ReminderChannelGroupSpec( + val id: String, + val label: String, + val accountType: String, + val isLocal: Boolean, + val ambiguous: Boolean, +) + +data class ReminderChannelSpec( + val id: String, + val calendarId: Long, + val name: String, + /** Null only for a channel created before its calendar could be looked up. */ + val groupId: String?, + /** + * Whether a sync creates it up front. A calendar that syncs no events never + * fires, so its channel only appears once something posts on it. + */ + val upFront: Boolean = true, +) + +/** What a channel already looks like in the system, as far as the plan compares it. */ +data class ExistingReminderChannel(val id: String, val name: String, val description: String?, val groupId: String?) + +data class ReminderChannelPlan( + val groups: List, + val channels: List, + /** + * The [channels] a sync writes: missing up-front ones, and existing ones + * whose name or (localized) description changed, or that still lack a group. + */ + val channelsToWrite: List, + /** The [groups] holding a channel that exists or is about to be written. */ + val groupsInUse: List, + val staleChannelIds: List, + val staleGroupIds: List, +) + +/** + * What the reminder channels should look like for [calendars]: one channel per + * calendar inside a group per account, which of them need writing, and the + * reminder channels and groups in [existing] / [existingGroupIds] no calendar + * claims any more. Ids outside the reminder namespace (the backup channel, the + * legacy channel) are never touched. + */ +fun planReminderChannels( + calendars: List, + existing: Collection, + existingGroupIds: Collection, + unnamed: String, + description: String, +): ReminderChannelPlan { + val (local, synced) = calendars.partition { it.isLocal } + val groups = buildList { + if (local.isNotEmpty()) { + add(ReminderChannelGroupSpec(LOCAL_GROUP_ID, "", local.first().accountType, isLocal = true, ambiguous = false)) + } + synced.groupByAccount().forEach { group -> + add( + ReminderChannelGroupSpec( + id = accountGroupId(group.key.type, group.key.name), + label = group.label, + accountType = group.accountType, + isLocal = false, + ambiguous = group.ambiguous, + ), + ) + } + } + val channels = calendars.map { calendar -> + ReminderChannelSpec( + id = reminderChannelId(calendar.id), + calendarId = calendar.id, + name = calendar.displayName.ifBlank { unnamed }, + groupId = if (calendar.isLocal) LOCAL_GROUP_ID else accountGroupId(calendar.accountType, calendar.accountName), + upFront = calendar.isLocal || calendar.syncsEvents, + ) + } + val existingById = existing.associateBy { it.id } + val wantedChannels = channels.mapTo(HashSet()) { it.id } + val wantedGroups = groups.mapTo(HashSet()) { it.id } + val toWrite = channels.filter { spec -> + val current = existingById[spec.id] + if (current == null) { + spec.upFront + } else { + current.name != spec.name || current.description != description || + (current.groupId == null && spec.groupId != null) + } + } + val usedGroupIds = channels + .filter { it.id in existingById || it in toWrite } + .mapNotNullTo(HashSet()) { it.groupId } + return ReminderChannelPlan( + groups = groups, + channels = channels, + channelsToWrite = toWrite, + groupsInUse = groups.filter { it.id in usedGroupIds }, + staleChannelIds = existingById.keys.filter { isReminderChannelId(it) && it !in wantedChannels }, + staleGroupIds = existingGroupIds.filter { isReminderGroupId(it) && it !in wantedGroups }, + ) +} + +private fun accountGroupId(type: String, name: String): String = "$GROUP_PREFIX$type/$name" + +/** A channel as far as its blocked state goes: switched off itself, and the group it sits in. */ +data class ReminderChannelState(val blocked: Boolean, val groupId: String?) + +/** Reminder notifications the system blocks, while Calendula would post them. */ +data class ReminderChannelStatus( + val appBlocked: Boolean = false, + val blockedCalendarIds: Set = emptySet(), + /** The blocked ones whose whole account group is off, which only the app's own screen can undo. */ + val groupBlockedCalendarIds: Set = emptySet(), +) + +/** + * What the system blocks of [calendarIds]' reminders: all of them while the + * app's notifications are off, otherwise those whose channel, or the group it + * sits in, is switched off. A calendar without a channel yet isn't blocked. + */ +fun reminderChannelStatus( + calendarIds: Collection, + appEnabled: Boolean, + channels: Map, + blockedGroupIds: Set, +): ReminderChannelStatus { + val groupBlocked = calendarIds.filterTo(HashSet()) { channels[reminderChannelId(it)]?.groupId in blockedGroupIds } + val blocked = if (!appEnabled) { + calendarIds.toSet() + } else { + calendarIds.filterTo(HashSet()) { channels[reminderChannelId(it)]?.blocked == true } + groupBlocked + } + return ReminderChannelStatus(appBlocked = !appEnabled, blockedCalendarIds = blocked, groupBlockedCalendarIds = groupBlocked) +} diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannels.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannels.kt new file mode 100644 index 00000000..3698ee76 --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannels.kt @@ -0,0 +1,208 @@ +package de.jeanlucmakiola.calendula.data.reminders + +import android.app.NotificationChannel +import android.app.NotificationChannelGroup +import android.app.NotificationManager +import android.content.Context +import android.util.Log +import dagger.hilt.android.qualifiers.ApplicationContext +import de.jeanlucmakiola.calendula.R +import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource +import de.jeanlucmakiola.calendula.domain.CalendarSource +import de.jeanlucmakiola.calendula.ui.common.sourceAppLabel +import java.util.Locale +import javax.inject.Inject +import javax.inject.Singleton + +/** + * The reminder notification channels: one per calendar, grouped by account + * (#145), created up front so each calendar can be muted or given its own sound + * in the system settings before it ever fires. + * + * A channel the user has touched keeps their settings; [sync] only creates the + * missing ones, renames changed ones, and deletes those whose calendar is gone. + */ +@Singleton +class ReminderChannels @Inject constructor( + @ApplicationContext private val context: Context, + private val calendarDataSource: CalendarDataSource, +) { + private val manager: NotificationManager + get() = context.getSystemService(NotificationManager::class.java) + + /** What the last [sync] saw, so an unchanged provider costs no channel writes. */ + @Volatile + private var lastSync: Any? = null + + /** + * Bring the channels in line with the provider's calendars. An empty + * snapshot changes nothing: that is a provider hiccup far more often than + * every calendar gone at once. + */ + @Synchronized + fun sync() { + val calendars = calendarDataSource.calendars() + if (calendars.isEmpty()) return + val manager = manager + val existing = manager.notificationChannels + val existingIds = existing.mapTo(HashSet()) { it.id } + if (syncKey(calendars, existingIds) == lastSync && LEGACY_REMINDER_CHANNEL_ID !in existingIds) return + val groups = manager.notificationChannelGroups + val plan = plan(calendars, existing, groups.map { it.id }) + plan.staleChannelIds.forEach(manager::deleteNotificationChannel) + plan.staleGroupIds.forEach(manager::deleteNotificationChannelGroup) + val groupNames = groups.associate { it.id to it.name?.toString() } + write( + groups = plan.groupsInUse.filter { groupNames[it.id] != groupLabel(it) }, + channels = plan.channelsToWrite, + existing = existing, + ) + val ids = existingIds - plan.staleChannelIds.toSet() + plan.channelsToWrite.map { it.id } + lastSync = syncKey(calendars, if (retireLegacyChannel()) ids - LEGACY_REMINDER_CHANNEL_ID else ids) + } + + private fun syncKey(calendars: List, channelIds: Set): Any = listOf( + calendars.map { listOf(it.id, it.displayName, it.accountName, it.accountType, it.isLocal, it.syncsEvents) }, + Locale.getDefault(), + channelIds, + ) + + /** + * The channel to post [calendarId]'s reminder on, created first if a sync + * has not got to it yet. Null when the calendar no longer exists. Should the + * calendar lookup fail or come back empty, the channel is still created, + * plainly named and ungrouped, for the next sync to name and file — a + * reminder is never lost to its channel. + */ + @Synchronized + fun channelFor(calendarId: Long): String? { + val id = reminderChannelId(calendarId) + val manager = manager + if (manager.getNotificationChannel(id) != null) return id + val existing = manager.notificationChannels + val calendars = try { + calendarDataSource.calendars() + } catch (e: Exception) { + Log.w(TAG, "Could not look up calendar $calendarId for its channel", e) + emptyList() + } + val fallback = ReminderChannelSpec(id, calendarId, context.getString(R.string.reminder_channel_name), null) + if (calendars.isEmpty()) { + write(emptyList(), listOf(fallback), existing) + return id + } + val plan = plan(calendars, existing, emptyList()) + val spec = plan.channels.firstOrNull { it.calendarId == calendarId } ?: return null + try { + val knownGroups = manager.notificationChannelGroups.mapTo(HashSet()) { it.id } + write( + groups = plan.groups.filter { it.id == spec.groupId && it.id !in knownGroups }, + channels = listOf(spec), + existing = existing, + ) + } catch (e: RuntimeException) { + Log.w(TAG, "Could not file the channel of calendar $calendarId", e) + write(emptyList(), listOf(fallback), existing) + } + return id + } + + /** What the system currently lets through for [calendarIds]' reminders (#145). */ + fun status(calendarIds: Collection): ReminderChannelStatus { + val manager = manager + val appEnabled = manager.areNotificationsEnabled() + val channels = manager.notificationChannels.associate { + it.id to ReminderChannelState(it.importance == NotificationManager.IMPORTANCE_NONE, it.group) + } + val blockedGroups = manager.notificationChannelGroups.filter { it.isBlocked }.mapTo(HashSet()) { it.id } + return reminderChannelStatus(calendarIds, appEnabled, channels, blockedGroups) + } + + private fun plan( + calendars: List, + existing: List, + existingGroupIds: List, + ): ReminderChannelPlan = planReminderChannels( + calendars = calendars, + existing = existing.map { ExistingReminderChannel(it.id, it.name.toString(), it.description, it.group) }, + existingGroupIds = existingGroupIds, + unnamed = context.getString(R.string.calendar_unnamed), + description = context.getString(R.string.reminder_channel_description), + ) + + private fun write( + groups: List, + channels: List, + existing: List, + ) { + val manager = manager + if (groups.isNotEmpty()) { + manager.createNotificationChannelGroups(groups.map { NotificationChannelGroup(it.id, groupLabel(it)) }) + } + if (channels.isEmpty()) return + val byId = existing.associateBy { it.id } + val description = context.getString(R.string.reminder_channel_description) + val template = byId[LEGACY_REMINDER_CHANNEL_ID] + // Importance only applies on creation; an existing channel keeps its own. + manager.createNotificationChannels( + channels.map { spec -> + val current = byId[spec.id] + NotificationChannel( + spec.id, + spec.name, + current?.importance ?: template?.importance ?: NotificationManager.IMPORTANCE_HIGH, + ).apply { + this.description = description + spec.groupId?.let { group = it } + if (current == null && template != null) inheritFrom(template) + } + }, + ) + } + + /** + * Carry the old single channel's sound, vibration, lights and badge over to + * a new per-calendar one (the system resets lock-screen visibility itself), so an upgrade keeps how reminders sounded. + */ + private fun NotificationChannel.inheritFrom(template: NotificationChannel) { + setSound(template.sound, template.audioAttributes) + // The pattern setter also flips vibration on or off, so it goes first. + vibrationPattern = template.vibrationPattern + enableVibration(template.shouldVibrate()) + enableLights(template.shouldShowLights()) + lightColor = template.lightColor + setShowBadge(template.canShowBadge()) + // Only honoured with Do Not Disturb access, so usually left to the user. + setBypassDnd(template.canBypassDnd()) + } + + /** + * Delete the pre-#145 channel once the per-calendar ones carry its settings, + * but not while a reminder posted on it is still on screen — deleting the + * channel would take that notification with it. Returns whether it is gone. + */ + private fun retireLegacyChannel(): Boolean { + val manager = manager + if (manager.getNotificationChannel(LEGACY_REMINDER_CHANNEL_ID) == null) return true + val showing = runCatching { + manager.activeNotifications.any { it.notification.channelId == LEGACY_REMINDER_CHANNEL_ID } + }.getOrElse { e -> + Log.w(TAG, "Could not read active notifications", e) + true + } + if (!showing) manager.deleteNotificationChannel(LEGACY_REMINDER_CHANNEL_ID) + return !showing + } + + private fun groupLabel(group: ReminderChannelGroupSpec): String { + if (group.isLocal) return context.getString(R.string.calendars_local_header) + val name = group.label.ifBlank { context.getString(R.string.calendar_unnamed) } + if (!group.ambiguous) return name + return context.getString(R.string.calendars_account_from_source, name, sourceAppLabel(context, group.accountType)) + } + + private companion object { + const val TAG = "ReminderChannels" + } +} + diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt index 215554b4..f7a4fd46 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt @@ -1,8 +1,6 @@ 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 @@ -29,8 +27,8 @@ import javax.inject.Inject import javax.inject.Singleton /** - * Posts one notification per occurrence on a dedicated channel. Tapping opens - * the event's detail screen. + * Posts one notification per occurrence on its calendar's channel + * ([ReminderChannels], #145). Tapping opens the event's detail screen. * * The tag is the [occurrenceKey], so each reminder for an occurrence replaces * the one before it in place (#463). A different reminder alerts afresh; the @@ -43,6 +41,7 @@ class ReminderNotifier @Inject constructor( private val settingsPrefs: SettingsPrefs, private val calendarPrefs: CalendarPrefs, private val calendarDataSource: CalendarDataSource, + private val channels: ReminderChannels, ) { /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */ @@ -53,19 +52,28 @@ class ReminderNotifier @Inject constructor( } /** - * The single choke point for "this calendar is switched off", covering the - * two paths that reach [post] around the scan's own filter: a snooze armed - * before the switch-off, and a read-only install whose switch lives in - * [CalendarPrefs]. + * The single choke point for "this calendar posts no reminders": switched + * off (also covering a snooze armed before the switch-off, and a read-only + * install whose switch lives in [CalendarPrefs]), or its notifications + * turned off in Calendula's own settings (#272). */ private suspend fun isSilenced(calendarId: Long): Boolean = - calendarId in calendarPrefs.pendingDisabledCalendarIds.first() || + calendarId in settingsPrefs.mutedReminderCalendarIds.first() || + calendarId in calendarPrefs.pendingDisabledCalendarIds.first() || calendarDataSource.isCalendarVisible(calendarId) == false - /** Post [alert], unless its calendar is switched off. */ + /** Post [alert], unless its calendar is silenced or gone. */ suspend fun post(alert: ReminderAlert) { if (isSilenced(alert.calendarId)) return - ensureChannel() + val channelId = try { + channels.channelFor(alert.calendarId) ?: run { + Log.i(TAG, "Dropped the reminder of event ${alert.eventId}: calendar ${alert.calendarId} is gone") + return + } + } catch (e: Exception) { + Log.w(TAG, "No channel for the reminder of event ${alert.eventId}", e) + return + } val title = displayTitle(alert) val is24Hour = settingsPrefs.timeFormat.first() .is24Hour(android.text.format.DateFormat.is24HourFormat(context)) @@ -88,7 +96,7 @@ class ReminderNotifier @Inject constructor( yesterdayLabel = context.getString(R.string.reminder_day_yesterday), ) val text = listOfNotNull(time, alert.location).joinToString(" · ") - val notification = NotificationCompat.Builder(context, CHANNEL_ID) + val notification = NotificationCompat.Builder(context, channelId) .setSmallIcon(R.drawable.ic_notification) .setContentTitle(title) .setContentText(text) @@ -153,7 +161,7 @@ class ReminderNotifier @Inject constructor( private fun cancelLegacy(alert: ReminderAlert) { val manager = NotificationManagerCompat.from(context) manager.activeNotifications - .filter { it.id == NOTIFICATION_ID && it.notification.channelId == CHANNEL_ID } + .filter { it.id == NOTIFICATION_ID && it.notification.channelId == LEGACY_REMINDER_CHANNEL_ID } .filter { !it.notification.extras.containsKey(EXTRA_REMINDER_KEY) } .filter { it.notification.`when` == alert.beginMillis } .filter { it.notification.extras.getCharSequence(NotificationCompat.EXTRA_TITLE)?.toString() == displayTitle(alert) } @@ -181,21 +189,8 @@ class ReminderNotifier @Inject constructor( PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE, ) - /** Channel creation is idempotent; re-running refreshes the localized name. */ - private fun ensureChannel() { - val channel = NotificationChannel( - CHANNEL_ID, - context.getString(R.string.reminder_channel_name), - NotificationManager.IMPORTANCE_HIGH, - ).apply { - description = context.getString(R.string.reminder_channel_description) - } - NotificationManagerCompat.from(context).createNotificationChannel(channel) - } - private companion object { const val TAG = "ReminderNotifier" - const val CHANNEL_ID = "reminders" // One id, distinct tags: the tag (occurrence) already keys the // notification, so a fixed id keeps cancellation/replacement simple. 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 a67c9b6a..f50e2728 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 @@ -43,6 +43,7 @@ class ReminderScanner @Inject constructor( private val source: ReminderInstanceSource, private val calendarDataSource: CalendarDataSource, private val notifier: ReminderNotifier, + private val channels: ReminderChannels, private val snoozes: ReminderSnoozeScheduler, private val alarms: ReminderAlarmScheduler, private val state: ReminderStatePrefs, @@ -85,10 +86,14 @@ class ReminderScanner @Inject constructor( return } + syncChannels() val lookahead = reminderQueryHorizon(LOOKAHEAD_MILLIS, source.longestReminderMinutes()) // Reach into the past too: an all-day "at time of event" encodes to a // negative offset, and a catch-up pass needs the occurrences it missed. + // Calendars muted in-app (#272) plan nothing, so they arm no wake-ups. + val muted = settingsPrefs.mutedReminderCalendarIds.first() val occurrences = source.occurrences(now - PAST_WINDOW_MILLIS, now + lookahead) + .filter { it.calendarId !in muted } val planned = planReminders( instances = occurrences, minutesByEvent = source.reminderMinutes(occurrences.map { it.eventId }) @@ -117,6 +122,19 @@ class ReminderScanner @Inject constructor( alarms.scheduleScan(schedule.nextAlarmMillis) } + /** + * A provider change re-scans, so a calendar added, renamed or removed keeps + * its channel in step here. Skipped while reminders are off, when the + * channels have nothing to do. A failure never costs the reminders. + */ + private fun syncChannels() { + try { + channels.sync() + } catch (e: Exception) { + Log.w(TAG, "Reminder channel sync failed", e) + } + } + private fun hasReadCalendar(): Boolean = context.hasPermission(Manifest.permission.READ_CALENDAR) /** diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/AccountGroups.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/AccountGroups.kt index c92c1ce3..d2a56674 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/AccountGroups.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/AccountGroups.kt @@ -1,5 +1,6 @@ package de.jeanlucmakiola.calendula.ui.common +import android.content.Context import androidx.compose.runtime.Composable import androidx.compose.runtime.remember import androidx.compose.ui.platform.LocalContext @@ -72,11 +73,13 @@ fun accountGroupTitle(group: CalendarAccountGroup): String { @Composable fun sourceAppName(accountType: String): String { val context = LocalContext.current - return remember(accountType) { - val pm = context.packageManager - val packages = sourceAppPackages(context, accountType) - packages.firstNotNullOfOrNull { pkg -> - runCatching { pm.getApplicationLabel(pm.getApplicationInfo(pkg, 0)).toString() }.getOrNull() - } ?: accountType - } + return remember(accountType) { sourceAppLabel(context, accountType) } +} + +/** [sourceAppName] outside composition, e.g. for notification channel groups. */ +fun sourceAppLabel(context: Context, accountType: String): String { + val pm = context.packageManager + return sourceAppPackages(context, accountType).firstNotNullOfOrNull { pkg -> + runCatching { pm.getApplicationLabel(pm.getApplicationInfo(pkg, 0)).toString() }.getOrNull() + } ?: accountType } diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/CalendarReminderSettings.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/CalendarReminderSettings.kt new file mode 100644 index 00000000..ef670cad --- /dev/null +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/CalendarReminderSettings.kt @@ -0,0 +1,292 @@ +package de.jeanlucmakiola.calendula.ui.settings + +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.LifecycleResumeEffect +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import de.jeanlucmakiola.calendula.R +import de.jeanlucmakiola.calendula.domain.CalendarSource +import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip +import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS +import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker +import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle +import de.jeanlucmakiola.calendula.ui.common.groupByAccount +import de.jeanlucmakiola.calendula.ui.common.orUnnamed +import de.jeanlucmakiola.floret.android.openNotificationSettings +import de.jeanlucmakiola.floret.components.CollapsingScaffold +import de.jeanlucmakiola.floret.components.ExpandIcon +import de.jeanlucmakiola.floret.components.GroupedHint +import de.jeanlucmakiola.floret.components.GroupedRow +import de.jeanlucmakiola.floret.components.GroupedSectionHeader +import de.jeanlucmakiola.floret.components.GroupedSwitchRow +import de.jeanlucmakiola.floret.components.Position +import de.jeanlucmakiola.floret.components.positionOf +import de.jeanlucmakiola.floret.identity.collapseExit +import de.jeanlucmakiola.floret.identity.expandEnter +import de.jeanlucmakiola.floret.reminders.ReminderOverride +import de.jeanlucmakiola.floret.reminders.reminderOverrideFor +import kotlinx.coroutines.launch + +/** + * Per-calendar notifications and reminder overrides (#145, #272), reached from + * Settings → Notifications. Calendars are listed by account as connected groups; + * a calendar unfolds its options in place, one tone darker, inside its group. + */ +@Composable +internal fun CalendarRemindersScreen( + state: SettingsUiState, + viewModel: SettingsViewModel, + onBack: () -> Unit, + onOpenSpecialDates: () -> Unit, + visible: Boolean = true, +) { + val context = LocalContext.current + val scope = rememberCoroutineScope() + var expandedCalendars by rememberSaveable { mutableStateOf(emptyList()) } + var overrideDialog by remember { mutableStateOf(null) } + val channelStatus by viewModel.channelStatus.collectAsStateWithLifecycle() + val calendarIds = state.reminderCalendars.map { it.id } + LifecycleResumeEffect(calendarIds) { + viewModel.refreshChannelStatus(calendarIds) + onPauseOrDispose { } + } + + CollapsingScaffold( + title = stringResource(R.string.settings_calendar_reminders_title), + onBack = onBack, + predictiveBack = true, + visible = visible, + ) { + GroupedHint(stringResource(R.string.settings_calendar_reminders_hint), style = MaterialTheme.typography.bodySmall) + state.reminderCalendars.groupByAccount().forEachIndexed { groupIndex, group -> + if (groupIndex > 0) Spacer(Modifier.height(8.dp)) + GroupedSectionHeader(accountGroupTitle(group)) + val calendars = group.calendars + calendars.forEachIndexed { index, calendar -> + val expanded = calendar.id in expandedCalendars + val notifying = calendar.id !in state.mutedReminderCalendarIds + CalendarReminderEntry( + calendar = calendar, + state = state, + position = positionOf(index, calendars.size), + expanded = expanded, + notifying = notifying, + blocked = notifying && calendar.id in channelStatus.blockedCalendarIds, + onToggleExpand = { + expandedCalendars = if (expanded) { + expandedCalendars - calendar.id + } else { + expandedCalendars + calendar.id + } + }, + onSetNotifying = { viewModel.setCalendarRemindersEnabled(calendar.id, it) }, + onOpenSound = { + scope.launch { + context.openNotificationSettings(viewModel.soundSettingsChannel(calendar.id)) + } + }, + onOpenSpecialDates = onOpenSpecialDates, + onEditOverride = { overrideDialog = it }, + ) + } + } + } + + overrideDialog?.let { target -> + val map = if (target.isAllDay) { + state.perCalendarAllDayReminderOverride + } else { + state.perCalendarReminderOverride + } + ReminderDefaultPicker( + title = stringResource( + if (target.isAllDay) { + R.string.settings_default_reminder_allday + } else { + R.string.settings_default_reminder + }, + ), + presets = if (target.isAllDay) ALLDAY_REMINDER_PRESETS else REMINDER_PRESETS, + selected = map.reminderOverrideFor(target.calendarId), + allowInherit = true, + onSelect = { + if (target.isAllDay) { + viewModel.setCalendarAllDayReminderOverride(target.calendarId, it) + } else { + viewModel.setCalendarReminderOverride(target.calendarId, it) + } + }, + onDismiss = { overrideDialog = null }, + leadTimeSummary = if (target.isAllDay) { + allDayFiringTimeSummary(state.allDayReminderTimeMinutes) + } else { + null + }, + ) + } +} + +/** + * One calendar in its account group, with its options unfolding beneath it: + * the notification switch and channel deep-link for every calendar, then the + * default-reminder overrides where it takes them — or, for a special-dates + * calendar, a link to the section that owns them. + */ +@Composable +private fun CalendarReminderEntry( + calendar: CalendarSource, + state: SettingsUiState, + position: Position, + expanded: Boolean, + notifying: Boolean, + blocked: Boolean, + onToggleExpand: () -> Unit, + onSetNotifying: (Boolean) -> Unit, + onOpenSound: () -> Unit, + onOpenSpecialDates: () -> Unit, + onEditOverride: (OverrideTarget) -> Unit, +) { + val opensGroup = position == Position.Top || position == Position.Alone + val closesGroup = position == Position.Bottom || position == Position.Alone + GroupedRow( + title = calendar.displayName.orUnnamed(), + summary = when { + !notifying -> stringResource(R.string.settings_calendar_notifications_off) + blocked -> stringResource(R.string.settings_notifications_blocked) + else -> null + }, + position = when { + !expanded -> position + opensGroup -> Position.Top + else -> Position.Middle + }, + leading = { CalendarColorChip(calendar.color) }, + trailing = { ExpandIcon(expanded) }, + onClick = onToggleExpand, + ) + AnimatedVisibility( + visible = expanded, + enter = expandEnter(), + exit = collapseExit(), + ) { + val managed = calendar.id in state.managedCalendarIds + val takesOverrides = calendar.canModifyContents && !managed + val nested = MaterialTheme.colorScheme.surfaceContainerHighest + // The options round off their calendar; mid-group they keep the row gap. + Column(if (closesGroup) Modifier else Modifier.padding(bottom = 2.dp)) { + GroupedSwitchRow( + title = stringResource(R.string.settings_calendar_notifications), + checked = notifying, + onCheckedChange = onSetNotifying, + summary = stringResource(R.string.settings_calendar_notifications_hint), + position = Position.Middle, + container = nested, + ) + GroupedRow( + title = stringResource(R.string.settings_notification_sound), + summary = if (blocked) { + stringResource(R.string.settings_notifications_blocked_hint) + } else { + stringResource(R.string.settings_calendar_notification_sound_hint) + }, + position = if (managed || takesOverrides) Position.Middle else Position.Bottom, + container = nested, + trailing = { ExternalLinkIcon() }, + onClick = onOpenSound, + ) + if (managed) { + GroupedRow( + title = stringResource(R.string.settings_default_reminder_allday), + summary = stringResource(R.string.settings_calendar_reminders_managed_hint), + position = Position.Bottom, + container = nested, + trailing = { ChevronIcon() }, + onClick = onOpenSpecialDates, + ) + } else if (takesOverrides) { + OverrideRow( + calendarId = calendar.id, + isAllDay = false, + choice = state.perCalendarReminderOverride.reminderOverrideFor(calendar.id), + globalDefault = state.defaultReminderMinutes, + position = Position.Middle, + container = nested, + onEditOverride = onEditOverride, + ) + OverrideRow( + calendarId = calendar.id, + isAllDay = true, + choice = state.perCalendarAllDayReminderOverride.reminderOverrideFor(calendar.id), + globalDefault = state.defaultAllDayReminderMinutes, + position = Position.Bottom, + container = nested, + onEditOverride = onEditOverride, + ) + } + } + } +} + +@Composable +private fun OverrideRow( + calendarId: Long, + isAllDay: Boolean, + choice: ReminderOverride, + globalDefault: List, + position: Position, + container: Color, + onEditOverride: (OverrideTarget) -> Unit, +) { + GroupedRow( + title = stringResource( + if (isAllDay) R.string.settings_default_reminder_allday else R.string.settings_default_reminder, + ), + summary = calendarOverrideSummary(choice, globalDefault), + position = position, + container = container, + onClick = { onEditOverride(OverrideTarget(calendarId, isAllDay)) }, + ) +} + +@Composable +private fun ChevronIcon() { + Icon( + imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) +} + +/** Which calendar + event kind a per-calendar reminder-override dialog targets. */ +private data class OverrideTarget(val calendarId: Long, val isAllDay: Boolean) + +/** Row summary for a calendar: its override, or the inherited global default. */ +@Composable +private fun calendarOverrideSummary( + choice: ReminderOverride, + globalDefault: List, +): String = when (choice) { + ReminderOverride.Inherit -> + stringResource(R.string.settings_calendar_reminder_inherits, reminderChoiceLabel(globalDefault)) + ReminderOverride.None -> stringResource(R.string.reminder_none) + is ReminderOverride.Minutes -> reminderChoiceLabel(choice.minutes) +} 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 b6fd7b28..b90b06c9 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 @@ -8,20 +8,27 @@ import android.os.PowerManager import android.provider.Settings import androidx.activity.compose.rememberLauncherForActivityResult import androidx.activity.result.contract.ActivityResultContracts -import androidx.compose.animation.AnimatedVisibility -import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Arrangement +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.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight +import androidx.compose.material.icons.automirrored.filled.OpenInNew +import androidx.compose.material.icons.outlined.Info import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.res.stringResource @@ -29,27 +36,26 @@ import androidx.compose.ui.unit.dp import androidx.core.net.toUri import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleEventObserver +import androidx.lifecycle.compose.LifecycleResumeEffect import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.collectAsStateWithLifecycle import de.jeanlucmakiola.calendula.R -import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip import de.jeanlucmakiola.calendula.ui.common.DurationPicker import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert import de.jeanlucmakiola.calendula.ui.common.durationLabel -import de.jeanlucmakiola.calendula.ui.common.orUnnamed import de.jeanlucmakiola.floret.android.hasPermission +import de.jeanlucmakiola.floret.android.openNotificationSettings import de.jeanlucmakiola.floret.components.CollapsingScaffold -import de.jeanlucmakiola.floret.components.ExpandIcon import de.jeanlucmakiola.floret.components.GroupedRow import de.jeanlucmakiola.floret.components.GroupedSwitchRow +import de.jeanlucmakiola.floret.components.IconInfoCard import de.jeanlucmakiola.floret.components.Position import de.jeanlucmakiola.floret.components.SelectedCheck -import de.jeanlucmakiola.floret.identity.collapseExit -import de.jeanlucmakiola.floret.identity.expandEnter import de.jeanlucmakiola.floret.reminders.ReminderOverride import de.jeanlucmakiola.floret.reminders.minutesOrEmpty -import de.jeanlucmakiola.floret.reminders.reminderOverrideFor +import kotlinx.coroutines.launch import kotlinx.datetime.LocalTime /** @@ -62,7 +68,7 @@ internal fun NotificationsScreen( state: SettingsUiState, viewModel: SettingsViewModel, onBack: () -> Unit, - onOpenSpecialDates: () -> Unit, + onOpenCalendarReminders: () -> Unit, visible: Boolean = true, ) { val context = LocalContext.current @@ -83,9 +89,13 @@ internal fun NotificationsScreen( var showAllDayReminder by remember { mutableStateOf(false) } var showAllDayReminderTime by remember { mutableStateOf(false) } var showSnooze by remember { mutableStateOf(false) } - var overrideDialog by remember { mutableStateOf(null) } - var calendarSectionExpanded by remember { mutableStateOf(false) } - var expandedCalendars by remember { mutableStateOf(emptySet()) } + val scope = rememberCoroutineScope() + val channelStatus by viewModel.channelStatus.collectAsStateWithLifecycle() + val calendarIds = state.reminderCalendars.map { it.id } + LifecycleResumeEffect(calendarIds) { + viewModel.refreshChannelStatus(calendarIds) + onPauseOrDispose { } + } CollapsingScaffold( title = stringResource(R.string.settings_section_notifications), @@ -93,6 +103,19 @@ internal fun NotificationsScreen( predictiveBack = true, visible = visible, ) { + if (IS_SAMSUNG && !state.notificationCategoryHintDismissed) { + NotificationCategoryHint( + onOpen = { + viewModel.dismissNotificationCategoryHint() + scope.launch { + viewModel.syncReminderChannels() + context.openNotificationSettings() + } + }, + onDismiss = viewModel::dismissNotificationCategoryHint, + ) + Spacer(Modifier.height(16.dp)) + } GroupedSwitchRow( title = stringResource(R.string.settings_reminders), checked = state.remindersEnabled, @@ -100,6 +123,22 @@ internal fun NotificationsScreen( summary = stringResource(R.string.settings_reminders_hint), position = Position.Top, ) + GroupedRow( + title = stringResource(R.string.settings_notification_sound), + summary = if (channelStatus.appBlocked) { + stringResource(R.string.settings_notifications_blocked_hint) + } else { + stringResource(R.string.settings_notification_sound_hint) + }, + position = Position.Middle, + trailing = { ExternalLinkIcon() }, + onClick = { + scope.launch { + viewModel.syncReminderChannels() + context.openNotificationSettings() + } + }, + ) GroupedRow( title = stringResource(R.string.settings_default_reminder), summary = reminderChoiceLabel(state.defaultReminderMinutes), @@ -149,84 +188,21 @@ internal fun NotificationsScreen( onClick = { showSnooze = true }, ) - // Per-calendar overrides, folded behind one header. Each writable - // calendar may keep, drop or replace the global default, separately for - // timed and all-day events. - if (state.writableCalendars.isNotEmpty()) { + if (state.reminderCalendars.isNotEmpty()) { Spacer(Modifier.height(24.dp)) GroupedRow( title = stringResource(R.string.settings_calendar_reminders_title), - summary = stringResource(R.string.settings_calendar_reminders_hint), + summary = stringResource(R.string.settings_calendar_reminders_subtitle), position = Position.Alone, - trailing = { ExpandIcon(calendarSectionExpanded) }, - onClick = { calendarSectionExpanded = !calendarSectionExpanded }, + trailing = { + Icon( + imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + }, + onClick = onOpenCalendarReminders, ) - AnimatedVisibility( - visible = calendarSectionExpanded, - enter = expandEnter(), - exit = collapseExit(), - ) { - Column { - state.writableCalendars.forEach { calendar -> - Spacer(Modifier.height(16.dp)) - // Special-dates calendars own their reminders in their - // own section — link there instead. - if (calendar.id in state.managedCalendarIds) { - GroupedRow( - title = calendar.displayName.orUnnamed(), - summary = stringResource(R.string.settings_calendar_reminders_managed_hint), - position = Position.Alone, - leading = { CalendarColorChip(calendar.color) }, - trailing = { - Icon( - imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight, - contentDescription = null, - tint = MaterialTheme.colorScheme.onSurfaceVariant, - ) - }, - onClick = onOpenSpecialDates, - ) - return@forEach - } - val expanded = calendar.id in expandedCalendars - GroupedRow( - title = calendar.displayName.orUnnamed(), - position = if (expanded) Position.Top else Position.Alone, - leading = { CalendarColorChip(calendar.color) }, - trailing = { ExpandIcon(expanded) }, - onClick = { - expandedCalendars = if (expanded) { - expandedCalendars - calendar.id - } else { - expandedCalendars + calendar.id - } - }, - ) - AnimatedVisibility( - visible = expanded, - enter = expandEnter(), - exit = collapseExit(), - ) { - Column { - val timed = state.perCalendarReminderOverride.reminderOverrideFor(calendar.id) - GroupedRow( - title = stringResource(R.string.settings_default_reminder), - summary = calendarOverrideSummary(timed, state.defaultReminderMinutes), - position = Position.Middle, - onClick = { overrideDialog = OverrideTarget(calendar.id, isAllDay = false) }, - ) - val allDay = state.perCalendarAllDayReminderOverride.reminderOverrideFor(calendar.id) - GroupedRow( - title = stringResource(R.string.settings_default_reminder_allday), - summary = calendarOverrideSummary(allDay, state.defaultAllDayReminderMinutes), - position = Position.Bottom, - onClick = { overrideDialog = OverrideTarget(calendar.id, isAllDay = true) }, - ) - } - } - } - } - } } } @@ -275,59 +251,43 @@ internal fun NotificationsScreen( onDismiss = { showAllDayReminderTime = false }, ) } - overrideDialog?.let { target -> - val map = if (target.isAllDay) { - state.perCalendarAllDayReminderOverride - } else { - state.perCalendarReminderOverride - } - ReminderDefaultPicker( - title = stringResource( - if (target.isAllDay) { - R.string.settings_default_reminder_allday - } else { - R.string.settings_default_reminder - }, - ), - presets = if (target.isAllDay) ALLDAY_REMINDER_PRESETS else REMINDER_PRESETS, - selected = map.reminderOverrideFor(target.calendarId), - allowInherit = true, - onSelect = { - if (target.isAllDay) { - viewModel.setCalendarAllDayReminderOverride(target.calendarId, it) - } else { - viewModel.setCalendarReminderOverride(target.calendarId, it) - } - }, - onDismiss = { overrideDialog = null }, - leadTimeSummary = if (target.isAllDay) { - allDayFiringTimeSummary(state.allDayReminderTimeMinutes) - } else { - null - }, +} + +/** Samsung's One UI can start a new notification category switched off (#145). */ +private val IS_SAMSUNG = Build.MANUFACTURER.equals("samsung", ignoreCase = true) + +/** The one-time Samsung note, with a way into the app's notification settings. */ +@Composable +private fun NotificationCategoryHint(onOpen: () -> Unit, onDismiss: () -> Unit) { + IconInfoCard( + icon = Icons.Outlined.Info, + iconContentDescription = null, + iconAlignment = Alignment.Top, + ) { + Text( + text = stringResource(R.string.settings_notification_category_hint), + style = MaterialTheme.typography.bodyMedium, ) + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End) { + TextButton(onClick = onDismiss) { Text(stringResource(R.string.reminder_action_dismiss)) } + TextButton(onClick = onOpen) { Text(stringResource(R.string.settings_notification_category_hint_open)) } + } } } -/** Which calendar + event kind a per-calendar reminder-override dialog targets. */ -private data class OverrideTarget(val calendarId: Long, val isAllDay: Boolean) +@Composable +internal fun ExternalLinkIcon() { + Icon( + imageVector = Icons.AutoMirrored.Filled.OpenInNew, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) +} /** A global default (empty = none) as a picker choice for selection highlighting. */ private fun List.toReminderChoice(): ReminderOverride = if (isEmpty()) ReminderOverride.None else ReminderOverride.Minutes(this) -/** Row summary for a calendar: its override, or the inherited global default. */ -@Composable -private fun calendarOverrideSummary( - choice: ReminderOverride, - globalDefault: List, -): String = when (choice) { - ReminderOverride.Inherit -> - stringResource(R.string.settings_calendar_reminder_inherits, reminderChoiceLabel(globalDefault)) - ReminderOverride.None -> stringResource(R.string.reminder_none) - is ReminderOverride.Minutes -> reminderChoiceLabel(choice.minutes) -} - /** Snooze delays offered for the notification "Snooze" action, in minutes. */ private val SNOOZE_PRESETS = listOf(5, 10, 15, 30, 60) diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt index 3bab7449..e3ba551c 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt @@ -73,7 +73,7 @@ import de.jeanlucmakiola.floret.identity.predictiveBackExit /** The settings sub-screens reached from the hub's category rows. */ private enum class SettingsSection { - Appearance, Views, EventForm, Notifications, SpecialDates, Widgets, Licences + Appearance, Views, EventForm, Notifications, CalendarReminders, SpecialDates, Widgets, Licences } /** @@ -131,8 +131,9 @@ fun SettingsScreen( ) { EventFormScreen(state = state, viewModel = viewModel, onBack = { section = null }, visible = section == SettingsSection.EventForm) } + // Stays up beneath its per-calendar subpage, so backing out reveals it. AnimatedVisibility( - visible = section == SettingsSection.Notifications, + visible = section == SettingsSection.Notifications || section == SettingsSection.CalendarReminders, enter = slideInHorizontally(slideSpec) { it } + fadeIn(), exit = overlayExit, ) { @@ -140,10 +141,23 @@ fun SettingsScreen( state = state, viewModel = viewModel, onBack = { section = null }, - onOpenSpecialDates = { section = SettingsSection.SpecialDates }, + onOpenCalendarReminders = { section = SettingsSection.CalendarReminders }, visible = section == SettingsSection.Notifications, ) } + AnimatedVisibility( + visible = section == SettingsSection.CalendarReminders, + enter = slideInHorizontally(slideSpec) { it } + fadeIn(), + exit = overlayExit, + ) { + CalendarRemindersScreen( + state = state, + viewModel = viewModel, + onBack = { section = SettingsSection.Notifications }, + onOpenSpecialDates = { section = SettingsSection.SpecialDates }, + visible = section == SettingsSection.CalendarReminders, + ) + } AnimatedVisibility( visible = section == SettingsSection.SpecialDates, enter = slideInHorizontally(slideSpec) { it } + fadeIn(), diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt index d97e7a00..34e603b3 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt @@ -96,8 +96,14 @@ data class SettingsUiState( val perCalendarReminderOverride: Map> = emptyMap(), /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */ val perCalendarAllDayReminderOverride: Map> = emptyMap(), - /** Writable calendars, shown as per-calendar reminder-override rows. */ + /** Switched-on calendars you can edit: the per-calendar event-duration rows. */ val writableCalendars: List = emptyList(), + /** Switched-on calendars, each with its own notification switch and channel (#145, #272). */ + val reminderCalendars: List = emptyList(), + /** Calendars whose reminders Calendula doesn't post (#272). */ + val mutedReminderCalendarIds: Set = emptySet(), + /** Whether the Samsung notification-category hint has been dismissed (#145); hidden until prefs load. */ + val notificationCategoryHintDismissed: Boolean = true, /** * Whether the event-colour picker is offered on calendars that publish no * colour palette (the colour may then not survive their next sync). diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt index 812910d8..21ff880b 100644 --- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt +++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt @@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.settings import android.content.Context import android.net.Uri import android.os.Build +import android.util.Log import androidx.datastore.preferences.core.Preferences import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope @@ -20,6 +21,7 @@ import de.jeanlucmakiola.floret.android.stateWhileSubscribed import de.jeanlucmakiola.floret.di.IoDispatcher import de.jeanlucmakiola.floret.reminders.ReminderOverride import de.jeanlucmakiola.floret.reminders.reminderOverrideFor +import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay import de.jeanlucmakiola.calendula.data.prefs.SettingsKeys import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs @@ -33,6 +35,8 @@ import de.jeanlucmakiola.calendula.data.prefs.SpecialDatesStalledReason import de.jeanlucmakiola.floret.prefs.ThemeMode import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref +import de.jeanlucmakiola.calendula.data.reminders.ReminderChannelStatus +import de.jeanlucmakiola.calendula.data.reminders.ReminderChannels import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner import de.jeanlucmakiola.calendula.domain.CalendarSource import de.jeanlucmakiola.calendula.domain.EventFormField @@ -45,7 +49,9 @@ import de.jeanlucmakiola.calendula.ui.common.TimelineScale import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle import de.jeanlucmakiola.calendula.ui.theme.AppFontSettings import de.jeanlucmakiola.calendula.ui.theme.FONT_CUSTOM_TOKEN +import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CoroutineDispatcher +import kotlinx.coroutines.Job import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableStateFlow @@ -62,11 +68,13 @@ import javax.inject.Inject @HiltViewModel class SettingsViewModel @Inject constructor( private val prefs: SettingsPrefs, + calendarPrefs: CalendarPrefs, repository: CalendarRepository, private val specialDatesEngine: SpecialDatesSyncEngine, specialDatesSpec: SpecialDatesCalendarSpec, private val launcherNameManager: LauncherNameManager, private val reminderScanner: ReminderScanner, + private val reminderChannels: ReminderChannels, @IoDispatcher private val io: CoroutineDispatcher, @ApplicationContext private val appContext: Context, ) : ViewModel() { @@ -74,16 +82,16 @@ class SettingsViewModel @Inject constructor( private val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S /** - * Writable calendars that are switched on — the only ones that take a - * per-calendar reminder override, since a switched-off one plans no - * reminders at all (#75). + * Calendars that are switched on — the only ones that plan reminders at + * all (#75), so the only ones with notification settings. */ - private val writableCalendars: Flow> = repository.calendars() - .map { calendars -> calendars.filter { it.canModifyContents && it.isVisibleInSystem } } - .catch { emit(emptyList()) } + private val visibleCalendars: Flow> = + combine(repository.calendars(), calendarPrefs.pendingDisabledCalendarIds) { calendars, pending -> + calendars.filter { it.isVisibleInSystem && it.id !in pending } + }.catch { emit(emptyList()) } val state: StateFlow = - combine(prefs.data, writableCalendars) { stored, calendars -> stored.toUiState(calendars) } + combine(prefs.data, visibleCalendars) { stored, calendars -> stored.toUiState(calendars) } .stateWhileSubscribed( scope = viewModelScope, initialValue = SettingsUiState(dynamicColorAvailable = dynamicColorAvailable), @@ -125,7 +133,10 @@ class SettingsViewModel @Inject constructor( snoozeMinutes = this[SettingsKeys.snoozeMinutes], perCalendarReminderOverride = this[SettingsKeys.perCalendarReminderOverride], perCalendarAllDayReminderOverride = this[SettingsKeys.perCalendarAllDayReminderOverride], - writableCalendars = calendars, + writableCalendars = calendars.filter { it.canModifyContents }, + reminderCalendars = calendars, + mutedReminderCalendarIds = this[SettingsKeys.mutedReminderCalendarIds], + notificationCategoryHintDismissed = this[SettingsKeys.notificationCategoryHintDismissed], allowColorOnUnsupportedCalendars = this[SettingsKeys.allowColorOnUnsupportedCalendars], managedCalendarIds = specialDatesCalendars.values.toSet(), ) @@ -357,6 +368,62 @@ class SettingsViewModel @Inject constructor( } } + /** + * Re-plans, since a muted calendar armed no wake-up for its next reminder. + * Unmuting scans once more before the write, so the watermark starts at the + * unmute and nothing that came due while muted is replayed. + */ + fun setCalendarRemindersEnabled(calendarId: Long, enabled: Boolean) { + viewModelScope.launch { + if (enabled) reminderScanner.scan() + prefs.setCalendarRemindersEnabled(calendarId, enabled) + reminderScanner.scan() + } + } + + private val _channelStatus = MutableStateFlow(ReminderChannelStatus()) + + /** What the system blocks of the reminders; re-read with [refreshChannelStatus] (#145). */ + val channelStatus: StateFlow = _channelStatus.asStateFlow() + + private var channelStatusJob: Job? = null + + fun refreshChannelStatus(calendarIds: Collection) { + channelStatusJob?.cancel() + channelStatusJob = viewModelScope.launch { + onChannels { status(calendarIds) }?.let { _channelStatus.value = it } + } + } + + fun dismissNotificationCategoryHint() = save { dismissNotificationCategoryHint() } + + /** + * The channel whose system screen to open for [calendarId] (#340), created + * if needed; null when only the app's own screen can help — the app or the + * calendar's account group is blocked there, or the channel couldn't be made. + */ + suspend fun soundSettingsChannel(calendarId: Long): String? = onChannels { + val channelId = channelFor(calendarId) ?: return@onChannels null + val status = status(listOf(calendarId)) + channelId.takeUnless { status.appBlocked || calendarId in status.groupBlockedCalendarIds } + } + + /** Create the per-calendar channels before showing the app's channel list, even with reminders off. */ + suspend fun syncReminderChannels() { + onChannels { sync() } + } + + private suspend fun onChannels(block: ReminderChannels.() -> T): T? = withContext(io) { + try { + reminderChannels.block() + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("SettingsViewModel", "Reminder channel update failed", e) + null + } + } + fun setAutofocusEventTitle(enabled: Boolean) = save { setAutofocusEventTitle(enabled) } fun setDefaultEventDuration(minutes: Int) = save { setDefaultEventDurationMinutes(minutes) } diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 278cc7ca..8d182bf1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -731,7 +731,18 @@ Amount Set Per-calendar reminders - Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own. + Notifications, sound and default reminders per calendar + Turn notifications off or pick a sound per calendar, and override the default reminder for calendars you can edit. + Notifications + Notify at this calendar\'s reminder times + Notifications off + Notification sound + Sound, vibration and pop-ups for each calendar, in system settings + Blocked in system settings + Blocked in system settings — tap to allow + On Samsung phones, new notification categories can start switched off. If a calendar\'s reminders don\'t arrive, check that its category is on. + Open settings + Sound, vibration and pop-ups for this calendar, in system settings Default (%1$s) Reliable delivery Android may delay reminders to save battery. Exempt Calendula so they arrive on time. 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 d2fb8e65..1e113689 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 @@ -601,6 +601,19 @@ class SettingsPrefsTest { assertThat(prefs.perCalendarEventDuration.first()).containsExactly(9L, 30) } + @Test + fun `calendar notifications default on and toggle per calendar`( + @TempDir tempDir: Path, + ) = runTest { + val prefs = testSettings(tempDir) + assertThat(prefs.mutedReminderCalendarIds.first()).isEmpty() + prefs.setCalendarRemindersEnabled(7L, false) + prefs.setCalendarRemindersEnabled(9L, false) + assertThat(prefs.mutedReminderCalendarIds.first()).containsExactly(7L, 9L) + prefs.setCalendarRemindersEnabled(7L, true) + assertThat(prefs.mutedReminderCalendarIds.first()).containsExactly(9L) + } + @Test fun `garbage per-calendar duration entries are dropped, the rest survive`( @TempDir tempDir: Path, diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlanTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlanTest.kt new file mode 100644 index 00000000..4634644b --- /dev/null +++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderChannelPlanTest.kt @@ -0,0 +1,151 @@ +package de.jeanlucmakiola.calendula.data.reminders + +import com.google.common.truth.Truth.assertThat +import de.jeanlucmakiola.calendula.domain.CalendarSource +import org.junit.jupiter.api.Test + +class ReminderChannelPlanTest { + + private fun calendar(id: Long, account: String, type: String, local: Boolean = false) = CalendarSource( + id = id, + displayName = "Cal $id", + accountName = account, + accountType = type, + color = 0, + isVisibleInSystem = true, + isLocal = local, + ) + + @Test + fun `one channel per calendar, grouped by account`() { + val plan = planReminderChannels( + calendars = listOf( + calendar(1, "me@example.org", "com.google"), + calendar(2, "me@example.org", "com.google"), + calendar(3, "dav", "bitfire.at.davdroid"), + ), + existing = emptyList(), + existingGroupIds = emptyList(), + unnamed = "Unnamed", + description = DESC, + ) + assertThat(plan.groups).hasSize(2) + assertThat(plan.channels.map { it.id }) + .containsExactly(reminderChannelId(1), reminderChannelId(2), reminderChannelId(3)) + assertThat(plan.channels[0].groupId).isEqualTo(plan.channels[1].groupId) + assertThat(plan.channels[2].groupId).isNotEqualTo(plan.channels[0].groupId) + assertThat(plan.staleChannelIds).isEmpty() + } + + @Test + fun `device calendars share one group`() { + val plan = planReminderChannels( + calendars = listOf( + calendar(1, "Calendula", "LOCAL", local = true), + calendar(2, "Other", "LOCAL", local = true), + ), + existing = emptyList(), + existingGroupIds = emptyList(), + unnamed = "Unnamed", + description = DESC, + ) + assertThat(plan.groups).hasSize(1) + assertThat(plan.groups.single().isLocal).isTrue() + } + + @Test + fun `same account name under two types is ambiguous`() { + val plan = planReminderChannels( + calendars = listOf( + calendar(1, "me@example.org", "com.google"), + calendar(2, "me@example.org", "bitfire.at.davdroid"), + calendar(3, "work", "bitfire.at.davdroid"), + ), + existing = emptyList(), + existingGroupIds = emptyList(), + unnamed = "Unnamed", + description = DESC, + ) + assertThat(plan.groups.filter { it.ambiguous }.map { it.accountType }) + .containsExactly("com.google", "bitfire.at.davdroid") + assertThat(plan.groups.single { it.label == "work" }.ambiguous).isFalse() + } + + @Test + fun `stale reminder channels and groups go, foreign ones stay`() { + val current = calendar(1, "me@example.org", "com.google") + fun plan(calendars: List, existing: List = emptyList(), groups: List = emptyList()) = + planReminderChannels(calendars, existing.map { ExistingReminderChannel(it, "Cal ${it.last()}", DESC, null) }, groups, "Unnamed", DESC) + val keptGroup = plan(listOf(current)).groups.single().id + val goneGroup = plan(listOf(calendar(9, "old", "com.google"))).groups.single().id + val result = plan( + calendars = listOf(current), + existing = listOf(reminderChannelId(1), reminderChannelId(9), LEGACY_REMINDER_CHANNEL_ID, "backup"), + groups = listOf(keptGroup, goneGroup, "other"), + ) + assertThat(result.staleChannelIds).containsExactly(reminderChannelId(9)) + assertThat(result.staleGroupIds).containsExactly(goneGroup) + } + + @Test + fun `only missing or renamed channels are written`() { + val plan = planReminderChannels( + calendars = listOf( + calendar(1, "a", "com.google"), + calendar(2, "a", "com.google"), + calendar(3, "a", "com.google").copy(displayName = ""), + calendar(4, "a", "com.google"), + ), + existing = listOf( + ExistingReminderChannel(reminderChannelId(1), "Cal 1", DESC, "g"), + ExistingReminderChannel(reminderChannelId(4), "Cal 4", "Old description", "g"), + ExistingReminderChannel(reminderChannelId(2), "Old name", DESC, "g"), + ), + existingGroupIds = emptyList(), + unnamed = "Unnamed", + description = DESC, + ) + assertThat(plan.channelsToWrite.map { it.calendarId }).containsExactly(2L, 3L, 4L) + assertThat(plan.channelsToWrite.single { it.calendarId == 3L }.name).isEqualTo("Unnamed") + } + + @Test + fun `non-syncing calendars keep a channel but get none up front`() { + val quiet = calendar(2, "a", "com.google").copy(syncsEvents = false) + val fresh = planReminderChannels(listOf(quiet), emptyList(), emptyList(), "Unnamed", DESC) + assertThat(fresh.channelsToWrite).isEmpty() + assertThat(fresh.groupsInUse).isEmpty() + val posted = planReminderChannels( + calendars = listOf(quiet), + existing = listOf(ExistingReminderChannel(reminderChannelId(2), "Cal 2", DESC, null)), + existingGroupIds = emptyList(), + unnamed = "Unnamed", + description = DESC, + ) + assertThat(posted.staleChannelIds).isEmpty() + assertThat(posted.channelsToWrite.map { it.calendarId }).containsExactly(2L) + assertThat(posted.groupsInUse).hasSize(1) + } + + @Test + fun `blocked calendars follow app, channel and group`() { + val channels = mapOf( + reminderChannelId(1) to ReminderChannelState(blocked = true, groupId = "g1"), + reminderChannelId(2) to ReminderChannelState(blocked = false, groupId = "g2"), + reminderChannelId(3) to ReminderChannelState(blocked = false, groupId = "g1"), + ) + val ids = listOf(1L, 2L, 3L, 4L) + val groupOff = reminderChannelStatus(ids, appEnabled = true, channels, blockedGroupIds = setOf("g2")) + assertThat(groupOff.blockedCalendarIds).containsExactly(1L, 2L) + assertThat(groupOff.groupBlockedCalendarIds).containsExactly(2L) + assertThat(reminderChannelStatus(ids, appEnabled = true, channels, blockedGroupIds = emptySet()).blockedCalendarIds) + .containsExactly(1L) + val appOff = reminderChannelStatus(ids, appEnabled = false, channels, blockedGroupIds = emptySet()) + assertThat(appOff.appBlocked).isTrue() + assertThat(appOff.blockedCalendarIds).containsExactly(1L, 2L, 3L, 4L) + } + + private companion object { + const val DESC = "Reminders" + } +} diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 771d9bd7..8f0a77ba 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -391,6 +391,26 @@ gate also covers a snooze re-shown from our own alarm after its calendar was switched off. The drawer's filter sheet (`CalendarPrefs.hiddenCalendarIds`) is a separate in-app declutter that never touches reminders. +**A channel per calendar (#145).** `ReminderChannels` keeps one notification +channel per calendar, grouped by account (one that syncs no events only gets +its channel once something posts on it), so a calendar can be +muted or given its own sound in the system settings before it ever fires. Every +scan with reminders on syncs them (skipped when nothing changed): missing +channels are created, renamed ones updated, and channels of deleted calendars +removed — but never on an empty snapshot, which is a provider hiccup more often +than every calendar gone. Switched-off calendars keep theirs, so toggling one +never cancels a showing reminder or loses its settings. `post` creates a missing +channel itself, so a reminder never waits on a sync. A new channel copies the sound, vibration and +importance of the pre-#145 single `reminders` channel, which is deleted once +nothing showing still sits on it. Settings → Notifications only deep-links into +the system's channel screens (#340); the app never sets a sound itself. Separate +from both, `SettingsPrefs.mutedReminderCalendarIds` is the in-app per-calendar +off switch (#272): the scan plans nothing for those calendars (so they arm no +wake-ups; toggling it re-scans), and `ReminderNotifier.post` checks it again +for snoozes. The settings screen re-reads `ReminderChannels.status` on every +resume and marks a calendar "Blocked in system settings" when the app, its +channel or its account group is switched off there. + Deliberately absent: a fallback to the provider's `EVENT_REMINDER` broadcast. Keeping both would double-post wherever the provider works, and Etar's way out — a latch that disables its own scheduling once a real broadcast arrives — cannot diff --git a/floret-kit b/floret-kit index a039ab5b..9a523314 160000 --- a/floret-kit +++ b/floret-kit @@ -1 +1 @@ -Subproject commit a039ab5bd470a548d754f2e8e610dc03bbcea40e +Subproject commit 9a523314ead24e2b25eb2b6637d4cc170c1ab405