Vier Punkte aus dem Praxistest

Download-Knopf tat nichts
  DownloadService.plan gab still nil zurück, wenn es keinen Auftrag
  bauen konnte, und download() reichte das als nil weiter. Der Knopf sah
  aus, als wäre er kaputt, dabei war der Grund jedes Mal bekannt. Es
  gibt jetzt einen eigenen Ablehnungsgrund mit vier unterschiedlichen
  Begründungen — keine Verbindung, keine Datei, kein abrufbarer Teil,
  keine Adresse. Eine Funktion, die kommentarlos nichts tut, ist selbst
  der Fehler.

Live-TV galt als „nicht eingerichtet"
  Plex legt die Empfängerliste unter dem Schlüssel `Dvr` ab, die Hülle
  kannte aber nur Metadata, Directory und Hub. Sie las eine leere Liste
  und zog daraus die falsche Schlussfolgerung — auf einem Server, auf
  dem ein Empfänger eingerichtet war. Dasselbe galt für die
  Anbieterliste unter `MediaProvider`, ohne die es keinen
  Programmführer gibt.

  Beim Umbau wäre beinahe die Fehlerdiagnose verloren gegangen: mit
  `try?` über alle Schlüssel verschwände auch ein echter Dekodierfehler
  und ergäbe stillschweigend eine leere Liste. Aus „ein Feld heißt jetzt
  anders" würde „die Mediathek ist leer". Jetzt wird erst geprüft, ob
  der Schlüssel da ist, und dann ohne try? dekodiert. Fünf Tests halten
  beides fest.

Qualität im Player wählbar
  Automatisch, Original, 1080p, 720p, 480p. Der Eingriff wird genau dann
  gebraucht, wenn es ruckelt — dafür will niemand den Film verlassen.
  Ein Wechsel baut den Strom neu auf (die Stufe steckt in der Adresse),
  merkt sich die Stelle und fährt sie wieder an. Der alte Transcoder
  wird vorher angehalten, sonst rechnet der Server zwei Ströme für einen
  Zuschauer.

AVPlayer-Anzeige entfernt
  Sie war eine Prüfhilfe aus Phase 1. Dieselbe Angabe steht weiterhin
  unter Einstellungen → Diagnose, wo sie hingehört.

137 Tests.

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

Flixy/Views/Player/PlayerModel.swift

@@ -45,6 +45,10 @@ final class PlayerModel {
     /// Ob aus dem Download-Ordner gespielt wird. Dann gibt es keinen
     /// Fortschritt zu melden und keine nächste Folge nachzuschlagen.
     private(set) var isOffline = false
+    /// Die im Player gewählte Stufe. `automatic` folgt den Einstellungen.
+    private(set) var quality: PlayerQuality = .automatic
+    /// Ob gerade auf eine andere Stufe umgestellt wird.
+    private(set) var isChangingQuality = false
 
     private let request: PlaybackRequest
     private let server: PlexServer?
@@ -55,6 +59,12 @@ final class PlayerModel {
     private let isLocalConnection: Bool
 
     private var item: PlexItem?
+    /// Die gerade gespielte Fassung und Datei.
+    ///
+    /// Festgehalten, damit ein Qualitätswechsel die Quelle neu bauen kann,
+    /// ohne die Metadaten erneut zu holen.
+    private var currentMedia: PlexMedia?
+    private var currentPart: PlexPart?
     private var eventTask: Task<Void, Never>?
     private var reportTask: Task<Void, Never>?
     private var transcodeSession: String?
@@ -120,6 +130,9 @@ final class PlayerModel {
             return
         }
 
+        currentMedia = media
+        currentPart = part
+
         let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
         self.decision = decision
 
@@ -132,6 +145,53 @@ final class PlayerModel {
         preloadNextEpisode()
     }
 
+    /// Stellt auf eine andere Qualitätsstufe um.
+    ///
+    /// Bedeutet zwangsläufig einen Neuaufbau: die Stufe steckt in der Adresse
+    /// des Stroms, nicht in einer Einstellung, die sich unterwegs drehen ließe.
+    /// Die Stelle wird gemerkt und danach wieder angefahren — sonst begänne der
+    /// Film bei jedem Wechsel von vorn.
+    func select(quality newQuality: PlayerQuality) async {
+        guard newQuality != quality, !isOffline,
+              let server, let item, let media = currentMedia, let part = currentPart
+        else { return }
+
+        isChangingQuality = true
+        defer { isChangingQuality = false }
+
+        let resumeAt = currentTime
+        quality = newQuality
+
+        // Den alten Transcoder anhalten, bevor der neue anläuft. Sonst rechnet
+        // der Server zwei Ströme gleichzeitig für einen Zuschauer.
+        if let transcodeSession {
+            await server.stopTranscode(sessionIdentifier: transcodeSession)
+            self.transcodeSession = nil
+        }
+        eventTask?.cancel()
+        engine?.teardown()
+        engine = nil
+        phase = .preparing
+
+        let newPolicy = newQuality.policy(basedOn: policy)
+        let newDecision = PlaybackDecider().decide(media: media, part: part, policy: newPolicy)
+        decision = newDecision
+
+        guard let source = await source(
+            for: newDecision,
+            item: item,
+            media: media,
+            part: part,
+            server: server,
+            startingAt: resumeAt
+        ) else {
+            phase = .failed(message: String(localized: "player.noPlayableFile"))
+            return
+        }
+
+        await load(source, decision: newDecision)
+    }
+
     /// Wiedergabe aus dem Download-Ordner.
     ///
     /// Ohne Server und ohne Transcoding: die Datei liegt so vor, wie sie auf
@@ -206,18 +266,22 @@ final class PlayerModel {
         item: PlexItem,
         media: PlexMedia,
         part: PlexPart,
-        server: PlexServer
+        server: PlexServer,
+        startingAt: Duration? = nil
     ) async -> PlaybackSource? {
+        let start = startingAt ?? request.startTime
+
         switch decision.method {
         case .directPlay:
             guard let url = server.directPlayURL(part: part) else { return nil }
-            return PlaybackSource(url: url, origin: .remote, startTime: request.startTime)
+            return PlaybackSource(url: url, origin: .remote, startTime: start)
 
         case .transcode(let maximumBitrate):
             let transcode = TranscodeRequest(
                 ratingKey: item.ratingKey,
                 mediaIndex: request.mediaIndex,
                 maximumBitrate: maximumBitrate,
+                resolution: quality.resolution,
                 isLocal: isLocalConnection
             )
             transcodeSession = transcode.sessionIdentifier
@@ -232,7 +296,7 @@ final class PlayerModel {
             }
 
             guard let url = server.transcodeURL(for: transcode) else { return nil }
-            return PlaybackSource(url: url, origin: .remote, startTime: request.startTime)
+            return PlaybackSource(url: url, origin: .remote, startTime: start)
         }
     }