Startseite: der Aufmacher wechselt, die Neuzugänge stimmen

Vier Dinge aus dem ersten Blick auf einen echten Jellyfin-Server.

**„Zuletzt hinzugefügt" waren nicht die Neuzugänge**, sondern eine
alphabetische Liste. Die Reihe kommt jetzt von `/Users/{id}/Items/Latest` —
dem Endpunkt, den Jellyfin dafür hat. Das behebt zwei Fehler auf einmal: die
Sortierung nach Anlegedatum kam alphabetisch zurück, und selbst wenn sie
gegriffen hätte, wäre sie falsch gewesen. Das Anlegedatum einer Serie ist der
Tag, an dem sie in die Mediathek kam; eine Serie, die seit zwei Jahren dort
steht und gestern eine neue Folge bekommen hat, wäre nie aufgetaucht. Die
Antwort ist dort ein nacktes Feld ohne `Items`-Hülle — dafür gibt es einen
Test, sonst bliebe die Startseite eines Tages stumm leer.

**Der Aufmacher war einer und blieb es.** Jetzt sind es bis zu fünf, die alle
sieben Sekunden weiterwandern und sich auch von Hand durchblättern lassen.
Der Zeitgeber hängt an der aktuellen Seite und fängt bei jedem Wechsel von
vorn an — sonst rutscht der Aufmacher genau dann weiter, wenn man sich einen
Titel ansieht. Wer Bewegung abgestellt hat, blättert selbst. Titel ohne
Hintergrundbild werden übersprungen, solange es andere gibt: eine graue
Fläche mit Text ist keine Bühne.

**Die Seitenleiste ist durchscheinend** statt undurchsichtig, und der
Schleier darunter dunkelt schwächer ab — ein voller Schleier hätte aus dem
Milchglas wieder eine Wand gemacht.

**Der Suchlauf ist aus der Mediathek verschwunden.** Er stand im
Dreipunktmenü, einen Tipp neben „Filter" und „Ansicht wechseln", und
beschäftigt den Server minutenlang. Er steht jetzt in den Einstellungen neben
der Mediathek, zu der er gehört.

Dazu eine Jellyfin-Attrappe unter Tools/: ein Server, der gerade genug kann,
dass sich die Oberfläche ansehen lässt. Damit ist diese Runde tatsächlich
angeschaut worden — Anmeldung per Code, Startseite, wandernder Aufmacher,
Seitenleiste, Einstellungen — ohne einen echten Server anzufassen.

Was weiter aussteht: die Seitenleiste oben statt seitlich, und ihre Einträge
selbst zusammenzustellen. Das ist die nächste Runde, nicht diese.

250 Tests grün.

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

Flixy/Views/Home/HeroCarousel.swift

@@ -0,0 +1,74 @@
+import SwiftUI
+import FlixyDesign
+import MediaKit
+
+/// Der Aufmacher oben auf der Startseite — mehrere Titel, die sich abwechseln.
+///
+/// Ein einzelnes Bild sagt jedes Mal dasselbe. Hier wandert der Aufmacher
+/// alle paar Sekunden weiter und lässt sich auch von Hand durchblättern; die
+/// Punkte darunter zeigen, wie viele es sind und wo man gerade ist.
+///
+/// Das Weiterwandern hält an, sobald jemand selbst blättert — der Zeitgeber
+/// hängt an der aktuellen Seite und fängt bei jedem Wechsel von vorn an.
+/// Sonst rutschte der Aufmacher genau in dem Moment weiter, in dem man sich
+/// einen Titel ansieht.
+struct HeroCarousel: View {
+    let items: [MediaItem]
+
+    /// Wie lange ein Titel stehen bleibt.
+    ///
+    /// Lang genug, um Titel, Beschreibung und Knöpfe zu lesen — bei drei
+    /// Sekunden ist der Satz zu Ende, bevor man ihn gelesen hat.
+    private static let dwell: Duration = .seconds(7)
+
+    @State private var index = 0
+    /// Bewegung, die von selbst losgeht, ist für manche Menschen unangenehm
+    /// bis unbrauchbar. Wer sie abgestellt hat, blättert von Hand.
+    @Environment(\.accessibilityReduceMotion) private var reduceMotion
+    @Environment(\.flixyAccent) private var accent
+
+    var body: some View {
+        VStack(spacing: FlixySpacing.regular) {
+            TabView(selection: $index) {
+                ForEach(Array(items.enumerated()), id: \.element.id) { position, item in
+                    HeroSection(item: item)
+                        .tag(position)
+                }
+            }
+            .tabViewStyle(.page(indexDisplayMode: .never))
+            // Die eigene Anzeige des TabView läge über dem Bild und damit über
+            // den Knöpfen. Die Höhe kommt aus dem Seitenverhältnis, weil ein
+            // TabView sonst nimmt, was es kriegen kann.
+            .aspectRatio(FlixyAspectRatio.hero, contentMode: .fit)
+
+            if items.count > 1 { indicator }
+        }
+        .task(id: index) { await advance() }
+        .onChange(of: items.map(\.id)) { _, ids in
+            // Nach dem Aktualisieren kann die Liste kürzer sein als die
+            // Stelle, an der man gerade war.
+            if index >= ids.count { index = 0 }
+        }
+    }
+
+    private var indicator: some View {
+        HStack(spacing: FlixySpacing.snug) {
+            ForEach(items.indices, id: \.self) { position in
+                Capsule()
+                    .fill(position == index ? accent : Color.flixyTextMuted.opacity(0.4))
+                    .frame(width: position == index ? 18 : 6, height: 6)
+            }
+        }
+        .animation(.snappy(duration: 0.25), value: index)
+        .accessibilityHidden(true)
+    }
+
+    private func advance() async {
+        guard items.count > 1, !reduceMotion else { return }
+        try? await Task.sleep(for: Self.dwell)
+        guard !Task.isCancelled else { return }
+        withAnimation(.easeInOut(duration: 0.5)) {
+            index = (index + 1) % items.count
+        }
+    }
+}

Flixy/Views/Home/HomeView.swift

@@ -58,8 +58,9 @@ struct HomeView: View {
     private func content(hubs: [MediaRowGroup]) -> some View {
         ScrollView {
             LazyVStack(alignment: .leading, spacing: FlixySpacing.section) {
-                if let featured = heroItem(in: hubs) {
-                    HeroSection(item: featured)
+                let featured = heroItems(in: hubs)
+                if !featured.isEmpty {
+                    HeroCarousel(items: featured)
                 }
 
                 ForEach(hubs) { hub in
@@ -71,14 +72,26 @@ struct HomeView: View {
         .scrollIndicators(.hidden)
     }
 
+    /// Wie viele Titel der Aufmacher durchwechselt.
+    private static let heroCount = 5
+
     /// Was oben groß gezeigt wird.
     ///
-    /// Erste Wahl ist etwas Angefangenes — wer die App öffnet, will meistens
-    /// weiterschauen. Erst wenn es nichts Angefangenes gibt, tritt der
-    /// Neuzugang an die Stelle.
-    private func heroItem(in hubs: [MediaRowGroup]) -> MediaItem? {
-        let continuing = hubs.first(where: \.isContinueWatching)
-        return continuing?.items.first ?? hubs.first?.items.first
+    /// Angefangenes zuerst — wer die App öffnet, will meistens weiterschauen.
+    /// Aufgefüllt wird aus den übrigen Reihen: bei einer einzigen angefangenen
+    /// Folge gäbe es sonst nichts zu blättern.
+    private func heroItems(in hubs: [MediaRowGroup]) -> [MediaItem] {
+        let continuing = hubs.first(where: \.isContinueWatching)?.items ?? []
+        let rest = hubs.filter { !$0.isContinueWatching }.flatMap(\.items)
+
+        var seen = Set<String>()
+        let candidates = (continuing + rest).filter { seen.insert($0.id).inserted }
+
+        // Ohne Hintergrundbild ist der Aufmacher eine graue Fläche mit Text.
+        // Lieber einen Titel überspringen als eine leere Bühne zeigen — es sei
+        // denn, keiner hätte eines.
+        let withArtwork = candidates.filter { $0.art != nil || $0.seriesArt != nil }
+        return Array((withArtwork.isEmpty ? candidates : withArtwork).prefix(Self.heroCount))
     }
 
     private func load() async {