Scarriffle/Flaro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Jellyfin: der Anmeldebildschirm bietet jetzt beides an

Browse Source 
Der Anmeldebildschirm kannte nur Plex. JellyfinKit war fertig, aber von der
App aus nicht erreichbar — „ich sehe nix von Jellyfin".

Quick Connect steht vorn: der Server nennt einen sechsstelligen Code, den man
in einem bereits angemeldeten Client bestätigt. Das Passwort erreicht Flixy
dabei nie, dieselbe Zusage wie bei Plex. Benutzername und Passwort sind der
Rückfall für Server, auf denen Quick Connect abgeschaltet ist; das Passwort
wird dann für die Dauer einer Anfrage gehalten und danach weggeworfen.

Die Adresse wird nicht erraten, sondern durchprobiert. „192.168.1.50" kann
alles Mögliche heißen, und die Reihenfolge ist der Kern von JellyfinAddress:
eine IP-Adresse im eigenen Netz spricht fast nie HTTPS, ein Domänenname fast
immer. Andersherum wartet man bei jedem Server ohne Zertifikat erst auf eine
Zeitüberschreitung.

Die Sitzung hält von hier an einen Server hinter dem neutralen Vertrag, nicht
mehr einen Plex-Server. Die Ansichten haben das nicht gemerkt — genau dafür
war MediaKit da. Dabei fällt ab, was Jellyfin kann und Plex nicht: Favoriten
stehen im Aktionsmenü, sobald der Server sie kennt, Sterne nur dort, wo es
sie gibt.

Was noch nicht geht und deshalb auch nicht behauptet wird: Wiedergabe und
Live-TV sprechen weiter unmittelbar mit Plex. Bei Jellyfin verschwindet der
Live-TV-Eintrag aus der Seitenleiste, und der Player sagt, dass die
Wiedergabe der nächste Schritt ist, statt „Server nicht erreichbar" zu
melden — er ist ja erreichbar.

Nebenbei zwei Stellen, die der Übersetzer aus Plex hinterlassen hat:
`catch is CancellationError` griff seit den getippten Fehlern nie mehr, weil
eine abgebrochene Netzanfrage als Übertragungsfehler zurückkommt; und das
Ersatz-Hintergrundbild einer Folge war toter Code, weil die linke Seite des
`??` gar nicht optional war.

TokenStore wandert nach MediaKit — Tokens sind nichts Plex-Eigenes. Die
Konten sind nach Server getrennt, damit ein späteres Umschalten nicht jedes
Mal eine neue Anmeldung kostet; „Abmelden" räumt trotzdem beide ab.

248 Tests grün.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
2026-09-13 13:22:09 +02:00
co-authored by Claude Opus 5
parent 9540f26dd8
commit 5696254034
27 changed files with 1714 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Flixy/Session/DownloadRefiller.swift
+2 -3
View File
@@ -1,7 +1,6 @@
import Foundation
import FlixyDownloads
import MediaKit
import PlexKit
/// Füllt den Vorrat an ungesehenen Folgen wieder auf.
///
@@ -10,7 +9,7 @@ import PlexKit
/// Server und ist deshalb prüfbar, das Auswählen braucht ihn zwangsläufig.
@MainActor
struct DownloadRefiller {
let backend: PlexBackend?
let backend: (any MediaBackend)?
let coordinator: DownloadCoordinator
/// Lädt nach, was den Regeln nach fehlt.
@@ -56,7 +55,7 @@ struct DownloadRefiller {
private func nextUnwatchedEpisodes(
inSeries seriesKey: String,
count: Int,
backend: PlexBackend
backend: any MediaBackend
) async -> [MediaItem] {
guard let seasons = try? await backend.children(of: seriesKey) else { return [] }
Flixy/Session/DownloadService.swift
+3 -4
View File
@@ -1,7 +1,6 @@
import Foundation
import FlixyDownloads
import MediaKit
import PlexKit
/// Übersetzt Titel vom Server in Download-Aufträge.
///
@@ -80,7 +79,7 @@ enum DownloadQuality: String, CaseIterable, Identifiable {
@MainActor
struct DownloadService {
let backend: PlexBackend?
let backend: (any MediaBackend)?
let coordinator: DownloadCoordinator
/// Baut den Auftrag für einen einzelnen Titel.
@@ -192,7 +191,7 @@ struct DownloadService {
// Einzelne Folgen ohne Datei stoppen den Stapel nicht — sie
// werden am Ende nur gezählt.
unavailable += 1
} catch let error as DownloadRefusal {
} catch {
refused.append((episode, error))
// Beim Speicherlimit hat es keinen Sinn, die übrigen Folgen
// noch einzeln durchzuprobieren — sie scheitern alle gleich.
@@ -204,7 +203,7 @@ struct DownloadService {
return (accepted, refused, unavailable)
}
private func allEpisodes(in container: MediaItem, backend: PlexBackend) async throws -> [MediaItem] {
private func allEpisodes(in container: MediaItem, backend: any MediaBackend) async throws -> [MediaItem] {
switch container.kind {
case .season:
return try await backend.children(of: container.id)
Flixy/Session/FlixySession.swift
+273 -55
View File
@@ -1,4 +1,5 @@
import Foundation
import JellyfinKit
import MediaKit
import Observation
import PlexKit
@@ -8,9 +9,20 @@ import PlexKit
/// 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
@@ -43,18 +55,31 @@ final class FlixySession {
}
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 der Server-Token im Schlüsselbund liegt.
/// Unter welchem Namen die Server-Token im Schlüsselbund liegen.
///
/// Nicht in den Voreinstellungen: er gibt vollen Zugriff auf die
/// Mediathek, genau wie der Konto-Token.
private static let serverTokenAccount = "plex.server"
/// 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.
@@ -69,21 +94,72 @@ final class FlixySession {
private(set) var showsManualCode = false
private(set) var phase: Phase = .launching
private(set) var server: PlexServer?
/// Derselbe Server, aber hinter dem neutralen Vertrag.
///
/// Die Ansichten sprechen hierüber, nicht mehr mit Plex unmittelbar. Der
/// Weg darunter bleibt offen, solange Player, Downloads und Live-TV noch
/// nicht umgestellt sind — die drei folgen als Nächstes.
var backend: PlexBackend? { server.map(PlexBackend.init) }
/// Welche Serverart gerade bedient wird — `nil`, solange niemand
/// angemeldet ist.
private(set) var kind: ServerKind?
/// Die Mediatheken in neutraler Form.
var mediaLibraries: [MediaLibrary] { libraries.map(\.asMediaLibrary) }
/// Nur die Mediatheken, die Flixy darstellen kann — Musik und Fotos
/// 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: [PlexLibrary] = []
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
}
}
/// Ob der aktive Server Live-TV anbietet, **so wie die App es heute kann**.
///
/// Nicht `capabilities.contains(.liveTV)`: Jellyfin kann es, der
/// Programmführer der App spricht aber noch unmittelbar mit Plex. Einen
/// Eintrag zu zeigen, der zu einem leeren Bildschirm führt, wäre eine
/// Zusage, die niemand einlöst.
var supportsLiveTV: Bool { server != nil }
/// 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()
@@ -92,10 +168,12 @@ final class FlixySession {
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)
@@ -105,18 +183,33 @@ final class FlixySession {
/// Versucht, mit einem bereits gespeicherten Token weiterzumachen.
func restore() async {
guard let token = authenticator.storedToken else {
switch storedKind {
case .jellyfin:
if await restoreJellyfin() { return }
phase = .signedOut
return
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)
}
}
// 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.
@@ -128,7 +221,7 @@ final class FlixySession {
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.serverTokenAccount)
let serverToken = tokenStore.token(for: Self.plexTokenAccount)
else { return false }
let name = defaults.string(forKey: Key.cachedServerName) ?? ""
@@ -152,18 +245,18 @@ final class FlixySession {
let server = PlexServer(resource: resource, connection: connection, identity: identity)
else { return false }
self.server = server
adopt(server: server)
do {
libraries = try await server.libraries().filter(\.isSupported)
libraries = try await server.libraries().filter(\.isSupported).map(\.asMediaLibrary)
phase = .ready
return true
} catch {
self.server = nil
clearActiveServer()
return false
}
}
// MARK: - Anmeldung
// MARK: - Anmeldung bei Plex
/// Öffnet die Anmeldeseite von Plex.
///
@@ -183,7 +276,7 @@ final class FlixySession {
do {
pin = try await authenticator.requestPin()
} catch {
phase = .failed(message: message(for: error))
phase = .failed(message: ErrorText.describe(error))
return
}
@@ -263,17 +356,22 @@ final class FlixySession {
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()
server = nil
libraries = []
forgetJellyfin()
defaults.removeObject(forKey: Key.serverKind)
clearActiveServer()
phase = .signedOut
}
// MARK: - Verbinden
// MARK: - Verbinden mit Plex
private func connect(accountToken: String) async {
phase = .connecting(serverName: "")
@@ -289,7 +387,7 @@ final class FlixySession {
phase = .signedOut
return
} catch {
phase = .failed(message: message(for: error))
phase = .failed(message: ErrorText.describe(error))
return
}
@@ -325,25 +423,26 @@ final class FlixySession {
return
}
self.server = server
adopt(server: server)
remember(resource: resource, connection: connection)
do {
libraries = try await server.libraries().filter(\.isSupported)
libraries = try await server.libraries().filter(\.isSupported).map(\.asMediaLibrary)
phase = .ready
} catch {
phase = .failed(message: message(for: error))
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)
defaults.set(resource.name, forKey: Key.cachedServerName)
if let token = resource.accessToken {
try? tokenStore.store(token, for: Self.serverTokenAccount)
try? tokenStore.store(token, for: Self.plexTokenAccount)
}
}
@@ -353,29 +452,148 @@ final class FlixySession {
Key.cachedConnectionIsLocal, Key.cachedServerName] {
defaults.removeObject(forKey: key)
}
tokenStore.remove(for: Self.serverTokenAccount)
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.
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
do {
libraries = try await backend.libraries().filter(\.isSupported)
} 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
do {
libraries = try await backend.libraries().filter(\.isSupported)
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.
private func adopt(server: PlexServer) {
kind = .plex
self.server = server
backend = PlexBackend(server: server)
jellyfinAccount = nil
}
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 {
if let token = authenticator.storedToken {
await connect(accountToken: token)
} else {
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
}
}
}
private func message(for error: any Error) -> String {
guard let plexError = error as? PlexError else { return error.localizedDescription }
return switch plexError {
case .unauthorized: String(localized: "error.unauthorized")
case .notFound: String(localized: "error.notFound")
case .noReachableConnection: String(localized: "error.serverUnreachable")
case .server(let status): String(localized: "error.server \(status)")
case .transport(let description): description
case .decoding: String(localized: "error.unexpectedResponse")
}
}
/// 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 {
Flixy/Session/JellyfinSignInModel.swift
+219
View File
@@ -0,0 +1,219 @@
import Foundation
import JellyfinKit
import MediaKit
import Observation
/// Führt durch die Anmeldung an einem Jellyfin-Server.
///
/// Eigenes Modell statt eines weiteren Falls in `FlixySession.Phase`: die
/// Anmeldung besteht aus mehreren Schritten mit eigener Bedienung — Adresse
/// eintippen, Code bestätigen lassen, notfalls doch Benutzername und Passwort
/// —, und keiner davon interessiert den Rest der App. Was hier ankommt, ist am
/// Ende ein einziges Ergebnis: ein Konto und ein Weg dorthin.
///
/// **Quick Connect zuerst.** Der sechsstellige Code wird in einem bereits
/// angemeldeten Client bestätigt; das Passwort erreicht Flixy dabei nie —
/// dieselbe Zusage wie bei Plex, wo die Anmeldemaske von Plex selbst kommt.
/// Benutzername und Passwort sind der Rückfall für Server, auf denen Quick
/// Connect abgeschaltet ist. Dann hält die App das Passwort für die Dauer
/// einer Anfrage und wirft es danach weg.
@MainActor
@Observable
final class JellyfinSignInModel {
enum Step: Equatable {
/// Die Adresse wird eingetippt.
case address
/// Die Adresse wird durchprobiert.
case checking
/// Der Code steht, jetzt wird auf die Bestätigung gewartet.
case quickConnect(code: String)
/// Der Rückfall: Benutzername und Passwort.
case credentials
case signingIn
}
var address = ""
var userName = ""
var password = ""
private(set) var step: Step = .address
private(set) var errorMessage: String?
/// Wie der gefundene Server heißt — die Bestätigung, dass die Adresse
/// stimmt, noch bevor jemand Anmeldedaten eintippt.
private(set) var serverName: String?
/// Ob der Server die Anmeldung per Code überhaupt anbietet.
private(set) var offersQuickConnect = false
/// Wird gerufen, sobald ein Konto feststeht.
///
/// Der Client kommt mit: er trägt den Token und die Gerätekennung bereits
/// und wird von der Sitzung unverändert weiterverwendet.
var onAuthenticated: ((JellyfinClient, JellyfinAccount, String) -> Void)?
private let identity: JellyfinIdentity
private var client: JellyfinClient?
private var authenticator: JellyfinAuthenticator?
private var pollTask: Task<Void, Never>?
init(identity: JellyfinIdentity) {
self.identity = identity
}
// MARK: - Schritt 1: den Server finden
/// Probiert die plausiblen Ergänzungen der eingetippten Adresse durch.
///
/// Nicht eine raten, sondern der Reihe nach fragen: „192.168.1.50" kann
/// alles Mögliche heißen, und wer die Adresse vollständig eintippen muss,
/// tippt sie dreimal falsch.
func findServer() async {
pollTask?.cancel()
errorMessage = nil
let candidates = JellyfinAddress.candidates(for: address)
guard !candidates.isEmpty else {
errorMessage = String(localized: "signIn.jellyfin.addressMissing")
return
}
step = .checking
for candidate in candidates {
let client = JellyfinClient(baseURL: candidate, identity: identity)
let authenticator = JellyfinAuthenticator(client: client)
guard let info = try? await authenticator.serverInfo() else { continue }
self.client = client
self.authenticator = authenticator
serverName = info.serverName
address = candidate.absoluteString
offersQuickConnect = await authenticator.supportsQuickConnect()
if offersQuickConnect {
await beginQuickConnect()
} else {
step = .credentials
}
return
}
step = .address
errorMessage = String(localized: "signIn.jellyfin.notFound")
}
// MARK: - Schritt 2a: Code bestätigen lassen
func beginQuickConnect() async {
guard let authenticator else { return }
errorMessage = nil
step = .checking
do {
let request = try await authenticator.beginQuickConnect()
step = .quickConnect(code: request.code)
startPolling(secret: request.secret, authenticator: authenticator)
} catch {
// Quick Connect abgeschaltet oder gestört: dann eben der andere
// Weg, statt hier stehen zu bleiben.
offersQuickConnect = false
step = .credentials
errorMessage = ErrorText.describe(error)
}
}
/// Fragt im Zweisekundentakt, ob der Code bestätigt wurde.
///
/// Fünf Minuten lang — so lange gilt ein Code bei Jellyfin in der
/// Voreinstellung. Danach wird nicht weiter gefragt, sondern gesagt, dass
/// er abgelaufen ist; eine Schleife, die ewig läuft, sieht aus wie eine
/// App, die hängt.
private func startPolling(secret: String, authenticator: JellyfinAuthenticator) {
pollTask?.cancel()
pollTask = Task { [weak self] in
for _ in 0..<150 {
try? await Task.sleep(for: .seconds(2))
if Task.isCancelled { return }
do {
if let account = try await authenticator.completeQuickConnect(secret: secret) {
self?.finish(with: account)
return
}
} catch MediaBackendError.notFound {
// Jellyfin kennt den Code nicht mehr: abgelaufen oder
// abgelehnt.
self?.expireQuickConnect()
return
} catch {
self?.errorMessage = ErrorText.describe(error)
return
}
}
self?.expireQuickConnect()
}
}
private func expireQuickConnect() {
errorMessage = String(localized: "signIn.jellyfin.codeExpired")
step = .credentials
}
// MARK: - Schritt 2b: Benutzername und Passwort
func signInWithPassword() async {
guard let authenticator else { return }
pollTask?.cancel()
errorMessage = nil
step = .signingIn
let secret = password
// Sofort aus dem Feld nehmen. Es wird nur noch für diese eine Anfrage
// gebraucht, und was nicht mehr dasteht, kann auch nicht in einem
// Bildschirmfoto landen.
password = ""
do {
let account = try await authenticator.signIn(userName: userName, password: secret)
finish(with: account)
} catch {
errorMessage = ErrorText.describe(error)
step = .credentials
}
}
// MARK: - Ende
private func finish(with account: JellyfinAccount) {
pollTask?.cancel()
guard let client else { return }
password = ""
onAuthenticated?(client, account, serverName ?? address)
}
/// Von der Code-Anzeige auf Benutzername und Passwort wechseln.
///
/// Der Weg ohne Passwort steht vorn, aber er ist kein Zwang: wer keinen
/// zweiten angemeldeten Client zur Hand hat, käme sonst nicht weiter.
func useCredentials() {
pollTask?.cancel()
errorMessage = nil
step = .credentials
}
/// Zurück zum Adressfeld — etwa nach einem Vertipper.
func startOver() {
pollTask?.cancel()
client = nil
authenticator = nil
serverName = nil
offersQuickConnect = false
password = ""
errorMessage = nil
step = .address
}
func cancel() {
pollTask?.cancel()
password = ""
}
}