Das Bild füllt den Schirm, und die Schrift bleibt darin

Vier Dinge am iPhone-Player, die zusammengehören, weil sie alle davon
handeln, wo der Bildschirm aufhört.

**Einpassen oder füllen.** `videoGravity` stand fest auf `.resizeAspect`,
und zwar in einer Zeile, die nach jedem Neuaufbau erneut läuft — eine
Wahl hätte dort also jeden Qualitätswechsel nicht überlebt. Jetzt steht
sie im Modell, und die Zeile liest sie. Umgelegt wird mit zwei Fingern
oder über einen Knopf; stufenlos wäre falsch, weil alles zwischen den
zwei Zuständen ein Bild ist, das weder ganz zu sehen ist noch den Schirm
füllt. Auf dem Mac erscheint der Knopf nicht: dort steht der
Vollbildknopf darüber, und zwei Knöpfe, die beide „grösser" bedeuten,
sind eine Zumutung.

**Untertitel im Füllmodus.** Dort reicht das Bild über die untere
Bildschirmkante hinaus, und genau dort zeichnet AVFoundation die
Untertitel. Statt sie anzuschneiden, wird die Bildebene um den
Sicherheitsrand eingerückt — rund zwanzig Punkt Bild gegen eine Zeile,
die man lesen kann. Dafür bekommt die Bildfläche echtes Layout: eine
`autoresizingMask` hält Ränder verhältnismässig, und ein fester Einzug
von zwanzig Punkten wäre im Querformat plötzlich vierzig gewesen.

**Die Bedienleiste kannte ihre Ränder nicht mehr.** Der Player bekommt
`ignoresSafeArea()` von der Wurzel und sieht danach überall null —
Schieberegler und Zeitangaben sassen im Home-Indikator, der Zurück-Pfeil
hinter der Dynamic Island, wo ihn niemand drücken konnte. Gemessen wird
jetzt eine Ebene weiter aussen, wo die Ränder noch gelten, und über die
Umgebung nach innen gereicht. Dieselbe Bauart wie der Akzent. Die Zeile
steht ganz am Ende der Kette: stünde sie vor dem Overlay, umschlösse das
Overlay sie, und ausgerechnet der Player ginge leer aus.

**Gedreht wird einmal, gesperrt wird nicht.** Die Maske blieb auf
`.landscape` stehen — wer im Bett auf der Seite lag, konnte nicht mehr
ins Hochformat drehen. Ein Film beginnt quer, weil er quer ist; danach
gehört die Entscheidung dem Nutzer. Dazu ein Drehknopf für den Fall,
dass die Ausrichtungssperre des Systems an ist, und ein Fehlerbehandler
an `requestGeometryUpdate`: eine abgelehnte Drehung ist dann eine
Einstellung und keine Panne.

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

Flixy/Views/Player/VideoSurface.swift

@@ -52,18 +52,24 @@ struct VideoSurface: View {
     /// nicht, wer sie bekommen **soll**. Das steht hier.
     var isActive = true
 
+    /// Wie viel unten frei bleibt, damit Untertitel nicht abgeschnitten werden.
+    ///
+    /// Siehe `PlayerModel.subtitleBottomInset`. Hier steht nur die Zahl; was
+    /// sie bedeutet, entscheidet das Modell.
+    var bottomInset: CGFloat = 0
+
     var body: some View {
         #if canImport(FlixyVLC)
         if let vlcEngine = engine as? VLCPlayerEngine {
-            SurfaceContainer(view: vlcEngine.videoView, isActive: isActive)
+            SurfaceContainer(view: vlcEngine.videoView, isActive: isActive, bottomInset: bottomInset)
         } else if engine is AVPlayerEngine {
-            SurfaceContainer(view: surface, isActive: isActive)
+            SurfaceContainer(view: surface, isActive: isActive, bottomInset: bottomInset)
         } else {
             Color.black
         }
         #else
         if engine is AVPlayerEngine {
-            SurfaceContainer(view: surface, isActive: isActive)
+            SurfaceContainer(view: surface, isActive: isActive, bottomInset: bottomInset)
         } else {
             Color.black
         }
@@ -130,58 +136,102 @@ final class PlayerLayerView: NSView {
 private struct SurfaceContainer: UIViewRepresentable {
     let view: PlatformView
     let isActive: Bool
+    let bottomInset: CGFloat
 
-    func makeUIView(context: Context) -> PlatformView {
-        let host = UIView()
+    func makeUIView(context: Context) -> SurfaceHostView {
+        let host = SurfaceHostView()
         host.backgroundColor = .black
-        if isActive { adopt(view, into: host) }
+        host.contentInset = UIEdgeInsets(top: 0, left: 0, bottom: bottomInset, right: 0)
+        if isActive { host.adopt(view) }
         return host
     }
 
-    func updateUIView(_ host: PlatformView, context: Context) {
+    func updateUIView(_ host: SurfaceHostView, context: Context) {
+        host.contentInset = UIEdgeInsets(top: 0, left: 0, bottom: bottomInset, right: 0)
         // Wer nicht dran ist, greift auch nicht zu. Ohne diese Zeile holen
         // sich beide Ansichten dieselbe Fläche, und die Reihenfolge
         // entscheidet — mal richtig, mal schwarz.
         guard isActive, view.superview !== host else { return }
-        adopt(view, into: host)
+        host.adopt(view)
     }
 }
 #else
 private struct SurfaceContainer: NSViewRepresentable {
     let view: PlatformView
     let isActive: Bool
+    let bottomInset: CGFloat
 
-    func makeNSView(context: Context) -> PlatformView {
-        let host = NSView()
+    func makeNSView(context: Context) -> SurfaceHostView {
+        let host = SurfaceHostView()
         host.wantsLayer = true
         host.layer?.backgroundColor = NSColor.black.cgColor
-        if isActive { adopt(view, into: host) }
+        host.bottomInset = bottomInset
+        if isActive { host.adopt(view) }
         return host
     }
 
-    func updateNSView(_ host: PlatformView, context: Context) {
+    func updateNSView(_ host: SurfaceHostView, context: Context) {
+        host.bottomInset = bottomInset
         guard isActive, view.superview !== host else { return }
-        adopt(view, into: host)
+        host.adopt(view)
     }
 }
 #endif
 
-/// Hängt die Fläche in ihre Hülle.
+/// Die Hülle, die der Bildfläche ihren Platz zuweist.
 ///
-/// Sie wird **nicht** unmittelbar an SwiftUI zurückgegeben, sondern in eine
-/// eigene Hülle gehängt. Der Unterschied zählt genau in dem Moment, in dem es
-/// Kachel und Vollbild kurz gleichzeitig gibt: eine Ansicht hat nur einen
-/// Vorgesetzten, und wer sie zuletzt bekommt, gewinnt. Gab SwiftUI sie
-/// unmittelbar heraus, nahm das Abräumen der einen der anderen das Bild weg.
-private func adopt(_ view: PlatformView, into host: PlatformView) {
-    #if canImport(UIKit)
-    view.translatesAutoresizingMaskIntoConstraints = true
-    view.frame = host.bounds
-    view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-    #else
-    view.translatesAutoresizingMaskIntoConstraints = true
-    view.frame = host.bounds
-    view.autoresizingMask = [.width, .height]
-    #endif
-    host.addSubview(view)
+/// **Warum nicht mehr `autoresizingMask`.** Bisher bekam die Fläche die
+/// Grösse der Hülle und eine Maske, die sie mitwachsen liess. Eine Maske hält
+/// Ränder aber **verhältnismässig**: ein Einzug von zwanzig Punkten wüchse
+/// beim Drehen mit und wäre im Querformat plötzlich vierzig. Ein fester Rand
+/// verlangt echtes Layout — und das sind genau diese vier Zeilen.
+#if canImport(UIKit)
+final class SurfaceHostView: UIView {
+    /// Was ringsum frei bleibt. Heute nur unten, siehe `VideoSurface`.
+    var contentInset: UIEdgeInsets = .zero {
+        didSet {
+            guard contentInset != oldValue else { return }
+            setNeedsLayout()
+        }
+    }
+
+    /// Hängt die Fläche ein — ohne Maske, die Grösse kommt aus `layoutSubviews`.
+    func adopt(_ view: UIView) {
+        view.translatesAutoresizingMaskIntoConstraints = true
+        view.autoresizingMask = []
+        addSubview(view)
+        setNeedsLayout()
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        subviews.first?.frame = bounds.inset(by: contentInset)
+    }
 }
+#else
+final class SurfaceHostView: NSView {
+    var bottomInset: CGFloat = 0 {
+        didSet {
+            guard bottomInset != oldValue else { return }
+            needsLayout = true
+        }
+    }
+
+    func adopt(_ view: NSView) {
+        view.translatesAutoresizingMaskIntoConstraints = true
+        view.autoresizingMask = []
+        addSubview(view)
+        needsLayout = true
+    }
+
+    override func layout() {
+        super.layout()
+        // Auf dem Mac liegt der Ursprung unten links: einzurücken heisst
+        // hier, den Ursprung anzuheben und die Höhe zu kürzen.
+        var rahmen = bounds
+        rahmen.origin.y += bottomInset
+        rahmen.size.height -= bottomInset
+        subviews.first?.frame = rahmen
+    }
+}
+#endif