Wetter: Zwischenspeicher auf Platte, Zeitlimits auf alle Netzaufrufe

Das Protokoll zeigte das Wetter nach 185 ms erfolgreich geladen — und
danach nichts mehr. Dazwischen liegt genau ein Aufruf, der noch ins Netz
geht: die Abfrage der Namensnennung. Sie hatte kein Zeitlimit, und ohne
sie wurde der Schnappschuss nie gebaut. Ein Netzaufruf ohne Zeitlimit ist
ein Aufruf, der hängen darf.

Jetzt hat jeder ein Limit: Wetter zwölf Sekunden, Ortung acht, Umkehrsuche
fünf, Namensnennung drei. Die Namensnennung hält den Messwert ohnehin nicht
mehr auf — sie ist Pflicht für die Anzeige, nicht für das Laden — und wird
behalten, weil sie sich nicht ändert.

Der Zwischenspeicher lag nur im Arbeitsspeicher. Beim Start stand deshalb
ein Rädchen da, bis der erste Abruf durch war; hing der, für immer. Er
liegt jetzt in weather.json und wird beim Anlegen des Modells gelesen: das
Widget zeigt sofort, was zuletzt bekannt war, mit Zeitstempel, und lädt im
Hintergrund nach. Ein Wert von vor einer Stunde ist eine Auskunft, ein
Rädchen ist keine.

Nachgeprüft: Datei wird geschrieben, Hamburg mit zwölf Stundenwerten.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/OnyxKit/Sources/WeatherProvider/WeatherCache.swift

@@ -12,8 +12,32 @@ public struct WeatherCache: Sendable {
     public static let maxAge: TimeInterval = 15 * 60
 
     private var entries: [String: WeatherSnapshot] = [:]
+    private let url: URL?
 
-    public init() {}
+    /// Liest beim Anlegen, was zuletzt bekannt war.
+    ///
+    /// Der Zwischenspeicher liegt auf der Platte und nicht nur im Arbeits-
+    /// speicher: sonst steht beim Start ein Rädchen da, bis der erste Abruf
+    /// durch ist — und wenn der hängt, für immer. Ein Wert von vor einer
+    /// Stunde mit Zeitstempel ist die bessere Auskunft.
+    public init(url: URL? = WeatherCache.standardURL) {
+        self.url = url
+        guard let url, let data = try? Data(contentsOf: url) else { return }
+        // Eine unlesbare Datei ist kein Grund, das Widget aufzugeben.
+        entries = (try? JSONDecoder().decode([String: WeatherSnapshot].self, from: data)) ?? [:]
+    }
+
+    public static var standardURL: URL? {
+        FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?
+            .appendingPathComponent("Onyx/weather.json")
+    }
+
+    public func save() throws {
+        guard let url else { return }
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(),
+                                                withIntermediateDirectories: true)
+        try JSONEncoder().encode(entries).write(to: url, options: .atomic)
+    }
 
     /// Der Stand, wenn er noch frisch genug ist.
     public func valid(for place: WeatherPlace, now: Date = Date()) -> WeatherSnapshot? {
@@ -77,3 +101,23 @@ public extension WeatherCondition {
         }
     }
 }
+
+/// Führt einen Aufruf mit Zeitlimit aus.
+///
+/// WeatherKit hat keines. Beim Testen lieferte es das Wetter in 185 ms und
+/// blieb danach beim Abruf der Namensnennung stehen — das Widget zeigte für
+/// immer ein Rädchen. Ein Netzaufruf ohne Zeitlimit ist ein Aufruf, der
+/// hängen darf.
+func withTimeout<T: Sendable>(seconds: TimeInterval,
+                              operation: @escaping @Sendable () async -> T) async -> T? {
+    await withTaskGroup(of: T?.self) { group in
+        group.addTask { await operation() }
+        group.addTask {
+            try? await Task.sleep(for: .seconds(seconds))
+            return nil
+        }
+        let first = await group.next() ?? nil
+        group.cancelAll()
+        return first
+    }
+}