Abspielen am Fernseher — mit Apples Player und unseren Spuren

Schritt sieben. Wiedergabe, Spurwahl, Titelzeile, „Intro überspringen".

**Die schwierige Stelle war die Spurwahl.** Unsere Ton- und Untertitelwahl
geht als `audioStreamIndex` an Jellyfin und verlangt bei einem Transcode
einen **neuen Stream**. Apples eingebauter Spurwähler zeigt dagegen die
Auswahlgruppen des **laufenden** Streams — beim Transcode genau eine. Er
ist die richtige Oberfläche für die falsche Liste. Unsere Menüs sitzen
deshalb über `transportBarCustomMenuItems` daneben; `customInfoViewControllers`
wäre falsch, denn die Tonspur ist ein Bedienelement der Wiedergabe und kein
Begleitmaterial.

**Der Neuaufbau wird angesagt, nicht erklärt.** Jeder Eintrag, der Sekunden
mit schwarzem Bild kostet, trägt das als Untertitel — vorher, nicht
hinterher. Wer drückt, sieht den Haken sofort wandern, weil das Menü sich
schliesst und darin kein Platz für einen Kreisel ist. Das schwarze Bild
deckt eine Überlagerung in `contentOverlayView` zu, die hinter den
Bedienelementen liegt und keinen Fokus nimmt — `customOverlayViewController`
täte beides nicht und machte die Fernbedienung währenddessen tot. Und
solange umgebaut wird, sind alle Einträge gesperrt: sonst räumt `restart()`
eine Engine ab, die eine andere gerade baut.

**Die Regel dahinter ist jetzt prüfbar.** „Wann kostet ein Spurwechsel einen
Neuaufbau" lag bisher mitten im Vollzug von `selectAudioStream` und liess
sich nur an einem echten Server mit mehreren Tonspuren auslösen. Als
`TrackMenu` steht sie neben den übrigen Entscheidungsregeln, mit sieben
Tests — darunter der Fall, auf den der Kommentar dort seit jeher hinweist:
stimmt die Spurzahl nicht überein, ist die Zuordnung über die Reihenfolge
falsch, und es muss neu aufgebaut werden.

**Zwei stille Fehler nebenbei.** Die Tonsitzung stand hinter `#if os(iOS)`
und wäre auf tvOS nie gesetzt worden — verfügbar ist sie dort seit 9.0, man
hätte es nur daran gemerkt, dass sich die Wiedergabe gegen anderen Ton
nicht durchsetzt. Und `PlayerModel.downloads` ist jetzt optional statt
eines leeren Koordinators: ein leerer bräuchte einen `ModelContainer`, und
der ist das Einzige, wofür diese App SwiftData benutzt.

**Belegt statt vermutet.** Im Simulator lief die Wiedergabe gegen die
Attrappe, und die Titelzeile zeigte „Unbekannt". Statt an AVKit zu drehen,
hat ein Protokolleintrag die Frage beantwortet: `externalMetadata` wird
gesetzt, der Wert stimmt, und „Unbekannt" ist wörtlich das, was die
Attrappe für unbekannte Kennungen liefert. Geblieben ist davon nur die
Erkenntnis, dass die Beschriftung auf das Item warten muss — beim
Austausch des Players gibt es noch keines.

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

FlixyTV/Views/Player/TVPlayerHost.swift

@@ -0,0 +1,79 @@
+import AVKit
+import SwiftUI
+import FlixyPlayback
+import MediaKit
+
+/// Hängt Apples Player in den SwiftUI-Baum.
+///
+/// **Wem was gehört.** Der `AVPlayerViewController` gehört dem Coordinator,
+/// nicht der SwiftUI-Struktur — die wird bei jedem Neuzeichnen neu gebaut —
+/// und nicht dem `PlayerModel`, das frei von UIKit bleiben soll. Das Modell
+/// gibt nur seinen `AVPlayer` heraus, und das ist AVFoundation.
+@MainActor
+struct TVPlayerHost: UIViewControllerRepresentable {
+    let model: PlayerModel
+    /// Eine Momentaufnahme dessen, was den Controller betrifft.
+    ///
+    /// **Als Wert, nicht als Verweis.** SwiftUI ruft `updateUIViewController`
+    /// nur, wenn sich am Repräsentanten etwas geändert hat. Stünde hier allein
+    /// das Modell, änderte sich nie etwas: es ist eine Klasse, und ihre
+    /// Kennung bleibt über jeden Spurwechsel hinweg dieselbe. Der Wert wird im
+    /// Rumpf der umgebenden Ansicht gebildet — dort und nur dort entsteht die
+    /// Beobachtungsbeziehung zu `@Observable`.
+    let snapshot: TVPlayerSnapshot
+    let onDismiss: () -> Void
+
+    func makeUIViewController(context: Context) -> AVPlayerViewController {
+        context.coordinator.controller
+    }
+
+    func updateUIViewController(_ controller: AVPlayerViewController, context: Context) {
+        context.coordinator.apply(snapshot, model: model)
+    }
+
+    func makeCoordinator() -> TVPlayerCoordinator {
+        TVPlayerCoordinator(onDismiss: onDismiss)
+    }
+}
+
+/// Was der Controller von der Wiedergabe wissen muss — und mehr nicht.
+struct TVPlayerSnapshot: Equatable {
+    /// Wechselt bei jedem Neuaufbau. Daran hängt der Austausch des Players.
+    let playerIdentity: ObjectIdentifier?
+    let audio: [TrackMenu.Entry]
+    let subtitles: [TrackMenu.Entry]
+    /// Läuft gerade ein Neuaufbau? Dann ist das Bild schwarz und das Menü
+    /// gesperrt.
+    let isRebuilding: Bool
+    let title: String
+    let subtitle: String?
+    /// Der Zeitbereich einer Marke — für „Intro überspringen".
+    let markerLabel: String?
+
+    /// `@MainActor`, weil das Modell es ist: gelesen wird hier zwölfmal aus
+    /// ihm, und zwar im Rumpf einer View — also ohnehin auf dem Hauptakteur.
+    @MainActor
+    init(_ model: PlayerModel, offLabel: String) {
+        playerIdentity = model.systemPlayer.map(ObjectIdentifier.init)
+        let direkt: Bool = if case .directPlay = model.decision?.method { true } else { false }
+        audio = TrackMenu.audio(
+            from: model.audioStreams,
+            selected: model.selectedAudioStream,
+            isDirectPlay: direkt,
+            playerTrackCount: model.audioTracks.count
+        )
+        subtitles = TrackMenu.subtitles(
+            from: model.subtitleStreams,
+            selected: model.selectedSubtitleStream,
+            isDirectPlay: direkt,
+            playerTrackLanguages: model.subtitleTracks.map(\.languageCode),
+            offLabel: offLabel
+        )
+        isRebuilding = model.isChangingQuality
+        title = model.title
+        subtitle = model.subtitle
+        markerLabel = model.activeMarker.map {
+            String(localized: $0.isIntro ? "player.skipIntro" : "player.skipCredits")
+        }
+    }
+}