Jellyfin: der Anmeldebildschirm bietet jetzt beides an
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
co-authored by
Claude Opus 5
Claude Opus 5
parent
9540f26dd8
commit
5696254034
@@ -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 {
|
||||
|
||||
Reference in New Issue
Block a user