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>
This commit is contained in:
Guido
Claude Opus 5
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
import Foundation
|
||||
|
||||
/// Ein Gerät, das am Plex-Konto hängt — für uns nur Server interessant.
|
||||
public struct PlexResource: Sendable, Equatable, Decodable, Identifiable {
|
||||
public let name: String
|
||||
public let product: String?
|
||||
public let productVersion: String?
|
||||
public let platform: String?
|
||||
public let clientIdentifier: String
|
||||
public let provides: String
|
||||
public let owned: Bool
|
||||
/// Der Token für genau diesen Server.
|
||||
///
|
||||
/// Nicht derselbe wie der Konto-Token: bei geteilten Servern bekommt man
|
||||
/// einen eigenen, eingeschränkten. Wer stattdessen den Konto-Token
|
||||
/// verwendet, bekommt bei fremden Servern wortlos 401.
|
||||
public let accessToken: String?
|
||||
public let connections: [PlexConnection]
|
||||
|
||||
public var id: String { clientIdentifier }
|
||||
|
||||
/// Ob es sich um einen Medienserver handelt — `provides` kann auch
|
||||
/// „client", „player" oder eine Kombination sein.
|
||||
public var isServer: Bool {
|
||||
provides.split(separator: ",").contains("server")
|
||||
}
|
||||
|
||||
private enum CodingKeys: String, CodingKey {
|
||||
case name, product, productVersion, platform, clientIdentifier
|
||||
case provides, owned, accessToken, connections
|
||||
}
|
||||
|
||||
public init(from decoder: any Decoder) throws {
|
||||
let values = try decoder.container(keyedBy: CodingKeys.self)
|
||||
self.name = try values.decode(String.self, forKey: .name)
|
||||
self.product = try values.decodeIfPresent(String.self, forKey: .product)
|
||||
self.productVersion = try values.decodeIfPresent(String.self, forKey: .productVersion)
|
||||
self.platform = try values.decodeIfPresent(String.self, forKey: .platform)
|
||||
self.clientIdentifier = try values.decode(String.self, forKey: .clientIdentifier)
|
||||
self.provides = try values.decodeIfPresent(String.self, forKey: .provides) ?? ""
|
||||
self.owned = try values.decodeIfPresent(Bool.self, forKey: .owned) ?? false
|
||||
self.accessToken = try values.decodeIfPresent(String.self, forKey: .accessToken)
|
||||
self.connections = try values.decodeIfPresent([PlexConnection].self, forKey: .connections) ?? []
|
||||
}
|
||||
|
||||
public init(
|
||||
name: String,
|
||||
clientIdentifier: String,
|
||||
provides: String = "server",
|
||||
owned: Bool = true,
|
||||
accessToken: String? = nil,
|
||||
connections: [PlexConnection] = [],
|
||||
product: String? = nil,
|
||||
productVersion: String? = nil,
|
||||
platform: String? = nil
|
||||
) {
|
||||
self.name = name
|
||||
self.product = product
|
||||
self.productVersion = productVersion
|
||||
self.platform = platform
|
||||
self.clientIdentifier = clientIdentifier
|
||||
self.provides = provides
|
||||
self.owned = owned
|
||||
self.accessToken = accessToken
|
||||
self.connections = connections
|
||||
}
|
||||
}
|
||||
|
||||
/// Ein Weg zu einem Server.
|
||||
public struct PlexConnection: Sendable, Equatable, Decodable, Identifiable {
|
||||
public let uri: String
|
||||
public let address: String?
|
||||
public let port: Int?
|
||||
public let local: Bool
|
||||
/// Ob der Weg über die Vermittlung von Plex läuft. Der ist immer
|
||||
/// erreichbar, aber auf wenige Mbit gedrosselt — taugt für Metadaten,
|
||||
/// nicht für 4K.
|
||||
public let relay: Bool
|
||||
public let `protocol`: String?
|
||||
public let iPv6: Bool
|
||||
|
||||
public var id: String { uri }
|
||||
public var url: URL? { URL(string: uri) }
|
||||
|
||||
private enum CodingKeys: String, CodingKey {
|
||||
case uri, address, port, local, relay
|
||||
case `protocol`
|
||||
case iPv6 = "IPv6"
|
||||
}
|
||||
|
||||
public init(from decoder: any Decoder) throws {
|
||||
let values = try decoder.container(keyedBy: CodingKeys.self)
|
||||
self.uri = try values.decode(String.self, forKey: .uri)
|
||||
self.address = try values.decodeIfPresent(String.self, forKey: .address)
|
||||
self.port = try values.decodeIfPresent(Int.self, forKey: .port)
|
||||
self.local = try values.decodeIfPresent(Bool.self, forKey: .local) ?? false
|
||||
self.relay = try values.decodeIfPresent(Bool.self, forKey: .relay) ?? false
|
||||
self.protocol = try values.decodeIfPresent(String.self, forKey: .protocol)
|
||||
self.iPv6 = try values.decodeIfPresent(Bool.self, forKey: .iPv6) ?? false
|
||||
}
|
||||
|
||||
public init(
|
||||
uri: String,
|
||||
local: Bool = false,
|
||||
relay: Bool = false,
|
||||
address: String? = nil,
|
||||
port: Int? = nil,
|
||||
protocol: String? = nil,
|
||||
iPv6: Bool = false
|
||||
) {
|
||||
self.uri = uri
|
||||
self.local = local
|
||||
self.relay = relay
|
||||
self.address = address
|
||||
self.port = port
|
||||
self.protocol = `protocol`
|
||||
self.iPv6 = iPv6
|
||||
}
|
||||
|
||||
/// In welcher Reihenfolge die Wege probiert werden.
|
||||
///
|
||||
/// Nicht „wer zuerst antwortet, gewinnt": die Vermittlung von Plex meldet
|
||||
/// sich oft schneller als der Server im eigenen Netz, ist aber gedrosselt.
|
||||
/// Ein Rennen ohne Rangordnung würde also ausgerechnet den langsamsten Weg
|
||||
/// prämieren.
|
||||
public var tier: Int {
|
||||
if local { return 0 }
|
||||
if relay { return 2 }
|
||||
return 1
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
import Foundation
|
||||
|
||||
/// Holt die Serverliste vom Konto.
|
||||
public actor PlexServerDirectory {
|
||||
private let client: PlexHTTPClient
|
||||
|
||||
public init(
|
||||
identity: PlexClientIdentity,
|
||||
token: String,
|
||||
transport: any PlexTransport = URLSession.shared
|
||||
) {
|
||||
self.client = PlexHTTPClient(
|
||||
baseURL: URL(string: "https://plex.tv")!,
|
||||
identity: identity,
|
||||
token: token,
|
||||
transport: transport
|
||||
)
|
||||
}
|
||||
|
||||
/// Alle Medienserver, auf die das Konto Zugriff hat — eigene und geteilte.
|
||||
public func servers() async throws(PlexError) -> [PlexResource] {
|
||||
let resources = try await client.send(
|
||||
PlexRequest(path: "/api/v2/resources", query: [
|
||||
// Ohne diese beiden Schalter fehlen in der Antwort die
|
||||
// plex.direct-Adressen und die Vermittlung — übrig bliebe nur
|
||||
// die lokale IP, und außer Haus ginge gar nichts.
|
||||
URLQueryItem(name: "includeHttps", value: "1"),
|
||||
URLQueryItem(name: "includeRelay", value: "1"),
|
||||
]),
|
||||
as: [PlexResource].self
|
||||
)
|
||||
return resources.filter(\.isServer)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user