fix(#145): review round C — no replay on unmute, fallback channel on write failure, hide pending-off calendars

.gitea/workflows/release.yaml

@@ -318,16 +318,13 @@ jobs:
   # not provide node inside custom job containers, so JavaScript actions
   # (checkout, download-artifact) can't run there. The Renovate job gets away
   # with a container because its only step is a shell command. Ruby is installed
-  # the same way sshpass, jq and fdroidserver are in the job above, from trixie:
-  # fastlane >= 2.241 needs Ruby 3.2+, and bookworm's apt only has 3.1.
+  # the same way sshpass, jq and fdroidserver are in the job above.
   play:
     needs: [detect, release]
     # workflow_dispatch is the F-Droid re-sign recovery path — it must never
     # touch Play, so gate on a real release only.
     if: needs.detect.outputs.is_release == 'true'
     runs-on: docker
-    container:
-      image: node:22-trixie
     env:
       VERSION: ${{ needs.detect.outputs.version }}
       VERSION_CODE: ${{ needs.detect.outputs.version_code }}

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<Set<Long>> = nullableStringPref(name).map(
+internal fun idSetPref(name: String): Pref<Set<Long>> = nullableStringPref(name).map(
     { stored -> stored.orEmpty().split(',').mapNotNull { it.trim().toLongOrNull() }.toSet() },
     { ids -> if (ids.isEmpty()) null else ids.sorted().joinToString(",") },
 )

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -166,6 +166,8 @@ class SettingsPrefs @Inject constructor(
     val defaultEventDurationMinutes: Flow<Int> = prefs.flow(SettingsKeys.defaultEventDurationMinutes)
     val perCalendarEventDuration: Flow<Map<Long, Int>> = prefs.flow(SettingsKeys.perCalendarEventDuration)
     val remindersEnabled: Flow<Boolean> = prefs.flow(SettingsKeys.remindersEnabled)
+    val mutedReminderCalendarIds: Flow<Set<Long>> = prefs.flow(SettingsKeys.mutedReminderCalendarIds)
+    val notificationCategoryHintDismissed: Flow<Boolean> = prefs.flow(SettingsKeys.notificationCategoryHintDismissed)
     val allowColorOnUnsupportedCalendars: Flow<Boolean> =
         prefs.flow(SettingsKeys.allowColorOnUnsupportedCalendars)
     val defaultReminderMinutes: Flow<List<Int>> = 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<Boolean> = 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<Set<Long>> = 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<Boolean> = 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

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<ReminderChannelGroupSpec>,
+    val channels: List<ReminderChannelSpec>,
+    /**
+     * 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<ReminderChannelSpec>,
+    /** The [groups] holding a channel that exists or is about to be written. */
+    val groupsInUse: List<ReminderChannelGroupSpec>,
+    val staleChannelIds: List<String>,
+    val staleGroupIds: List<String>,
+)
+
+/**
+ * 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<CalendarSource>,
+    existing: Collection<ExistingReminderChannel>,
+    existingGroupIds: Collection<String>,
+    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<Long> = emptySet(),
+    /** The blocked ones whose whole account group is off, which only the app's own screen can undo. */
+    val groupBlockedCalendarIds: Set<Long> = 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<Long>,
+    appEnabled: Boolean,
+    channels: Map<String, ReminderChannelState>,
+    blockedGroupIds: Set<String>,
+): 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)
+}

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<CalendarSource>, channelIds: Set<String>): 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<Long>): 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<CalendarSource>,
+        existing: List<NotificationChannel>,
+        existingGroupIds: List<String>,
+    ): 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<ReminderChannelGroupSpec>,
+        channels: List<ReminderChannelSpec>,
+        existing: List<NotificationChannel>,
+    ) {
+        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"
+    }
+}
+

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.

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)
 
     /**

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
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt

@@ -9,19 +9,28 @@ 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.Arrangement
 import androidx.compose.foundation.layout.Column
+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,8 +38,11 @@ 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.domain.CalendarSource
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
 import de.jeanlucmakiola.calendula.ui.common.DurationPicker
 import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
@@ -39,10 +51,12 @@ 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
@@ -50,6 +64,7 @@ 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
 
 /**
@@ -86,6 +101,16 @@ internal fun NotificationsScreen(
     var overrideDialog by remember { mutableStateOf<OverrideTarget?>(null) }
     var calendarSectionExpanded by remember { mutableStateOf(false) }
     var expandedCalendars by remember { mutableStateOf(emptySet<Long>()) }
+    val scope = rememberCoroutineScope()
+    val channelStatus by viewModel.channelStatus.collectAsStateWithLifecycle()
+    val calendarIds = state.reminderCalendars.map { it.id }
+    LifecycleResumeEffect(calendarIds) {
+        viewModel.refreshChannelStatus(calendarIds)
+        onPauseOrDispose { }
+    }
+    val openCalendarSound: (Long) -> Unit = { calendarId ->
+        scope.launch { context.openNotificationSettings(viewModel.soundSettingsChannel(calendarId)) }
+    }
 
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_notifications),
@@ -93,6 +118,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 +138,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,10 +203,8 @@ 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()) {
+        // Per-calendar notifications and reminder overrides (#145, #272).
+        if (state.reminderCalendars.isNotEmpty()) {
             Spacer(Modifier.height(24.dp))
             GroupedRow(
                 title = stringResource(R.string.settings_calendar_reminders_title),
@@ -167,30 +219,18 @@ internal fun NotificationsScreen(
                 exit = collapseExit(),
             ) {
                 Column {
-                    state.writableCalendars.forEach { calendar ->
+                    state.reminderCalendars.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
+                        val notifying = calendar.id !in state.mutedReminderCalendarIds
+                        val blocked = notifying && calendar.id in channelStatus.blockedCalendarIds
                         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 = if (expanded) Position.Top else Position.Alone,
                             leading = { CalendarColorChip(calendar.color) },
                             trailing = { ExpandIcon(expanded) },
@@ -207,22 +247,16 @@ internal fun NotificationsScreen(
                             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) },
-                                )
-                            }
+                            CalendarNotificationRows(
+                                calendar = calendar,
+                                state = state,
+                                notifying = notifying,
+                                blocked = blocked,
+                                onSetNotifying = { viewModel.setCalendarRemindersEnabled(calendar.id, it) },
+                                onOpenSound = { openCalendarSound(calendar.id) },
+                                onOpenSpecialDates = onOpenSpecialDates,
+                                onEditOverride = { overrideDialog = it },
+                            )
                         }
                     }
                 }
@@ -309,6 +343,107 @@ internal fun NotificationsScreen(
     }
 }
 
+/**
+ * One calendar's expanded rows: its 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 CalendarNotificationRows(
+    calendar: CalendarSource,
+    state: SettingsUiState,
+    notifying: Boolean,
+    blocked: Boolean,
+    onSetNotifying: (Boolean) -> Unit,
+    onOpenSound: () -> Unit,
+    onOpenSpecialDates: () -> Unit,
+    onEditOverride: (OverrideTarget) -> Unit,
+) {
+    val managed = calendar.id in state.managedCalendarIds
+    val takesOverrides = calendar.canModifyContents && !managed
+    Column {
+        GroupedSwitchRow(
+            title = stringResource(R.string.settings_calendar_notifications),
+            checked = notifying,
+            onCheckedChange = onSetNotifying,
+            summary = stringResource(R.string.settings_calendar_notifications_hint),
+            position = Position.Middle,
+        )
+        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,
+            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,
+                trailing = {
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                },
+                onClick = onOpenSpecialDates,
+            )
+        } else if (takesOverrides) {
+            val timed = state.perCalendarReminderOverride.reminderOverrideFor(calendar.id)
+            GroupedRow(
+                title = stringResource(R.string.settings_default_reminder),
+                summary = calendarOverrideSummary(timed, state.defaultReminderMinutes),
+                position = Position.Middle,
+                onClick = { onEditOverride(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 = { onEditOverride(OverrideTarget(calendar.id, isAllDay = true)) },
+            )
+        }
+    }
+}
+
+/** 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)) }
+        }
+    }
+}
+
+@Composable
+private fun ExternalLinkIcon() {
+    Icon(
+        imageVector = Icons.AutoMirrored.Filled.OpenInNew,
+        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)
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt

@@ -96,8 +96,14 @@ data class SettingsUiState(
     val perCalendarReminderOverride: Map<Long, List<Int>> = emptyMap(),
     /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */
     val perCalendarAllDayReminderOverride: Map<Long, List<Int>> = 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<CalendarSource> = emptyList(),
+    /** Switched-on calendars, each with its own notification switch and channel (#145, #272). */
+    val reminderCalendars: List<CalendarSource> = emptyList(),
+    /** Calendars whose reminders Calendula doesn't post (#272). */
+    val mutedReminderCalendarIds: Set<Long> = 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).

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<List<CalendarSource>> = repository.calendars()
-        .map { calendars -> calendars.filter { it.canModifyContents && it.isVisibleInSystem } }
-        .catch { emit(emptyList()) }
+    private val visibleCalendars: Flow<List<CalendarSource>> =
+        combine(repository.calendars(), calendarPrefs.pendingDisabledCalendarIds) { calendars, pending ->
+            calendars.filter { it.isVisibleInSystem && it.id !in pending }
+        }.catch { emit(emptyList()) }
 
     val state: StateFlow<SettingsUiState> =
-        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<ReminderChannelStatus> = _channelStatus.asStateFlow()
+
+    private var channelStatusJob: Job? = null
+
+    fun refreshChannelStatus(calendarIds: Collection<Long>) {
+        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 <T> 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) }

app/src/main/res/values/strings.xml

@@ -731,7 +731,17 @@
     <string name="reminder_custom_amount">Amount</string>
     <string name="reminder_custom_set">Set</string>
     <string name="settings_calendar_reminders_title">Per-calendar reminders</string>
-    <string name="settings_calendar_reminders_hint">Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own.</string>
+    <string name="settings_calendar_reminders_hint">Turn notifications off or pick a sound per calendar, and override the default reminder for calendars you can edit.</string>
+    <string name="settings_calendar_notifications">Notifications</string>
+    <string name="settings_calendar_notifications_hint">Notify at this calendar\'s reminder times</string>
+    <string name="settings_calendar_notifications_off">Notifications off</string>
+    <string name="settings_notification_sound">Notification sound</string>
+    <string name="settings_notification_sound_hint">Sound, vibration and pop-ups for each calendar, in system settings</string>
+    <string name="settings_notifications_blocked">Blocked in system settings</string>
+    <string name="settings_notifications_blocked_hint">Blocked in system settings — tap to allow</string>
+    <string name="settings_notification_category_hint">On Samsung phones, new notification categories can start switched off. If a calendar\'s reminders don\'t arrive, check that its category is on.</string>
+    <string name="settings_notification_category_hint_open">Open settings</string>
+    <string name="settings_calendar_notification_sound_hint">Sound, vibration and pop-ups for this calendar, in system settings</string>
     <string name="settings_calendar_reminder_inherits">Default (%1$s)</string>
     <string name="settings_reliable_delivery">Reliable delivery</string>
     <string name="settings_reliable_delivery_hint">Android may delay reminders to save battery. Exempt Calendula so they arrive on time.</string>

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,

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<CalendarSource>, existing: List<String> = emptyList(), groups: List<String> = 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"
+    }
+}

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