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>

Flixy/Views/Settings/SettingsView.swift

@@ -1,112 +1,51 @@
 import SwiftUI
 import FlixyDesign
-import FlixyDownloads
-import FlixyPlayback
-import MediaKit
-import PlexKit
 
-/// Die Einstellungen.
+/// Die Einstellungen — als Übersicht, nicht als eine lange Liste.
 ///
-/// In Phase 1 bewusst schmal: Serverangaben und Abmelden. Akzentfarbe,
-/// Qualitätsregler und Download-Einstellungen kommen mit den Phasen, in denen
-/// es das Geregelte auch gibt.
+/// 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 — je mehr Einstellungen
+/// dazukamen, desto weiter rutschte alles nach unten.
+///
+/// Jetzt führt jede Zeile in einen Bildschirm, der zu **einer** Frage gehört.
 struct SettingsView: View {
     @Environment(FlixySession.self) private var session
     @Environment(\.flixyAccent) private var accent
-    @Environment(PlaybackSettings.self) private var settings
-    @Environment(DownloadCoordinator.self) private var downloads
     @State private var showsSignOutConfirmation = false
 
     var body: some View {
         Form {
             if session.backend != nil {
-                Section("settings.server") {
-                    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 {
-                    ForEach(session.libraries) { library in
-                        LibraryRow(library: library)
-                    }
-                } header: {
-                    Text("settings.libraries")
-                } footer: {
-                    // Der Suchlauf stand vorher im Dreipunktmenü der Mediathek
-                    // — einen Tipp neben „Filter" und „Ansicht wechseln". Er
-                    // beschäftigt den Server minutenlang und gehört nicht in
-                    // eine Reihe mit Dingen, die man im Vorbeigehen antippt.
-                    if session.backend?.capabilities.contains(.libraryScan) == true {
-                        Text("settings.scanExplanation")
+                    NavigationLink {
+                        ServerSettingsView()
+                    } label: {
+                        LabeledContent {
+                            Text(session.serverName)
+                                .foregroundStyle(Color.flixyTextSecondary)
+                        } label: {
+                            Label("settings.server", systemImage: "externaldrive.connected.to.line.below")
+                        }
                     }
                 }
             }
 
+            Section("settings.section.look") {
+                row("appearance.title", symbol: "paintpalette") { AppearanceView() }
+                row("homeLayout.title", symbol: "rectangle.stack") { HomeLayoutView() }
+            }
+
+            Section("settings.section.playing") {
+                row("settings.playback", symbol: "play.rectangle") { PlaybackSettingsView() }
+                row("languages.title", symbol: "captions.bubble") { LanguagesView() }
+                row("sidebar.downloads", symbol: "arrow.down.circle") { DownloadSettingsView() }
+            }
+
             Section {
-                Picker("settings.qualityWifi", selection: Bindable(settings).wifiQuality) {
-                    ForEach(PlaybackSettings.Quality.allCases) { quality in
-                        Text(quality.label).tag(quality)
-                    }
-                }
-                Picker("settings.qualityCellular", selection: Bindable(settings).cellularQuality) {
-                    ForEach(PlaybackSettings.Quality.allCases) { quality in
-                        Text(quality.label).tag(quality)
-                    }
-                }
-            } header: {
-                Text("settings.quality")
-            } footer: {
-                Text("settings.qualityExplanation")
+                row("diagnostics.title", symbol: "stethoscope") { DiagnosticsView() }
             }
 
-            Section("settings.playback") {
-                Toggle("settings.autoSkipIntro", isOn: Bindable(settings).autoSkipIntro)
-                Toggle("settings.autoSkipCredits", isOn: Bindable(settings).autoSkipCredits)
-                Toggle("settings.autoPlayNext", isOn: Bindable(settings).autoPlayNext)
-            }
-
-            Section {
-                NavigationLink {
-                    AppearanceView()
-                } label: {
-                    Label("appearance.title", systemImage: "paintpalette")
-                }
-
-                NavigationLink {
-                    LanguagesView()
-                } label: {
-                    Label("languages.title", systemImage: "captions.bubble")
-                }
-
-                NavigationLink {
-                    HomeLayoutView()
-                } label: {
-                    Label("homeLayout.title", systemImage: "rectangle.stack")
-                }
-
-                NavigationLink {
-                    DiagnosticsView()
-                } label: {
-                    Label("diagnostics.title", systemImage: "stethoscope")
-                }
-            }
-
-            downloadSection
-
             Section("settings.app") {
                 LabeledContent("settings.version", value: Branding.version)
                 LabeledContent("settings.build", value: Branding.buildStamp)
@@ -141,174 +80,15 @@ struct SettingsView: View {
         }
     }
 
-    /// Die Download-Einstellungen.
-    ///
-    /// Die Löschfrist steht bewusst mit ausgeschriebenen Fristen da statt mit
-    /// einem Schieberegler: „Nach 7 Tagen" ist eine Entscheidung, die man
-    /// bewusst trifft — beim Löschen von Filmen soll niemand versehentlich
-    /// auf „sofort" rutschen.
-    @ViewBuilder
-    private var downloadSection: some View {
-        @Bindable var downloads = downloads
-
-        Section {
-            Picker("settings.storageLimit", selection: storageLimitBinding) {
-                Text("settings.storageUnlimited").tag(Int64(0))
-                ForEach([Int64(5), 10, 20, 30, 50, 100], id: \.self) { gigabytes in
-                    Text("\(gigabytes) GB").tag(gigabytes * 1_000_000_000)
-                }
-            }
-
-            Picker("settings.deleteWatched", selection: deleteAfterBinding) {
-                Text("settings.deleteNever").tag(Double(-1))
-                Text("settings.deleteImmediately").tag(Double(0))
-                Text("settings.deleteAfterDay").tag(Duration.afterOneDay.seconds)
-                Text("settings.deleteAfterWeek").tag(Duration.afterOneWeek.seconds)
-            }
-
-            Picker("settings.keepUnwatched", selection: keepUnwatchedBinding) {
-                Text("settings.keepOff").tag(0)
-                ForEach([1, 2, 3, 5], id: \.self) { count in
-                    Text("settings.keepCount \(count)").tag(count)
-                }
-            }
-
-            Toggle("downloads.wifiOnly", isOn: $downloads.isWiFiOnly)
-        } header: {
-            Text("sidebar.downloads")
-        } footer: {
-            Text("settings.downloadsExplanation")
-        }
-    }
-
-    private var storageLimitBinding: Binding<Int64> {
-        Binding(
-            get: { downloads.storageLimitBytes ?? 0 },
-            set: { downloads.storageLimitBytes = $0 > 0 ? $0 : nil }
-        )
-    }
-
-    private var deleteAfterBinding: Binding<Double> {
-        Binding(
-            get: { downloads.rules.deleteWatchedAfter?.seconds ?? -1 },
-            set: { downloads.rules.deleteWatchedAfter = $0 >= 0 ? .seconds($0) : nil }
-        )
-    }
-
-    private var keepUnwatchedBinding: Binding<Int> {
-        Binding(
-            get: { downloads.rules.keepUnwatchedEpisodes ?? 0 },
-            set: { downloads.rules.keepUnwatchedEpisodes = $0 > 0 ? $0 : nil }
-        )
-    }
-
-    /// 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") }
-        return String(localized: "settings.connectionRemote")
-    }
-}
-
-extension PlaybackSettings.Quality {
-    var label: LocalizedStringKey {
-        switch self {
-        case .original: "quality.original"
-        case .high: "quality.high"
-        case .medium: "quality.medium"
-        case .low: "quality.low"
-        case .minimal: "quality.minimal"
-        }
-    }
-}
-
-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")
-        }
-    }
-}
-
-/// Eine Mediathek in den Einstellungen, mit dem Suchlauf daneben.
-private struct LibraryRow: View {
-    let library: MediaLibrary
-
-    @Environment(FlixySession.self) private var session
-    @Environment(\.flixyAccent) private var accent
-    @State private var phase: Phase = .idle
-
-    private enum Phase { case idle, running, done }
-
-    var body: some View {
-        LabeledContent {
-            HStack(spacing: FlixySpacing.regular) {
-                // Nur, wenn es nicht dasselbe Wort ist: eine Mediathek namens
-                // „Filme" stand sonst als „Filme — Filme" da.
-                if library.title.localizedCaseInsensitiveCompare(library.kind.label) != .orderedSame {
-                    Text(library.kind.label)
-                        .foregroundStyle(Color.flixyTextSecondary)
-                }
-
-                if session.backend?.capabilities.contains(.libraryScan) == true {
-                    Button {
-                        Task { await scan() }
-                    } label: {
-                        symbol
-                    }
-                    .buttonStyle(.borderless)
-                    .disabled(phase == .running)
-                    .accessibilityLabel(Text("library.scan"))
-                }
-            }
+    private func row<Destination: View>(
+        _ title: LocalizedStringKey,
+        symbol: String,
+        @ViewBuilder destination: @escaping () -> Destination
+    ) -> some View {
+        NavigationLink {
+            destination()
         } label: {
-            Text(library.title)
+            Label(title, systemImage: symbol)
         }
     }
-
-    @ViewBuilder
-    private var symbol: some View {
-        switch phase {
-        case .idle:
-            Image(systemName: "arrow.triangle.2.circlepath")
-        case .running:
-            ProgressView().controlSize(.small)
-        case .done:
-            Image(systemName: "checkmark").foregroundStyle(accent)
-        }
-    }
-
-    /// Stößt einen Suchlauf auf dem Server an.
-    ///
-    /// Der Server meldet nicht, wann er fertig ist. Deshalb steht hier kein
-    /// Fortschritt, sondern nur ein Haken dafür, dass der Auftrag angekommen
-    /// ist — ein Balken, der etwas anderes behauptet, wäre erfunden.
-    private func scan() async {
-        guard let backend = session.backend, phase != .running else { return }
-        phase = .running
-        try? await backend.refreshLibrary(library)
-        phase = .done
-        try? await Task.sleep(for: .seconds(4))
-        phase = .idle
-    }
 }