Phase 6: Live-TV, plus Live Activity für Downloads

Live-TV
- An keinem echten Server geprüft: die DVR- und EPG-Endpunkte sind der am
  schlechtesten dokumentierte Teil der Plex-API. Die Modelle sind deshalb
  durchgehend nachsichtig — fehlende Felder ergeben leere Listen, nicht
  Fehler, und die Senderkennung wird als Zahl, Zeichenkette oder uuid
  akzeptiert.
- Ohne eingerichteten Empfänger erklärt die App das, statt einen Fehler
  zu zeigen. Das ist der häufigste Fall.
- Senderliste mit laufender Sendung, Fortschrittsbalken und „danach".
  Der Programmführer wird getrennt geholt: fällt er aus, bleibt das
  Umschalten möglich.
- Die Anbieterkennung wird aus /media/providers gelesen statt fest
  verdrahtet — sie wechselt je nach Server.

Live Activity
- Eigene Widget-Erweiterung; iOS zeichnet den Sperrbildschirm in einem
  getrennten Prozess, während die App meist gar nicht läuft.
- Der Presenter drosselt auf 1,5 Sekunden. ActivityKit verwirft zu
  häufige Aktualisierungen kommentarlos, und der Fortschritt kommt
  mehrmals je Sekunde — ungebremst bliebe die Anzeige stehen.
- @preconcurrency import: Activity und ActivityContent tragen keine
  Sendable-Zusage.

Zwei Stolpersteine unterwegs: canImport(ActivityKit) ist auf macOS wahr,
die Typen darin aber nicht verfügbar — es muss os(iOS) sein. Und eine
von Hand geschriebene Info.plist ohne CFBundleIdentifier führt zu einer
Erweiterung ganz ohne Kennung; der Fehler lautet dann „not prefixed with
the parent app's bundle identifier" und zeigt auf die falsche Stelle.

126 Tests.

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

Packages/FlixyKit/Sources/FlixyDownloads/Engine/DownloadActivityPresenter.swift

@@ -0,0 +1,76 @@
+import Foundation
+
+#if os(iOS)
+// `@preconcurrency`, weil `Activity` und `ActivityContent` keine
+// Sendable-Zusage tragen. Beide bleiben hier ohnehin auf dem Hauptakteur —
+// die Klasse ist darauf festgelegt, und ActivityKit erwartet seine Aufrufe
+// von dort. Ohne diese Zeile lehnt Swift 6 jeden Aufruf ab.
+@preconcurrency import ActivityKit
+
+/// Zeigt den Download-Fortschritt im Sperrbildschirm.
+///
+/// Getrennt vom Koordinator, weil Live Activities eine Reihe eigener Fallen
+/// haben — sie können vom Nutzer abgeschaltet sein, ihre Zahl ist begrenzt,
+/// und eine nicht beendete Activity bleibt stundenlang stehen. Der Koordinator
+/// meldet nur „das läuft gerade"; was daraus wird, entscheidet sich hier.
+@MainActor
+public final class DownloadActivityPresenter {
+    private var activity: Activity<DownloadActivityAttributes>?
+    /// Wann zuletzt aktualisiert wurde.
+    ///
+    /// ActivityKit drosselt häufige Aktualisierungen und verwirft sie
+    /// irgendwann kommentarlos. Der Fortschritt kommt mehrmals je Sekunde —
+    /// ungebremst weitergereicht bliebe die Anzeige irgendwann stehen.
+    private var lastUpdate = Date.distantPast
+    private let minimumInterval: TimeInterval = 1.5
+
+    public init() {}
+
+    /// Bringt die Anzeige auf den neuesten Stand.
+    ///
+    /// `nil` beendet sie — das ist der Fall, wenn nichts mehr läuft.
+    /// `async`, nicht `Task { … }` im Inneren: `Activity` und
+    /// `ActivityContent` sind nicht `Sendable`, und eine Aufgabe würde sie über
+    /// die Isolationsgrenze schicken. So bleibt alles auf dem Hauptakteur.
+    public func update(with state: DownloadActivityAttributes.ContentState?) async {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+
+        guard let state else {
+            await end()
+            return
+        }
+
+        if let activity {
+            guard Date().timeIntervalSince(lastUpdate) >= minimumInterval else { return }
+            lastUpdate = Date()
+            await activity.update(ActivityContent(state: state, staleDate: nil))
+        } else {
+            start(with: state)
+        }
+    }
+
+    private func start(with state: DownloadActivityAttributes.ContentState) {
+        do {
+            activity = try Activity.request(
+                attributes: DownloadActivityAttributes(),
+                content: ActivityContent(state: state, staleDate: nil)
+            )
+            lastUpdate = Date()
+        } catch {
+            // Scheitert meist, weil die Höchstzahl gleichzeitiger Activities
+            // erreicht ist. Kein Grund, den Download anzuhalten — die Anzeige
+            // ist Beiwerk.
+            activity = nil
+        }
+    }
+
+    /// Beendet die Anzeige.
+    public func end() async {
+        guard let activity else { return }
+        self.activity = nil
+        // `.immediate`: eine Download-Anzeige, die nach dem letzten Byte noch
+        // eine Viertelstunde im Sperrbildschirm klebt, ist Müll.
+        await activity.end(nil, dismissalPolicy: .immediate)
+    }
+}
+#endif

Packages/FlixyKit/Sources/FlixyDownloads/Engine/DownloadCoordinator.swift

@@ -119,6 +119,10 @@ public final class DownloadCoordinator {
     private var session: URLSession!
     private let delegate = DownloadSessionDelegate()
 
+    #if os(iOS)
+    private let activityPresenter = DownloadActivityPresenter()
+    #endif
+
     /// Die Konfiguration der Hintergrundsitzung.
     ///
     /// Als eigene Funktion, damit Tests stattdessen eine flüchtige Sitzung
@@ -424,6 +428,7 @@ public final class DownloadCoordinator {
         guard let item = items.first(where: { $0.ratingKey == ratingKey }) else { return }
         item.receivedBytes = received
         if expected > 0 { item.totalBytes = expected }
+        updateActivity()
         // Bewusst ohne `save()`: der Fortschritt kommt mehrmals je Sekunde, und
         // jedes Schreiben wäre eine Plattenoperation. Für die Anzeige reicht
         // die Beobachtung; gespeichert wird bei Zustandswechseln.
@@ -444,6 +449,7 @@ public final class DownloadCoordinator {
             item.completedAt = Date()
             save()
             refreshUsage()
+            updateActivity()
         } catch {
             fail(item, message: error.localizedDescription)
         }
@@ -469,6 +475,33 @@ public final class DownloadCoordinator {
         item.state = .failed
         item.failureMessage = message
         save()
+        updateActivity()
+    }
+
+    /// Hält die Anzeige im Sperrbildschirm auf dem Stand.
+    ///
+    /// Zeigt den am weitesten fortgeschrittenen Download — bei zwei
+    /// gleichzeitigen ist das der, der zuerst fertig wird, und damit der, auf
+    /// den man wartet.
+    private func updateActivity() {
+        #if os(iOS)
+        let running = items.filter { $0.state == .downloading }
+        guard let leading = running.max(by: { ($0.progress ?? 0) < ($1.progress ?? 0) }) else {
+            Task { [activityPresenter] in await activityPresenter.update(with: nil) }
+            return
+        }
+
+        // Der Zustand wird hier gebaut, nicht in der Aufgabe: SwiftData-Objekte
+        // gehören dem Hauptakteur, der reine Wertetyp darf wandern.
+        let state = DownloadActivityAttributes.ContentState(
+            title: leading.title,
+            progress: leading.progress,
+            receivedBytes: leading.receivedBytes,
+            totalBytes: leading.totalBytes,
+            remainingCount: items.filter { $0.state.isTransferable }.count + running.count - 1
+        )
+        Task { [activityPresenter] in await activityPresenter.update(with: state) }
+        #endif
     }
 
     // MARK: - Innereien

Packages/FlixyKit/Sources/FlixyDownloads/Model/DownloadActivityAttributes.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+// `os(iOS)` statt `canImport(ActivityKit)`: der Import gelingt auch auf
+// macOS, die Typen darin sind dort aber als nicht verfügbar markiert. Eine
+// Prüfung auf den Import allein übersetzt deshalb nicht.
+#if os(iOS)
+import ActivityKit
+
+/// Was im Sperrbildschirm und in der Dynamic Island steht.
+///
+/// Liegt in FlixyDownloads, weil App und Widget-Erweiterung denselben Typ
+/// brauchen — zwei getrennte Kopien wären die klassische Quelle für eine Live
+/// Activity, die sich nicht mehr aktualisieren lässt: ActivityKit gleicht die
+/// Typen über ihren vollen Namen ab.
+public struct DownloadActivityAttributes: ActivityAttributes {
+    public struct ContentState: Codable, Hashable, Sendable {
+        /// Der Titel, der gerade lädt.
+        public var title: String
+        /// 0…1, oder `nil` solange die Gesamtgröße unbekannt ist.
+        public var progress: Double?
+        public var receivedBytes: Int64
+        public var totalBytes: Int64
+        /// Wie viele weitere in der Warteschlange stehen.
+        public var remainingCount: Int
+
+        public init(
+            title: String,
+            progress: Double?,
+            receivedBytes: Int64,
+            totalBytes: Int64,
+            remainingCount: Int
+        ) {
+            self.title = title
+            self.progress = progress
+            self.receivedBytes = receivedBytes
+            self.totalBytes = totalBytes
+            self.remainingCount = remainingCount
+        }
+    }
+
+    /// Bleibt über die Laufzeit gleich. Hier leer: welcher Titel lädt, wechselt
+    /// im Laufe einer Staffel und gehört deshalb in den Zustand.
+    public init() {}
+}
+#endif