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/FlixyApp.swift
+6
View File
@@ -3,6 +3,8 @@ import SwiftUI
import FlixyDesign
import FlixyDownloads
import FlixyPlayback
import JellyfinKit
import MediaKit
import PlexKit
@main
@@ -35,6 +37,10 @@ struct FlixyApp: App {
)
_session = State(initialValue: FlixySession(
identity: identity,
jellyfinIdentity: JellyfinIdentity.current(
client: Branding.appName,
version: Branding.version
),
tokenStore: KeychainTokenStore(service: Branding.keychainService)
))
Flixy/Resources/Localizable.xcstrings
+550 -22
View File
@@ -33,6 +33,22 @@
"comment": "A label for a 720p movie.",
"isCommentAutoGenerated": true
},
"action.addFavourite": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Zu Favoriten"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Add to favourites"
}
}
}
},
"action.apply": {
"extractionState": "stale",
"localizations": {
@@ -186,6 +202,22 @@
}
}
},
"action.removeFavourite": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Aus Favoriten entfernen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Remove from favourites"
}
}
}
},
"action.retry": {
"extractionState": "stale",
"localizations": {
@@ -1858,6 +1890,102 @@
}
}
},
"library.kind.liveTV": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Live-TV"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Live TV"
}
}
}
},
"library.kind.movie": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Filme"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Movies"
}
}
}
},
"library.kind.music": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Musik"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Music"
}
}
}
},
"library.kind.other": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Sonstiges"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Other"
}
}
}
},
"library.kind.photo": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Fotos"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Photos"
}
}
}
},
"library.kind.show": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Serien"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "TV shows"
}
}
}
},
"library.scan": {
"extractionState": "stale",
"localizations": {
@@ -2363,6 +2491,22 @@
}
}
},
"player.jellyfinPending": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Die Wiedergabe von Jellyfin ist noch nicht fertig — sie ist der nächste Schritt."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Playback from Jellyfin isn't finished yet — it's the next step."
}
}
}
},
"player.loadFailed": {
"extractionState": "stale",
"localizations": {
@@ -3105,6 +3249,22 @@
}
}
},
"settings.account": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Konto"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Account"
}
}
}
},
"settings.address": {
"extractionState": "stale",
"localizations": {
@@ -3544,6 +3704,22 @@
}
}
},
"settings.serverKind": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Art"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Type"
}
}
}
},
"settings.serverName": {
"extractionState": "stale",
"localizations": {
@@ -3782,22 +3958,6 @@
}
}
},
"signIn.action": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Mit Plex anmelden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Sign in with Plex"
}
}
}
},
"signIn.cancelled": {
"extractionState": "stale",
"localizations": {
@@ -3815,6 +3975,342 @@
}
}
},
"signIn.jellyfin.addressHint": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Schema und Port kannst du weglassen — die üblichen werden durchprobiert."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "You can leave out the scheme and port — the usual ones are tried in turn."
}
}
}
},
"signIn.jellyfin.addressMissing": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Trag bitte die Adresse deines Servers ein."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Please enter your server's address."
}
}
}
},
"signIn.jellyfin.addressPlaceholder": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "192.168.1.50 oder medien.example.com"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "192.168.1.50 or media.example.com"
}
}
}
},
"signIn.jellyfin.addressPrompt": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Wo steht dein Server?"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Where is your server?"
}
}
}
},
"signIn.jellyfin.codeExpired": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Der Code ist abgelaufen. Fordere einen neuen an oder melde dich mit Passwort an."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The code has expired. Request a new one or sign in with a password."
}
}
}
},
"signIn.jellyfin.connect": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Verbinden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Connect"
}
}
}
},
"signIn.jellyfin.foundServer": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Gefundener Server"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Server found"
}
}
}
},
"signIn.jellyfin.notFound": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Unter dieser Adresse antwortet kein Jellyfin-Server."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "No Jellyfin server answers at that address."
}
}
}
},
"signIn.jellyfin.otherAddress": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Andere Adresse eintragen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Enter a different address"
}
}
}
},
"signIn.jellyfin.password": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Passwort"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Password"
}
}
}
},
"signIn.jellyfin.passwordNote": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Das Passwort wird nur für diese eine Anfrage gehalten. Gespeichert wird allein der Zugangsschlüssel, und der im Schlüsselbund."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The password is held for this one request only. Only the access token is stored, and it goes into the keychain."
}
}
}
},
"signIn.jellyfin.privacy": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "So erreicht dein Passwort diese App nie."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "This way your password never reaches this app."
}
}
}
},
"signIn.jellyfin.quickConnectHint": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Öffne Jellyfin auf einem Gerät, an dem du schon angemeldet bist, und gib diesen Code unter „Benutzer → Quick Connect“ ein."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Open Jellyfin on a device you're already signed in on and enter this code under “User → Quick Connect”."
}
}
}
},
"signIn.jellyfin.searching": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Server wird gesucht …"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Looking for the server …"
}
}
}
},
"signIn.jellyfin.signingIn": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Anmeldung läuft …"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Signing in …"
}
}
}
},
"signIn.jellyfin.submit": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Anmelden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Sign in"
}
}
}
},
"signIn.jellyfin.title": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Jellyfin-Server"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Jellyfin server"
}
}
}
},
"signIn.jellyfin.useCode": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Stattdessen einen Code bestätigen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Approve a code instead"
}
}
}
},
"signIn.jellyfin.usePassword": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Stattdessen Benutzername und Passwort"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Use a username and password instead"
}
}
}
},
"signIn.jellyfin.userName": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Benutzername"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Username"
}
}
}
},
"signIn.jellyfin.waitingForApproval": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Warte auf die Bestätigung …"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Waiting for approval …"
}
}
}
},
"signIn.manualHint": {
"comment": "Hinweis, wenn die Browser-Verknüpfung nicht greift",
"localizations": {
@@ -3837,33 +4333,33 @@
"de": {
"stringUnit": {
"state": "translated",
"value": "Die Anmeldemaske kommt von Plex. Dein Passwort erreicht diese App nie."
"value": "Die Anmeldung läuft über deinen Server. Dein Passwort erreicht diese App nie."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The sign-in page comes from Plex. Your password never reaches this app."
"value": "Sign-in happens on your server. Your password never reaches this app."
}
}
}
},
"signIn.tagline": {
"comment": "Untertitel auf dem Anmeldebildschirm",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Deine Plex-Mediathek, schöner."
"value": "Deine Mediathek, schöner."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Your Plex library, nicer."
"value": "Your library, nicer."
}
}
}
},
"comment": "Untertitel auf dem Anmeldebildschirm"
},
"signIn.timedOut": {
"comment": "Die Anmeldung wurde nicht innerhalb der Gültigkeit des Codes abgeschlossen",
@@ -3900,6 +4396,38 @@
}
}
},
"signIn.withJellyfin": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Mit Jellyfin anmelden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Sign in with Jellyfin"
}
}
}
},
"signIn.withPlex": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Mit Plex anmelden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Sign in with Plex"
}
}
}
},
"sort.lastPlayed": {
"extractionState": "stale",
"localizations": {
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 = ""
}
}
Flixy/Views/Detail/ItemActionsMenu.swift
+41 -21
View File
@@ -1,13 +1,16 @@
import SwiftUI
import FlixyDesign
import MediaKit
import PlexKit
/// Das Aktionsmenü auf einer Detailseite.
///
/// Alles, was den Server verändert, liegt hier zusammen — statt verstreut als
/// einzelne Knöpfe. Das hält die Kopfzeile frei für das, was man ständig
/// braucht: Abspielen und Herunterladen.
///
/// Welche Einträge erscheinen, entscheidet der Server: Plex kennt Sterne, aber
/// keine Favoriten, Jellyfin Favoriten, aber keine Sterne. Ein Eintrag, der
/// nichts bewirkt, ist schlimmer als keiner.
struct ItemActionsMenu: View {
let item: MediaItem
/// Wird gerufen, wenn sich am Server etwas geändert hat und die
@@ -18,14 +21,18 @@ struct ItemActionsMenu: View {
@State private var isWorking = false
@State private var errorMessage: String?
private var capabilities: Set<BackendCapability> {
session.backend?.capabilities ?? []
}
var body: some View {
Menu {
Button {
run { server in
run { backend in
if item.isWatched {
try await server.markUnwatched(id: item.id)
try await backend.markUnwatched(id: item.id)
} else {
try await server.markWatched(id: item.id)
try await backend.markWatched(id: item.id)
}
}
} label: {
@@ -35,25 +42,38 @@ struct ItemActionsMenu: View {
)
}
Menu {
ForEach((1...5).reversed(), id: \.self) { stars in
Button {
// Plex rechnet in Zehnteln: fünf Sterne sind eine 10.
run { try await $0.rate(id: item.id, rating: stars * 2) }
} label: {
Label(String(repeating: "★", count: stars), systemImage: "star")
}
if capabilities.contains(.favourites) {
Button {
run { try await $0.setFavourite(!item.isFavourite, id: item.id) }
} label: {
Label(
item.isFavourite ? "action.removeFavourite" : "action.addFavourite",
systemImage: item.isFavourite ? "heart.slash" : "heart"
)
}
if item.rating != nil {
Divider()
Button(role: .destructive) {
run { try await $0.rate(id: item.id, rating: 0) }
} label: {
Label("action.clearRating", systemImage: "star.slash")
}
if capabilities.contains(.ratings) {
Menu {
ForEach((1...5).reversed(), id: \.self) { stars in
Button {
// In Zehnteln: fünf Sterne sind eine 10.
run { try await $0.rate(id: item.id, rating: stars * 2) }
} label: {
Label(String(repeating: "★", count: stars), systemImage: "star")
}
}
if item.rating != nil {
Divider()
Button(role: .destructive) {
run { try await $0.rate(id: item.id, rating: 0) }
} label: {
Label("action.clearRating", systemImage: "star.slash")
}
}
} label: {
Label("action.rate", systemImage: "star")
}
} label: {
Label("action.rate", systemImage: "star")
}
} label: {
if isWorking {
@@ -78,7 +98,7 @@ struct ItemActionsMenu: View {
/// Bewusst ohne vorweggenommene Anzeige: den Haken sofort zu setzen und
/// bei einem Fehler wieder zurückzunehmen sieht aus wie ein Wackler. Die
/// Aktionen dauern Millisekunden.
private func run(_ action: @escaping (PlexBackend) async throws -> Void) {
private func run(_ action: @escaping (any MediaBackend) async throws -> Void) {
guard let backend = session.backend else { return }
isWorking = true
Flixy/Views/Home/HomeView.swift
+1 -1
View File
@@ -51,7 +51,7 @@ struct HomeView: View {
.toolbarColorScheme(.dark, for: .navigationBar)
.toolbar { SearchToolbarItem() }
.navigationDestination(for: MediaRoute.self) { MediaDetailView(route: $0) }
.task(id: session.server?.name) { await load() }
.task(id: session.serverName) { await load() }
.refreshable { await load() }
}
Flixy/Views/Library/LibraryFilterSheet.swift
+1 -1
View File
@@ -92,7 +92,7 @@ struct LibraryFilterSheet: View {
private func loadGenres() async {
guard let server = session.backend,
let library = session.mediaLibraries.first(where: { $0.kind == libraryKind })
let library = session.libraries.first(where: { $0.kind == libraryKind })
else { return }
genres = (try? await server.filterOptions(inLibrary: library, field: .genre)) ?? []
}
Flixy/Views/Library/LibraryView.swift
+3 -2
View File
@@ -184,9 +184,10 @@ struct LibraryView: View {
items = first.items
page = first
state = .loaded(())
} catch is CancellationError {
return
} catch {
// Siehe `LoadState.load`: eine abgebrochene Netzanfrage meldet
// sich als Übertragungsfehler, nicht als Abbruch.
if Task.isCancelled { return }
state = .failed(message: ErrorText.describe(error))
}
}
Flixy/Views/LoadState.swift
+7 -3
View File
@@ -36,12 +36,16 @@ extension LoadState {
) async -> Self {
do {
return .loaded(try await operation())
} catch is CancellationError {
} catch {
// Der Bildschirm wurde verlassen, während geladen wurde. Ein
// Fehlertext wäre hier falsch — es ist niemand mehr da, den er
// interessiert.
return previous ?? .loading
} catch {
//
// Gefragt wird die Aufgabe, nicht der Fehler: eine abgebrochene
// Netzanfrage kommt als Übertragungsfehler zurück und nicht als
// `CancellationError`. Danach zu fangen sah richtig aus und griff
// nie.
if Task.isCancelled { return previous ?? .loading }
return .failed(message: ErrorText.describe(error))
}
}
Flixy/Views/Navigation/RootView.swift
+10 -4
View File
@@ -126,7 +126,8 @@ struct RootView: View {
diagnostics: diagnostics,
policy: settings.policy(for: network),
settings: settings,
isLocalConnection: session.server?.connection.local ?? false
isLocalConnection: session.server?.connection.local ?? false,
unavailableMessage: session.playbackUnavailableMessage
)
// Aus Bild-in-Bild zurückzukehren soll im Vollbild landen, nicht in
// der Kachel — dort kam man vorher gar nicht mehr heraus.
@@ -146,7 +147,7 @@ struct RootView: View {
}
private var sidebarDestinations: [SidebarDestination] {
session.mediaLibraries.map { .library(key: $0.id, title: $0.title) }
session.libraries.map { .library(key: $0.id, title: $0.title) }
}
/// iPad: die Seitenleiste ist Teil des Fensters.
@@ -154,6 +155,7 @@ struct RootView: View {
NavigationSplitView {
SidebarView(
libraries: sidebarDestinations,
showsLiveTV: session.supportsLiveTV,
selection: $selection,
showsHeader: false
) {}
@@ -167,7 +169,11 @@ struct RootView: View {
/// iPhone: die Seitenleiste fährt über den Inhalt.
private var drawerLayout: some View {
DrawerContainer(isOpen: $isSidebarOpen) {
SidebarView(libraries: sidebarDestinations, selection: $selection) {
SidebarView(
libraries: sidebarDestinations,
showsLiveTV: session.supportsLiveTV,
selection: $selection
) {
isSidebarOpen = false
}
} content: {
@@ -196,7 +202,7 @@ struct RootView: View {
case .home:
HomeView()
case .library(let key, let title):
if let library = session.mediaLibraries.first(where: { $0.id == key }) {
if let library = session.libraries.first(where: { $0.id == key }) {
LibraryView(library: library)
} else {
PlaceholderScreen(destination: .library(key: key, title: title))
Flixy/Views/Navigation/SidebarView.swift
+7 -1
View File
@@ -8,6 +8,12 @@ import FlixyDesign
/// `NavigationSplitView` stecken, ohne etwas zu ändern.
struct SidebarView: View {
let libraries: [SidebarDestination]
/// Ob der aktive Server Live-TV anbietet.
///
/// Ein Eintrag, der zu einem leeren Bildschirm führt, ist schlimmer als
/// keiner — und bei Jellyfin führt er dorthin, bis der Programmführer
/// umgestellt ist.
var showsLiveTV: Bool = true
@Binding var selection: SidebarDestination
/// Auf dem iPad trägt die Navigationsleiste den Namen bereits — dort wäre
/// eine eigene Überschrift die dritte Nennung auf demselben Bildschirm.
@@ -27,7 +33,7 @@ struct SidebarView: View {
section(
title: String(localized: "sidebar.more"),
items: [.liveTV, .downloads, .settings]
items: showsLiveTV ? [.liveTV, .downloads, .settings] : [.downloads, .settings]
)
}
.padding(.horizontal, FlixySpacing.regular)
Flixy/Views/Player/PlayerModel.swift
+11 -2
View File
@@ -99,6 +99,13 @@ final class PlayerModel {
private let policy: PlaybackPolicy
private let settings: PlaybackSettings
private let isLocalConnection: Bool
/// Was zu sagen ist, wenn es keinen Server gibt, mit dem sich abspielen
/// ließe.
///
/// Als Text durchgereicht statt hier entschieden: bei Plex heißt das
/// „nicht erreichbar", bei Jellyfin „kommt als Nächstes", und welcher
/// Server angemeldet ist, weiß die Sitzung, nicht der Player.
private let unavailableMessage: String
private var item: PlexItem?
/// Die gerade gespielte Fassung und Datei.
@@ -127,7 +134,8 @@ final class PlayerModel {
diagnostics: PlaybackDiagnostics,
policy: PlaybackPolicy,
settings: PlaybackSettings,
isLocalConnection: Bool
isLocalConnection: Bool,
unavailableMessage: String
) {
self.request = request
self.server = server
@@ -136,6 +144,7 @@ final class PlayerModel {
self.policy = policy
self.settings = settings
self.isLocalConnection = isLocalConnection
self.unavailableMessage = unavailableMessage
self.title = request.title
}
@@ -158,7 +167,7 @@ final class PlayerModel {
}
guard let server else {
phase = .failed(message: String(localized: "error.serverUnreachable"))
phase = .failed(message: unavailableMessage)
return
}
Flixy/Views/Search/SearchView.swift
+6 -2
View File
@@ -113,9 +113,13 @@ struct SearchView: View {
do {
hubs = try await backend.search(trimmed, limit: 30)
if !hubs.isEmpty { remember(trimmed) }
} catch is CancellationError {
return
} catch {
// Abgebrochen, weil weitergetippt oder der Bildschirm verlassen
// wurde: `Task.isCancelled` statt `catch is CancellationError` —
// eine abgebrochene Netzanfrage kommt als Übertragungsfehler
// zurück, nicht als Abbruch, und die alte Prüfung lief deshalb
// ins Leere.
if Task.isCancelled { return }
hubs = []
}
}
Flixy/Views/Settings/SettingsView.swift
+46 -7
View File
@@ -2,6 +2,7 @@ import SwiftUI
import FlixyDesign
import FlixyDownloads
import FlixyPlayback
import MediaKit
import PlexKit
/// Die Einstellungen.
@@ -18,18 +19,29 @@ struct SettingsView: View {
var body: some View {
Form {
if let server = session.server {
if session.backend != nil {
Section("settings.server") {
LabeledContent("settings.serverName", value: server.name)
LabeledContent("settings.connection", value: connectionLabel(server.connection))
LabeledContent("settings.address", value: server.connection.uri)
.font(.flixyCaption)
.textSelection(.enabled)
LabeledContent("settings.serverName", value: session.serverName)
// Welche Art von Server — bei zwei möglichen ist das keine
// Nebensache mehr, sondern die erste Frage bei jeder
// Rückmeldung.
LabeledContent("settings.serverKind", value: kindLabel)
if let connection = session.server?.connection {
LabeledContent("settings.connection", value: connectionLabel(connection))
}
if let address = session.serverAddress {
LabeledContent("settings.address", value: address)
.font(.flixyCaption)
.textSelection(.enabled)
}
if let accountName = session.accountName {
LabeledContent("settings.account", value: accountName)
}
}
Section("settings.libraries") {
ForEach(session.libraries) { library in
LabeledContent(library.title, value: library.type.capitalized)
LabeledContent(library.title, value: library.kind.label)
}
}
}
@@ -176,6 +188,15 @@ struct SettingsView: View {
/// Zeigt, über welchen Weg die Verbindung läuft — beim Suchen nach
/// Ruckeln ist das die erste Frage.
/// Welche Serverart gerade bedient wird.
private var kindLabel: String {
switch session.kind {
case .plex: "Plex"
case .jellyfin: "Jellyfin"
case nil: "—"
}
}
private func connectionLabel(_ connection: PlexConnection) -> String {
if connection.local { return String(localized: "settings.connectionLocal") }
if connection.relay { return String(localized: "settings.connectionRelay") }
@@ -194,3 +215,21 @@ extension PlaybackSettings.Quality {
}
}
}
extension MediaLibrary.Kind {
/// Wie diese Art von Mediathek heißt.
///
/// Übersetzt statt durchgereicht: die Server liefern „movies" und
/// „tvshows", und das großgeschrieben anzuzeigen war eine englische
/// Beschriftung in einer deutschen Oberfläche.
var label: String {
switch self {
case .movie: String(localized: "library.kind.movie")
case .show: String(localized: "library.kind.show")
case .music: String(localized: "library.kind.music")
case .photo: String(localized: "library.kind.photo")
case .liveTV: String(localized: "library.kind.liveTV")
case .other: String(localized: "library.kind.other")
}
}
}
Flixy/Views/SignIn/JellyfinSignInView.swift
+266
View File
@@ -0,0 +1,266 @@
import SwiftUI
import FlixyDesign
import JellyfinKit
/// Die Anmeldung an einem Jellyfin-Server.
///
/// Drei Bildschirme in einem, weil es drei Fragen sind und nicht mehr: wo
/// steht der Server, wie heißt du, und — wenn der Server es kann — bestätige
/// diesen Code. Der Weg über den Code steht vorn, weil dabei kein Passwort
/// durch diese App läuft.
struct JellyfinSignInView: View {
@Environment(FlixySession.self) private var session
@Environment(\.dismiss) private var dismiss
@Environment(\.flixyAccent) private var accent
@State private var model: JellyfinSignInModel?
@FocusState private var focusedField: Field?
private enum Field { case address, userName, password }
var body: some View {
NavigationStack {
ScrollView {
if let model {
content(for: model)
.padding(.horizontal, FlixySpacing.section)
.padding(.vertical, FlixySpacing.section)
.frame(maxWidth: 420)
.frame(maxWidth: .infinity)
}
}
.scrollDismissesKeyboard(.interactively)
.background(Color.flixyCanvas)
.navigationTitle(Text("signIn.jellyfin.title"))
.navigationBarTitleDisplayMode(.inline)
.toolbar {
ToolbarItem(placement: .cancellationAction) {
Button("action.cancel") {
model?.cancel()
dismiss()
}
}
}
}
.tint(accent)
.task {
// Erst hier, nicht im Eigenschaftswert: das Modell braucht die
// Gerätekennung der Sitzung. Baut es sich eine eigene, steht die
// App nach dem Anmelden ein zweites Mal in der Geräteliste.
guard model == nil else { return }
let fresh = JellyfinSignInModel(identity: session.jellyfinDeviceIdentity)
fresh.onAuthenticated = { client, account, serverName in
dismiss()
Task { await session.adoptJellyfin(client: client, account: account, serverName: serverName) }
}
model = fresh
}
.onDisappear {
// Wird das Blatt weggewischt, läuft sonst die Abfrageschleife
// noch minutenlang weiter — unsichtbar und für nichts.
model?.cancel()
}
}
@ViewBuilder
private func content(for model: JellyfinSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlixySpacing.section) {
switch model.step {
case .address:
addressStep(model: model)
case .checking:
waiting(text: "signIn.jellyfin.searching")
case .quickConnect(let code):
quickConnectStep(model: model, code: code)
case .credentials:
credentialsStep(model: model)
case .signingIn:
waiting(text: "signIn.jellyfin.signingIn")
}
if let message = model.errorMessage {
Label(message, systemImage: "exclamationmark.triangle")
.font(.flixyCaption)
.foregroundStyle(Color.flixyDestructive)
}
}
}
// MARK: - Adresse
@ViewBuilder
private func addressStep(model: JellyfinSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlixySpacing.regular) {
Text("signIn.jellyfin.addressPrompt")
.font(.flixyRowHeader)
.foregroundStyle(Color.flixyTextPrimary)
TextField("signIn.jellyfin.addressPlaceholder", text: $model.address)
.textFieldStyle(.plain)
.textContentType(.URL)
.keyboardType(.URL)
.textInputAutocapitalization(.never)
.autocorrectionDisabled()
.submitLabel(.go)
.focused($focusedField, equals: .address)
.onSubmit { Task { await model.findServer() } }
// Hier statt beim Öffnen des Blattes: so bekommt das Feld den
// Fokus auch dann, wenn man nach einem Vertipper zurückkommt.
.task { focusedField = .address }
.padding(FlixySpacing.regular)
.background(Color.flixyElevated, in: .rect(cornerRadius: FlixyRadius.control))
.foregroundStyle(Color.flixyTextPrimary)
// Ein Beispiel statt einer Erklärung: „Schema, Host, Port" sagt
// niemandem etwas, „192.168.1.50" jedem.
Text("signIn.jellyfin.addressHint")
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextMuted)
Button {
focusedField = nil
Task { await model.findServer() }
} label: {
Text("signIn.jellyfin.connect")
.font(.flixyRowHeader)
.frame(maxWidth: .infinity)
.padding(.vertical, FlixySpacing.regular)
}
.buttonStyle(.borderedProminent)
.tint(accent)
.disabled(model.address.trimmingCharacters(in: .whitespaces).isEmpty)
}
}
// MARK: - Code
@ViewBuilder
private func quickConnectStep(model: JellyfinSignInModel, code: String) -> some View {
VStack(alignment: .leading, spacing: FlixySpacing.regular) {
foundServerHeader(model: model)
Text("signIn.jellyfin.quickConnectHint")
.font(.flixyBody)
.foregroundStyle(Color.flixyTextSecondary)
Text(code)
.font(.system(.largeTitle, design: .monospaced, weight: .semibold))
.tracking(8)
.foregroundStyle(Color.flixyTextPrimary)
.textSelection(.enabled)
.padding(.vertical, FlixySpacing.regular)
.frame(maxWidth: .infinity)
.background(Color.flixyElevated, in: .rect(cornerRadius: FlixyRadius.control))
HStack(spacing: FlixySpacing.snug) {
ProgressView().controlSize(.small)
Text("signIn.jellyfin.waitingForApproval")
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextMuted)
}
Text("signIn.jellyfin.privacy")
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextMuted)
Divider().overlay(Color.flixySeparator)
Button("signIn.jellyfin.usePassword") { model.useCredentials() }
.font(.flixyCaption)
Button("signIn.jellyfin.otherAddress") { model.startOver() }
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextSecondary)
}
}
// MARK: - Benutzername und Passwort
@ViewBuilder
private func credentialsStep(model: JellyfinSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlixySpacing.regular) {
foundServerHeader(model: model)
TextField("signIn.jellyfin.userName", text: $model.userName)
.textContentType(.username)
.textInputAutocapitalization(.never)
.autocorrectionDisabled()
.submitLabel(.next)
.focused($focusedField, equals: .userName)
.onSubmit { focusedField = .password }
.padding(FlixySpacing.regular)
.background(Color.flixyElevated, in: .rect(cornerRadius: FlixyRadius.control))
SecureField("signIn.jellyfin.password", text: $model.password)
.textContentType(.password)
.submitLabel(.go)
.focused($focusedField, equals: .password)
.onSubmit { Task { await model.signInWithPassword() } }
.padding(FlixySpacing.regular)
.background(Color.flixyElevated, in: .rect(cornerRadius: FlixyRadius.control))
Button {
focusedField = nil
Task { await model.signInWithPassword() }
} label: {
Text("signIn.jellyfin.submit")
.font(.flixyRowHeader)
.frame(maxWidth: .infinity)
.padding(.vertical, FlixySpacing.regular)
}
.buttonStyle(.borderedProminent)
.tint(accent)
.disabled(model.userName.isEmpty)
// Das Passwort wird für die eine Anfrage gehalten und danach
// verworfen. Gespeichert wird nur der Token, und der im
// Schlüsselbund.
Text("signIn.jellyfin.passwordNote")
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextMuted)
Divider().overlay(Color.flixySeparator)
if model.offersQuickConnect {
Button("signIn.jellyfin.useCode") { Task { await model.beginQuickConnect() } }
.font(.flixyCaption)
}
Button("signIn.jellyfin.otherAddress") { model.startOver() }
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextSecondary)
}
.foregroundStyle(Color.flixyTextPrimary)
}
// MARK: - Bausteine
@ViewBuilder
private func foundServerHeader(model: JellyfinSignInModel) -> some View {
VStack(alignment: .leading, spacing: FlixySpacing.tight) {
Text("signIn.jellyfin.foundServer")
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextMuted)
.textCase(.uppercase)
Text(model.serverName ?? model.address)
.font(.flixyTitle)
.foregroundStyle(Color.flixyTextPrimary)
}
}
@ViewBuilder
private func waiting(text: LocalizedStringKey) -> some View {
HStack(spacing: FlixySpacing.snug) {
ProgressView().controlSize(.small)
Text(text)
.font(.flixyBody)
.foregroundStyle(Color.flixyTextSecondary)
}
.frame(maxWidth: .infinity, alignment: .center)
.padding(.vertical, FlixySpacing.section)
}
}
Flixy/Views/SignIn/SignInView.swift
+27 -6
View File
@@ -1,20 +1,26 @@
import SwiftUI
import FlixyDesign
import PlexKit
/// Der Anmeldebildschirm.
///
/// Ein Knopf, mehr nicht. Die Anmeldemaske kommt von Plex und öffnet sich in
/// einem Fenster innerhalb der App; das Passwort wird dort eingegeben und
/// erreicht Flixy nie. Nach dem Anmelden schließt sich das Fenster von selbst.
/// Zwei Wege, weil es zwei Serverarten gibt. **Plex** öffnet seine eigene
/// Anmeldemaske in einem Fenster innerhalb der App; das Passwort wird dort
/// eingegeben und erreicht Flixy nie. **Jellyfin** hat kein Verzeichnis wie
/// plex.tv — dort wird die Adresse des eigenen Servers eingetippt und, wann
/// immer der Server es anbietet, ein Code bestätigt statt eines Passworts.
///
/// Die beiden Wege sind absichtlich nicht zu einem zusammengefasst. Sie haben
/// nichts gemeinsam außer dem Ziel, und der Versuch, das zu verstecken, würde
/// beide verschlechtern.
struct SignInView: View {
let phase: FlixySession.Phase
/// Der Code der laufenden Anmeldung, sobald er gezeigt werden soll.
/// Der Code der laufenden Plex-Anmeldung, sobald er gezeigt werden soll.
let manualCode: String?
let onSignIn: () -> Void
let onCancel: () -> Void
@Environment(\.flixyAccent) private var accent
@State private var showsJellyfinSignIn = false
private var isAuthenticating: Bool {
if case .authenticating = phase { return true }
@@ -48,7 +54,7 @@ struct SignInView: View {
if isAuthenticating {
ProgressView().tint(Color.flixyCanvas)
} else {
Text("signIn.action").font(.flixyRowHeader)
Text("signIn.withPlex").font(.flixyRowHeader)
}
}
.frame(maxWidth: .infinity)
@@ -58,6 +64,18 @@ struct SignInView: View {
.tint(accent)
.disabled(isAuthenticating)
Button {
showsJellyfinSignIn = true
} label: {
Text("signIn.withJellyfin")
.font(.flixyRowHeader)
.frame(maxWidth: .infinity)
.padding(.vertical, FlixySpacing.regular)
}
.buttonStyle(.bordered)
.tint(Color.flixyTextSecondary)
.disabled(isAuthenticating)
if let manualCode {
manualFallback(code: manualCode)
} else {
@@ -74,6 +92,9 @@ struct SignInView: View {
.frame(maxWidth: 420)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(Color.flixyCanvas)
.sheet(isPresented: $showsJellyfinSignIn) {
JellyfinSignInView()
}
}
/// Der Ausweg, wenn die Browser-Seite den Code nicht verknüpft.
Packages/FlixyKit/Package.swift
+1 -1
View File
@@ -43,7 +43,7 @@ let package = Package(
// Ein Werkzeug für die Fragen, die reines HTTP sind — ohne Oberfläche,
// ohne Gerät, ohne Upload. Eine Runde dauert damit Sekunden statt
// eines halben Tages, und das Upload-Kontingent bleibt für Builds.
.executableTarget(name: "FlixyProbe", dependencies: ["PlexKit"]),
.executableTarget(name: "FlixyProbe", dependencies: ["MediaKit", "PlexKit"]),
.testTarget(
name: "PlexKitTests",
dependencies: ["PlexKit"],
Packages/FlixyKit/Sources/FlixyProbe/main.swift
+1
View File
@@ -1,4 +1,5 @@
import Foundation
import MediaKit
import PlexKit
// Ein Werkzeug für die Fragen, die reines HTTP sind.
Packages/FlixyKit/Sources/JellyfinKit/JellyfinAddress.swift
+65
View File
@@ -0,0 +1,65 @@
import Foundation
/// Macht aus dem, was jemand eintippt, eine Adresse, die antwortet.
///
/// Jellyfin hat kein Verzeichnis wie plex.tv — die Adresse kommt vom Nutzer.
/// Und die tippt niemand vollständig: „192.168.1.50" ohne Schema, ohne Port,
/// oder „medien.example.com" ohne „https://". Dieser Typ rät nicht **eine**
/// Ergänzung, sondern nennt die plausiblen in der Reihenfolge, in der sie es
/// wahrscheinlich sind; der Aufrufer probiert sie durch und nimmt die erste,
/// die sich als Jellyfin-Server ausweist.
///
/// Die Reihenfolge ist der ganze Inhalt dieser Datei, und sie ist nicht
/// beliebig: eine IP-Adresse im eigenen Netz spricht fast nie HTTPS, ein
/// Domänenname fast immer.
public enum JellyfinAddress {
/// Der Standardport eines Jellyfin-Servers.
public static let defaultPort = 8096
public static func candidates(for input: String) -> [URL] {
var text = input.trimmingCharacters(in: .whitespacesAndNewlines)
while text.hasSuffix("/") { text.removeLast() }
guard !text.isEmpty else { return [] }
// Wer ein Schema hinschreibt, meint es auch so. Daran wird nichts
// ergänzt — sonst landet eine Anfrage unverschlüsselt, obwohl jemand
// ausdrücklich „https" getippt hat.
if text.contains("://") {
return URL(string: text).map { [$0] } ?? []
}
// IPv6 in eckigen Klammern: hier wird nicht geraten, weil die
// Doppelpunkte sonst als Port gelesen würden.
if text.hasPrefix("[") {
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
let authority = String(text.split(separator: "/", maxSplits: 1).first ?? "")
let host = String(authority.split(separator: ":").first ?? "")
let hasExplicitPort = authority.contains(":")
&& Int(authority.split(separator: ":").last ?? "") != nil
if hasExplicitPort {
// Port genannt, Schema nicht: erst unverschlüsselt, weil ein
// eigener Port fast immer ein Server ohne Zertifikat ist.
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
// Eine reine Zahlenadresse, ein Bonjour-Name oder ein Wort ohne Punkt
// — alles Dinge, die es nur im eigenen Netz gibt.
let isLocalLooking = host.allSatisfy { $0.isNumber || $0 == "." }
|| host.hasSuffix(".local")
|| !host.contains(".")
let forms = isLocalLooking
? ["http://\(withDefaultPort(text))", "http://\(text)", "https://\(text)"]
: ["https://\(text)", "http://\(text)", "http://\(withDefaultPort(text))"]
return forms.compactMap(URL.init(string:))
}
/// Hängt den Standardport an — vor einen etwaigen Pfad, nicht dahinter.
private static func withDefaultPort(_ text: String) -> String {
guard let slash = text.firstIndex(of: "/") else { return "\(text):\(defaultPort)" }
return "\(text[text.startIndex..<slash]):\(defaultPort)\(text[slash...])"
}
}
Packages/FlixyKit/Sources/JellyfinKit/JellyfinIdentity+Current.swift
+44
View File
@@ -0,0 +1,44 @@
import Foundation
#if canImport(UIKit)
import UIKit
#endif
extension JellyfinIdentity {
private static let storageKey = "flixy.jellyfin.deviceID"
/// Baut die Kennung für das laufende Gerät und merkt sie sich.
///
/// Dieselbe Vorsicht wie bei Plex: wechselt die Gerätekennung, gilt die
/// App dem Server als neues Gerät. In der Geräteliste steht dann bei jedem
/// Start ein weiterer Eintrag, und laufende Sitzungen lassen sich nicht
/// mehr zuordnen.
///
/// `@MainActor`, weil `UIDevice.current` dort beheimatet ist.
@MainActor
public static func current(
client: String,
version: String,
defaults: UserDefaults = .standard
) -> JellyfinIdentity {
let deviceID: String
if let stored = defaults.string(forKey: storageKey) {
deviceID = stored
} else {
deviceID = UUID().uuidString
defaults.set(deviceID, forKey: storageKey)
}
#if canImport(UIKit)
let device = UIDevice.current.name
#else
let device = ProcessInfo.processInfo.hostName
#endif
return JellyfinIdentity(
client: client,
device: device,
deviceID: deviceID,
version: version
)
}
}
Packages/FlixyKit/Sources/JellyfinKit/JellyfinItem+Media.swift
+10 -5
View File
@@ -21,11 +21,16 @@ extension JellyfinItem {
rating: criticRating.map { $0 / 10 } ?? communityRating,
audienceRating: communityRating,
thumb: imageBase.primary(itemID: id, tag: imageTags?["Primary"]),
art: imageBase.backdrop(itemID: id, tag: backdropImageTags?.first)
?? parentBackdropItemID.map { imageBase.backdrop(itemID: $0, tag: nil) } ?? nil,
parentThumb: seasonID.map { imageBase.primary(itemID: $0, tag: nil) } ?? nil,
seriesThumb: seriesID.map { imageBase.primary(itemID: $0, tag: seriesPrimaryImageTag) } ?? nil,
seriesArt: seriesID.map { imageBase.backdrop(itemID: $0, tag: nil) } ?? nil,
// Nur wenn es auch eines gibt: die Adresse entsteht aus der
// Kennung, nicht aus einer Antwort des Servers — ohne diese
// Prüfung stünde hinter jedem Titel ohne Hintergrundbild eine
// Adresse, die mit „nicht gefunden" antwortet. Fehlt dem Titel
// eines, nennt Jellyfin die Serie, von der es geliehen werden darf.
art: backdropImageTags?.first.map { imageBase.backdrop(itemID: id, tag: $0) }
?? parentBackdropItemID.map { imageBase.backdrop(itemID: $0, tag: nil) },
parentThumb: seasonID.map { imageBase.primary(itemID: $0, tag: nil) },
seriesThumb: seriesID.map { imageBase.primary(itemID: $0, tag: seriesPrimaryImageTag) },
seriesArt: seriesID.map { imageBase.backdrop(itemID: $0, tag: nil) },
index: indexNumber,
parentIndex: parentIndexNumber,
parentTitle: seasonName,
Packages/FlixyKit/Sources/PlexKit/Auth/TokenStore.swift → Packages/FlixyKit/Sources/MediaKit/TokenStore.swift
+6 -2
View File
@@ -3,10 +3,14 @@ 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
/// Nicht in `UserDefaults`: ein Server-Token gibt vollen Zugriff auf die
/// Mediathek und bleibt gültig, bis er am Server zurückgezogen wird. In den
/// Voreinstellungen läge er als Klartext in einer Datei, die jedes Backup
/// mitnimmt.
///
/// Der Kontoname trennt die Server: `plex.server` und `jellyfin.server`
/// liegen nebeneinander. Wer zwischen beiden wechselt, soll beim
/// Zurückwechseln nicht neu anmelden müssen.
public protocol TokenStoring: Sendable {
func store(_ token: String, for account: String) throws
func token(for account: String) -> String?
Packages/FlixyKit/Tests/JellyfinKitTests/AddressTests.swift
+67
View File
@@ -0,0 +1,67 @@
import Foundation
import Testing
@testable import JellyfinKit
/// Was aus dem wird, was jemand in das Adressfeld tippt.
///
/// Die Reihenfolge ist der Prüfgegenstand, nicht die bloße Menge: probiert
/// die App bei einer IP-Adresse zuerst HTTPS, wartet man auf jedem Server
/// ohne Zertifikat erst einmal auf eine Zeitüberschreitung.
@Suite("Adressen ergänzen")
struct AddressTests {
@Test("Ein getipptes Schema wird nicht angetastet")
func keepsExplicitScheme() {
let candidates = JellyfinAddress.candidates(for: "https://medien.example.com/jellyfin")
#expect(candidates.map(\.absoluteString) == ["https://medien.example.com/jellyfin"])
}
@Test("Nachlaufende Schrägstriche fallen weg")
func trimsTrailingSlash() {
let candidates = JellyfinAddress.candidates(for: " https://example.com/ ")
#expect(candidates.map(\.absoluteString) == ["https://example.com"])
}
@Test("Bei einer IP-Adresse zuerst der Standardport, unverschlüsselt")
func prefersPlainHTTPForAddresses() {
let candidates = JellyfinAddress.candidates(for: "192.168.1.50")
#expect(candidates.map(\.absoluteString) == [
"http://192.168.1.50:8096",
"http://192.168.1.50",
"https://192.168.1.50",
])
}
@Test("Bei einem Domänennamen zuerst HTTPS")
func prefersHTTPSForDomains() {
let candidates = JellyfinAddress.candidates(for: "medien.example.com")
#expect(candidates.first?.absoluteString == "https://medien.example.com")
#expect(candidates.map(\.absoluteString).contains("http://medien.example.com:8096"))
}
@Test("Ein genannter Port wird nicht überschrieben")
func keepsExplicitPort() {
let candidates = JellyfinAddress.candidates(for: "medien.example.com:8920")
#expect(candidates.map(\.absoluteString) == [
"http://medien.example.com:8920",
"https://medien.example.com:8920",
])
}
@Test("Der Standardport landet vor dem Pfad, nicht dahinter")
func insertsPortBeforePath() {
let candidates = JellyfinAddress.candidates(for: "server.local/jellyfin")
#expect(candidates.first?.absoluteString == "http://server.local:8096/jellyfin")
}
@Test("Leere Eingabe ergibt keine Adresse")
func rejectsEmptyInput() {
#expect(JellyfinAddress.candidates(for: " ").isEmpty)
}
}
Packages/FlixyKit/Tests/JellyfinKitTests/TranslationTests.swift
+36
View File
@@ -128,5 +128,41 @@ struct TranslationTests {
#expect(episode.thumb == "/Items/a1b2c3d4e5f6/Images/Primary?tag=tag-primary")
#expect(episode.clearLogoPath == "/Items/a1b2c3d4e5f6/Images/Logo?tag=tag-logo")
#expect(episode.seriesThumb == "/Items/series-1/Images/Primary?tag=tag-series")
#expect(episode.art == "/Items/a1b2c3d4e5f6/Images/Backdrop?tag=tag-backdrop")
}
@Test("Ohne eigenes Hintergrundbild kommt es von der Serie")
func borrowsBackdropFromParent() throws {
let item = try decode("""
{"Id": "ohne-bild", "Name": "Folge ohne Bild", "Type": "Episode",
"ParentBackdropItemId": "series-1"}
""")
// Die Bildadressen entstehen aus der Kennung, nicht aus einer Antwort
// des Servers. Ohne diese Unterscheidung stünde hinter jeder Folge
// eine Adresse, die mit „nicht gefunden" antwortet — und das Feld, das
// Jellyfin dafür mitschickt, wäre totes Gewicht.
#expect(item.art == "/Items/series-1/Images/Backdrop")
}
@Test("Gibt es weder eigenes noch geliehenes Bild, bleibt das Feld leer")
func leavesBackdropEmpty() throws {
let item = try decode("""
{"Id": "ganz-ohne", "Name": "Nichts da", "Type": "Movie"}
""")
#expect(item.art == nil)
}
/// Ein einzelner Eintrag, wie er über die Leitung käme.
///
/// Für die Fälle, die in den aufgezeichneten Antworten nicht vorkommen —
/// eine Folge ohne eigenes Bild etwa. Eine weitere Datei dafür anzulegen
/// verstellt den Blick darauf, worum es im Test geht.
private func decode(_ json: String) throws -> MediaItem {
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let item = try decoder.decode(JellyfinItem.self, from: Data(json.utf8))
return item.asMediaItem(imageBase: JellyfinImagePaths())
}
}
project.yml
+4
View File
@@ -47,6 +47,10 @@ targets:
product: MediaKit
- package: FlixyKit
product: PlexKit
# Der zweite Server. Steht neben PlexKit, nicht darin: die beiden teilen
# die neutrale Schicht und sonst nichts.
- package: FlixyKit
product: JellyfinKit
- package: FlixyKit
product: FlixyDesign
- package: FlixyKit