Live-TV: das Programm zeigte die falsche Sendung als laufend

Der Fehler steckte in der Abfrage, und er ist grob:

    beginsAt> = jetzt − 1 Std.
    endsAt<   = jetzt + 6 Std.

Beide Grenzen schließen genau das aus, was man sehen will. Ein
Zweistünder, der um halb vier begann, war um Viertel nach fünf
unsichtbar — und angezeigt wurde stattdessen die nächste Sendung, die
durch den Filter passte. Deshalb wich die Anzeige von Plex' eigener ab.

Jetzt wird nur der **Anfang** eingegrenzt, mit sechs Stunden Vorlauf für
lange Sendungen, und keine Grenze auf das Ende. Zurück kommt, was den
Zeitraum berührt, statt was vollständig hineinpasst.

Gefiltert wird danach nur das Programm, nicht die Senderliste: ein Sender
ohne frische Daten soll „kein Programm" sagen, statt zu verschwinden.

Dazu zwei Wünsche aus dem Feldtest:

Die Kachel lässt sich in der Größe ziehen. Der Griff sitzt in der Ecke,
die zur Bildschirmmitte zeigt — am äußeren Rand läge er halb außerhalb
des Daumens. Gespeichert wird die begrenzte Breite, nicht die gezogene,
sonst bliebe eine einmal zu weit gezogene Kachel für immer zu groß.

Und eine Senderauswahl. Über zwanzig Sender zu zeichnen und ihr Programm
zu holen kostet Zeit, und die meisten sieht man nie an. Eine leere
Auswahl heißt weiterhin „alle" — sonst stünde man beim ersten Öffnen vor
einer leeren Liste.

Die Zeiten im Raster-Abzug liegen jetzt in der Zukunft. Mit den echten
Zeitstempeln von damals wäre er ab dem Tag nach der Aufnahme leer
gewesen, sobald auf Frische gefiltert wird.

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

Flixy/Views/Player/MiniPlayer.swift

@@ -30,23 +30,43 @@ struct MiniPlayer: View {
         MiniPlayerPlacement.Corner(rawValue: storedCorner) ?? .bottomTrailing
     }
 
-    /// Auf dem iPad darf sie größer sein — dort ist genug Fläche, und bei
+    /// Die selbst eingestellte Breite. Null heißt „noch nie angefasst".
+    @AppStorage("miniPlayer.width") private var storedWidth: Double = 0
+    /// Änderung während des Ziehens am Griff, noch nicht übernommen.
+    @State private var widthChange: CGFloat = 0
+    /// Die zuletzt tatsächlich gezeigte Breite — schon begrenzt.
+    ///
+    /// Ohne sie würde beim Loslassen der ungebremste Wert gespeichert, und
+    /// eine einmal zu weit gezogene Kachel bliebe für immer zu groß.
+    @State private var lastWidth: CGFloat = 0
+
+    /// Auf dem iPad größer voreingestellt — dort ist genug Fläche, und bei
     /// 180 Punkten sähe man auf einem 13-Zoll-Schirm nichts.
-    private var tileWidth: CGFloat { sizeClass == .regular ? 280 : 180 }
-    private var tileSize: CGSize {
-        CGSize(width: tileWidth, height: (tileWidth / FlixyAspectRatio.landscape).rounded())
+    private var defaultWidth: CGFloat { sizeClass == .regular ? 280 : 180 }
+
+    private func tileSize(in bounds: CGSize) -> CGSize {
+        let chosen = storedWidth > 0 ? CGFloat(storedWidth) : defaultWidth
+        // Nach oben durch den Bildschirm begrenzt: eine Kachel, die breiter
+        // ist als das Fenster, ließe sich nicht mehr wegziehen.
+        let upper = max(160, min(bounds.width * 0.75, 560))
+        let width = min(max(chosen + widthChange, 140), upper)
+        return CGSize(width: width, height: (width / FlixyAspectRatio.landscape).rounded())
     }
 
     var body: some View {
         GeometryReader { geometry in
+            let tileSize = tileSize(in: geometry.size)
             let placement = MiniPlayerPlacement(bounds: geometry.size, tile: tileSize)
             let resting = placement.center(for: corner)
             let position = placement.clamped(
                 center: CGPoint(x: resting.x + drag.width, y: resting.y + drag.height)
             )
 
-            tile
+            tile(corner: corner)
                 .frame(width: tileSize.width, height: tileSize.height)
+                .onChange(of: tileSize.width, initial: true) { _, width in
+                    lastWidth = width
+                }
                 .position(position)
                 .gesture(dragGesture(in: placement, from: resting))
                 // Nur während des Ziehens ohne Animation, sonst würde die
@@ -56,7 +76,7 @@ struct MiniPlayer: View {
         .transition(.scale(scale: 0.8).combined(with: .opacity))
     }
 
-    private var tile: some View {
+    private func tile(corner: MiniPlayerPlacement.Corner) -> some View {
         ZStack {
             Color.black
 
@@ -68,6 +88,7 @@ struct MiniPlayer: View {
 
             if showsControls {
                 controls.transition(.opacity)
+                resizeHandle(corner: corner).transition(.opacity)
             }
 
             // Bei einem laufenden Sender hat ein Fortschritt keine Bedeutung —
@@ -135,6 +156,46 @@ struct MiniPlayer: View {
         }
     }
 
+    /// Der Griff zum Größerziehen.
+    ///
+    /// Er sitzt in der Ecke, die zur Bildschirmmitte zeigt — dort ist er
+    /// erreichbar, egal in welcher Ecke die Kachel klebt. Am äußeren Rand
+    /// läge er halb außerhalb des Daumens.
+    private func resizeHandle(corner: MiniPlayerPlacement.Corner) -> some View {
+        VStack {
+            if corner.isTop { Spacer() }
+            HStack {
+                if corner.isLeading { Spacer() }
+                Image(systemName: "arrow.up.left.and.arrow.down.right")
+                    .font(.caption2.weight(.bold))
+                    .foregroundStyle(.white)
+                    .padding(FlixySpacing.snug)
+                    .contentShape(.rect)
+                    .gesture(resizeGesture(corner: corner))
+                    .accessibilityLabel(Text("miniPlayer.resize"))
+                if !corner.isLeading { Spacer() }
+            }
+            if !corner.isTop { Spacer() }
+        }
+        // Gespiegelt, damit das Symbol in die Richtung zeigt, in die es
+        // tatsächlich größer wird.
+        .rotationEffect(.degrees(corner.isTop == corner.isLeading ? 0 : 90))
+    }
+
+    private func resizeGesture(corner: MiniPlayerPlacement.Corner) -> some Gesture {
+        DragGesture()
+            .onChanged { value in
+                hideTask?.cancel()
+                // Klebt die Kachel rechts, wächst sie beim Ziehen nach links.
+                widthChange = corner.isLeading ? value.translation.width : -value.translation.width
+            }
+            .onEnded { _ in
+                storedWidth = Double(lastWidth)
+                widthChange = 0
+                reveal()
+            }
+    }
+
     private var progress: Double? {
         guard let duration = model.duration, duration.seconds > 0 else { return nil }
         return model.currentTime.seconds / duration.seconds