ScarriffleandClaude Opus 5
2dbe260901
Jeder Aufruf einer Mediathek war ein Serverabruf mit Ladekreis davor. Die Plakate lagen längst auf der Platte; was fehlte, war die Liste, die sagt, welche davon hierhergehören. Jetzt liegt die erste Seite als Abzug daneben: beim Aufrufen steht sie sofort da, der Server wird still nachgefragt, und man sieht in aller Regel nichts davon. Antwortet er nicht, bleibt der Abzug stehen — eine Liste von gestern ist im Zug brauchbarer als ein Fehlerbildschirm. Bewusst nur die erste Seite. Stünden 240 gespeicherte Titel da und der Server antwortet mit 60, müsste entweder die Liste vor den Augen schrumpfen oder der Versatz fürs Nachladen wäre falsch. Gespeichert wird ausserdem nur, was eine Kachel zeigt. Ein Titel aus einer Listenabfrage bringt jede Spur jeder Datei mit — im Raster steht davon nichts, und ausgepackt werden müsste es bei jedem Aufrufen, also genau da, wo der Abzug Zeit sparen soll. Die Mediathekenliste selbst wird nur als Rettungsanker gemerkt, nicht als Beschleuniger: sie sofort zu zeigen hiesse, eine Sitzung für fertig zu erklären, bevor feststeht, dass der Token noch gilt. Abmelden räumt alles weg. Titel, Zusammenfassungen und Sehfortschritt sind persönlich. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
728 lines
29 KiB
Swift
728 lines
29 KiB
Swift
import Foundation
|
|
import JellyfinKit
|
|
import MediaKit
|
|
import Observation
|
|
import PlexKit
|
|
|
|
/// Der Zustand der Verbindung zum Server.
|
|
///
|
|
/// Alles, was die App über „bin ich angemeldet und mit wem spreche ich" weiß,
|
|
/// steht hier. Die Views lesen nur `phase` — dadurch gibt es genau einen Ort,
|
|
/// an dem sich entscheidet, was auf dem Bildschirm erscheint.
|
|
///
|
|
/// Seit es zwei Serverarten gibt, hält diese Klasse **einen** aktiven Server,
|
|
/// nicht zwei. Zwei gleichzeitig hießen: zwei Startseiten, zwei Mediatheken,
|
|
/// zwei Suchergebnisse — und bei jedem Titel die Frage, woher er stammt.
|
|
/// Umschalten ja, nebeneinander nein.
|
|
@MainActor
|
|
@Observable
|
|
final class FlixySession {
|
|
/// Welche Art von Server gerade bedient wird.
|
|
enum ServerKind: String, Sendable, CaseIterable {
|
|
case plex
|
|
case jellyfin
|
|
}
|
|
|
|
enum Phase: Equatable {
|
|
/// Beim Start: liegt ein Token im Schlüsselbund?
|
|
case launching
|
|
case signedOut
|
|
/// Das Anmeldefenster von Plex ist offen.
|
|
case authenticating
|
|
/// Mehrere Server am Konto — einer muss gewählt werden.
|
|
case choosingServer([PlexResource])
|
|
/// Ein Weg zum Server wird gesucht.
|
|
case connecting(serverName: String)
|
|
case ready
|
|
case failed(message: String)
|
|
|
|
static func == (lhs: Phase, rhs: Phase) -> Bool {
|
|
switch (lhs, rhs) {
|
|
case (.launching, .launching), (.signedOut, .signedOut), (.ready, .ready):
|
|
true
|
|
case (.authenticating, .authenticating):
|
|
true
|
|
case (.choosingServer(let l), .choosingServer(let r)):
|
|
l.map(\.clientIdentifier) == r.map(\.clientIdentifier)
|
|
case (.connecting(let l), .connecting(let r)):
|
|
l == r
|
|
case (.failed(let l), .failed(let r)):
|
|
l == r
|
|
default:
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
private enum Key {
|
|
/// Welche Serverart zuletzt aktiv war.
|
|
///
|
|
/// Fehlt der Eintrag, aber es liegt ein Plex-Token bereit, war es
|
|
/// Plex — so kam die App bis hierher, und niemand soll durch ein
|
|
/// Update abgemeldet werden.
|
|
static let serverKind = "flixy.backend.kind"
|
|
static let preferredServer = "flixy.server.clientIdentifier"
|
|
static let cachedConnectionURI = "flixy.server.connectionURI"
|
|
static let cachedServerName = "flixy.server.name"
|
|
static let cachedConnectionIsLocal = "flixy.server.connectionIsLocal"
|
|
static let jellyfinAddress = "flixy.jellyfin.address"
|
|
static let jellyfinUserID = "flixy.jellyfin.userID"
|
|
static let jellyfinUserName = "flixy.jellyfin.userName"
|
|
static let jellyfinServerName = "flixy.jellyfin.serverName"
|
|
static let jellyfinIsAdministrator = "flixy.jellyfin.isAdministrator"
|
|
}
|
|
|
|
/// Unter welchem Namen die Server-Token im Schlüsselbund liegen.
|
|
///
|
|
/// Nicht in den Voreinstellungen: sie geben vollen Zugriff auf die
|
|
/// Mediathek. Getrennte Konten je Serverart, damit ein späteres Umschalten
|
|
/// zwischen beiden nicht jedes Mal eine neue Anmeldung kostet. Das
|
|
/// ausdrückliche Abmelden räumt trotzdem beide ab — siehe `signOut()`.
|
|
private static let plexTokenAccount = "plex.server"
|
|
private static let jellyfinTokenAccount = "jellyfin.server"
|
|
|
|
/// Wird für die Anmelde-Adresse gebraucht: plex.tv ordnet den
|
|
/// bestätigten Code darüber diesem Gerät zu.
|
|
var clientIdentifier: String { identity.clientIdentifier }
|
|
|
|
/// Der Code der laufenden Anmeldung.
|
|
///
|
|
/// Wird nach kurzer Zeit im Anmeldebildschirm eingeblendet — als Ausweg,
|
|
/// falls die Browser-Seite den Code nicht verknüpft. Das passiert, wenn
|
|
/// man dort schon angemeldet ist, und ohne diesen Ausweg säße man fest.
|
|
private(set) var pendingCode: String?
|
|
private(set) var showsManualCode = false
|
|
|
|
/// Ob der Server in **demselben** Netz steht wie wir.
|
|
///
|
|
/// Entscheidet, ob „Auto" gedeckelt anfängt: zuhause trägt die Leitung
|
|
/// das Original, unterwegs nicht. Bei Plex steht es im gewählten Weg; bei
|
|
/// Jellyfin wird der Server gefragt, weil ein Blick auf die Adresse nicht
|
|
/// genügt — wer über einen Reverse Proxy geht, erreicht seinen Server
|
|
/// auch von der Couch aus unter einem öffentlichen Namen.
|
|
///
|
|
/// Im Zweifel `false`: lieber einmal zu vorsichtig gedeckelt als eine
|
|
/// Wiedergabe, die über eine Fernverbindung gar nicht erst anläuft.
|
|
private(set) var isLocalConnection = false
|
|
|
|
private(set) var phase: Phase = .launching
|
|
/// Welche Serverart gerade bedient wird — `nil`, solange niemand
|
|
/// angemeldet ist.
|
|
private(set) var kind: ServerKind?
|
|
|
|
/// Der aktive Server hinter dem neutralen Vertrag.
|
|
///
|
|
/// Die Ansichten sprechen ausschließlich hierüber. Ob dahinter Plex oder
|
|
/// Jellyfin steckt, sehen sie nicht — und genau deshalb musste für
|
|
/// Jellyfin keine einzige Ansicht neu geschrieben werden.
|
|
private(set) var backend: (any MediaBackend)?
|
|
|
|
/// Der Plex-Server, solange Plex aktiv ist.
|
|
///
|
|
/// Player, Live-TV und die Diagnose sprechen noch unmittelbar mit ihm.
|
|
/// Bei Jellyfin ist er `nil` — diese drei Bereiche wandern als Nächstes
|
|
/// auf den neutralen Vertrag.
|
|
private(set) var server: PlexServer?
|
|
|
|
/// Das angemeldete Jellyfin-Konto, solange Jellyfin aktiv ist.
|
|
private(set) var jellyfinAccount: JellyfinAccount?
|
|
|
|
/// Wer angemeldet ist — sofern der Server einen Namen dafür kennt.
|
|
///
|
|
/// Plex führt den Kontonamen am Konto, nicht am Server; dort steht er hier
|
|
/// noch nicht zur Verfügung, und deshalb bleibt die Zeile leer, statt
|
|
/// etwas Falsches zu behaupten.
|
|
var accountName: String? { jellyfinAccount?.userName }
|
|
|
|
/// Die Mediatheken, die Flixy darstellen kann — Musik und Fotos
|
|
/// erscheinen gar nicht erst.
|
|
private(set) var libraries: [MediaLibrary] = []
|
|
|
|
/// Wie der Server heißt, so wie er sich selbst nennt.
|
|
var serverName: String { backend?.serverName ?? "" }
|
|
|
|
/// Unter welcher Adresse er erreicht wird.
|
|
var serverAddress: String? {
|
|
switch kind {
|
|
case .plex: server?.connection.uri
|
|
case .jellyfin: defaults.string(forKey: Key.jellyfinAddress)
|
|
case nil: nil
|
|
}
|
|
}
|
|
|
|
/// Wie die Verbindung zum Server zu beschreiben ist.
|
|
///
|
|
/// Für die Diagnose, und deshalb hier: welcher Weg zum Server führt, weiß
|
|
/// die Sitzung. Bei Plex ist es die entscheidende Angabe — über die
|
|
/// Vermittlung von plex.tv ist alles gedrosselt, und das erklärt die
|
|
/// Hälfte aller Ruckler, bevor man weitersucht.
|
|
var connectionDescription: String? {
|
|
switch kind {
|
|
case .plex:
|
|
guard let connection = server?.connection else { return nil }
|
|
if connection.local { return "Lokal · \(connection.uri)" }
|
|
if connection.relay { return "Plex-Vermittlung (gedrosselt)" }
|
|
return "Direkt von außen · \(connection.uri)"
|
|
case .jellyfin:
|
|
return serverAddress
|
|
case nil:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
/// Ob der aktive Server Live-TV anbietet.
|
|
///
|
|
/// Endlich die Fähigkeit selbst. Hier stand `server != nil` — also „nur
|
|
/// Plex" —, weil der Programmführer unmittelbar mit Plex sprach; einen
|
|
/// Eintrag zu zeigen, der zu einem leeren Bildschirm führt, wäre eine
|
|
/// Zusage gewesen, die niemand einlöst. Seit Live-TV über den neutralen
|
|
/// Vertrag läuft, löst sie jeder ein, der sie gibt.
|
|
var supportsLiveTV: Bool { backend?.capabilities.contains(.liveTV) == true }
|
|
|
|
/// Ob er darüber hinaus aufnehmen kann.
|
|
///
|
|
/// Getrennt gefragt, weil Plex das eine kann und das andere nicht.
|
|
var supportsRecordings: Bool { backend?.capabilities.contains(.liveTVRecordings) == true }
|
|
|
|
/// Der Server als Live-TV-Server — sofern er einer ist.
|
|
var liveTV: (any LiveTVBackend)? { backend as? any LiveTVBackend }
|
|
|
|
/// Der Server als Aufnahme-Server — sofern er einer ist.
|
|
var recorder: (any LiveTVRecordingBackend)? { backend as? any LiveTVRecordingBackend }
|
|
|
|
/// Warum gerade nicht abgespielt werden kann.
|
|
///
|
|
/// Bei Jellyfin ist die Anmeldung fertig, die Wiedergabe noch nicht — sie
|
|
/// ist der nächste Schritt. „Server nicht erreichbar" wäre an dieser
|
|
/// Stelle schlicht gelogen: er ist erreichbar, die App kann nur noch
|
|
/// nichts von ihm abspielen.
|
|
var playbackUnavailableMessage: String {
|
|
kind == .jellyfin
|
|
? String(localized: "player.jellyfinPending")
|
|
: String(localized: "error.serverUnreachable")
|
|
}
|
|
|
|
private let identity: PlexClientIdentity
|
|
private let jellyfinIdentity: JellyfinIdentity
|
|
private let tokenStore: any TokenStoring
|
|
private let authenticator: PlexAuthenticator
|
|
private let webAuthenticator = PlexWebAuthenticator()
|
|
private let defaults: UserDefaults
|
|
private var authorizationTask: Task<Void, Never>?
|
|
|
|
init(
|
|
identity: PlexClientIdentity,
|
|
jellyfinIdentity: JellyfinIdentity,
|
|
tokenStore: any TokenStoring,
|
|
defaults: UserDefaults = .standard
|
|
) {
|
|
self.identity = identity
|
|
self.jellyfinIdentity = jellyfinIdentity
|
|
self.tokenStore = tokenStore
|
|
self.defaults = defaults
|
|
self.authenticator = PlexAuthenticator(identity: identity, tokenStore: tokenStore)
|
|
}
|
|
|
|
// MARK: - Start
|
|
|
|
/// Versucht, mit einem bereits gespeicherten Token weiterzumachen.
|
|
func restore() async {
|
|
#if DEBUG
|
|
if await adoptStubServerIfRequested() { return }
|
|
#endif
|
|
|
|
switch storedKind {
|
|
case .jellyfin:
|
|
if await restoreJellyfin() { return }
|
|
phase = .signedOut
|
|
|
|
case .plex, nil:
|
|
guard let token = authenticator.storedToken else {
|
|
phase = .signedOut
|
|
return
|
|
}
|
|
// Wer vor dieser Version angemeldet war, hat keinen Eintrag über
|
|
// die Serverart — nachtragen, damit „nicht eingetragen" von hier
|
|
// an eindeutig „abgemeldet" heißt.
|
|
defaults.set(ServerKind.plex.rawValue, forKey: Key.serverKind)
|
|
|
|
// Erst der kurze Weg: die Verbindung, die beim letzten Mal
|
|
// funktioniert hat. Ohne ihn kostet jeder Start eine Anfrage an
|
|
// plex.tv plus eine neue Verbindungssuche — zusammen mehrere
|
|
// Sekunden, in denen nur ein Ladekreis zu sehen ist.
|
|
if await restoreFromRememberedConnection() { return }
|
|
|
|
await connect(accountToken: token)
|
|
}
|
|
}
|
|
|
|
private var storedKind: ServerKind? {
|
|
defaults.string(forKey: Key.serverKind).flatMap(ServerKind.init(rawValue:))
|
|
}
|
|
|
|
/// Nimmt die zuletzt funktionierende Verbindung wieder auf.
|
|
///
|
|
/// Gibt `false` zurück, wenn nichts gespeichert ist oder der Server nicht
|
|
/// mehr darüber erreichbar ist — dann übernimmt die vollständige Suche.
|
|
/// Das ist der Fall, wenn man von zuhause weggeht: die lokale Adresse
|
|
/// antwortet nicht mehr, und der direkte Weg muss neu gefunden werden.
|
|
private func restoreFromRememberedConnection() async -> Bool {
|
|
guard let identifier = defaults.string(forKey: Key.preferredServer),
|
|
let uri = defaults.string(forKey: Key.cachedConnectionURI),
|
|
let serverToken = tokenStore.token(for: Self.plexTokenAccount)
|
|
else { return false }
|
|
|
|
let name = defaults.string(forKey: Key.cachedServerName) ?? ""
|
|
phase = .connecting(serverName: name)
|
|
|
|
let connection = PlexConnection(
|
|
uri: uri,
|
|
local: defaults.bool(forKey: Key.cachedConnectionIsLocal)
|
|
)
|
|
let resource = PlexResource(
|
|
name: name,
|
|
clientIdentifier: identifier,
|
|
accessToken: serverToken,
|
|
connections: [connection]
|
|
)
|
|
|
|
// Kurze Zeitgrenze: wenn die gemerkte Adresse nicht sofort antwortet,
|
|
// ist die vollständige Suche schneller als weiteres Warten.
|
|
let selector = PlexConnectionSelector(identity: identity, probeTimeout: .seconds(2))
|
|
guard await selector.selectConnection(for: resource) != nil,
|
|
let server = PlexServer(resource: resource, connection: connection, identity: identity)
|
|
else { return false }
|
|
|
|
let plex = adopt(server: server)
|
|
do {
|
|
libraries = try await loadLibraries(from: plex)
|
|
phase = .ready
|
|
return true
|
|
} catch {
|
|
clearActiveServer()
|
|
return false
|
|
}
|
|
}
|
|
|
|
// MARK: - Anmeldung bei Plex
|
|
|
|
/// Öffnet die Anmeldeseite von Plex.
|
|
///
|
|
/// Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem
|
|
/// Plex einen Token herausgibt. Sichtbar ist er nicht mehr.
|
|
///
|
|
/// Das Fenster wird geöffnet, aber **nicht abgewartet**: Plex führt den
|
|
/// Rücksprung über `forwardUrl` nicht zuverlässig aus. Auf dem iPad landet
|
|
/// der Browser nach dem Anmelden auf watch.plex.tv und bleibt dort stehen
|
|
/// — der Token liegt längst bereit, aber die App wartete auf einen
|
|
/// Rückruf, der nie kam. Stattdessen wird hier im Sekundentakt beim Server
|
|
/// nachgefragt und nebenbei geprüft, ob das Fenster geschlossen wurde.
|
|
func beginSignIn() async {
|
|
phase = .authenticating
|
|
|
|
let pin: PlexPin
|
|
do {
|
|
pin = try await authenticator.requestPin()
|
|
} catch {
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
return
|
|
}
|
|
|
|
guard let url = pin.linkURL else {
|
|
phase = .failed(message: String(localized: "signIn.windowFailed"))
|
|
return
|
|
}
|
|
|
|
pendingCode = pin.code
|
|
showsManualCode = false
|
|
webAuthenticator.present(url: url, callbackScheme: Branding.urlScheme)
|
|
|
|
// Die Frist entspricht der Gültigkeit des Codes bei Plex.
|
|
for second in 0..<900 {
|
|
try? await Task.sleep(for: .seconds(1))
|
|
|
|
// Nach einer Viertelminute den Code zeigen. Wer bis dahin nicht
|
|
// durch ist, hat vermutlich den Fall erwischt, in dem die Seite
|
|
// nicht verknüpft — dann hilft nur noch das Abtippen.
|
|
if second == 15 { showsManualCode = true }
|
|
|
|
if let token = try? await authenticator.token(for: pin) {
|
|
webAuthenticator.dismiss()
|
|
clearPendingCode()
|
|
await connect(accountToken: token)
|
|
return
|
|
}
|
|
|
|
// Fenster geschlossen, ohne dass ein Token da ist.
|
|
if webAuthenticator.didReturn {
|
|
switch webAuthenticator.outcome {
|
|
case .cancelled, nil:
|
|
// Abgebrochen oder zurückgesprungen, ohne dass der Token
|
|
// schon bereitlag. Noch ein paar Sekunden nachfragen,
|
|
// bevor aufgegeben wird — zwischen Rücksprung und Eintrag
|
|
// bei Plex liegt manchmal eine Sekunde.
|
|
if let token = try? await graceTokenLookup(pin: pin) {
|
|
clearPendingCode()
|
|
await connect(accountToken: token)
|
|
return
|
|
}
|
|
// Fenster zu, kein Token: nicht abmelden, sondern den Code
|
|
// stehen lassen. Er gilt weiter, und das Abtippen bei
|
|
// plex.tv/link ist jetzt der schnellste Weg.
|
|
showsManualCode = true
|
|
case .presentationFailed(let description):
|
|
phase = .failed(message: description)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
webAuthenticator.dismiss()
|
|
clearPendingCode()
|
|
phase = .failed(message: String(localized: "signIn.timedOut"))
|
|
}
|
|
|
|
private func clearPendingCode() {
|
|
pendingCode = nil
|
|
showsManualCode = false
|
|
}
|
|
|
|
/// Fragt nach dem Schließen des Fensters noch ein paar Sekunden nach.
|
|
private func graceTokenLookup(pin: PlexPin) async throws -> String? {
|
|
for _ in 0..<5 {
|
|
if let token = try? await authenticator.token(for: pin) { return token }
|
|
try? await Task.sleep(for: .milliseconds(700))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func cancelSignIn() {
|
|
authorizationTask?.cancel()
|
|
authorizationTask = nil
|
|
webAuthenticator.dismiss()
|
|
clearPendingCode()
|
|
phase = .signedOut
|
|
}
|
|
|
|
/// Meldet ab — von allen Servern, nicht nur vom gerade aktiven.
|
|
///
|
|
/// Der Knopf heißt „Abmelden" und nicht „diesen Server verlassen". Nur den
|
|
/// aktiven zu vergessen hieße, dass nach dem Abmelden beim nächsten Start
|
|
/// wieder eine Mediathek dasteht — die des anderen Servers.
|
|
func signOut() {
|
|
authorizationTask?.cancel()
|
|
authenticator.signOut()
|
|
forgetRememberedConnection()
|
|
forgetJellyfin()
|
|
defaults.removeObject(forKey: Key.serverKind)
|
|
clearActiveServer()
|
|
// Titel, Zusammenfassungen und Sehfortschritt sind persönlich. Was
|
|
// einem abgemeldeten Konto gehörte, hat auf der Platte nichts mehr
|
|
// verloren.
|
|
Task { await LibraryCache.shared.clearAll() }
|
|
phase = .signedOut
|
|
}
|
|
|
|
// MARK: - Verbinden mit Plex
|
|
|
|
private func connect(accountToken: String) async {
|
|
phase = .connecting(serverName: "")
|
|
|
|
let directory = PlexServerDirectory(identity: identity, token: accountToken)
|
|
let servers: [PlexResource]
|
|
do {
|
|
servers = try await directory.servers()
|
|
} catch PlexError.unauthorized {
|
|
// Der Token wurde am Konto zurückgezogen. Ihn zu behalten würde
|
|
// bei jedem Start denselben Fehler erzeugen.
|
|
authenticator.signOut()
|
|
phase = .signedOut
|
|
return
|
|
} catch {
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
return
|
|
}
|
|
|
|
guard !servers.isEmpty else {
|
|
phase = .failed(message: String(localized: "error.noServers"))
|
|
return
|
|
}
|
|
|
|
// Beim zweiten Start soll niemand erneut wählen müssen.
|
|
let remembered = defaults.string(forKey: Key.preferredServer)
|
|
if let chosen = servers.first(where: { $0.clientIdentifier == remembered }) ?? servers.singleElement {
|
|
await connect(to: chosen)
|
|
} else {
|
|
phase = .choosingServer(servers)
|
|
}
|
|
}
|
|
|
|
func connect(to resource: PlexResource) async {
|
|
phase = .connecting(serverName: resource.name)
|
|
|
|
let selector = PlexConnectionSelector(identity: identity)
|
|
guard let connection = await selector.selectConnection(for: resource) else {
|
|
phase = .failed(message: String(localized: "error.serverUnreachable"))
|
|
return
|
|
}
|
|
|
|
guard let server = PlexServer(
|
|
resource: resource,
|
|
connection: connection,
|
|
identity: identity
|
|
) else {
|
|
phase = .failed(message: String(localized: "error.serverUnreachable"))
|
|
return
|
|
}
|
|
|
|
let plex = adopt(server: server)
|
|
remember(resource: resource, connection: connection)
|
|
|
|
do {
|
|
libraries = try await loadLibraries(from: plex)
|
|
phase = .ready
|
|
} catch {
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
}
|
|
}
|
|
|
|
/// Merkt sich, worüber es funktioniert hat.
|
|
private func remember(resource: PlexResource, connection: PlexConnection) {
|
|
defaults.set(ServerKind.plex.rawValue, forKey: Key.serverKind)
|
|
defaults.set(resource.clientIdentifier, forKey: Key.preferredServer)
|
|
defaults.set(connection.uri, forKey: Key.cachedConnectionURI)
|
|
defaults.set(connection.local, forKey: Key.cachedConnectionIsLocal)
|
|
isLocalConnection = connection.local
|
|
defaults.set(resource.name, forKey: Key.cachedServerName)
|
|
if let token = resource.accessToken {
|
|
try? tokenStore.store(token, for: Self.plexTokenAccount)
|
|
}
|
|
}
|
|
|
|
/// Vergisst die gemerkte Verbindung.
|
|
private func forgetRememberedConnection() {
|
|
for key in [Key.preferredServer, Key.cachedConnectionURI,
|
|
Key.cachedConnectionIsLocal, Key.cachedServerName] {
|
|
defaults.removeObject(forKey: key)
|
|
}
|
|
tokenStore.remove(for: Self.plexTokenAccount)
|
|
}
|
|
|
|
// MARK: - Verbinden mit Jellyfin
|
|
|
|
/// Übernimmt eine fertige Jellyfin-Anmeldung.
|
|
///
|
|
/// Die Anmeldung selbst führt `JellyfinSignInModel` — sie besteht aus
|
|
/// mehreren Schritten mit eigener Bedienung (Adresse, Code, Rückfall auf
|
|
/// Passwort) und gehört deshalb in ein eigenes Modell. Hier kommt nur das
|
|
/// Ergebnis an: ein Konto und ein Weg dorthin.
|
|
#if DEBUG
|
|
/// Meldet sich an der Attrappe aus `Tools/JellyfinStub` an.
|
|
///
|
|
/// Nur in der Entwicklung und nur auf ausdrückliches Kommando:
|
|
/// `-FlixyStubServer http://127.0.0.1:8096` als Startargument. Der Weg
|
|
/// führt bewusst **am Schlüsselbund vorbei** und schreibt nichts fort —
|
|
/// so lässt sich die Oberfläche ansehen, prüfen und fotografieren, ohne
|
|
/// dass je ein echter Server, ein echtes Konto oder ein echter Token im
|
|
/// Spiel wäre. Genau daran hat es bisher gefehlt: Aussagen über das
|
|
/// Aussehen waren Vermutungen, weil niemand hinsehen konnte.
|
|
private func adoptStubServerIfRequested() async -> Bool {
|
|
guard let raw = defaults.string(forKey: "FlixyStubServer"),
|
|
let baseURL = URL(string: raw)
|
|
else { return false }
|
|
|
|
let account = JellyfinAccount(
|
|
userID: "user-1",
|
|
userName: "Attrappe",
|
|
token: "stub-token",
|
|
isAdministrator: true
|
|
)
|
|
let client = JellyfinClient(baseURL: baseURL, identity: jellyfinIdentity, token: account.token)
|
|
let backend = JellyfinBackend(client: client, account: account, serverName: "Attrappe")
|
|
|
|
kind = .jellyfin
|
|
jellyfinAccount = account
|
|
self.backend = backend
|
|
|
|
do {
|
|
libraries = try await loadLibraries(from: backend)
|
|
phase = .ready
|
|
} catch {
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
}
|
|
return true
|
|
}
|
|
#endif
|
|
|
|
func adoptJellyfin(
|
|
client: JellyfinClient,
|
|
account: JellyfinAccount,
|
|
serverName: String
|
|
) async {
|
|
phase = .connecting(serverName: serverName)
|
|
|
|
let backend = JellyfinBackend(client: client, account: account, serverName: serverName)
|
|
clearActiveServer()
|
|
kind = .jellyfin
|
|
jellyfinAccount = account
|
|
self.backend = backend
|
|
isLocalConnection = await backend.isInLocalNetwork()
|
|
|
|
do {
|
|
libraries = try await loadLibraries(from: backend)
|
|
} catch {
|
|
self.backend = nil
|
|
jellyfinAccount = nil
|
|
kind = nil
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
return
|
|
}
|
|
|
|
rememberJellyfin(account: account, serverName: serverName, baseURL: client.baseURL)
|
|
phase = .ready
|
|
}
|
|
|
|
/// Nimmt eine gespeicherte Jellyfin-Anmeldung wieder auf.
|
|
///
|
|
/// Gibt `false` zurück, wenn nichts gespeichert ist oder der Token nicht
|
|
/// mehr gilt — dann steht die Anmeldung wieder am Anfang. Ist der Server
|
|
/// bloß gerade nicht erreichbar, bleibt die Anmeldung dagegen bestehen und
|
|
/// es gibt einen Fehler mit „Erneut versuchen": auf dem Weg zur Arbeit ist
|
|
/// jeder Server unerreichbar, und das ist kein Grund, jemanden abzumelden.
|
|
private func restoreJellyfin() async -> Bool {
|
|
guard let address = defaults.string(forKey: Key.jellyfinAddress),
|
|
let baseURL = URL(string: address),
|
|
let userID = defaults.string(forKey: Key.jellyfinUserID),
|
|
let token = tokenStore.token(for: Self.jellyfinTokenAccount)
|
|
else { return false }
|
|
|
|
let serverName = defaults.string(forKey: Key.jellyfinServerName) ?? ""
|
|
phase = .connecting(serverName: serverName)
|
|
|
|
let account = JellyfinAccount(
|
|
userID: userID,
|
|
userName: defaults.string(forKey: Key.jellyfinUserName) ?? "",
|
|
token: token,
|
|
isAdministrator: defaults.bool(forKey: Key.jellyfinIsAdministrator)
|
|
)
|
|
let client = JellyfinClient(baseURL: baseURL, identity: jellyfinIdentity, token: token)
|
|
let backend = JellyfinBackend(client: client, account: account, serverName: serverName)
|
|
|
|
clearActiveServer()
|
|
kind = .jellyfin
|
|
jellyfinAccount = account
|
|
self.backend = backend
|
|
// Auch hier fragen: dasselbe Konto kann heute zuhause und morgen im
|
|
// Zug wiederhergestellt werden, und die Antwort gilt je Sitzung.
|
|
isLocalConnection = await backend.isInLocalNetwork()
|
|
|
|
do {
|
|
libraries = try await loadLibraries(from: backend)
|
|
phase = .ready
|
|
return true
|
|
} catch MediaBackendError.unauthorized {
|
|
// Der Token wurde am Server zurückgezogen. Ihn zu behalten würde
|
|
// bei jedem Start denselben Fehler erzeugen.
|
|
forgetJellyfin()
|
|
clearActiveServer()
|
|
return false
|
|
} catch {
|
|
phase = .failed(message: ErrorText.describe(error))
|
|
return true
|
|
}
|
|
}
|
|
|
|
private func rememberJellyfin(account: JellyfinAccount, serverName: String, baseURL: URL) {
|
|
defaults.set(ServerKind.jellyfin.rawValue, forKey: Key.serverKind)
|
|
defaults.set(baseURL.absoluteString, forKey: Key.jellyfinAddress)
|
|
defaults.set(account.userID, forKey: Key.jellyfinUserID)
|
|
defaults.set(account.userName, forKey: Key.jellyfinUserName)
|
|
defaults.set(serverName, forKey: Key.jellyfinServerName)
|
|
defaults.set(account.isAdministrator, forKey: Key.jellyfinIsAdministrator)
|
|
try? tokenStore.store(account.token, for: Self.jellyfinTokenAccount)
|
|
}
|
|
|
|
private func forgetJellyfin() {
|
|
for key in [Key.jellyfinAddress, Key.jellyfinUserID, Key.jellyfinUserName,
|
|
Key.jellyfinServerName, Key.jellyfinIsAdministrator] {
|
|
defaults.removeObject(forKey: key)
|
|
}
|
|
tokenStore.remove(for: Self.jellyfinTokenAccount)
|
|
}
|
|
|
|
// MARK: - Der aktive Server
|
|
|
|
/// Setzt Plex als aktiven Server und gibt die Hülle zurück.
|
|
///
|
|
/// Zurückgegeben, damit der Aufrufer sie benutzen kann, ohne sich ein
|
|
/// zweites Mal eine zu bauen — die trüge eine eigene Live-TV-Sitzung mit
|
|
/// sich, und dann wären zwei im Umlauf, die sich nichts voneinander
|
|
/// erzählen.
|
|
@discardableResult
|
|
private func adopt(server: PlexServer) -> PlexBackend {
|
|
let hülle = PlexBackend(server: server)
|
|
kind = .plex
|
|
self.server = server
|
|
backend = hülle
|
|
jellyfinAccount = nil
|
|
return hülle
|
|
}
|
|
|
|
/// Holt die Mediathekenliste und merkt sie sich.
|
|
///
|
|
/// **Der Speicher ist hier nur ein Rettungsanker**, kein Beschleuniger:
|
|
/// die Liste ist eine einzige kleine Anfrage, und sie sofort zu zeigen
|
|
/// hiesse, eine Sitzung für fertig zu erklären, bevor feststeht, dass der
|
|
/// Token noch gilt. Antwortet der Server dagegen **nicht**, ist eine
|
|
/// Seitenleiste von gestern besser als eine leere — im Zug ist das der
|
|
/// Unterschied zwischen „das Heruntergeladene ansehen" und „gar nichts".
|
|
private func loadLibraries(from backend: any MediaBackend) async throws -> [MediaLibrary] {
|
|
let kennung = backend.identity
|
|
do {
|
|
let geladen = try await backend.libraries().filter(\.isSupported)
|
|
await LibraryCache.shared.storeLibraries(geladen, server: kennung)
|
|
return geladen
|
|
} catch {
|
|
guard let gemerkt = await LibraryCache.shared.libraries(server: kennung),
|
|
!gemerkt.isEmpty
|
|
else { throw error }
|
|
return gemerkt
|
|
}
|
|
}
|
|
|
|
private func clearActiveServer() {
|
|
server = nil
|
|
backend = nil
|
|
jellyfinAccount = nil
|
|
kind = nil
|
|
libraries = []
|
|
}
|
|
|
|
/// Nach einem Fehler noch einmal versuchen, ohne die Anmeldung zu verlieren.
|
|
func retry() async {
|
|
switch storedKind {
|
|
case .jellyfin:
|
|
if await restoreJellyfin() { return }
|
|
phase = .signedOut
|
|
case .plex, nil:
|
|
if let token = authenticator.storedToken {
|
|
await connect(accountToken: token)
|
|
} else {
|
|
phase = .signedOut
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Die Kennung für Jellyfin-Anmeldungen.
|
|
///
|
|
/// Der Anmeldebildschirm baut sich seinen eigenen Client, bevor es eine
|
|
/// Sitzung gibt — er braucht dieselbe Gerätekennung, sonst steht die App
|
|
/// nach dem Anmelden ein zweites Mal in der Geräteliste des Servers.
|
|
var jellyfinDeviceIdentity: JellyfinIdentity { jellyfinIdentity }
|
|
}
|
|
|
|
extension Array {
|
|
/// Das einzige Element — oder `nil`, wenn es keines oder mehrere gibt.
|
|
var singleElement: Element? { count == 1 ? first : nil }
|
|
}
|