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/LiveTV/ChannelSelectionSheet.swift

@@ -0,0 +1,121 @@
+import SwiftUI
+import FlixyDesign
+import PlexKit
+
+/// Welche Sender überhaupt angezeigt werden.
+///
+/// Der Empfänger liefert alles, was die Senderliste hergibt — bei einer
+/// Swisscom-Liste sind das mehr als zwanzig, und die meisten sieht man nie an.
+/// Jeden davon zu zeichnen und sein Programm zu holen kostet Zeit und macht
+/// die Ansicht unübersichtlich.
+struct ChannelSelectionSheet: View {
+    let channels: [PlexChannel]
+    @Binding var selection: Set<String>
+
+    @Environment(FlixySession.self) private var session
+    @Environment(\.flixyAccent) private var accent
+    @Environment(\.dismiss) private var dismiss
+
+    var body: some View {
+        NavigationStack {
+            List {
+                Section {
+                    ForEach(channels) { channel in
+                        row(for: channel)
+                    }
+                } footer: {
+                    Text("liveTV.selection.hint")
+                }
+            }
+            .navigationTitle(Text("liveTV.selection"))
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarLeading) {
+                    // „Alle" statt „keine": eine leere Auswahl bedeutet
+                    // ohnehin alle, und ein Knopf, der scheinbar nichts tut,
+                    // wäre verwirrend.
+                    Button("liveTV.selection.all") { selection.removeAll() }
+                        .disabled(selection.isEmpty)
+                }
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("action.done") { dismiss() }
+                }
+            }
+        }
+    }
+
+    private func row(for channel: PlexChannel) -> some View {
+        Button {
+            // Beim ersten Antippen aus „alle" eine echte Auswahl machen:
+            // sonst hakt man einen Sender an und alle anderen bleiben
+            // trotzdem sichtbar.
+            if selection.isEmpty {
+                selection = Set(channels.map(\.id)).subtracting([channel.id])
+            } else if selection.contains(channel.id) {
+                selection.remove(channel.id)
+            } else {
+                selection.insert(channel.id)
+            }
+        } label: {
+            HStack(spacing: FlixySpacing.regular) {
+                FlixyArtwork(
+                    url: session.server?.artworkURL(path: channel.thumb, width: 120, height: 120),
+                    aspectRatio: 1,
+                    fallbackSymbol: "tv"
+                )
+                .frame(width: 32, height: 32)
+                .clipShape(.rect(cornerRadius: 4))
+
+                if let number = channel.channelIdentifier {
+                    Text(number)
+                        .font(.system(.caption, design: .monospaced))
+                        .foregroundStyle(Color.flixyTextMuted)
+                }
+
+                Text(channel.title)
+                    .font(.flixyBody)
+                    .foregroundStyle(Color.flixyTextPrimary)
+
+                Spacer()
+
+                Image(systemName: isShown(channel) ? "checkmark.circle.fill" : "circle")
+                    .foregroundStyle(isShown(channel) ? accent : Color.flixyTextMuted)
+            }
+            .contentShape(.rect)
+        }
+        .buttonStyle(.plain)
+    }
+
+    private func isShown(_ channel: PlexChannel) -> Bool {
+        ChannelSelection.shows(channel, selection: selection)
+    }
+}
+
+/// Die Regel, nach der ausgewählt wird.
+///
+/// Eigener Typ, weil sie an zwei Stellen gilt — in der Auswahl und in der
+/// Anzeige — und beide dasselbe meinen müssen. Eine **leere** Auswahl bedeutet
+/// „alle": so sieht man beim ersten Öffnen sein Programm, ohne vorher etwas
+/// angehakt zu haben.
+enum ChannelSelection {
+    static func shows(_ channel: PlexChannel, selection: Set<String>) -> Bool {
+        selection.isEmpty || selection.contains(channel.id)
+    }
+
+    static func apply(_ selection: Set<String>, to channels: [PlexChannel]) -> [PlexChannel] {
+        guard !selection.isEmpty else { return channels }
+        let kept = channels.filter { selection.contains($0.id) }
+        // Wählt jemand Sender ab, die es nicht mehr gibt, bliebe sonst eine
+        // leere Liste stehen, ohne dass er es ändern könnte.
+        return kept.isEmpty ? channels : kept
+    }
+
+    /// Die Auswahl als Text, wie sie in den Einstellungen liegt.
+    static func decode(_ stored: String) -> Set<String> {
+        Set(stored.split(separator: "\n").map(String.init))
+    }
+
+    static func encode(_ selection: Set<String>) -> String {
+        selection.sorted().joined(separator: "\n")
+    }
+}