Merge branch 'feat/17-silence-after' into release/v1.0.0

# Conflicts:
#	app/src/main/java/de/jeanlucmakiola/clockula/alarm/AlarmEngine.kt
#	app/src/main/java/de/jeanlucmakiola/clockula/data/backup/BackupDto.kt
#	app/src/test/java/de/jeanlucmakiola/clockula/data/backup/BackupCodecTest.kt
#	app/src/test/java/de/jeanlucmakiola/clockula/data/prefs/SettingsPrefsTest.kt
#	docs/BACKUP.md
This commit is contained in:
makiolaj committed 2026-10-26 20:48:54 +01:00
commit 333a23d6be
35 files changed
+1284 -109

No files matched your search

+4
View File
@@ -57,6 +57,10 @@ The first release of Clockula: alarms, timers, a stopwatch and a world clock.
with Clockula. A voice-set alarm cleans up after itself once dismissed.
- Settings: theme, dynamic colour, language, and the defaults every new alarm
and timer inherits.
- Choose how long a ringing alarm or a finished timer keeps going before it
stops on its own: 1, 5, 10, 15, 20 or 25 minutes, or Never, separately for
alarms and timers. Ten minutes stays the default, and Never still stops
after an hour so a phone left at home can't ring its battery flat.
- Back up alarms, timers, world clocks and settings to a JSON file, and restore
them on this device or another one.
- "Why might my alarm not ring?", a self-check that reads your device's real
@@ -21,6 +21,7 @@ import de.jeanlucmakiola.clockula.domain.resolveSettings
import de.jeanlucmakiola.clockula.domain.time.WallClock
import de.jeanlucmakiola.clockula.domain.time.ZoneProvider
import de.jeanlucmakiola.clockula.system.RebootRepair
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.distinctUntilChanged
@@ -29,6 +30,8 @@ import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import kotlin.time.Duration
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Instant
import javax.inject.Inject
@@ -80,13 +83,43 @@ class AlarmEngine @Inject constructor(
suspend fun onAutoSilence(alarmId: Long): Unit = lock.withLock {
val state = states.state(alarmId)
if (state.ringingSince == null) return@withLock
val since = state.ringingSince ?: return@withLock
// A ring still inside the window in force keeps ringing: a backstop
// broadcast already queued when "Silence after" was raised must not end
// the time just granted. A negative age is a clock moved back whose
// TIME_SET has not been handled yet; the backstop has then had its
// window in real time, and closes the ring as in v1.
val age = wallClock.now() - since
if (age >= Duration.ZERO && rearmIfInsideWindowLocked(state)) return@withLock
// Missed, not snoozed: the ring stops, the cycle closes, the next
// occurrence is scheduled. There is no missed-alarm notification in v1.
closeCycleLocked(alarmId, state)
}
/**
* Writes the alarms' "Silence after" — the engine is its only writer outside
* a backup restore — and measures a ring in progress against the new
* window at once: one already past it closes as missed, exactly as the
* backstop would close it, and one still inside it has its backstop moved
* to the new end. Measured from when the ring started, so changing the
* setting back and forth cannot buy a ring a fresh window.
*/
suspend fun setAlarmSilenceAfter(minutes: Int): Unit = withContext(NonCancellable) {
// Not cancellable: a write that lands without the re-measure would leave
// a ring in progress on the old window.
lock.withLock {
settings.setAlarmSilenceAfterMinutes(minutes)
remeasureRingLocked()
}
}
private suspend fun remeasureRingLocked() {
val state = states.ringing() ?: return
if (!rearmIfInsideWindowLocked(state)) closeCycleLocked(state.alarmId, state)
}
/** [minutesOverride] is a one-off, already clamped; it is never persisted anywhere (M9 D15). */
suspend fun snooze(alarmId: Long, minutesOverride: Int? = null): SnoozeOutcome =
lock.withLock { snoozeLocked(alarmId, minutesOverride) }
@@ -156,7 +189,15 @@ class AlarmEngine @Inject constructor(
rescheduleLocked()
}
suspend fun onSystemTimeOrZoneChanged(): ScheduledFire? = reschedule()
/**
* The backstop is a wall-clock registration, so a clock change moves it. A
* ring in progress is re-measured first: a clock moved forward past its
* window closes it, one moved back re-arms it a window from now at most.
*/
suspend fun onSystemTimeOrZoneChanged(): ScheduledFire? = lock.withLock {
remeasureRingLocked()
rescheduleLocked()
}
suspend fun onPackageReplaced(): ScheduledFire? = reschedule()
@@ -204,7 +245,12 @@ class AlarmEngine @Inject constructor(
* emission; a live readout passes a `Ticker`'s flow (M5 D8).
*/
fun upcoming(refresh: Flow<Unit> = flowOf(Unit)): Flow<List<UpcomingAlarm>> =
combine(alarms.alarms(), states.states(), refresh) { alarms, states, _ ->
combine(
alarms.alarms(),
states.states(),
settings.defaults.map { it.alarmSilenceAfter }.distinctUntilChanged(),
refresh,
) { alarms, states, silenceAfter, _ ->
val now = wallClock.now()
val zone = zones.current()
val byId = states.associateBy { it.alarmId }
@@ -217,6 +263,7 @@ class AlarmEngine @Inject constructor(
byId[alarm.id] ?: AlarmRingState.initial(alarm.id),
now,
zone,
silenceAfter,
)
UpcomingAlarm(alarm, resolution.nextFire, resolution.source)
}
@@ -234,13 +281,14 @@ class AlarmEngine @Inject constructor(
private suspend fun rescheduleLocked(deferUpcomingTo: MutableList<UpcomingSync>? = null): ScheduledFire? {
val now = wallClock.now()
val zone = zones.current()
val silenceAfter = settings.currentDefaults().alarmSilenceAfter
var earliest: Pair<Alarm, AlarmResolution>? = null
val resolved = mutableListOf<UpcomingAlarm>()
val pendingSkips = mutableListOf<Instant>()
for (alarm in alarms.alarms().first()) {
val state = states.state(alarm.id)
val resolution = AlarmResolver.resolve(alarm, state, now, zone)
val resolution = AlarmResolver.resolve(alarm, state, now, zone, silenceAfter)
persist(alarm, state, resolution)
resolved += UpcomingAlarm(alarm, resolution.nextFire, resolution.source)
resolution.state.skippedOccurrence?.let { pendingSkips += it }
@@ -311,10 +359,11 @@ class AlarmEngine @Inject constructor(
val alarm = alarms.find(alarmId)
val state = states.state(alarmId)
val isSnoozeFire = state.snoozedUntil != null && state.snoozedUntil == scheduledFor
val silenceAfter = settings.currentDefaults().alarmSilenceAfter
// A snooze is kept for as long as the resolver keeps it pending, so one
// delivered late (after a reboot, or by Doze) still rings. Rejecting it
// here would only re-register the same past instant and fire again.
val lateBy = if (isSnoozeFire) AlarmRing.AUTO_SILENCE_AFTER else AlarmRing.FIRE_GRACE
val lateBy = if (isSnoozeFire) AlarmRing.snoozeGrace(silenceAfter) else AlarmRing.FIRE_GRACE
// A skip armed on this very occurrence after its fire was already on its
// way: the user dismissed it in advance (#16), so it must not ring.
// Only the armed skip, not the handled-occurrence watermark: the
@@ -331,16 +380,22 @@ class AlarmEngine @Inject constructor(
// At most one alarm rings, and the newly-firing one takes over. The one
// it displaces keeps its handled-occurrence watermark, so it does not
// come back the moment the slot is re-resolved.
// Its cycle has closed undismissed, so a one-shot alarm is switched off
// as on every other such close, rather than armed for tomorrow.
states.ringing()?.takeIf { it.alarmId != alarmId }?.let { other ->
ring.stopRinging(other.alarmId)
states.save(other.copy(ringingSince = null, snoozedUntil = null, snoozeCount = 0))
alarms.find(other.alarmId)?.takeIf { !it.repeatDays.isRepeating }?.let { disableOrDeleteLocked(it) }
}
// `ringingSince` is cleared too: this fire opens the ring afresh, and a
// stale value left behind would let the re-resolution below close (and
// switch off) the very alarm that is about to ring.
val opened = if (isSnoozeFire) {
// The cycle is the same one: the count and the watermark carry over.
state.copy(snoozedUntil = null)
state.copy(ringingSince = null, snoozedUntil = null)
} else {
state.copy(snoozedUntil = null, snoozeCount = 0, handledOccurrence = scheduledFor)
state.copy(ringingSince = null, snoozedUntil = null, snoozeCount = 0, handledOccurrence = scheduledFor)
}
// The watermark is written before anything else can interrupt, and the
// slot is re-resolved while the alarm is not yet marked as ringing — so
@@ -355,7 +410,7 @@ class AlarmEngine @Inject constructor(
try {
states.save(states.state(alarmId).copy(ringingSince = now))
ring.startRinging(alarmId)
scheduler.scheduleAutoSilence(now + AlarmRing.AUTO_SILENCE_AFTER, alarmId)
scheduler.scheduleAutoSilence(now + silenceAfter, alarmId)
} finally {
upcoming.forEach { syncUpcomingLocked(it, now) }
}
@@ -394,21 +449,58 @@ class AlarmEngine @Inject constructor(
private suspend fun resumeRingingIfAnyLocked(): Long? {
val state = states.ringing() ?: return null
val since = state.ringingSince ?: return null
// Slept through it: leave it to the next resolution to close the cycle.
if (wallClock.now() - since >= AlarmRing.AUTO_SILENCE_AFTER) return null
val alarm = alarms.find(state.alarmId)?.takeIf { it.enabled } ?: return null
// Slept through it: leave it to the next resolution to close the cycle.
if (!rearmIfInsideWindowLocked(state)) return null
ring.startRinging(alarm.id)
// The backstop is measured from when the ring started, not from now, so
// a reboot does not buy the alarm another ten minutes.
scheduler.scheduleAutoSilence(since + AlarmRing.AUTO_SILENCE_AFTER, alarm.id)
return alarm.id
}
/** Everything the resolver asked to be written, and nothing it did not. */
/**
* The one rule for measuring a ring against "Silence after": still inside
* the window ⇒ the backstop is (re-)armed at its end and this returns true;
* run out ⇒ false, and the caller closes or drops it. Measured from when the
* ring started, so neither a reboot nor a setting change buys it a fresh
* window.
*
* A clock moved back behind that start is re-anchored to now and stored, so
* a negative age never lingers for a later re-measure to read as "a whole
* window left": a clock moved back adds at most the time already rung, once.
*/
private suspend fun rearmIfInsideWindowLocked(state: AlarmRingState): Boolean {
val stored = state.ringingSince ?: return false
val now = wallClock.now()
val since = if (now < stored) {
states.save(state.copy(ringingSince = now))
now
} else {
stored
}
val silenceAfter = settings.currentDefaults().alarmSilenceAfter
if (now - since >= silenceAfter) return false
scheduler.scheduleAutoSilence(since + silenceAfter, state.alarmId)
return true
}
/**
* Everything the resolver asked to be written, and nothing it did not —
* plus stopping the sound of a ring it closed, which storage alone cannot do.
*/
private suspend fun persist(alarm: Alarm, before: AlarmRingState, resolution: AlarmResolution) {
if (resolution.state != before) states.save(resolution.state)
// A snooze the resolver dropped (it never fired, or the alarm was
// switched off) takes its "Snoozed until" notification with it.
if (before.snoozedUntil != null && resolution.state.snoozedUntil == null) notifier.clearSnoozed(alarm.id)
// The resolver closed a ring: its window ran out before the backstop
// fired ("Silence after" was shortened mid-ring, or the clock jumped),
// or the alarm was switched off while ringing. Storage now says it is
// not ringing, so the sound stops with it rather than waiting for a
// backstop registered against the old window.
if (before.ringingSince != null && resolution.state.ringingSince == null) {
ring.stopRinging(alarm.id)
scheduler.cancelAutoSilence()
}
if (resolution.clearSkipFlag) alarms.setSkipNextOccurrence(alarm.id, false)
// A transient alarm is deleted wherever a permanent one would be
// disabled: the cycle has closed either way (M9 D10).
@@ -17,6 +17,7 @@ import de.jeanlucmakiola.clockula.alarm.AlarmIntents
import de.jeanlucmakiola.clockula.domain.alarm.RingPresentationPolicy
import de.jeanlucmakiola.clockula.domain.alarm.RingSession
import de.jeanlucmakiola.clockula.domain.ring.RingFallbackPolicy
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.ring.RingAudioPlayer
import de.jeanlucmakiola.clockula.ring.RingVibrator
import kotlinx.coroutines.CoroutineScope
@@ -198,8 +199,8 @@ class AlarmRingService : Service() {
private const val ACTION_REPOST = AlarmIntents.ACTION_DISMISS + ".SERVICE_REPOST"
private const val WAKE_LOCK_TAG = "clockula:alarm-ring"
/** A backstop on the backstop: the ring window is ten minutes. */
private const val WAKE_LOCK_TIMEOUT_MILLIS = 15L * 60L * 1_000L
/** A backstop on the backstop, shared with the other ring service. */
private val WAKE_LOCK_TIMEOUT_MILLIS = SilenceAfter.WAKE_LOCK_TIMEOUT.inWholeMilliseconds
fun start(context: Context) {
context.startForegroundService(Intent(context, AlarmRingService::class.java))
@@ -130,6 +130,8 @@ object BackupCodec {
timerRingtoneUri = defaults.timerRingtoneUri,
dismissChallenge = defaults.dismissChallenge.name,
homeZoneId = defaults.homeZoneId,
alarmSilenceAfterMinutes = defaults.alarmSilenceAfterMinutes,
timerSilenceAfterMinutes = defaults.timerSilenceAfterMinutes,
timerPresets = timerPresets.map { it.inWholeMilliseconds },
bedtime = bedtime?.toDto(),
)
@@ -272,6 +274,9 @@ object BackupCodec {
timerRingtoneUri = settingsDto.timerRingtoneUri?.takeIf { it.isNotBlank() },
dismissChallenge = settingsDto.dismissChallenge.toEnum(DismissChallenge.NONE),
homeZoneId = settingsDto.homeZoneId?.let(Zones::normalise),
// Clamped on apply, by the preference, like every other default.
alarmSilenceAfterMinutes = settingsDto.alarmSilenceAfterMinutes,
timerSilenceAfterMinutes = settingsDto.timerSilenceAfterMinutes,
),
timerPresets = settingsDto.timerPresets?.map { it.milliseconds } ?: TimerPresets.BUILT_IN,
bedtime = settingsDto.bedtime?.toBedtime(),
@@ -1,6 +1,7 @@
package de.jeanlucmakiola.clockula.data.backup
import de.jeanlucmakiola.clockula.domain.bedtime.BedtimeSettings
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
@@ -72,6 +73,12 @@ data class SettingsDto(
@SerialName("default_timer_ringtone_uri") val timerRingtoneUri: String? = null,
@SerialName("default_dismiss_challenge") val dismissChallenge: String = "NONE",
@SerialName("home_zone_id") val homeZoneId: String? = null,
/**
* Minutes, or 0 for "Never". Absent in a file from before the setting
* existed, which is v1's fixed ten minutes.
*/
@SerialName("default_alarm_silence_after_minutes") val alarmSilenceAfterMinutes: Int = SilenceAfter.DEFAULT_MINUTES,
@SerialName("default_timer_silence_after_minutes") val timerSilenceAfterMinutes: Int = SilenceAfter.DEFAULT_MINUTES,
/**
* Absent is not empty: an empty list is a user who removed every preset,
* while a file without the field (an older or hand-written one) keeps the
@@ -3,6 +3,7 @@ package de.jeanlucmakiola.clockula.data.prefs
import de.jeanlucmakiola.clockula.domain.ClockLimits
import de.jeanlucmakiola.clockula.domain.DismissChallenge
import de.jeanlucmakiola.clockula.domain.Zones
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.floret.prefs.Pref
import de.jeanlucmakiola.floret.prefs.booleanPref
import de.jeanlucmakiola.floret.prefs.enumPref
@@ -31,6 +32,20 @@ object ClockPrefs {
val dismissChallenge: Pref<DismissChallenge> =
enumPref("default_dismiss_challenge", DismissChallenge.NONE)
/**
* How long a ringing alarm, and a finished timer, keep going before they
* stop on their own (#17): minutes, or [SilenceAfter.NEVER], sanitised both
* ways through [SilenceAfter.sanitise]. An absent key reads as v1's fixed
* ten minutes, so an upgrade changes nothing.
*/
val alarmSilenceAfterMinutes: Pref<Int> =
intPref("default_alarm_silence_after_minutes", SilenceAfter.DEFAULT_MINUTES)
.map(decode = SilenceAfter::sanitise, encode = SilenceAfter::sanitise)
val timerSilenceAfterMinutes: Pref<Int> =
intPref("default_timer_silence_after_minutes", SilenceAfter.DEFAULT_MINUTES)
.map(decode = SilenceAfter::sanitise, encode = SilenceAfter::sanitise)
/** Normalised through [Zones] both ways, so a zone the device dropped reads as absent. */
val homeZoneId: Pref<String?> = nullableStringPref("home_zone_id")
.map(decode = Zones::normalise, encode = Zones::normalise)
@@ -65,14 +65,20 @@ class SettingsPrefs @Inject constructor(private val store: PrefStore) {
dismissChallenge = dismissChallenge,
)
},
combine(
store.flow(ClockPrefs.alarmSilenceAfterMinutes),
store.flow(ClockPrefs.timerSilenceAfterMinutes),
) { alarmMinutes, timerMinutes -> alarmMinutes to timerMinutes },
store.flow(ClockPrefs.alarmRingtoneUri),
store.flow(ClockPrefs.timerRingtoneUri),
store.flow(ClockPrefs.homeZoneId),
) { partial, alarmRingtoneUri, timerRingtoneUri, homeZoneId ->
) { partial, silenceAfter, alarmRingtoneUri, timerRingtoneUri, homeZoneId ->
partial.copy(
alarmRingtoneUri = alarmRingtoneUri,
timerRingtoneUri = timerRingtoneUri,
homeZoneId = homeZoneId,
alarmSilenceAfterMinutes = silenceAfter.first,
timerSilenceAfterMinutes = silenceAfter.second,
)
}.distinctUntilChanged()
@@ -95,6 +101,8 @@ class SettingsPrefs @Inject constructor(private val store: PrefStore) {
prefs[ClockPrefs.timerRingtoneUri] = backup.defaults.timerRingtoneUri
prefs[ClockPrefs.dismissChallenge] = backup.defaults.dismissChallenge
prefs[ClockPrefs.homeZoneId] = backup.defaults.homeZoneId
prefs[ClockPrefs.alarmSilenceAfterMinutes] = backup.defaults.alarmSilenceAfterMinutes
prefs[ClockPrefs.timerSilenceAfterMinutes] = backup.defaults.timerSilenceAfterMinutes
prefs[TimerPrefs.presets] = backup.timerPresets
// Absent from a file written before bedtime existed: keep it.
backup.bedtime?.let { prefs.putBedtime(it) }
@@ -116,6 +124,12 @@ class SettingsPrefs @Inject constructor(private val store: PrefStore) {
suspend fun setDismissChallenge(challenge: DismissChallenge) =
store.set(ClockPrefs.dismissChallenge, challenge)
suspend fun setAlarmSilenceAfterMinutes(minutes: Int) =
store.set(ClockPrefs.alarmSilenceAfterMinutes, minutes)
suspend fun setTimerSilenceAfterMinutes(minutes: Int) =
store.set(ClockPrefs.timerSilenceAfterMinutes, minutes)
suspend fun setHomeZoneId(zoneId: String?) = store.set(ClockPrefs.homeZoneId, zoneId)
// --- timer presets (M6) ---
@@ -1,8 +1,15 @@
package de.jeanlucmakiola.clockula.domain
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import kotlin.time.Duration
/**
* The app-wide defaults an alarm or timer inherits when it has no override.
* Backed by DataStore, edited in M10's settings screen.
*
* The two silence-after values are app-wide only: no alarm or timer overrides
* them (#17). They are stored as [SilenceAfter] minutes; read them as a window
* through [alarmSilenceAfter] and [timerSilenceAfter].
*/
data class ClockDefaults(
val snoozeMinutes: Int = 10,
@@ -13,7 +20,15 @@ data class ClockDefaults(
val timerRingtoneUri: String? = null,
val dismissChallenge: DismissChallenge = DismissChallenge.NONE,
val homeZoneId: String? = null,
)
val alarmSilenceAfterMinutes: Int = SilenceAfter.DEFAULT_MINUTES,
val timerSilenceAfterMinutes: Int = SilenceAfter.DEFAULT_MINUTES,
) {
/** How long a ringing alarm rings before it is silenced as missed. */
val alarmSilenceAfter: Duration get() = SilenceAfter.window(alarmSilenceAfterMinutes)
/** How long a finished timer sounds before the noise stops. */
val timerSilenceAfter: Duration get() = SilenceAfter.window(timerSilenceAfterMinutes)
}
/**
* The ranges a user can choose from, for the defaults and for an alarm's own
@@ -27,6 +27,10 @@ data class AlarmResolution(
*
* The precedence is fixed and total: disabled, then ringing, then snoozed, then
* the natural occurrence.
*
* `autoSilenceAfter` is the "Silence after" setting's window
* (`ClockDefaults.alarmSilenceAfter`). It has no default, so no caller can
* measure a ring against a window the user did not choose.
*/
object AlarmResolver {
fun resolve(
@@ -34,7 +38,7 @@ object AlarmResolver {
state: AlarmRingState,
now: Instant,
zone: ZoneId,
autoSilenceAfter: Duration = AlarmRing.AUTO_SILENCE_AFTER,
autoSilenceAfter: Duration,
fireGrace: Duration = AlarmRing.FIRE_GRACE,
): AlarmResolution {
// 1. Disabled: every volatile field goes, except the dismissal watermark
@@ -68,8 +72,11 @@ object AlarmResolver {
// 3. Snooze. A snooze promised before a reboot is kept, even if it came
// due while the device was off; one older than the ring window is gone.
// Never sooner than SNOOZE_GRACE, so a short "Silence after" cannot make
// a snooze easier to lose than it was in v1.
val snoozedUntil = working.snoozedUntil
val snoozePending = snoozedUntil != null && now - snoozedUntil < autoSilenceAfter
val snoozeGrace = AlarmRing.snoozeGrace(autoSilenceAfter)
val snoozePending = snoozedUntil != null && now - snoozedUntil < snoozeGrace
if (snoozedUntil != null && !snoozePending) {
working = working.copy(snoozedUntil = null, snoozeCount = 0)
}
@@ -89,6 +96,22 @@ object AlarmResolver {
}
}
// A cycle that has just closed as missed (a ring past its window, or a
// snooze that never fired) closes a one-shot alarm for good, exactly as
// the engine's own close does. Falling through would hand it the same
// time tomorrow.
val closedAsMissed = ringingSince != null || snoozedUntil != null
if (closedAsMissed && !alarm.repeatDays.isRepeating) {
return AlarmResolution(
alarmId = alarm.id,
nextFire = null,
source = FireSource.NONE,
state = working.copy(skippedOccurrence = null),
clearSkipFlag = alarm.skipNextOccurrence,
disableAlarm = true,
)
}
// 4. The natural occurrence, with the skip watermark on top.
if (!alarm.skipNextOccurrence) {
return AlarmResolution(
@@ -4,20 +4,27 @@ import kotlin.time.Duration
import kotlin.time.Duration.Companion.minutes
/**
* The alarm ring cycle's constants. They are values rather than settings: v1
* does not offer them to the user (docs/PLAN.md §4). The audio chain's own
* constants live in `domain/ring/RingAudio`, shared with the timer's ring.
* The alarm ring cycle's constants. They are values rather than settings
* (docs/PLAN.md §4). How long an alarm rings before it is silenced as missed
* became a setting in #17: `ClockDefaults.alarmSilenceAfter`. The audio
* chain's own constants live in `domain/ring/RingAudio`, shared with the
* timer's ring.
*/
object AlarmRing {
/**
* How long an undismissed alarm rings before it is silenced as missed.
* AOSP DeskClock's default, and the window a resumed ring is measured against.
*/
val AUTO_SILENCE_AFTER: Duration = 10.minutes
/**
* How late a fire may arrive and still count. A fire delayed by doze, a slow
* boot or a `TIME_SET` nudge still rings; one missed by hours does not.
*/
val FIRE_GRACE: Duration = 2.minutes
/**
* The least time a late snooze is still kept: v1's fixed ring window. A
* snooze delayed by a reboot or by Doze is kept for the "Silence after"
* window or this, whichever is longer, so a short window never makes a
* promised snooze easier to lose.
*/
val SNOOZE_GRACE: Duration = 10.minutes
/** How late a snooze may come due and still ring, given the ring window. */
fun snoozeGrace(silenceAfter: Duration): Duration = maxOf(silenceAfter, SNOOZE_GRACE)
}
@@ -0,0 +1,62 @@
package de.jeanlucmakiola.clockula.domain.ring
import kotlin.time.Duration
import kotlin.time.Duration.Companion.minutes
/**
* How long a ring keeps going before it stops on its own: the "Silence after"
* setting, one for alarms and one for timers (#17). Stored as whole minutes,
* with [NEVER] for the option that has no user-facing limit.
*
* "Never" is not unbounded. The auto-silence backstop is also what stops a
* phone left at home from ringing until its battery is flat, and what keeps a
* reboot from resuming a ring that started hours ago, so "Never" rings until
* [HARD_STOP] — longer than any finite choice — and then stops as any other
* window would.
*/
object SilenceAfter {
/** The stored value for "Never". Zero, because no window can be zero minutes long. */
const val NEVER: Int = 0
/** The default, for alarms and timers alike: AOSP DeskClock's, and v1's fixed value. */
const val DEFAULT_MINUTES: Int = 10
/**
* The longest a ring ever lasts, in minutes, and what "Never" means in
* practice. The settings hints say "an hour" in words; change them with it.
*/
const val HARD_STOP_MINUTES: Int = 60
val HARD_STOP: Duration = HARD_STOP_MINUTES.minutes
/**
* How long the ring services hold their wake locks: a backstop on the
* backstop, past the longest window there is, so a ring is never cut
* short by its own wake lock.
*/
val WAKE_LOCK_TIMEOUT: Duration = HARD_STOP + 5.minutes
/** The range a stored value is measured against: below it is corrupt, and [sanitise] stores the hard stop itself as [NEVER]. */
val MINUTES: IntRange = NEVER..HARD_STOP_MINUTES
/** The choices the pickers offer, in order: Google Clock's, so nothing here surprises. */
val CHOICES: List<Int> = listOf(1, 5, 10, 15, 20, 25, NEVER)
/**
* What a stored value is read and written as, from a picker, a hand-edited
* file or a backup. The hard stop or longer is "Never", which rings that
* long anyway, so the picker never shows two names for one window. Negative is nothing anyone chose, so it is the default rather
* than the clamp's floor, which would be "Never".
*/
fun sanitise(minutes: Int): Int = when {
minutes < MINUTES.first -> DEFAULT_MINUTES
minutes >= HARD_STOP_MINUTES -> NEVER
else -> minutes
}
/** The ring window [minutes] stands for, sanitised first so the engines never see an unofferable value. */
fun window(minutes: Int): Duration {
val sane = sanitise(minutes)
return if (sane == NEVER) HARD_STOP else sane.minutes
}
}
@@ -5,17 +5,13 @@ import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.minutes
/**
* The timer ring's constants. Values rather than settings: v1 does not offer
* them to the user (docs/PLAN.md §5, slice plan D11).
* The timer ring's constants. Values rather than settings (docs/PLAN.md §5,
* slice plan D11). How long an unacknowledged timer sounds before the noise
* stops became a setting in #17, `ClockDefaults.timerSilenceAfter`: its own
* rather than the alarm's, because coupling the two would make one number
* answer two questions.
*/
object TimerRing {
/**
* How long an unacknowledged timer sounds before the noise stops (D11).
* The same value as the alarm's and its own constant, free to diverge:
* coupling the two would make one number answer two questions.
*/
val AUTO_SILENCE_AFTER: Duration = 10.minutes
/** What "+1 min" grants (D12). */
val ADD_TIME: Duration = 1.minutes
@@ -1,6 +1,8 @@
package de.jeanlucmakiola.clockula.domain.timer
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import kotlin.time.Duration
import kotlin.time.Instant
sealed interface TimerRingDecision {
@@ -16,8 +18,13 @@ sealed interface TimerRingDecision {
data class Sound(
val subjectId: Long,
val settings: TimerSettings,
/** When the window closes: the session anchor + [TimerRing.AUTO_SILENCE_AFTER]. */
/** When the window closes: the session anchor + [ClockDefaults.timerSilenceAfter]. */
val silenceAt: Instant,
/**
* The session anchor: when its audio opened. The session's identity
* (D10), which [silenceAt] is not, since "Silence after" can move it.
*/
val openedAt: Instant,
) : TimerRingDecision
}
@@ -29,6 +36,17 @@ data class TimerRingOutcome(
/** The whole audio arbitration, as a pure function of current state (D9–D11). */
object TimerRingPolicy {
/** Whether a session anchored at [soundingSince] has run out of [window] by [now]. The one rule, for every reader. */
fun isLapsed(soundingSince: Instant?, now: Instant, window: Duration): Boolean =
soundingSince != null && now - soundingSince >= window
/**
* What a lapsed session's anchor is stored as: moved back past the longest
* window there is, so it stays run out whatever "Silence after" becomes.
*/
fun lapsedAnchor(soundingSince: Instant, now: Instant): Instant =
minOf(soundingSince, now - SilenceAfter.HARD_STOP)
/**
* [expired] is `TimerReadings.expired`'s output, so its first element is
* already the subject (D10). Nothing here is an event: a timer suppressed
@@ -49,10 +67,12 @@ object TimerRingPolicy {
// Auto-silence before suppression: a window that has run out stays run
// out, and an alarm ringing over it must not hand it a fresh one.
if (soundingSince != null && now - soundingSince >= TimerRing.AUTO_SILENCE_AFTER) {
val window = defaults.timerSilenceAfter
if (soundingSince != null && now - soundingSince >= window) {
return TimerRingOutcome(
TimerRingDecision.AutoSilenced(subject.timer.id),
soundingSince = soundingSince,
// Raising the setting later cannot start a silenced timer ringing again.
soundingSince = lapsedAnchor(soundingSince, now),
)
}
@@ -67,13 +87,14 @@ object TimerRingPolicy {
// The anchor is the instant the audio *opened*, so a second timer
// expiring mid-session inherits the window rather than buying a fresh
// ten minutes (D10).
// one (D10).
val anchor = soundingSince ?: now
return TimerRingOutcome(
TimerRingDecision.Sound(
subjectId = subject.timer.id,
settings = subject.timer.resolveSettings(defaults),
silenceAt = anchor + TimerRing.AUTO_SILENCE_AFTER,
silenceAt = anchor + window,
openedAt = anchor,
),
soundingSince = anchor,
)
@@ -14,9 +14,11 @@ import de.jeanlucmakiola.clockula.domain.timer.TimerRing
import de.jeanlucmakiola.clockula.domain.timer.TimerRingDecision
import de.jeanlucmakiola.clockula.domain.timer.TimerRingPolicy
import de.jeanlucmakiola.clockula.system.RebootRepair
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import kotlin.time.Duration
import kotlin.time.Instant
import javax.inject.Inject
@@ -115,6 +117,23 @@ class TimerEngine @Inject constructor(
suspend fun serviceState(alreadyAlerted: Boolean): TimerServiceState =
lock.withLock { serviceStateLocked(alreadyAlerted) }
/**
* Writes the timers' "Silence after". A session that has already run out of
* the old window is recorded as lapsed first — even when no service pass was
* there to see it go — so raising the setting cannot start it sounding
* again. Not cancellable, so the write never lands without that record.
*/
suspend fun setTimerSilenceAfter(minutes: Int): Unit = withContext(NonCancellable) {
lock.withLock {
val anchor = ringState.current()
val now = wall.now()
if (anchor != null && TimerRingPolicy.isLapsed(anchor, now, settings.currentDefaults().timerSilenceAfter)) {
ringState.set(TimerRingPolicy.lapsedAnchor(anchor, now))
}
settings.setTimerSilenceAfterMinutes(minutes)
}
}
/** Starts IDLE/EXPIRED from the configured duration, resumes PAUSED. No-op when RUNNING. */
suspend fun start(timerId: Long): Unit = lock.withLock {
val timer = timers.find(timerId) ?: return@withLock
@@ -266,7 +285,8 @@ class TimerEngine @Inject constructor(
*/
private suspend fun dropLapsedSessionLocked() {
val anchor = ringState.current() ?: return
if (wall.now() - anchor >= TimerRing.AUTO_SILENCE_AFTER) ringState.set(null)
val window = settings.currentDefaults().timerSilenceAfter
if (TimerRingPolicy.isLapsed(anchor, wall.now(), window)) ringState.set(null)
}
private suspend fun serviceStateLocked(alreadyAlerted: Boolean): TimerServiceState {
@@ -14,6 +14,7 @@ import de.jeanlucmakiola.clockula.alarm.AlarmCapabilities
import de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.clockula.data.timers.TimerRepository
import de.jeanlucmakiola.clockula.domain.ring.RingFallbackPolicy
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.domain.timer.TimerNotificationState
import de.jeanlucmakiola.clockula.domain.timer.TimerMode
import de.jeanlucmakiola.clockula.domain.timer.TimerRingDecision
@@ -95,11 +96,11 @@ class TimerService : Service() {
private var alreadyAlerted: Boolean = false
/**
* The auto-silence window the heads-up above was spent inside. A window is
* one ring session (D10), so a *new* session is a new event and gets its
* own one heads-up — even while an earlier timer stays EXPIRED.
* The anchor of the ring session the heads-up above was spent inside. A
* *new* session is a new event and gets its own one heads-up (D10) — even
* while an earlier timer stays EXPIRED.
*/
private var alertedWindow: Instant? = null
private var alertedSession: Instant? = null
/**
* `startForeground` is for going foreground, not for posting: every engine
@@ -204,8 +205,10 @@ class TimerService : Service() {
}
/**
* A ring session's window is its identity (D10), so when the window moves the
* flag that spends the session's one heads-up moves with it. The state is
* A ring session's anchor is its identity (D10), so when a new session opens
* the flag that spends the session's one heads-up moves with it. The anchor
* rather than the window's end, which a "Silence after" edit can move
* mid-session without making it a new one. The state is
* asked for again, because it was computed from the answer that has just
* changed — a second pass rather than a notification that says the right
* thing one trigger too late.
@@ -214,9 +217,9 @@ class TimerService : Service() {
// Only a sounding decision carries a window; a suppressed or silenced one
// must not clear the record, or an alarm ringing across a session would
// buy it a second heads-up (D9).
val window = (state.ring as? TimerRingDecision.Sound)?.silenceAt ?: return state
val reopened = alreadyAlerted && window != alertedWindow
alertedWindow = window
val session = (state.ring as? TimerRingDecision.Sound)?.openedAt ?: return state
val reopened = alreadyAlerted && session != alertedSession
alertedSession = session
if (!reopened) return state
alreadyAlerted = false
return engine.serviceState(alreadyAlerted)
@@ -363,8 +366,8 @@ class TimerService : Service() {
companion object {
private const val WAKE_LOCK_TAG = "clockula:timer-ring"
/** A backstop on the backstop: the ring window is ten minutes. */
private const val WAKE_LOCK_TIMEOUT_MILLIS = 15L * 60L * 1_000L
/** A backstop on the backstop, shared with the other ring service. */
private val WAKE_LOCK_TIMEOUT_MILLIS = SilenceAfter.WAKE_LOCK_TIMEOUT.inWholeMilliseconds
fun start(context: Context) {
context.startForegroundService(Intent(context, TimerService::class.java))
@@ -96,11 +96,12 @@ class AlarmsViewModel @Inject internal constructor(
}
/**
* The ring service is a single global slot the resolver cannot reach, and
* its auto-silence backstop disarms itself once `ringingSince` is null — so
* switching off a *ringing* alarm has to go through the engine first, or it
* sounds until the wake lock expires. Conditional, because dismissing a
* merely snoozed alarm would drop a snooze it should keep (M5 D11).
* Switching off a *ringing* alarm goes through the engine first, so the ring
* closes as a dismissal: the snooze notification cleared and the cycle
* closed under the engine's lock. (Since #17 the engine would also stop the
* sound when the next resolution sees the alarm disabled, but that is a
* backstop, not the path.) Conditional, because dismissing a merely
* snoozed alarm would drop a snooze it should keep (M5 D11).
*/
private suspend fun stopRingIfRinging(alarmId: Long) {
if (engine.ringSession()?.alarm?.id == alarmId) engine.dismiss(alarmId)
@@ -3,18 +3,19 @@ package de.jeanlucmakiola.clockula.ui.ring
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.clockula.data.timers.TimerRepository
import de.jeanlucmakiola.clockula.data.timers.TimerRingStateStore
import de.jeanlucmakiola.clockula.domain.time.ElapsedRealtimeClock
import de.jeanlucmakiola.clockula.domain.time.Ticker
import de.jeanlucmakiola.clockula.domain.time.WallClock
import de.jeanlucmakiola.clockula.domain.timer.TimerReadings
import de.jeanlucmakiola.clockula.domain.timer.TimerRing
import de.jeanlucmakiola.clockula.timer.TimerEngine
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import kotlin.time.Duration.Companion.seconds
@@ -29,6 +30,7 @@ import javax.inject.Inject
class TimerRingViewModel @Inject constructor(
timers: TimerRepository,
ringState: TimerRingStateStore,
settings: SettingsPrefs,
private val engine: TimerEngine,
elapsed: ElapsedRealtimeClock,
wall: WallClock,
@@ -41,7 +43,12 @@ class TimerRingViewModel @Inject constructor(
* the auto-silence window ends without anything being written at all.
*/
val state: StateFlow<TimerRingUiState> =
combine(timers.timers(), ringState.soundingSince, ticker.ticks(TICK)) { rows, soundingSince, _ ->
combine(
timers.timers(),
ringState.soundingSince,
settings.defaults.map { it.timerSilenceAfter }.distinctUntilChanged(),
ticker.ticks(TICK),
) { rows, soundingSince, silenceAfter, _ ->
val now = wall.now()
val expired = TimerReadings.expired(
TimerReadings.active(rows, elapsed.elapsedRealtime(), now),
@@ -49,7 +56,7 @@ class TimerRingViewModel @Inject constructor(
val subject = expired.firstOrNull()
// Auto-silence leaves the rows EXPIRED (D11) but ends the ring, and a
// screen held on over a silent timer is only a battery drain.
val silenced = soundingSince != null && now - soundingSince >= TimerRing.AUTO_SILENCE_AFTER
val silenced = soundingSince != null && now - soundingSince >= silenceAfter
if (subject == null || silenced) {
TimerRingUiState.Finished
} else {
@@ -26,11 +26,12 @@ import de.jeanlucmakiola.floret.components.GroupedRow
import de.jeanlucmakiola.floret.components.Position
/** Which of the alarm-default pickers is open. Mirrors [de.jeanlucmakiola.clockula.ui.alarms.AlarmEditorScreen]'s shape. */
private enum class OpenAlarmPicker { VIBRATE, VOLUME_RAMP, SNOOZE_LENGTH, SNOOZE_LIMIT, CHALLENGE }
private enum class OpenAlarmPicker { VIBRATE, VOLUME_RAMP, SNOOZE_LENGTH, SNOOZE_LIMIT, CHALLENGE, SILENCE_AFTER }
/**
* What every new alarm starts with: how it sounds, how it snoozes, and how it
* is dismissed. The ringtone picker itself is ViewModel state, drawn by the hub.
* is dismissed; then how long any alarm rings, which no alarm overrides (#17).
* The ringtone picker itself is ViewModel state, drawn by the hub.
*/
@Composable
internal fun AlarmDefaultsScreen(
@@ -85,6 +86,17 @@ internal fun AlarmDefaultsScreen(
position = Position.Alone,
onClick = { openPicker = OpenAlarmPicker.CHALLENGE },
)
// Its own group with its own hint: unlike everything above, this one is
// not a default an alarm can change in its editor.
Spacer(Modifier.height(24.dp))
GroupedRow(
title = stringResource(R.string.settings_silence_after),
summary = silenceAfterText(defaults.alarmSilenceAfterMinutes),
position = Position.Alone,
onClick = { openPicker = OpenAlarmPicker.SILENCE_AFTER },
)
SettingsHint(stringResource(R.string.settings_alarm_silence_after_hint))
}
when (openPicker) {
@@ -124,5 +136,10 @@ internal fun AlarmDefaultsScreen(
onSelect = { viewModel.onDismissChallengeChanged(it ?: defaults.dismissChallenge) },
onDismiss = { openPicker = null },
)
OpenAlarmPicker.SILENCE_AFTER -> SilenceAfterPicker(
selected = defaults.alarmSilenceAfterMinutes,
onSelect = { viewModel.onAlarmSilenceAfterChanged(it) },
onDismiss = { openPicker = null },
)
}
}
@@ -3,7 +3,9 @@ package de.jeanlucmakiola.clockula.ui.settings
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import de.jeanlucmakiola.clockula.alarm.AlarmEngine
import de.jeanlucmakiola.clockula.alarm.DeviceStateReader
import de.jeanlucmakiola.clockula.timer.TimerEngine
import de.jeanlucmakiola.clockula.data.appicon.LauncherIcon
import de.jeanlucmakiola.clockula.data.appicon.LauncherIconManager
import de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs
@@ -48,6 +50,8 @@ import javax.inject.Inject
@HiltViewModel
class SettingsViewModel @Inject internal constructor(
private val settings: SettingsPrefs,
private val alarmEngine: AlarmEngine,
private val timerEngine: TimerEngine,
private val ringtones: RingtoneCatalog,
private val preview: RingtonePreviewer,
private val worldClocks: WorldClockSource,
@@ -142,6 +146,14 @@ class SettingsViewModel @Inject internal constructor(
fun onDismissChallengeChanged(value: DismissChallenge) =
viewModelScope.launch { settings.setDismissChallenge(value) }
/** The engine re-measures a ring in progress against the new window at once. */
fun onAlarmSilenceAfterChanged(minutes: Int) = viewModelScope.launch {
alarmEngine.setAlarmSilenceAfter(minutes)
}
fun onTimerSilenceAfterChanged(minutes: Int) =
viewModelScope.launch { timerEngine.setTimerSilenceAfter(minutes) }
// --- the default ringtone pickers ---
internal fun onOpenRingtonePicker(kind: DefaultRingtoneKind) {
@@ -0,0 +1,39 @@
package de.jeanlucmakiola.clockula.ui.settings
import androidx.compose.runtime.Composable
import androidx.compose.ui.res.pluralStringResource
import androidx.compose.ui.res.stringResource
import de.jeanlucmakiola.clockula.R
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.floret.components.OptionPicker
/** [SilenceAfter.NEVER] is "Never" in words, never "0 minutes". */
@Composable
internal fun silenceAfterText(minutes: Int): String = if (minutes == SilenceAfter.NEVER) {
stringResource(R.string.silence_after_never)
} else {
pluralStringResource(R.plurals.silence_after_minutes, minutes, minutes)
}
/**
* "Silence after" is app-wide only (#17): no alarm or timer overrides it, so
* this picker has no "App default" rung. A stored value no choice matches (a
* backup can carry any minute up to the hard stop) is offered too, in its
* place, so the picker always shows what is selected and can put it back.
*/
@Composable
internal fun SilenceAfterPicker(
selected: Int,
onSelect: (Int) -> Unit,
onDismiss: () -> Unit,
) {
val finite = (SilenceAfter.CHOICES + selected).filter { it != SilenceAfter.NEVER }.distinct().sorted()
OptionPicker(
title = stringResource(R.string.settings_silence_after),
options = finite + SilenceAfter.NEVER,
selected = selected,
label = { silenceAfterText(it) },
onSelect = onSelect,
onDismiss = onDismiss,
)
}
@@ -3,6 +3,10 @@ package de.jeanlucmakiola.clockula.ui.settings
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
@@ -11,13 +15,15 @@ import de.jeanlucmakiola.floret.components.CollapsingScaffold
import de.jeanlucmakiola.floret.components.GroupedRow
import de.jeanlucmakiola.floret.components.Position
/** What a new timer starts with: its sound. */
/** What a new timer starts with, its sound; then how long any timer sounds (#17). */
@Composable
internal fun TimerDefaultsScreen(
state: SettingsUiState.Loaded,
viewModel: SettingsViewModel,
onBack: () -> Unit,
) {
var silenceAfterOpen by rememberSaveable { mutableStateOf(false) }
CollapsingScaffold(title = stringResource(R.string.settings_section_timers), onBack = onBack) {
SettingsHint(stringResource(R.string.settings_timer_sound_hint))
Spacer(Modifier.height(8.dp))
@@ -28,5 +34,22 @@ internal fun TimerDefaultsScreen(
position = Position.Alone,
onClick = { viewModel.onOpenRingtonePicker(DefaultRingtoneKind.TIMER) },
)
Spacer(Modifier.height(24.dp))
GroupedRow(
title = stringResource(R.string.settings_silence_after),
summary = silenceAfterText(state.defaults.timerSilenceAfterMinutes),
position = Position.Alone,
onClick = { silenceAfterOpen = true },
)
SettingsHint(stringResource(R.string.settings_timer_silence_after_hint))
}
if (silenceAfterOpen) {
SilenceAfterPicker(
selected = state.defaults.timerSilenceAfterMinutes,
onSelect = { viewModel.onTimerSilenceAfterChanged(it) },
onDismiss = { silenceAfterOpen = false },
)
}
}
+10
View File
@@ -169,6 +169,16 @@
<string name="challenge_math">Solve a sum</string>
<string name="challenge_hold">Press and hold</string>
<!-- #17: how long a ring lasts before it stops on its own -->
<string name="settings_silence_after">Silence after</string>
<string name="silence_after_never">Never</string>
<plurals name="silence_after_minutes">
<item quantity="one">%1$d minute</item>
<item quantity="other">%1$d minutes</item>
</plurals>
<string name="settings_alarm_silence_after_hint">Applies to every alarm. An alarm nobody stops goes quiet after this long and counts as missed. Never still stops after an hour, so a phone left at home can\'t ring until its battery runs out.</string>
<string name="settings_timer_silence_after_hint">Applies to every timer. A finished timer nobody stops goes quiet after this long but stays finished, so you can still add a minute. Never still stops after an hour.</string>
<!-- M5: the ringtone picker -->
<string name="ringtone_picker_title">Alarm sound</string>
<string name="ringtone_silent">Silent</string>
@@ -2,8 +2,8 @@ package de.jeanlucmakiola.clockula.alarm
import app.cash.turbine.test
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.RepeatDays
import de.jeanlucmakiola.clockula.domain.alarm.AlarmRing
import de.jeanlucmakiola.clockula.domain.alarm.DismissOutcome
import de.jeanlucmakiola.clockula.domain.alarm.SnoozeOutcome
import de.jeanlucmakiola.clockula.testing.BERLIN
@@ -246,7 +246,7 @@ class AlarmEngineInteropTest {
harness.givenAlarm(id = 1L, hour = 7, deleteAfterUse = true)
harness.engine.reschedule()
harness.givenRinging(alarmId = 1L, at = sevenToday)
harness.wallClock.instant = sevenToday + AlarmRing.AUTO_SILENCE_AFTER
harness.wallClock.instant = sevenToday + ClockDefaults().alarmSilenceAfter
harness.engine.onAutoSilence(1L)
@@ -10,15 +10,16 @@ import de.jeanlucmakiola.clockula.data.alarms.AlarmStateRepositoryImpl
import de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.clockula.domain.Alarm
import de.jeanlucmakiola.clockula.domain.AlarmDraft
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.RepeatDays
import de.jeanlucmakiola.clockula.domain.TimeOfDay
import de.jeanlucmakiola.clockula.domain.alarm.AlarmRing
import de.jeanlucmakiola.clockula.domain.alarm.AlarmRingState
import de.jeanlucmakiola.clockula.domain.alarm.FireOutcome
import de.jeanlucmakiola.clockula.domain.alarm.FireSource
import de.jeanlucmakiola.clockula.domain.alarm.ScheduleMode
import de.jeanlucmakiola.clockula.domain.alarm.SnoozeOutcome
import de.jeanlucmakiola.clockula.domain.resolveSettings
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.testing.BERLIN
import de.jeanlucmakiola.clockula.testing.FakeAlarmDao
import de.jeanlucmakiola.clockula.testing.FakeAlarmNotifier
@@ -49,6 +50,7 @@ import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.io.TempDir
import java.nio.file.Path
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.seconds
import kotlin.time.Instant
@@ -274,7 +276,7 @@ class AlarmEngineTest {
assertThat(states.state(1L).ringingSince).isEqualTo(sevenToday)
assertThat(states.state(1L).handledOccurrence).isEqualTo(sevenToday)
assertThat(scheduler.autoSilence)
.isEqualTo(Registration(sevenToday + AlarmRing.AUTO_SILENCE_AFTER, 1L))
.isEqualTo(Registration(sevenToday + ClockDefaults().alarmSilenceAfter, 1L))
}
@Test
@@ -680,7 +682,7 @@ class AlarmEngineTest {
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(scheduler.autoSilence)
.isEqualTo(Registration(sevenToday + AlarmRing.AUTO_SILENCE_AFTER, 1L))
.isEqualTo(Registration(sevenToday + ClockDefaults().alarmSilenceAfter, 1L))
}
@Test
@@ -692,7 +694,8 @@ class AlarmEngineTest {
engine.onBootCompleted()
assertThat(ring.events).isEmpty()
// Closing the stale ring stops whatever might still sound; nothing starts.
assertThat(ring.events).containsExactly(RingEvent.Stopped(1L))
assertThat(states.state(1L).ringingSince).isNull()
assertThat(scheduler.next?.fireAt).isEqualTo(sevenTomorrow)
}
@@ -798,6 +801,316 @@ class AlarmEngineTest {
assertThat(scheduler.next).isEqualTo(Registration(sevenToday, 1L))
}
// --- #17: the ring window is the "Silence after" setting ---
@Test
fun `the backstop is armed at the chosen silence-after, not ten minutes`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(25)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + 25.minutes, 1L))
}
@Test
fun `Never arms the backstop at the hard stop`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(SilenceAfter.NEVER)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + SilenceAfter.HARD_STOP, 1L))
}
@Test
fun `a reschedule inside a longer window keeps the ring going`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(25)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 20.minutes
engine.reschedule()
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(states.state(1L).ringingSince).isEqualTo(sevenToday)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + 25.minutes, 1L))
}
@Test
fun `shortening silence-after mid-ring stops a ring already past the new window`(@TempDir dir: Path) =
runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 5.minutes
settings.setAlarmSilenceAfterMinutes(1)
engine.reschedule()
assertThat(ring.ringing.value).isNull()
assertThat(ring.events.last()).isEqualTo(RingEvent.Stopped(1L))
assertThat(states.state(1L).ringingSince).isNull()
assertThat(scheduler.autoSilence).isNull()
assertThat(scheduler.next?.fireAt).isEqualTo(sevenTomorrow)
}
@Test
fun `a ring interrupted by a reboot resumes inside a longer window`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday + 20.minutes
givenRingingAt(alarmId = 1L, occurrence = sevenToday, since = sevenToday)
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(25)
val engine = engineOver(settings)
engine.onBootCompleted()
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + 25.minutes, 1L))
}
@Test
fun `a late snooze is kept for as long as the chosen window`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
val snoozeAt = sevenToday + 9.minutes
states.save(
ringState(snoozedUntil = snoozeAt, snoozeCount = 1, handledOccurrence = sevenToday),
)
wallClock.instant = snoozeAt + 20.minutes
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(25)
val engine = engineOver(settings)
val outcome = engine.onFire(alarmId = 1L, scheduledFor = snoozeAt)
assertThat(outcome).isEqualTo(FireOutcome.Ringing(1L))
}
@Test
fun `upcoming measures a ring against the chosen window`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday + 20.minutes
givenRingingAt(alarmId = 1L, occurrence = sevenToday, since = sevenToday)
val settings = settings(dir)
settings.setAlarmSilenceAfterMinutes(25)
val engine = engineOver(settings)
val entry = engine.upcoming().first().single()
assertThat(entry.source).isEqualTo(FireSource.RESUMED_RING)
}
@Test
fun `raising silence-after mid-ring moves the backstop at once`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 3.minutes
engine.setAlarmSilenceAfter(SilenceAfter.NEVER)
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + SilenceAfter.HARD_STOP, 1L))
}
@Test
fun `lowering silence-after below a ring's age closes it as missed at once`(@TempDir dir: Path) = runTest {
givenAlarm()
wallClock.instant = sevenToday
val settings = settings(dir)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 5.minutes
engine.setAlarmSilenceAfter(1)
assertThat(ring.ringing.value).isNull()
assertThat(states.state(1L).ringingSince).isNull()
assertThat(scheduler.autoSilence).isNull()
// A one-shot alarm's cycle has closed, so it is off, not armed for tomorrow.
assertThat(alarms.find(1L)?.enabled).isFalse()
}
@Test
fun `changing silence-after with nothing ringing touches nothing`(@TempDir dir: Path) = runTest {
givenAlarm()
val settings = settings(dir)
val engine = engineOver(settings)
engine.setAlarmSilenceAfter(1)
assertThat(ring.events).isEmpty()
assertThat(scheduler.autoSilence).isNull()
}
@Test
fun `a one-shot ring missed across a reboot is disabled, not re-armed for tomorrow`(@TempDir dir: Path) =
runTest {
givenAlarm()
wallClock.instant = sevenToday + 40.minutes
givenRingingAt(alarmId = 1L, occurrence = sevenToday, since = sevenToday)
val engine = engine(dir)
engine.onBootCompleted()
assertThat(alarms.find(1L)?.enabled).isFalse()
assertThat(scheduler.next).isNull()
}
@Test
fun `a one-shot alarm displaced by another's fire is switched off`(@TempDir dir: Path) = runTest {
givenAlarm(id = 1L, hour = 7)
val sevenFive = offsetInstant("2026-06-10T07:05+02:00")
givenAlarm(id = 2L, hour = 7, minute = 5, repeatDays = RepeatDays.EVERY_DAY)
givenRingingAt(alarmId = 1L, occurrence = sevenToday, since = sevenToday)
wallClock.instant = sevenFive
val engine = engine(dir)
engine.onFire(alarmId = 2L, scheduledFor = sevenFive)
assertThat(alarms.find(1L)?.enabled).isFalse()
assertThat(ring.ringing.value).isEqualTo(2L)
}
@Test
fun `a stale ring left in storage cannot switch off the alarm that is firing`(@TempDir dir: Path) =
runTest {
givenAlarm()
val yesterday = offsetInstant("2026-06-09T07:00+02:00")
givenRingingAt(alarmId = 1L, occurrence = yesterday, since = yesterday)
wallClock.instant = sevenToday
val engine = engine(dir)
val outcome = engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
assertThat(outcome).isEqualTo(FireOutcome.Ringing(1L))
assertThat(alarms.find(1L)?.enabled).isTrue()
assertThat(states.state(1L).ringingSince).isEqualTo(sevenToday)
}
@Test
fun `a clock moved back mid-ring cannot stretch it past one window`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val settings = settings(dir)
val engine = engineOver(settings)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday - 30.minutes
engine.setAlarmSilenceAfter(5)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday - 30.minutes + 5.minutes, 1L))
}
@Test
fun `a backstop reached with the clock still behind the ring's start closes it`(@TempDir dir: Path) =
runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val engine = engine(dir)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday - 20.minutes
engine.onAutoSilence(1L)
assertThat(ring.ringing.value).isNull()
assertThat(states.state(1L).ringingSince).isNull()
}
@Test
fun `a clock moved back mid-ring re-arms the backstop a window from now`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val engine = engine(dir)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday - 1.hours
engine.onSystemTimeOrZoneChanged()
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(scheduler.autoSilence)
.isEqualTo(Registration(sevenToday - 1.hours + ClockDefaults().alarmSilenceAfter, 1L))
}
@Test
fun `a clock moved forward past the window closes the ring`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val engine = engine(dir)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 1.hours
engine.onSystemTimeOrZoneChanged()
assertThat(ring.ringing.value).isNull()
assertThat(states.state(1L).ringingSince).isNull()
assertThat(scheduler.autoSilence).isNull()
}
@Test
fun `a snooze the resolver drops takes its notification with it`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
states.save(
ringState(snoozedUntil = sevenToday + 9.minutes, snoozeCount = 1, handledOccurrence = sevenToday),
)
wallClock.instant = sevenToday + 2.hours
val engine = engine(dir)
engine.reschedule()
assertThat(notifier.cleared).contains(1L)
}
@Test
fun `a clock moved back re-anchors the ring once, so toggling the setting buys nothing`(
@TempDir dir: Path,
) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val engine = engine(dir)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
val moved = sevenToday - 1.hours
wallClock.instant = moved
engine.onSystemTimeOrZoneChanged()
wallClock.instant = moved + 4.minutes
engine.setAlarmSilenceAfter(25)
engine.setAlarmSilenceAfter(5)
assertThat(states.state(1L).ringingSince).isEqualTo(moved)
assertThat(scheduler.autoSilence).isEqualTo(Registration(moved + 5.minutes, 1L))
}
@Test
fun `a backstop queued behind a raised window does not end the ring`(@TempDir dir: Path) = runTest {
givenAlarm(repeatDays = RepeatDays.EVERY_DAY)
wallClock.instant = sevenToday
val engine = engine(dir)
engine.setAlarmSilenceAfter(5)
engine.onFire(alarmId = 1L, scheduledFor = sevenToday)
wallClock.instant = sevenToday + 5.minutes
engine.setAlarmSilenceAfter(25)
engine.onAutoSilence(1L)
assertThat(ring.ringing.value).isEqualTo(1L)
assertThat(scheduler.autoSilence).isEqualTo(Registration(sevenToday + 25.minutes, 1L))
}
// --- upcoming() ---
@Test
@@ -886,7 +1199,7 @@ class AlarmEngineTest {
assertThat(ring.ringing.value).isEqualTo(2L)
assertThat(states.state(2L).ringingSince).isEqualTo(eightToday)
assertThat(scheduler.autoSilence)
.isEqualTo(Registration(eightToday + AlarmRing.AUTO_SILENCE_AFTER, 2L))
.isEqualTo(Registration(eightToday + ClockDefaults().alarmSilenceAfter, 2L))
assertThat(states.state(1L).snoozedUntil).isNull()
assertThat(notifier.cleared).contains(1L)
}
@@ -12,6 +12,7 @@ import de.jeanlucmakiola.clockula.domain.backup.BackupTimer
import de.jeanlucmakiola.clockula.domain.backup.BackupWorldClock
import de.jeanlucmakiola.clockula.domain.bedtime.BedtimeEffects
import de.jeanlucmakiola.clockula.domain.bedtime.BedtimeSettings
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.domain.timer.TimerPresets
import de.jeanlucmakiola.floret.prefs.ThemeMode
import org.junit.jupiter.api.Test
@@ -62,6 +63,8 @@ class BackupCodecTest {
timerRingtoneUri = "content://media/2",
dismissChallenge = DismissChallenge.HOLD,
homeZoneId = "America/New_York",
alarmSilenceAfterMinutes = 25,
timerSilenceAfterMinutes = SilenceAfter.NEVER,
),
timerPresets = listOf(1.minutes, 2.minutes, 10.minutes),
bedtime = BedtimeSettings(
@@ -299,6 +302,20 @@ class BackupCodecTest {
assertThat(bedtime.reminderMinutes).isEqualTo(120)
}
@Test
fun `a file from before silence after keeps the ten minutes it was made with`() {
val defaults = (BackupCodec.decode(minimalDocument()) as BackupResult.Success).content.settings.defaults
assertThat(defaults.alarmSilenceAfterMinutes).isEqualTo(10)
assertThat(defaults.timerSilenceAfterMinutes).isEqualTo(10)
}
@Test
fun `silence after is written under its documented keys`() {
val json = BackupCodec.encode(sampleContent())
assertThat(json).contains("\"default_alarm_silence_after_minutes\": 25")
assertThat(json).contains("\"default_timer_silence_after_minutes\": 0")
}
@Test
fun `an empty preset list is honoured as all removed`() {
val json = minimalDocument().replace("\"settings\": {}", "\"settings\": {\"timer_presets\": []}")
@@ -9,6 +9,7 @@ import app.cash.turbine.test
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.DismissChallenge
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.floret.prefs.PrefStore
import de.jeanlucmakiola.floret.prefs.ThemeMode
import kotlinx.coroutines.CoroutineScope
@@ -53,6 +54,8 @@ class ClockPrefsTest {
prefs.setTimerRingtoneUri("content://t")
prefs.setDismissChallenge(DismissChallenge.HOLD)
prefs.setHomeZoneId("Europe/Berlin")
prefs.setAlarmSilenceAfterMinutes(25)
prefs.setTimerSilenceAfterMinutes(SilenceAfter.NEVER)
assertThat(prefs.defaults.first()).isEqualTo(
ClockDefaults(
@@ -64,6 +67,8 @@ class ClockPrefsTest {
timerRingtoneUri = "content://t",
dismissChallenge = DismissChallenge.HOLD,
homeZoneId = "Europe/Berlin",
alarmSilenceAfterMinutes = 25,
timerSilenceAfterMinutes = SilenceAfter.NEVER,
),
)
}
@@ -148,4 +153,21 @@ class ClockPrefsTest {
cancel()
}
}
@Test
fun `silence after clamps on write and on read`(@TempDir tempDir: Path) = runTest {
val dataStore = newDataStore(tempDir)
val prefs = SettingsPrefs(PrefStore(dataStore))
prefs.setAlarmSilenceAfterMinutes(999)
prefs.setTimerSilenceAfterMinutes(-3)
assertThat(prefs.defaults.first().alarmSilenceAfterMinutes).isEqualTo(SilenceAfter.NEVER)
assertThat(prefs.defaults.first().timerSilenceAfterMinutes).isEqualTo(SilenceAfter.DEFAULT_MINUTES)
dataStore.updateData { stored ->
stored.toMutablePreferences()
.apply { this[intPreferencesKey("default_alarm_silence_after_minutes")] = 5_000 }
}
assertThat(prefs.defaults.first().alarmSilenceAfter).isEqualTo(SilenceAfter.HARD_STOP)
}
}
@@ -11,6 +11,7 @@ import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.RepeatDays
import de.jeanlucmakiola.clockula.domain.TimeOfDay
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.domain.backup.BackupSettings
import de.jeanlucmakiola.clockula.domain.bedtime.BedtimeEffects
import de.jeanlucmakiola.clockula.domain.bedtime.BedtimeSettings
@@ -80,7 +81,13 @@ class SettingsPrefsTest {
BackupSettings(
themeMode = ThemeMode.DARK,
dynamicColor = false,
defaults = ClockDefaults(snoozeMinutes = 99, volumeRampSeconds = 99, alarmRingtoneUri = " "),
defaults = ClockDefaults(
snoozeMinutes = 99,
volumeRampSeconds = 99,
alarmRingtoneUri = " ",
alarmSilenceAfterMinutes = 25,
timerSilenceAfterMinutes = 999,
),
timerPresets = listOf(5.minutes, 1.minutes, 5.minutes),
),
)
@@ -90,6 +97,8 @@ class SettingsPrefsTest {
assertThat(prefs.currentDefaults().snoozeMinutes).isEqualTo(60)
assertThat(prefs.currentDefaults().volumeRampSeconds).isEqualTo(60)
assertThat(prefs.currentDefaults().alarmRingtoneUri).isNull()
assertThat(prefs.currentDefaults().alarmSilenceAfterMinutes).isEqualTo(25)
assertThat(prefs.currentDefaults().timerSilenceAfterMinutes).isEqualTo(SilenceAfter.NEVER)
assertThat(prefs.timerPresets.first()).containsExactly(1.minutes, 5.minutes).inOrder()
}
@@ -2,7 +2,9 @@ package de.jeanlucmakiola.clockula.domain.alarm
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.Alarm
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.RepeatDays
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.testing.BERLIN
import de.jeanlucmakiola.clockula.testing.alarmAt
import de.jeanlucmakiola.clockula.testing.instantAt
@@ -28,8 +30,9 @@ class AlarmResolverTest {
state: AlarmRingState = ringState(alarmId = alarm.id),
now: Instant = morning,
fireGrace: Duration = AlarmRing.FIRE_GRACE,
silenceAfter: Duration = ClockDefaults().alarmSilenceAfter,
): AlarmResolution =
AlarmResolver.resolve(alarm, state, now, BERLIN, AlarmRing.AUTO_SILENCE_AFTER, fireGrace)
AlarmResolver.resolve(alarm, state, now, BERLIN, silenceAfter, fireGrace)
// --- T32–T34: the disabled and plain cases ---
@@ -158,7 +161,7 @@ class AlarmResolverTest {
@Test
fun `a ring exactly as old as the auto-silence window has timed out`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val state = ringState(ringingSince = morning - AlarmRing.AUTO_SILENCE_AFTER)
val state = ringState(ringingSince = morning - ClockDefaults().alarmSilenceAfter)
val resolution = resolve(alarm, state)
@@ -374,4 +377,88 @@ class AlarmResolverTest {
assertThat(resolve(alarm, state)).isEqualTo(first)
assertThat(state).isEqualTo(copy)
}
// --- #17: the window is the "Silence after" setting ---
@Test
fun `a longer window keeps a ring going past the default's ten minutes`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val state = ringState(ringingSince = morning - 20.minutes)
val resolution = resolve(alarm, state, silenceAfter = SilenceAfter.window(25))
assertThat(resolution.source).isEqualTo(FireSource.RESUMED_RING)
assertThat(resolution.state).isEqualTo(state)
}
@Test
fun `a shorter window closes a ring the default would still keep`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val state = ringState(ringingSince = morning - 2.minutes)
val resolution = resolve(alarm, state, silenceAfter = SilenceAfter.window(1))
assertThat(resolution.source).isEqualTo(FireSource.OCCURRENCE)
assertThat(resolution.state.ringingSince).isNull()
}
@Test
fun `Never still closes a ring at the hard stop`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val never = SilenceAfter.window(SilenceAfter.NEVER)
val ringing = resolve(alarm, ringState(ringingSince = morning - 59.minutes), silenceAfter = never)
val stopped = resolve(alarm, ringState(ringingSince = morning - 1.hours), silenceAfter = never)
assertThat(ringing.source).isEqualTo(FireSource.RESUMED_RING)
assertThat(stopped.state.ringingSince).isNull()
}
@Test
fun `a late snooze is kept for as long as the window the user chose`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val snoozedUntil = morning - 20.minutes
val state = ringState(snoozedUntil = snoozedUntil, snoozeCount = 1)
val kept = resolve(alarm, state, silenceAfter = SilenceAfter.window(25))
val dropped = resolve(alarm, state, silenceAfter = SilenceAfter.window(15))
assertThat(kept.nextFire to kept.source).isEqualTo(snoozedUntil to FireSource.SNOOZE)
assertThat(dropped.state.snoozedUntil).isNull()
}
@Test
fun `a one-shot ring closed as missed disables the alarm rather than ringing tomorrow`() {
val alarm = alarmAt(hour = 7)
val state = ringState(ringingSince = morning - 2.minutes, handledOccurrence = morning - 2.minutes)
val resolution = resolve(alarm, state, silenceAfter = SilenceAfter.window(1))
assertThat(resolution.disableAlarm).isTrue()
assertThat(resolution.nextFire).isNull()
assertThat(resolution.state.ringingSince).isNull()
}
@Test
fun `a one-shot snooze that never fired disables the alarm rather than ringing tomorrow`() {
val alarm = alarmAt(hour = 7)
val state = ringState(snoozedUntil = morning - 11.minutes, snoozeCount = 1)
val resolution = resolve(alarm, state)
assertThat(resolution.disableAlarm).isTrue()
assertThat(resolution.nextFire).isNull()
assertThat(resolution.state.snoozedUntil).isNull()
}
@Test
fun `a short window never makes a late snooze easier to lose than v1's ten minutes`() {
val alarm = alarmAt(hour = 7, repeatDays = RepeatDays.EVERY_DAY)
val snoozedUntil = morning - 8.minutes
val state = ringState(snoozedUntil = snoozedUntil, snoozeCount = 1)
val resolution = resolve(alarm, state, silenceAfter = SilenceAfter.window(1))
assertThat(resolution.nextFire to resolution.source).isEqualTo(snoozedUntil to FireSource.SNOOZE)
}
}
@@ -0,0 +1,55 @@
package de.jeanlucmakiola.clockula.domain.ring
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import org.junit.jupiter.api.Test
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes
/** #17: what a stored "Silence after" value means to the two engines. */
class SilenceAfterTest {
@Test
fun `the default is v1's fixed ten minutes, for alarms and timers alike`() {
val defaults = ClockDefaults()
assertThat(defaults.alarmSilenceAfter).isEqualTo(10.minutes)
assertThat(defaults.timerSilenceAfter).isEqualTo(10.minutes)
}
@Test
fun `a stored value is that many minutes`() {
assertThat(SilenceAfter.window(1)).isEqualTo(1.minutes)
assertThat(SilenceAfter.window(25)).isEqualTo(25.minutes)
}
@Test
fun `Never is the hard stop, an hour`() {
assertThat(SilenceAfter.window(SilenceAfter.NEVER)).isEqualTo(SilenceAfter.HARD_STOP)
assertThat(SilenceAfter.HARD_STOP).isEqualTo(1.hours)
assertThat(SilenceAfter.WAKE_LOCK_TIMEOUT).isGreaterThan(SilenceAfter.HARD_STOP)
}
@Test
fun `no value reaches the engines as a window longer than the hard stop`() {
assertThat(SilenceAfter.window(24 * 60)).isEqualTo(SilenceAfter.HARD_STOP)
}
@Test
fun `a negative value is the default, not Never`() {
assertThat(SilenceAfter.sanitise(-1)).isEqualTo(SilenceAfter.DEFAULT_MINUTES)
assertThat(SilenceAfter.window(-5)).isEqualTo(10.minutes)
}
@Test
fun `every choice is in range, and the hard stop outlasts every finite one`() {
assertThat(SilenceAfter.CHOICES).contains(SilenceAfter.DEFAULT_MINUTES)
assertThat(SilenceAfter.CHOICES).contains(SilenceAfter.NEVER)
SilenceAfter.CHOICES.forEach { minutes ->
assertThat(minutes).isIn(SilenceAfter.MINUTES)
assertThat(SilenceAfter.window(minutes)).isAtMost(SilenceAfter.HARD_STOP)
}
assertThat(SilenceAfter.CHOICES.filter { it != SilenceAfter.NEVER }.max().minutes)
.isLessThan(SilenceAfter.HARD_STOP)
}
}
@@ -3,6 +3,7 @@ package de.jeanlucmakiola.clockula.domain.timer
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.Ringtones
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.testing.T0
import de.jeanlucmakiola.clockula.testing.expiredTimer
import org.junit.jupiter.api.Test
@@ -154,7 +155,8 @@ class TimerRingPolicyTest {
TimerRingDecision.Sound(
subjectId = 7L,
settings = released.sound().settings,
silenceAt = now + TimerRing.AUTO_SILENCE_AFTER,
silenceAt = now + ClockDefaults().timerSilenceAfter,
openedAt = now,
),
soundingSince = now,
),
@@ -174,18 +176,20 @@ class TimerRingPolicyTest {
/** §5.4 #14 */
@Test
fun `a session that has run its window auto-silences`() {
val opened = now - TimerRing.AUTO_SILENCE_AFTER
val opened = now - ClockDefaults().timerSilenceAfter
val outcome = decide(soundingSince = opened)
assertThat(outcome)
.isEqualTo(TimerRingOutcome(TimerRingDecision.AutoSilenced(7L), soundingSince = opened))
// The anchor moves back past the longest window, so the session stays run out (#17).
assertThat(outcome).isEqualTo(
TimerRingOutcome(TimerRingDecision.AutoSilenced(7L), soundingSince = now - SilenceAfter.HARD_STOP),
)
}
/** §5.4 #15 */
@Test
fun `auto-silence is decided before suppression`() {
val opened = now - TimerRing.AUTO_SILENCE_AFTER
val opened = now - ClockDefaults().timerSilenceAfter
val outcome = decide(alarmIsRinging = true, soundingSince = opened)
@@ -195,19 +199,20 @@ class TimerRingPolicyTest {
/** §5.4 #16 */
@Test
fun `an auto-silenced session does not restart a minute later`() {
val opened = now - TimerRing.AUTO_SILENCE_AFTER
val silenced = decide(soundingSince = now - ClockDefaults().timerSilenceAfter)
val outcome = decide(soundingSince = opened, at = now + 1.minutes)
val outcome = decide(soundingSince = silenced.soundingSince, at = now + 1.minutes)
assertThat(outcome)
.isEqualTo(TimerRingOutcome(TimerRingDecision.AutoSilenced(7L), soundingSince = opened))
assertThat(outcome).isEqualTo(
TimerRingOutcome(TimerRingDecision.AutoSilenced(7L), soundingSince = silenced.soundingSince),
)
}
/** §5.4 #17 */
@Test
fun `resetting the last expired timer closes an auto-silenced session`() {
val outcome =
decide(expired = emptyList(), soundingSince = now - TimerRing.AUTO_SILENCE_AFTER)
decide(expired = emptyList(), soundingSince = now - ClockDefaults().timerSilenceAfter)
assertThat(outcome).isEqualTo(TimerRingOutcome(TimerRingDecision.Silent, soundingSince = null))
}
@@ -227,7 +232,7 @@ class TimerRingPolicyTest {
fun `the window closes ten minutes after the audio opened`() {
val outcome = decide()
assertThat(outcome.sound().silenceAt).isEqualTo(now + TimerRing.AUTO_SILENCE_AFTER)
assertThat(outcome.sound().silenceAt).isEqualTo(now + ClockDefaults().timerSilenceAfter)
}
/** §5.4 #20 */
@@ -242,4 +247,59 @@ class TimerRingPolicyTest {
assertThat(outcome.sound().subjectId).isEqualTo(9L)
}
// --- #17: the window is the timer's own "Silence after" setting ---
@Test
fun `the window is the timer setting, not the alarm's`() {
val custom = defaults.copy(timerSilenceAfterMinutes = 25, alarmSilenceAfterMinutes = 1)
val outcome = decide(defaults = custom)
assertThat(outcome.sound().silenceAt).isEqualTo(now + 25.minutes)
}
@Test
fun `a shorter window auto-silences a session the default would keep`() {
val custom = defaults.copy(timerSilenceAfterMinutes = 1)
val outcome = decide(defaults = custom, soundingSince = now - 1.minutes)
assertThat(outcome.decision).isEqualTo(TimerRingDecision.AutoSilenced(7L))
}
@Test
fun `Never sounds up to the hard stop and no further`() {
val never = defaults.copy(timerSilenceAfterMinutes = SilenceAfter.NEVER)
val sounding = decide(defaults = never, soundingSince = now - 59.minutes)
val silenced = decide(defaults = never, soundingSince = now - SilenceAfter.HARD_STOP)
assertThat(sounding.sound().silenceAt).isEqualTo(now - 59.minutes + SilenceAfter.HARD_STOP)
assertThat(silenced.decision).isEqualTo(TimerRingDecision.AutoSilenced(7L))
}
@Test
fun `raising silence-after does not restart a session that already went quiet`() {
val short = defaults.copy(timerSilenceAfterMinutes = 1)
val silenced = decide(defaults = short, soundingSince = now - 1.minutes)
val raised = decide(
defaults = defaults.copy(timerSilenceAfterMinutes = SilenceAfter.NEVER),
soundingSince = silenced.soundingSince,
at = now + 4.minutes,
)
assertThat(raised.decision).isEqualTo(TimerRingDecision.AutoSilenced(7L))
}
@Test
fun `changing silence-after mid-session moves the window but not the session`() {
val opened = now - 2.minutes
val sound = decide(defaults = defaults.copy(timerSilenceAfterMinutes = 25), soundingSince = opened).sound()
assertThat(sound.openedAt).isEqualTo(opened)
assertThat(sound.silenceAt).isEqualTo(opened + 25.minutes)
}
}
@@ -1,10 +1,10 @@
package de.jeanlucmakiola.clockula.timer
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.TimerState
import de.jeanlucmakiola.clockula.domain.time.BootId
import de.jeanlucmakiola.clockula.domain.timer.TimerNotificationAction
import de.jeanlucmakiola.clockula.domain.timer.TimerRing
import de.jeanlucmakiola.clockula.domain.timer.TimerRingDecision
import de.jeanlucmakiola.clockula.testing.T0
import de.jeanlucmakiola.clockula.testing.TimerEngineHarness
@@ -497,7 +497,39 @@ class TimerEngineTest {
val state = harness.engine.serviceState(alreadyAlerted = false)
assertThat(state.silenceIn).isEqualTo(TimerRing.AUTO_SILENCE_AFTER - 30.seconds)
assertThat(state.silenceIn).isEqualTo(ClockDefaults().timerSilenceAfter - 30.seconds)
}
/** #17 */
@Test
fun `raising silence-after keeps a session that lapsed unseen silent`(
@TempDir tempDir: Path,
) = runTest {
val harness = timerEngineHarness(tempDir)
harness.settings.setTimerSilenceAfterMinutes(1)
harness.given(expiredTimer(id = 1L))
// The session opened ten minutes ago and no pass ran when its window ended.
harness.ringState.set(T0 - 10.minutes)
harness.engine.setTimerSilenceAfter(25)
val state = harness.engine.serviceState(alreadyAlerted = true)
assertThat(state.ring).isInstanceOf(TimerRingDecision.AutoSilenced::class.java)
}
/** #17 */
@Test
fun `the ring session's window is the timer's silence-after setting`(
@TempDir tempDir: Path,
) = runTest {
val harness = timerEngineHarness(tempDir)
harness.settings.setTimerSilenceAfterMinutes(25)
harness.given(expiredTimer(id = 1L))
harness.ringState.set(T0 - 30.seconds)
val state = harness.engine.serviceState(alreadyAlerted = false)
assertThat(state.silenceIn).isEqualTo(25.minutes - 30.seconds)
}
/** §5.8 #31 */
@@ -688,7 +720,7 @@ class TimerEngineTest {
harness.engine.onExpiryDue()
// The first timer sounds, and is then left alone until the window lapses.
harness.engine.serviceState(alreadyAlerted = false)
harness.advance(TimerRing.AUTO_SILENCE_AFTER)
harness.advance(ClockDefaults().timerSilenceAfter)
val lapsed = harness.engine.serviceState(alreadyAlerted = true)
harness.engine.start(2L)
@@ -699,7 +731,7 @@ class TimerEngineTest {
assertThat(lapsed.ring).isInstanceOf(TimerRingDecision.AutoSilenced::class.java)
assertThat(second.ring).isInstanceOf(TimerRingDecision.Sound::class.java)
assertThat((second.ring as TimerRingDecision.Sound).silenceAt)
.isEqualTo(harness.wallClock.instant + TimerRing.AUTO_SILENCE_AFTER)
.isEqualTo(harness.wallClock.instant + ClockDefaults().timerSilenceAfter)
}
/** §5.8 #42 — added with the review fix for finding 2. */
@@ -1,8 +1,8 @@
package de.jeanlucmakiola.clockula.ui.ring
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.domain.ClockDefaults
import de.jeanlucmakiola.clockula.domain.TimerState
import de.jeanlucmakiola.clockula.domain.timer.TimerRing
import de.jeanlucmakiola.clockula.testing.MainDispatcherExtension
import de.jeanlucmakiola.clockula.testing.T0
import de.jeanlucmakiola.clockula.testing.TimerEngineHarness
@@ -35,6 +35,7 @@ class TimerRingViewModelTest {
private fun TestScope.viewModel(harness: TimerEngineHarness) = TimerRingViewModel(
timers = harness.timers,
ringState = harness.ringState,
settings = harness.settings,
engine = harness.engine,
elapsed = harness.elapsed,
wall = harness.wallClock,
@@ -124,11 +125,29 @@ class TimerRingViewModelTest {
advanceUntilIdle()
assertThat(viewModel.state.value).isInstanceOf(TimerRingUiState.Ringing::class.java)
harness.wallClock.advance(TimerRing.AUTO_SILENCE_AFTER + 1.seconds)
harness.wallClock.advance(ClockDefaults().timerSilenceAfter + 1.seconds)
harness.ticker.tick()
advanceUntilIdle()
assertThat(harness.stored(1L)!!.state).isEqualTo(TimerState.EXPIRED)
assertThat(viewModel.state.value).isEqualTo(TimerRingUiState.Finished)
}
@Test
fun `the screen follows the timer's own silence-after setting`(@TempDir tempDir: Path) =
runTest(main.dispatcher) {
val harness = timerEngineHarness(tempDir)
harness.settings.setTimerSilenceAfterMinutes(1)
harness.given(expiredTimer(id = 1L))
harness.ringState.set(T0)
val viewModel = viewModel(harness)
advanceUntilIdle()
assertThat(viewModel.state.value).isInstanceOf(TimerRingUiState.Ringing::class.java)
harness.wallClock.advance(1.minutes + 1.seconds)
harness.ticker.tick()
advanceUntilIdle()
assertThat(viewModel.state.value).isEqualTo(TimerRingUiState.Finished)
}
}
@@ -1,13 +1,44 @@
package de.jeanlucmakiola.clockula.ui.settings
import com.google.common.truth.Truth.assertThat
import de.jeanlucmakiola.clockula.alarm.AlarmEngine
import de.jeanlucmakiola.clockula.data.alarms.AlarmMapper
import de.jeanlucmakiola.clockula.data.alarms.AlarmRepositoryImpl
import de.jeanlucmakiola.clockula.data.alarms.AlarmStateRepositoryImpl
import de.jeanlucmakiola.clockula.data.appicon.LauncherIcon
import de.jeanlucmakiola.clockula.data.prefs.BootStateStore
import de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs
import de.jeanlucmakiola.clockula.data.timers.TimerRepositoryImpl
import de.jeanlucmakiola.clockula.data.timers.TimerRingStateStore
import de.jeanlucmakiola.clockula.domain.DismissChallenge
import de.jeanlucmakiola.clockula.domain.RepeatDays
import de.jeanlucmakiola.clockula.domain.ring.SilenceAfter
import de.jeanlucmakiola.clockula.testing.BERLIN
import de.jeanlucmakiola.clockula.testing.FakeAlarmDao
import de.jeanlucmakiola.clockula.testing.FakeAlarmNotifier
import de.jeanlucmakiola.clockula.testing.FakeAlarmScheduler
import de.jeanlucmakiola.clockula.testing.FakeAlarmStateDao
import de.jeanlucmakiola.clockula.testing.FakeAlarmRingStatus
import de.jeanlucmakiola.clockula.testing.FakeBootIdProvider
import de.jeanlucmakiola.clockula.testing.FakeDeviceStateReader
import de.jeanlucmakiola.clockula.testing.FakeElapsedRealtimeClock
import de.jeanlucmakiola.clockula.testing.FakeLauncherIconManager
import de.jeanlucmakiola.clockula.testing.FakeRingtoneCatalog
import de.jeanlucmakiola.clockula.testing.FakeRingCoordinator
import de.jeanlucmakiola.clockula.testing.FakeRingtonePreviewer
import de.jeanlucmakiola.clockula.testing.FakeTimerDao
import de.jeanlucmakiola.clockula.testing.FakeTimerScheduler
import de.jeanlucmakiola.clockula.testing.FakeTimerServiceHandle
import de.jeanlucmakiola.clockula.testing.FakeWallClock
import de.jeanlucmakiola.clockula.testing.FakeZoneProvider
import de.jeanlucmakiola.clockula.testing.MainDispatcherExtension
import de.jeanlucmakiola.clockula.testing.alarmAt
import de.jeanlucmakiola.clockula.testing.RecordingRebootRepair
import de.jeanlucmakiola.clockula.testing.RecordingStopwatchRepository
import de.jeanlucmakiola.clockula.system.RebootRepair
import de.jeanlucmakiola.clockula.timer.TimerEngine
import de.jeanlucmakiola.floret.prefs.PrefStore
import de.jeanlucmakiola.clockula.testing.instantAt
import de.jeanlucmakiola.clockula.testing.worldClockHarness
import de.jeanlucmakiola.floret.prefs.ThemeMode
import kotlinx.coroutines.Dispatchers
@@ -21,6 +52,8 @@ import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.api.io.TempDir
import java.nio.file.Path
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.seconds
/**
* The real [SettingsViewModel] over the real [de.jeanlucmakiola.clockula.data.prefs.SettingsPrefs]
@@ -35,13 +68,56 @@ class SettingsViewModelTest {
@RegisterExtension
val main = MainDispatcherExtension()
// The alarm engine "Silence after" re-measures a ring through, over fakes.
private val alarmDao = FakeAlarmDao()
private val stateDao = FakeAlarmStateDao(alarms = alarmDao)
private val wallClock = FakeWallClock(instantAt(BERLIN, "2026-06-10T07:00"))
private val alarmScheduler = FakeAlarmScheduler()
private val ring = FakeRingCoordinator()
private lateinit var alarmEngine: AlarmEngine
/** The timer engine "Silence after" writes through, over fakes and the harness's own store. */
private fun timerEngine(settings: SettingsPrefs, store: PrefStore): TimerEngine {
val elapsed = FakeElapsedRealtimeClock(1_000.seconds)
val timers = TimerRepositoryImpl(FakeTimerDao(), elapsed, wallClock)
return TimerEngine(
timers = timers,
settings = settings,
ringState = TimerRingStateStore(store),
scheduler = FakeTimerScheduler(),
service = FakeTimerServiceHandle(),
alarmRing = FakeAlarmRingStatus(),
rebootRepair = RebootRepair(
bootIds = FakeBootIdProvider(),
bootState = BootStateStore(store),
timers = timers,
stopwatch = RecordingStopwatchRepository(),
),
elapsed = elapsed,
wall = wallClock,
)
}
private fun TestScope.newViewModel(
tempDir: Path,
launcherIcons: FakeLauncherIconManager = FakeLauncherIconManager(),
): SettingsViewModel {
val harness = worldClockHarness(tempDir)
alarmEngine = AlarmEngine(
alarms = AlarmRepositoryImpl(alarmDao, wallClock),
states = AlarmStateRepositoryImpl(stateDao),
settings = harness.settings,
scheduler = alarmScheduler,
ring = ring,
notifier = FakeAlarmNotifier(),
rebootRepair = RecordingRebootRepair(),
wallClock = wallClock,
zones = FakeZoneProvider(BERLIN),
)
return SettingsViewModel(
settings = harness.settings,
alarmEngine = alarmEngine,
timerEngine = timerEngine(harness.settings, harness.store),
ringtones = FakeRingtoneCatalog(),
preview = FakeRingtonePreviewer(),
worldClocks = harness.source,
@@ -119,6 +195,8 @@ class SettingsViewModelTest {
viewModel.onSnoozeLimitChanged(2)
viewModel.onVolumeRampChanged(30)
viewModel.onDismissChallengeChanged(DismissChallenge.MATH)
viewModel.onAlarmSilenceAfterChanged(25)
viewModel.onTimerSilenceAfterChanged(SilenceAfter.NEVER)
advanceUntilIdle()
val defaults = (viewModel.state.value as SettingsUiState.Loaded).defaults
@@ -127,8 +205,24 @@ class SettingsViewModelTest {
assertThat(defaults.snoozeLimit).isEqualTo(2)
assertThat(defaults.volumeRampSeconds).isEqualTo(30)
assertThat(defaults.dismissChallenge).isEqualTo(DismissChallenge.MATH)
assertThat(defaults.alarmSilenceAfterMinutes).isEqualTo(25)
assertThat(defaults.timerSilenceAfterMinutes).isEqualTo(SilenceAfter.NEVER)
}
@Test
fun `changing the alarm silence-after re-measures a ring in progress`(@TempDir tempDir: Path) =
runTest(main.dispatcher) {
val viewModel = collecting(newViewModel(tempDir))
alarmDao.insert(AlarmMapper.toEntity(alarmAt(id = 1L, hour = 7, repeatDays = RepeatDays.EVERY_DAY)))
alarmEngine.onFire(alarmId = 1L, scheduledFor = wallClock.instant)
advanceUntilIdle()
viewModel.onAlarmSilenceAfterChanged(25)
advanceUntilIdle()
assertThat(alarmScheduler.autoSilence?.fireAt).isEqualTo(wallClock.instant + 25.minutes)
}
@Test
fun `choosing a default alarm ringtone writes through and closes the picker`(@TempDir tempDir: Path) =
runTest(main.dispatcher) {
+76 -13
View File
@@ -1057,14 +1057,14 @@ M10 adds no `<uses-permission>`.
| Not here | Milestone |
|---|---|
| Reordering alarms by hand. The list is ordered by time of day (§13) and `alarms` has no `sort_order` column, so this would be a schema change for a preference the time order already answers | not planned for v1 |
| A per-alarm auto-silence duration. Every other per-alarm setting became an override picker in M5; this one is still global and still `AlarmRing.AUTO_SILENCE_AFTER` | not planned for v1 |
| A per-alarm auto-silence duration. Every other per-alarm setting became an override picker in M5; "Silence after" (#17) is an app-wide setting only, because an override would need a new `alarms` column, a migration and an editor row for a value almost nobody sets per alarm | not planned |
| Voice-interaction follow-on flows: `Activity.isVoiceInteraction`, `VoiceInteractor.CompleteVoiceRequest` (publishing a deeplink to the alarm just created) and `PickOptionRequest` (disambiguating by voice). `android.intent.category.VOICE` is therefore not declared: advertising it while answering with a touch dialog would be a promise the app does not keep. Clockula *accepts* a `clockula://` deeplink and publishes none | not planned for v1 |
| A "most closely matched" time search for `DISMISS_ALARM`. `ALARM_SEARCH_MODE_TIME` matches **exactly**: dismissing an alarm the caller did not name is a missed alarm, and there is no distance at which that becomes a good trade | not planned for v1 |
| A toast or any other confirmation on a `SKIP_UI` write. `SKIP_UI` means "bypass any intermediate UI", a voice assistant speaks its own confirmation, and the status-bar alarm icon `setAlarmClock` lights is the platform's own receipt (§17) | not planned for v1 |
| Surfacing `delete_after_use` in either editor. It is a property the contract sets, not a setting; an alarm the user edits keeps it, and that consequence is documented (§17) rather than papered over with a checkbox | not planned for v1 |
| Carrying `EXTRA_MESSAGE` into the timer setup panel when no length was given. There is no row to carry it on and the panel has no label field | not planned for v1 |
| Verifying a ringtone URI at the intent boundary. M5 locked "an unreadable sound is reported, never rewritten"; an unmounted card comes back, and the boundary opens no `ContentResolver` | not planned for v1 |
| A user-configurable auto-silence duration, an unlimited-snooze option, per-alarm auto-silence | not planned for v1 |
| An unlimited-snooze option, per-alarm auto-silence | not planned for v1 |
| Reordering timers by hand. `sort_order` and `TimerRepository.reorder` exist and stay caller-less: the list is in storage order, M5 gave the same answer for alarms, and a drag surface would also mean abandoning the `LazyColumn` | not planned for v1 |
| Per-timer vibrate, volume-ramp or dismiss-challenge overrides. `timers` has exactly one nullable settings column, its ringtone; four more would be a schema change for settings the roadmap does not ask for | not planned for v1 |
| A "stop all" for several expired timers, and undo after a timer delete. Each expired timer is acknowledged on its own, and the delete confirmation asks before rather than after | not planned for v1 |
@@ -1150,7 +1150,7 @@ repair, resume and reschedule one by one, so its whole pass is inside the lock.
1. **Disabled** ⇒ clear the snooze, the ring and the skip watermark; keep
`handled_occurrence`, because re-enabling must not un-suppress a dismissal.
2. **Ringing** within `AUTO_SILENCE_AFTER` ⇒ `RESUMED_RING`, nothing scheduled:
2. **Ringing** within the "Silence after" window ⇒ `RESUMED_RING`, nothing scheduled:
it is not an alarm to come, it is one that is happening. A clock moved
*backwards* under a ringing alarm reads as a negative age, which is inside the
window, so it keeps ringing. Beyond the window it is auto-dismissed as
@@ -1165,8 +1165,55 @@ repair, resume and reschedule one by one, so its whole pass is inside the lock.
### The ring cycle
A cycle opens when the alarm fires and closes on dismiss, on the snooze limit
being reached, or on auto-silence after `AUTO_SILENCE_AFTER` = **10 minutes**
(AOSP DeskClock's default; not user-configurable in v1). Snoozing keeps it open.
being reached, or on auto-silence after the **"Silence after"** window. That is
a setting since #17 (Settings › Alarms: 1, 5, 10, 15, 20 or 25 minutes, or
Never), **10 minutes** by default, AOSP DeskClock's default and v1's fixed
value, so an upgrade changes nothing. Snoozing keeps it open.
The window is read from `ClockDefaults.alarmSilenceAfter` everywhere a ring is
measured: the resolver's ringing check, the backstop `onFire` arms, and whether
a ring interrupted by a reboot is resumed. `AlarmResolver.resolve` takes it
without a default, so no caller can measure against a window the user did not
choose. How late a snooze may come due and still ring is the window **or
`AlarmRing.SNOOZE_GRACE` (v1's ten minutes), whichever is longer**: a short
"Silence after" must not make a promised snooze easier to lose to a reboot.
**"Never" is an hour.** The backstop is also what stops a phone left at home
from ringing until its battery is flat, what bounds the ring services' wake
locks, and what keeps a reboot hours later from resuming a ring nobody was
there for. So "Never" maps to `SilenceAfter.HARD_STOP` (60 minutes), longer
than any finite choice, and the settings hint says so in words. Stored values
go through `SilenceAfter.sanitise` on read, on write and from a backup: 60 or more
is "Never", so no value can make a ring outlast the hard stop, and a negative one is
the default rather than the clamp's floor, which would be "Never".
Changing the setting mid-ring applies at once. The settings screen writes it
through `AlarmEngine.setAlarmSilenceAfter()`, which stores it and, under the
same lock and uncancellably, measures the ring in progress against the new
window from when it *started*: past it, the cycle closes as missed through
`closeCycleLocked`; inside it, the backstop moves to the new end. A clock
change re-measures the ring the same way before rescheduling: the backstop is a
wall-clock registration, so a clock moved back re-arms it at most one window
from the moved clock, and one moved forward past the window closes it. A ring
whose start the clock has moved back behind is re-anchored to now and stored,
once, so a later re-measure cannot read the negative age as a whole window
left; a clock moved back mid-ring adds at most the time already rung, which
v1's fixed backstop did not bound at all. A backstop that fires while the ring
is still inside the window in force (one queued behind a raised setting)
re-arms instead of closing.
The timers' setting is written through `TimerEngine.setTimerSilenceAfter()` for
the same reason: under the engine's lock it first records a session that has
already run out of the old window as lapsed, even one no service pass saw go
quiet, so raising the setting cannot start it sounding again.
Whenever the resolver closes a ring (a clock jumped forward, a ringing alarm
switched off, a reboot outlasting the window), `persist` stops the ring service
and cancels the backstop: storage says nothing rings, so nothing may. Earlier
that path only cleared `ringingSince` and left the sound to the backstop. And a
cycle the resolver closes as missed (a ring past its window, or a snooze that
never fired) **disables a one-shot alarm**, exactly as `closeCycleLocked`
does; falling through would have armed it for the same time tomorrow.
A **non-repeating alarm is disabled when its cycle closes, never when it opens**.
Disabling it at the start would clear its own snooze and the alarm would vanish
@@ -1203,7 +1250,9 @@ genuinely ringing alarm sounding with its backstop intact.
**At most one alarm rings, and a newly-firing alarm takes over.** Two ringtones
at once is not a feature, and queueing invents a state machine nobody can debug
at 07:00. The alarm that is displaced keeps its watermark, so it does not come
back the moment the slot is re-resolved.
back the moment the slot is re-resolved. Its cycle has closed undismissed, so a
displaced one-shot alarm is switched off (or deleted, if transient), as on
every other close.
`snoozeLimit == 0` means **snoozing is disabled**, not unlimited; v1 offers no
unlimited, and "0 means infinite" is a trap. A refused snooze *dismisses*; it
@@ -1356,7 +1405,7 @@ timer too. What the alarm **keeps to itself** is the full-screen intent, the
ring activity, the dismiss challenge and the snooze; what the timer
parameterises is its own ringtone, a ramp of **zero seconds** (a timer is set by
someone awake, and a gentle start is just a quiet start) and its own
auto-silence constant. §14 has the rest, including which of the two wins the
"Silence after" setting. §14 has the rest, including which of the two wins the
one audio stream.
---
@@ -1505,7 +1554,7 @@ whichever comes first, for every challenge kind, asserted as a parameterised
invariant over `DismissChallenge`, not as three happy paths.
Three more guarantees hold alongside it. Snooze is never gated: the gate protects
dismissal only. Auto-silence still ends the ring at ten minutes regardless of the
dismissal only. Auto-silence still ends the ring at its "Silence after" window regardless of the
gate, because that is the engine's, and the screen only follows the session to
`Finished`. And a wrong answer carries no lockout and no penalty timer; it
replaces the problem and that is all.
@@ -1768,6 +1817,12 @@ the engine's own mutex, so it cannot race the fire it is asking about, and it is
deliberately **conditional**: dismissing unconditionally would also drop a
merely *snoozed* alarm's pending snooze, which is wrong for a label edit.
Since #17 the engine's `persist` also stops the ring service and cancels the
backstop whenever the resolver closes a ring (§11), so the disabled branch no
longer leaves a ring sounding on its own. The dismiss-first rule stays: it is
what closes the cycle *as a dismissal* (a one-shot alarm disabled, the snooze
notification cleared), and a deleted row never reaches the resolver at all.
### Immediate apply
There is no Save button, no dirty state and no discard dialog: `PLAN.md` §11
@@ -1952,8 +2007,8 @@ sound.
- **A session is one window.** It opens when the audio *actually starts
sounding* and closes when the expired set returns to empty. A second timer
expiring mid-session inherits the session's remaining window rather than
buying a fresh ten minutes. That is the conservative direction, and the same rule as
§11's "a reboot does not buy the alarm another ten minutes". The anchor is the
buying a fresh window. That is the conservative direction, and the same rule as
§11's "a reboot does not buy the alarm a fresh window". The anchor is the
instant the audio *opened* rather than the instant of expiry, so a long alarm ring in
front of it does not eat the timer's whole window.
- **A lapsed window does not silence the next timer.** A window that has run out
@@ -1964,9 +2019,17 @@ sound.
opens a fresh window with its own heads-up. Inheriting stays the rule for a
timer expiring *inside* a live window.
`TimerRing.AUTO_SILENCE_AFTER` is **ten minutes**: its own constant with the
same value as the alarm's, free to diverge, because coupling the two would make
one number answer two questions. Unlike an alarm's, a timer's
The window is the timer's own **"Silence after"** setting
(`ClockDefaults.timerSilenceAfter`, Settings › Timers, #17), ten minutes by
default: the same choices as the alarm's and the same one-hour "Never", but a
separate value, because coupling the two would make one number answer two
questions. `TimerRingPolicy` reads it from the defaults it already takes, so a
change applies on the service's next pass. A session that has gone quiet stays
quiet: on auto-silence the policy moves the stored anchor back past
`SilenceAfter.HARD_STOP`, so raising the setting afterwards cannot start it
ringing again. The service's one heads-up is keyed to the session's anchor
(`Sound.openedAt`) rather than to the window's end, which an edit can move
without making a new session. Unlike an alarm's, a timer's
**auto-silence stops the noise and leaves the row `EXPIRED`.** An auto-silenced
alarm is a *missed* alarm and its cycle closes; an auto-silenced timer has still
finished, and the user coming back must be able to see that and add a minute
+12 -2
View File
@@ -136,6 +136,8 @@ device or after a reboot (`docs/PLAN.md` §5). Every imported timer lands
"default_timer_ringtone_uri": null,
"default_dismiss_challenge": "NONE",
"home_zone_id": null,
"default_alarm_silence_after_minutes": 10,
"default_timer_silence_after_minutes": 10,
"timer_presets": [60000, 120000, 180000, 300000, 600000, 900000, 1800000, 3600000],
"bedtime": {
"enabled": false,
@@ -164,8 +166,16 @@ the importing device creates its own (`docs/ARCHITECTURE.md` §18).
Field names mirror `ClockPrefs`'/`SettingsPrefs`' own on-disk keys. Older
files may also carry `default_timer_duration_millis`, from a default timer
length setting that has since been removed; it is ignored on import like any
other unknown field. Every
numeric/duration value is clamped on *apply* using the same ranges and encoding
other unknown field.
`default_alarm_silence_after_minutes` and `default_timer_silence_after_minutes`
are how long a ringing alarm or a finished timer keeps going before it stops on
its own: whole minutes, with `0` meaning "Never" (which still stops after an
hour). A file without them, from before the setting existed, imports as `10`,
the value it was made with. A value of 60 or more reads as 0, "Never" (which
rings for that long anyway); a negative one reads as the default, 10.
Every numeric/duration value is clamped on *apply* using the same ranges and encoding
as the existing preference setters, never on parse.
## Ringtone URIs