Phase 1: Anmeldung, Bibliothek, Detailseiten, Hybrid-Player

Die Datenschicht: - plex.tv-Anmeldung über das PIN-Verfahren, Token im Schlüsselbund - Serversuche und Verbindungsauswahl nach Rang (lokal vor direkt vor Vermittlung), mit Abgleich der Server-Kennung gegen veraltete plex.direct-Adressen - PlexServer als einzige Stelle, an der die App Endpunkte kennt: Mediatheken, Hubs, seitenweises Blättern mit Filtern, Metadaten, Staffeln/Folgen, Suche Die Oberfläche: - Startseite mit Aufmacher und den Reihen vom Server - Mediathek als Raster oder Liste, mit Filter- und Sortierblatt - Detailseiten für Filme, Folgen, Serien und Staffeln inkl. Besetzung, Fassungsauswahl und aufklappbaren technischen Angaben - Suche mit gemerkten Anfragen - Vollbildplayer mit eigenem Chrome Der Player: - AVPlayerEngine und VLCPlayerEngine hinter einem gemeinsamen Protokoll - VLCKit liegt in einem eigenen Package (FlixyVLC), damit `swift test` in FlixyKit nicht das 920-MB-Binärpaket mitzieht Am echten plex.tv geprüft: der Anmeldecode kommt an. Dabei fiel auf, dass `strong=true` einen dreißigstelligen Code liefert, der sich bei plex.tv/link nicht eintippen lässt — jetzt der kurze. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-11 16:46:28 +02:00
parent 1ed64bf166
commit 9a69df4635
44 changed files with 6311 additions and 138 deletions
@@ -0,0 +1,110 @@
+import Foundation
+
+/// Sucht den besten erreichbaren Weg zu einem Server.
+///
+/// Geht die Wege nach Rang durch — erst lokal, dann direkt von außen, zuletzt
+/// über die Vermittlung von Plex. Innerhalb eines Rangs laufen die Versuche
+/// gleichzeitig, weil sie sich gegenseitig nicht ausschließen und ein
+/// unerreichbarer Weg sonst die volle Zeitüberschreitung kostet, bevor der
+/// nächste überhaupt beginnt.
+public struct PlexConnectionSelector: Sendable {
+    private let identity: PlexClientIdentity
+    private let transport: any PlexTransport
+    private let probeTimeout: Duration
+
+    public init(
+        identity: PlexClientIdentity,
+        transport: any PlexTransport = URLSession.shared,
+        probeTimeout: Duration = .seconds(5)
+    ) {
+        self.identity = identity
+        self.transport = transport
+        self.probeTimeout = probeTimeout
+    }
+
+    public func selectConnection(for resource: PlexResource) async -> PlexConnection? {
+        guard let token = resource.accessToken else { return nil }
+
+        let tiers = Dictionary(grouping: resource.connections, by: \.tier)
+        for tier in tiers.keys.sorted() {
+            guard let candidates = tiers[tier] else { continue }
+            if let winner = await race(candidates, token: token, expecting: resource.clientIdentifier) {
+                return winner
+            }
+        }
+        return nil
+    }
+
+    /// Lässt die Wege eines Rangs gegeneinander antreten; der erste, der sich
+    /// korrekt ausweist, gewinnt.
+    private func race(
+        _ connections: [PlexConnection],
+        token: String,
+        expecting clientIdentifier: String
+    ) async -> PlexConnection? {
+        await withTaskGroup(of: PlexConnection?.self) { group in
+            for connection in connections {
+                group.addTask {
+                    await probe(connection, token: token, expecting: clientIdentifier) ? connection : nil
+                }
+            }
+
+            for await result in group {
+                if let result {
+                    // Die übrigen Versuche interessieren nicht mehr. Ohne das
+                    // Abbrechen liefe eine unerreichbare Adresse noch bis zur
+                    // Zeitüberschreitung weiter und hielte die Aufgabe offen.
+                    group.cancelAll()
+                    return result
+                }
+            }
+            return nil
+        }
+    }
+
+    /// Fragt `/identity` ab — der einzige Endpunkt, der ohne Token antwortet
+    /// und die Kennung des Servers nennt.
+    private func probe(
+        _ connection: PlexConnection,
+        token: String,
+        expecting clientIdentifier: String
+    ) async -> Bool {
+        guard let baseURL = connection.url else { return false }
+
+        let client = PlexHTTPClient(
+            baseURL: baseURL,
+            identity: identity,
+            token: token,
+            transport: transport
+        )
+
+        do {
+            let identityResponse = try await client.send(
+                PlexRequest(path: "/identity"),
+                as: PlexIdentity.self
+            )
+            // Der Abgleich der Kennung ist keine Förmlichkeit: eine veraltete
+            // plex.direct-Adresse kann auf einen fremden Server zeigen, und
+            // ohne Prüfung würde die App fremde Mediatheken anzeigen.
+            return identityResponse.machineIdentifier == clientIdentifier
+        } catch {
+            return false
+        }
+    }
+}
+
+/// Die Antwort von `/identity`.
+public struct PlexIdentity: Sendable, Decodable {
+    public let machineIdentifier: String
+    public let version: String?
+
+    private enum OuterKeys: String, CodingKey { case mediaContainer = "MediaContainer" }
+    private enum InnerKeys: String, CodingKey { case machineIdentifier, version }
+
+    public init(from decoder: any Decoder) throws {
+        let outer = try decoder.container(keyedBy: OuterKeys.self)
+        let inner = try outer.nestedContainer(keyedBy: InnerKeys.self, forKey: .mediaContainer)
+        self.machineIdentifier = try inner.decode(String.self, forKey: .machineIdentifier)
+        self.version = try inner.decodeIfPresent(String.self, forKey: .version)
+    }
+}