Create Lock Screen Reminder Widget

DynamicIsland/managers/LockScreenReminderWidgetManager.swift

@@ -0,0 +1,209 @@
+import Foundation
+import Combine
+import Defaults
+import SwiftUI
+import AppKit
+
+@MainActor
+final class LockScreenReminderWidgetManager: ObservableObject {
+    static let shared = LockScreenReminderWidgetManager()
+
+    @Published private(set) var snapshot: LockScreenReminderWidgetSnapshot?
+
+    private let reminderManager = ReminderLiveActivityManager.shared
+    private var cancellables = Set<AnyCancellable>()
+
+    private let timeFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .none
+        formatter.timeStyle = .short
+        return formatter
+    }()
+
+    private init() {
+        observeReminderUpdates()
+        observeDefaults()
+    }
+
+    func showReminderWidget() {
+        guard Defaults[.enableLockScreenReminderWidget] else {
+            LockScreenReminderWidgetPanelManager.shared.hide()
+            return
+        }
+
+        if let snapshot {
+            LockScreenReminderWidgetPanelManager.shared.show(with: snapshot)
+        } else {
+            recomputeSnapshot(now: reminderManager.currentDate)
+            if let snapshot {
+                LockScreenReminderWidgetPanelManager.shared.show(with: snapshot)
+            } else {
+                LockScreenReminderWidgetPanelManager.shared.hide()
+            }
+        }
+    }
+
+    func hideReminderWidget() {
+        LockScreenReminderWidgetPanelManager.shared.hide()
+    }
+
+    private func observeReminderUpdates() {
+        reminderManager.$activeReminder
+            .receive(on: RunLoop.main)
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.recomputeSnapshot(now: self.reminderManager.currentDate)
+            }
+            .store(in: &cancellables)
+
+        reminderManager.$currentDate
+            .receive(on: RunLoop.main)
+            .sink { [weak self] now in
+                guard let self else { return }
+                self.recomputeSnapshot(now: now)
+            }
+            .store(in: &cancellables)
+    }
+
+    private func observeDefaults() {
+        Defaults.publisher(.enableLockScreenReminderWidget, options: [])
+            .sink { [weak self] change in
+                guard let self else { return }
+                if change.newValue {
+                    self.recomputeSnapshot(now: self.reminderManager.currentDate)
+                    self.showReminderWidgetIfPossible()
+                } else {
+                    self.snapshot = nil
+                    LockScreenReminderWidgetPanelManager.shared.hide()
+                }
+            }
+            .store(in: &cancellables)
+
+        Defaults.publisher(.lockScreenReminderChipStyle, options: [])
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.recomputeSnapshot(now: self.reminderManager.currentDate)
+            }
+            .store(in: &cancellables)
+    }
+
+    private func showReminderWidgetIfPossible() {
+        guard LockScreenManager.shared.currentLockStatus else { return }
+        guard Defaults[.enableLockScreenReminderWidget] else { return }
+        if let snapshot {
+            LockScreenReminderWidgetPanelManager.shared.show(with: snapshot)
+        } else {
+            LockScreenReminderWidgetPanelManager.shared.hide()
+        }
+    }
+
+    private func recomputeSnapshot(now: Date) {
+        guard Defaults[.enableLockScreenReminderWidget] else {
+            snapshot = nil
+            LockScreenReminderWidgetPanelManager.shared.hide()
+            return
+        }
+
+        guard let entry = reminderManager.activeReminder else {
+            snapshot = nil
+            LockScreenReminderWidgetPanelManager.shared.hide()
+            return
+        }
+
+        let snapshot = makeSnapshot(from: entry, now: now)
+        if self.snapshot != snapshot {
+            self.snapshot = snapshot
+        }
+        deliver(snapshot)
+    }
+
+    private func deliver(_ snapshot: LockScreenReminderWidgetSnapshot) {
+        guard LockScreenManager.shared.currentLockStatus else { return }
+        if LockScreenReminderWidgetPanelManager.shared.isVisible {
+            LockScreenReminderWidgetPanelManager.shared.update(with: snapshot)
+        } else {
+            LockScreenReminderWidgetPanelManager.shared.show(with: snapshot)
+        }
+    }
+
+    private func makeSnapshot(from entry: ReminderLiveActivityManager.ReminderEntry, now: Date) -> LockScreenReminderWidgetSnapshot {
+        let title = entry.event.title.isEmpty ? "Upcoming Reminder" : entry.event.title
+        let timeText = timeFormatter.string(from: entry.event.start)
+        let isCritical = criticalWindowContains(entry: entry, now: now)
+        let relative = relativeDescription(for: entry, now: now)
+        let accent = accentColor(for: entry, isCritical: isCritical)
+        let iconName = isCritical ? ReminderLiveActivityManager.criticalIconName : ReminderLiveActivityManager.standardIconName
+
+        return LockScreenReminderWidgetSnapshot(
+            title: title,
+            eventTimeText: timeText,
+            relativeDescription: relative,
+            accent: accent,
+            chipStyle: Defaults[.lockScreenReminderChipStyle],
+            isCritical: isCritical,
+            iconName: iconName
+        )
+    }
+
+    private func accentColor(for entry: ReminderLiveActivityManager.ReminderEntry, isCritical: Bool) -> LockScreenReminderWidgetSnapshot.RGBAColor {
+        if isCritical {
+            return LockScreenReminderWidgetSnapshot.RGBAColor(nsColor: .systemRed)
+        }
+
+        let boosted = Color(nsColor: entry.event.calendar.color).ensureMinimumBrightness(factor: 0.7)
+        return LockScreenReminderWidgetSnapshot.RGBAColor(nsColor: NSColor(boosted))
+    }
+
+    private func relativeDescription(for entry: ReminderLiveActivityManager.ReminderEntry, now: Date) -> String? {
+        let remaining = entry.event.start.timeIntervalSince(now)
+        if remaining <= 0 {
+            return "now"
+        }
+
+        let minutes = Int(ceil(remaining / 60))
+        if minutes <= 0 {
+            return "now"
+        }
+        if minutes == 1 {
+            return "in 1 min"
+        }
+        return "in \(minutes) min"
+    }
+
+    private func criticalWindowContains(entry: ReminderLiveActivityManager.ReminderEntry, now: Date) -> Bool {
+        let window = TimeInterval(Defaults[.reminderSneakPeekDuration])
+        guard window > 0 else { return false }
+        let remaining = entry.event.start.timeIntervalSince(now)
+        return remaining > 0 && remaining <= window
+    }
+}
+
+struct LockScreenReminderWidgetSnapshot: Equatable {
+    struct RGBAColor: Equatable {
+        let red: Double
+        let green: Double
+        let blue: Double
+        let alpha: Double
+
+        init(nsColor: NSColor) {
+            let color = nsColor.usingColorSpace(.sRGB) ?? nsColor
+            self.red = Double(color.redComponent)
+            self.green = Double(color.greenComponent)
+            self.blue = Double(color.blueComponent)
+            self.alpha = Double(color.alphaComponent)
+        }
+
+        var color: Color {
+            Color(red: red, green: green, blue: blue, opacity: alpha)
+        }
+    }
+
+    let title: String
+    let eventTimeText: String
+    let relativeDescription: String?
+    let accent: RGBAColor
+    let chipStyle: LockScreenReminderChipStyle
+    let isCritical: Bool
+    let iconName: String
+}
+