ScarriffleandClaude Opus 5
a3399d3a96
Apples eigene Einblendung lässt sich aushängen, ohne Root und ohne SIP anzufassen: `com.apple.OSDUIHelper` liegt in der GUI-Domäne des angemeldeten Benutzers, nicht im System. `launchctl bootout` dort hinein genügt. Standardmäßig aus, denn es verschwindet **jede** Einblendung — auch Helligkeit und Feststelltaste, und für die Feststelltaste hat Onyx keinen Ersatz. Beim Beenden wird wieder eingehängt: eine Einstellung darf nicht überleben, was sie eingestellt hat. Dazu zwei Fehler im Anlernen behoben. Der Posenname stand als roher Schlüssel da — die Zeichenketten liegen im Bündel von `FaceProvider`, gesucht wurden sie im Hauptbündel. Und „Gesicht vergleichen" blieb nach dem Anlernen grau, weil `isEnrolled` bei jedem Aufruf den Schlüsselbund las: richtig, aber für SwiftUI unsichtbar, weil es nichts gab, woran eine Ansicht die Änderung hätte bemerken können. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
680 lines
30 KiB
Swift
680 lines
30 KiB
Swift
import SwiftUI
|
|
import AppKit
|
|
import OnyxCore
|
|
import OnyxDesign
|
|
import OnyxNotch
|
|
import OnyxMenuBar
|
|
import OnyxWidgetKit
|
|
import CalendarProvider
|
|
import WeatherProvider
|
|
import MediaProvider
|
|
import MetricsProvider
|
|
import NetworkProvider
|
|
import AudioProvider
|
|
import ShelfProvider
|
|
import ClipboardProvider
|
|
import LockProvider
|
|
import FaceProvider
|
|
import NotesProvider
|
|
import ActivityProvider
|
|
import OSLog
|
|
|
|
private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "App")
|
|
|
|
@main
|
|
struct OnyxApp: App {
|
|
@NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate
|
|
|
|
var body: some Scene {
|
|
// Onyx hat kein Hauptfenster — alles lebt in der Notch und in der
|
|
// Menüleiste. Die Einstellungen sind die einzige Ausnahme; im Panel
|
|
// wäre dafür zu wenig Platz.
|
|
// Eine Szene ist Pflicht, benutzt wird sie nicht: das
|
|
// Einstellungsfenster führt SettingsWindowController selbst.
|
|
// Siehe die Begründung dort.
|
|
Settings { EmptyView() }
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
final class AppDelegate: NSObject, NSApplicationDelegate {
|
|
|
|
private(set) var model: AppModel?
|
|
private var coordinator: NotchCoordinator?
|
|
private var menuBar: MenuBarController?
|
|
private var onyxItem: NSStatusItem?
|
|
private var calendarModel: CalendarModel?
|
|
private var weatherModel: WeatherModel?
|
|
private var mediaModel: MediaModel?
|
|
private var metricsModel: MetricsModel?
|
|
|
|
/// Woran erkannt wird, dass sich etwas **geändert** hat. Ohne dieses
|
|
/// Gedächtnis meldete jede Messung dasselbe noch einmal.
|
|
/// Entscheidet, ob ein Messwert überhaupt ein Ereignis ist. Geprüft in
|
|
/// `PowerWatcherTests`.
|
|
private var powerWatcher = PowerWatcher()
|
|
/// Woran ein Titelwechsel erkannt wird — Titel und Interpret, nicht der
|
|
/// ganze Zustand: die Abspielposition wandert im Sekundentakt weiter, und
|
|
/// das ist kein Ereignis.
|
|
private var lastTrack: String?
|
|
|
|
/// Die Helligkeit des eingebauten Bildschirms. Auf Rechnern ohne lesbare
|
|
/// Helligkeit bleibt sie leer und meldet nie etwas.
|
|
private let brightness = DisplayBrightness()
|
|
/// Der Sperrbildschirm. Steht bereit, sperrt aber nur auf Verlangen.
|
|
private let lockController = LockController()
|
|
/// Der zuletzt gemeldete Stand — der erste meldet nichts, sonst begrüßte
|
|
/// Onyx jeden Start mit der Helligkeit, die ohnehin schon eingestellt war.
|
|
private var lastBrightness: Double?
|
|
private var networkModel: NetworkModel?
|
|
private var shelfStore: ShelfStore?
|
|
private var clipboardStore: ClipboardStore?
|
|
private var notesStore: NotesStore?
|
|
private let settingsWindow = SettingsWindowController()
|
|
private let fanControl = FanControl()
|
|
private let audioMixer = AudioMixer()
|
|
private let systemAudio = SystemAudio()
|
|
private let launchAtLogin = LaunchAtLogin()
|
|
private let onboarding = OnboardingWindowController()
|
|
private let galleryWindow = GalleryWindowController()
|
|
private let activities = ActivityPresenter()
|
|
|
|
func applicationDidFinishLaunching(_ notification: Notification) {
|
|
NSApp.setActivationPolicy(.accessory)
|
|
|
|
// Werkstattschalter: die Erscheinung **nur dieser App** umstellen, um
|
|
// Fenster hell und dunkel nebeneinander prüfen zu können. Die
|
|
// Systemeinstellung dafür zu drehen wäre ein Eingriff in die Umgebung
|
|
// des Nutzers — für einen Blick auf ein Fenster zu viel.
|
|
//
|
|
// open Onyx.app --args -onyx.appearance light
|
|
//
|
|
// **Nur im Debug.** Der Schalter liegt im flüchtigen Argument-Bereich
|
|
// und überlebt keinen Neustart — aber eine ausgelieferte App, die sich
|
|
// über die Erscheinungswahl des Systems hinwegsetzen *kann*, ist eine
|
|
// Falle, die irgendwann jemand auslöst.
|
|
#if DEBUG
|
|
switch UserDefaults.standard.string(forKey: "onyx.appearance") {
|
|
case "light": NSApp.appearance = NSAppearance(named: .aqua)
|
|
case "dark": NSApp.appearance = NSAppearance(named: .darkAqua)
|
|
default: break
|
|
}
|
|
#endif
|
|
|
|
// Vor allem anderen: sicherstellen, dass wir allein sind. Zwei Instanzen
|
|
// bringen zwei Zustandsmaschinen und zwei Animationen auf dieselbe
|
|
// Notch — das sieht aus wie ein Ruckler und ist keiner.
|
|
if case .blocked(let pids) = SingleInstance.claim() {
|
|
SingleInstance.explainBlocked(by: pids)
|
|
NSApp.terminate(nil)
|
|
return
|
|
}
|
|
|
|
registerWidgets()
|
|
|
|
let model = AppModel()
|
|
self.model = model
|
|
// Die gespeicherte Wahl gleich anwenden — sonst steht Onyx nach einem
|
|
// Neustart wieder ohne Dock-Symbol da, obwohl es eingeschaltet ist.
|
|
NSApp.setActivationPolicy(model.showsDockIcon ? .regular : .accessory)
|
|
|
|
let coordinator = NotchCoordinator(policy: model.displayPolicy,
|
|
trigger: model.triggerArea) { displayID, presentation in
|
|
NotchHostingView(
|
|
rootView: NotchContainer(
|
|
presentation: presentation,
|
|
leading: { [weak self] in
|
|
NotchBandSlot(presentation: presentation) {
|
|
BandSlotView(model: model, edge: .leading,
|
|
weather: self?.weatherModel,
|
|
metrics: self?.metricsModel)
|
|
}
|
|
},
|
|
trailing: { [weak self] in
|
|
NotchBandSlot(presentation: presentation) {
|
|
BandSlotView(model: model, edge: .trailing,
|
|
weather: self?.weatherModel,
|
|
metrics: self?.metricsModel)
|
|
}
|
|
},
|
|
ambient: { [weak self] in
|
|
if let self { NotchAmbientSlot(presenter: activities) }
|
|
},
|
|
content: { NotchPanelContent(model: model, displayID: displayID) }),
|
|
presentation: presentation)
|
|
}
|
|
coordinator.showsIdleIsland = model.showsIdleIsland
|
|
coordinator.style = model.notchStyle
|
|
coordinator.virtualWidthOverrides = model.notchWidths
|
|
coordinator.start()
|
|
self.coordinator = coordinator
|
|
|
|
// Die Live Activities: der Presenter entscheidet, die Controller
|
|
// führen aus. Beides je Bildschirm, weil jede Notch ihr eigenes
|
|
// Fenster hat.
|
|
activities.onChange = { [weak self] activity in
|
|
guard let self, let coordinator = self.coordinator else { return }
|
|
for controller in coordinator.activeControllers {
|
|
controller.setAmbient(activity == nil ? nil : self.activities.contentSize)
|
|
}
|
|
}
|
|
observeVolume()
|
|
observePower()
|
|
observeMedia()
|
|
observeBrightness()
|
|
|
|
NotificationCenter.default.addObserver(
|
|
self, selector: #selector(screensChanged),
|
|
name: NSApplication.didChangeScreenParametersNotification, object: nil)
|
|
applyContentSize()
|
|
|
|
// Einstellungen wirken sofort. Eine Änderung, die erst nach einem
|
|
// Neustart greift, ist in einer App ohne Fenster praktisch unauffindbar.
|
|
model.onLayoutChanged = { [weak self] _ in self?.applyContentSize() }
|
|
model.onTriggerAreaChanged = { [weak self] area in
|
|
self?.coordinator?.trigger = area
|
|
}
|
|
model.onDisplayPolicyChanged = { [weak self] policy in
|
|
self?.coordinator?.policy = policy
|
|
self?.applyContentSize()
|
|
}
|
|
model.onShowsIdleIslandChanged = { [weak self] shows in
|
|
self?.coordinator?.showsIdleIsland = shows
|
|
}
|
|
model.onNotchStyleChanged = { [weak self] style in
|
|
self?.coordinator?.style = style
|
|
}
|
|
model.onNotchWidthsChanged = { [weak self] widths in
|
|
self?.coordinator?.virtualWidthOverrides = widths
|
|
}
|
|
// Ohne diese Zeile wäre der Schalter in den Einstellungen eine
|
|
// Behauptung: gespeichert, aber ohne Wirkung.
|
|
if model.suppressSystemOSD { SystemOSD.suppress() }
|
|
model.onSuppressOSDChanged = { suppress in
|
|
suppress ? SystemOSD.suppress() : SystemOSD.restore()
|
|
}
|
|
|
|
lockController.usesFaceUnlock = model.faceUnlockEnabled
|
|
model.onFaceUnlockChanged = { [weak self] uses in
|
|
self?.lockController.usesFaceUnlock = uses
|
|
}
|
|
|
|
let menuBar = MenuBarController()
|
|
if let metricsModel {
|
|
for metric in MetricKind.allCases {
|
|
menuBar.register(MetricMenuBarModule(metric: metric, model: metricsModel),
|
|
settings: model.menuBarSettings(for: "metric.\(metric.rawValue)"))
|
|
}
|
|
}
|
|
if let networkModel {
|
|
menuBar.register(NetworkMenuBarModule(model: networkModel),
|
|
settings: model.menuBarSettings(for: "network"))
|
|
}
|
|
// Der Ausgangspegel muss die Programme auslassen, die der Mixer bereits
|
|
// abgreift — nur der Mixer weiß, welche das sind.
|
|
systemAudio.levels.mutedProcesses = { [weak audioMixer] in
|
|
audioMixer?.tappedProcessIDs ?? []
|
|
}
|
|
|
|
// Mixer und Lüfter gehören genauso in die Leiste wie die Messwerte:
|
|
// beides regelt man mitten in etwas anderem, und dafür ist der Weg
|
|
// über ein Fenster zu weit.
|
|
menuBar.register(MixerMenuBarModule(mixer: audioMixer, system: systemAudio),
|
|
settings: model.menuBarSettings(for: "audio"))
|
|
menuBar.register(FanMenuBarModule(control: fanControl),
|
|
settings: model.menuBarSettings(for: "fans"))
|
|
menuBar.start()
|
|
self.menuBar = menuBar
|
|
model.menuBar = menuBar
|
|
|
|
// Der Mixer läuft nur an, wenn das Häkchen gesetzt ist — er greift in
|
|
// den Tonweg ein, und das soll niemandem ungefragt passieren.
|
|
audioMixer.enableIfWanted()
|
|
|
|
installOnyxStatusItem()
|
|
observeMenuBarPreference()
|
|
requestPermissions()
|
|
|
|
if GalleryWindowController.opensAtLaunch {
|
|
galleryWindow.show(model: model)
|
|
}
|
|
|
|
// Derselbe Werkstattgriff wie beim Schaufenster: bauen, starten,
|
|
// hinsehen — ohne den Umweg übers Statusmenü.
|
|
//
|
|
// open Onyx.app --args -onyx.settings.open YES \
|
|
// -onyx.settings.section appearance
|
|
if UserDefaults.standard.bool(forKey: "onyx.settings.open") {
|
|
let name = UserDefaults.standard.string(forKey: "onyx.settings.section") ?? ""
|
|
showSettings(section: SettingsSection(rawValue: name) ?? .general)
|
|
}
|
|
}
|
|
|
|
/// Berechtigungen beim Start anfragen, nicht erst wenn ein Widget sichtbar
|
|
/// wird.
|
|
///
|
|
/// Das Panel ist beim Start zu. Eine an die View gebundene Anfrage kommt
|
|
/// deshalb erst, wenn jemand die Notch berührt — und bis dahin taucht Onyx
|
|
/// in den Systemeinstellungen gar nicht auf, es gibt also nichts, das man
|
|
/// dort freischalten könnte. Genau dieser Zustand ist beim Testen
|
|
/// aufgetreten.
|
|
private func requestPermissions() {
|
|
guard let calendarModel, let weatherModel else { return }
|
|
log.notice("Start: Einrichtung erledigt = \(self.onboarding.isDone, privacy: .public)")
|
|
// Immer einmal laden: mit Berechtigung kommen Termine, ohne sie zeigt
|
|
// das Widget den Berechtigungshinweis statt einer leeren Liste.
|
|
calendarModel.refresh()
|
|
|
|
// Die Einrichtung kommt beim ersten Start immer — auch wenn zufällig
|
|
// schon alles erlaubt ist. Sie erklärt nicht nur Berechtigungen,
|
|
// sondern auch den Helfer und den Autostart, und sie ist der einzige
|
|
// Moment, in dem jemand erfährt, was Onyx eigentlich alles kann.
|
|
guard onboarding.isDone else {
|
|
onboarding.show(calendarModel: calendarModel, weatherModel: weatherModel,
|
|
mixer: audioMixer, fanControl: fanControl,
|
|
launchAtLogin: launchAtLogin)
|
|
return
|
|
}
|
|
|
|
// Danach nur noch, wenn wirklich etwas fehlt.
|
|
let needsLocation = weatherModel.locationIsUndetermined
|
|
guard !calendarModel.hasAccess || needsLocation else { return }
|
|
|
|
// Nicht im Hintergrund anfragen.
|
|
//
|
|
// Onyx ist eine App ohne Fenster. TCC bereitet den Dialog zwar vor
|
|
// (promptType 1), entscheidet sich dann aber dagegen (promptPolicy 0),
|
|
// weil keine App im Vordergrund ist, an die er gehören könnte. Die
|
|
// Anfrage kommt kommentarlos mit `false` zurück, der Status bleibt
|
|
// `notDetermined` — und in den Systemeinstellungen taucht Onyx nie auf.
|
|
// `NSApp.activate` davor hilft nicht: Aktivierung wirkt asynchron und
|
|
// ist beim Aufruf noch nicht durch.
|
|
//
|
|
// Deshalb der ehrliche Weg: ein echtes Fenster im Vordergrund. Die
|
|
// Einrichtung lief schon einmal, hier fehlt nur noch etwas — dann
|
|
// genügt der Berechtigungsbereich der Einstellungen.
|
|
showSettings(section: .permissions)
|
|
}
|
|
|
|
/// Die Einrichtung noch einmal zeigen — aus den Einstellungen heraus.
|
|
private func showOnboarding() {
|
|
guard let calendarModel, let weatherModel else { return }
|
|
onboarding.show(calendarModel: calendarModel, weatherModel: weatherModel,
|
|
mixer: audioMixer, fanControl: fanControl,
|
|
launchAtLogin: launchAtLogin)
|
|
}
|
|
|
|
/// Ausdrücklich `false`, auch wenn es der Standard ist.
|
|
///
|
|
/// Onyx lebt in der Menüleiste und in der Notch. Dass das letzte Fenster
|
|
/// zugeht, sagt über das Beenden nichts aus — und die Voreinstellung darf
|
|
/// sich nicht unbemerkt ändern.
|
|
func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
|
|
false
|
|
}
|
|
|
|
func applicationWillTerminate(_ notification: Notification) {
|
|
// Apples Einblendung wieder einhängen. Ohne das säße jemand bis zum
|
|
// nächsten Abmelden ganz ohne Rückmeldung da — auch bei der Helligkeit,
|
|
// mit der Onyx nichts zu tun hat — und wüsste nicht, warum. Eine
|
|
// Einstellung darf nicht überleben, was sie eingestellt hat.
|
|
if model?.suppressSystemOSD == true { SystemOSD.restore() }
|
|
coordinator?.stop()
|
|
menuBar?.stop()
|
|
// Der Herzschlag endet damit. Der Helfer stellt die Lüfter binnen fünf
|
|
// Sekunden auf Automatik zurück — auch wenn Onyx abstürzt statt sauber
|
|
// zu beenden.
|
|
fanControl.stop()
|
|
// Ohne das bleiben die abgegriffenen Programme stumm zurück: der Tap
|
|
// schaltet das Original stumm, und ohne laufenden Mixer gibt niemand
|
|
// mehr etwas aus.
|
|
audioMixer.disable()
|
|
}
|
|
|
|
private func registerWidgets() {
|
|
let calendarModel = CalendarModel()
|
|
self.calendarModel = calendarModel
|
|
WidgetRegistry.shared.register(CalendarWidget(model: calendarModel))
|
|
|
|
let weatherModel = WeatherModel()
|
|
self.weatherModel = weatherModel
|
|
WidgetRegistry.shared.register(WeatherWidget(model: weatherModel))
|
|
|
|
let mediaModel = MediaModel()
|
|
self.mediaModel = mediaModel
|
|
WidgetRegistry.shared.register(MediaWidget(model: mediaModel))
|
|
|
|
let metricsModel = MetricsModel()
|
|
// Der Akku bekommt seinen Ladelimit-Regler über den Helfer, den sonst
|
|
// die Lüfter benutzen — es ist derselbe SMC-Zugang.
|
|
metricsModel.chargeControl = fanControl
|
|
self.metricsModel = metricsModel
|
|
for metric in MetricKind.allCases {
|
|
WidgetRegistry.shared.register(MetricWidget(metric: metric, model: metricsModel))
|
|
}
|
|
|
|
let networkModel = NetworkModel()
|
|
self.networkModel = networkModel
|
|
WidgetRegistry.shared.register(NetworkWidget(model: networkModel))
|
|
|
|
WidgetRegistry.shared.register(AudioMixerWidget(mixer: audioMixer, system: systemAudio))
|
|
|
|
WidgetRegistry.shared.register(FanWidget(control: fanControl))
|
|
|
|
let shelfStore = ShelfStore()
|
|
self.shelfStore = shelfStore
|
|
// AirDrop steckt in der Ablage-Kachel — zwei eigene Kacheln für je
|
|
// eine leere Ablegefläche waren ein Drittel des Panels.
|
|
WidgetRegistry.shared.register(ShelfWidget(store: shelfStore))
|
|
|
|
let clipboardStore = ClipboardStore()
|
|
self.clipboardStore = clipboardStore
|
|
WidgetRegistry.shared.register(ClipboardWidget(store: clipboardStore))
|
|
|
|
let notesStore = NotesStore()
|
|
self.notesStore = notesStore
|
|
WidgetRegistry.shared.register(NotesWidget(store: notesStore))
|
|
}
|
|
|
|
/// Je Bildschirm eine eigene Größe.
|
|
///
|
|
/// Ein Fernseher mit 1280 Punkten Breite darf das Panel auf dem Notebook
|
|
/// nicht zusammendrücken.
|
|
private func applyContentSize() {
|
|
guard let model, let coordinator else { return }
|
|
for controller in coordinator.activeControllers {
|
|
controller.contentSize = model.panelContentSize(forDisplay: controller.displayID)
|
|
}
|
|
}
|
|
|
|
/// Bildschirm angesteckt, abgezogen oder umgestellt.
|
|
///
|
|
/// Ohne das blieb die einmal gerechnete Größe stehen — auch nachdem das
|
|
/// Gerät wieder weg war. Verzögert um einen Durchlauf, damit der Koordinator
|
|
/// seine Fenster vorher neu aufgebaut hat: sonst bekämen die alten die neue
|
|
/// Größe und die neuen gar keine.
|
|
@objc private func screensChanged() {
|
|
model?.noteScreensChanged()
|
|
Task { @MainActor [weak self] in self?.applyContentSize() }
|
|
}
|
|
|
|
// MARK: - Menüleiste
|
|
|
|
/// Das feste Onyx-Element.
|
|
///
|
|
/// **Kein „Panel öffnen" im Menü**, aber ganz normal ein Menü.
|
|
///
|
|
/// Der Eintrag beschrieb einen Umweg um die eigentliche Bedienung herum —
|
|
/// das Panel öffnet sich, wenn man die Notch berührt. Ihn durch „Linksklick
|
|
/// fährt das Panel aus" zu ersetzen war aber schlechter als das Problem:
|
|
/// dieser Klick ging als Fixieren durch, und danach stand das Panel offen
|
|
/// und reagierte auf nichts. Ein Statuselement zeigt bei einem Klick sein
|
|
/// Menü. Alles andere überrascht.
|
|
private func installOnyxStatusItem() {
|
|
let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
|
|
item.autosaveName = "onyx.menubar.main"
|
|
item.button?.image = Self.menuBarIcon()
|
|
|
|
let menu = NSMenu()
|
|
menu.addItem(withTitle: String(localized: "menu.settings"),
|
|
action: #selector(openSettings), keyEquivalent: ",").target = self
|
|
menu.addItem(withTitle: String(localized: "settings.onboarding.show"),
|
|
action: #selector(openOnboarding), keyEquivalent: "").target = self
|
|
// Werkzeug, kein Programmteil: unlokalisiert, und im Release nur, wenn
|
|
// jemand den Schlüssel ausdrücklich setzt. Siehe
|
|
// `GalleryWindowController.isAvailable`.
|
|
if GalleryWindowController.isAvailable {
|
|
menu.addItem(withTitle: "Schaufenster",
|
|
action: #selector(openGallery), keyEquivalent: "").target = self
|
|
}
|
|
if model?.lockScreenEnabled == true {
|
|
menu.addItem(.separator())
|
|
menu.addItem(withTitle: String(localized: "menu.lock"),
|
|
action: #selector(lockNow), keyEquivalent: "l").target = self
|
|
}
|
|
menu.addItem(.separator())
|
|
menu.addItem(withTitle: String(localized: "menu.quit"),
|
|
action: #selector(quit), keyEquivalent: "q").target = self
|
|
item.menu = menu
|
|
|
|
onyxItem = item
|
|
}
|
|
|
|
@objc private func openOnboarding() { showOnboarding() }
|
|
|
|
@objc private func lockNow() { lockController.lock() }
|
|
|
|
/// Meldet jede Änderung der Systemlautstärke als Live Activity an.
|
|
///
|
|
/// Über `withObservationTracking` und nicht über einen eigenen Listener:
|
|
/// `SystemAudio` hängt bereits mit CoreAudio-Listenern an Lautstärke und
|
|
/// Stummschaltung. Ein zweiter Weg dorthin wäre eine zweite Wahrheit.
|
|
///
|
|
/// Die Meldung kommt **vor** dem Schreiben; der neue Wert steht erst
|
|
/// danach. Deshalb wird er in einer Aufgabe gelesen, nicht im Rückruf.
|
|
private func observeVolume() {
|
|
withObservationTracking {
|
|
_ = systemAudio.outputVolume
|
|
_ = systemAudio.outputMuted
|
|
} onChange: {
|
|
Task { @MainActor [weak self] in
|
|
guard let self else { return }
|
|
activities.raise(VolumeActivity(level: systemAudio.outputVolume,
|
|
isMuted: systemAudio.outputMuted))
|
|
observeVolume()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Meldet jeden **Wechsel** am Strom als Live Activity an.
|
|
///
|
|
/// Nicht jeden Messwert: der Ladestand ändert sich ständig, und eine Notch,
|
|
/// die das begleitet, wäre eine Leuchtreklame. Angemeldet wird nur, wenn
|
|
/// sich der Zustand ändert — und der Zustand ist das, was ``ChargeActivity``
|
|
/// aus Laden, Netz, Ladestand und Limit ableitet.
|
|
///
|
|
/// Der erste gelesene Zustand meldet **nichts**. Sonst begrüßte Onyx jeden
|
|
/// Start mit „am Netz" — einer Nachricht über nichts, das gerade geschehen
|
|
/// ist.
|
|
private func observePower() {
|
|
guard let metricsModel else { return }
|
|
withObservationTracking {
|
|
_ = metricsModel.snapshot.battery
|
|
} onChange: {
|
|
Task { @MainActor [weak self] in
|
|
guard let self else { return }
|
|
defer { observePower() }
|
|
guard let battery = self.metricsModel?.snapshot.battery else { return }
|
|
guard let event = self.powerWatcher.observe(
|
|
isCharging: battery.isCharging,
|
|
isPluggedIn: battery.isPluggedIn,
|
|
charge: battery.charge,
|
|
limit: self.metricsModel?.chargeControl?.chargeLimit)
|
|
else { return }
|
|
|
|
let kind: PowerActivity.Kind = switch event {
|
|
case .charging: .charging
|
|
case .plugged: .plugged
|
|
case .unplugged: .unplugged
|
|
case .atLimit(let limit): .atLimit(limit)
|
|
case .low: .low
|
|
}
|
|
self.activities.raise(PowerActivity(kind: kind,
|
|
charge: battery.charge,
|
|
isCharging: battery.isCharging,
|
|
isPluggedIn: battery.isPluggedIn))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Meldet jede Helligkeitsänderung als Live Activity an.
|
|
///
|
|
/// Nur, wenn dieser Rechner überhaupt eine lesbare Helligkeit hat — auf
|
|
/// einem Mini am Monitor gibt es keine, und dann soll auch nichts
|
|
/// erscheinen. Siehe ``DisplayBrightness``.
|
|
private func observeBrightness() {
|
|
guard brightness.isAvailable else { return }
|
|
withObservationTracking {
|
|
_ = brightness.level
|
|
} onChange: {
|
|
Task { @MainActor [weak self] in
|
|
guard let self else { return }
|
|
defer { observeBrightness() }
|
|
guard let level = self.brightness.level else { return }
|
|
|
|
guard let previous = self.lastBrightness else {
|
|
self.lastBrightness = level
|
|
return
|
|
}
|
|
self.lastBrightness = level
|
|
// Ein Hauch Unterschied ist kein Ereignis: die Meldung kommt
|
|
// auch bei automatischer Anpassung an das Umgebungslicht, und
|
|
// die kriecht in winzigen Schritten.
|
|
guard abs(level - previous) >= Self.brightnessStep else { return }
|
|
self.activities.raise(BrightnessActivity(level: level))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Ab welchem Sprung eine Helligkeitsänderung als Handgriff gilt.
|
|
///
|
|
/// Ein Tastendruck ändert sie um rund ein Sechzehntel; das Umgebungslicht
|
|
/// kriecht in viel kleineren Schritten.
|
|
private static let brightnessStep = 0.02
|
|
|
|
/// Meldet jeden **Titelwechsel** als Live Activity an.
|
|
///
|
|
/// Nicht jede Änderung an `nowPlaying`: dort wandert die Abspielposition
|
|
/// im Sekundentakt weiter, und das ist kein Ereignis. Verglichen wird
|
|
/// deshalb Titel und Interpret, nicht der ganze Zustand.
|
|
///
|
|
/// Auch hier meldet der erste gelesene Titel nichts — beim Start läuft
|
|
/// vielleicht seit einer Stunde dasselbe Stück.
|
|
private func observeMedia() {
|
|
guard let mediaModel else { return }
|
|
withObservationTracking {
|
|
_ = mediaModel.nowPlaying
|
|
} onChange: {
|
|
Task { @MainActor [weak self] in
|
|
guard let self else { return }
|
|
defer { observeMedia() }
|
|
guard let playing = self.mediaModel?.nowPlaying, !playing.title.isEmpty else {
|
|
self.lastTrack = nil
|
|
return
|
|
}
|
|
|
|
let track = "\(playing.title)\u{1}\(playing.artist)"
|
|
guard let previous = self.lastTrack else {
|
|
self.lastTrack = track
|
|
return
|
|
}
|
|
guard track != previous else { return }
|
|
self.lastTrack = track
|
|
// Ein pausierter Titel wechselt nicht von selbst — was hier
|
|
// ankommt, während nichts läuft, ist ein Nachtrag der Quelle
|
|
// und kein Ereignis.
|
|
guard playing.isPlaying else { return }
|
|
self.activities.raise(MediaActivity(title: playing.title,
|
|
artist: playing.artist,
|
|
artwork: playing.artwork))
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc private func openGallery() {
|
|
guard let model else { return }
|
|
galleryWindow.show(model: model)
|
|
}
|
|
|
|
/// Das Glyph aus dem App-Icon, auf Menüleistengröße gebracht.
|
|
///
|
|
/// Nicht das vollständige App-Icon: das bringt die abgerundete Kachel samt
|
|
/// Farbverlauf mit, und die gehört in Dock und Finder, nicht in die
|
|
/// Menüleiste. Dort steht sie als farbiger Klotz zwischen lauter
|
|
/// Strichsymbolen.
|
|
///
|
|
/// **Eine eigene Konturfassung, nicht das App-Icon.**
|
|
///
|
|
/// Das Glyph des App-Icons besteht aus deckenden Flächen in sehr dunklen
|
|
/// Tönen. Auf dem blauen Verlauf des Icons liest es sich als Kristall,
|
|
/// allein auf einer dunklen Menüleiste ist es schwarz auf schwarz. Und als
|
|
/// Template-Bild — der einzige Weg, macOS zum Einfärben zu bewegen —
|
|
/// verschmelzen die Facetten zu einer flachen Silhouette, weil dabei nur
|
|
/// der Alphakanal zählt.
|
|
///
|
|
/// `MenuBarIcon.svg` ist deshalb als Kontur gezeichnet: zwischen den Linien
|
|
/// ist nichts, also bleibt beim Einfärben die Struktur erhalten. Das Symbol
|
|
/// wird damit automatisch weiß auf dunkler und schwarz auf heller
|
|
/// Menüleiste, ohne zweite Datei für den zweiten Fall.
|
|
///
|
|
/// 18 pt ist die übliche Höhe; die Leiste ist 22 pt hoch und braucht oben
|
|
/// und unten Luft.
|
|
private static func menuBarIcon() -> NSImage {
|
|
let size = NSSize(width: 18, height: 18)
|
|
|
|
if let url = Bundle.main.url(forResource: "MenuBarIcon", withExtension: "svg"),
|
|
let glyph = NSImage(contentsOf: url) {
|
|
let image = NSImage(size: size, flipped: false) { rect in
|
|
glyph.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1)
|
|
return true
|
|
}
|
|
image.isTemplate = true
|
|
image.accessibilityDescription = "Onyx"
|
|
return image
|
|
}
|
|
|
|
// Ein Menüleisteneintrag ohne Bild wäre unsichtbar und die App darüber
|
|
// unerreichbar — deshalb ein Rückfall statt eines leeren Knopfs.
|
|
let fallback = NSImage(systemSymbolName: "circle.hexagongrid.fill",
|
|
accessibilityDescription: "Onyx") ?? NSImage()
|
|
fallback.isTemplate = true
|
|
return fallback
|
|
}
|
|
|
|
private func observeMenuBarPreference() {
|
|
guard let model else { return }
|
|
withObservationTracking {
|
|
_ = model.showsMenuBarIcon
|
|
} onChange: {
|
|
Task { @MainActor [weak self] in
|
|
self?.onyxItem?.isVisible = model.showsMenuBarIcon
|
|
self?.observeMenuBarPreference()
|
|
}
|
|
}
|
|
onyxItem?.isVisible = model.showsMenuBarIcon
|
|
}
|
|
|
|
@objc private func togglePanel() { coordinator?.togglePanelUnderPointer() }
|
|
|
|
@objc private func openSettings() { showSettings(section: .general) }
|
|
|
|
private func showSettings(section: SettingsSection) {
|
|
guard let model, let calendarModel, let weatherModel else { return }
|
|
settingsWindow.show(model: model, calendarModel: calendarModel,
|
|
weatherModel: weatherModel, metricsModel: metricsModel,
|
|
shelfStore: shelfStore, fanControl: fanControl,
|
|
lockController: lockController,
|
|
launchAtLogin: launchAtLogin,
|
|
showOnboarding: { [weak self] in self?.showOnboarding() },
|
|
section: section)
|
|
}
|
|
|
|
@objc private func quit() { NSApp.terminate(nil) }
|
|
|
|
}
|
|
|
|
/// Der Inhalt des Panels. Liest `model.layout` und zeichnet sich damit neu,
|
|
/// sobald in den Einstellungen etwas geändert wird.
|
|
private struct NotchPanelContent: View {
|
|
let model: AppModel
|
|
let displayID: CGDirectDisplayID
|
|
|
|
var body: some View {
|
|
WidgetGrid(placements: model.layout,
|
|
availableWidth: model.availableWidth(forDisplay: displayID))
|
|
// Im Rumpf gelesen, damit ein Farbwechsel ankommt.
|
|
.tint(Onyx.Color.accent)
|
|
.labelStyle(.onyx)
|
|
}
|
|
}
|