Einstellungen: sechs Bildschirme statt einer Liste — und was sie steuern
Deine Einstellungs-Bilder sind eine lange Liste. Ich habe sie durchgegangen
und getrennt: was etwas steuert, ist gebaut; was eine Einstellung für eine
Sache wäre, die es nicht gibt, ist nicht gebaut. Ein Schalter, der nichts
bewirkt, ist schlimmer als kein Schalter.
**Die Einstellungen sind jetzt eine Übersicht.** Vorher stand alles
untereinander auf einem Bildschirm — Serverangaben, Qualität, Wiedergabe, drei
Verweise, Downloads, Version, Abmelden. Das war beim Bauen bequem und beim
Suchen anstrengend. Jetzt führt jede Zeile in einen Bildschirm, der zu einer
Frage gehört: Server, Erscheinungsbild, Startseite, Wiedergabe, Ton &
Untertitel, Downloads, Diagnose.
**Neu, und jedes davon greift irgendwo:**
- Zurück- und Vorspulen getrennt einstellbar. Die Knöpfe im Player und die
Doppeltipp-Flächen tragen danach auch das passende Symbol.
- Startgeschwindigkeit — die Engine kann es längst, gefragt wurde nie.
- „Im Querformat sperren" abschaltbar. Für die allermeisten Filme richtig, für
den, der im Bett auf der Seite liegt, das Gegenteil.
- „Gewählte Qualität merken": die Stufe gilt dann auch für den nächsten Titel.
Aufbewahrt wird eine **Zahl**, keine Sprosse — welche Sprossen es gibt, hängt
von der Quelle ab, und eine 720p-Datei kennt keine Zwanzig-Megabit-Stufe.
Dann kommt die nächstgelegene, nicht „automatisch".
- „Bitrate im Qualitätsmenü zeigen".
- Gleichzeitige Downloads. Der Wert gab es schon in der Engine, nur ohne
Bedienung und ohne dass er einen Neustart überlebte.
- Aufmacher: wie viele Titel, und ob sie aus Angefangenem oder nur aus
Neuzugängen kommen.
- „Weiterschauen und Als Nächstes zusammenlegen" und „Gesehenes aus
Neuzugängen ausblenden" — beides in der Ansicht, nicht im Server: das sind
Fragen der Darstellung, und so gelten sie für Plex und Jellyfin gleich.
**Verkleinert herunterladen geht jetzt auch bei Jellyfin.** Da hatte ich zu
früh aufgegeben: ich hatte nur nach der Adresse zum *Abspielen* gesucht, und
die ist eine Abspielliste mit hunderten Schnipseln — als Datei unbrauchbar.
`/Videos/{id}/stream.mp4` gibt dieselbe Umrechnung als eine Datei heraus. Die
Größe bleibt eine Schätzung; eine Umrechnung, die erst beim Abruf beginnt,
kennt ihre eigene Länge nicht.
**Die Kontozeile ist jetzt eine Karte, die nach oben aufklappt**, kein
Systemmenü mehr. Ein Menü legt sich als eigene Ebene über alles und springt
dorthin, wo Platz ist; die Karte bleibt, wo sie ist, und lässt die Zeile mit
dem Namen stehen — man sieht also weiter, um wessen Konto es geht.
**Nicht gebaut, mit Grund:** Trailer im Karussell, Poster- und Sammlungsstil,
Untertitel-Aussehen, sekundäre Untertitel, lokale Intros, Modular Home,
App-Symbol. Für all das fehlt das, was die Einstellung steuern würde — es gibt
in Flixy weder Trailer noch Sammlungen, und der Player zeichnet Untertitel
nicht selbst.
263 Tests grün. **Nicht angesehen**: der Simulator-Tunnel ist weiterhin
abgestürzt und ließ sich nicht wieder aufbauen.
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
3f6c6d8816
commit
dace5d1543
@@ -95,7 +95,9 @@ public final class DownloadCoordinator {
|
||||
/// Zwei statt aller auf einmal: eine ganze Staffel parallel zu laden teilt
|
||||
/// die Bandbreite so auf, dass keine Folge fertig wird — und unterwegs ist
|
||||
/// eine fertige Folge mehr wert als zehn halbe.
|
||||
public var maximumConcurrentDownloads = 2
|
||||
public var maximumConcurrentDownloads: Int {
|
||||
didSet { defaults.set(maximumConcurrentDownloads, forKey: Key.maximumConcurrent) }
|
||||
}
|
||||
|
||||
/// Die Regeln fürs automatische Löschen und Nachladen.
|
||||
public var rules: DownloadRules {
|
||||
@@ -110,6 +112,7 @@ public final class DownloadCoordinator {
|
||||
static let storageLimit = "flixy.downloads.storageLimit"
|
||||
static let deleteAfter = "flixy.downloads.deleteWatchedAfter"
|
||||
static let keepUnwatched = "flixy.downloads.keepUnwatched"
|
||||
static let maximumConcurrent = "flixy.downloads.maximumConcurrent"
|
||||
}
|
||||
|
||||
/// Der Container, nicht nur der Kontext.
|
||||
@@ -176,6 +179,9 @@ public final class DownloadCoordinator {
|
||||
self.fileStore = fileStore
|
||||
self.defaults = defaults
|
||||
self.isWiFiOnly = defaults.object(forKey: Key.wifiOnly) as? Bool ?? true
|
||||
// Zwei statt aller auf einmal: eine ganze Staffel parallel zu laden
|
||||
// teilt die Bandbreite so auf, dass keine Folge fertig wird.
|
||||
self.maximumConcurrentDownloads = defaults.object(forKey: Key.maximumConcurrent) as? Int ?? 2
|
||||
let storedLimit = defaults.object(forKey: Key.storageLimit) as? Int64 ?? 0
|
||||
self.storageLimitBytes = storedLimit > 0 ? storedLimit : nil
|
||||
|
||||
|
||||
@@ -57,6 +57,44 @@ public enum PlayerQuality: Hashable, Sendable, Identifiable {
|
||||
Rung(bitrate: 64, height: 160),
|
||||
]
|
||||
|
||||
/// Eine Zahl, die sich aufbewahren lässt.
|
||||
///
|
||||
/// Über mehrere Filme hinweg gilt nur die **Absicht** — „ungefähr so viel
|
||||
/// Bitrate" —, nicht die genaue Sprosse: welche Sprossen es gibt, hängt
|
||||
/// von der Quelle ab. Deshalb eine Zahl und kein Aufzählungswert.
|
||||
public var storageValue: Int {
|
||||
switch self {
|
||||
case .automatic: 0
|
||||
case .original: -1
|
||||
case .audioOnly: -2
|
||||
case .limited(let rung): rung.bitrate
|
||||
}
|
||||
}
|
||||
|
||||
/// Die Stufe zu einer aufbewahrten Zahl, so nah wie möglich.
|
||||
///
|
||||
/// Gibt es die Sprosse für diese Quelle nicht, wird die nächstgelegene
|
||||
/// genommen — eine 720p-Datei kennt keine 20-Megabit-Stufe, und dann
|
||||
/// stillschweigend auf „automatisch" zurückzufallen wäre eine andere
|
||||
/// Antwort als die, um die gebeten wurde.
|
||||
public static func restored(from value: Int, forSourceHeight height: Int?) -> PlayerQuality? {
|
||||
switch value {
|
||||
case 0: return nil
|
||||
case -1: return .original
|
||||
case -2: return .audioOnly
|
||||
default: break
|
||||
}
|
||||
|
||||
let rungs = available(forSourceHeight: height).compactMap { quality -> Rung? in
|
||||
if case .limited(let rung) = quality { return rung }
|
||||
return nil
|
||||
}
|
||||
guard let closest = rungs.min(by: {
|
||||
abs($0.bitrate - value) < abs($1.bitrate - value)
|
||||
}) else { return nil }
|
||||
return .limited(closest)
|
||||
}
|
||||
|
||||
public static var allCases: [PlayerQuality] {
|
||||
[.automatic, .original] + ladder.map(PlayerQuality.limited) + [.audioOnly]
|
||||
}
|
||||
|
||||
@@ -291,17 +291,50 @@ public struct JellyfinBackend: MediaBackend {
|
||||
)
|
||||
}
|
||||
|
||||
/// Eine verkleinerte Fassung zum Herunterladen.
|
||||
///
|
||||
/// **Fortlaufendes MP4, nicht HLS.** Zum Abspielen liefert Jellyfin eine
|
||||
/// Abspielliste mit hunderten Schnipseln; das ist für einen Strom richtig
|
||||
/// und für eine Datei, die auf dem Gerät liegen soll, unbrauchbar. Der
|
||||
/// Endpunkt `/Videos/{id}/stream.mp4` gibt dieselbe Umrechnung als **eine**
|
||||
/// Datei heraus.
|
||||
///
|
||||
/// Hier wird die Adresse selbst gebaut statt über `/PlaybackInfo` erfragt —
|
||||
/// anders als beim Abspielen. Der Grund ist die Signatur: diese Stelle darf
|
||||
/// keine Anfrage stellen, weil die Oberfläche die Adresse beim Zeichnen
|
||||
/// braucht. Das ist vertretbar, weil hier nichts zu entscheiden ist: die
|
||||
/// Stufe steht fest, der Server soll sie liefern.
|
||||
///
|
||||
/// Die Größe bleibt eine Schätzung. Eine Umrechnung, die erst beim Abruf
|
||||
/// beginnt, kennt ihre eigene Länge nicht — der Fortschrittsbalken rechnet
|
||||
/// deshalb gegen die geschätzten Bytes, nicht gegen eine Zusage des Servers.
|
||||
public nonisolated func compressedDownloadURL(
|
||||
itemID: String,
|
||||
versionIndex: Int,
|
||||
maximumBitrate: Int,
|
||||
resolution: String?
|
||||
) -> URL? {
|
||||
// Jellyfin liefert die Adresse für eine umgerechnete Fassung erst nach
|
||||
// einer Anfrage an `/PlaybackInfo` — das geht hier nicht, weil diese
|
||||
// Methode keine Anfrage stellen darf. `nil` heißt: nur Original
|
||||
// anbieten, statt eine Adresse zu erfinden, die nicht antwortet.
|
||||
nil
|
||||
var query = [
|
||||
URLQueryItem(name: "videoCodec", value: "h264"),
|
||||
URLQueryItem(name: "audioCodec", value: "aac"),
|
||||
// Jellyfin rechnet in Bit, die App in Kilobit.
|
||||
URLQueryItem(name: "videoBitRate", value: String(maximumBitrate * 1_000)),
|
||||
URLQueryItem(name: "audioBitRate", value: "128000"),
|
||||
// Zwei Kanäle: ein Handy hat keine Rückkanäle, und 5.1 auf zwei
|
||||
// Lautsprecher heruntergemischt klingt schlechter als von
|
||||
// vornherein Stereo.
|
||||
URLQueryItem(name: "TranscodingMaxAudioChannels", value: "2"),
|
||||
URLQueryItem(name: "TranscodingContainer", value: "mp4"),
|
||||
]
|
||||
if let height = resolution?.split(separator: "x").last.flatMap({ Int($0) }) {
|
||||
query.append(URLQueryItem(name: "maxHeight", value: String(height)))
|
||||
}
|
||||
|
||||
return client.url(
|
||||
path: "/Videos/\(itemID)/stream.mp4",
|
||||
query: query,
|
||||
includingToken: account.token
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Zustand melden
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
import Testing
|
||||
@testable import FlixyPlayback
|
||||
|
||||
/// Die gemerkte Qualitätsstufe über mehrere Filme hinweg.
|
||||
///
|
||||
/// Aufbewahrt wird eine Zahl, keine Sprosse: welche Sprossen es gibt, hängt
|
||||
/// von der Quelle ab. Eine 720p-Datei kennt keine Zwanzig-Megabit-Stufe — und
|
||||
/// dann stillschweigend auf „automatisch" zurückzufallen wäre eine andere
|
||||
/// Antwort als die, um die gebeten wurde.
|
||||
@Suite("Gemerkte Qualität")
|
||||
struct QualityMemoryTests {
|
||||
|
||||
@Test("Null heißt: nichts gemerkt")
|
||||
func returnsNilForAutomatic() {
|
||||
#expect(PlayerQuality.automatic.storageValue == 0)
|
||||
#expect(PlayerQuality.restored(from: 0, forSourceHeight: 1080) == nil)
|
||||
}
|
||||
|
||||
@Test("Original und Nur-Ton kommen unverändert zurück")
|
||||
func restoresSpecialCases() {
|
||||
#expect(PlayerQuality.restored(from: PlayerQuality.original.storageValue,
|
||||
forSourceHeight: 1080) == .original)
|
||||
#expect(PlayerQuality.restored(from: PlayerQuality.audioOnly.storageValue,
|
||||
forSourceHeight: 1080) == .audioOnly)
|
||||
}
|
||||
|
||||
@Test("Eine vorhandene Sprosse kommt genau zurück")
|
||||
func restoresExactRung() {
|
||||
let chosen = PlayerQuality.limited(.init(bitrate: 3_000, height: 720))
|
||||
|
||||
let restored = PlayerQuality.restored(from: chosen.storageValue, forSourceHeight: 1080)
|
||||
|
||||
#expect(restored == chosen)
|
||||
}
|
||||
|
||||
@Test("Gibt es die Sprosse nicht, kommt die nächstgelegene")
|
||||
func fallsBackToClosestRung() {
|
||||
// Zwanzig Megabit gibt es nur für 1080p. Bei einer 480p-Quelle ist die
|
||||
// beste erreichbare Stufe eine andere — aber nicht „gar keine".
|
||||
let restored = PlayerQuality.restored(from: 20_000, forSourceHeight: 480)
|
||||
|
||||
guard case .limited(let rung) = restored else {
|
||||
Issue.record("keine Stufe zurückbekommen")
|
||||
return
|
||||
}
|
||||
#expect(rung.height <= 480)
|
||||
}
|
||||
}
|
||||
@@ -141,6 +141,27 @@ struct PlaybackTests {
|
||||
#expect(fields["IsPaused"] as? Bool == false)
|
||||
}
|
||||
|
||||
@Test("Verkleinert herunterladen ergibt eine einzelne Datei")
|
||||
func buildsCompressedDownloadURL() throws {
|
||||
let url = try #require(backend(RecordingTransport()).compressedDownloadURL(
|
||||
itemID: "film-1",
|
||||
versionIndex: 0,
|
||||
maximumBitrate: 4_000,
|
||||
resolution: "1280x720"
|
||||
))
|
||||
|
||||
// `.mp4`, nicht `.m3u8`: eine Abspielliste mit hunderten Schnipseln
|
||||
// lässt sich nicht als Datei ablegen.
|
||||
#expect(url.path == "/Videos/film-1/stream.mp4")
|
||||
|
||||
let query = try #require(URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems)
|
||||
// In Bit, nicht in Kilobit — eine Null zu wenig, und aus vier Megabit
|
||||
// werden vier Kilobit.
|
||||
#expect(query.contains(URLQueryItem(name: "videoBitRate", value: "4000000")))
|
||||
#expect(query.contains(URLQueryItem(name: "maxHeight", value: "720")))
|
||||
#expect(query.contains(URLQueryItem(name: "ApiKey", value: "tok")))
|
||||
}
|
||||
|
||||
@Test("Der erste Bericht legt die Sitzung an")
|
||||
func reportsStartSeparately() async throws {
|
||||
let transport = RecordingTransport()
|
||||
|
||||
Reference in New Issue
Block a user