chore(repo): iOS-App als ios/ ins Hauptrepo uebernehmen

Calendarr-IOS wird mit vollstaendiger Historie als Unterverzeichnis ios/ eingebunden. Damit liegen Server, Web, Android und iOS in einem gemeinsamen Repo. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-14 09:20:12 +02:00
parent 560457945c 31d7a0080e
commit 6e981e7aea
107 changed files with 19373 additions and 0 deletions
@@ -0,0 +1,82 @@
+import BackgroundTasks
+import Foundation
+import CalendarrCore
+
+/// Keeps the shared snapshot fresh while the app is not in the foreground.
+///
+/// Without this, `publishWidgetSnapshot()` only ever runs from a user action,
+/// so an event created on the web or on Android does not reach the widgets — or
+/// the watch — until the app is opened again. iOS decides when this actually
+/// runs, based on how the user uses the app: it improves freshness, it does not
+/// guarantee it.
+@MainActor
+enum BackgroundRefresh {
+    static let taskIdentifier = "com.scarriffleservices.calendarr.ios.refresh"
+
+    /// Minimum gap between runs we ask for. iOS treats this as the earliest
+    /// acceptable time, not a promise.
+    private static let interval: TimeInterval = 30 * 60
+
+    /// Call once at launch, before the app finishes starting up.
+    static func register() {
+        BGTaskScheduler.shared.register(forTaskWithIdentifier: taskIdentifier,
+                                        using: nil) { task in
+            guard let refresh = task as? BGAppRefreshTask else {
+                task.setTaskCompleted(success: false)
+                return
+            }
+            Task { @MainActor in await handle(refresh) }
+        }
+    }
+
+    /// Ask for the next run. Safe to call repeatedly; a duplicate submission
+    /// replaces the pending request rather than queueing a second one.
+    static func schedule() {
+        let request = BGAppRefreshTaskRequest(identifier: taskIdentifier)
+        request.earliestBeginDate = Date(timeIntervalSinceNow: interval)
+        do { try BGTaskScheduler.shared.submit(request) }
+        catch {
+            // Submission fails on a simulator and when the user has disabled
+            // background refresh. Neither is worth interrupting anyone over.
+            print("[BackgroundRefresh] submit failed: \(error.localizedDescription)")
+        }
+    }
+
+    private static func handle(_ task: BGAppRefreshTask) async {
+        // Reschedule first: if the work below throws or is killed, the chain
+        // must not end here.
+        schedule()
+
+        let work = Task { @MainActor in await refreshSnapshot() }
+        task.expirationHandler = { work.cancel() }
+
+        let succeeded = await work.value
+        task.setTaskCompleted(success: succeeded)
+    }
+
+    /// Fetch the snapshot window and republish. Returns false when there was
+    /// nothing to do or the fetch failed.
+    private static func refreshSnapshot() async -> Bool {
+        let state = AppState()
+        guard state.isConfigured, state.isLoggedIn else { return false }
+
+        // An SSO session can lapse while the app is closed; renewing first
+        // avoids spending the whole background window on a 401.
+        await OIDCSessionRefresher.refreshIfNeeded(state)
+
+        let api = CalendarrAPI(baseURL: state.serverURL, token: state.authToken)
+        let store = CalendarStore()
+
+        let calendar = Calendar(identifier: .gregorian)
+        let dayStart = calendar.startOfDay(for: Date())
+        guard let from = calendar.date(byAdding: .day, value: -SnapshotCoverage.daysBehind, to: dayStart),
+              let to = calendar.date(byAdding: .day, value: SnapshotCoverage.daysAhead, to: dayStart)
+        else { return false }
+
+        // force: a freshly created store has an empty in-memory cache, so
+        // without this the "already cached" short-circuit would skip the fetch.
+        await store.loadEvents(api: api, start: from, end: to, force: true)
+
+        return store.lastError == nil
+    }
+}