Live Activities unter der Notch, nicht daneben
Neben ihr wären die Arme zwangsläufig gleich breit — die Silhouette zeichnet den Steg mittig um die Hardware. Ein Symbol links und ein Balken rechts hieße dann 132 Punkte Schwarz für ein Symbol. Darunter hängt die Fläche frei und wird so breit, wie ihr Inhalt es braucht. Lautstärke, Strom, Titelwechsel und Helligkeit. Gemeldet wird nur, was sich **geändert** hat: `PowerWatcher` schweigt beim ersten gelesenen Zustand, sonst begrüßte Onyx jeden Start mit „am Netz". Die Helligkeit kostete einen Spike. Von drei Wegen trägt nur `DisplayServices`, und nur für den eingebauten Bildschirm. `CoreDisplay` — der Weg, den jede Anleitung empfiehlt — gibt für alle Bildschirme 1.0 zurück, auch für den, der auf 62 % stand. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
c05ccb8ae1
commit
9b600de9a9
@@ -0,0 +1,124 @@
|
||||
import SwiftUI
|
||||
import OnyxDesign
|
||||
import OnyxNotch
|
||||
|
||||
/// Führt die Live Activities und sagt der Notch, was gerade gilt.
|
||||
///
|
||||
/// Die Entscheidung selbst trifft `ActivityQueue` — hier steht nur, was mit
|
||||
/// Zeit und Bildschirm zu tun hat: den Wecker für die nächste ablaufende
|
||||
/// stellen und den Controllern melden, ob überhaupt etwas anliegt.
|
||||
@MainActor
|
||||
@Observable
|
||||
public final class ActivityPresenter {
|
||||
|
||||
/// Die Activity, die gerade gezeichnet wird.
|
||||
///
|
||||
/// Bleibt nach dem Ende noch stehen, solange die Fläche einfährt — sonst
|
||||
/// wäre die View im selben Bild weg, in dem sich die Notch zurückziehen
|
||||
/// soll, und es gäbe nichts mehr zu sehen. Was **gilt**, sagt
|
||||
/// `isPresenting`.
|
||||
public private(set) var current: (any NotchActivity)?
|
||||
|
||||
/// Ob die Activity noch gilt oder nur noch ausblendet.
|
||||
public private(set) var isPresenting = false
|
||||
|
||||
/// Wird nach jeder Änderung gerufen — mit dem, was jetzt gilt.
|
||||
///
|
||||
/// **Nicht nur bei „etwas / nichts".** Löst ein zweiter Lautstärkeschritt
|
||||
/// die erste Activity ab, bleibt „etwas liegt an" gleich, aber die Arme
|
||||
/// werden vielleicht anders breit. Wer nur auf den Wechsel von nichts zu
|
||||
/// etwas hört, verpasst das.
|
||||
@ObservationIgnored public var onChange: (((any NotchActivity)?) -> Void)?
|
||||
|
||||
@ObservationIgnored private var queue = ActivityQueue()
|
||||
@ObservationIgnored private var activities: [String: any NotchActivity] = [:]
|
||||
@ObservationIgnored private var alarm: DispatchWorkItem?
|
||||
@ObservationIgnored private var retirement: DispatchWorkItem?
|
||||
@ObservationIgnored private let clock: () -> Date
|
||||
|
||||
public init(clock: @escaping () -> Date = Date.init) {
|
||||
self.clock = clock
|
||||
}
|
||||
|
||||
/// Meldet eine Activity an. Eine bereits stehende mit derselben Kennung
|
||||
/// wird ersetzt — samt neuer Standzeit.
|
||||
public func raise(_ activity: any NotchActivity) {
|
||||
activities[activity.id] = activity
|
||||
queue.raise(ActivityTicket(id: activity.id,
|
||||
rank: activity.rank,
|
||||
raised: clock(),
|
||||
duration: activity.duration))
|
||||
settle()
|
||||
}
|
||||
|
||||
public func withdraw(id: String) {
|
||||
activities[id] = nil
|
||||
queue.withdraw(id: id)
|
||||
settle()
|
||||
}
|
||||
|
||||
/// Die Fläche, die die eingeklappte Notch dafür unter sich aufspannt.
|
||||
///
|
||||
/// `nil`, sobald die Activity nicht mehr gilt — auch wenn sie noch
|
||||
/// gezeichnet wird. Genau daran fährt die Fläche ein und schneidet den
|
||||
/// Inhalt dabei weg.
|
||||
public var contentSize: CGSize? { isPresenting ? current?.size : nil }
|
||||
|
||||
private func settle() {
|
||||
let now = clock()
|
||||
queue.prune(now: now)
|
||||
|
||||
let next = queue.current(now: now).flatMap { activities[$0.id] }
|
||||
if let next {
|
||||
retirement?.cancel()
|
||||
retirement = nil
|
||||
current = next
|
||||
isPresenting = true
|
||||
} else if isPresenting {
|
||||
isPresenting = false
|
||||
scheduleRetirement()
|
||||
}
|
||||
onChange?(isPresenting ? current : nil)
|
||||
|
||||
scheduleAlarm(after: now)
|
||||
}
|
||||
|
||||
/// Weckt genau dann, wenn die nächste abläuft.
|
||||
///
|
||||
/// Nicht abtasten: eine Notch, die zehnmal je Sekunde nachfragt, ob etwas
|
||||
/// vorbei ist, hält den Rechner wach — und zwar den ganzen Tag, für ein
|
||||
/// Ereignis alle paar Minuten.
|
||||
private func scheduleAlarm(after now: Date) {
|
||||
alarm?.cancel()
|
||||
alarm = nil
|
||||
guard let next = queue.nextExpiry(after: now) else { return }
|
||||
|
||||
let work = DispatchWorkItem { [weak self] in
|
||||
MainActor.assumeIsolated { self?.settle() }
|
||||
}
|
||||
alarm = work
|
||||
DispatchQueue.main.asyncAfter(deadline: .now() + max(next.timeIntervalSince(now), 0),
|
||||
execute: work)
|
||||
}
|
||||
}
|
||||
|
||||
private extension ActivityPresenter {
|
||||
|
||||
/// Räumt die ausgeblendete Activity weg, wenn die Fläche eingefahren ist.
|
||||
///
|
||||
/// Nicht sofort: solange die Notch schrumpft, muss noch etwas darin stehen.
|
||||
/// Die Dauer kommt aus dem Bewegungsprofil, damit sie bei „ruhig" mitwächst
|
||||
/// — eine feste Zahl schnitte den Inhalt dort mittendrin ab.
|
||||
func scheduleRetirement() {
|
||||
retirement?.cancel()
|
||||
let work = DispatchWorkItem { [weak self] in
|
||||
MainActor.assumeIsolated {
|
||||
guard let self, !self.isPresenting else { return }
|
||||
self.current = nil
|
||||
}
|
||||
}
|
||||
retirement = work
|
||||
DispatchQueue.main.asyncAfter(deadline: .now() + OnyxTheme.shared.motion.collapseDuration,
|
||||
execute: work)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
import Foundation
|
||||
|
||||
/// Ein Anspruch auf die eingeklappte Notch.
|
||||
///
|
||||
/// Bewusst ohne Darstellung: was eine Live Activity *zeigt*, ist eine View und
|
||||
/// gehört nicht in die Entscheidung, **welche** gerade gilt. So lässt sich die
|
||||
/// Regel ohne Bildschirm prüfen — wie `NotchStateMachine` und `LayoutEngine`.
|
||||
public struct ActivityTicket: Equatable, Sendable, Identifiable {
|
||||
|
||||
public let id: String
|
||||
/// Höher verdrängt niedriger.
|
||||
public let rank: Int
|
||||
/// Wann angemeldet.
|
||||
public let raised: Date
|
||||
/// Wie lange sie steht. `nil` heißt: bis sie zurückgezogen wird.
|
||||
public let duration: TimeInterval?
|
||||
|
||||
public init(id: String, rank: Int, raised: Date, duration: TimeInterval?) {
|
||||
self.id = id
|
||||
self.rank = rank
|
||||
self.raised = raised
|
||||
self.duration = duration
|
||||
}
|
||||
|
||||
/// Wann sie von selbst geht. `nil` bei dauerhaften.
|
||||
public var expiry: Date? {
|
||||
duration.map { raised.addingTimeInterval($0) }
|
||||
}
|
||||
|
||||
public func hasExpired(at now: Date) -> Bool {
|
||||
guard let expiry else { return false }
|
||||
return now >= expiry
|
||||
}
|
||||
}
|
||||
|
||||
/// Wer die eingeklappte Notch gerade bekommt.
|
||||
///
|
||||
/// **Warum überhaupt eine Warteschlange.** Die Anlässe kommen unabhängig
|
||||
/// voneinander: die Lautstärke ändert sich, während ein Titel wechselt, während
|
||||
/// das Netzteil angesteckt wird. Ohne Regel gewinnt, wer zuletzt kam — und dann
|
||||
/// verschluckt ein beiläufiger Lautstärkeschritt die Meldung, dass der Akku
|
||||
/// fast leer ist.
|
||||
///
|
||||
/// **Die Regel ist Rang vor Aktualität.** Bei gleichem Rang gilt die jüngere:
|
||||
/// zwei Lautstärkeschritte hintereinander sollen den zweiten zeigen, nicht den
|
||||
/// ersten stehen lassen.
|
||||
public struct ActivityQueue: Equatable, Sendable {
|
||||
|
||||
private var tickets: [ActivityTicket] = []
|
||||
|
||||
public init() {}
|
||||
|
||||
/// Alles, was gerade anliegt — ungefiltert, in Anmeldereihenfolge.
|
||||
public var all: [ActivityTicket] { tickets }
|
||||
|
||||
/// Meldet einen Anspruch an. Ein bereits vorhandener mit derselben Kennung
|
||||
/// wird **ersetzt**, nicht ergänzt.
|
||||
///
|
||||
/// Das ist der Normalfall und keine Ausnahme: wer die Lautstärke dreimal
|
||||
/// verstellt, meldet dreimal dieselbe Activity an und will dreimal die
|
||||
/// volle Standzeit — nicht drei Einträge in einer Schlange.
|
||||
public mutating func raise(_ ticket: ActivityTicket) {
|
||||
tickets.removeAll { $0.id == ticket.id }
|
||||
tickets.append(ticket)
|
||||
}
|
||||
|
||||
public mutating func withdraw(id: String) {
|
||||
tickets.removeAll { $0.id == id }
|
||||
}
|
||||
|
||||
/// Wirft weg, was abgelaufen ist.
|
||||
public mutating func prune(now: Date) {
|
||||
tickets.removeAll { $0.hasExpired(at: now) }
|
||||
}
|
||||
|
||||
/// Welche gerade gilt.
|
||||
public func current(now: Date) -> ActivityTicket? {
|
||||
tickets
|
||||
.filter { !$0.hasExpired(at: now) }
|
||||
// `last` statt `max(by:)`: bei gleichem Rang gewinnt die zuletzt
|
||||
// angemeldete, und `tickets` steht in Anmeldereihenfolge.
|
||||
.reduce(into: ActivityTicket?.none) { best, candidate in
|
||||
guard let current = best else { best = candidate; return }
|
||||
if candidate.rank >= current.rank { best = candidate }
|
||||
}
|
||||
}
|
||||
|
||||
/// Wann das nächste Mal etwas von selbst verschwindet.
|
||||
///
|
||||
/// Der Presenter stellt darauf seinen Wecker. Ohne diese Auskunft müsste er
|
||||
/// abtasten — und eine Notch, die zehnmal je Sekunde nachfragt, ob etwas
|
||||
/// abgelaufen ist, hält den Rechner wach.
|
||||
public func nextExpiry(after now: Date) -> Date? {
|
||||
tickets.compactMap(\.expiry).filter { $0 > now }.min()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
import SwiftUI
|
||||
|
||||
/// Was die eingeklappte Notch zeigt.
|
||||
///
|
||||
/// **Unter der Notch, nicht daneben.** Neben ihr wären die Arme zwangsläufig
|
||||
/// gleich breit — die Silhouette zeichnet den Steg mittig um die Hardware, und
|
||||
/// verschieden breite Arme schöben die Lücke aus ihr heraus. Ein Symbol links
|
||||
/// und ein Balken rechts hieße dann 132 Punkte Schwarz für ein Symbol. Darunter
|
||||
/// hängt die Fläche frei und wird genau so breit, wie ihr Inhalt es braucht.
|
||||
///
|
||||
/// **Die Größe steht im Protokoll, sie wird nicht gemessen.** Eine Notch, die
|
||||
/// sich an ihren Inhalt anpasst, müsste ihn erst zeichnen, seine Größe
|
||||
/// zurückmelden und sich dann bewegen — das ist ein Bild zu spät und sieht als
|
||||
/// Ruckeln aus. Wer eine Activity schreibt, weiß, wie groß sie wird.
|
||||
@MainActor
|
||||
public protocol NotchActivity: Sendable {
|
||||
|
||||
/// Stabil: eine erneute Anmeldung mit derselben Kennung ersetzt die alte,
|
||||
/// statt sich anzureihen.
|
||||
var id: String { get }
|
||||
|
||||
/// Höher verdrängt niedriger.
|
||||
var rank: Int { get }
|
||||
|
||||
/// Wie lange sie steht. `nil` heißt: bis sie zurückgezogen wird.
|
||||
var duration: TimeInterval? { get }
|
||||
|
||||
/// Die Fläche **unter** der Notch. Ist sie schmaler als die Notch, gibt
|
||||
/// diese das Maß vor — sonst hinge unter dem Steg ein schmalerer Zipfel.
|
||||
var size: CGSize { get }
|
||||
|
||||
func makeContent() -> AnyView
|
||||
}
|
||||
|
||||
/// Die Ränge, damit sie an einer Stelle stehen und nicht als Zahlen im Code.
|
||||
///
|
||||
/// Die Ordnung ist keine Geschmacksfrage: was der Nutzer **selbst gerade
|
||||
/// ausgelöst** hat, muss er sehen — sonst wirkt der Regler kaputt. Was ihn
|
||||
/// warnt, steht darüber, weil er es sonst verpasst. Was nur begleitet, steht
|
||||
/// ganz unten.
|
||||
public enum ActivityRank {
|
||||
/// Läuft im Hintergrund mit, wenn sonst nichts ansteht.
|
||||
public static let ambient = 10
|
||||
/// Ein Zustand, der sich von selbst geändert hat — Titelwechsel, Kopplung.
|
||||
public static let notice = 30
|
||||
/// Eine Reaktion auf einen Handgriff — Lautstärke, Helligkeit.
|
||||
public static let response = 50
|
||||
/// Etwas, das man nicht verpassen darf — Akku fast leer.
|
||||
public static let alert = 90
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
import AppKit
|
||||
import Observation
|
||||
import os
|
||||
|
||||
private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "Brightness")
|
||||
|
||||
/// Die Helligkeit des eingebauten Bildschirms — gelesen, nicht gesetzt.
|
||||
///
|
||||
/// **Nur der eingebaute.** Ein Spike über drei Wege hat ergeben: von
|
||||
/// `DisplayServices` bekommt man für externe Monitore Fehler 1000, `CoreDisplay`
|
||||
/// liefert für jeden Bildschirm stur 1,0 und ist damit wertlos, und
|
||||
/// `IODisplayConnect` gibt es auf Apple Silicon gar nicht mehr. Siehe
|
||||
/// `Spikes/brightness-probe.swift`.
|
||||
///
|
||||
/// **Und nicht abgetastet, sondern gemeldet.** Eine Notch, die zehnmal je
|
||||
/// Sekunde nach der Helligkeit fragt, hält den Rechner wach — den ganzen Tag,
|
||||
/// für ein Ereignis alle paar Stunden. `DisplayServices` kann benachrichtigen;
|
||||
/// gäbe es das nicht, wäre diese Anzeige den Preis nicht wert gewesen.
|
||||
///
|
||||
/// **Private API, und deshalb mit Netz.** Fehlt eines der Symbole — bei einem
|
||||
/// Systemwechsel jederzeit möglich —, bleibt `level` auf `nil` und Onyx zeigt
|
||||
/// schlicht keine Helligkeit an. Nichts anzuzeigen ist ein hinnehmbarer
|
||||
/// Ausfall; abzustürzen wäre keiner.
|
||||
@MainActor
|
||||
@Observable
|
||||
public final class DisplayBrightness {
|
||||
|
||||
/// Der zuletzt gemeldete Stand, 0 bis 1. `nil` heißt: nicht lesbar.
|
||||
public private(set) var level: Double?
|
||||
|
||||
/// Ob dieser Rechner überhaupt eine lesbare Helligkeit hat.
|
||||
public var isAvailable: Bool { display != nil }
|
||||
|
||||
@ObservationIgnored private let display: CGDirectDisplayID?
|
||||
@ObservationIgnored private let read: GetBrightness?
|
||||
|
||||
private typealias GetBrightness =
|
||||
@convention(c) (CGDirectDisplayID, UnsafeMutablePointer<Float>) -> Int32
|
||||
private typealias Callback =
|
||||
@convention(c) (UnsafeRawPointer?, CGDirectDisplayID, CFString?, Double) -> Void
|
||||
private typealias Register =
|
||||
@convention(c) (CGDirectDisplayID, UnsafeRawPointer?, Callback) -> Int32
|
||||
|
||||
/// Der Rückruf ist ein reiner C-Zeiger und kann nichts einfangen. Die eine
|
||||
/// laufende Instanz steht deshalb hier — schwach, damit sie sich beenden
|
||||
/// lässt.
|
||||
@ObservationIgnored private nonisolated(unsafe) static weak var current: DisplayBrightness?
|
||||
|
||||
private static let frameworkPath =
|
||||
"/System/Library/PrivateFrameworks/DisplayServices.framework/DisplayServices"
|
||||
|
||||
public init() {
|
||||
display = NSScreen.screens
|
||||
.compactMap { $0.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")]
|
||||
as? CGDirectDisplayID }
|
||||
.first { CGDisplayIsBuiltin($0) != 0 }
|
||||
|
||||
guard let handle = dlopen(Self.frameworkPath, RTLD_LAZY) else {
|
||||
log.notice("DisplayServices nicht ladbar — keine Helligkeitsanzeige")
|
||||
read = nil
|
||||
return
|
||||
}
|
||||
read = dlsym(handle, "DisplayServicesGetBrightness")
|
||||
.map { unsafeBitCast($0, to: GetBrightness.self) }
|
||||
|
||||
Self.current = self
|
||||
refresh()
|
||||
subscribe(handle)
|
||||
}
|
||||
|
||||
/// Liest den aktuellen Stand einmal.
|
||||
public func refresh() {
|
||||
guard let display, let read else { level = nil; return }
|
||||
var value: Float = 0
|
||||
// Status ungleich null heißt: dieser Bildschirm hat keine Helligkeit,
|
||||
// die man lesen könnte. Kein Fehler, nur keine Antwort.
|
||||
guard read(display, &value) == 0 else { level = nil; return }
|
||||
level = Double(min(max(value, 0), 1))
|
||||
}
|
||||
|
||||
private func subscribe(_ handle: UnsafeMutableRawPointer) {
|
||||
guard let display,
|
||||
let symbol = dlsym(handle,
|
||||
"DisplayServicesRegisterForBrightnessChangeNotifications")
|
||||
else {
|
||||
log.notice("Keine Helligkeitsmeldungen — Anzeige bleibt beim Startwert")
|
||||
return
|
||||
}
|
||||
|
||||
let callback: Callback = { _, _, _, value in
|
||||
// Der Rückruf kommt aus einem fremden Faden.
|
||||
Task { @MainActor in
|
||||
DisplayBrightness.current?.level = min(max(value, 0), 1)
|
||||
}
|
||||
}
|
||||
let status = unsafeBitCast(symbol, to: Register.self)(display, nil, callback)
|
||||
if status != 0 {
|
||||
log.notice("Anmeldung für Helligkeitsmeldungen fehlgeschlagen: \(status, privacy: .public)")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
import Testing
|
||||
import Foundation
|
||||
import CoreGraphics
|
||||
import SwiftUI
|
||||
import OnyxNotch
|
||||
@testable import ActivityProvider
|
||||
|
||||
@Suite("Warteschlange der Live Activities")
|
||||
struct ActivityQueueTests {
|
||||
|
||||
private let now = Date(timeIntervalSince1970: 1_780_000_000)
|
||||
|
||||
private func ticket(_ id: String, rank: Int, at offset: TimeInterval = 0,
|
||||
for duration: TimeInterval? = 2) -> ActivityTicket {
|
||||
ActivityTicket(id: id, rank: rank,
|
||||
raised: now.addingTimeInterval(offset), duration: duration)
|
||||
}
|
||||
|
||||
@Test("Leer heißt: nichts zu zeigen")
|
||||
func emptyShowsNothing() {
|
||||
#expect(ActivityQueue().current(now: now) == nil)
|
||||
}
|
||||
|
||||
/// Ohne diese Regel verschluckt ein beiläufiger Lautstärkeschritt die
|
||||
/// Meldung, dass der Akku fast leer ist.
|
||||
@Test("Rang schlägt Aktualität")
|
||||
func rankBeatsRecency() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("battery", rank: 90))
|
||||
queue.raise(ticket("volume", rank: 10, at: 1))
|
||||
|
||||
#expect(queue.current(now: now.addingTimeInterval(1))?.id == "battery")
|
||||
}
|
||||
|
||||
@Test("Bei gleichem Rang gilt die jüngere")
|
||||
func sameRankPrefersNewest() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("volume", rank: 10))
|
||||
queue.raise(ticket("brightness", rank: 10, at: 1))
|
||||
|
||||
#expect(queue.current(now: now.addingTimeInterval(1))?.id == "brightness")
|
||||
}
|
||||
|
||||
/// Wer die Lautstärke dreimal verstellt, will dreimal die volle Standzeit —
|
||||
/// nicht drei Einträge in einer Schlange.
|
||||
@Test("Dieselbe Kennung ersetzt, statt sich anzureihen")
|
||||
func raisingAgainReplaces() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("volume", rank: 10))
|
||||
queue.raise(ticket("volume", rank: 10, at: 1))
|
||||
|
||||
#expect(queue.all.count == 1)
|
||||
#expect(queue.current(now: now.addingTimeInterval(1))?.raised
|
||||
== now.addingTimeInterval(1))
|
||||
}
|
||||
|
||||
@Test("Abgelaufene zählen nicht mehr")
|
||||
func expiredIsGone() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("volume", rank: 10, for: 2))
|
||||
|
||||
#expect(queue.current(now: now.addingTimeInterval(1)) != nil)
|
||||
#expect(queue.current(now: now.addingTimeInterval(2)) == nil)
|
||||
}
|
||||
|
||||
/// Genau dafür gibt es dauerhafte: etwas, das steht, wenn sonst nichts
|
||||
/// ansteht — das Wetter etwa.
|
||||
@Test("Eine dauerhafte läuft nie ab")
|
||||
func persistentNeverExpires() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("weather", rank: 1, for: nil))
|
||||
|
||||
#expect(queue.current(now: now.addingTimeInterval(86_400))?.id == "weather")
|
||||
}
|
||||
|
||||
@Test("Nach dem Ablauf der kurzen kommt die dauerhafte zurück")
|
||||
func persistentReturns() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("weather", rank: 1, for: nil))
|
||||
queue.raise(ticket("volume", rank: 10, for: 2))
|
||||
|
||||
#expect(queue.current(now: now)?.id == "volume")
|
||||
#expect(queue.current(now: now.addingTimeInterval(3))?.id == "weather")
|
||||
}
|
||||
|
||||
@Test("Zurückziehen wirkt sofort")
|
||||
func withdrawWorks() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("media", rank: 20, for: nil))
|
||||
queue.withdraw(id: "media")
|
||||
|
||||
#expect(queue.current(now: now) == nil)
|
||||
}
|
||||
|
||||
/// Eine Notch, die zehnmal je Sekunde nachfragt, ob etwas abgelaufen ist,
|
||||
/// hält den Rechner wach. Deshalb rechnet die Schlange den Weckzeitpunkt aus.
|
||||
@Test("Der nächste Ablauf ist der früheste noch offene")
|
||||
func nextExpiryIsEarliest() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("volume", rank: 10, for: 5))
|
||||
queue.raise(ticket("charge", rank: 50, for: 2))
|
||||
queue.raise(ticket("weather", rank: 1, for: nil))
|
||||
|
||||
#expect(queue.nextExpiry(after: now) == now.addingTimeInterval(2))
|
||||
}
|
||||
|
||||
@Test("Ohne offene Fristen gibt es keinen Weckzeitpunkt")
|
||||
func noExpiryWithoutDurations() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("weather", rank: 1, for: nil))
|
||||
|
||||
#expect(queue.nextExpiry(after: now) == nil)
|
||||
}
|
||||
|
||||
@Test("Aufräumen entfernt genau die abgelaufenen")
|
||||
func pruneRemovesExpiredOnly() {
|
||||
var queue = ActivityQueue()
|
||||
queue.raise(ticket("volume", rank: 10, for: 1))
|
||||
queue.raise(ticket("weather", rank: 1, for: nil))
|
||||
queue.prune(now: now.addingTimeInterval(2))
|
||||
|
||||
#expect(queue.all.map(\.id) == ["weather"])
|
||||
}
|
||||
}
|
||||
|
||||
@Suite("Fläche unter der Notch")
|
||||
@MainActor
|
||||
struct AmbientSizeTests {
|
||||
|
||||
private struct Row: NotchActivity {
|
||||
let id = "volume"
|
||||
let rank = ActivityRank.response
|
||||
let duration: TimeInterval? = 2
|
||||
var size: CGSize { CGSize(width: 196, height: 34) }
|
||||
func makeContent() -> AnyView { AnyView(EmptyView()) }
|
||||
}
|
||||
|
||||
@Test("Die angemeldete Activity gibt die Fläche vor")
|
||||
func sizeComesFromActivity() {
|
||||
let presenter = ActivityPresenter()
|
||||
presenter.raise(Row())
|
||||
|
||||
#expect(presenter.contentSize == CGSize(width: 196, height: 34))
|
||||
}
|
||||
|
||||
@Test("Ohne Activity gibt es keine Fläche")
|
||||
func noActivityNoSize() {
|
||||
#expect(ActivityPresenter().contentSize == nil)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
import Testing
|
||||
@testable import MetricsProvider
|
||||
|
||||
@Suite("Strom: was gemeldet wird")
|
||||
struct PowerWatcherTests {
|
||||
|
||||
@Test("Der erste gelesene Zustand meldet nichts")
|
||||
func firstReadingIsSilent() {
|
||||
var watcher = PowerWatcher()
|
||||
// Beim Start ist „am Netz" kein Ereignis, sondern die Lage.
|
||||
#expect(watcher.observe(isCharging: false, isPluggedIn: true,
|
||||
charge: 0.8, limit: nil) == nil)
|
||||
#expect(watcher.current == .plugged)
|
||||
}
|
||||
|
||||
@Test("Derselbe Zustand meldet sich nicht noch einmal")
|
||||
func repeatedStateIsSilent() {
|
||||
var watcher = PowerWatcher()
|
||||
_ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: nil)
|
||||
#expect(watcher.observe(isCharging: true, isPluggedIn: true,
|
||||
charge: 0.51, limit: nil) == nil)
|
||||
#expect(watcher.observe(isCharging: true, isPluggedIn: true,
|
||||
charge: 0.99, limit: nil) == nil)
|
||||
}
|
||||
|
||||
@Test("Netzteil abgezogen: das ist ein Ereignis")
|
||||
func unplugging() {
|
||||
var watcher = PowerWatcher()
|
||||
_ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: nil)
|
||||
#expect(watcher.observe(isCharging: false, isPluggedIn: false,
|
||||
charge: 0.5, limit: nil) == .unplugged)
|
||||
}
|
||||
|
||||
@Test("Fast leer schlägt „am Akku\"")
|
||||
func lowBeatsUnplugged() {
|
||||
var watcher = PowerWatcher()
|
||||
_ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
|
||||
// Beides trifft zu — gemeldet wird das, was man nicht verpassen darf.
|
||||
#expect(watcher.observe(isCharging: false, isPluggedIn: false,
|
||||
charge: 0.15, limit: nil) == .low)
|
||||
}
|
||||
|
||||
@Test("Von fast leer zurück auf normal ist wieder ein Wechsel")
|
||||
func recoveringFromLow() {
|
||||
var watcher = PowerWatcher()
|
||||
_ = watcher.observe(isCharging: false, isPluggedIn: false, charge: 0.1, limit: nil)
|
||||
#expect(watcher.observe(isCharging: false, isPluggedIn: false,
|
||||
charge: 0.5, limit: nil) == .unplugged)
|
||||
}
|
||||
|
||||
@Test("Die Schwelle liegt bei zwanzig Prozent, einschließlich")
|
||||
func thresholdIsInclusive() {
|
||||
var atThreshold = PowerWatcher()
|
||||
_ = atThreshold.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
|
||||
#expect(atThreshold.observe(isCharging: false, isPluggedIn: false,
|
||||
charge: 0.2, limit: nil) == .low)
|
||||
|
||||
var above = PowerWatcher()
|
||||
_ = above.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
|
||||
#expect(above.observe(isCharging: false, isPluggedIn: false,
|
||||
charge: 0.21, limit: nil) == .unplugged)
|
||||
}
|
||||
|
||||
@Test("Am Ladelimit ist ein eigener Zustand, nicht „am Netz\"")
|
||||
func limitIsItsOwnState() {
|
||||
var watcher = PowerWatcher()
|
||||
_ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: 80)
|
||||
#expect(watcher.observe(isCharging: false, isPluggedIn: true,
|
||||
charge: 0.80, limit: 80) == .atLimit(80))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user