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>
2026-09-11 17:54:17 +02:00
parent b7fc18823a
commit 5c0c1d651d
14 changed files with 924 additions and 7 deletions
@@ -0,0 +1,126 @@
+import Foundation
+
+/// Was beim Live-TV herauskommen kann.
+public enum LiveTVAvailability: Sendable, Equatable {
+    /// Es gibt einen Empfänger und Sender.
+    case available(dvrs: [PlexDVR])
+    /// Der Server läuft, hat aber keinen Empfänger eingerichtet.
+    ///
+    /// Der mit Abstand häufigste Fall — Live-TV verlangt eine Fernsehkarte
+    /// oder einen Netzwerk-Tuner. Die Oberfläche soll das erklären, statt
+    /// einen Fehler zu zeigen.
+    case notConfigured
+    case failed(message: String)
+}
+
+extension PlexServer {
+    /// Prüft, ob der Server überhaupt Live-TV kann.
+    public func liveTVAvailability() async -> LiveTVAvailability {
+        do {
+            let container = try await client.send(
+                PlexRequest(path: "/livetv/dvrs", timeout: .seconds(10)),
+                as: PlexMediaContainer<PlexDVR>.self
+            )
+            return container.content.isEmpty ? .notConfigured : .available(dvrs: container.content)
+        } catch PlexError.notFound {
+            // Ältere Serverfassungen kennen den Endpunkt gar nicht. Das ist
+            // dasselbe Ergebnis wie „kein Empfänger": es gibt nichts zu sehen.
+            return .notConfigured
+        } catch {
+            return .failed(message: String(describing: error))
+        }
+    }
+
+    /// Die Sender eines Empfängers.
+    public func channels(inDVR dvr: PlexDVR) async throws(PlexError) -> [PlexChannel] {
+        let container = try await client.send(
+            PlexRequest(path: "/livetv/dvrs/\(dvr.key)/channels"),
+            as: PlexMediaContainer<PlexChannel>.self
+        )
+        return container.content
+    }
+
+    /// Die Kennung des Programmanbieters.
+    ///
+    /// Sie wechselt je nach Server und Einrichtung (etwa
+    /// `tv.plex.providers.epg.cloud:2`) und steckt in der Anbieterliste. Fest
+    /// verdrahtet wäre sie auf der Hälfte der Server falsch.
+    public func electronicProgramGuideIdentifier() async -> String? {
+        guard let container = try? await client.send(
+            PlexRequest(path: "/media/providers"),
+            as: PlexMediaContainer<PlexMediaProvider>.self
+        ) else { return nil }
+
+        return container.content.first { $0.identifier.contains("epg") }?.identifier
+    }
+
+    /// Das Programmraster für einen Zeitraum.
+    ///
+    /// Bewusst über einen Zeitraum statt „alles": ein Tag über hundert Sender
+    /// sind mehrere tausend Sendungen, und mehr als die nächsten Stunden
+    /// braucht niemand beim Umschalten.
+    public func guide(
+        providerIdentifier: String,
+        from start: Date,
+        to end: Date
+    ) async throws(PlexError) -> [PlexProgram] {
+        let container = try await client.send(
+            PlexRequest(
+                path: "/\(providerIdentifier)/grid",
+                query: [
+                    // 1 steht bei Plex für „Sendung".
+                    URLQueryItem(name: "type", value: "1"),
+                    URLQueryItem(name: "beginsAt>", value: String(Int(start.timeIntervalSince1970))),
+                    URLQueryItem(name: "endsAt<", value: String(Int(end.timeIntervalSince1970))),
+                ],
+                timeout: .seconds(30)
+            ),
+            as: PlexMediaContainer<PlexGridEntry>.self
+        )
+
+        return container.content.compactMap { entry in
+            // Die Senderzuordnung steckt im Medien-Block. Fehlt sie, lässt
+            // sich die Sendung keiner Spalte zuordnen — dann ist sie für ein
+            // Raster wertlos.
+            let channelID = entry.media?.first?.parts.first?.key
+            return entry.program(channelID: channelID)
+        }
+    }
+
+    /// Schaltet einen Sender ein.
+    ///
+    /// Live-TV kommt immer als umgerechneter Strom: der Tuner liefert einen
+    /// Transportstrom, den kein iPhone direkt abspielt. Deshalb führt der Weg
+    /// hier zwangsläufig über den Transcoder — anders als bei Dateien, wo
+    /// DirectPlay der Normalfall ist.
+    public func tune(channel: PlexChannel, maximumBitrate: Int?) async throws(PlexError) -> URL? {
+        guard let key = channel.key else { return nil }
+
+        let session = UUID().uuidString
+        let container = try await client.send(
+            PlexRequest(
+                path: "/livetv/sessions/\(session)/\(key)",
+                query: [URLQueryItem(name: "X-Plex-Session-Identifier", value: session)],
+                timeout: .seconds(30)
+            ),
+            as: PlexMediaContainer<PlexItem>.self
+        )
+
+        guard let item = container.content.first else { throw .notFound }
+        return transcodeURL(for: TranscodeRequest(
+            ratingKey: item.ratingKey,
+            maximumBitrate: maximumBitrate,
+            isLocal: connection.local,
+            sessionIdentifier: session
+        ))
+    }
+}
+
+/// Ein Anbieter am Server — Mediathek, Programmführer, Entdecken.
+public struct PlexMediaProvider: Sendable, Equatable, Decodable, Identifiable {
+    public let identifier: String
+    public let title: String?
+    public let types: String?
+
+    public var id: String { identifier }
+}