Fünf Punkte aus dem Praxistest

iPad meldete sich nie an
  Die Ursache ist unangenehm speziell: Wer im Browser schon bei Plex
  angemeldet ist, wird von app.plex.tv/auth sofort auf watch.plex.tv
  weitergeschickt — OHNE dass der Code verknüpft wird. Man sieht sich
  angemeldet, die App wartet vergeblich, und es gibt keinerlei Hinweis.

  Jetzt wird plex.tv/link mit eingetragenem Code geöffnet. Diese Seite
  tut nur eine Sache: den Code bestätigen. Die Gerätekennung steckt
  ohnehin schon im PIN.

  Dazu ein Ausweg: bleibt es nach fünfzehn Sekunden ohne Token, erscheint
  der Code im Anmeldebildschirm zum Abtippen. Schließt man das Fenster
  ohne Erfolg, bleibt er stehen statt abzumelden — er gilt weiter.

Download fragte nicht nach der Qualität
  Jetzt Original, Full HD, HD oder Sparsam, jeweils mit geschätzter
  Größe. Die Größe ist das eigentliche Entscheidungskriterium — „Full HD"
  allein sagt nicht, ob es aufs Telefon passt.
  Die komprimierten Stufen laufen über den Universal-Transcoder und sind
  weiterhin NICHT am Server geprüft; steht so im Quelltext.

Schwarzes Bild ohne Anzeige
  Der Player kannte nur „spielt" und „spielt nicht". Wartete er auf
  Daten, stand man vor einem Standbild ohne Hinweis. Es gibt jetzt einen
  eigenen Pufferzustand mit Anzeige.

Aufmacher war beschnitten
  Er stand auf 3:4, Plex liefert als `art` aber 16:9 — mit scaledToFill
  ging links und rechts je ein Viertel verloren, ohne dass man es dem
  Bild ansah. Die Seitenverhältnisse liegen jetzt an einer Stelle in
  FlixyAspectRatio.

Schwarze Leiste über dem Aufmacher
  .ultraThinMaterial statt undurchsichtigem Grund: das Bild läuft
  unscharf hinter der Leiste weiter, statt an einer harten Kante zu
  enden. Weichgezeichnet, nicht abgedunkelt.

139 Tests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy/Session/DownloadService.swift

@@ -7,6 +7,50 @@ import PlexKit
 /// Die Trennung ist Absicht: `DownloadCoordinator` kennt nur Adressen, Bytes
 /// und Zustände — nichts von Plex. Dadurch bleibt die Engine ohne Server
 /// testbar, und dieser Typ ist die einzige Stelle, die beides kennt.
+/// In welcher Qualität heruntergeladen wird.
+enum DownloadQuality: String, CaseIterable, Identifiable {
+    /// Die Datei, wie sie auf dem Server liegt.
+    case original
+    case fullHD
+    case hd
+    case low
+
+    var id: String { rawValue }
+
+    var maximumBitrate: Int? {
+        switch self {
+        case .original: nil
+        case .fullHD: 8_000
+        case .hd: 4_000
+        case .low: 2_000
+        }
+    }
+
+    var resolution: String? {
+        switch self {
+        case .original: nil
+        case .fullHD: "1920x1080"
+        case .hd: "1280x720"
+        case .low: "854x480"
+        }
+    }
+
+    /// Grobe Schätzung der Dateigröße bei dieser Stufe.
+    ///
+    /// Aus Bitrate mal Laufzeit. Nicht genau — der Transcoder arbeitet mit
+    /// variabler Bitrate —, aber genau genug für die Frage, ob es aufs Gerät
+    /// passt. Bei `original` steht die echte Größe zur Verfügung.
+    func estimatedBytes(durationMilliseconds: Int?, originalBytes: Int64) -> Int64 {
+        guard let maximumBitrate, let durationMilliseconds, durationMilliseconds > 0 else {
+            return originalBytes
+        }
+        let seconds = Double(durationMilliseconds) / 1000
+        let estimate = Int64(Double(maximumBitrate) * 1000 / 8 * seconds)
+        // Nie mehr schätzen als das Original groß ist.
+        return originalBytes > 0 ? min(estimate, originalBytes) : estimate
+    }
+}
+
 @MainActor
 struct DownloadService {
     let server: PlexServer?
@@ -18,7 +62,11 @@ struct DownloadService {
     /// ist nicht akademisch: mit `nil` sah der Download-Knopf aus, als täte er
     /// nichts, obwohl der Grund bekannt war — etwa ein Titel, den der Server
     /// noch nicht analysiert hat.
-    func plan(for item: PlexItem, mediaIndex: Int = 0) throws(DownloadRefusal) -> DownloadPlan {
+    func plan(
+        for item: PlexItem,
+        mediaIndex: Int = 0,
+        quality: DownloadQuality = .original
+    ) throws(DownloadRefusal) -> DownloadPlan {
         guard let server else {
             throw .noDownloadableFile(reason: String(localized: "downloads.refused.noServer"))
         }
@@ -31,7 +79,22 @@ struct DownloadService {
         guard let part = media.parts.first else {
             throw .noDownloadableFile(reason: String(localized: "downloads.refused.noPart"))
         }
-        guard let url = server.downloadURL(part: part) else {
+        let url: URL?
+        switch quality {
+        case .original:
+            url = server.downloadURL(part: part)
+        case .fullHD, .hd, .low:
+            // Über den Universal-Transcoder. NOCH NICHT AM SERVER GEPRÜFT:
+            // offen ist, ob Plex eine Content-Length mitschickt — ohne sie
+            // gibt es keinen Fortschrittsbalken und kein Fortsetzen.
+            url = server.transcodedDownloadURL(
+                ratingKey: item.ratingKey,
+                mediaIndex: mediaIndex,
+                maximumBitrate: quality.maximumBitrate ?? 8_000,
+                resolution: quality.resolution
+            )
+        }
+        guard let url else {
             throw .noDownloadableFile(reason: String(localized: "downloads.refused.noURL"))
         }
 
@@ -46,15 +109,22 @@ struct DownloadService {
             seasonIndex: item.parentIndex,
             episodeIndex: item.index,
             durationMilliseconds: item.duration,
-            expectedBytes: part.size ?? 0,
+            expectedBytes: quality.estimatedBytes(
+                durationMilliseconds: item.duration,
+                originalBytes: part.size ?? 0
+            ),
             offlineMedia: offlineMedia(for: item, media: media, part: part)
         )
     }
 
     /// Lädt einen einzelnen Titel.
     @discardableResult
-    func download(_ item: PlexItem, mediaIndex: Int = 0) throws(DownloadRefusal) -> DownloadItem {
-        try coordinator.enqueue(try plan(for: item, mediaIndex: mediaIndex))
+    func download(
+        _ item: PlexItem,
+        mediaIndex: Int = 0,
+        quality: DownloadQuality = .original
+    ) throws(DownloadRefusal) -> DownloadItem {
+        try coordinator.enqueue(try plan(for: item, mediaIndex: mediaIndex, quality: quality))
     }
 
     /// Lädt alle Folgen einer Staffel oder Serie.