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>

Packages/FlixyKit/Tests/FlixyPlaybackTests/TrackMenuTests.swift

@@ -0,0 +1,115 @@
+import Testing
+import MediaKit
+@testable import FlixyPlayback
+
+@Suite("Was im Spurenmenü steht")
+struct TrackMenuTests {
+
+    private func spur(
+        _ id: String,
+        kind: MediaStream.Kind = .audio,
+        sprache: String? = "Deutsch",
+        code: String? = "deu",
+        name: String? = nil,
+        codec: String? = "AC3"
+    ) -> MediaStream {
+        MediaStream(
+            id: id, kind: kind, codec: codec, language: sprache, languageCode: code,
+            displayTitle: name, channels: nil, isSelected: false, isForced: false,
+            title: nil, isDefault: false, isHearingImpaired: false, isOriginal: false
+        )
+    }
+
+    // MARK: - Wann es einen Neuaufbau kostet
+
+    /// **Der Fall, der bisher nirgends stand.** Rechnet der Server um, liegt
+    /// im Stream genau eine Tonspur — jede andere Wahl verlangt eine neue
+    /// Bestellung und damit Sekunden mit schwarzem Bild.
+    @Test("Beim Umrechnen kostet jede Wahl einen Neuaufbau")
+    func transcodeAlwaysRebuilds() {
+        let einträge = TrackMenu.audio(
+            from: [spur("1"), spur("2")],
+            selected: nil, isDirectPlay: false, playerTrackCount: 1
+        )
+        #expect(einträge.allSatisfy { $0.rebuilds })
+    }
+
+    @Test("Unverändert gespielt und gleiche Anzahl: kein Neuaufbau")
+    func directPlayMatchingCountIsCheap() {
+        let einträge = TrackMenu.audio(
+            from: [spur("1"), spur("2")],
+            selected: nil, isDirectPlay: true, playerTrackCount: 2
+        )
+        #expect(einträge.allSatisfy { !$0.rebuilds })
+    }
+
+    /// **Die Regel aus `PlayerModel`, zum ersten Mal prüfbar.** Die Zuordnung
+    /// geht über die Reihenfolge; stimmt die Anzahl nicht, ist die Annahme
+    /// falsch, und es wäre die falsche Sprache statt einer Unterbrechung.
+    /// Auslösen liess sich das bisher nur an einem echten Server.
+    @Test("Abweichende Anzahl heißt Neuaufbau, auch unverändert gespielt")
+    func directPlayMismatchRebuilds() {
+        let einträge = TrackMenu.audio(
+            from: [spur("1"), spur("2"), spur("3")],
+            selected: nil, isDirectPlay: true, playerTrackCount: 2
+        )
+        #expect(einträge.allSatisfy { $0.rebuilds })
+    }
+
+    // MARK: - Untertitel
+
+    @Test("„Aus“ steht vorn und kostet nie einen Neuaufbau")
+    func offComesFirstAndIsFree() {
+        let einträge = TrackMenu.subtitles(
+            from: [spur("1", kind: .subtitle)],
+            selected: nil, isDirectPlay: false, offLabel: "Aus"
+        )
+        #expect(einträge.first?.id == nil)
+        #expect(einträge.first?.title == "Aus")
+        #expect(einträge.first?.isSelected == true)
+        #expect(einträge.first?.rebuilds == false)
+    }
+
+    /// Nur was der Player wirklich hat, lässt sich ohne Neuaufbau schalten.
+    @Test("Eine Untertitelspur, die der Player nicht hat, kostet einen Neuaufbau")
+    func unmappableSubtitleRebuilds() {
+        let deutsch = spur("1", kind: .subtitle, sprache: "Deutsch", code: "deu")
+        let englisch = spur("2", kind: .subtitle, sprache: "English", code: "eng")
+        let einträge = TrackMenu.subtitles(
+            from: [deutsch, englisch],
+            selected: nil, isDirectPlay: true,
+            playerTrackLanguages: ["de"], offLabel: "Aus"
+        )
+        // „deu" und „de" sind dieselbe Sprache — das entscheidet LanguageCode.
+        #expect(einträge[1].rebuilds == false)
+        #expect(einträge[2].rebuilds == true)
+    }
+
+    // MARK: - Beschriftung
+
+    @Test("Der Name des Servers gewinnt, sonst Sprache und Codec")
+    func fallsBackToLanguageAndCodec() {
+        let mitNamen = spur("1", name: "Deutsch (AC3 5.1)")
+        let ohneNamen = spur("2", sprache: "English", codec: "eac3")
+        let einträge = TrackMenu.audio(
+            from: [mitNamen, ohneNamen],
+            selected: mitNamen, isDirectPlay: true, playerTrackCount: 2
+        )
+        #expect(einträge[0].title == "Deutsch (AC3 5.1)")
+        #expect(einträge[1].title == "English · EAC3")
+        #expect(einträge[0].isSelected)
+        #expect(!einträge[1].isSelected)
+    }
+
+    /// Ohne alles bleibt ein Strich — besser als eine leere Zeile, bei der
+    /// niemand weiss, ob sie anklickbar ist.
+    @Test("Ohne Sprache und Codec bleibt ein Strich")
+    func namelessStreamStillHasALabel() {
+        let leer = spur("7", sprache: nil, code: nil, codec: nil)
+        let einträge = TrackMenu.audio(
+            from: [leer], selected: nil, isDirectPlay: true, playerTrackCount: 1
+        )
+        #expect(einträge[0].title == "—")
+        #expect(einträge[0].id == 7)
+    }
+}