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,108 @@
|
||||
import Foundation
|
||||
|
||||
/// Führt die Anmeldung bei plex.tv durch.
|
||||
public actor PlexAuthenticator {
|
||||
/// Wo das Konto-Token im Schlüsselbund steht.
|
||||
public static let accountTokenAccount = "plex.account"
|
||||
|
||||
private let client: PlexHTTPClient
|
||||
private let identity: PlexClientIdentity
|
||||
private let tokenStore: any TokenStoring
|
||||
private let clock: any Clock<Duration>
|
||||
|
||||
public init(
|
||||
identity: PlexClientIdentity,
|
||||
tokenStore: any TokenStoring,
|
||||
transport: any PlexTransport = URLSession.shared,
|
||||
clock: any Clock<Duration> = ContinuousClock()
|
||||
) {
|
||||
self.identity = identity
|
||||
self.tokenStore = tokenStore
|
||||
self.clock = clock
|
||||
self.client = PlexHTTPClient(
|
||||
baseURL: URL(string: "https://plex.tv")!,
|
||||
identity: identity,
|
||||
transport: transport
|
||||
)
|
||||
}
|
||||
|
||||
/// Der bereits gespeicherte Token, falls vorhanden.
|
||||
public nonisolated var storedToken: String? {
|
||||
tokenStore.token(for: Self.accountTokenAccount)
|
||||
}
|
||||
|
||||
/// Fordert einen neuen Anmeldecode an.
|
||||
///
|
||||
/// Bewusst ohne `strong=true`: das liefert zwar einen schwerer zu
|
||||
/// erratenden Code, aber einen dreißigstelligen. Bei plex.tv/link
|
||||
/// abzutippen ist der nicht — und genau das ist der Weg, den Flixy
|
||||
/// anbietet. Der kurze Code ist vier Zeichen lang und läuft nach wenigen
|
||||
/// Minuten ab, was das Raten ausreichend aussichtslos macht.
|
||||
public func requestPin() async throws(PlexError) -> PlexPin {
|
||||
try await client.send(
|
||||
PlexRequest(method: .post, path: "/api/v2/pins"),
|
||||
as: PlexPin.self
|
||||
)
|
||||
}
|
||||
|
||||
/// Wartet darauf, dass der Nutzer den Code im Browser bestätigt.
|
||||
///
|
||||
/// Plex bietet keinen Rückkanal — es bleibt nur regelmäßiges Nachfragen.
|
||||
/// Das Intervall ist bewusst großzügig: der Weg über den Browser dauert
|
||||
/// ohnehin Sekunden, und sekündliches Anklopfen brächte nichts außer Last.
|
||||
public func waitForAuthorization(
|
||||
pin: PlexPin,
|
||||
pollInterval: Duration = .seconds(2),
|
||||
timeout: Duration = .seconds(300)
|
||||
) async throws(PlexError) -> String {
|
||||
// Über die Anzahl der Versuche statt über einen Zeitpunkt: eine
|
||||
// existenzielle `any Clock` gibt ihren Instant-Typ nicht preis, und
|
||||
// deshalb lassen sich zwei ihrer Zeitpunkte nicht vergleichen. Das
|
||||
// Ergebnis ist dasselbe, und in Tests reicht eine Uhr, die sofort
|
||||
// zurückkehrt.
|
||||
//
|
||||
// Nach oben begrenzt, damit ein versehentlich winziges Intervall nicht
|
||||
// in einen Überlauf oder Millionen Anfragen läuft.
|
||||
let attempts = pollInterval > .zero
|
||||
? min(1000, max(1, Int(timeout / pollInterval)))
|
||||
: 1
|
||||
|
||||
for _ in 0..<attempts {
|
||||
do {
|
||||
try await clock.sleep(for: pollInterval)
|
||||
} catch {
|
||||
// Abbruch durch die Oberfläche, etwa weil das Anmeldeblatt
|
||||
// geschlossen wurde. Kein Fehlerfall.
|
||||
throw .transport(description: "Anmeldung abgebrochen")
|
||||
}
|
||||
|
||||
let current = try await client.send(
|
||||
PlexRequest(path: "/api/v2/pins/\(pin.id)"),
|
||||
as: PlexPin.self
|
||||
)
|
||||
|
||||
if let token = current.authToken, !token.isEmpty {
|
||||
try? tokenStore.store(token, for: Self.accountTokenAccount)
|
||||
await client.setToken(token)
|
||||
return token
|
||||
}
|
||||
|
||||
if let expiresAt = current.expiresAt, expiresAt < Date() {
|
||||
throw .transport(description: "Der Anmeldecode ist abgelaufen")
|
||||
}
|
||||
}
|
||||
|
||||
throw .transport(description: "Zeit für die Anmeldung abgelaufen")
|
||||
}
|
||||
|
||||
/// Meldet das Gerät ab. Der Token verschwindet aus dem Schlüsselbund;
|
||||
/// am Konto bleibt der Eintrag stehen, bis er dort entfernt wird.
|
||||
///
|
||||
/// `nonisolated`, weil nur der Schlüsselbund angefasst wird — der ist
|
||||
/// selbst abgesichert. Die Oberfläche soll beim Abmelden nicht auf den
|
||||
/// Actor warten müssen, denn das kann mitten in einer laufenden Abfrage
|
||||
/// passieren.
|
||||
public nonisolated func signOut() {
|
||||
tokenStore.remove(for: Self.accountTokenAccount)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
import Foundation
|
||||
|
||||
/// Der Anmeldecode aus dem PIN-Verfahren.
|
||||
///
|
||||
/// Plex legt auf Anfrage einen vierstelligen Code an. Der Nutzer bestätigt ihn
|
||||
/// im Browser bei plex.tv, danach trägt derselbe Datensatz den Token. Die App
|
||||
/// selbst bekommt nie Benutzername oder Passwort zu sehen — deshalb ist dieser
|
||||
/// Weg dem manuellen Eintippen eines Tokens vorzuziehen.
|
||||
public struct PlexPin: Sendable, Equatable, Decodable {
|
||||
public let id: Int
|
||||
public let code: String
|
||||
public let authToken: String?
|
||||
public let expiresAt: Date?
|
||||
|
||||
private enum CodingKeys: String, CodingKey {
|
||||
case id, code, authToken, expiresAt
|
||||
}
|
||||
|
||||
public init(from decoder: any Decoder) throws {
|
||||
let values = try decoder.container(keyedBy: CodingKeys.self)
|
||||
self.id = try values.decode(Int.self, forKey: .id)
|
||||
self.code = try values.decode(String.self, forKey: .code)
|
||||
self.authToken = try values.decodeIfPresent(String.self, forKey: .authToken)
|
||||
|
||||
// Plex liefert ISO-8601 mit Zeitzone. Ein eigener Formatierer statt
|
||||
// einer Decoder-Strategie, weil sonst alle anderen Datumsfelder in
|
||||
// dieser Antwort mitbetroffen wären.
|
||||
if let text = try values.decodeIfPresent(String.self, forKey: .expiresAt) {
|
||||
self.expiresAt = ISO8601DateFormatter().date(from: text)
|
||||
} else {
|
||||
self.expiresAt = nil
|
||||
}
|
||||
}
|
||||
|
||||
public init(id: Int, code: String, authToken: String? = nil, expiresAt: Date? = nil) {
|
||||
self.id = id
|
||||
self.code = code
|
||||
self.authToken = authToken
|
||||
self.expiresAt = expiresAt
|
||||
}
|
||||
|
||||
/// Die Adresse, unter der der Nutzer den Code bestätigt.
|
||||
///
|
||||
/// `forwardUrl` fehlt bewusst: der Rücksprung in die App wäre bequemer,
|
||||
/// verlangt aber ein eigenes URL-Schema. Solange die App den Code ohnehin
|
||||
/// im Hintergrund abfragt, merkt niemand einen Unterschied.
|
||||
public func authorizationURL(clientIdentifier: String, product: String) -> URL? {
|
||||
var components = URLComponents(string: "https://app.plex.tv/auth")
|
||||
components?.fragment = "?clientID=\(clientIdentifier)&code=\(code)"
|
||||
+ "&context%5Bdevice%5D%5Bproduct%5D=\(product.addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? product)"
|
||||
return components?.url
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
import Foundation
|
||||
import Security
|
||||
|
||||
/// Legt Tokens im Schlüsselbund ab.
|
||||
///
|
||||
/// Nicht in `UserDefaults`: ein Plex-Token gibt vollen Zugriff auf die
|
||||
/// Mediathek und bleibt gültig, bis er am Konto zurückgezogen wird. In den
|
||||
/// Voreinstellungen läge er als Klartext in einer Datei, die jedes Backup
|
||||
/// mitnimmt.
|
||||
public protocol TokenStoring: Sendable {
|
||||
func store(_ token: String, for account: String) throws
|
||||
func token(for account: String) -> String?
|
||||
func remove(for account: String)
|
||||
}
|
||||
|
||||
public struct KeychainTokenStore: TokenStoring {
|
||||
private let service: String
|
||||
|
||||
public init(service: String) {
|
||||
self.service = service
|
||||
}
|
||||
|
||||
public enum Failure: Error, Equatable {
|
||||
case keychain(status: OSStatus)
|
||||
}
|
||||
|
||||
public func store(_ token: String, for account: String) throws {
|
||||
let query: [String: Any] = [
|
||||
kSecClass as String: kSecClassGenericPassword,
|
||||
kSecAttrService as String: service,
|
||||
kSecAttrAccount as String: account,
|
||||
]
|
||||
|
||||
let attributes: [String: Any] = [
|
||||
kSecValueData as String: Data(token.utf8),
|
||||
// Ohne Gerätesperre kein Zugriff, und nicht in Backups übertragbar.
|
||||
// Ein Token, der auf einem anderen Gerät wieder auftaucht, wäre
|
||||
// ein stiller Zweitzugang zur Mediathek.
|
||||
kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
|
||||
]
|
||||
|
||||
let status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
|
||||
switch status {
|
||||
case errSecSuccess:
|
||||
return
|
||||
case errSecItemNotFound:
|
||||
let insert = query.merging(attributes) { current, _ in current }
|
||||
let addStatus = SecItemAdd(insert as CFDictionary, nil)
|
||||
guard addStatus == errSecSuccess else { throw Failure.keychain(status: addStatus) }
|
||||
default:
|
||||
throw Failure.keychain(status: status)
|
||||
}
|
||||
}
|
||||
|
||||
public func token(for account: String) -> String? {
|
||||
let query: [String: Any] = [
|
||||
kSecClass as String: kSecClassGenericPassword,
|
||||
kSecAttrService as String: service,
|
||||
kSecAttrAccount as String: account,
|
||||
kSecReturnData as String: true,
|
||||
kSecMatchLimit as String: kSecMatchLimitOne,
|
||||
]
|
||||
|
||||
var result: CFTypeRef?
|
||||
guard SecItemCopyMatching(query as CFDictionary, &result) == errSecSuccess,
|
||||
let data = result as? Data
|
||||
else { return nil }
|
||||
|
||||
return String(data: data, encoding: .utf8)
|
||||
}
|
||||
|
||||
public func remove(for account: String) {
|
||||
let query: [String: Any] = [
|
||||
kSecClass as String: kSecClassGenericPassword,
|
||||
kSecAttrService as String: service,
|
||||
kSecAttrAccount as String: account,
|
||||
]
|
||||
SecItemDelete(query as CFDictionary)
|
||||
}
|
||||
}
|
||||
|
||||
/// Ein Ablageort im Arbeitsspeicher — für Tests und SwiftUI-Vorschauen.
|
||||
public final class InMemoryTokenStore: TokenStoring, @unchecked Sendable {
|
||||
private let lock = NSLock()
|
||||
private var tokens: [String: String] = [:]
|
||||
|
||||
public init() {}
|
||||
|
||||
public func store(_ token: String, for account: String) throws {
|
||||
lock.withLock { tokens[account] = token }
|
||||
}
|
||||
|
||||
public func token(for account: String) -> String? {
|
||||
lock.withLock { tokens[account] }
|
||||
}
|
||||
|
||||
public func remove(for account: String) {
|
||||
_ = lock.withLock { tokens.removeValue(forKey: account) }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user