Die Ansichten sprechen nicht mehr mit Plex
Start, Suche, Mediathek, Detailseiten und Downloads arbeiten jetzt mit `MediaItem` und dem `MediaBackend`-Vertrag. Damit sind sie fertig für einen zweiten Server, ohne dass an ihnen noch etwas zu tun wäre. Dabei sind ein paar Namen ehrlicher geworden: aus `grandparentTitle` wurde `seriesTitle`, aus `viewedLeafCount` `playedEpisodeCount`. Und `TagStrip` nahm bisher Plex-Marken mit Kennung und Rolle entgegen, um davon nur den Namen anzuzeigen — Genres sind jetzt schlicht Zeichenketten. `Arrangement` ist aus PlexKit heraus und generisch: dieselbe Rechnung gilt für jede Liste, die jemand selbst zusammenstellt. Phase 3 baut die konfigurierbare Seitenleiste darauf, statt sie ein zweites Mal — und ein zweites Mal falsch — zu schreiben. Die Fehlerübersetzung gibt es nur noch einmal. Es waren zwei, und sie waren bereits auseinandergelaufen: derselbe Fehler bekam je nach Bildschirm eine andere Erklärung. Das Nachladen der Mediathek bleibt unangetastet: eine lange Liste, die fünf Einträge vor dem Ende nachlädt. `MediaPage` heißt zwar Seite, ist aber eine technische Portion — Blättern mit „weiter zu Seite 2" gehört nicht in eine Mediathek, in der man stöbert. Der Kommentar dort sagt das jetzt ausdrücklich, damit es niemand später „aufräumt". Player, Live-TV und die Download-Engine sprechen noch unmittelbar mit Plex. Sie folgen als Nächstes. 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
effdcd4532
commit
fe2d730c00
@@ -0,0 +1,72 @@
|
||||
import Foundation
|
||||
|
||||
/// Etwas, das der Nutzer ausblenden und verschieben kann.
|
||||
public protocol Arrangeable {
|
||||
/// Eine Kennung, die über Abrufe hinweg gleich bleibt.
|
||||
///
|
||||
/// **Nicht** der angezeigte Titel: benennt der Server eine Reihe oder eine
|
||||
/// Mediathek um, wäre sonst alles Gespeicherte hinfällig.
|
||||
var arrangementID: String { get }
|
||||
var arrangementTitle: String { get }
|
||||
}
|
||||
|
||||
/// Was ausgeblendet ist und in welcher Reihenfolge der Rest steht.
|
||||
///
|
||||
/// War bis eben an die Startseiten-Reihen von Plex gebunden. Die Rechnung ist
|
||||
/// dieselbe für jede Liste, die jemand selbst zusammenstellt — Reihen,
|
||||
/// Seitenleisteneinträge, Sender. Sie ein zweites Mal zu schreiben hieße, sie
|
||||
/// ein zweites Mal falsch zu machen.
|
||||
public struct Arrangement: Sendable, Equatable {
|
||||
public var hidden: Set<String>
|
||||
public var order: [String]
|
||||
|
||||
public init(hidden: Set<String> = [], order: [String] = []) {
|
||||
self.hidden = hidden
|
||||
self.order = order
|
||||
}
|
||||
|
||||
/// Wendet Auswahl und Reihenfolge an.
|
||||
///
|
||||
/// Unbekannte Einträge landen am Ende statt zu verschwinden. Sie zu
|
||||
/// verwerfen wäre die einfachere Regel — und der Grund dafür, dass ein
|
||||
/// neu angelegtes Regal auf dem Server in der App nie aufgetaucht wäre.
|
||||
public func apply<Element: Arrangeable>(to elements: [Element]) -> [Element] {
|
||||
let visible = elements.filter { !hidden.contains($0.arrangementID) }
|
||||
guard !order.isEmpty else { return visible }
|
||||
|
||||
let positions = Dictionary(
|
||||
order.enumerated().map { ($1, $0) },
|
||||
// Ein doppelter Eintrag in der gespeicherten Reihenfolge — etwa
|
||||
// nach einem fehlgeschlagenen Schreibvorgang — soll nicht
|
||||
// abstürzen. Die erste Position gewinnt.
|
||||
uniquingKeysWith: { first, _ in first }
|
||||
)
|
||||
|
||||
return visible.enumerated().sorted { left, right in
|
||||
let leftPosition = positions[left.element.arrangementID] ?? Int.max
|
||||
let rightPosition = positions[right.element.arrangementID] ?? Int.max
|
||||
// Bei gleicher Position — beide unbekannt — bleibt die Reihenfolge
|
||||
// des Servers erhalten. Ohne diese Rückfalllinie wäre die
|
||||
// Anordnung neuer Einträge zufällig.
|
||||
if leftPosition == rightPosition { return left.offset < right.offset }
|
||||
return leftPosition < rightPosition
|
||||
}.map(\.element)
|
||||
}
|
||||
|
||||
/// Die Liste für den Einstellungsbildschirm: gespeicherte Reihenfolge
|
||||
/// zuerst, danach alles Übrige.
|
||||
///
|
||||
/// Gespeicherte Einträge, die es nicht mehr gibt, fallen heraus — sie
|
||||
/// anzuzeigen hieße, eine Reihe anzubieten, die niemand mehr hat.
|
||||
public func arrangedIdentifiers<Element: Arrangeable>(from elements: [Element]) -> [String] {
|
||||
let available = elements.map(\.arrangementID)
|
||||
let known = Set(available)
|
||||
let stored = order.filter(known.contains)
|
||||
return stored + available.filter { !stored.contains($0) }
|
||||
}
|
||||
}
|
||||
|
||||
extension MediaRowGroup: Arrangeable {
|
||||
public var arrangementID: String { id }
|
||||
public var arrangementTitle: String { title }
|
||||
}
|
||||
@@ -43,6 +43,22 @@ public protocol MediaBackend: Sendable {
|
||||
nonisolated func artworkURL(path: String?, width: Int, height: Int) -> URL?
|
||||
nonisolated func rawImageURL(path: String?) -> URL?
|
||||
|
||||
// MARK: - Herunterladen
|
||||
|
||||
/// Die Adresse, unter der eine Datei unverändert zu holen ist.
|
||||
nonisolated func downloadURL(for file: MediaFile) -> URL?
|
||||
|
||||
/// Die Adresse für eine verkleinerte Fassung.
|
||||
///
|
||||
/// `nil`, wenn der Server das nicht anbietet — dann bleibt nur das
|
||||
/// Original, und die Oberfläche soll die Wahl gar nicht erst zeigen.
|
||||
nonisolated func compressedDownloadURL(
|
||||
itemID: String,
|
||||
versionIndex: Int,
|
||||
maximumBitrate: Int,
|
||||
resolution: String?
|
||||
) -> URL?
|
||||
|
||||
// MARK: - Zustand melden
|
||||
|
||||
func markWatched(id: String) async throws(MediaBackendError)
|
||||
@@ -67,16 +83,27 @@ public enum BackendCapability: String, Sendable, Hashable {
|
||||
case transcoding
|
||||
}
|
||||
|
||||
/// Eine Seite aus einer Mediathek.
|
||||
/// Ein Ausschnitt aus einer Mediathek.
|
||||
///
|
||||
/// „Seite" ist hier eine technische Portion, **keine Seite in der Oberfläche**.
|
||||
/// Die Mediathek ist eine einzige lange Liste, die nachlädt, sobald man sich
|
||||
/// dem Ende nähert — Blättern mit „weiter zu Seite 2" gehört nicht in eine
|
||||
/// Mediathek, in der man stöbert.
|
||||
public struct MediaPage: Sendable, Equatable {
|
||||
public let items: [MediaItem]
|
||||
/// Ab welcher Stelle dieser Ausschnitt beginnt.
|
||||
public let offset: Int
|
||||
/// Wie viele es insgesamt gibt — Grundlage fürs Nachladen.
|
||||
public let totalCount: Int?
|
||||
public let totalCount: Int
|
||||
|
||||
public init(items: [MediaItem], totalCount: Int? = nil) {
|
||||
public init(items: [MediaItem], offset: Int = 0, totalCount: Int) {
|
||||
self.items = items
|
||||
self.offset = offset
|
||||
self.totalCount = totalCount
|
||||
}
|
||||
|
||||
public var hasMore: Bool { offset + items.count < totalCount }
|
||||
public var nextOffset: Int { offset + items.count }
|
||||
}
|
||||
|
||||
/// Ein möglicher Wert für einen Filter.
|
||||
|
||||
@@ -62,6 +62,31 @@ public struct MediaVersion: Sendable, Equatable, Identifiable {
|
||||
}
|
||||
}
|
||||
|
||||
/// Die Auflösung als Wort — „4K", „1080p".
|
||||
///
|
||||
/// Aus der Bildhöhe, nicht aus dem Namen des Servers: Plex sagt „4k",
|
||||
/// Jellyfin gibt Zahlen. Gemeint ist dasselbe.
|
||||
public var resolutionLabel: String? {
|
||||
guard let pixelHeight else { return videoResolution?.uppercased() }
|
||||
switch pixelHeight {
|
||||
case 1_600...: return "4K"
|
||||
case 1_000..<1_600: return "1080p"
|
||||
case 700..<1_000: return "720p"
|
||||
case 1..<700: return "SD"
|
||||
default: return nil
|
||||
}
|
||||
}
|
||||
|
||||
/// Eine kurze Beschreibung für die Versionsauswahl, etwa
|
||||
/// „4K · HEVC · 38 Mbit/s".
|
||||
public var qualityLabel: String {
|
||||
var pieces: [String] = []
|
||||
if let label = resolutionLabel { pieces.append(label) }
|
||||
if let videoCodec { pieces.append(videoCodec.uppercased()) }
|
||||
if let bitrate { pieces.append("\(bitrate / 1000) Mbit/s") }
|
||||
return pieces.joined(separator: " · ")
|
||||
}
|
||||
|
||||
/// Was die Wiedergabe-Entscheidung über diese Fassung wissen muss.
|
||||
public func profile(file: MediaFile?) -> MediaProfile {
|
||||
MediaProfile(
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
import Foundation
|
||||
|
||||
/// Wie die Reihen der Startseite angeordnet werden.
|
||||
///
|
||||
/// Reine Rechnung ohne Speicher und ohne Oberfläche — die Stelle, an der die
|
||||
/// zwei unangenehmen Fälle entschieden werden: was mit Reihen geschieht, die
|
||||
/// der Server neu liefert, und was mit gespeicherten, die es nicht mehr gibt.
|
||||
public struct HubArrangement: Sendable, Equatable {
|
||||
/// Ausdrücklich ausgeblendete Reihen.
|
||||
public var hidden: Set<String>
|
||||
/// Die gewünschte Reihenfolge. Reihen, die hier fehlen, landen am Ende.
|
||||
public var order: [String]
|
||||
|
||||
public init(hidden: Set<String> = [], order: [String] = []) {
|
||||
self.hidden = hidden
|
||||
self.order = order
|
||||
}
|
||||
|
||||
/// Wendet Auswahl und Reihenfolge an.
|
||||
///
|
||||
/// Unbekannte Reihen landen am Ende statt zu verschwinden. Sie zu
|
||||
/// verwerfen wäre die einfachere Regel — und der Grund dafür, dass ein
|
||||
/// neu angelegtes Regal auf dem Server in der App nie aufgetaucht wäre.
|
||||
public func apply(to hubs: [PlexHub]) -> [PlexHub] {
|
||||
let visible = hubs.filter { !hidden.contains($0.hubIdentifier) }
|
||||
guard !order.isEmpty else { return visible }
|
||||
|
||||
let positions = Dictionary(
|
||||
order.enumerated().map { ($1, $0) },
|
||||
// Ein doppelter Eintrag in der gespeicherten Reihenfolge — etwa
|
||||
// nach einem fehlgeschlagenen Schreibvorgang — soll nicht
|
||||
// abstürzen. Die erste Position gewinnt.
|
||||
uniquingKeysWith: { first, _ in first }
|
||||
)
|
||||
|
||||
return visible.enumerated().sorted { left, right in
|
||||
let leftPosition = positions[left.element.hubIdentifier] ?? Int.max
|
||||
let rightPosition = positions[right.element.hubIdentifier] ?? Int.max
|
||||
// Bei gleicher Position — beide unbekannt — bleibt die Reihenfolge
|
||||
// des Servers erhalten. Ohne diese Rückfalllinie wäre die
|
||||
// Anordnung neuer Reihen zufällig.
|
||||
if leftPosition == rightPosition { return left.offset < right.offset }
|
||||
return leftPosition < rightPosition
|
||||
}.map(\.element)
|
||||
}
|
||||
|
||||
/// Die Liste für den Einstellungsbildschirm: gespeicherte Reihenfolge
|
||||
/// zuerst, danach alles, was der Server sonst noch liefert.
|
||||
///
|
||||
/// Gespeicherte Reihen, die es nicht mehr gibt, fallen dabei heraus — sie
|
||||
/// anzuzeigen hieße, eine Reihe anzubieten, die nie erscheinen kann.
|
||||
public func arrangedIdentifiers(from hubs: [PlexHub]) -> [String] {
|
||||
var result: [String] = []
|
||||
var seen = Set<String>()
|
||||
|
||||
for identifier in order
|
||||
where !seen.contains(identifier) && hubs.contains(where: { $0.hubIdentifier == identifier }) {
|
||||
result.append(identifier)
|
||||
seen.insert(identifier)
|
||||
}
|
||||
for hub in hubs where !seen.contains(hub.hubIdentifier) {
|
||||
result.append(hub.hubIdentifier)
|
||||
seen.insert(hub.hubIdentifier)
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
@@ -49,7 +49,11 @@ public struct PlexBackend: MediaBackend {
|
||||
offset: offset,
|
||||
limit: limit
|
||||
)
|
||||
return MediaPage(items: page.items.map(\.asMediaItem), totalCount: page.totalSize)
|
||||
return MediaPage(
|
||||
items: page.items.map(\.asMediaItem),
|
||||
offset: page.offset,
|
||||
totalCount: page.totalSize
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -95,6 +99,29 @@ public struct PlexBackend: MediaBackend {
|
||||
server.rawImageURL(path: path)
|
||||
}
|
||||
|
||||
// MARK: - Herunterladen
|
||||
|
||||
public nonisolated func downloadURL(for file: MediaFile) -> URL? {
|
||||
guard let key = file.key else { return nil }
|
||||
// Nur der Schlüssel wird gebraucht; alles andere steckt schon in der
|
||||
// Adresse oder ist für den Abruf ohne Belang.
|
||||
return server.downloadURL(part: PlexPart(id: 0, key: key))
|
||||
}
|
||||
|
||||
public nonisolated func compressedDownloadURL(
|
||||
itemID: String,
|
||||
versionIndex: Int,
|
||||
maximumBitrate: Int,
|
||||
resolution: String?
|
||||
) -> URL? {
|
||||
server.transcodedDownloadURL(
|
||||
ratingKey: itemID,
|
||||
mediaIndex: versionIndex,
|
||||
maximumBitrate: maximumBitrate,
|
||||
resolution: resolution
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Zustand melden
|
||||
|
||||
public func markWatched(id: String) async throws(MediaBackendError) {
|
||||
|
||||
+23
-23
@@ -1,33 +1,33 @@
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import PlexKit
|
||||
@testable import MediaKit
|
||||
|
||||
private func hub(_ identifier: String) -> PlexHub {
|
||||
PlexHub(hubIdentifier: identifier, title: identifier.capitalized)
|
||||
private func hub(_ identifier: String) -> MediaRowGroup {
|
||||
MediaRowGroup(id: identifier, title: identifier.capitalized)
|
||||
}
|
||||
|
||||
@Suite("Anordnung der Startseiten-Reihen")
|
||||
struct HubArrangementTests {
|
||||
struct ArrangementTests {
|
||||
private let serverHubs = [hub("continue"), hub("recent"), hub("watchlist"), hub("collections")]
|
||||
|
||||
@Test("Ohne Einstellungen bleibt die Reihenfolge des Servers")
|
||||
func defaultKeepsServerOrder() {
|
||||
let result = HubArrangement().apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["continue", "recent", "watchlist", "collections"])
|
||||
let result = Arrangement().apply(to: serverHubs)
|
||||
#expect(result.map(\.id) == ["continue", "recent", "watchlist", "collections"])
|
||||
}
|
||||
|
||||
@Test("Ausgeblendete Reihen verschwinden")
|
||||
func hiddenRowsAreRemoved() {
|
||||
let arrangement = HubArrangement(hidden: ["watchlist", "collections"])
|
||||
let arrangement = Arrangement(hidden: ["watchlist", "collections"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["continue", "recent"])
|
||||
#expect(result.map(\.id) == ["continue", "recent"])
|
||||
}
|
||||
|
||||
@Test("Die gespeicherte Reihenfolge wird angewendet")
|
||||
func storedOrderIsApplied() {
|
||||
let arrangement = HubArrangement(order: ["watchlist", "continue", "recent", "collections"])
|
||||
let arrangement = Arrangement(order: ["watchlist", "continue", "recent", "collections"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["watchlist", "continue", "recent", "collections"])
|
||||
#expect(result.map(\.id) == ["watchlist", "continue", "recent", "collections"])
|
||||
}
|
||||
|
||||
@Test("Neue Reihen vom Server landen am Ende statt zu verschwinden")
|
||||
@@ -35,53 +35,53 @@ struct HubArrangementTests {
|
||||
// Der Fall, der die einfachere Regel — nur Bekanntes anzeigen — zur
|
||||
// Falle macht: ein neu angelegtes Regal auf dem Server wäre in der App
|
||||
// nie aufgetaucht, ohne dass jemand den Grund gesehen hätte.
|
||||
let arrangement = HubArrangement(order: ["recent", "continue"])
|
||||
let arrangement = Arrangement(order: ["recent", "continue"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
|
||||
#expect(result.map(\.id) == ["recent", "continue", "watchlist", "collections"])
|
||||
}
|
||||
|
||||
@Test("Mehrere neue Reihen behalten die Reihenfolge des Servers")
|
||||
func multipleUnknownRowsKeepServerOrder() {
|
||||
// Ohne stabile Rückfalllinie wäre ihre Anordnung zufällig — und
|
||||
// änderte sich bei jedem Start.
|
||||
let arrangement = HubArrangement(order: ["collections"])
|
||||
let arrangement = Arrangement(order: ["collections"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["collections", "continue", "recent", "watchlist"])
|
||||
#expect(result.map(\.id) == ["collections", "continue", "recent", "watchlist"])
|
||||
}
|
||||
|
||||
@Test("Gespeicherte Reihen, die es nicht mehr gibt, stören nicht")
|
||||
func staleOrderEntriesAreIgnored() {
|
||||
// Entsteht beim Löschen einer Mediathek auf dem Server.
|
||||
let arrangement = HubArrangement(order: ["geloescht", "recent", "continue"])
|
||||
let arrangement = Arrangement(order: ["geloescht", "recent", "continue"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
|
||||
#expect(result.map(\.id) == ["recent", "continue", "watchlist", "collections"])
|
||||
}
|
||||
|
||||
@Test("Ein doppelter Eintrag in der Reihenfolge stürzt nicht ab")
|
||||
func duplicateOrderEntriesAreTolerated() {
|
||||
// Kann nach einem abgebrochenen Schreibvorgang entstehen. Ein
|
||||
// Dictionary aus doppelten Schlüsseln wäre ein harter Absturz.
|
||||
let arrangement = HubArrangement(order: ["recent", "recent", "continue"])
|
||||
let arrangement = Arrangement(order: ["recent", "recent", "continue"])
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.first?.hubIdentifier == "recent")
|
||||
#expect(result.first?.id == "recent")
|
||||
#expect(result.count == 4)
|
||||
}
|
||||
|
||||
@Test("Ausblenden und Sortieren greifen zusammen")
|
||||
func hidingAndOrderingCombine() {
|
||||
let arrangement = HubArrangement(
|
||||
let arrangement = Arrangement(
|
||||
hidden: ["recent"],
|
||||
order: ["collections", "recent", "continue"]
|
||||
)
|
||||
let result = arrangement.apply(to: serverHubs)
|
||||
#expect(result.map(\.hubIdentifier) == ["collections", "continue", "watchlist"])
|
||||
#expect(result.map(\.id) == ["collections", "continue", "watchlist"])
|
||||
}
|
||||
|
||||
// MARK: - Die Liste für die Einstellungen
|
||||
|
||||
@Test("Der Einstellungsbildschirm zeigt Gespeichertes zuerst")
|
||||
func settingsListPutsStoredFirst() {
|
||||
let arrangement = HubArrangement(order: ["watchlist", "continue"])
|
||||
let arrangement = Arrangement(order: ["watchlist", "continue"])
|
||||
let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
|
||||
#expect(identifiers == ["watchlist", "continue", "recent", "collections"])
|
||||
}
|
||||
@@ -90,14 +90,14 @@ struct HubArrangementTests {
|
||||
func settingsListIncludesHidden() {
|
||||
// Sonst ließe sich eine einmal ausgeblendete Reihe nie wieder
|
||||
// einschalten — eine Einbahnstraße.
|
||||
let arrangement = HubArrangement(hidden: ["recent"])
|
||||
let arrangement = Arrangement(hidden: ["recent"])
|
||||
let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
|
||||
#expect(identifiers.contains("recent"))
|
||||
}
|
||||
|
||||
@Test("Verschwundene Reihen erscheinen nicht in den Einstellungen")
|
||||
func settingsListDropsStaleEntries() {
|
||||
let arrangement = HubArrangement(order: ["geloescht", "recent"])
|
||||
let arrangement = Arrangement(order: ["geloescht", "recent"])
|
||||
let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
|
||||
#expect(!identifiers.contains("geloescht"))
|
||||
}
|
||||
Reference in New Issue
Block a user