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