fix(#518): review round 3 — post under the channel lock, refuse unreadable sounds, audible importance
This commit is contained in:
1 parent
661300728a
commit
081675906b
4 files changed
+70
-32
No files matched your search
@@ -1,8 +1,12 @@
|
||||
package de.jeanlucmakiola.calendula.data.reminders
|
||||
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationChannelGroup
|
||||
import android.app.NotificationManager
|
||||
import android.app.NotificationManager.IMPORTANCE_DEFAULT
|
||||
import android.app.NotificationManager.IMPORTANCE_LOW
|
||||
import android.app.NotificationManager.IMPORTANCE_MIN
|
||||
import android.content.Context
|
||||
import android.media.AudioAttributes
|
||||
import android.net.Uri
|
||||
@@ -57,7 +61,11 @@ class ReminderChannels @Inject constructor(
|
||||
val versions = currentVersions(existingIds).also { knownVersions = it }
|
||||
if (syncKey(calendars, existingIds, versions) == lastSync && LEGACY_REMINDER_CHANNEL_ID !in existingIds) return
|
||||
val groups = manager.notificationChannelGroups
|
||||
val plan = plan(calendars, existing, groups.map { it.id }, versions, showingChannelIds())
|
||||
val groupIds = groups.map { it.id }
|
||||
// Active notifications are only read when there is something stale to protect.
|
||||
val plan = plan(calendars, existing, groupIds, versions).let { draft ->
|
||||
if (draft.staleChannelIds.isEmpty()) draft else plan(calendars, existing, groupIds, versions, showingChannelIds(draft.staleChannelIds))
|
||||
}
|
||||
plan.staleChannelIds.forEach(manager::deleteNotificationChannel)
|
||||
plan.staleGroupIds.forEach(manager::deleteNotificationChannelGroup)
|
||||
val groupNames = groups.associate { it.id to it.name?.toString() }
|
||||
@@ -94,12 +102,12 @@ class ReminderChannels @Inject constructor(
|
||||
private fun currentVersions(existingChannelIds: Collection<String>): Map<Long, Int> =
|
||||
currentReminderChannelVersions(existingChannelIds, runBlocking { settingsPrefs.reminderChannelVersions.first() })
|
||||
|
||||
/** Channels with a notification on screen; on failure every channel counts, so none is deleted. */
|
||||
private fun showingChannelIds(): Set<String> = runCatching {
|
||||
/** Channels with a notification on screen; on failure all of [candidates] count, so none is deleted. */
|
||||
private fun showingChannelIds(candidates: Collection<String>): Set<String> = runCatching {
|
||||
manager.activeNotifications.mapNotNullTo(HashSet()) { it.notification.channelId }
|
||||
}.getOrElse { e ->
|
||||
Log.w(TAG, "Could not read active notifications", e)
|
||||
manager.notificationChannels.mapTo(HashSet()) { it.id }
|
||||
candidates.toSet()
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -147,6 +155,13 @@ class ReminderChannels @Inject constructor(
|
||||
return id
|
||||
}
|
||||
|
||||
/**
|
||||
* Run [block] with [calendarId]'s channel held: no sound pick or sync can
|
||||
* move or retire it until [block] returns. Null when the calendar is gone.
|
||||
*/
|
||||
@Synchronized
|
||||
fun <T> withChannel(calendarId: Long, block: (String) -> T): T? = channelFor(calendarId)?.let(block)
|
||||
|
||||
/** What the system currently lets through for [calendarIds]' reminders (#145). */
|
||||
fun status(calendarIds: Collection<Long>): ReminderChannelStatus {
|
||||
val manager = manager
|
||||
@@ -174,7 +189,7 @@ class ReminderChannels @Inject constructor(
|
||||
/**
|
||||
* Give [calendarIds]' reminders [sound] (null = silent). A channel's sound is
|
||||
* fixed once created, so each moves to a new channel version carrying over
|
||||
* everything else, and the old one retires (#518). Calendars without a
|
||||
* everything else, and the old one retires on the next sync (#518). Calendars without a
|
||||
* channel are skipped unless [createMissing]. Returns whether every move
|
||||
* went through.
|
||||
*/
|
||||
@@ -189,20 +204,28 @@ class ReminderChannels @Inject constructor(
|
||||
return recreate(settingsPrefs.reserveReminderChannelVersions(floors), sound)
|
||||
}
|
||||
|
||||
/** Create each calendar's [versions] from its current channel, then retire the old one. */
|
||||
/**
|
||||
* Create each calendar's [versions] from its current channel. The old one is
|
||||
* left to the next [sync], which retires it once nothing shows on it.
|
||||
*/
|
||||
@Synchronized
|
||||
private fun recreate(versions: Map<Long, Int>, sound: Uri?): Boolean {
|
||||
val manager = manager
|
||||
val byId = manager.notificationChannels.associateBy { it.id }
|
||||
val current = currentReminderChannelVersions(byId.keys, emptyMap())
|
||||
val showing = showingChannelIds()
|
||||
var allApplied = true
|
||||
versions.forEach { (calendarId, version) ->
|
||||
val from = current[calendarId]?.takeIf { it < version } ?: return@forEach
|
||||
val old = byId[reminderChannelId(calendarId, from)] ?: return@forEach
|
||||
try {
|
||||
// Picking a sound asks for one, which a "Silent" (low) channel would never play.
|
||||
val importance = if (sound != null && old.importance in IMPORTANCE_MIN..IMPORTANCE_LOW) {
|
||||
IMPORTANCE_DEFAULT
|
||||
} else {
|
||||
old.importance
|
||||
}
|
||||
manager.createNotificationChannel(
|
||||
NotificationChannel(reminderChannelId(calendarId, version), old.name, old.importance).apply {
|
||||
NotificationChannel(reminderChannelId(calendarId, version), old.name, importance).apply {
|
||||
description = old.description
|
||||
old.group?.let { group = it }
|
||||
inheritFrom(old)
|
||||
@@ -210,7 +233,6 @@ class ReminderChannels @Inject constructor(
|
||||
},
|
||||
)
|
||||
knownVersions = knownVersions + (calendarId to version)
|
||||
if (old.id !in showing) manager.deleteNotificationChannel(old.id)
|
||||
} catch (e: RuntimeException) {
|
||||
Log.w(TAG, "Could not move calendar $calendarId to a new sound", e)
|
||||
allApplied = false
|
||||
@@ -292,7 +314,7 @@ class ReminderChannels @Inject constructor(
|
||||
private fun retireLegacyChannel(): Boolean {
|
||||
val manager = manager
|
||||
if (manager.getNotificationChannel(LEGACY_REMINDER_CHANNEL_ID) == null) return true
|
||||
val showing = LEGACY_REMINDER_CHANNEL_ID in showingChannelIds()
|
||||
val showing = LEGACY_REMINDER_CHANNEL_ID in showingChannelIds(listOf(LEGACY_REMINDER_CHANNEL_ID))
|
||||
if (!showing) manager.deleteNotificationChannel(LEGACY_REMINDER_CHANNEL_ID)
|
||||
return !showing
|
||||
}
|
||||
@@ -307,10 +329,7 @@ class ReminderChannels @Inject constructor(
|
||||
private companion object {
|
||||
const val TAG = "ReminderChannels"
|
||||
|
||||
val DEFAULT_AUDIO_ATTRIBUTES: AudioAttributes = AudioAttributes.Builder()
|
||||
.setUsage(AudioAttributes.USAGE_NOTIFICATION)
|
||||
.setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
|
||||
.build()
|
||||
val DEFAULT_AUDIO_ATTRIBUTES: AudioAttributes = Notification.AUDIO_ATTRIBUTES_DEFAULT
|
||||
}
|
||||
}
|
||||
|
||||
@@ -87,16 +87,19 @@ class ReminderNotifier @Inject constructor(
|
||||
yesterdayLabel = context.getString(R.string.reminder_day_yesterday),
|
||||
)
|
||||
val text = listOfNotNull(time, alert.location).joinToString(" · ")
|
||||
// Resolved last, so a sound picked meanwhile (#518) can't retire it before notify.
|
||||
val channelId = try {
|
||||
channels.channelFor(alert.calendarId) ?: run {
|
||||
Log.i(TAG, "Dropped the reminder of event ${alert.eventId}: calendar ${alert.calendarId} is gone")
|
||||
return
|
||||
}
|
||||
val posted = try {
|
||||
// Under the channel lock, so a sound picked meanwhile (#518) can't move it mid-post.
|
||||
channels.withChannel(alert.calendarId) { channelId -> notify(alert, channelId, title, text) }
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "No channel for the reminder of event ${alert.eventId}", e)
|
||||
return
|
||||
}
|
||||
if (posted == null) {
|
||||
Log.i(TAG, "Dropped the reminder of event ${alert.eventId}: calendar ${alert.calendarId} is gone")
|
||||
}
|
||||
}
|
||||
|
||||
private fun notify(alert: ReminderAlert, channelId: String, title: String, text: String) {
|
||||
val notification = NotificationCompat.Builder(context, channelId)
|
||||
.setSmallIcon(R.drawable.ic_notification)
|
||||
.setContentTitle(title)
|
||||
|
||||
@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.settings
|
||||
import android.content.Context
|
||||
import android.net.Uri
|
||||
import android.os.Build
|
||||
import android.provider.Settings
|
||||
import android.util.Log
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import androidx.lifecycle.ViewModel
|
||||
@@ -54,6 +55,8 @@ import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.CoroutineDispatcher
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.NonCancellable
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.flow.receiveAsFlow
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.MutableSharedFlow
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
@@ -396,10 +399,12 @@ class SettingsViewModel @Inject constructor(
|
||||
/** Each calendar's reminder sound (#518), null until first read; a calendar without a channel yet is absent. */
|
||||
val channelSounds: StateFlow<Map<Long, ReminderSound>?> = _channelSounds.asStateFlow()
|
||||
|
||||
private val _soundFailed = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
|
||||
private val _soundFailed = Channel<Unit>(Channel.CONFLATED)
|
||||
|
||||
/** Emits when a picked sound couldn't be applied to every calendar. */
|
||||
val soundFailed: SharedFlow<Unit> = _soundFailed
|
||||
/** Emits when a picked sound couldn't be applied to every calendar; kept until the screen collects it. */
|
||||
val soundFailed: Flow<Unit> = _soundFailed.receiveAsFlow()
|
||||
|
||||
private val soundTitles = mutableMapOf<Uri, String?>()
|
||||
|
||||
fun refreshChannelStatus(calendarIds: Collection<Long>) {
|
||||
channelStatusJob?.cancel()
|
||||
@@ -407,41 +412,50 @@ class SettingsViewModel @Inject constructor(
|
||||
onChannels { status(calendarIds) }?.let { _channelStatus.value = it }
|
||||
val sounds = onChannels { sounds(calendarIds) } ?: return@launch
|
||||
_channelSounds.value = withContext(io) {
|
||||
val titles = sounds.values.filterNotNull().distinct().associateWith { appContext.ringtoneTitle(it) }
|
||||
sounds.mapValues { (_, uri) -> ReminderSound(uri, uri?.let(titles::get)) }
|
||||
sounds.mapValues { (_, uri) ->
|
||||
ReminderSound(uri, uri?.let { synchronized(soundTitles) { soundTitles.getOrPut(it) { appContext.ringtoneTitle(it) } } })
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Give [calendarId]'s reminders [sound] (null = silent), on a fresh channel (#518). */
|
||||
fun setReminderSound(calendarId: Long, sound: Uri?) = applySound { setSound(listOf(calendarId), sound, createMissing = true) }
|
||||
fun setReminderSound(calendarId: Long, sound: Uri?) = applySound(sound) {
|
||||
setSound(listOf(calendarId), sound, createMissing = true)
|
||||
}
|
||||
|
||||
/**
|
||||
* Give every switched-on calendar's reminders [sound]. Reads the calendars
|
||||
* itself, so a pick returning after process death still finds them; those
|
||||
* that only get a channel when something posts are left alone.
|
||||
*/
|
||||
fun setReminderSoundForAll(sound: Uri?) = applySound {
|
||||
fun setReminderSoundForAll(sound: Uri?) = applySound(sound) {
|
||||
try {
|
||||
sync()
|
||||
} catch (e: Exception) {
|
||||
Log.w("SettingsViewModel", "Channel sync before a sound pick failed", e)
|
||||
}
|
||||
setSound(visibleCalendars.first().map { it.id }, sound, createMissing = false)
|
||||
val ids = visibleCalendars.first().map { it.id }
|
||||
ids.isNotEmpty() && setSound(ids, sound, createMissing = false)
|
||||
}
|
||||
|
||||
private fun canRead(uri: Uri): Boolean = uri.authority == Settings.AUTHORITY ||
|
||||
runCatching { appContext.contentResolver.openAssetFileDescriptor(uri, "r")?.close() != null }.getOrDefault(false)
|
||||
|
||||
/** Runs to completion even if the screen closes meanwhile, so a pick is never half-applied. */
|
||||
private fun applySound(block: suspend ReminderChannels.() -> Boolean) {
|
||||
private fun applySound(sound: Uri?, block: suspend ReminderChannels.() -> Boolean) {
|
||||
viewModelScope.launch {
|
||||
val applied = withContext(io + NonCancellable) {
|
||||
try {
|
||||
// The system plays the sound but checks that Calendula could read it.
|
||||
if (sound != null && !canRead(sound)) return@withContext false
|
||||
reminderChannels.block()
|
||||
} catch (e: Exception) {
|
||||
Log.w("SettingsViewModel", "Could not set the reminder sound", e)
|
||||
false
|
||||
}
|
||||
}
|
||||
if (!applied) _soundFailed.tryEmit(Unit)
|
||||
if (!applied) _soundFailed.trySend(Unit)
|
||||
refreshChannelStatus(visibleCalendars.first().map { it.id })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -410,8 +410,10 @@ the app (#518) can't be set on an existing channel, so
|
||||
current version is simply the highest channel that exists, so the new one only
|
||||
takes over once written; `SettingsPrefs.reminderChannelVersions` is just a
|
||||
high-water mark that keeps ids from being reused (a re-used id would bring back
|
||||
the deleted channel's settings). The sync treats older versions as stale and
|
||||
keeps one while a notification still shows on it.
|
||||
the deleted channel's settings). `setSound` leaves the old version to the sync,
|
||||
which treats older versions as stale and keeps one while a notification still
|
||||
shows on it; `ReminderNotifier.post` resolves and posts under the channel lock
|
||||
(`withChannel`), so a pick never moves a channel mid-post.
|
||||
Separate from the channels, `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
|
||||
|
||||
Reference in new issue
Block a user