Mehrere Folgen ankreuzen und in einem Zug laden

Je Folge einzeln zu tippen ist bei einer halb gesehenen Staffel die falsche
Arbeit. „Auswählen" im Kopf der Folgenliste schaltet um: jede Zeile bekommt
einen Kreis, unten erscheint „N Folgen laden".

**Der Knopf steht bei dem, was er auswählt** — in der Zeile mit „Folgen",
nicht oben in der Werkzeugleiste. Dort wäre er weiter von der Liste entfernt
als von allem anderen auf der Seite.

**Nur bei Folgen.** Eine Staffelliste zeigt ihn nicht; für ganze Staffeln
gibt es den Knopf oben im Kopf.

**Die Qualität wird einmal gefragt, nicht je Folge.** Dafür werden die
Dateiangaben **einer** Folge nachgeholt — die Folgen einer Staffel sind in
derselben Fassung kodiert, und zwanzig Anfragen für eine Frage, die einmal
gestellt wird, wären zwanzig zu viel. Geladen wird danach jede Folge
einzeln; dort zählt wieder ihre eigene Größe.

**Was zur Wahl steht, steht jetzt an einer Stelle.** Die beiden Rechnungen
— welche Stufen angeboten werden dürfen und wie sie beschriftet sind —
lagen im Knopf einer einzelnen Folge. Mit der Leiste gäbe es sie zweimal,
und die zweite Kopie wäre die mit dem Fehler. Sie sind jetzt
`DownloadQualityChoice`, ohne eine Zeile SwiftUI darin.

`DownloadService.downloadAll` und der neue Weg teilen sich dieselbe
Schleife; „alle Folgen" ist nur noch „diese Folgen" mit einer anderen Liste.

Im Simulator geprüft: Serienseite ohne Knopf, Staffelseite mit; zwei Folgen
angekreuzt → „2 Folgen laden". iOS und tvOS bauen, 489 Tests grün.

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

Flixy/Views/Downloads/DownloadButton.swift

@@ -74,8 +74,8 @@ struct DownloadButton: View {
             isPresented: $showsQualityChoice,
             titleVisibility: .visible
         ) {
-            ForEach(availableQualities) { quality in
-                Button(qualityLabel(quality)) { enqueue(quality: quality) }
+            ForEach(choice.available) { quality in
+                Button(choice.label(for: quality)) { enqueue(quality: quality) }
             }
             Button("action.cancel", role: .cancel) {}
         } message: {
@@ -166,53 +166,9 @@ struct DownloadButton: View {
         }
     }
 
-    private var currentMedia: MediaVersion? {
-        source.versions.indices.contains(mediaIndex) ? source.versions[mediaIndex] : source.preferredVersion
-    }
-
-    /// Nur Stufen, die unter der Auflösung der Datei liegen.
-    ///
-    /// Und nur, wenn der Server verkleinerte Fassungen überhaupt herausgibt.
-    /// Jellyfin nennt die Adresse dafür erst nach einer eigenen Anfrage — die
-    /// Wahl anzubieten und dann abzulehnen wäre eine leere Zusage.
-    private var availableQualities: [DownloadQuality] {
-        let all = DownloadQuality.available(forSourceHeight: currentMedia?.pixelHeight)
-        guard canDownloadCompressed else { return [.original] }
-        return all
-    }
-
-    private var canDownloadCompressed: Bool {
-        session.backend?.compressedDownloadURL(
-            itemID: item.id,
-            versionIndex: mediaIndex,
-            maximumBitrate: 8_000,
-            resolution: nil
-        ) != nil
-    }
-
-    /// Die Beschriftung samt Auflösung und geschätzter Größe.
-    ///
-    /// Beim Original steht dabei, was es überhaupt ist: „Original · 720p".
-    /// Ohne diese Angabe ist die Wahl blind — man weiß nicht, ob man gerade
-    /// herunterrechnet oder nicht.
-    private func qualityLabel(_ quality: DownloadQuality) -> String {
-        let originalBytes = currentMedia?.files.first?.size ?? 0
-        let bytes = quality.estimatedBytes(
-            durationMilliseconds: item.duration,
-            originalBytes: originalBytes
-        )
-
-        var name = String(localized: quality.localizedName)
-        if quality == .original, let resolution = currentMedia?.resolutionLabel {
-            name += " · \(resolution)"
-        }
-
-        guard bytes > 0 else { return name }
-
-        let size = bytes.formatted(.byteCount(style: .file))
-        return quality == .original
-            ? "\(name) · \(size)"
-            : String(localized: "downloads.quality.approx \(name) \(size)")
+    /// Was zur Wahl steht — siehe `DownloadQualityChoice`.
+    private var choice: DownloadQualityChoice {
+        DownloadQualityChoice(item: source, mediaIndex: mediaIndex, backend: session.backend)
     }
 }
 

Flixy/Views/Downloads/DownloadQualityChoice.swift

@@ -0,0 +1,67 @@
+import Foundation
+import FlixyDownloads
+import MediaKit
+
+/// Welche Qualitätsstufen für einen Titel zur Wahl stehen — und wie sie heißen.
+///
+/// **Als eigener Typ, weil es die Frage inzwischen an zwei Stellen gibt:** am
+/// Knopf einer einzelnen Folge und an der Leiste, mit der man mehrere auf
+/// einmal lädt. Dieselbe Entscheidung zweimal zu schreiben hiesse, dass sie
+/// sich auseinanderentwickelt — und die erste Kopie wäre die mit dem Fehler.
+///
+/// Kein `View`: hier steht keine Zeile SwiftUI, nur die Frage, was angeboten
+/// werden darf und wie es beschriftet ist.
+struct DownloadQualityChoice {
+    let item: MediaItem
+    var mediaIndex: Int = 0
+    let backend: (any MediaBackend)?
+
+    /// Nur Stufen, die unter der Auflösung der Datei liegen.
+    ///
+    /// Und nur, wenn der Server verkleinerte Fassungen überhaupt herausgibt.
+    /// Jellyfin nennt die Adresse dafür erst nach einer eigenen Anfrage — die
+    /// Wahl anzubieten und dann abzulehnen wäre eine leere Zusage.
+    var available: [DownloadQuality] {
+        let alle = DownloadQuality.available(forSourceHeight: currentMedia?.pixelHeight)
+        guard allowsCompressed else { return [.original] }
+        return alle
+    }
+
+    /// Die Beschriftung samt Auflösung und geschätzter Größe.
+    ///
+    /// Beim Original steht dabei, was es überhaupt ist: „Original · 720p".
+    /// Ohne diese Angabe ist die Wahl blind — man weiß nicht, ob man gerade
+    /// herunterrechnet oder nicht.
+    func label(for quality: DownloadQuality) -> String {
+        let originalBytes = currentMedia?.files.first?.size ?? 0
+        let bytes = quality.estimatedBytes(
+            durationMilliseconds: item.duration,
+            originalBytes: originalBytes
+        )
+
+        var name = String(localized: quality.localizedName)
+        if quality == .original, let resolution = currentMedia?.resolutionLabel {
+            name += " · \(resolution)"
+        }
+
+        guard bytes > 0 else { return name }
+
+        let size = bytes.formatted(.byteCount(style: .file))
+        return quality == .original
+            ? "\(name) · \(size)"
+            : String(localized: "downloads.quality.approx \(name) \(size)")
+    }
+
+    private var currentMedia: MediaVersion? {
+        item.versions.indices.contains(mediaIndex) ? item.versions[mediaIndex] : item.preferredVersion
+    }
+
+    private var allowsCompressed: Bool {
+        backend?.compressedDownloadURL(
+            itemID: item.id,
+            versionIndex: mediaIndex,
+            maximumBitrate: 8_000,
+            resolution: nil
+        ) != nil
+    }
+}