Scarriffle/Flaro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Scarriffle/Flaro:a7cf6c5def07b8f72872559d0b791e4c54808e74
Branches Tags
Scarriffle/Flaro:main
...
compare: Scarriffle/Flaro:main
Branches Tags
Scarriffle/Flaro:main
191 Commits
a7cf6c5def ... main
Author SHA1 Message Date
ScarriffleandClaude Opus 5 68abd71074 Ein Bild, wo bisher nur eine Zahl stand 
Wer zur Zeitleiste greift, sieht jetzt das Standbild der Stelle — im Web
beim Überfahren, in der App beim Ziehen.

**Erzeugt wird beim Abspielen, nicht auf Vorrat.** Ein Lauf über 453
Filme und 4213 Folgen wäre ein Abend ffmpeg und mehrere Gigabyte für
Titel, die niemand anfasst. Startet jemand einen Titel, stellt sich die
Datei hinten an; bis zum ersten Griff zur Leiste ist der Lauf durch.
Gemessen an einer erzeugten Datei: 191 ms für 250 Sekunden Film, ein
Zweistünder liegt damit bei etwa fünf Sekunden.

**Ein ffmpeg-Aufruf, nicht siebenhundert.** `fps=1/10,scale=320:-2,
tile=10x10` macht aus einem Durchlauf fertige Blätter zu hundert
Kacheln. Bezahlbar ist das durch `-skip_frame nokey` — dieselbe
Abkürzung wie beim Abtasten der Abspannhelligkeit: nur Keyframes
dekodieren. Dass die Vorschau dadurch um zwei Sekunden danebenliegen
kann, sieht niemand.

**Der Spieler lädt ein Blatt und verschiebt danach nur den Ausschnitt.**
Beim Fahren über die Leiste wird kein einziger Abruf mehr fällig. Die
Rechnung Sekunde → Kachel steht an drei Stellen — Server, Web, App —
und deshalb auch dreimal dieselbe; weicht eine ab, hält man die Vorschau
für ein unscharfes Bild statt für einen Fehler. Neun Prüfungen decken
die Ränder ab: Sekunde null, letzte Kachel eines Blattes, erste des
nächsten, und hinter dem Ende.

**Die Kachelmasse werden gemessen, nicht gerechnet.** `scale=320:-2`
hält das Seitenverhältnis, ein Breitbildfilm ergibt also flachere
Kacheln. Geraten wäre jede Kachel um ein paar Bildpunkte verschoben.

Aufgeräumt wird mit dem Transcode-Cache: der Namensanfang trägt Kennung
und Änderungszeit der Mediendatei, verwaiste Blätter sind daran ohne
Tabelle erkennbar. Der Ordner taucht unter „Speicher" auf.

**Und die Pfeiltasten spulen wieder.** Hatte die Zeitleiste den Fokus,
überliess der Spieler die Pfeile dem Browser — der verschiebt `value`
und löst `input` aus, aber `change` kommt bei Tastatureingabe nicht
verlässlich, also wurde nie gesprungen. Die Ausnahme fällt weg; Pfeil
heisst überall ±10 Sekunden. Nativ wären es ohnehin 100 Millisekunden
gewesen, weil `step` auf 0,1 steht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-16 17:05:55 +02:00
ScarriffleandClaude Opus 5 ed13d5fa43 Kratzplatz, Markenerkennung, Tonabdruck — erfundene Wörter für Fachbegriffe 
„Scratch disk" wörtlich zu übersetzen ist derselbe Fehler wie „Wachhund"
für Watchdog und „Keks" für Cookie. Und „Marke" ist kein Fachbegriff für
das, was gemeint ist: Jellyfin nennt diese Abschnitte Media Segments, und
das ist auch das Wort, in dem sich darüber reden lässt.

    Kratzplatz*       → Transcode*          (was es ist, steht in FLARO_TRANSCODE)
    Marke, Marken     → Segment, Segmente
    Markenerkennung   → Segmenterkennung
    Markenart/-suche  → Segmentart/-suche
    Tonabdruck        → Fingerprint         (Chromaprint nennt es so)
    Tonabgleich       → Fingerprintabgleich
    Schlüsselbild     → Keyframe
    Bildabtaster      → Frameabtaster

Gewöhnliches Deutsch bleibt gewöhnliches Deutsch: Wartung, Freigabe,
Meldung, Abspann, Vorspann. Das war nie das Problem.

**Was sich nicht ändert, und zwar mit Absicht.** Die drei
Einstellungsschlüssel `wartung.kratzplatz.paket.*` bleiben, wie sie sind —
sie stehen in der Datenbank, und ein neuer Name hiesse, dass die Werte
des Nutzers stillschweigend auf die Vorgabe zurückfallen. Dasselbe für
die Endpunktpfade `/marken`: sie sind nicht sichtbar, und ein Umbenennen
wäre Diff ohne Gewinn.

**Die Migration ist von Hand geschrieben.** `dotnet ef` hat ein Gerüst
erzeugt, das beide Tabellen löscht und neu anlegt — es sieht eine
verschwundene und eine neue Tabelle, nicht eine umbenannte. Damit wäre
jedes erkannte Segment und jeder Vermerk „hier wurde schon gesucht" weg
gewesen. `RenameTable` und `RenameIndex` tun dasselbe, ohne eine Zeile
anzufassen; nachgemessen an einer echten SQLite-Datei: Zeilen vorher 1
und 1, nachher 1 und 1, Inhalt unverändert.

Nachgezogen: in `bilder.ts` und `main.ts` heisst „marke" ein Häkchen und
das Logo — die blieben unberührt. Und „Segment" ist sächlich, was eine
Blindersetzung nicht weiss: „eine Segment" stand danach an vierzehn
Stellen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-16 16:26:57 +02:00
ScarriffleandClaude Opus 5 32f592b83e Ein Abspann darf aus Stücken bestehen 
Zwei Fälle fielen durch, beide am Bestand gesehen. Bei einem Marvel-Film
liegt hinter dem Abspann eine Post-Credit-Szene: die Suche begann am
Dateiende, fand nur den kurzen Rest dahinter und verwarf ihn als zu kurz.
Und ein Abspann, den eine Szene in der Mitte teilt, zerfiel in zwei
Reste, von denen keiner lang genug war. Dieselbe Ursache: der Abspann
musste eine zusammenhängende dunkle Strecke bis zum Dateiende sein.

Jetzt bildet die Suche Läufe, fasst sie über Lücken bis vier Minuten
zusammen — so lang ist die längste bekannte Post-Credit-Szene plus
Reserve — und lässt die **Summe** über die Mindestlänge entscheiden statt
jedes einzelne Stück. Ein Lauf unter fünfzehn Sekunden ist eine Blende
und zählt nicht mit.

Dafür mussten die eindeutigen Indizes über (Titel, Art) weichen; sie
standen mit dem Vermerk „eine Art einmal je Titel" da, und genau das
stimmt nicht mehr. `SchreibenAsync` ersetzt jetzt die Menge, statt eine
Zeile umzuschreiben — das ist der einzige Weg, der in beide Richtungen
stimmt, wenn aus zwei Stücken wieder eines wird.

**Drei Stellen trugen das nicht.** Im Web hiess „Abspann überspringen"
bei einem Film immer Schluss — beim ersten von zwei Stücken bekäme
niemand die Szene je zu sehen; geschlossen wird jetzt nur, wenn nichts
mehr folgt. Auf iOS verwarf der Spieler die Abspannmarke eines Films
ganz; diese Regel gehört nicht dorthin, sondern auf den Server, und ist
ersatzlos weg. Und die Gesehen-Schwelle nahm irgendeine Abspannzeile —
ohne `OrderBy` entschied die Datenbank; gemeint ist immer die früheste.

Dazu der Schalter „Zusätzliche Szenen mit überspringen" (Vorgabe aus) bei
den Geräteeinstellungen, und ein Messwerkzeug: ein Knopf auf der
Filmseite lädt die Kurve je Schlüsselbild als Tabelle — Dunkelanteil des
ganzen Bildes und der beiden Randstreifen. Ob bei Outtakes im Abspann die
Ränder dunkel bleiben, ist eine Vermutung; bevor daraus eine Schwelle
wird, will ich die Zahlen sehen.

Fünf neue Prüfungen, darunter die wichtigste: ein durchgehender Abspann
bleibt ein Stück.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 16:46:27 +02:00
ScarriffleandClaude Opus 5 791c00dacc Nicht wie hell das Bild ist, sondern wie viel davon schwarz 
Gemessen wurde der Mittelwert über das ganze Bild, und daran scheiterte
die Abspannsuche wiederholt: weisse Schrift hebt den Mittelwert. Derselbe
Abspann misst 19, wenn wenig Schrift darin steht, und 37, wenn viel darin
steht — die Schwelle musste zwischen diesen Wert und die Handlung passen,
und der Abstand schrumpfte mit jeder Textzeile. Zweimal nachgezogen,
zweimal wieder getroffen.

Jellyfin zählt stattdessen Pixel, und das ist kein besserer Schwellenwert,
sondern ein besseres Merkmal. Nachgemessen an denselben erzeugten
Abspännen, durch dieselbe Kette wie im Betrieb:

                      Mittelwert   Anteil dunkler Pixel
    Handlung                 128                    0 %
    Abspann, schriftreich     37                   84 %
    Abspann, schlank          19                   87 %
    dunkle Nachtszene         28                   37 %

Schrift belegt ein bis zehn Prozent der Fläche; der Rest bleibt schwarz.
Der Anteil hängt deshalb nicht an der Schriftmenge, und der Abstand zur
Handlung ist nach beiden Seiten riesig.

`signalstats` weicht `blackframe=amount=0:threshold=24` — die Schwelle
für das einzelne Pixel über eine Reihe von Werten eingemessen: darunter
(16) fällt der Abspann selbst auf zehn Prozent ab, darüber (32) fängt die
Handlung an mitzuzählen. Die Ausgabe kommt über denselben
`metadata=print`-Weg wie vorher, nur unter einem anderen Schlüssel.

**Und die relative Schwelle fällt ersatzlos weg.** Sie war nötig, solange
der Mittelwert gemessen wurde: wie hell ein Abspann ist, hing am Film,
also musste sich die Schwelle am Film ausrichten. Der Pixelanteil eicht
sich selbst — `Abspannkante.Schwelle` und `Abspannregeln.Anteil` sind
gestrichen, und mit ihnen die Rechnerei um den Grundton.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 15:14:52 +02:00
ScarriffleandClaude Opus 5 121ee62be9 Erst fragen, ob die Datei den Abspann selbst benennt 
Zweimal gemessen scheitert die Helligkeitssuche am selben: „Alice im
Wunderland" legt den Abspann über verzierte Hintergründe, „(T)Raumschiff
Surprise" zeigt darin Outtakes. Deine Zeile sagt es genau — Schwelle
49,4, letzte Probe 1, dunkle Strecke drei Sekunden: der Film endet
schwarz, und davor ist volles Bild. Helligkeit kann dazu nichts sagen,
und das ist kein Fehler, sondern ihre Grenze.

Ein Kapitel sagt es dagegen genau. Die Suche fragt jetzt zuerst danach:
ffprobe liest dafür nur den Kopf der Datei, Millisekunden gegen zwanzig
Minuten Schlüsselbilder. Findet sie ein benanntes Kapitel am Ende, ist
sie fertig; sonst geht es wie bisher über das Bild.

**Nur bei einem Namen, der es hergibt** — „Chapter 12" ist keine
Auskunft, und das letzte Kapitel ist nicht automatisch der Abspann:
bei vielen Dateien ist es die Schlussszene. Lieber kein Fund als ein
Knopf, der die letzten zehn Minuten Handlung überspringt. „Opening
Credits" bei Minute zwei trägt dasselbe Wort und ist das Gegenteil,
also zählt nur, was im letzten Drittel liegt.

**Und wo nichts gefunden wird, steht jetzt die Kapitellage dabei** —
„Keine Kapitel.", „14 Kapitel, alle ohne Namen." oder „12 Kapitel,
letztes „Finale"." Ob sich an diesem Weg weiterbauen lohnt, sieht man
erst an vielen Dateien, und genau das misst diese Zeile.

Elf Prüfungen: das Lesen der ffprobe-Antwort ohne ffprobe, und die
Regel, wann ein Kapitel zählt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 14:48:22 +02:00
ScarriffleandClaude Opus 5 f79ecf2757 „Schon durchsucht" und „hat eine Marke" sind zwei verschiedene Dinge 
Genau dazwischen fehlte die Unterscheidung. Ein Film, bei dem die Suche
einmal nichts fand, trägt einen Vermerk und keine Marke — und war damit
für jeden weiteren Lauf erledigt, obwohl er der interessanteste Fall ist.
Es gab nur alles oder nichts, und der Knopf bei der Mediathek schickte
immer „alles": 453 Filme mal zwanzig Minuten Schlüsselbilder, auch für
die vierhundert, bei denen längst etwas stand.

Aus `bool erneut` wird `Markenumfang` mit drei Werten. `Neue` ist, was
der Scan tut, und ändert sich nicht. `Luecken` nimmt sich vor, wo keine
Marke steht — gleich ob dort schon einmal gesucht wurde. `Alles` ist der
alte Holzhammer.

Bei der Mediathek jetzt zwei Knöpfe, weil es zwei Fragen sind: „Fehlende
Marken suchen" ist die alltägliche, „Alles neu durchsuchen" die seltene
und teure, und deren Rückfrage nennt die Zahl der Titel. Auf der
Detailseite bleibt es bei einem Knopf mit „alles" — wer ihn bei genau
diesem Titel drückt, ist mit genau diesem Titel unzufrieden.

Bei einer Serie wird eine Staffel ganz gelesen, sobald einer ihrer
Folgen etwas fehlt. Billiger ginge es nur, indem man die Lücke gar nicht
erst angeht, und genau dafür drückt jemand den Knopf.

Vier Prüfungen am Endpunkt, die messen, ob der Lauf den Film anfasst:
`Neue` überspringt den Durchsuchten, `Luecken` nimmt ihn sich vor,
`Alles` sowieso, und ein Film mit Marke bleibt bei `Luecken` in Ruhe.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 14:20:47 +02:00
ScarriffleandClaude Opus 5 f2752e6c05 Ein doppelter Platzhalter riss jede Serie mit 
`log.LogInformation("… {Folgen} … {Folgen}.", a, b, c, d, e)` — sechs
Platzhalter, fünf Argumente. Vorlagen sind positionsbezogen: auch ein
wiederholter Name verbraucht ein weiteres Argument. Der Logger warf eine
Ausnahme, die riss `StaffelMeldenAsync` mit, und die wiederum den ganzen
Serienlauf. Gefunden war dann alles umsonst — „A Knight of the Seven
Kingdoms" und „Alice in Borderland" haben ihre Marken deshalb verloren,
nachdem sie längst berechnet waren.

**CA2017 hatte das gemeldet.** Als Warnung, unter hundert anderen Zeilen,
und ich habe beim Bauen nach „warning CS" gegriffen. Eine neue
`Directory.Build.props` macht genau diese eine Regel zum Fehler — nicht
alle Warnungen, das wäre eine andere Entscheidung. Gegengeprüft: mit der
kaputten Zeile bricht der Bau jetzt ab.

**Und der zweite Fund, aus „Alice im Wunderland".** Die Zeile meldete
„Schwelle 247,6", und das kann bei 0–255 nicht entstehen: die Schwelle
ist Grundton mal 0,55, das wären 450 gewesen. `signalstats` rechnet in
der Skala des Bildformats — bei acht Bit 0–255, bei zehn Bit 0–1023.
Gemessen am selben erzeugten Bild: YAVG 127 gegen YAVG 500. Alle
Schwellen hier sind an acht Bit gemessen; bei einer 10-Bit-Datei bedeutete
dieselbe Zahl ein Viertel.

`format=gray` vor `signalstats` bringt jede Datei auf dieselbe Skala. Es
rechnet dabei auch den Fernsehbereich 16–235 auf 0–255 um — linear, und
die dunklen Werte trifft das am stärksten: der gemessene Abspann liegt
jetzt bei 28 statt bei 40. Der Boden wandert entsprechend von 35 auf 22.

Dazu: die Schlusszeile je Serie trennt Vorspann und Abspann, statt eine
Zahl aus beidem zu machen — „14 Marken" beantwortet nicht, ob die Serie
ihre Vorspänne bekommen hat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 14:06:16 +02:00
ScarriffleandClaude Opus 5 259996c5ad Zweimal vermerkt, einmal gespeichert, Serie verloren 
„Markensuche für ‚A Knight of the Seven Kingdoms' abgebrochen — An error
occurred while saving the entity changes." Das war meiner, und er hat
mehr gekostet als eine Fehlermeldung: der Lauf brach beim Speichern ab,
und damit war alles weg, was er für diese Serie gefunden hatte.

`VermerkenAsync` sah in der Datenbank nach, ob die Staffel schon
vermerkt ist — und eine Abfrage sieht nicht, was derselbe Lauf eben erst
hinzugefügt und noch nicht gespeichert hat. Seit der Bildweg dazukam,
wird für dieselbe Staffel zweimal vermerkt: einmal nach dem Tonabgleich,
einmal vor dem Bild. Die zweite Abfrage fand nichts, legte eine zweite
Zeile an, und der eindeutige Schlüssel über (Serie, Staffel, Art) warf
sie beim Speichern wieder hinaus. Jetzt wird erst im Änderungsspeicher
nachgesehen, dann in der Datenbank.

**Und die Meldung taugte nichts.** Das Tagebuch hängt nur `Message` an,
und EF Core schreibt dort „See the inner exception for details." — eine
Zeile, die ausdrücklich sagt, dass sie die Auskunft nicht enthält. Alle
vier Abbruchmeldungen nennen jetzt den innersten Grund über
`Fehlertext.FuerMenschen`.

**Dazu der zweite Fund aus demselben Protokoll.** „(T)Raumschiff
Surprise": kein Abspann, 1318 Proben, Schwelle 51,1, letzte Probe 17 —
das Ende ist also dunkel, und trotzdem kein Fund. 1318 Proben auf zwanzig
Minuten heissen eine alle 0,9 Sekunden, und die Nachsicht gegenüber
hellen Stellen mitten im Abspann war in *Proben* angegeben: zwei Stück,
dort also 1,8 Sekunden. Bei einer Datei mit einem Schlüsselbild alle zehn
Sekunden waren dieselben zwei Proben zwanzig Sekunden. Dasselbe
Zugeständnis, zehnfach verschieden — genau der Fehler, den ich eine Zeile
höher bei der Schlusstafel schon behoben hatte. `Nachsicht` zählt jetzt
Sekunden, zehn davon.

**Und die Suche sagt, woran es lag.** „kein Abspann — das Ende ist hell"
gegen „die dunkle Strecke ist mit 20 s zu kurz" sind zwei verschiedene
Ursachen mit zwei verschiedenen Antworten; bisher stand dort beides Mal
dasselbe.

Vier neue Prüfungen, darunter dieselbe Szene bei 0,9 und bei 10 Sekunden
Abtastung. Mit der alten Probenzählung ist die dichte rot.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 13:31:48 +02:00
ScarriffleandClaude Opus 5 767491ef03 Serie für Serie, Film für Film — statt einer Zeile mit einer GUID 
Die Markensuche lief stundenlang über 95 Serien, 4213 Folgen und 453
Filme und schrieb dabei fünf Zeilen, in denen Kennungen standen statt
Namen. „Markenerkennung für 4f3a…: 12 Marken." beantwortet keine der
Fragen, die in den letzten Tagen tatsächlich aufkamen — welche Staffel
nichts bekommen hat, warum, und ob die Serie überhaupt dran war.

Jetzt nennt jede Zeile den Titel, und es gibt eine je Serie, je Staffel
und je Folge:

    „Biohackers": 2 Staffel(n), 18 Folge(n).
    „Biohackers", Staffel 2: Vorspann in 8 von 8 Folge(n), Abspann in 1 von 8.
    Biohackers S02E01 · Neuanfang: Vorspann 0:31–1:24, Abspann ab 41:12 (über das Bild).
    Biohackers S02E07 · Letzte Fahrt: Vorspann 0:31–1:24, kein Abspann.
    „Biohackers" fertig: 14 Marke(n).

Die Folgenzeilen werden **aus der Datenbank gelesen, nicht mitgezählt**:
so steht dort, was danach wirklich an der Folge hängt, und nicht, was
dieser eine Lauf geschrieben hat. Nur das beantwortet „warum kommt bei
dieser Folge kein Knopf?".

**Drei Gründe statt eines `false`.** `FilmAsync` gab für „keine Datei",
„schon durchsucht" und „nichts gefunden" dasselbe zurück, und von aussen
waren sie nicht zu unterscheiden. Jetzt sagt jeder seinen Namen.

**Und eine Live-Zeile bei der Mediathek**, wie der Scan sie hat. Sie
benutzt denselben Mechanismus — `Scanschritt` mit einer neuen Phase,
derselbe Endpunkt, ein eigenes Feld. Ein eigenes, weil der Scan sich auf
„fertig" setzt, sobald er die Markensuche angestossen hat; in sein Feld
geschrieben sähe er wieder laufend aus.

**Zwei Fehler sind dabei herausgefallen.** In `NachScanAsync` stand
`if (serien.Count == 0) return;` vor dem Filmteil — eine reine
Filmmediathek bekam nach einem Scan also nie eine Abspannsuche. Und die
fpcalc-Prüfung stand ganz oben und galt für beides, obwohl der Bildweg
fpcalc gar nicht braucht: ohne fpcalc fand der Server keinen einzigen
Filmabspann.

Dazu ein Suchfeld im Protokoll und tausend Anfangszeilen statt
dreihundert. Ohne das wäre eine Zeile je Folge keine Auskunft, sondern
eine Mauer — genau der Fall, gegen den sich `ScanCoordinator` für den
Scan schon einmal entschieden hat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-15 13:11:58 +02:00
ScarriffleandClaude Opus 5 70ab4cc421 Mein Prüfbild war dunkler als jeder echte Abspann 
Die Abspannsuche lief gegen eine feste Schwelle von 35. Die stammte aus
einem erzeugten Prüfbild mit 0,8 Prozent weisser Fläche — Helligkeit 18,
weit unter 35, alles schien zu stimmen. Ein echter Abspann hat mehr
Schrift.

Nachgemessen an 1080p mit zwei Spalten Namen, durch dieselbe ffmpeg-Kette
wie im Betrieb:

    Handlung                              126
    Abspann, realistische Schriftdichte     32
    Abspann, dicht gesetzt                  47

Die Fünfunddreissig lag mitten zwischen den beiden Abspannfällen und
schnitt sie auseinander. Dasselbe noch einmal an der erzeugten Prüfdatei,
nachdem ihr Abspann realistische Dichte bekam: 40,2 — und die Prüfung,
die vorher grün war, wurde rot. Das ist der Fehler, lokal reproduziert.

**Dunkel ist keine absolute Grösse.** Entscheidend ist nicht, wie dunkel
der Abspann ist, sondern dass er viel dunkler ist als das, was davor
lief. Gemessen wird jetzt gegen den Grundton des Films — das obere
Viertel der Proben, mal 0,55. Die alte Schwelle bleibt als Boden, damit
ein durchweg dämmriger Film nicht in Fehlalarme rutscht.

**Und die Logotafel.** Die Suche verlangte, dass die allerletzte Probe
dunkel ist. Hinter dem Abspann steht bei vielen Produktionen noch eine
Tafel — Sender, Studio, Förderer —, oft hell. Ein einziges weisses
Schlussbild machte damit den ganzen Abspann unsichtbar. Zwanzig Sekunden
sind jetzt erlaubt, in Sekunden gezählt und nicht in Proben: wie viele
Messpunkte auf eine Tafel fallen, hängt allein an der Schlüsselbilddichte
der Datei.

**Ein Lauf ohne Fund sagt jetzt, warum.** Anzahl Proben, Schwelle,
letzte Probe — ohne diese drei Zahlen ist „kein Abspann erkannt" keine
Auskunft, und man rät wieder.

Sieben neue Prüfungen mit den gemessenen Werten. Die beiden
entscheidenden sind mit der alten Schwelle rot; gegengeprüft, nicht
behauptet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-14 21:57:39 +02:00
ScarriffleandClaude Opus 5 7e5b3fb0ee Eine Staffel mit einer Folge fiel ganz durch 
Nein, die Erkennung sieht sich nicht die ganze Serie an — sie gruppiert
nach Staffel, vermerkt je Staffel, und der eindeutige Schlüssel führt die
Staffel mit. Andere Besetzung, anderer Abspann, andere Musik in Staffel 2
stören den Abgleich also nicht. Der Verdacht war berechtigt, die Stelle
eine andere.

Gefunden hat ihn die Frage trotzdem. Ganz oben in der Staffelschleife
stand `if (geordnet.Count < 2) continue;` — richtig für den Tonabgleich,
der zwei Folgen zum Vergleichen braucht. Seit es den Bildweg gibt, ist es
zu früh: der braucht keine zweite Folge, nur eine Datei. Eine laufende
Serie, von der erst die Premiere der neuen Staffel da ist, bekam deshalb
gar nichts — weder über den Ton, was stimmt, noch über das Bild, was
hätte gehen müssen.

Jetzt läuft der Tonabgleich nur, wenn es etwas zu vergleichen gibt, und
der Bildweg in jedem Fall. Mit Vermerk, sonst liefe er bei jedem Scan
von Neuem.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-14 21:27:41 +02:00
ScarriffleandClaude Opus 5 ef667a9f39 Erst für sich, dann mit der Bedienung 
Die Acht-Sekunden-Frist war geraten, und sie war die falsche Antwort auf
eine richtige Beobachtung. Ein Zeitgeber entscheidet für den Zuschauer,
wann er genug gesehen hat; das kann er selbst besser.

Jetzt gilt für Vorspann und Abspann, Web wie App, dieselbe Regel: eine
neue Marke zeigt ihre Knöpfe von selbst, ohne dass man das Bild
anfassen müsste. Sobald die Bedienung einmal eingeblendet war, gehören
sie zu ihr und gehen mit ihr — ein- wie ausblenden. Eine neue Marke
fängt wieder von vorn an; sie ist ein neues Angebot.

**Der Übergang zählt, nicht der Zustand.** Beim Start liegt die
Bedienung ohnehin da, und `zeigen()` läuft im Web bei jeder
Mausbewegung. Beides als „einmal gezeigt" zu werten hiesse, dem Intro
seinen Knopf zu nehmen, bevor es ihn je hatte. Gewertet wird deshalb nur
der Sprung von verborgen nach sichtbar.

Am Ende des Films bleiben die Knöpfe stehen: dort ist „Nächste Folge"
die einzige noch offene Frage, und es gibt kein Bild mehr, das sie
verdecken könnten.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-14 16:57:31 +02:00
ScarriffleandClaude Opus 5 820789b7f6 Die Ausnahme löste nichts und stand dafür im Bild 
„Beim Abspann kommt kein Knopf" hatte ich als zu kurze Frist gedeutet und
die Abspann-Knöpfe dauerhaft gemacht. Die Frage war falsch gestellt: es
kam keiner, weil dem Staffelfinale die Marke fehlte — der Tonabgleich
findet sie dort nicht, weil das Finale anders ausklingt. Das ist
inzwischen behoben, über das Bild.

Geblieben war die Ausnahme, und sie liess einen Knopf sechs Minuten lang
über dem Bild stehen, auch nachdem die übrige Bedienung längst weg war.
Jetzt gilt für Vorspann und Abspann dieselbe Frist: acht Sekunden von
selbst, danach zusammen mit der Bedienung. Am Ende des Films bleiben sie
— dort ist es die einzige offene Frage, und es gibt kein Bild mehr, das
sie verdecken könnten.

Im Web steht die Ausnahme noch; dort fällt sie nicht auf, weil die
Bedienung bei jeder Mausbewegung ohnehin zurückkommt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-14 16:52:34 +02:00
ScarriffleandClaude Opus 5 93f4dfd8e9 Ein frischer JSONDecoder, drei Zeilen neben der Warnung davor 
Im Web stand am Abspann „Nächste Folge", in der App nur „Abspann
überspringen". Der Server war es nicht: beide fragen denselben Endpunkt,
und der ordnet nach Staffel und dann nach Nummer — er findet also auch
die erste Folge der nächsten Staffel.

Es war `nachbar`. Die Stelle baute sich einen frischen `JSONDecoder()`,
und der kennt das Datumsformat des Servers nicht. Solange die
Nachbarfolge weder `publishAt` noch `lastPlayedAt` mitbrachte, ging es
gut — mit eingeschalteter Prüfung bringt sie ein `publishAt`. Das `try?`
schluckte den Fehler, und von aussen sah es aus, als gäbe es keine
nächste Folge: kein Knopf, kein Hinweis, nichts.

In `FlaroClient` steht seit je ein eingerichteter Dekoder, ausdrücklich
nicht privat, „damit die Prüfungen denselben Dekoder benutzen" — und
direkt darunter die Warnung, dass ein frischer an genau diesem Format
scheitert. Diese eine Stelle las sie nicht.

Vier Prüfungen dazu, darunter die mit Datumsangaben: mit dem alten
Dekoder ist sie rot, mit dem neuen grün. Gegengeprüft, nicht behauptet.

Die übrigen frischen Dekoder im Quelltext lesen nur, was dieselbe App
vorher selbst geschrieben hat — Zwischenspeicher, Abzüge, Offline-
Angaben. Die laufen rund und bleiben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-14 08:39:31 +02:00
ScarriffleandClaude Opus 5 ce4da992ea Einen Knopf je Serie ist bei fünfundneunzig kein Angebot 
Es gab ihn: auf der Serienseite, das Uhrsymbol. Nur gilt er für genau
eine Serie — und nach jeder Änderung an der Erkennung will man ohnehin
alles noch einmal. Der Weg dorthin fehlte da, wo man ihn sucht: bei der
Mediathek, neben „Scannen" und „Metadaten auffrischen".

Der Lauf selbst war schon da. `NachScanAsync` macht genau das, Serien
über den Tonabgleich und Filme über das Bild — er hing bloss am Scan und
liess sich nicht von Hand anstossen. Jetzt nimmt er ein „erneut" entgegen
und ist über einen Endpunkt erreichbar. Die Antwort kommt sofort: über
einen grossen Bestand dauert das Stunden, und eine Anfrage so lange offen
zu halten hiesse, sie in ein Zeitlimit laufen zu lassen. Wie weit es ist,
steht im Protokoll von heute.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 21:01:11 +02:00
ScarriffleandClaude Opus 5 1340176bf0 Beim Staffelfinale klingt der Abspann anders 
Und genau daran fiel er durch. Der Tonabgleich lebt davon, dass der
Abspann in jeder Folge derselbe ist; beim Finale ist er es oft nicht —
anderer Schluss, andere Musik, kein Treffer. In jeder Staffel fehlte
deshalb genau eine Marke, immer die letzte, und wer dort weitersah, sah
keinen Knopf. Das war der ganze Fehler. Der Spieler war nie schuld, und
meine Schranken-Vermutung von eben war falsch.

Was der Ton nicht findet, sucht jetzt das Bild — derselbe Weg wie bei
einem Film: dunkel werden und bis zum Ende durchhalten. Das Verfahren
lag fertig in `FilmAsync` und war nur dort eingebaut; es steht jetzt für
sich und wird von beiden benutzt. Nur für die Lücken: bei einer Staffel
ohne fehlende Marke läuft der Abtaster gar nicht.

**Drei Punkte heissen „mehr davon", nicht „tu etwas".** Bei einer Folge
taten sie etwas — wegräumen aus „Fortsetzen", ohne Rückfrage. Jeder, der
sie sah, hat ein Menü erwartet, draufgetippt, und dann baute die Seite
sich neu auf und die Punkte waren weg. Jetzt ein Kreuz, und eine Zeile,
die sagt, was geschehen ist.

Und die Markenanzeige nennt die Zeiten, nicht nur die Namen: dass eine
Marke da ist, sagt noch nicht, dass sie an der richtigen Stelle steht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 20:49:50 +02:00
ScarriffleandClaude Opus 5 74643b8242 Gefunden und gleich wieder weggeworfen 
**Stream, nicht Strom.** Mein Fehler, und die Regel kenne ich: Fachbegriffe
bleiben englisch. Betroffen war eine Meldung im Spieler und vier Zeilen im
Tagesprotokoll.

**Der Abspann fiel durch die eigene Schranke.** `Hoechstlaenge` von fünf
Minuten galt für Vorspann und Abspann gleichermassen. Fünf Minuten sind
für einen Abspann aber keine Obergrenze, sondern die Regel — eine deutsche
Serienproduktion listet Sprecher, Synchronregie und Studio hinterher, und
sechs Minuten kommen vor. Der Tonabgleich fand das Stück, und die Zeile
darunter warf es weg. Von aussen sah das aus wie „nichts gefunden".
Der Abspann darf jetzt so lang sein wie sein Suchfenster; weiter reicht
eine Marke ohnehin nie.

**Vermutung, nicht Messung** — das Stück steht auf einem Server, an den ich
nicht komme. Deshalb dasselbe Commit:

**Man kann jetzt nachsehen.** Neben jeder Folge steht für Verwalter, was
die Erkennung gefunden hat: „Vorspann + Abspann", „Vorspann" oder „keine
Marken". Ob eine Marke fehlt oder bloss nicht angezeigt wird, war von
aussen nicht zu unterscheiden — und beides hat eine andere Ursache. Die
Angabe kostet nichts: sie steht längst in der Antwort des Servers.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 20:33:52 +02:00
ScarriffleandClaude Opus 5 a360bed02b Vier Stellen, an denen eine Angabe unterwegs verlorenging 
**Der Aufmacher wusste nur die Serie.** `Heroeintrag.titel` ist bei einer
angefangenen Folge der Name der Serie — richtig, denn der Aufmacher zeigt
die Serie. Wer von dort startete, las über dem Spieler „Biohackers" und
nicht, welche Folge läuft. Staffel, Nummer und Folgentitel reisen jetzt
mit. Dasselbe im Aufmacher selbst: „Staffel 1 · Folge 2" statt „S1 · F2".

**Der Abspann ist kein Angebot, sondern eine Frage.** Die Acht-Sekunden-
Frist von gestern war für das Intro gedacht und traf den Abspann mit:
„Nächste Folge" verschwand genau dort, wo man hinsieht. Ein Intro-Knopf
geht, wenn man ihn nicht nimmt; der Abspann-Knopf bleibt, bis die Folge
zu Ende ist. Web und App.

**„deu" stand da, weil es in der Datei steht.** Der Server reichte einen
vorhandenen Spurnamen unbesehen durch — und viele Dateien tragen als
Titel schlicht das Sprachkürzel. Wiederholt er bloss die Sprache, gilt er
nicht, und die Tabelle darunter macht „Deutsch" daraus.

**Und zweimal „Deutsch" ist keine Wahl.** Zwei deutsche Untertitelspuren
sind der Normalfall — Vollfassung und Nur-Fremdsprachiges. Gleichnamige
bekommen jetzt ihren Codec dazu, und wenn der auch gleich ist, die
Nummer. Das kann keine Spur für sich beantworten: ob ein Name eindeutig
ist, hängt an den anderen. Deshalb steht es in `Benennung` und hat fünf
Prüfungen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 17:34:11 +02:00
ScarriffleandClaude Opus 5 d152ac3795 Der Regler gehörte der Uhr, nicht dem Finger 
`zeitAuffrischen` schrieb `zeitleiste.value` bei jedem `timeupdate` neu —
viermal je Sekunde, auch mitten im Ziehen. Das hatte zwei Gesichter, und
nur das harmlosere war zu sehen: der Knopf sprang unter dem Finger an die
laufende Stelle zurück, und nach dem Loslassen noch einmal, weil ein
Sprung einen Augenblick braucht und der Spieler in dem weiter die alte
Stelle meldet.

Das andere ist schlimmer. Gemessen an einer Nachbildung mit 20-ms-Takt:
gezogen auf 113, und `onchange` las 7 — der Takt hatte `value` überschrieben,
bevor der Browser den Zug festschreiben konnte. Es sprang also nicht nur
zurück, es sprang an die falsche Stelle. Genau deshalb half Festhalten: es
schiebt den letzten `input` näher an den `change`.

Jetzt gehört der Regler dem Zeiger, solange einer darauf liegt, und danach
dem Sprungziel, bis der Spieler dort angekommen ist. Mit Notbremse nach
dreissig Sekunden, damit eine Leiste nie stehen bleibt, wenn ein neu
gebauter Strom woanders herauskommt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 16:39:28 +02:00
ScarriffleandClaude Opus 5 0186087051 Ein Angebot, das keiner annimmt, nimmt man zurück 
„Intro überspringen" soll erscheinen, ohne dass man den Bildschirm
antippen muss — das war der Wunsch, und er war richtig. Nur blieb der
Knopf dann liegen, solange die Marke dauert: bei einem Abspann sechs
Minuten lang ein Knopf über dem Bild, auch nachdem die übrige Bedienung
längst weggeblendet war.

Jetzt hat er eine eigene Frist. Acht Sekunden von selbst, lang genug zum
Bemerken und Treffen; danach gehört er zur Bedienung wie alles andere
und kommt mit einem Antippen zurück. Am Ende des Films bleibt er stehen
— dort ist er die einzige Frage, die noch offen ist.

Im Web dasselbe, plus die Stelle, an der es im Stehen auseinanderfiel:
`markenstand` rechnet nur, während das Bild läuft. Wer pausiert im Intro
die Maus bewegte, bekam die Bedienung zurück und den Knopf nicht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 16:16:15 +02:00
ScarriffleandClaude Opus 5 fbd865e93b Heruntergeladen heisst nicht: ohne Angaben 
Bei einer lokalen Datei kehrte der Spieler zurück, sobald sie lief — und
liess `item` leer. Daran hing mehr als der Titel: keine Marken, also kein
„Intro überspringen"; keine Nachbarfolgen, also keine Knöpfe zum Blättern.
Nur bei Heruntergeladenem, und darum sah es so lange nach einem Fehler in
der Erkennung aus. Jetzt werden die Angaben nachgeholt, während das Bild
schon läuft.

Dazu, was derselbe Weg betrifft: der Spieler sagt „Staffel 1 · Folge 6"
statt „S1 E6" — der Folgenname wird an einer Stelle gebaut, nicht an
dreien. Im Abspann einer Serie stehen zwei Knöpfe statt einem, weil der
Abspann zwei Fragen stellt.

Und die Abdrücke, mit denen der Tonabgleich geprüft wird, sind jetzt
echte: zwei Aufnahmen desselben dreissigsekündigen Stücks, verschiedene
Bitraten, durch fpcalc gedreht. Vorher war jede Prüfung mit erfundenen
Zahlen bestanden — und genau deshalb war nie belegt, dass der Abgleich an
echten Daten etwas findet. Er findet: 17,8–51,0 s und 72,7–105,9 s, bei
20–50 und 75–105.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 16:03:57 +02:00
ScarriffleandClaude Opus 5 afa78f9ee0 Ein Knopf, von dem niemand weiss, dass es ihn gibt, ist keiner 
„Intro überspringen" lag im Web in der Bedienleiste und verschwand mit
ihr. Am Fernseher sieht man die Leiste gar nicht — der Knopf war also
da und trotzdem unsichtbar. Jetzt liegt er als eigene Schicht über dem
Bild und bleibt stehen, solange die Marke läuft.

**Im Abspann ist „überspringen" ohnehin die falsche Frage.** Was man
dort will, ist die nächste Folge; ans Ende dieser zu springen bringt
niemanden weiter. Gibt es eine, heisst der Knopf jetzt so — im Web wie
in der App, und in der App nicht mehr erst, wenn alles durchgelaufen
ist. Bei einem Film gibt es nichts danach: dort heisst „Abspann
überspringen" jetzt wirklich Schluss, statt auf ein stehendes Bild zu
spulen und den Spieler offen zu lassen.

Dazu der Titel über dem Spieler. Dort stand bei einer Folge „S1 E6" und
bei einer aus der Detailseite gestarteten sogar nur „Wiedergabe". Auf
einer Kachel ist die Kurzform richtig, dort zählt jeder Buchstabe; über
dem Spieler steht eine Zeile in einer leeren Fläche. Jetzt steht da
„Küstenwache · Staffel 1 · Folge 6 · Der Nebel kommt". In der App hiess
es „Episode" statt „Folge" — das eine Wort, das sonst nirgends steht.

Und drei Prüfungen für die Marken auf dem Weg in die App: aus einer
Serverantwort mit Vorspann und Abspann werden zwei Marken an der
richtigen Stelle. Die Übersetzung war nicht der Grund, warum der Knopf
dort fehlte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 15:35:59 +02:00
ScarriffleandClaude Opus 5 7673c73757 Vier Sekunden, die ffprobe zu früh aufhörte zu lesen 
Die Untertitel kamen vier Sekunden zu spät. Nicht an ihnen lag es: der
Server meldete dem Spieler einen Anfang, der vor dem lag, an dem der
Strom wirklich begann, und genau diese Differenz landet eins zu eins im
Versatz.

Die Schlüsselbildsuche las mit `-read_intervals` bis eine halbe Sekunde
hinter den Wunsch. ffprobe bricht am Ende eines Fensters auf Paketebene
ab — das letzte Schlüsselbild darin kam regelmässig gar nicht mehr
heraus, und die Suche gab das davor zurück. Bei Bildgruppen von vier
Sekunden sind das vier Sekunden.

Nachgemessen gegen die Stelle, an der ffmpeg tatsächlich anfängt, an
einer Datei mit Schlüsselbildern alle vier Sekunden:

    Wunsch   Suche (0,5 s)   ffmpeg    Abweichung
      52,0            48      52,0         −4,0
      73,3            68      72,0         −4,0
     100,2            96     100,0         −4,0

Mit zehn Sekunden Nachlauf lag dieselbe Messung bei allen sieben Werten
auf 0,000. Was über den Wunsch hinausgelesen wird, verwirft die
Filterung ohnehin.

Die Prüfung vergleicht nicht gegen eine erwartete Zahl, sondern gegen
ffmpeg selbst — mit dem alten Wert fällt sie um.

Dazu der Filmteil der Abspannerkennung: `Abspannkante` als reine
Rechnung mit elf Prüfungen, `Bildabtaster` über ffmpeg, Marken auch an
Filmen, Knöpfe zum Suchen und Verwerfen auf der Filmseite. An einer
erzeugten Datei trifft die Kante auf vier Sekunden genau.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 06:42:16 +02:00
ScarriffleandClaude Opus 5 8112c15d4d Jeder Scan hätte jede Tonspur noch einmal gelesen 
Gemerkt wurde nur, was gefunden wurde. Eine Staffel ohne Abspann — es
gibt genug davon — sah damit bei jedem Scan aus wie eine, in der noch
niemand nachgesehen hat, und wurde wieder abgetastet: jede Tonspur jeder
Folge noch einmal von der Platte, für immer, ohne Ertrag. Bei
sechstausend Folgen ist das kein Schönheitsfehler.

Jetzt steht auch „gesucht und nichts gefunden" in der Datenbank, je
Staffel und Art. Ausgelöst wird ein zweiter Lauf von der Folgenzahl:
kommt eine Folge dazu, gibt es etwas Neues zu vergleichen, sonst nicht.
Ein Zeitstempel allein täte das nicht — eine Staffel, die sich nie
ändert, hat nie einen Grund für einen zweiten Lauf.

Dazu der Knopf, der ausdrücklich doch noch einmal rechnet: die Uhr auf
der Serienseite sucht ab jetzt immer neu. Von selbst läuft die Suche
nach jedem Scan und überspringt dort das Abgesuchte; wer hier drückt,
will genau das Gegenteil.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-13 05:51:23 +02:00
ScarriffleandClaude Opus 5 9bcdd239d7 Entwurf: den Abspann eines Films im Bild finden 
Der Tonabgleich kann bei Filmen grundsätzlich nichts finden — er erkennt
einen Abspann daran, dass er sich über die Folgen einer Staffel
wiederholt, und ein Film hat nichts, womit er sich vergleichen liesse.

Der Entwurf steht auf zwei Messungen statt auf Vermutungen: an einem
erzeugten Film liegt die mittlere Helligkeit in der Handlung bei 125 und
im Abspann bei 18, mit einer scharfen Kante genau am Übergang. Und das
Dekodieren der letzten Minuten kostet 2,89 Sekunden, wenn man jedes
zweite Bild nimmt, aber 0,24, wenn man sich auf Schlüsselbilder
beschränkt.

Dazu steht drin, wo das Verfahren danebenliegt: ein Abspann über
laufendem Bild hat keine dunkle Strecke und bekommt deshalb keinen Knopf.
Das ist die richtige Antwort — ein geratener Knopf schnitte Handlung weg.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 22:12:15 +02:00
ScarriffleandClaude Opus 5 fd79fb4022 „No such file or directory" über Dateien, die da waren 
Im Protokoll stand für jede einzelne Folge, fpcalc könne die Datei nicht
öffnen — während der Spieler dieselbe Datei im selben Augenblick
umpackte. Null Marken, und der Grund stand nicht da.

`-ts` ist bei fpcalc kein Zeitstempel, sondern ein Schalter: „gib
Zeitstempel aus". Die Sekundenzahl dahinter las fpcalc als zweiten
Dateinamen, fand ihn nicht und brach ab, bevor es die echte Datei
überhaupt ansah.

Nachgemessen am Binärprogramm aus dem Abbild: einen Startpunkt gibt es
bei fpcalc gar nicht. `-length` begrenzt nur die Dauer vom Anfang an —
für den Abspann braucht es aber das Ende. Also einmal die ganze Spur je
Folge, und Vorspann wie Abspann sind danach zwei Ausschnitte aus
demselben Abdruck.

Das ist nicht nur richtig, sondern billiger: eine Folge von 45 Minuten
kostet 1,6 Sekunden und ergibt 21 786 Werte — gegenüber zwei
Ausschnitten, die zusammen mehr gekostet hätten und nie funktionierten.
Die Rate von 0,1239 Sekunden je Wert steht jetzt als Prüfung daneben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 22:09:56 +02:00
ScarriffleandClaude Opus 5 2c535e6f47 Drei Wege, die über ein Neuladen führten 
**In „Fortsetzen" startet ein Tipp.** Dort steht ein Titel, *weil* man ihn
angefangen hat, und die Stelle steht daneben — der Umweg über die
Detailseite stellte eine Frage, die schon beantwortet war. Überall sonst
bleibt es beim Weg auf die Seite: wer nachsehen will, wie viele Staffeln
eine Serie hat, soll nicht den Film bekommen.

**Ein Haken nimmt die Kachel mit.** In „Fortsetzen" und „Als Nächstes"
steht, was offen ist. Eine abgehakte Folge ist nicht mehr offen — sie mit
einem Haken stehen zu lassen sah aus, als hätte das Abhaken nicht
gewirkt. Dasselbe für „Aus Fortsetzen entfernen": in der Reihe selbst
heisst entfernen genau das.

**Und ein getauschtes Bild erreicht den Aufmacher.** Wer auf der
Startseite ein Plakat wechselt, sieht denselben Titel gleich darüber in
voller Breite — dort stand bis zum nächsten Neuladen das alte. Die
Kachel frischt sich selbst auf; der Aufmacher steht ganz woanders und
erfuhr nichts davon. Jetzt meldet der Bilderdialog es der ganzen Seite,
und wer es angeht, hört zu.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 21:54:50 +02:00
ScarriffleandClaude Opus 5 adca700c4a Marken suchen, ohne dass jemand danach fragt 
Eine neue Folge bekommt keine Vorspann-Marke, wenn niemand den Knopf
drückt — und niemand drückt ihn, weil man nicht weiss, dass es etwas zu
drücken gibt. Der Scan ist der Augenblick, in dem neue Folgen entstehen;
jetzt hängt sich der Lauf dort hinten an.

Eine Serie nach der anderen, nicht alle zugleich: jede liest von jeder
ihrer Folgen ein Stück Ton, und zwanzig gleichzeitig wären zwanzig
Leseköpfe auf derselben Platte. Gerechnet wird nur, wo noch nichts
steht — beim ersten Mal über einen grossen Bestand dauert das
entsprechend, danach findet der Lauf nichts mehr zu tun.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 21:52:24 +02:00
ScarriffleandClaude Opus 5 1d70be0f99 Fünf Aufmacher je Titel, und der Abspann zählt als Schluss 
**Der Aufmacher darf wechseln.** Bisher hing hinter jedem Titel genau ein
Hintergrundbild, und das Karussell war nach einer Woche ein Standbild.
Jetzt lassen sich bis zu fünf Aufnahmen aussuchen — im Bilderdialog unter
einem vierten Reiter, gespeist aus denselben Hintergründen.

Welches gerade gilt, entscheidet der Server aus Uhrzeit und Kennung: alle
fünf Stunden ein anderes, überall dasselbe — im Web, in der App, nach
einem Neustart. Ein Zufall je Abruf hiesse, dass das Bild beim Blättern
springt; eine gespeicherte Wahl hiesse einen Schreibvorgang je Titel und
Fenster. Die Kennung geht mit in die Rechnung, damit nicht alle Titel im
selben Augenblick umschalten.

Plakat und Hintergrund bleiben unberührt. Sie stehen hinter Kacheln und
Kopfzeilen, und dort soll nichts wechseln.

**Und der Abspann zählt als Schluss.** Eine Serie hängt sechs Minuten
Abspann an eine Folge von fünfundvierzig; neunzig Prozent liegen dann
mittendrin, und die Folge gilt erst als gesehen, wenn man ihn sich ganz
ansieht. Die Schwelle herunterzudrehen hiesse, jeden anderen Titel zu
früh abzuhaken. Der erkannte Abspann ist die genauere Antwort auf
dieselbe Frage — er zieht die Schwelle nach vorn, nie nach hinten.

Dazu der Verlauf über dem Aufmacher: er war immer noch zu dunkel. Jetzt
trägt der Schattenwurf der Schrift, was vorher eine Decke über dem
ganzen Bild tat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 21:44:43 +02:00
ScarriffleandClaude Opus 5 8cf2118723 Vorspann und Abspann — erkannt, abgelegt, überspringbar 
Beides mit derselben Rechnung, nur in einem anderen Fenster: vorn die
ersten fünfzehn Minuten, hinten die letzten zehn. Was `Tonabgleich`
findet, hängt allein daran, welchen Ausschnitt man ihm gibt — eine
zweite Erkennung für den Abspann wäre dieselbe Suche ein zweites Mal.

Je Staffel verglichen, nicht je Serie: Serien wechseln ihren Vorspann
zwischen Staffeln, und über alle hinweg fände man nichts oder das
Falsche. Gefundenes über fünf Minuten wird verworfen — zwei Folgen, die
dieselbe Datei tragen, teilen vierzig, und darüber stünde sonst ein
Überspringen-Knopf.

Der Lauf geht auf Zuruf, nicht bei jedem Scan: er liest von jeder Folge
ein Stück Ton und dauert Minuten. Der Knopf dafür steht auf der
Serienseite, bei den Verwalterknöpfen.

Die Marken gehen im Folgenvertrag mit — als „intro" und „credits", die
Wörter, die die Apps von Jellyfin her ohnehin kennen. In der App zeichnet
sie der vorhandene Überspringen-Knopf, der bisher nie etwas zu tun
hatte; im Web ist er neu, rechtsbündig über der Zeitleiste.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 21:28:36 +02:00
ScarriffleandClaude Opus 5 acba683c94 Eine Folge weiter, eine zurück — ohne den Spieler zu verlassen 
Wer eine Serie schaut, will blättern können. Bisher gab es genau einen
Knopf dafür, und der erschien erst am Ende: „Nächste Folge", wenn der
Abspann durchgelaufen war. Zurück ging gar nicht — nur über die
Serienseite, und die beendet die Wiedergabe.

Jetzt stehen beide Knöpfe in der Bedienleiste, in der App wie im Web,
links und rechts vom Abspielknopf. Nur bei Serien: bei einem Film
antwortet der Server mit 404, bei der letzten Folge mit 204, und beides
heisst hier „kein Knopf". Sie erscheinen also von selbst nur dort, wo
sie etwas tun.

Der Server kannte nur den Weg vorwärts. Jetzt gibt es `/previous`
daneben, und beide Richtungen kommen aus derselben Rechnung — als zwei
Endpunkte abgeschrieben liefen sie auseinander, sobald einer etwas
dazubekommt. Jellyfin hat kein Gegenstück zu „NextUp"; dort entsteht
die vorige Folge aus der Folgenliste der Serie.

Beim Wechsel gilt weiter, was für die Serie an Sprache eingestellt ist.
Ohne das spränge die nächste Folge auf die erste Tonspur der Datei
zurück — bei deutschen Veröffentlichungen also auf Deutsch, mitten in
einer Serie, die man im Original schaut.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 21:11:09 +02:00
ScarriffleandClaude Opus 5 bcbe5557d7 Der Kern des Vorspann-Abgleichs — ohne Anschluss, aber geprüft 
Ein Vorspann ist das, was in jeder Folge einer Staffel gleich klingt.
Sonst ist an einer Folge nichts, woran er sich erkennen liesse: er sieht
aus wie Handlung und klingt wie Handlung, er wiederholt sich nur.

`Tonabgleich` sucht das längste Stück, das zwei Abdruckreihen teilen —
reine Rechnung, ohne Datei und ohne ffmpeg, deshalb mit sieben Prüfungen
belegt. Darunter die wichtigere Richtung: zwei Folgen ohne Gemeinsamkeit
ergeben nichts. Ein nicht gefundener Vorspann kostet einen Knopf, ein
erfundener schneidet dem Zuschauer eine halbe Minute Handlung weg.

Die Abdrücke holt `fpcalc` aus Chromaprint, nicht selbstgeschriebene
Signalverarbeitung. Dasselbe tut Jellyfins Intro Skipper, aus demselben
Grund. Das Programk liegt ab jetzt im Abbild; fehlt es, gibt es eben
keine Marken — sie sind eine Zugabe, kein Teil der Wiedergabe.

Noch ruft das niemand auf. Tabelle, Lauf und Knöpfe kommen als Nächstes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 20:56:37 +02:00
ScarriffleandClaude Opus 5 bfe263d495 Vierundzwanzig Bilder, und der Weg dorthin fehlte sowieso 
Zwei Dinge, die zusammengehören.

**Den Bilderdialog gab es nur an der Kachel.** Wer auf der Seite eines
Films stand und sah, dass das Plakat falsch ist, stand genau dort, wo er
nichts dagegen tun konnte — der Weg führte zurück in die Liste und über
das Dreipunktmenü. Jetzt steht „Bearbeiten" in der Knopfreihe der
Detailseite, bei Filmen wie bei Serien, und nur im Kopf: dieselbe Reihe
steht auch über jeder Fassung und jeder Folge.

**Und es waren vierundzwanzig, weil dort vierundzwanzig stand.** Bei
„365 Tage" hat TMDB neunundsechzig Plakate. Dazu ein zweiter, leiserer
Filter: gefragt wurden nur drei Sprachen. Fürs automatische Holen ist
das richtig — dort wird eines genommen, und es soll passen. Wer von Hand
wählt, will sehen, was es gibt; sortiert wird ohnehin nach Sprache, also
steht das Passende weiterhin oben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 20:49:37 +02:00
ScarriffleandClaude Opus 5 78e347c58d Zwei Zeilen Untertitel, die zweite halb unter dem Bildrand 
Gemessen am Bildschirmfoto: zwischen den Zeilen lagen 71 Pixel bei 18
Pixel Texthöhe — fast das Vierfache dessen, was `line-height: 1.25`
ergibt. Und die zweite Zeile war mitten im Buchstaben abgeschnitten.

Beides derselbe Grund. Der bisherige Weg ging über die Norm:
`lineAlign = "end"` macht `line: 90` zur **Unter**kante, und dann steht
auch ein zweizeiliger Untertitel vollständig über dem Rand. Chrome und
Firefox halten sich daran — nachgestellt und abgelichtet. WebKit nicht:
dort ist es die Oberkante, der Kasten wächst nach unten aus dem Bild,
und `line-height` aus `::cue` bleibt ebenfalls wirkungslos.

Jetzt wird dort gar nichts mehr an den Einblendungen verstellt.
Stattdessen rückt der Kasten ab, in den der Browser sie setzt — ein
Element, das WebKit selbst erfunden hat und das es dort also gibt. Eine
Verschiebung des ganzen Kastens kann nichts abschneiden, egal wie viele
Zeilen eine Einblendung hat.

Wer den Kasten nicht kennt — Firefox —, bekommt weiter den Weg über die
Norm. Erkannt wird das daran, ob die Regel im Stilblatt stehen bleibt,
nicht an der Browserkennung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 20:42:16 +02:00
ScarriffleandClaude Opus 5 5a0f2bf07f Eine Prüfung dafür, dass eine Datei auch ein Bild sein darf 
Der Lader gab bei jeder `file:`-Adresse `nil` zurück, und nichts hätte
das gemeldet. Drei Zeilen Prüfung: ein PNG auf der Platte kommt an, eine
fehlende Datei nicht, und Text ist kein Bild.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 20:28:14 +02:00
ScarriffleandClaude Opus 5 79d7d04583 Ein Download sah aus wie eine Videodatei, nicht wie ein Film 
Vier Dinge, die beim Ausprobieren auffielen.

**Die Plakate blieben grau.** Sie lagen auf der Platte, der Lader wollte
sie aber nicht: er verlangte von jeder Antwort eine HTTPURLResponse, und
eine Datei antwortet nicht so. Jede lokale Adresse kam als `nil` zurück.

**Eine Serie hatte ohnehin nie ein Plakat.** Heruntergeladen wird nie die
Serie, nur ihre Folgen — und deren Bild ist das Szenenbild, quer. Jetzt
kommt das Serienplakat unter dem Serienschlüssel mit und geht mit der
letzten Folge wieder.

**Zwanzig Folgen waren zwanzig Kacheln.** Jetzt steht die Serie einmal
da, darunter wie viele Folgen bereitliegen; welche genau, zeigt ihre
Seite — auch ohne Server, dann aus dem, was auf dem Gerät liegt.

**Das Bild wurde schwarz, sobald jemand auf „Bildfüllend" wechselte.**
Daran war ein eigener ViewModifier schuld, der zwischen
`ignoresSafeArea()` und gar nichts umschaltete. Genau das ist in SwiftUI
ein Zweig: der Baum darunter wurde neu gebaut, die Bildebene mit ihm.
`edges: []` ignoriert nichts und bleibt doch derselbe Modifikator.

Dazu „Als Nächstes": die Reihe begann am Anfang der Serie statt dort, wo
der Benutzer steht. Wer bei Folge 2 war und Folge 1 nie abgehakt hatte,
bekam Folge 1 vorgeschlagen — und das Abhaken half nicht, weil die
Kachel sich nur selbst einen Haken malte, statt zu verschwinden.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 20:20:27 +02:00
ScarriffleandClaude Opus 5 8f0568cb6c Ohne Server stand man vor der Tür, mit dem Film in der Tasche 
Fiel der Server aus, endete der Start bei einem Fehlerbildschirm mit
zwei Knöpfen: „Erneut versuchen" und „Abmelden". Beide nützen im
Flugzeug nichts — und dahinter lagen die Dateien, die man genau für
diesen Fall heruntergeladen hatte.

Jetzt geht die App trotzdem auf: Token und Konto liegen auf dem Gerät,
die Mediathekenliste auch, und die Startseite kommt neuerdings aus
demselben Speicher. Oben die Downloads, darunter der Stand vom letzten
Mal, ausgegraut, mit einem Satz, der sagt warum. Die Detailseite nimmt
den Titel vom Gerät, wenn der Server schweigt, und der Abspielknopf
bleibt an, weil die Datei ja da ist.

Und was man offline geschaut hat, zählt: Fortschritt, den der Server
nicht annimmt, wird zurückgelegt und nachgereicht, sobald er wieder
antwortet. Dafür sagt `reportProgress` jetzt, ob die Meldung ankam.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 19:41:22 +02:00
ScarriffleandClaude Opus 5 77593105de Heruntergeladenes lag auf dem Gerät und war nirgends zu sehen 
Downloads gab es nur im Downloads-Bereich. Wer wissen wollte, was im
Flugzeug läuft, musste zwei Listen vergleichen: die Mediathek und die
Downloads.

Jetzt sind sie eine Reihe auf der Startseite, tragen in jeder Kachel
eine Marke, und in der Mediathek gibt es „Nur Heruntergeladene" — der
Filter fragt den Server gar nicht erst, weil der nicht weiss, was auf
diesem Gerät liegt.

Dabei kam heraus, dass Downloads nie ein Bild mitbrachten: der
Dateiname dafür stand im Modell, gesetzt hat ihn niemand. Neue holen es
mit, alten wird es beim nächsten Start nachgereicht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 19:28:45 +02:00
ScarriffleandClaude Opus 5 fb8ad1c831 Der Stand lag daneben und wurde trotzdem weggeworfen 
Der Fortschrittsbalken ist an **einer** Stelle gebaut und wird in jeder
Kachel verwendet — Web wie App. Fehlte er, dann nicht an der Kachel,
sondern weil der Server `State: null` schickte. Drei Listen taten das,
obwohl die Stände in derselben Abfrage danebenlagen:

  /home/suggestions  — „Weil du Ähnliches gesehen hast"
  /home/seasonal     — die saisonale Reihe
  /movies/{id}/similar — „Ähnliche Titel"

Ausgerechnet die erste entsteht aus dem Sehverhalten: ein halb gesehener
Film sah dort aus wie ein unangetasteter, während dieselbe Kachel in der
Mediathek einen Balken trug. `ZuständeZu` gab es längst, es war nur
privat.

**Und „Als Nächstes" lässt sich jetzt räumen.** Das vorhandene Weglegen
reichte nicht dorthin: die Reihe liest `Watched` und `InProgress`, nie
`Dismissed` — und bei einer nie gestarteten Folge ist `InProgress` ohnehin
`false`. Weggelegt wird deshalb die **Serie**, nicht die Folge: beim
nächsten Laden rückte sonst die übernächste nach, und man legte
zwanzigmal weg. Den Zustand dafür gibt es schon, er wurde nur nie
gelesen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 19:13:09 +02:00
ScarriffleandClaude Opus 5 fa8d1a97e2 Vom Aufmacher war vor allem Grau zu sehen 
Zwei Beschwerden, zwei Ursachen.

**„Niedrig" war nicht niedrig.** Mit 62 vh war es mittel mit anderem
Namen; die Spanne reichte nur nach oben, weil die fünfte Stufe damals
oben gebraucht wurde. Darunter steht jetzt „Flach" mit 46 vh — für den,
der den Aufmacher als Kopfzeile will und nicht als halbe Seite.

**Der Verlauf fing auf halber Höhe schon mit 55 % Deckung an** und wurde
erst bei 85 % durchsichtig. Von einem starken Bild blieb dadurch vor
allem Grau übrig. Jetzt kurz und steil: unten dunkel genug, dass die
Schrift trägt, und die obere Hälfte frei. Der Text sitzt unten links —
genau dort muss es tragen, und darüber nicht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-12 19:03:45 +02:00
ScarriffleandClaude Opus 5 0a394b9b3b „Wartet" für immer, obwohl der Server längst fertig war 
Der Eintrag ging nach einer 202 zurück auf „wartet" und rief danach
`resume`. Das nimmt aber nur auf, was **angehalten oder gescheitert**
ist — ein wartender lief in die Schutzklausel und kam nie wieder heraus.
Im Protokoll packte ffmpeg um, in der App stand „wartet", und dazwischen
lag nichts.

Jetzt wird die Warteschlange abgearbeitet statt ein einzelner Eintrag
aufgenommen; „wartet" steht darin.

Dazu zwei Dinge, um die du gebeten hast:

**Das Protokoll liest sich wie eine Kommandozeile.** Älteste Zeile oben,
neueste unten, die Ansicht steht am Ende. Mitgeschoben wird nur, wenn man
unten steht — wer hochgescrollt hat, liest etwas, und ihn bei jeder neuen
Zeile ans Ende zu reissen wäre, als nähme man ihm die Seite aus der Hand.

**Ein Tipp auf eine Kachel führt auf die Detailseite**, am Telefon wie am
iPad wie am Mac. Nur in „Weiterschauen" spielt er ab: dort steht der
Titel, *weil* man ihn angefangen hat. Vorher war es umgekehrt, mit dem
Argument „wer eine Kachel antippt, weiss schon, was er sehen will". Im
Gebrauch stimmte das nicht — wer nachsehen wollte, wie viele Staffeln
eine Serie hat, bekam den Film. Ein Umweg von einem Schritt ist
ärgerlich; eine Wiedergabe, die man nicht wollte, ist schlimmer.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-11 20:56:39 +02:00
ScarriffleandClaude Opus 5 ce5dc66047 Eine 500, die der Benutzer sieht und das Protokoll nicht 
Im Spieler stand „der Server hat den Download mit Fehler 500 abgelehnt",
und im Tagesprotokoll war davon nichts zu finden. Der Haken, der
Ausnahmen aufschreibt, fängt nur Ausnahmen; ein Endpunkt, der von sich
aus `Results.Problem(… 500)` zurückgibt, läuft daran vorbei.

Jetzt wird jede Antwort ab 500 vermerkt, mit Verfahren, Weg und Abfrage —
egal woher sie kommt. Dieselbe Lehre wie beim ffmpeg-Fehler: eine
Fehlermeldung, die nur der Benutzer sieht, ist eine Sackgasse.

Dazu, weil es beim Suchen im Weg stand: „Hole Metadaten zu Phineas und
Ferb 4×23 — 1334 von 1347" steht nicht mehr im Protokoll. Ein Auffrischen
schrieb vierzehnhundert solche Zeilen und schob alles andere aus der
Ansicht. Das ist Fortschritt, keine Auskunft; er gehört in die
Fortschrittszeile, wo er auch steht. Was bleibt, sind die Vermerke — sie
erklären, warum etwas so zugeordnet wurde — und die Zusammenfassung am
Ende.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-11 20:41:47 +02:00
ScarriffleandClaude Opus 5 a44d55e71c 163 Byte als Film verbucht, in einer Sekunde heruntergeladen 
Muss der Server eine Datei umpacken, antwortet er mit **202** und einem
kurzen Text: noch nicht, komm wieder. Die Prüfung im Download verwarf
alles ausserhalb von 200 bis 299 — und 202 liegt mittendrin. Der
Antworttext lag danach als Film auf dem Gerät.

Jetzt ist 202 ein eigener Fall: der Eintrag geht zurück in die
Warteschlange und fragt alle fünfzehn Sekunden erneut, bis zu fünf
Minuten lang. Es ist nichts schiefgegangen, es ist nur noch nicht fertig
— und im Sekundentakt nachzufragen hiesse, dieselbe Datei hundertmal
anzufangen und wegzuwerfen.

Gezählt wird im Arbeitsspeicher, nicht im Eintrag: nach einem Neustart
beginnt das Zählen von vorn, und das ist richtig — der Server hat
inzwischen vermutlich fertig gepackt.

Dazu, aus derselben Meldung: bei 21∶9 auf einem Telefon reichte das Bild
hinter die Dynamic Island. Im Vollbild bleibt das so — wer es wählt, hat
sich fürs Beschneiden entschieden. Im normalen Modus nicht mehr: dort ist
der Anspruch gerade, dass nichts fehlt, und dann darf auch nichts
verdeckt sein.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-11 20:33:32 +02:00
ScarriffleandClaude Opus 5 c05004f586 Untertitel kamen an, der Ton nicht — sie sahen woanders nach 
Die Vorwahl auf der Filmseite legt beides unter der Kennung des Films ab.
Beim Untertitel habe ich das beim Lesen berücksichtigt, beim Ton nicht:
dort stand `item.seriesID`, und die ist bei einem Film nichts. Die
Einstellung wurde gespeichert und nie wieder gelesen.

Jetzt gibt es eine Stelle, die sagt, wo die Vorwahl eines Titels liegt:
bei einer Folge die Serie, bei einem Film er selbst. Beides ist dieselbe
Frage auf der Ebene, die der Benutzer vor sich hatte, als er sie
beantwortet hat.

Dasselbe betraf das Merken einer von Hand gewählten Spur und die Anzeige
im Spurenblatt: bei einem Film merkte sich der Spieler nichts, weil die
Kennung fehlte. Jetzt lesen alle vier Stellen dieselbe.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-11 13:58:44 +02:00
ScarriffleandClaude Opus 5 94458ef41c Fünf Knöpfe in einer Reihe wurden auf dem Telefon zu Säulen 
In einem `HStack` teilen sich die Knöpfe die Breite. Abspielen, Von vorn,
Herunterladen und zwei Sprachknöpfe passten auf einem Telefon nicht
nebeneinander — heraus kamen Säulen aus einzelnen Buchstaben, senkrecht
untereinander. Lesbar war nichts mehr; angetippt hätte man trotzdem das
Richtige.

`Flusszeile` bricht um, statt zu quetschen: was nicht mehr hinpasst,
kommt in die nächste Zeile. Zwei Zeilen sind kein Mangel, sie sind, was
dort hinpasst — und ein Knopf, der auf schmalen Geräten verschwindet,
wäre eine zweite Oberfläche, die gepflegt werden will.

Kein `ViewThatFits`: das wählt zwischen fertigen Entwürfen, und die
müsste man für jede Zahl von Knöpfen von Hand hinschreiben. Hier wird
gerechnet.

Dazu bleibt die Beschriftung eines Sprachknopfs einzeilig. Umbrochen wird
die Reihe, nicht das Wort darin.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 23:20:57 +02:00
ScarriffleandClaude Opus 5 f85891aba4 Die Sprachwahl gehört neben den Knopf, der sie anwendet 
Auf der Filmseite standen „Tonsprache für diesen Titel" und „Untertitel
für diesen Titel" als zwei breite Zeilen unter der Beschreibung — weit
weg von „Abspielen", und mit so viel Platz dazwischen, dass sie wie eine
Einstellung aussahen und nicht wie eine Wahl für diesen Film.

Jetzt stehen sie als „Ton: Deutsch" und „Untertitel: Keine" in der Reihe
mit Abspielen, Von vorn und Herunterladen.

Der Auswahlknopf hat dafür eine zweite Form bekommen statt eines zweiten
Typs: neben „Abspielen" ist kein Platz für eine Zeile mit Spalten, und
Beschriftung plus Wert in einem sagt dasselbe in einem Wort mehr. Auf der
Serienseite bleibt es bei der Zeile — dort stehen sie in einer Liste.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 22:16:12 +02:00
ScarriffleandClaude Opus 5 84612335ec Sprachwahl in der App — bei Serien und bei Filmen 
Auf der Serienseite stand ein Menü für den Ton, gefüllt mit zwanzig
Sprachen, von denen die Serie zwei hatte. Für Untertitel gab es keines,
und auf der Filmseite überhaupt nichts.

Jetzt beides an beiden Orten, und zwar nur mit dem, was es wirklich gibt:

Bei einer **Serie** über den neuen Endpunkt — die Schnittmenge über alle
Folgen. Was dadurch wegfällt, steht als Satz darunter, sonst sähe eine
gekürzte Liste aus wie die ganze Wahrheit.

Bei einem **Film** aus den Spuren der Datei. Kein Serverweg nötig: dort
ist die Datei der Titel, und ihre Spuren stehen in der Antwort, die die
Seite ohnehin geholt hat.

Ton und Untertitel teilen sich einen Typ. Sie unterscheiden sich in genau
zwei Punkten — woher der Wert kommt und ob es „Keine" gibt; ein zweiter
Typ wäre dieselbe Datei mit zwei geänderten Zeilen. „Keine" gibt es nur
beim Untertitel: ein Film ohne Tonspur ist kein Wunsch, sondern ein
Fehler.

Die Untertitelsprache liegt je Titel, in einem Topf für Serien und Filme
— eine Filmkennung kollidiert mit keiner Serie, und zwei Wörterbücher für
dieselbe Frage liefen auseinander. Der Spieler liest sie jetzt: vorher
kannte er nur die allgemeine, und eine Serie im Original mit deutschen
Untertiteln liess sich nicht einstellen, ohne sie überall einzuschalten.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:56:15 +02:00
ScarriffleandClaude Opus 5 95d7eee8c3 Die Staffelwahl klebte am Untertitelknopf 
Die Sprachwahl einer Serie steht zwischen dem Kopf und den Staffeln und
hatte als einziger Abschnitt dort keinen Abstand nach unten. Jetzt
denselben wie jeder andere.

Dazu: der Hinweissatz darunter verschwindet, wenn er leer ist. Ein leeres
Feld nimmt sonst Platz für einen Satz, den es nicht gibt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:45:33 +02:00
ScarriffleandClaude Opus 5 fc36bb7ddb Eine Serie, eine Sprachwahl — nicht zwanzig 
Auf der Serienseite im Web stand bei jeder einzelnen Folge ein Knopf für
Ton und einer für Untertitel. Zwanzig Folgen hiessen zwanzigmal dieselbe
Frage, und am Ende wusste niemand, welche Antwort gilt. „Dieser Anime
läuft auf Japanisch mit deutschen Untertiteln" ist eine Aussage über die
Serie, nicht über Folge 7.

Die Wahl steht jetzt einmal oben bei den Angaben zur Serie und an den
Folgen gar nicht mehr. Beim Film bleibt sie, wo sie war — dort ist die
Datei der Titel.

Angeboten werden nur Sprachen, die in **jeder** Folge vorkommen; was
dadurch wegfällt, steht als Satz darunter. Gemerkt wird die Sprache, nicht
die Spurnummer: die unterscheidet sich von Folge zu Folge, und beim Start
wird sie für diese Datei nachgeschlagen.

Dazu die Staffeln. Sie standen alle untereinander — nach Folge 8 kam
wieder eine Folge 1, und wer zur dritten Staffel wollte, scrollte an
zwanzig Folgen vorbei. Die Überschrift ist jetzt das Menü. Bei einer
einzigen Staffel bleibt es bei der Überschrift: ein Menü, das nur sich
selbst anbietet, ist keine Wahl.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:43:17 +02:00
ScarriffleandClaude Opus 5 22be288fc3 Welche Sprachen eine Serie durchgehend führt 
Das Menü auf der Serienseite bot zwanzig Sprachen an, von denen die Serie
zwei hatte. Um das zu ändern, muss jemand wissen, welche es wirklich
gibt — und zwar in einer Abfrage: zwanzig Folgen einzeln zu holen wären
zwanzig Rundreisen, und am Ende müsste der Client dieselbe Rechnung
anstellen.

`GET /api/v1/series/{id}/languages` nennt Ton- und Textsprachen als
**Schnittmenge** über alle Folgen. Eine Sprache anzubieten, die es nur in
Staffel 1 gibt, hiesse: eine Einstellung für die Serie, die ab Staffel 2
stillschweigend etwas anderes tut. Was dabei wegfällt, wird gezählt —
damit die Oberfläche es sagen kann, statt es zu verschweigen.

Zwei Dinge, die sonst falsche Ergebnisse gäben:

Gruppiert wird nach dem **Namen**, nicht nach dem Kürzel. Eine gewachsene
Sammlung trägt „ger" und „deu" nebeneinander; nach dem Kürzel gezählt
fiele Deutsch aus der Schnittmenge, obwohl es überall liegt.

Gezählt werden nur Folgen, die eine **Datei** haben. Eine angekündigte
Folge kann keine Sprache beisteuern; sie als fehlend zu zählen liesse das
Menü bei jeder laufenden Serie leer.

Die Rechnung steht in `Flaro.Core`, nicht im Endpunkt: sie hängt an keiner
Datenbank und lässt sich so prüfen, ohne eine Serie anzulegen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:38:19 +02:00
ScarriffleandClaude Opus 5 2c51f639be Untertitel vorher wählen, wie den Ton auch 
Auf der Detailseite stand „Ton: Deutsch" und liess sich vor dem Start
umstellen — aus gutem Grund: im Spieler umzuschalten heisst, den Strom
neu aufzubauen. Für Untertitel gab es das nicht, obwohl dort dieselbe
Überlegung gilt und die Spuren ohnehin schon dastehen.

Jetzt steht „Untertitel: Keine" daneben. Auch bei nur einer Spur: anders
als beim Ton gibt es hier immer mindestens zwei Möglichkeiten — diese
eine, oder gar keine.

Der Wunsch wird gemerkt wie beim Ton, mit einem dritten Zustand. „Keine"
ist eine Antwort und kein Fehlen einer: wer sie abgewählt hat, will sie
beim nächsten Film auch nicht, während „nie etwas gesagt" offen lässt,
ob eine erzwungene Spur erscheinen darf.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:33:35 +02:00
ScarriffleandClaude Opus 5 ab43656f71 Nach Folge 8 kam wieder Folge 1, und nichts sagte warum 
Der Server liefert die Folgen einer Serie am Stück. Auf der Seite stand
unter „Staffeln" eine durchgehende Liste, in der nach der achten Folge
wieder eine erste kam — die der zweiten Staffel, aber das stand nirgends.

Jetzt wählt ein Menü die Staffel, dort wo vorher nur „Folgen" stand. Bei
einer einzigen Staffel bleibt es beim Wort: ein Menü mit einem Eintrag
ist keine Wahl.

Kein `Picker`: diese Seite ist eine `ScrollView`, kein `Form`, und dort
hat ein `Picker` kein Aussehen, auf das man sich verlassen kann —
dieselbe Begründung wie beim Sprachmenü darüber.

„Alle auswählen" meint jetzt die gezeigte Staffel. Vorher hätte ein Griff
sechzehn Folgen heruntergeladen statt acht. Beim Wechsel der Staffel
fällt eine bestehende Auswahl weg: stehen zu lassen, was man nicht mehr
sieht, lädt unsichtbare Folgen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:27:58 +02:00
ScarriffleandClaude Opus 5 fa31adf3d1 Deutsch gewählt, Englisch gesehen 
„Die erste ist die richtige" stand hier, und es stimmte — solange der
Server genau eine Textspur auslieferte, nämlich die bestellte. Seit die
Wiedergabe über einen Strom läuft, stehen alle Spuren in der
Abspielliste, und dann ist die erste schlicht die erste.

Gesucht wird jetzt die Spur, die zur Bestellung passt: erst über das
Sprachkürzel — `ger`, `deu` und `de` meinen dasselbe, dafür gibt es
`LanguageCode` längst —, bei gleicher Sprache über das Merkmal
„erzwungen", und zuletzt über den Namen. Findet sich keine, bleibt es bei
der ersten: bei einem umgerechneten Strom gibt es nur sie, und gar kein
Untertitel wäre schlechter als der eine.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:13:52 +02:00
ScarriffleandClaude Opus 5 5657cd9e4b Der Sprung ging ins Leere, und die Prüfung dagegen griff nie 
Nach vorn ziehen, Regler springt zurück. Im Pausieren nicht — dort wuchs
die Abspielliste weiter und holte die Stelle irgendwann ein.

Der Spieler sollte einen Sprung ausserhalb des Stroms daran erkennen,
dass er hinter dessen Ende liegt. Das Ende stand in `streamEnd`, und das
wird gesetzt, wenn der Player eine Dauer meldet — was er bei einer
wachsenden Liste nie tut. `streamEnd` blieb also nichts, jeder Sprung
galt als innerhalb, AVPlayer bekam ein Ziel ohne Schnipsel und verwarf
es.

Gefragt wird jetzt der Vorrat: so weit, wie Daten da sind, springt der
Spieler selbst; darüber hinaus wird der Strom neu gebaut. Weiss niemand,
wie weit es reicht, wird ebenfalls neu gebaut — ein neuer Strom dauert
ein paar Sekunden, ein Sprung, der nichts tut, ist kaputt.

Entschieden wird vor dem Aufräumen: `seek` verwirft den Vorrat, und
genau an dem hängt die Antwort.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 21:01:35 +02:00
ScarriffleandClaude Opus 5 064f8f61af Eine wachsende Abspielliste hat keine Länge, also kam nie eine 
Mein letzter Versuch griff an der falschen Stelle: er verbesserte, was
`durationResolved` einträgt — nur kommt dieses Ereignis bei einem Strom
aus Flaro gar nicht. Die Abspielliste wächst und trägt kein
`EXT-X-ENDLIST`; für AVPlayer ist die Dauer damit unbestimmt.

`duration` blieb also auf nichts, und die Ansicht rechnet dann mit einer
Sekunde (`model.duration ?? .seconds(1)`). Darum stand der Regler bei
1:50:07 am Anschlag, egal was noch kam.

Jetzt wird die Länge gesetzt, sobald der Strom steht — aus der Datei, die
der Spieler ohnehin in der Hand hat. Auf den Player zu warten hiesse, auf
etwas zu warten, das er nicht wissen kann.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:50:44 +02:00
ScarriffleandClaude Opus 5 693a6cc867 Cookie heisst Cookie 
„Keks", „Keksglas", „Kekse" — eingedeutscht, wo es nichts zu
verdeutschen gibt. Ein Cookie ist ein Cookie; wer danach sucht, sucht
nicht nach Keksen, und wer den Quelltext liest, liest daneben die
Schnittstelle, in der es `HTTPCookieStorage` heisst.

Betrifft Kommentare und Prüfungsnamen, kein Verhalten.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:42:29 +02:00
ScarriffleandClaude Opus 5 f789c40594 Der Vorrat holte unangemeldet, und das stand im Protokoll 
20:32:40  Umpacken … Vorbereitung 3203 ms
    20:32:40  FlaroToken was challenged
    20:32:52  Umkodieren … 0 ms
    20:32:55  erstes Stück nach 2750 ms

Einmal je Wiedergabe eine abgewiesene Anfrage, gefolgt von zwölf
Sekunden Stille und einer zweiten Bestellung. Die zwölf Sekunden sind
AVPlayer, der auf etwas wartet, das nie kommt.

Der Vorrat, der dem Spieler die Schnipsel voraushält, benutzt eine
flüchtige URLSession — und die bringt ihren eigenen, leeren Keksspeicher
mit. Jede Anfrage von dort ging unangemeldet hinaus. Bei Jellyfin fiel
das nie auf, weil der Schlüssel dort in der Adresse steht; Flaro meldet
über ein Keks an. Und bisher kam der Vorrat bei Flaro nie zum Zug: er
springt nur bei einer Abspielliste an, und die App hat bis gestern eine
fertige Datei abgespielt.

Dass die zweite Bestellung lief, passt dazu: nach dem Fehlschlag gibt der
Vorrat auf, und der Spieler holt unmittelbar vom Server — mit dem Keks,
den er selbst hat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:35:37 +02:00
ScarriffleandClaude Opus 5 347ddfea01 Das Protokoll kannte nur, was jemand ausdrücklich hineinschrieb 
Start, Ende, ein paar Fehler — mehr stand nie drin. Dabei meldet der
Server längst, was er tut: „Scan gestartet", „Strom angelegt",
„Untertitel aus … gezogen", „Bibliothek ohne Treffer". Das ging alles an
`ILogger` und damit in die Container-Ausgabe, wo es zwischen den
EF-Abfragen untergeht.

Eine Senke hängt das Tagebuch jetzt an die Protokollkette. Nur Flaros
eigene Kategorien — `Microsoft.*` käme mit einer Zeile je Datenbank-
abfrage und machte das Protokoll nach einem Scan unlesbar. Debug und
Trace bleiben draussen, die sind fürs Entwickeln.

Damit fallen die beiden Stellen weg, an denen ich gestern von Hand ins
Tagebuch geschrieben habe; sie kommen jetzt über denselben Weg wie alles
andere. Der Name der Quelle steht davor: „Streamkoordinator: …".

Nebenbei: das Tagebuch wird von Hand gebaut statt aus dem Behälter
geholt. Die Senke braucht es, bevor der Behälter steht, und ein
`BuildServiceProvider()` dafür legte eine zweite Ausgabe an — zwei
Tagebücher mit zwei Schlössern, die sich beim Schreiben ins Gehege
kommen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:30:23 +02:00
ScarriffleandClaude Opus 5 19ec17da19 Zwölf Sekunden für eine Hülle um nichts 
Die Messung sagt es deutlich:

    20:15:53  Umpacken    — Schlüsselbildsuche 2348 ms, Vorbereitung 2394 ms.
    20:16:05  Umkodieren  — Schlüsselbildsuche 0 ms, Vorbereitung 0 ms.
    20:16:08  erstes Stück nach 2750 ms.

Fünfzehn Sekunden, und zwölf davon liegen zwischen zwei Bestellungen für
denselben Film. Der erste Strom wurde angelegt und dann nie abgeholt —
keine Medienliste, kein Stück, kein ffmpeg-Fehler. Danach gab die App auf
und bestellte neu, diesmal mit Umkodieren, und das lief nach knapp drei
Sekunden.

Dazwischen lag die Hauptliste. Es gibt sie allein wegen der
Untertitelspuren, und bei diesem Film waren die noch gar nicht aus der
Datei gezogen — sie war also leer bis auf einen Verweis auf die
Medienliste. Eine Hülle um nichts, und keine umsonst: ohne `CODECS` muss
ein Spieler sie erst aufmachen, um zu sehen, was darin liegt.

Jetzt gibt es sie nur, wenn wenigstens eine Spur abholbar ist. Sonst
bekommt die App die Medienliste unmittelbar — denselben Weg wie der
Browser, der nie gestolpert ist.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:20:16 +02:00
ScarriffleandClaude Opus 5 a6b3217d6e Das Protokoll steht jetzt da, statt sich holen zu lassen 
Vorher: eine Liste von Tagen, je Tag drei Knöpfe, und erst nach „Ansehen"
stand irgendwo Text. Wer wissen wollte, was gerade schiefgeht, brauchte
drei Handgriffe für eine Antwort, die auf der ersten Seite hätte stehen
können.

Jetzt ist „Protokolle" eine Liste von Ereignissen, wie man sie aus Home
Assistant kennt: der heutige Tag sofort und offen, neueste Zeile oben —
damit man zum Mitlesen nicht scrollen muss —, und alle vier Sekunden
kommt dazu, was dazugekommen ist. Fehler und Warnungen tragen die Farbe
am Rand statt im Text; eine ganze Zeile in Rot liest sich schlechter als
eine in Grau mit rotem Strich.

Die früheren Tage stehen darunter als Kacheln zum Herunterladen. Der
heutige nicht: er steht schon oben, und eine zweite Tür zum selben Raum
ist keine Hilfe.

Mehrzeiliges — ffmpeg schreibt gern vier Zeilen — hat keinen eigenen
Zeitstempel und gehört zur Zeile darüber. Es wird eingerückt gezeigt
statt verworfen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:15:50 +02:00
ScarriffleandClaude Opus 5 4db2a17e64 „Es dauert fünfzehn Sekunden" liess sich nicht beantworten 
Zwischen dem Antippen und dem ersten Bild liegen drei Strecken: die
Schlüsselbildsuche, der Start von ffmpeg und das Warten auf das erste
Stück. Keine davon war irgendwo abzulesen — jede Erklärung wäre Raterei
gewesen.

Jetzt steht je Wiedergabe eine Zeile im Tagesprotokoll, mit den ersten
beiden Zeiten. Dauert das erste Stück länger als zwei Sekunden, kommt
eine zweite Zeile dazu. Eine Zeile je Wiedergabe ist kein Lärm; sie ist
genau das, wonach man im Protokoll sucht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:11:02 +02:00
ScarriffleandClaude Opus 5 855cfddf03 Der Regler stand am Ende, obwohl noch zwanzig Minuten kamen 
Als Filmlänge nahm der Spieler `item.duration` und fiel sonst auf die
Länge des Stroms zurück. Beides ging daneben: `item.duration` kommt aus
der Liste, und dort stehen keine Dateien — bei einem Titel, der aus einer
Reihe geöffnet wurde, ist es nichts. Übrig blieb die Länge des Stroms,
und eine wachsende Abspielliste ist am Anfang ein paar Sekunden lang.

Die Datei weiss es genau. Sie steht im Spieler ohnehin, weil er aus ihr
abspielt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 20:04:47 +02:00
ScarriffleandClaude Opus 5 b88e58d5eb Das Gerät war da, die VA-Anzeige dahinter nicht 
ffmpeg endete mit 234. No VA display found for device
    /dev/dri/renderD128. Device creation failed: -22.

Hier stand `File.Exists("/dev/dri/renderD128")`, und das war keine
Prüfung, sondern eine Vermutung. Auf dem NAS liegt das Gerät
durchgereicht da — eine VA-Anzeige steht nicht dahinter. ffmpeg bricht
dann schon an der globalen Option ab, vor dem ersten Bild, und für den
Zuschauer sieht das aus wie ein kaputter Server: HTTP 500 auf die
Abspielliste, „Die Wiedergabe wurde unterbrochen".

Jetzt wird ffmpeg einmal je Lauf wirklich gefragt: ein Bild aus dem
Nichts, nirgendwohin, mit Frist. Geht die Zeile vor dem ersten Bild nicht
durch, läuft es in Software weiter — langsamer, aber es läuft.
FLARO_HWACCEL=vaapi überspringt die Probe für den, der es ausdrücklich
verlangt.

Dazu, aus derselben Gegend: in der Hauptliste stehen nur Untertitelspuren,
die jetzt sofort abholbar sind. Sie werden beim ersten Bedarf aus der
Datei gezogen, und bei einem Dreistünder dauert das Minuten. Der Browser
verträgt das — er fragt die Spur einzeln an und wartet. AVPlayer bricht
daran die ganze Wiedergabe ab, nicht bloss den Untertitel. Das Füllen
läuft beim Anlegen der Sitzung schon an; beim nächsten Abspielen stehen
sie drin.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 19:59:49 +02:00
ScarriffleandClaude Opus 5 34ade18ed6 „Die Einzelheiten stehen im Protokoll von heute" — standen sie nicht 
Der Spieler verweist bei einer gescheiterten Wiedergabe aufs
Tagesprotokoll. Dort stand nichts: `ILogger` landet in den
Container-Ausgaben, und das Tagebuch ist eine eigene Datei, in die nur
Scan, Wartung und unbehandelte Ausnahmen schreiben. Der Hinweis war eine
Sackgasse — gemessen an einem Protokoll, das einen ganzen Tag Betrieb mit
vier Zeilen Start und Ende wiedergab, während eine Wiedergabe mit 500
abgebrochen war.

Jetzt geht der ffmpeg-Fehler auch dorthin.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 19:51:41 +02:00
ScarriffleandClaude Opus 5 6ef84b47cf Den Weg der App einmal ganz abgehen 
Die App schickt keine Codec-Listen; dann nimmt der Server Apples Profil.
Das führt zu einer anderen Entscheidung als beim Browser — dort wird
umgerechnet, hier umgepackt — und damit auf einen Weg, den keine Prüfung
abging. Jetzt schon: bestellen, Hauptliste, Medienliste, erstes Stück.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 17:01:50 +02:00
ScarriffleandClaude Opus 5 6e503d63de „noch 35:37" wird zu „−35:37" 
Das Wort stand da, weil die Zahl ganz rechts hinter den Menüs allein
nicht zu deuten war. Neben der verstrichenen Zeit tut das Minuszeichen
dasselbe mit einem Zeichen statt vier.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:41:41 +02:00
ScarriffleandClaude Opus 5 1bcf6f12e5 Die App wartete auf eine fertige Datei, statt zu streamen 
Gleichzeitig im Web und in der App auf Abspielen getippt: das Web lief,
die App lud dreissig Sekunden. Das war keine Ladezeit, sondern die Zeit,
die der Server braucht, um den ganzen Film einmal durchzuschreiben.

`preparePlayback` kannte nur `/files/{id}/download`. Muss die Datei
umgepackt werden, fragte es im Sekundentakt nach, bis die vollständige
MP4 auf der Platte lag — Grenze zehn Minuten. Der Endpunkt, den das Web
benutzt, ist am Server längst da; die App wusste nur nichts davon.

Jetzt zuerst `/files/{id}/stream`. Das erste Stück ist beim Umpacken in
deutlich unter einer Sekunde da. Der alte Weg bleibt als Rückfall: er ist
langsam, kommt aber ohne Sitzung aus, und eine späte Wiedergabe ist
besser als keine.

**Der Strom beginnt dort, wo man weiterschauen wollte**, und zählt
trotzdem ab null. Ohne das mitzurechnen stünde bei „Fortsetzen ab 1:32"
eine Null auf der Uhr — und genau die ginge als Fortschritt an den
Server. Also: die Zeit der Engine plus Vorlauf ist die Zeit des Films,
und der Spieler springt nicht noch einmal dorthin, wo der Server schon
steht.

**Ein Sprung aus dem Strom heraus baut ihn neu auf.** Die Abspielliste
wächst von der Einstiegsstelle vorwärts; davor und dahinter gibt es
nichts, und ein Sprung ins Leere liesse den Spieler mit einem Kreisel
stehen. Innerhalb des Erzeugten springt er weiterhin selbst — dafür eine
neue Sitzung zu starten hiesse, Sekunden zu warten, um fünf Sekunden
zurückzugehen.

**Und die Sitzung wird geschlossen.** `endPlayback` war eine leere
Methode; das passte, solange es keine Sitzung gab. Mit dem Strom läuft
sonst ein ffmpeg weiter und schreibt den Film zu Ende, während längst
niemand mehr zusieht.

Die Laufzeit kommt weiter aus den Metadaten und nicht aus der Engine:
eine wachsende Liste meldet anfangs ein paar Sekunden, und als Filmlänge
genommen stünde der Regler sofort am Ende.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:22:18 +02:00
ScarriffleandClaude Opus 5 4a5576f939 Eine Hauptliste, damit auch AVPlayer die Untertitel findet 
`index.m3u8` ist eine Medienliste: eine Reihe von Schnipseln, sonst
nichts. Dem Browser reicht das, weil er die Untertitel als eigene Spur
ans Videoelement gehängt bekommt. AVPlayer kann das nicht — dort gibt es
keinen Weg, einer laufenden Wiedergabe eine Textspur von aussen
beizulegen. Was er findet, findet er in der Abspielliste oder gar nicht.

Also eine Hauptliste: dieselbe Medienliste als Bildspur, daneben je eine
Textspur als eigene Liste mit genau einem Stück — unsere WebVTT-Datei
über den ganzen Rest des Films. Der Vorlauf der Sitzung hängt daran, denn
die Zeitstempel in der Datei zählen ab Dateianfang und der Strom ab null.

Für den Browser ändert sich nichts; er holt weiterhin `index.m3u8`. Eine
Direktwiedergabe bekommt keine Hauptliste: die Datei bringt ihre Spuren
selbst mit, und eine Liste darum herum wäre eine Hülle um nichts.

Vorarbeit für die App, die bisher auf eine fertig umgepackte MP4 wartet —
dreissig Sekunden, wo das Web nach einer anfängt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:17:47 +02:00
ScarriffleandClaude Opus 5 912969d829 Abspielen in die Mitte, die beiden Zeiten daneben 
Die verstrichene Zeit stand hinter dem Lautstärkeregler — „1:51:01"
direkt neben einem Schieber liest sich wie dessen Beschriftung — und die
verbleibende ganz rechts hinter den Menüs. Zwei Angaben über dieselbe
Sache, so weit auseinander wie möglich.

Jetzt stehen sie dort, wo man ohnehin hinsieht: links und rechts vom
Knopf, den man drückt.

Drei Spalten statt drei Flex-Kinder, denn die Mitte soll die Mitte des
Bildes sein und nicht die Mitte dessen, was links und rechts übrig
bleibt. Mit `space-between` wanderte der Knopf, sobald rechts ein Menü
dazukam oder links die Lautstärke wegfiel.

Schmal weicht, was man auch anders bekommt: die Lautstärke liegt am
Telefon auf einer Taste, und die verbleibende Zeit lässt sich an der
Leiste ablesen. Der Knopf in der Mitte weicht nicht — dort sucht ihn der
Daumen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:12:50 +02:00
ScarriffleandClaude Opus 5 3dba736def Zwei Angaben über dieselbe Sache, so weit auseinander wie möglich 
Die verstrichene Zeit stand hinter dem Lautstärkeregler, die verbleibende
ganz rechts hinter den Menüs. „1:48:20" direkt neben einem Schieber für
Lautstärke liest sich wie dessen Beschriftung — und die zweite Zahl, die
dazugehört, war einen halben Bildschirm entfernt.

Beide stehen jetzt links und rechts von dem Balken, über den sie Auskunft
geben. Schmal weicht die verbleibende Zeit; dort ist der Balken wichtiger
als die zweite Zahl.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:09:57 +02:00
ScarriffleandClaude Opus 5 dbd66592a6 Untertitel klebten am Bildrand, und ihr Zeilenabstand blieb gross 
Zwei Fehler, die sich gegenseitig verstärkt haben.

**Der Zeilenabstand kam nicht mit.** `::cue { font-size }` ändert die
Schrift, nicht die Zeilenhöhe — die rechnet der Browser weiter aus seiner
eigenen Grösse. Bei 50 Prozent stand deshalb winziger Text mit dem
Abstand von grossem darunter; zwischen zwei Zeilen klaffte eine dritte.
`line-height` als Vielfaches der eigenen Grösse hält das Verhältnis.

**Und sie sassen ganz unten.** Ohne Angabe setzt der Browser jede
Einblendung an den unteren Rand des Videos. Dort liegt bei uns die
Bedienleiste — bei zwei Zeilen verschwand die untere darunter. Die
Unterkante sitzt jetzt bei neunzig Prozent der Videohöhe.

Gestellt wird das am `VTTCue`, nicht über CSS: `::cue` gestaltet den
Text, aber nicht seinen Platz. `lineAlign: "end"` ist dabei der Punkt —
damit meint `line` die Unterkante. Ohne ihn stünde ein zweizeiliger
Untertitel wieder tiefer als ein einzeiliger, also genau der Fall, um den
es ging.

Eine Einblendung, die ihre Stelle selbst mitbringt, behält sie:
Schilder und Aufschriften stehen dort, wo sie im Bild stehen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 14:08:07 +02:00
ScarriffleandClaude Opus 5 c5ab200846 Die Startseite holte ihre Reihen im Gänsemarsch 
Die Weboberfläche holt alles, was auf der Startseite steht, in einem
einzigen `Promise.all` — und sie holt sogar mehr davon: Vorschlag und
saisonale Reihe kennt die App gar nicht. Trotzdem war sie spürbar
langsamer. Der Grund stand in einer Schleife:

    for mediathek in mediatheken {
        ... await client.send(...)
    }

Ein `await` im Schleifenrumpf heisst: Rundreise, warten, nächste
Rundreise. Bei vier Mediatheken viermal hintereinander, nachdem
„Fortsetzen" und „Als Nächstes" längst da waren. Dieselbe Schleife stand
in beiden Hintergründen, für Flaro wie für Jellyfin.

Jetzt laufen sie nebeneinander, in einer `TaskGroup`. Die Reihenfolge der
Mediatheken bleibt erhalten — nach den Antworten zu ordnen hiesse, dass
die Reihen nach jedem Start woanders stünden. Ein Actor steht dem nicht
im Weg: jede Anfrage gibt ihn beim Warten frei, genau wie die beiden
`async let` darüber es schon tun.

Nebenbei: ein Fehler bei einer Mediathek nimmt die anderen nicht mehr
mit. Eine Startseite mit drei von vier Reihen ist besser als keine.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-10 13:55:24 +02:00
ScarriffleandClaude Opus 5 8397e042b8 Der Publikumswert steht auf der Seite, also wird er von dort gelesen 
OMDb führt im Feld `Ratings` nur eine Zahl je Dienst, und bei Rotten
Tomatoes ist das die der Kritik. Die erweiterten Felder gibt es, sie
stehen aber seit Jahren auf `N/A`; Jellyfin fragt sie an und liest sie
nicht einmal aus — deren Antwortklasse kennt `tomatoUserMeter` gar nicht.
Dort hat den Publikumswert also niemand.

Auf der Seite selbst steht er. Gemessen an `/m/the_matrix`: im Quelltext
liegt `"audienceScore":{… "score":"85" …}` neben `"criticsScore"`, dazu
ein `application/ld+json` mit Titel und Erscheinungsdatum; bei Serien
unter `/tv/…` dasselbe, und ein unbekannter Weg antwortet mit 404. Eine
Prüfung mit `[Explicit]` geht einmal wirklich hinaus und bestätigt es:
`rottenTomatoes 83%, rottenTomatoesAudience 85%`.

Das ist Auslesen einer fremden Webseite, und es hat seinen Preis. Eine
offene Suche gibt es nicht — `/napi/search` antwortet mit 401 —, also
wird der Weg aus dem Titel geraten und hinterher am Jahr geprüft: auf der
Seite steht keine IMDb-Kennung, und `/m/the_lion_king` ist der von 1994.
Weicht das Jahr um mehr als eines ab, wird verworfen; lieber keine Zahl
als die eines fremden Films. Der Originaltitel kommt zuerst dran, sonst
fände ein deutscher Bestand dort fast nichts. Ohne Jahr zuerst, weil der
Normalfall den blanken Namen trägt — mit Jahr zuerst kostete jeder Titel
eine Anfrage zu viel.

Deshalb ein Schalter, und der steht aus, bis jemand ihn umlegt. Dazu eine
Bremse: höchstens eine Anfrage je Sekunde, prozessweit. Achthundert Titel
in einem Schwall von einer Adresse wären eine Zumutung und würden
gesperrt. Der Scan dauert dadurch länger; das ist der Preis fürs
Mitbenutzen.

Die Probe unter Einstellungen → Metadaten fragt die Quelle mit, und dort
ist sie mehr als eine Höflichkeit: wird die Seite umgebaut, merkt man es
genau da und sonst nirgends.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-09 16:51:22 +02:00
ScarriffleandClaude Opus 5 e05bbfc2cd Einen einzelnen Titel neu holen, statt achthundert 
Eine neue Quelle wirkt erst beim nächsten Holen der Metadaten. Das ging
bisher nur je Mediathek: achthundert Titel, eine Viertelstunde — nur um
an einem Film zu sehen, ob ein Schlüssel etwas bringt. Wer auf einer
Detailseite bemerkt, dass IMDb und Rotten Tomatoes fehlen, hatte von dort
keinen Weg dorthin.

Der Server kann eine Auswahl längst; es fehlte bloss die Kennung der
Mediathek in der Antwort, damit die Seite weiss, wohin ihr Titel gehört.
Der runde Knopf holt diesen einen Titel, wartet den Lauf ab und zeichnet
die Seite neu.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-09 16:02:39 +02:00
ScarriffleandClaude Opus 5 18db89399d Ein leeres Jahrfeld ist eine Angabe, kein Versehen 
Wer bei der Zuordnung kein Jahr einträgt, sagt damit, dass er keines
weiss. Der Server reichte trotzdem eines nach — das aus dem Dateinamen —,
und das leere Feld hatte überhaupt keine Wirkung. Gerade bei einem falsch
benannten Film ist der Dateiname aber die unzuverlässigste Quelle, die es
gibt: „Plan B (2010)" heisst bei TMDB „DivertiMento – Plan B" und ist von
2011. Mit dem nachgereichten 2010 kam nie ein Treffer, und es gab keinen
Weg daran vorbei.

Ohne Angabe wird jetzt ohne Jahr gesucht. Der Platzhalter sagt es auch.

Auf der Detailseite stand im Feld bisher das Jahr der bestehenden
Zuordnung — also genau der, die gerade korrigiert werden soll. „Doctor
Strange" war auf ein Making-of von 2022 gelaufen; mit dessen Jahr konnte
der richtige Film von 2016 gar nicht erscheinen. Das Feld bleibt jetzt
leer, und leer heisst überall dasselbe.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-09 16:02:29 +02:00
ScarriffleandClaude Opus 5 ac64b20a5b Jede Zahl sagt jetzt, was sie ist — und woher sie kommt 
Nebeneinander standen „7,2" und „12", beide ohne Beschriftung. Die 12
konnte alles heissen: zwölf Folgen, zwölf von hundert Punkten, ab zwölf
Jahren. Die Auskunft steckte im Tooltip, und den sieht nur, wer schon
vermutet, dass dort etwas steht. Jetzt trägt jeder Wert seine Quelle:
FSK 12, TMDB 7,2, IMDb 7,4, MC 62.

Bei Rotten Tomatoes ist „RT 87%" ebenfalls keine Auskunft, denn dort
stehen zwei Zahlen — die der Kritik und die des Publikums, oft weit
auseinander. Also „RT Kritik" und „RT Publikum", auch wenn nur eine
der beiden da ist.

Und das Publikum wird mitverlangt: `tomatoes=true` legt die Felder
derselben Antwort bei, kostet keine zweite Anfrage und nichts vom
Tageskontingent. Ob etwas darin steht, ist eine andere Frage — seit 2018
wird berichtet, dass dort `N/A` steht, und die Frage, ob die Felder je
wieder Daten führen, ist bei OMDb seit 2017 unbeantwortet offen. Darum
wird nichts erwartet und nichts erzwungen: steht eine Zahl da, erscheint
sie; steht `N/A`, entsteht keine Wertung. Die Probe unter Einstellungen →
Metadaten zeigt, was wirklich kam.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 22:41:41 +02:00
ScarriffleandClaude Opus 5 a609b2d087 Ein Haken, der stehen blieb, als die Rechnung sich änderte 
Ein Film stand bei 1:32 und tauchte in „Fortsetzen" trotzdem nicht auf.
Die Reihe fragt nicht die Regel, sondern deren festgehaltenes Ergebnis:
die Spalte `InProgress`. Die Bruchrechnung „Stelle kleiner als Anteil der
Laufzeit" lässt sich nicht nach SQL übersetzen, also steht sie als
Wahrheitswert in der Zeile — und berechnet wird sie nur, wenn eine
Fortschrittsmeldung eintrifft. Die kaputte Meldung von vorgestern hatte
dort `false` hinterlassen; die Korrektur am Server verhinderte neuen
Schaden, räumte den alten aber nicht weg.

`Sehstandpflege` rechnet nach jedem Update einmal durch: erst die
Laufzeit aus der Datei nachtragen, dann neu bewerten — in dieser
Reihenfolge, denn eine Neubewertung auf Basis eines Stummels käme wieder
zu `false`. `UpdatedAt` bleibt, wo es war; danach ist die Reihe sortiert.

Und der Knopf heisst jetzt so wie die Reihe, über der er steht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 22:41:22 +02:00
ScarriffleandClaude Opus 5 5dfc22bdce „Hinterlegt" war keine Auskunft, und die Übersicht keine Ablage 
**Man konnte nicht sehen, ob ein Schlüssel wirkt.** Nach dem Eintragen
stand „Hinterlegt" da, und das war alles. Ob er stimmt, ob der Dienst
antwortet, ob zu einem Film überhaupt etwas zu holen ist — herausfinden
liess sich das nur, indem man die Metadaten über achthundert Titel
auffrischte und danach nachsah, ob sich etwas geändert hatte.

Jetzt gibt es „Verbindung prüfen". Es wird mit „The Matrix" gefragt, nicht
mit einem Film aus der Mediathek: der könnte schlicht unbekannt sein, und
dann wüsste man wieder nicht, ob es am Schlüssel liegt oder am Film. Die
Antwort nennt, was zurückkam — bei fanart.tv die Zahl der Plakate und
davon die in der eingestellten Sprache, denn genau dafür ist die Quelle da.

Gemessen am laufenden Server:

    tmdb    eingerichtet  ok   Erreichbar — Probeabruf ergab The Matrix (1999).
    fanart  —             —    Kein Schlüssel hinterlegt — die Quelle ist aus.
    omdb    —             —    Kein Schlüssel hinterlegt — die Quelle ist aus.

**Und die Übersicht war eine Ablage für alles geworden.** Zu Recht
angemerkt: es gibt eine Seite „Metadaten", und die Zugänge standen trotzdem
unter „Übersicht" — zwischen Servername, doppelten Einträgen, Fassung und
Speicherplatz. Die drei Quellen stehen jetzt dort, wo man sie sucht, jede
mit einem Satz dazu, was sie liefert und was sie dafür braucht.

Aufmacherhöhe und saisonale Reihen bekommen einen eigenen Bereich
„Darstellung". Eine Seite, die „Übersicht" heisst, ist nicht der Ort für
alles, was sonst nirgends passt.

**Am Telefon tat die Aufmacherhöhe gar nichts.** Gemeldet als „auf 100 %
ist es immer noch zu niedrig" — und das stimmte buchstäblich: unter 860
Pixeln Breite stand `height: min(52vh, 420px)` fest und überschrieb die
Einstellung vollständig. Ob „niedrig" oder „sehr hoch", es kamen immer
dieselben 52 vh heraus.

Jetzt hat jede Stufe zwei Höhen, eine fürs breite und eine fürs schmale
Bild; am Telefon fällt sie eine Spur flacher aus, weil der Bildschirm
hochkant ist und derselbe Anteil der ersten Kachelreihe dort den Platz
nähme. Dazu eine fünfte Stufe „Bildschirmhoch" — mehr ginge nicht
sinnvoll, darüber ist es kein Aufmacher mehr, sondern die ganze Seite.

Eine Prüfung hält ausserdem fest, dass ein Film ohne passendes Stichwort
und ohne passendes Genre nicht in der saisonalen Reihe steht. Anlass war
die Meldung, dort stünden harmlose Zeichentrickfilme — die Reihe arbeitet
richtig, sie macht nur sichtbar, wenn ein Titel auf den falschen Eintrag
zugeordnet ist.

765 Tests grün.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 22:11:55 +02:00
ScarriffleandClaude Opus 5 e066f5fe87 Eine Reihe, die nur zu ihrer Zeit dasteht 
Zu Halloween, zur Weihnachtszeit, zum Jahreswechsel, im Sommer — und zu
allem, was sonst jemand feiert.

**Nach Stichwörtern, nicht nach Genres.** „Stirb langsam" ist kein
Familienfilm und trägt trotzdem „christmas". Eine Weihnachtsreihe nach
Genres enthielte jeden Zeichentrickfilm und diesen Film nicht. TMDB führt
die Stichwörter ohnehin; sie kommen jetzt über `append_to_response` mit
und landen in einer eigenen Tabelle, nach demselben Muster wie Genres.
Kleingeschrieben abgelegt — TMDB liefert „Christmas" und „christmas" je
nach Eintrag, und zwei Schreibweisen wären zwei Stichwörter.

**Einstellbar und nicht eingebaut.** Halloween und Weihnachten kennt
jeder; der 1. August ist Schweizer Nationalfeiertag, der 4. Juli
amerikanischer, und der Geburtstag des Betreibers steht in keiner
Bibliothek. Eine feste Liste im Quelltext hiesse: für jeden Anlass eine
neue Fassung. Vier sind vorangelegt — als Beispiel, nicht als Meinung
darüber, was jemand feiert.

**Über den Jahreswechsel hinweg.** „28.12. bis 02.01." ist kein Fehler,
sondern der Normalfall für Silvester; ein Vergleich, der nur „von ≤ heute
≤ bis" kennt, fände diesen Zeitraum nie — und die Reihe stünde genau in
den Tagen nicht da, für die sie gedacht ist. Geprüft, Tag für Tag, samt
der Zusicherung, dass sich die vorangelegten Anlässe an keinem Tag im Jahr
überschneiden.

**Leer heisst leer.** Gilt heute kein Anlass oder findet er nichts, kommt
eine Reihe ohne Namen zurück und der Client zeigt gar keine — statt einer
mit Überschrift und nichts darunter. Scheitert der Abruf ganz, fehlt eine
Reihe und nicht die Startseite.

Bedient wird sie als Text, eine Zeile je Anlass: Name, von, bis,
Stichwörter, Genres. Ein Listeneditor mit Zeilen zum Hinzufügen,
Verschieben und Löschen wäre viel Oberfläche für etwas, das man dreimal im
Jahr anfasst — und es ist dieselbe Form, in der es gespeichert wird.

Ein Anlass ohne Stichwort und ohne Genre wird abgewiesen statt
stillschweigend geschluckt: er fände nie etwas, und wer ihn eingetragen
hat, suchte den Fehler woanders.

**Die Stichwörter kommen erst beim nächsten Auffrischen der Metadaten.**
Vorhandene Titel tragen noch keine — bis dahin bleibt die Reihe leer.

764 Tests grün, davon 22 neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:45:09 +02:00
ScarriffleandClaude Opus 5 c13d1e78d2 Eine Mediathek für alles, was in keinem Katalog steht 
Urlaubsaufnahmen, Mitschnitte, Vorträge. Jedes Verfahren, das bei Filmen
richtig ist, wäre hier falsch: „Sommer 2019 Teil 2" ist kein Film von 2019,
zwei Aufnahmen desselben Tages sind nicht zwei Fassungen derselben Sache,
und in keinem Katalog steht, was da liegt.

Die neue Art `Videos` nimmt den Dateinamen als Titel, zerlegt nichts, legt
nichts zusammen und fragt niemanden. Der Pfad ist dabei der
Vergleichsschlüssel, nicht der Name — zwei Dateien „Ausflug.mp4" in zwei
Ordnern sind zwei Ausflüge.

**Der Unterordner wird zur Kategorie.** Statt eine eigene Gruppierung zu
bauen, bekommt jedes Video den Namen seines Ordners als Genre. Damit
greifen Filter, Kategorienansicht und Suche, ohne dass es in der Oberfläche
etwas Neues gibt. Eine zweite Gruppierung daneben hiesse: zwei Wege für
dasselbe, und einer davon wäre überall sonst ungepflegt.

Die Anreicherung übergeht jetzt alles, was `MatchLocked` trägt. Das galt
bisher nur für von Hand korrigierte Zuordnungen und gilt damit auch hier —
eine Suche nach „Abend am Feuer" fände irgendeinen fremden Film, und der
stünde danach mit Plakat und Beschreibung in der Urlaubsmediathek.

Geprüft: vier Dateien in zwei Ordnern ergeben vier Titel mit ihren
Dateinamen, keine Jahre, keinen fremden Treffer — und genau zwei
Kategorien, denn was direkt in der Wurzel liegt, bekommt keine.

742 Tests grün, davon zwei neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:36:06 +02:00
ScarriffleandClaude Opus 5 af2b844d65 IMDb, Rotten Tomatoes und Metacritic neben der TMDB-Wertung 
IMDbs eigene Schnittstelle kostet Geld, Rotten Tomatoes vergibt Zugänge nur
an Partner, Letterboxd hat gar keine offene. OMDb liefert alle drei in
einer Antwort, über die IMDb-Kennung, die ohnehin schon an jedem Film steht.

**Eine Tabelle und kein Feld je Quelle.** `Movie.Rating` ist ein Skalar
ohne Quellenangabe, und das war richtig, solange es eine Quelle gab. Für
drei weitere wären es drei Spalten — und bei der vierten wieder eine
Migration. Jetzt ist jede Quelle eine Zeile, je Titel und Quelle eine, mit
eindeutigem Index darauf: ein zweiter Lauf schreibt um statt anzuhäufen.

**Zwei Werte je Bewertung, und beide gebraucht.** Der normierte Wert zum
Vergleichen und Sortieren, die Anzeige zum Hinschreiben. Rotten Tomatoes in
„8,7 von 10" umzurechnen wäre eine Lüge über die Quelle — dort steht 87 %,
und genau so kennt man es.

**Wieder keine zweite Metadatenquelle.** `IBewertungsquelle` liefert
Bewertungen, sonst nichts. Bei Titel und Beschreibung wären zwei Anbieter
zwei Wahrheiten; bei einer Bewertung ist jede Quelle eine eigene Zahl, und
da sind mehrere kein Widerspruch, sondern der Sinn der Sache.

**Ohne Kennung wird nicht gefragt.** OMDb kennt nur den Weg über die
IMDb-Kennung; nach einem Titel zu suchen hiesse, denselben Zuordnungsfehler
ein zweites Mal zu riskieren. Und auf Unbekanntes antwortet OMDb mit 200
und `Response: "False"` — das als Treffer durchzulassen legte eine leere
Bewertung ab, die danach als „keine Wertung" dastünde.

Angezeigt wird mit Kürzel statt Stern: vier gleich aussehende Zahlen
nebeneinander sagen nicht, woher sie kommen. Kein Logo — die Marken von
IMDb und Rotten Tomatoes mitzuliefern hiesse, fremde Zeichen auszuliefern.

Kein mitgelieferter Schlüssel, aus demselben Grund wie bei fanart.tv: OMDb
begrenzt auf tausend Abrufe am Tag je Schlüssel. Einzutragen unter
Einstellungen → Übersicht → Metadaten.

740 Tests grün, davon acht neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:26:58 +02:00
ScarriffleandClaude Opus 5 97edb49564 Eine zweite Bildquelle, weil TMDB nicht alles hat 
„365 Tage" stand mit polnischem Plakat da. Nachgesehen: TMDB hat zu diesem
Film 26 Plakate und kein einziges deutsches. Die Auswahl von gestern nimmt
seither das sprachlose statt des polnischen — erfinden kann sie keines.

fanart.tv ist die Quelle, bei der jedes Plakat seine Sprache mitführt, und
die Gemeinschaft dort pflegt landessprachliche Fassungen. OMDb wäre keine
Hilfe gewesen: es liefert das Plakat von IMDb, und das ist in aller Regel
das amerikanische.

**Ausdrücklich keine zweite Metadatenquelle.** `IBildquelle` liefert
Bilder, sonst nichts. Titel, Beschreibung und Besetzung kommen weiterhin
von einer Stelle — zwei Anbieter für dieselbe Angabe wären zwei Wahrheiten.

**Gefragt wird nur, wenn es lohnt.** `MovieMetadata` trägt jetzt die
Sprache des gewählten Plakats mit. Hat TMDB schon eines in der
eingestellten Sprache, geht keine Anfrage hinaus — bei achthundert Titeln
ist das der Unterschied zwischen „läuft nebenher" und „hängt am fremden
Dienst". Und nur ein landessprachliches sticht: ein sprachloses von
fanart.tv ist nicht besser als ein sprachloses von TMDB.

**Die Rangfolge liegt jetzt im Kern**, nicht im TMDB-Client. Sie gilt für
alle Quellen, sonst kämen die Bilder zweier Anbieter in zwei Reihenfolgen
zusammen. Im Bilderdialog stehen beide Quellen gemeinsam geordnet: ein
deutsches Plakat von fanart.tv vor einem sprachlosen von TMDB.

**Nur Filme.** Der Serienweg von fanart.tv verlangt eine TVDB-Kennung, und
die führt Flaro nicht. Eine halbe Lösung, die bei Serien stillschweigend
nichts tut, wäre schlechter als eine, die sagt, worauf sie sich beschränkt.

**Kein mitgelieferter Schlüssel.** Bei TMDB gibt es einen als Rückfall;
fanart.tv verlangt einen persönlichen, und einen fremden mitzuliefern
hiesse, ihn fremd zu benutzen. Ohne eigenen Schlüssel geht keine Anfrage
hinaus — geprüft. Einzutragen unter Einstellungen → Übersicht → Metadaten.

Dass „00" dort „ohne Sprache" heisst, wird beim Lesen übersetzt: sonst
führte die gemeinsame Rangfolge ein sprachloses Plakat als Sprache „00"
und setzte es hinter Englisch statt davor.

732 Tests grün, davon sieben neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:18:27 +02:00
ScarriffleandClaude Opus 5 2bd13f0f19 Breitbild sass oben statt mittig 
Ein 21:9-Film war in der Breite richtig und in der Höhe nicht: der schwarze
Rand lag ganz unten statt gleichmässig oben und unten. Im Fenster fällt das
kaum auf, im Vollbild sofort.

Gemessen an einem 2560×1080-Film in einem 1024×768-Fenster:

    Hülle        768 hoch
    Videokasten  459 hoch, bei oben 0

Woran es lag: die Hülle ist ein Raster mit `place-items: center`. Damit
wird das Videoelement nicht gedehnt, und sein `height: 100%` löst sich
gegen eine Zeile auf, die ihre Höhe wiederum aus dem Element nimmt — die
Prozentangabe hatte nichts, woran sie sich halten konnte. Herausgekommen
ist ein Kasten, der weder die volle Höhe hatte noch mittig sass.

Jetzt liegt das Videoelement im grossen Spieler absolut über der ganzen
Hülle. `object-fit: contain` rechnet damit gegen den vollen Bildschirm und
legt den Rand von selbst zu gleichen Teilen oben und unten — in beiden
Richtungen, nicht nur in der einen, die vorher stimmte.

Nachher dieselbe Messung: Kasten 1024 × 768, oben 0.

Die kleine Leiste bleibt unberührt — sie positioniert dasselbe Element
ohnehin absolut und mit eigenen Massen; deshalb das `:not(.pl-klein)`.
Nachgemessen: 128 × 70, `object-fit: cover`, unverändert.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:07:31 +02:00
ScarriffleandClaude Opus 5 144470a413 Im Browser gibt es keine Datei mehr, nur den Strom 
Auf der Detailseite stand ein Knopf „Herunterladen", der die Datei als MP4
herausgab. Das ist etwas anderes, als einen Strom zu zeigen: wer eine Datei
bekommt, hat sie und kann sie weitergeben — und das soll dieser Server
nicht anbieten.

Weg sind der Knopf, das Bereitstellen davor und die beiden Stellen in der
Schnittstelle, die nur dafür da waren.

**Der Endpunkt bleibt.** Die Apps holen sich eine Mitnahme über
`/api/v1/files/{id}/download`, und dort ist sie an ein Gerät gebunden statt
an einen Ordner. Das heisst aber auch: wer angemeldet ist und die Adresse
kennt, kommt weiterhin an die Datei. Soll das zu — etwa als Recht je
Benutzer oder als Schalter für den ganzen Server —, ist das ein eigener
Schritt und keine Zeile in dieser Änderung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:07:20 +02:00
ScarriffleandClaude Opus 5 532473b1f9 Ein Plan für das, was an keinem Aufruf hängt 
Sichern, Datenbank aufräumen, verwaiste Bilder wegwerfen — alle drei Tage,
alle sieben Tage, von selbst.

**Der erste Hintergrunddienst in diesem Server, und das mit Bedacht.** An
drei Stellen steht sinngemäss, ein eigener Dienst wäre Aufwand ohne
Gegenwert, und für das Wegräumen abgelaufener Gerätecodes stimmt das:
solche Arbeit hängt an einem Aufruf, der ohnehin kommt. Eine Sicherung
hängt an nichts. Sie soll alle drei Tage geschehen, auch wenn niemand etwas
anklickt, und dafür gibt es eine Uhr. Alle fünfzehn Minuten eine Frage an
eine Tabelle mit einer Handvoll Zeilen; ist nichts fällig — der Normalfall
—, kostet es nichts.

Der letzte Lauf steht in der Datenbank, nicht im Arbeitsspeicher. Ein
Server, der jede Nacht neu startet, sicherte sonst jeden Morgen — oder,
bei einem Zähler, der bei null anfängt, nie. Auch ein Fehlschlag wird
vermerkt, sonst versuchte der Plan es alle fünfzehn Minuten wieder und
eine volle Platte erzeugte ein volles Protokoll.

**Die Sicherung ist `VACUUM INTO`, nicht Datei kopieren.** Die Datenbank
läuft im WAL-Modus: neben `flaro.db` stehen `-wal` und `-shm`, und wer nur
die erste Datei kopiert, bekommt einen Stand von vor Stunden oder einen
halben. `VACUUM INTO` schreibt eine vollständige, aufgeräumte Kopie im
laufenden Betrieb. Der Zielordner ist einstellbar und geht als gebundener
Wert in die Anweisung — eine Einstellung soll keine SQL-Anweisung werden.

Die Prüfung verlässt sich nicht darauf, dass eine Datei entstanden ist: sie
öffnet die Kopie als Datenbank und zählt die Zeilen. Eine Sicherung, die
sich nicht öffnen lässt, ist schlimmer als keine — man verlässt sich
darauf und merkt es erst, wenn es zu spät ist.

**Bilder nur, wenn verwaist.** Den ganzen Bildspeicher zu leeren gibt es
als Knopf und ist gefahrlos, kostet danach aber tausende Abrufe bei TMDB.
Hier fliegt nur, worauf kein Titel mehr zeigt — mit einer Stunde
Schonfrist, weil ein Bild abgelegt wird, bevor der Verweis darauf
gespeichert ist. Ohne diese Frist räumte ein Lauf mitten im Scan genau das
weg, was gerade geholt wurde.

**Eine eigene Seite „Wartung".** Die drei Kratzplatzzahlen standen unter
„Wiedergabe" — dort ist ihr Anlass, aber nicht ihr Thema. Sie ziehen mit
um: alles auf dieser Seite ist etwas, das der Server ohne Zutun erledigt,
und man sieht es an einem Ort nach. Je Aufgabe steht da, wann sie zuletzt
lief und was herauskam, dazu ein Knopf „Jetzt ausführen" — wer gleich etwas
Grosses vorhat, will die Kopie jetzt und nicht in drei Tagen.

725 Tests grün, davon elf neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 21:02:42 +02:00
ScarriffleandClaude Opus 5 c4af182d31 Der Kratzplatz räumt sich auf 
39,1 GB in FLARO_TRANSCODE, und das war kein Normalzustand, sondern ein
Leck: für jede Mitnahme baut der Server eine MP4 in Quellgrösse und löschte
sie nie. Die einzige Löschung, die es gab, räumte ältere Fassungen
derselben Datei weg. Stromordner verschwanden nur beim geordneten
Herunterfahren, Untertitel gar nicht.

**Zuerst: fertig heisst fertig.** ffmpeg schrieb direkt auf den Endnamen.
Nach einem harten Abbruch lag dort eine abgeschnittene Datei, `IsReady`
meldete „fertig", und sie ging so hinaus — und ein Aufräumer konnte
vollständig und abgeschnitten nicht unterscheiden. Gebaut wird jetzt unter
`.teil`, umbenannt erst nach Erfolg. Dabei muss das Format ausdrücklich
gesetzt werden: ffmpeg wählt den Muxer an der Endung und antwortet auf
`.teil` mit „Unable to choose an output format". Das hätte jedes Umpacken
zerlegt; die Prüfung hat es gefunden, bevor es jemand zu spüren bekam.

**Zwei Stufen für die Pakete.** Verwaiste gehen bedingungslos: unleserlicher
Name, fremde Bauart, kein Eintrag in der Mediathek, oder der Zeitstempel im
Namen passt nicht mehr. Der Rest fällt unter Obergrenze (20 GB) und Alter
(7 Tage), Ältestes zuerst.

Beides, und nicht eines: ein Alter allein löst den Fall nicht, denn die 39
GB waren gültige, aktuelle Dateien, jede für sich berechtigt. Eine
Obergrenze allein ist zu grob — ein Topf knapp darunter, in dem seit Wochen
nichts gebraucht wurde, besetzt ein Volume, das anderes braucht.

„Zuletzt gebraucht" ist die Änderungszeit der Paketdatei selbst, bei jeder
Auslieferung neu gestempelt. Die Zugriffszeit wäre das Naheliegende, nur
führt sie nicht jedes Dateisystem — mit `noatime` steht sie still, und der
Aufräumer hielte alles für uralt.

Ein laufender Download wird nie gelöscht: ein Benutzungszähler hält die
Datei fest, solange die Antwort läuft, dazu eine Schonfrist von 30 Minuten.
Der Zähler ist auch unter Linux nötig — der laufende Strom überlebt ein
Entfernen, die Fortsetzung einer Bereichsanfrage nicht, und der Client finge
von vorn an.

**Stromordner** werden beim Start bedingungslos geleert — nach einem Start
gibt es keine einzige Sitzung, also ist jeder Ordner verwaist. Im Betrieb
nur die ohne passende Sitzung, deren Änderungszeit älter ist als die
Geduld; das fängt auch den Fall, dass `Abraeumen` an einem IOException
scheitert und der Ordner für immer liegenbleibt.

**Untertitel** nur, wenn sie verwaist sind. Keine Obergrenze: eine .vtt ist
Kilobytes, und eine gültige wird wieder gebraucht — sie nach Platz zu
löschen hiesse, Minuten Lesearbeit gegen Megabytes zu tauschen. Eine leere
bleibt ausdrücklich liegen: sie ist das Ergebnis „diese Spur hat keinen
Text", und wer sie wegräumt, lässt bei jedem Start eine vierzig Gigabyte
grosse Datei neu durchlesen.

**Vier Anlässe, kein Dienst.** Start, vor jedem Umpacken, nach einem Scan,
auf Knopfdruck — wie alles Wiederkehrende in diesem Server. Einer zur Zeit;
wer nicht hineinkommt, geht weiter.

Gemessen am laufenden Server mit Attrappen:

    vorher    packages 17408 KB (4), untertitel 5 KB (3), 1 Stromordner
    nachher   14 MB freigegeben, 4 Dateien
              gültiges Paket blieb, verwaistes/veraltetes/Teilstück weg,
              verwaiste .vtt weg, gültige blieben, Stromordner weg

    Obergrenze 1 MB, Datei in der Schonfrist   -> bleibt
    Obergrenze 1 MB, Schonfrist vorbei         -> 3072 KB freigegeben

In der Übersicht steht die Belegung je Unterordner mit Dateizahl und
daneben „Jetzt aufräumen"; die drei Zahlen stehen unter Wiedergabe, wo
Transcoder-Stufe und Schwellen schon stehen — der Kratzplatz ist, was die
Wiedergabe hinterlässt.

714 Tests grün, davon 36 neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 19:07:52 +02:00
ScarriffleandClaude Opus 5 1b4784f1db Zwei Fassungen dürfen gewollt sein, und die Startseite darf nicht warten 
**Mehrfachfassungen lassen sich abhaken.** Zwei Dateien an einem Film sind
meist zwei Fassungen und völlig in Ordnung. In der Liste standen sie
trotzdem für immer: sie rechnet jedes Mal frisch, und es gab keinen Zustand.
Wer absichtlich zwei Fassungen hält, konnte die Gruppe nicht loswerden — und
unter den gewollten ging das Ungewollte unter.

Abgehakt wird eine Dateizahl, kein Zeitpunkt. Ein Zeitstempel müsste gegen
`MediaFile.ModifiedAt` verglichen werden, und eine alte Datei, frisch
hineinkopiert, behält ihre alte Zeit und käme nie wieder hoch. Die Anzahl
ist genau die Frage: kommt eine dritte Fassung dazu, meldet sich die Gruppe
von selbst zurück. Gerechnet wird sie auf dem Server — ein Client mit
veralteter Liste hakte sonst eine Gruppe mit zwei Dateien ab, die inzwischen
drei hat.

„Ignorierte zeigen" führt zurück, wie bei den erledigten Meldungen; ohne das
wäre das Abhaken unumkehrbar und niemand wüsste, was er weggeklickt hat.

**Die Startseite wartete dreimal nacheinander.** Erst die Serverauskunft,
dann Konto und Mediatheken, dann erst die Startseite — drei Rundreisen,
bevor das erste Bild in Auftrag ging. Liegt eine Sitzung im Speicher, laufen
die ersten beiden jetzt zugleich los. Nur dann: ohne Sitzung liefen
`/auth/me` und `/libraries` vor der Antwort auf `needsSetup` in ein 401, und
die Sitzungsprüfung kann daraufhin abmelden.

Gemessen am laufenden Server: `users/me`, `system/info` und `libraries`
starten alle bei 37 ms, die Startseitenabfragen folgen bei 73 ms. Vorher
lagen drei Runden dazwischen.

**Sieben Hintergrundbilder auf einmal waren sechs zu viel.** Jede Folie des
Aufmachers bekam sofort ihr `w1280`-Bild; sichtbar ist immer nur eine. Jetzt
lädt die sichtbare sofort und der Rest in der Leerlaufzeit — und wer
weiterschaltet, bevor das lief, bekommt sein Bild dann.

**Die Schrift kam von Google.** `display=swap` rettete den Text, nicht den
ersten Aufbau: ein Stylesheet blockiert das Zeichnen, und ein Heimserver
ohne Internet oder mit träger Namensauflösung wartete davor. Inter liegt
jetzt als zwei Dateien von zusammen sechzig Kilobyte im Projekt, variabel
für alle Schnitte, mit `unicode-range` getrennt nach latin und latin-ext.
Gemessen: null Anfragen an fonts.googleapis.com. Lizenztext liegt dabei.

**Und mein Untertitelvorrat bremste mit.** Er startete sofort beim
Hochfahren und las die ganze Mediathek — von derselben Platte, von der die
Startseite ihre Bilder holt. Jetzt beginnt er eine Minute später und stellt
zurück, solange eine Wiedergabe läuft. Die Datei bleibt dabei vorn in der
Reihe; verworfen wird nichts.

678 Tests grün, davon zwei neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 17:56:41 +02:00
ScarriffleandClaude Opus 5 2809821c9b Vier Fehler, und bei zweien log der Kommentar daneben 
**Der Einstellungsknopf lag hinter der Abspielleiste.** Gemessen: `.pl`
steht auf Stufe 150, `#chrome` auf gar keiner, und die kleine Leiste spannte
über die ganze Breite — genau über die unteren 72 Bildpunkte der
Seitenleiste, wo „Einstellungen" klebt. Weil der Spieler bei jedem Wechsel
der Adresse minimiert, stand sie zuverlässig im Weg, sobald man dorthin
wollte.

Die Leiste beginnt jetzt hinter der Seitenleiste. Nicht über die Stufen
gelöst, und das ist der Punkt: `#chrome` höher zu setzen hiesse, die
Seitenleiste läge auch über dem grossen Spieler — es ist dieselbe Hülle.
Dass diese Leiste Platz wegnimmt statt sich darüberzulegen, stand für
Inhalt, Hinweise und Auswahlleiste ohnehin schon da; die Seitenleiste war
die vergessene vierte. Gemessen, 1400 Bildpunkte breit: Leiste ab 240,
Knopf bei 0, keine Überschneidung, und ein Treffertest in der Knopfmitte
trifft den Knopf.

**Ein Klick auf eine Kategorie kam nie an.** Dort sprang der Code in die
Mediathek und suchte danach `.filterzeile select`, um den Wert zu setzen.
Die Filterzeile hat kein `<select>` — `auswahl()` baut einen Knopf, mit
Absicht und begründet. Der Zweig lief also nie, und man landete in der
ungefilterten Mediathek. Der Kommentar daneben behauptete das Gegenteil.

Das Genre steht jetzt in der Adresse: `#/m/{id}/mediathek/Horror`. Das
löst zugleich das zweite Problem — die Mediathek wird unter ihrem Weg
gemerkt, und stünde das Genre nur im Kopf, zeigte ein zweiter Besuch die
Liste des ersten. Geprüft: Klick setzt den Weg und die Pille, Neuladen
behält beides, Zurück führt auf die Kategorien, Vorwärts wieder hinein.

**Zurückgezogene Einladungen blieben für immer stehen.** Der Knopfblock
steckte ganz in `if (!e.revokedAt)`, eine erledigte Zeile hatte also gar
keinen Knopf. Die Serverbegründung — eine Zeile wegzuwerfen hiesse,
hinterher nicht mehr zu wissen, dass es den Link je gab — bleibt richtig,
sie gilt nur nicht ewig: eine Liste, aus der nichts verschwindet, wird
unlesbar, und dann sieht man die eine Zeile nicht mehr, um die es ging.

Deshalb kein umgedeutetes DELETE, sondern `?purge=true`, und das greift nur
bei einem Link, der ohnehin keine Tür mehr öffnet. Ein gültiger wird mit
einem deutschen Satz abgewiesen.

**Poster in der falschen Sprache.** „365 Tage" stand mit polnischem Plakat
da. Kein fehlender Anbieter: für den Schriftzug gab es die sprachgewichtete
Wahl längst, fürs Plakat wurde das blanke `poster_path` der Hauptantwort
genommen — bei TMDB das Bild der Originalsprache, wenn in der gewünschten
keines eingetragen ist. Die sortierte Liste lag im selben Abruf schon vor
und wurde ausschliesslich für den Schriftzug benutzt.

Plakat und Hintergrund nehmen jetzt dieselbe Rangfolge: eingestellte
Sprache, dann sprachlos, dann Englisch. Sprachlos vor Englisch ist keine
Verlegenheit — ein Bild ohne Sprachkennung trägt keinen Text, und ein
Plakat ohne Titel ist für einen deutschen Bestand besser als dasselbe mit
englischem. Im Bilderdialog stehen die Kandidaten jetzt ebenso sortiert.
Bestehende Titel ändern sich beim nächsten Auffrischen; von Hand gesetzte
Plakate bleiben unangetastet.

676 Tests grün, davon zehn neue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 17:46:46 +02:00
ScarriffleandClaude Opus 5 c6df9fdab0 Die Schriftgrösse war am falschen Ende grosszügig 
60 bis 300 Prozent waren es, und gebraucht wird der Weg nach unten: schon
die Vorgabe des Browsers ist auf einem grossen Bildschirm eher zu gross als
zu klein, und 300 Prozent füllt das halbe Bild. Jetzt 30 bis 120 Prozent,
mit unveränderter 100-Prozent-Marke.

Dazu Fünferschritte statt Zehner. Auf einer Spanne von 90 statt 240 Prozent
wiegt ein Zehnerschritt doppelt so schwer; bei 35 Prozent ist der
Unterschied zu 45 Prozent kein Feinschliff mehr, sondern ein Sprung.

Ein gemerkter Wert von früher wird beim Lesen gekappt — geprüft: 190 im
Speicher ergibt Regler 120 und `font-size: 120%`. Und 30 Prozent ist am
Bild nachgesehen klein, aber lesbar; als Untergrenze taugt es.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 06:59:15 +02:00
ScarriffleandClaude Opus 5 963e5a74ae Untertitel so gross und so bunt, wie man sie braucht 
Die Voreinstellung des Browsers ist weisse Schrift auf schwarzem Kasten, in
einer Grösse, die er aus der Höhe des Videos rechnet. Auf einem grossen
Bildschirm aus drei Metern Abstand ist das zu klein, und wer schlecht sieht,
braucht es anders.

Einstellbar sind Grösse (60 bis 300 Prozent in Zehnerschritten),
Schriftfarbe (Weiss, Hellgelb, Hellblau, Schwarz) und Hintergrund
(Halbdunkel, Schwarz, Grau, Ohne).

Gestaltet wird mit `::cue`, nicht mit eigenen Kästen. Der Browser zeichnet
die Einblendungen selbst — Position, Umbruch, Zeilenabstand und die
Platzangaben aus der Datei. Das nachzubauen hiesse, all das noch einmal zu
schreiben und dabei schlechter zu werden.

Gemessen an einem Video mit echter Spur, Bild für Bild: 200 Prozent in
Hellgelb ohne Kasten und 140 Prozent in Hellblau auf Grau kommen beide so
heraus, wie sie gemeint sind.

Ohne Kasten setzt es von selbst einen Schatten. Weisse Schrift in einer
hellen Szene ist sonst weg, und das wäre eine Einstellung, die sich selbst
unbrauchbar macht. Mit Kasten wäre derselbe Schatten nur Unschärfe.

Die Einstellung sitzt im Untertitelmenü, abgetrennt unter den Spuren — wie
der Tonversatz im Tonmenü. Ob die Schrift gross genug ist, sieht man nur an
einem laufenden Film, in diesem Licht, aus diesem Abstand; wer dafür die
Wiedergabe verlassen muss, stellt zweimal falsch ein, bevor er einmal
richtig liegt.

Gemerkt wird im Browser, nicht am Konto: wie gross Schrift sein muss, hängt
am Bildschirm und am Abstand davor. Dasselbe Konto am Telefon und am
Fernseher will zwei verschiedene Grössen.

Farbfelder statt einer Liste mit Farbnamen — „Hellblau" muss man lesen und
sich vorstellen, ein Feld sieht man. Das gewählte trägt einen Ring aussen
herum und keinen Haken darin: ein Haken wäre auf Weiss unsichtbar und auf
Schwarz erst recht. „Ohne Hintergrund" zeigt ein Karomuster, weil ein
leeres Feld nach Weiss aussähe.

Gelesen wird nur, was bekannt ist. Ein fremder Eintrag im Speicher darf
nicht zu beliebigem CSS in der Seite werden.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 06:43:26 +02:00
ScarriffleandClaude Opus 5 40f41f0cee Zwei Tonspuren sind eine Wahl, kein Chor 
„Auf der App höre ich einfach alle Audiospuren gleichzeitig."

MP4 ordnet Spuren derselben Art einer `alternate_group` zu, und ein
Abspieler nimmt daraus genau eine. ffmpeg leitet diese Gruppe aus der
Markierung der Quelle ab — sind dort zwei Tonspuren als Vorgabe markiert,
hält es sie für Verschiedenes und legt sie in getrennte Gruppen. Dann ist
jede für sich eingeschaltet, und man hört beide übereinander. Bei Rips aus
freier Wildbahn ist die doppelte Markierung eher Regel als Ausnahme; in
Matroska stört sie niemanden, in MP4 ist sie der Unterschied zwischen Wahl
und Chor.

Gemessen an einer Quelle mit zwei markierten Tonspuren, am Spurkopf der
fertigen MP4:

    vorher    Spur 2: an,  Gruppe 1
              Spur 3: an,  Gruppe 2     <- beide laufen
    nachher   Spur 2: an,  Gruppe 1
              Spur 3: aus, Gruppe 1     <- eine zur Wahl

Das Umpacken schreibt jetzt genau eine Vorgabe je Spurart: die, die es in
der Quelle schon war, sonst die erste. Auch die Nullen gehören
hingeschrieben — ffmpeg übernähme sonst die Markierung der Quelle für alle
übrigen, und genau die ist ja das Problem. „Erzwungen" wird dabei
ausdrücklich erhalten, weil `-disposition` die ganze Markierung ersetzt
statt sie zu ergänzen.

Untertitel bekommen dieselbe Behandlung. War in der Quelle keiner
vorgesehen, bleibt es dabei — sonst erschienen auf einmal zwei übereinander.

Der Name im Zwischenspeicher trägt jetzt die Bauart mit. Ohne das bliebe
auf einem NAS, das schon umgepackt hat, die fehlerhafte Datei liegen und
würde weiter ausgeliefert, obwohl der Server es längst besser kann.

Geprüft an der echten Datei, am `tkhd` und nicht an der Disposition: was
ein Abspieler tut, hängt an „enabled" und `alternate_group`, und ffprobe
zeigt davon nur einen Teil. Ohne die Korrektur fällt die Prüfung um
(Gruppe 1 gegen 2).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-08 06:32:25 +02:00
ScarriffleandClaude Opus 5 1531163bc1 Die Untertitel holen, bevor jemand sie einschaltet 
Zwei Minuten „wird geholt", und noch immer kein Text. Die Ablage von vorhin
war richtig und reichte nicht: beim ersten Mal musste immer noch jemand
warten, und zwar der, der gerade einen Film anschaut.

Das Lesen selbst lässt sich nicht beschleunigen. Untertitelpakete liegen
über die ganze Datei verteilt; sie zu finden heisst, alles zu lesen. Bei
vierzig Gigabyte auf einem NAS sind das Minuten, und daran ändert kein
Schalter etwas. Also nicht schneller lesen, sondern früher.

Der Vorrat arbeitet die Mediathek jetzt von sich aus durch: beim Start des
Servers und nach jedem Scan, die zuletzt hinzugekommenen zuerst. Eine Datei
nach der anderen, mit zwei Sekunden Pause dazwischen — das Lesen ist von
der Platte begrenzt, und eine laufende Wiedergabe liest von derselben
Platte und ist wichtiger. Wer einen Film startet, drängelt sich vor: seine
Datei ist als Nächstes dran statt als Dreissigste.

Einmal je Datei, nie wieder: der Name der Ablage trägt den
Änderungszeitpunkt. Eine ersetzte Datei bekommt dadurch von selbst einen
neuen Namen, eine unveränderte wird nie zweimal gelesen.

Gemessen am Prüfserver mit leerer Ablage:

    Start, ohne jeden Abruf   -> „1 Datei(en) werden im Hintergrund
                                  gelesen", danach „2 von 2 Spur(en)"
    Klick auf „Deutsch"       -> 153 ms bis zum Text, 10 Einblendungen,
                                  die erste bei 0 bis 3 s

Landet jemand trotzdem im Wartefall, gibt der Spieler nicht mehr nach zwei
Minuten auf, sondern fragt zehn Minuten lang nach — und sagt dazu, dass es
einmalig ist.

Die Auswahl der Textspuren stand zweimal im Quelltext und steht jetzt
einmal: im Vorrat. Zwei Listen, von denen eine das Menü füllt und die
andere bestimmt, was geholt wird, laufen sonst irgendwann auseinander.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 22:14:20 +02:00
ScarriffleandClaude Opus 5 c2fd2a86fd Einmal aus der Datei holen, nicht bei jedem Abruf 
„Diese Untertitelspur liess sich nicht laden", und auf der zweiten Spur kam
gar nichts. Nicht das Format war schuld und auch nicht das Verschieben,
sondern die Zeit: jeder Abruf startete ffmpeg, ffmpeg musste die ganze
Datei durchlesen, und nach dreissig Sekunden wurde abgebrochen. An einem
Prüffilm von fünfzehn Megabyte fällt das nie auf; bei einem Dreistünder auf
einem NAS reicht es nie.

Schlimmer wurde es durch meine eigene Korrektur von gestern: seit die
Adresse den Einstiegspunkt mitführt (`?ab=`), ändert sie sich bei jedem
Sprung — der Browser konnte nichts mehr aus seinem Zwischenspeicher nehmen,
und jeder Sprung stiess einen neuen Durchlauf an.

Jetzt:

- Ein ffmpeg-Durchlauf holt alle Textspuren auf einmal. Das Lesen der Datei
  ist der teure Teil und wird nicht mehr je Spur bezahlt.
- Das Ergebnis bleibt liegen, ungeschoben; das Verschieben ist eine
  Zeilenersetzung und kostet nichts. Gemessen: erster Abruf 0,42 s, jeder
  weitere 2 bis 3 ms — und der zweite Sprung in derselben Datei trifft
  dieselbe Ablage statt eines neuen Durchlaufs.
- Angestossen wird beim Start des Stroms, nicht erst beim Einschalten. Wer
  nach einer halben Stunde Untertitel will, wartet dann gar nicht.
- Geschrieben wird unter `.teil` und erst danach umbenannt. Eine
  abgebrochene Datei am richtigen Namen gälte sonst für immer als fertig.
- Die Geduld steigt von 30 Sekunden auf 30 Minuten. Sie ist jetzt eine
  Obergrenze gegen einen hängenden Prozess, keine Wartezeit mehr.

Und der Spieler kann endlich unterscheiden, was los ist. Ein `<track>`
meldet jeden Misserfolg gleich — „es gibt sie nicht", „sie enthält keinen
Text" und „der Server holt sie gerade" sahen identisch aus. Geholt wird
deshalb selbst, mit Token statt Keks (gemessen: ohne Keks kam jeder Abruf
mit 401 zurück, ohne dass irgendwo etwas stand), und bei 503 fragt der
Spieler nach, statt aufzugeben. Der Text geht als Blob an den `<track>` —
dieselbe Anzeige, ein ehrlicher Weg dahin.

Dazu eine Unsauberkeit im Verschieben: die Trennzeile eines weggefallenen
Blocks blieb stehen. Gemessen am echten Film 52 Leerzeilen vor dem ersten
Satz.

Geprüft im Spieler, kalter Vorrat, Einstieg bei Sekunde 500: Blob am
`<track>`, zehn Einblendungen, die erste bei 0 bis 3 s mit „Deutsch bei
500 s".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 22:00:06 +02:00
ScarriffleandClaude Opus 5 339a6c07d0 Ein Client darf einen Stand fortschreiben, nicht zerstören 
Ein Film stand bei 46 Minuten; nach einem Neuladen bot die Detailseite nur
noch „Abspielen" an. Gemessen am laufenden Server, was eine einzige Meldung
„Stelle 500 s, Laufzeit 60 s" anrichtet:

    Stelle        500 s  ->   60 s
    Laufzeit      600 s  ->   60 s
    gesehen        nein  ->   ja
    Weiterschauen    ja  ->   nein

Der Server beschnitt die Stelle auf die gemeldete Laufzeit, ersetzte die
richtige Laufzeit durch sie und setzte das Häkchen. Ein Film war damit weg.

Und 60 ist keine erfundene Zahl. Wer einen gerechneten Strom abspielt, misst
an einer Playlist, die noch wächst, und sieht anfangs nur einen Stummel.
Genau den meldete die App als Laufzeit — und sie meldet beim Öffnen
ausserdem die Zeit null, bevor sie überhaupt gesprungen ist.

Drei Stellen, dieselbe Regel:

- Server: die gemessene Laufzeit schlägt die gemeldete. Die Datei zuerst,
  nicht der gemerkte Wert — stünde dort schon ein Stummel, bliebe er sonst
  für immer stehen. So heilt sich ein verdorbener Eintrag von selbst.
- Server: eine gemeldete Null löscht keine gemerkte Stelle. Wer wirklich
  von vorn anfängt, verliert nichts: zehn Sekunden später meldet derselbe
  Spieler die 10, und die zählt. Zurückspulen bleibt unberührt.
- App: dieselbe Rangfolge bei der Laufzeit, und beim Öffnen wird die
  Stelle gemeldet, an der der Spieler einsteigen will, statt der Null.

Im Webspieler kam eine eigene Null dazu: bei Direktwiedergabe gibt der
Server `startSeconds: 0` zurück und der Browser springt selbst, sobald die
Metadaten da sind. Kommen sie nie, weil er mit der Datei nicht zurechtkommt,
blieb `filmzeit()` auf null — und der Rückfall aufs Umkodieren, der
ausdrücklich „an der Stelle weiter, an der es hing" meint, fing von vorn an.
Der ausstehende Sprung zählt jetzt mit.

Fünf neue Prüfungen halten die gemessenen Zahlen fest, damit die Regel nicht
wieder umkippt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 21:36:35 +02:00
ScarriffleandClaude Opus 5 51d1db4641 Zwei Uhren, und niemand hatte sie verglichen 
Untertitel zeigten auf keiner Spur Text. Der Grund: die Zeitstempel einer
WebVTT-Spur zählen ab Dateianfang, der Strom zählt ab null. Wer bei Minute
30 einstieg, bekam jeden Satz dreissig Minuten in die Zukunft geschoben —
und weil ein Strom nur bis zum Filmende reicht, erschien überhaupt keiner
mehr.

Gemessen im Spieler, vorher: „Fortsetzen ab 8:37" geklickt, deutsche Spur
gewählt, Standanzeige 8:38 — angezeigt wurde der Satz von Sekunde 0.
Versatz 515 Sekunden, also genau der Einstiegspunkt.

Nachher, derselbe Weg: Standanzeige 9:02, angezeigt „Deutsch bei 540 s".

Verschoben wird auf dem Server, nicht im Browser: dort hiesse es, die Spur
selbst zu zerlegen und als VTTCue neu aufzubauen — ein eigener Parser für
ein Format, das der Browser schon kann. Hier ist es eine Zeilenersetzung,
und sie lässt sich prüfen. Was vor dem Einstieg endet, fällt samt Text weg;
was darüber hinwegreicht, fängt bei null an.

Zwei Kleinigkeiten lagen daneben und sind mit erledigt:

- `srclang` bekam „ger".slice(0, 2) und damit „ge" — kein gültiges Kürzel.
  Jetzt bleibt das Feld leer, wenn das Kürzel nicht zweistellig ist.
- Scheiterte das Laden einer Spur, geschah nichts Sichtbares. Jetzt sagt
  es der Spieler.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 21:28:39 +02:00
ScarriffleandClaude Opus 5 57fff63516 Die Überschrift des Versatzes brach um 
„TONVERSATZ — OHNE VERSATZ" am Stück passte nicht in das schmale Menü und
stand auf zwei Zeilen — und sah damit nach zwei Dingen aus. Jetzt steht
der Name links und der eingestellte Wert rechts in derselben Zeile, der
Wert hell und ohne Versalien, damit man sieht, welches davon die
Einstellung ist. Die Liste ist dafür 230 statt 180 Bildpunkte breit —
„Ton 3 s früher" muss daneben passen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 20:44:13 +02:00
ScarriffleandClaude Opus 5 2f7768136b Der Tonversatz ist ein Regler, abgetrennt unter den Spuren 
Drei Anläufe, und du hattest jedes Mal recht.

**Er gehört ins Tonmenü** — aber sichtbar nicht zu den Spuren. Jetzt
trennt ihn ein Strich ab, darüber steht „TONVERSATZ — Ohne Versatz" als
Überschrift, darunter ein Regler. Drei Mittel, und jedes einzelne würde
schon sagen, dass das keine Sprache ist.

**Ein Regler statt Auswahlpunkten.** Feste Stufen hiessen: für jeden Wert
ein Eintrag, und die standen zwischen den Sprachen wie weitere Sprachen.
Gezogen wird von −3 bis +3 Sekunden in Hundertern; die Mitte ist als
Strich markiert, sonst trifft man die Null nur zufällig. Gerechnet wird
erst beim Loslassen, nicht beim Ziehen — jede Änderung baut den Strom neu
auf, und das tut man nicht zwanzigmal beim Hinschieben. Daneben
„Zurücksetzen", sobald etwas eingestellt ist.

**Und der Lautsprecher ist zurück.** Hier stand ein eigenes Zeichen, damit
er nicht zweimal in der Leiste auftaucht — links Stummschalten, rechts die
Tonspur. Die Wellenform erkannte aber niemand als „Ton". Zwei Lautsprecher
sind das kleinere Übel, zumal der linke beim Stummschalten
durchgestrichen wird und damit anders aussieht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 20:42:50 +02:00
ScarriffleandClaude Opus 5 dc9d1cea85 Meine Rundung war eine Klinge, und ich bin hineingelaufen 
Du hast recht, und zwar doppelt.

**Der Versatz stand im falschen Menü.** „Später (+100 ms)" unter den
Tonspuren liest sich wie der Name einer Spur. Jetzt hat er einen eigenen
Knopf in der Leiste, mit eigenem Zeichen und festen Stufen von „Ton 1 s
früher" bis „Ton 1 s später", dazwischen „Ohne Versatz" — mit Haken, wie
bei der Qualität. Im Tonmenü stehen wieder nur Sprachen.

**Und das Schlimmere: die Rundung aufs Schlüsselbild hat es verschlechtert.**
Sie musste auf die Millisekunde stimmen, sonst nimmt ffmpeg das
Schlüsselbild davor. Gemessen an einer Datei mit Schlüsselbildern alle
fünf Sekunden:

    -ss 15.015  →  Bild ab 0,000 | Ton ab 0,004
    -ss 15.014  →  Bild ab 0,000 | Ton ab 4,983

Eine Millisekunde. Und die Zeile, die den Wert an ffmpeg gibt, rundete auf
drei Nachkommastellen — bei 23,976 Bildern je Sekunde liegen
Schlüsselbilder auf Werten wie 3,336667, und die überleben das nicht
zuverlässig. Damit konnte jede Fortsetzung schlechter werden als vorher.
Das war mein Fehler, eingebaut in E8GSRE.

**Der richtige Hebel ist `-noaccurate_seek`**, und er braucht gar keine
Genauigkeit. Damit schneidet ffmpeg auch den Ton nicht auf die Sekunde,
sondern lässt ihn beim selben Schlüsselbild anfangen wie das kopierte
Bild. Gemessen, dieselbe Datei, fünf verschiedene Sprungwerte quer durch
die Bildgruppe:

    15,014 → 0,015 | 17 → 0,004 | 19,9 → 0,004 | 12,5 → 0,015 | 3,2 → 0,011

Statt bis zu fünf Sekunden also überall unter zwanzig Millisekunden, und
zwar ohne dass irgendein Wert getroffen werden muss. Fünf Testfälle quer
durch die Bildgruppe halten das jetzt fest; vorher prüfte der Sprungtest
nur, ob überhaupt Segmente entstehen.

Die Schlüsselbildsuche bleibt — aber nur noch, um dem Spieler eine
ehrliche Uhr zu geben. Vergreift sie sich, geht die Uhr falsch; Bild und
Ton bleiben zusammen. Vorher hing die Ausrichtung daran, und das war der
schlechte Tausch.

Und die Sekundenangaben gehen jetzt mit sechs Nachkommastellen hinaus
statt mit drei.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 20:24:21 +02:00
ScarriffleandClaude Opus 5 6ad4deb634 Fünf Sekunden Bild ohne Ton — jetzt weiss ich, woher 
Deine Angabe war der Schlüssel: du hast **mitten im Film die Tonspur
umgeschaltet**. Dabei baut der Spieler den Strom an der aktuellen Stelle
neu auf, und damit greift der Sprung — den ich gestern nur mit
Spielzeugdateien gemessen hatte.

Also eine Datei gebaut, die einem Film gleicht: 23,976 Bilder je Sekunde,
Schlüsselbild alle fünf Sekunden, zwei Tonspuren, Deutsch als Stereo-AAC
und Englisch als 5.1 in EAC3. Gemessen, erster Zeitstempel je Spur:

| | Bild ab | Ton ab |
|---|---|---|
| Spur 2, ab Sekunde 0 | 0,021 | 0,000 |
| Spur 2, ab 17 (mitten in der Bildgruppe) | 0,000 | **1,964** |
| Spur 2, ab 15 (knapp vor dem Schlüsselbild) | 0,000 | **4,969** |

Fast fünf Sekunden Bild ohne Ton. Zueinander sind beide dabei richtig
getaktet — aber eine solche Lücke am Anfang darf jeder Spieler deuten, wie
er will, und hls.js schiebt den Ton dann nach vorn. Genau das hast du
gehört.

Die Rundung auf das Schlüsselbild, die seit E8GSRE drin ist, nimmt das
weg: dieselbe Datei, Sprung auf 17, gerundet auf 15,015 — **Bild ab 0,000,
Ton ab 0,004**. Du läufst noch auf 5YZ63F; deshalb steht im Protokoll auch
keine ffmpeg-Warnung, die gibt es erst ab E8GSRE.

**Die Tonspur lässt sich jetzt vor dem Start wählen.** Auf der
Detailseite steht neben „Abspielen" ein Knopf „Ton: Deutsch"; das Menü
zeigt alle Spuren der Datei. Gemerkt wird dabei die **Sprache**, nicht die
Spurnummer — welche Nummer Englisch trägt, ist von Film zu Film
verschieden, dass du Englisch willst, ist es nicht. Beim nächsten Film
steht die passende Spur damit schon da, und das Umschalten mitten im Film
entfällt. Wer doch im Spieler wechselt, ändert dieselbe Merkstelle.

**Und ein Fehler aus deinem Protokoll**, der nichts damit zu tun hat:
„UNIQUE constraint failed: Sehtage.UserId, Sehtage.Tag, Sehtage.MovieId".
Das ist ein Wettlauf im Sehprotokoll von vorgestern — der Spieler meldet
alle zehn Sekunden, ein Sprung meldet sofort, und zwei Meldungen können
sich überholen. Dann fanden beide keine Zeile, beide legten eine an. Jetzt
wird in der Datenbank hochgezählt statt im Speicher, und wer dabei zu spät
kommt, zählt beim zweiten Versuch mit. Mit Test.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 20:09:46 +02:00
ScarriffleandClaude Opus 5 cf272f20aa Ton und Bild: ein Versatz zum Einstellen, und zwei gemessene Fehler weniger 
Du meldest Ton, der drei, vier Sekunden neben dem Bild liegt.
**Nachstellen konnte ich es nicht** — und das sage ich lieber, als eine
Vermutung als Befund zu verkaufen.

Gemessen habe ich alle vier Wege, jeweils mit ffprobe am Ergebnis, erster
Zeitstempel je Spur:

| Weg | Bild ab | Ton ab |
|---|---|---|
| Umpacken, ab 0 | 0,021 | 0,000 |
| Umpacken, ab 12 | 0,000 | 1,979 |
| Umkodieren, ab 0 | 0,021 | 0,000 |
| Umkodieren, ab 12 | 0,021 | 0,000 |

Alle vier sind **zueinander richtig**. Auch eine Quelle mit einem echten
Loch in der Tonspur blieb ausgerichtet. Die naheliegende Erklärung — `-ss`
vor `-i` mit kopiertem Bild und neu gerechnetem Ton — ist damit widerlegt.

**Zwei echte Fehler hat dieselbe Messung aber gefunden**, und beide sehen
aus wie „um Sekunden daneben":

Zeile zwei der Tabelle. Beim Umpacken fängt das Bild beim Schlüsselbild
*vor* dem Sprung an, der Ton genau beim Sprung — bei Sekunde 12 also zwei
Sekunden Bild **ohne Ton** am Anfang. Zueinander stimmen beide, aber jeder
Spieler darf diese Lücke deuten, wie er will. Und der Server meldete dem
Spieler „beginnt bei 12", obwohl er bei 10 beginnt: die Uhr, die
Zeitleiste und der gespeicherte Stand lagen um diesen Unterschied daneben.

Beides geht weg, indem der Sprung **auf das Schlüsselbild gerundet** wird
und derselbe Wert zurückgemeldet wird. Dann fangen Bild und Ton zusammen
an, es gibt keine Stille davor, und die Uhr stimmt. Beim Umkodieren
entfällt das Runden — dort schneidet das neu gerechnete Bild genau.

**Und: ffmpeg durfte bisher nichts sagen.** `-loglevel error` versteckt
genau die Meldungen, die einen Tonversatz ankündigen, und der
Fehlerkanal wurde bei Rückgabewert 0 weggeworfen. Jetzt steht er auf
`warning`, und Warnungen landen auch bei einem geglückten Lauf im
Protokoll. Wenn es bei dir wieder auftritt, steht diesmal etwas da.

**Der Versatz zum Einstellen** sitzt im Tonmenü des Spielers: „Später"
und „Früher" in Hundertmillisekundenschritten, bis ±5 s, dazu
„Zurücksetzen". Gemerkt wird er **je Datei in diesem Browser** — ein
Versatz ist meist eine Eigenschaft der Datei, kann aber auch an der
Anlage liegen, und über Bluetooth stimmt etwas anderes als am Fernseher.

Verschoben wird serverseitig: die Datei wird ein zweites Mal mit
`-itsoffset` geöffnet und von dort nur der Ton genommen. Mit einer
Eingabe verschöbe sich beides gemeinsam. Der Preis: der Strom startet neu,
und eine durchgereichte Datei muss dafür umgepackt werden — ohne ffmpeg
lässt sich nichts verschieben.

Zwei neue Läufe halten das fest: dass Bild und Ton zusammen anfangen, und
dass ein halbe-Sekunde-Versatz den Ton um eine halbe Sekunde verschiebt
und das Bild gar nicht. Der Sprungtest daneben lief bisher genau durch
diesen Fall und sah nur nach, ob überhaupt Segmente entstehen.

Ein Test musste umgeschrieben werden: er stand auf „Einstiegspunkt ist
genau 2" und hielt damit die falsche Meldung fest.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 19:37:21 +02:00
ScarriffleandClaude Opus 5 3fe0013be1 Die Auflösung wechselt den Text, statt einen Tooltip zu öffnen 
Gestern wanderte der genaue Wert in den Tooltip. Ein Tooltip kommt
verzögert, legt sich über die Nachbarzeile und existiert am Finger gar
nicht. Jetzt steht in Ruhe „Full HD" da, und beim Überfahren tritt
„1080p · 1920 × 800" an dieselbe Stelle.

**Beide liegen übereinander, nicht nacheinander.** Das Feld ist so breit
wie der breitere der beiden Texte — sonst rückte beim Überfahren die halbe
Tabelle. Gerastert statt absolut gesetzt, damit die Zeilenhöhe von selbst
stimmt.

Ohne Zeiger gibt es kein Überfahren: dort steht das Genaue dauerhaft
daneben, statt unerreichbar zu sein.

Gemessen: in Ruhe „Full HD" bei Deckung 1 und „1080p · 1920 × 800" bei 0,
unter dem Zeiger umgekehrt — und kein `title` mehr am Element.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 18:32:21 +02:00
ScarriffleandClaude Opus 5 cdea8e3b0a Die Höhe des Aufmachers ist jetzt einstellbar 
Vier Stufen unter Einstellungen → Verwaltung → Übersicht: niedrig, mittel,
hoch, sehr hoch. Mittel ist, was gestern fest verdrahtet war.

**Keine Pixelzahl.** Eine einzustellen hiesse, sie an jedem Bildschirm neu
einzustellen — der Aufmacher misst sich an der Fensterhöhe, nicht an einer
festen Grösse. Gemessen bei 800 Bildpunkten Fensterhöhe: 496, 576, 656,
736. Oben ist Schluss, bevor von der ersten Plakatreihe nichts mehr übrig
bleibt; sie soll zeigen, dass unten noch etwas kommt. Am Telefon bleibt es
flacher, dort wäre auch das weg.

**Sie reist mit der Systemauskunft mit**, nicht in einer eigenen Abfrage.
Die holt der Client ohnehin als Erstes, noch vor der Anmeldung; käme die
Höhe später, stünde der Aufmacher einen Augenblick in der Vorgabe und
spränge dann — genau das, was eine einstellbare Höhe vermeiden soll.
Gesetzt wird sie als Marke am `<html>`, das Regelwerk hängt vier Werte
daran.

Serverweit und nur für Admins, dieselbe Linie wie bei den
Wiedergaberegeln: eine Entscheidung des Gastgebers, nicht des Gastes.
Unbekanntes in der Spalte wird zur Vorgabe statt zu einem Fehler — eine
Startseite, die an einem alten Eintrag scheitert, wäre die schlechtere
Antwort.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 18:32:10 +02:00
ScarriffleandClaude Opus 5 a7a4419626 Adminrecht geben und nehmen — und einen, dem es niemand nimmt 
Ein Konto liess sich anlegen und danach nie wieder ändern: kein Weg zum
Administrator, keiner zurück, keiner zum Löschen. Mit Einladungslinks
füllte sich der Server also in genau eine Richtung.

**Warum es einen Besitzer braucht.** Sobald Administratoren einander das
Recht entziehen können, gibt es einen Zustand ohne jeden Administrator —
und aus dem führt kein Weg zurück ausser dem an der Datenbank. Ein Konto,
das ausgenommen ist, schliesst ihn aus. Es ist das erste, also das, mit
dem eingerichtet wurde; die Migration trägt das auf bestehenden Servern
nach, und weil die Kennungen zeitlich geordnet vergeben werden, ist der
Älteste schlicht der mit der kleinsten.

Weitergeben lässt er sich: vom Besitzer, an einen Administrator, mit
Rückfrage. Nur an einen Administrator, sonst wäre der Server einen Klick
von einem Besitzer entfernt, der die Verwaltung gar nicht sieht.

**Drei Türen sind zugemauert**, und jede hat ihren Test: dem Besitzer das
Recht nehmen, den Besitzer löschen, sich selbst das eigene Recht nehmen.
Das letzte ist die unauffälligste — wer sich im Eifer entmachtet, steht
vor einer Verwaltung, die er nicht mehr öffnen kann, und das Zurücknehmen
braucht genau die.

Gemessen und als Test festgehalten: ein frisch vergebenes Adminrecht gilt
**sofort**, ohne neue Anmeldung. Die Rolle wird je Anfrage aus der
Datenbank gelesen und nicht aus dem Token — ich hatte das Gegenteil
befürchtet.

Löschen nimmt mit, was am Konto hing: Geräte, Sehstände, Sehprotokoll,
Meldungen, offene Einladungen. Alles hängt mit `Cascade` daran. Zahlen
über jemanden zu führen, den es nicht mehr gibt, wäre die schlechtere
Hälfte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 18:31:05 +02:00
ScarriffleandClaude Opus 5 d5e21d663f Einladen, statt sich für jemanden ein Passwort auszudenken 
Ein Konto von Hand anzulegen heisst: sich für einen anderen ein Passwort
ausdenken und es ihm durchsagen — über denselben Kanal, über den auch ein
Link gegangen wäre. Jetzt gibt es den Link. Wer ihn öffnet, wählt Namen
und Passwort selbst und ist danach angemeldet.

Gültigkeit und Anzahl wählst du beim Erstellen: einen Tag bis einen Monat,
einmal bis unbegrenzt. **Eine Rolle wählst du nicht** — wer eingeladen
wird, ist gewöhnlicher Benutzer. Ein Feld, über das ein Link Adminrechte
verschenken könnte, gibt es gar nicht, und damit auch keinen Weg, es
versehentlich zu setzen.

**Der Link steht genau einmal da.** Gespeichert ist nur sein
Fingerabdruck, wie beim Gerätetoken; aus der Liste lässt sich keiner mehr
bauen. Eine verlorene Einladung wird deshalb nicht wiedergefunden, sondern
neu gemacht. Und gebaut wird die Adresse im Browser: der Server weiss
nicht, unter welchem Namen er von aussen erreichbar ist, und hinter einem
Reverse Proxy rät er falsch.

**Das Rennen beim Einlösen.** Zwei Leute, die gleichzeitig denselben
einmaligen Link öffnen, läsen beide „null benutzt" und schrieben beide
„eins" — und hätten beide ein Konto. Der Zähler geht deshalb mit einer
Bedingung hoch, die die Gültigkeit noch einmal prüft; wer dabei keine
Zeile trifft, war der Zweite. Das Ganze in einer Transaktion, damit ein
Tippfehler im Namen den Link nicht verbrennt. Beides steht als Test da —
zwei gleichzeitige Einlösungen ergeben genau ein Konto.

**Angelegt wird, angemeldet wird danach gewöhnlich.** Derselbe Zweischritt
wie beim Einrichten, und der Grund ist nicht Bequemlichkeit: die Anmeldung
setzt den Sitzungskeks, und ohne den lädt kein Plakat — Bilder weisen sich
über ihn aus, nicht über das Token. Gemessen beim Durchspielen: nach dem
Einlösen kommt ein Bild mit 200 zurück.

**Die Weiche liegt im Hochfahren, nicht im Router.** Der Router läuft nie,
wenn niemand angemeldet ist — ein Ausgeloggter mit Einladungslink sähe
sonst die Anmeldekarte und landete nach dem Anmelden auf der Startseite,
ohne je erfahren zu haben, wozu er eingeladen war. Nach dem Einrichten,
damit ein nagelneuer Server zuerst seinen Administrator bekommt.

Wer schon angemeldet ist, bekommt kein Formular, sondern den Hinweis und
zwei Wege. Und die Gründe einer Ablehnung sind verschieden benannt:
abgelaufen, zurückgezogen, schon benutzt. Verschwiegener wäre ein
einheitliches „gilt nicht" — und dann fragt der Eingeladene nach, und der
Gastgeber rät mit.

Nebenbei korrigiert: die Erkundung meinte, dem Benutzernamen fehle ein
eindeutiger Index. Er hat einen, seit der ersten Migration, sogar mit
`NOCASE`. Das Namensrennen war also nie offen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 17:23:25 +02:00
ScarriffleandClaude Opus 5 c65356c16f 4K, Full HD, HD, SD — die Zahl steht beim Überfahren 
„1080p" ist eine Angabe für den, der eine Stufe einstellt. Wer sich fragt,
ob es sich lohnt, dafür den Fernseher anzumachen, liest „Full HD". Die
Zeile sagt jetzt das Wort, der Tooltip den genauen Wert und die gemessene
Grösse: `1080p · 1920 × 800`.

**Es gab zwei Leitern, und sie waren sich uneinig.** `Benennung.AusHoehe`
machte aus 2160 ein „2160p", `FileNames.FassungAusHoehe` ein „4K" — auf
derselben Detailseite stand beides übereinander, ein paar Zeilen
auseinander. Die zweite ist weg; sie hatte ausserdem nur die Höhe und
vergab sich damit beim Kinoformat.

Gemessen an zwei echten Dateien: 1920×800 heisst „Full HD" (nur an der
Höhe gemessen hiesse es „HD", und daneben stünde ein 1280×720 mit
demselben Wort), 720×576 heisst „SD".

**1440p fällt unter Full HD.** „QHD" kennt kaum jemand, und ein fünftes
Wort für etwas zwischen zwei bekannten hilft beim Entscheiden nicht.
„8K" steht nur da, damit eine 8K-Datei nicht als 4K gemeldet wird.

**Der Client zerlegt nichts mehr.** Er las die Stufe bisher mit
`display.split(' · ')[0]` heraus — richtig, solange vor der Auflösung nie
etwas anderes steht. Jetzt kommen Wort und genauer Wert als eigene Felder.

**Die Fassung wird nicht mehr gespeichert, sondern gerechnet.** Sie stand
in der Spalte und war damit das, was beim letzten Scan galt: ein neues
Wort hätte keine bestehende Zeile erreicht. Jetzt hält die Spalte nur
noch, was im Dateinamen stand („Mobil"), und die Messung kommt frisch
dazu. Eine Migration räumt die alten gerechneten Werte weg.

**Nicht angefasst:** was eine *gewählte* Stufe ist statt einer gemessenen
— die Umkodierleiter, der Qualitätswähler im Spieler, die Stufen in den
Apps. Wer eine Stufe wählt, wählt eine Zahl.

Die Apps rechnen sich das Wort ohnehin selbst aus und sagen seit jeher
„4K" und „Full HD"; der Server ist ihnen jetzt angeglichen, nicht
umgekehrt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 17:13:23 +02:00
ScarriffleandClaude Opus 5 168fcdfb4c Der Aufmacher war dir zu niedrig 
`min(62vh, 560px)` → `min(72vh, 640px)`. Bei 800 Bildpunkten Fensterhöhe
gemessen: 576 statt 496, und die erste Plakatreihe lugt mit ihrem Beginn
bei 648 weiterhin über den Falz — sie soll ja zeigen, dass unten noch
etwas kommt.

Am Telefon bleibt es bei `min(52vh, 420px)`: dort ist der Aufmacher im
Verhältnis zum Bildschirm ohnehin höher.

Ein Satz musste mit, und der ist tragend: die Begründung, warum das
Aufklappen der Inhaltsangabe nicht schaukelt, nennt die feste Höhe
wörtlich. Die Zahl wird falsch, das Argument bleibt richtig.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 17:13:06 +02:00
ScarriffleandClaude Opus 5 8e9da1355c Der Server schrieb deutsche Sätze an eine Stelle, die niemand liest 
„Die Anfrage war so nicht zu gebrauchen" — das ist der Ersatzsatz des
Browsers für eine Ablehnung ohne Begründung. Dabei stand die Begründung
da: „Benutzername darf nicht leer sein, das Passwort braucht mindestens 8
Zeichen." Nur eben in `errors`, und beide Clients lesen `detail`.

Zwei Formen waren betroffen. `Results.ValidationProblem` legt den Satz
unter `errors` ab, `Results.BadRequest(new { fehler = … })` unter
`fehler` — in beiden Fällen kommt er nirgends an. Zusammen 36 Stellen,
darunter jede Zeile, die ich gestern für die Meldungen geschrieben habe.
Dass die Clients `title` und `errors` auslassen, ist dabei richtig: dort
stehen sonst die englischen Prüftexte des Rahmenwerks, und „Not Found" ist
keine Auskunft.

Jetzt eine Form, hinter `Einwand.Bitte` / `.Fehlt` / `.Belegt`. Dass es
drei benannte Türen sind statt eines Aufrufs mit Zahl, hat einen Grund:
man sieht am Wort, ob der Server um eine bessere Eingabe bittet, etwas
nicht findet oder auf etwas Bestehendes stösst.

**Auffallen konnte es nicht**, und das ist der eigentliche Fund. Die
vorhandenen Tests prüften den Rumpf als Zeichenkette — der Satz *stand* ja
drin, nur im falschen Feld. Der neue Test prüft deshalb, in welchem Feld,
und ein Wächter am Quelltext schlägt an, wenn eine der beiden alten Formen
zurückkommt. Er hat beim ersten Lauf gleich eine Stelle gefunden, die mein
Suchmuster übersehen hatte.

Dazu drei Kleinigkeiten, die beim Lesen auffielen:

**Passwörter wurden getrimmt.** Der Dialog schnitt jedem Feld die Ränder
ab, auch dem Passwort — `login.ts` sendet es ungeschoren. Ein Leerzeichen
am Ende, und das angelegte Konto war für immer unbetretbar.

**Beim Einrichten stapelten sich die Fehlerzeilen**, weil `.error`
weggeräumt wurde und `.fehler` entsteht. Drei Fehlversuche, drei rote
Kästen.

**Der Benutzerdialog versprach acht Zeichen und prüfte nichts.** Jetzt
sagt er es selbst, ohne den Umweg über die Leitung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-07 17:12:57 +02:00
ScarriffleandClaude Opus 5 7cd48f5528 Wer etwas sieht, kann es jetzt auch sagen 
Wer einen Server für andere betreibt, erfährt von Fehlern zuletzt: dass
die deutsche Tonspur nach einer halben Stunde aussetzt, merkt der, der den
Film sieht, und nicht der, der ihn eingeräumt hat. Bisher gab es dafür
keinen Weg ausser dem Zuruf im Wohnzimmer.

Gemeldet wird an einem Film, einer Serie, einer einzelnen Staffel und
einer einzelnen Folge: Art (Bild, Ton, Untertitel, Angaben, Sonstiges),
eine freiwillige Stelle wie 0:34:12 und der Kommentar. Pflicht ist nur der
Kommentar — die beiden anderen machen aus einer Liste von Sätzen etwas,
das man sortieren und nachstellen kann.

**Eine Staffel gibt es als Zeile nicht**, und das prägt den Entwurf. Sie
ist Serie plus Nummer, so wie überall sonst in diesem Server; die Meldung
trägt deshalb drei Fremdschlüssel und daneben eine Staffelnummer. Dass die
Nummer auf eine Staffel zeigt, die es gibt, prüft der Endpunkt beim
Schreiben — die Datenbank kann es nicht, es gibt nichts, worauf sie zeigen
könnte.

**Die Rechteprüfung steht nirgends.** Wer einen Titel nicht sehen darf,
findet ihn beim Melden nicht — das erledigt der Freigabefilter, ohne ein
einziges `Where`. Elegant und genau deshalb leicht zu zerstören, darum
steht dafür ein Test da.

**Die eigene Liste überlebt fremde Entscheidungen.** Titel werden
nachgeschlagen, nicht verbunden: zieht ein Administrator einen Titel
zurück, nachdem jemand ihn gemeldet hat, bleibt die Meldung beim Melder
stehen — nur ohne Namen. Ein Join hätte sie verschwinden lassen, und das
wäre jemandes eigene Eingabe, weggenommen wegen einer fremden Entscheidung.
`IgnoreQueryFilters` wäre die bequeme Abkürzung und gäbe den Namen eines
unveröffentlichten Titels über einen Weg heraus, an den beim nächsten Mal
niemand denkt.

**Erledigt heisst abgehakt, nicht gelöscht**, als Zeitpunkt und nicht als
Haken — wie `PublishAt` und `ChangedSince`. Daneben steht „Wieder öffnen";
ein Fehlgriff wäre sonst endgültig. Das Archiv wird erst auf Zuruf geholt:
es wächst nur, und für den seltenen Blick dauernd zu zahlen lohnt nicht.

**Der Abschnitt steht neben der Prüfliste, nicht darin.** Die versteckt
sich, sobald nichts auf Freigabe wartet — das ist der Normalfall, und die
Meldungen verschwänden mit ihr. Umgekehrt bleibt der Meldungsabschnitt
stehen, auch wenn nichts drinsteht: ein Kanal, der sich versteckt, solange
ihn niemand benutzt hat, bringt niemandem bei, dass es ihn gibt.

Die Zahl an der Leiste holt sich nur, wer sie nicht ohnehin hat: steht „Zu
prüfen" offen, meldet der Abschnitt sie selbst und nach jedem Abhaken.

Nebenbei zwei Dinge am Dialog, die hier auffielen. Es gab **kein
mehrzeiliges Feld** — und das Einsammeln der Werte hätte ein `<textarea>`
still verschluckt: es ist kein `HTMLInputElement` und wäre ins Auffangnetz
für Auswahlfelder gelaufen, also als `undefined` hinausgegangen. Der
Server hätte „ohne Beschreibung" geantwortet, auf einem Dialog, in dem
sichtbar etwas steht. Und `dialog()` meldete sich als einziger nicht beim
Seitenwechsel an: ein Dialog von der Detailseite überlebte den
Zurück-Knopf und stand danach über der Mediathek.

Neun Testfälle auf dem Server, zwölf Läufe. Für den Web-Client gibt es in
diesem Projekt keine Tests; dort ist von Hand geprüft.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 22:18:14 +02:00
ScarriffleandClaude Opus 5 02978e482c Die Knöpfe bleiben, die Inhaltsangabe klappt auf 
Ich hatte „die Beschreibung nur beim Hovern" gelesen und daraufhin
Beschreibung *und* Knöpfe ausgeblendet. Die Knöpfe gehören immer dahin: in
Ruhe steht oben, was läuft und was man damit tun kann.

Die Inhaltsangabe dagegen steht erst da, wenn man es will. Zwei Sekunden
auf dem Titel stehenbleiben, dann fährt er hoch und darunter klappt sie
auf; wer nur vorbeifährt, sieht nichts. Gibt es keine, passiert gar
nichts — der Absatz fällt dann ganz aus dem Fluss.

**Angefasst wird am Titel, losgelassen am ganzen Aufmacher.** Das ist die
ganze Vorsicht an dieser Stelle. Beim Aufklappen wächst der Block nach
oben, der Titel rückt um 77 Bildpunkte weg und steht nicht mehr unter dem
Zeiger. Hinge das Zuklappen an seinem `:hover`, wäre das die erste Hälfte
einer Schaukel. Der Aufmacher selbst kann das nicht: gemessen, offen wie
zu, 476 px hoch ab 48 — auf den Bildpunkt derselbe Kasten.

**Die Höhe wird gemessen, nicht geraten.** Nach `auto` lässt sich nicht
überblenden, und eine feste Obergrenze wäre bei einer einzeiligen Angabe
zu drei Vierteln Leerlauf. Gemessen wird bei jedem Folienwechsel und bei
jeder Fensteränderung; `scrollHeight` ginge nicht, der meldet bei einem
`-webkit-box` die ungeklammerte Höhe.

**Der Rasterabstand wandert mit.** Gemessen: zugeklappt stehen zwischen
Eckdaten und Knopfzeile 16 px — mit Inhaltsangabe wie ohne, und genau so
viele wie vorher. Aufgeklappt sind es 12 über und 16 unter dem Text, und
die Knopfzeile steht still (Unterkante 492 in beiden Zuständen).

Nebenbei kommt das Abbruchsignal endlich an: `hero()` nahm eines
entgegen, aber `main.ts` baute die Startseite ohne. Sie wird gemerkt — ihr
Neun-Sekunden-Takt lief also weiter, während man längst woanders war.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 22:05:44 +02:00
ScarriffleandClaude Opus 5 ac9faacefb Im Aufmacher steht in Ruhe nur, was läuft 
Inhaltsangabe und Knöpfe blenden sich beim Überfahren ein und wieder aus.
In Ruhe bleibt oben nur, *was* läuft — Schriftzug oder Name, Jahr,
Laufzeit, Freigabe. Was man damit tun kann und worum es geht, kommt auf
Zuruf. So ist das Bild in Ruhe ein Bild und nicht eine Wand aus Text
darüber.

**Langsamer herein als hinaus**, 340 gegen 220 Millisekunden: das
Erscheinen soll man sehen, das Verschwinden nicht abwarten müssen. Die
Pfeile gehen denselben Takt mit; sie standen auf 150 ms und blitzten
dagegen auf.

**Der Platz bleibt reserviert.** Mit `display: none` spränge beim ersten
Überfahren der ganze Block nach oben; geschaltet wird nur die Deckung.
Gemessen an derselben Folie: 349,2 px hoch mit Deckung 0, 349,2 px mit
Deckung 1.

**Der Terminhinweis bleibt stehen.** „Ab Di., 6. Okt., 18:00 Uhr" ist
keine Handlung, sondern die Auskunft, warum hier nichts zu drücken ist —
die darf nicht erst auf Zuruf kommen. Darum trifft die Regel `.btn` und
nicht die ganze Knopfzeile.

**Der Fokus zählt wie der Zeiger.** Ein Knopf, der unsichtbar den Fokus
bekommt, ist eine Sackgasse. Gemessen, mit abgeschalteten Übergängen:
in Ruhe alles auf 0; Fokus im Aufmacher — Text 1, beide Knöpfe 1, beide
Pfeile 0,72; nach dem Verlassen wieder 0.

`hover: hover` wie bei den Pfeilen: ohne Zeiger gäbe es kein Überfahren,
und „Abspielen" wäre nicht mehr erreichbar. Dort steht alles wie immer.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 21:15:39 +02:00
ScarriffleandClaude Opus 5 3a0afa918d Die Pfeile im Aufmacher warten, bis man hinzeigt 
Sie liegen über dem Bild und damit über allem, was dort steht. Bei einem
einzeiligen Titel geht das gut. „Pirates of the Caribbean — Salazars
Rache" bricht um, die erste Zeile rückt nach oben — und der linke Pfeil
sitzt auf dem ersten Buchstaben.

Ständig sichtbar ist er dort ein Fleck, auf Zuruf ein Knopf. Also
erscheinen beide erst beim Überfahren des Aufmachers, in 150 ms, und
verschwinden wieder.

`hover: hover` ist dabei die ganze Vorsicht: auf einem Tablett gibt es
kein Überfahren, und ein Knopf, der nur dabei erscheint, wäre dort
schlicht nicht erreichbar. Dort bleibt alles, wie es war — unter 860
Bildpunkten gibt es die Pfeile ohnehin nicht, da wird gewischt.

Gemessen: in Ruhe Deckung 0, kein Zeigerziel. Zeiger über dem Aufmacher:
0,72 und anklickbar. Zeiger auf dem Pfeil: 1, dunklerer Grund, und der
Klick blättert tatsächlich weiter (Tastatur-Tabulator vom Knopf „Mehr"
aus: Deckung 1, `:focus-visible` greift, Umriss 2 px) — `pointer-events:
none` hält nur den Zeiger ab, nicht den Fokus.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 21:03:30 +02:00
ScarriffleandClaude Opus 5 ffc4bbe597 Ein Viertel des Hintergrundbildes lag hinter der Seitenleiste 
Es stand auf `inset: 0` und lag damit auch hinter Seiten- und Kopfleiste —
beide undurchsichtig. Bei 1280×800 gemessen: 18,8 % der Breite, 7 % der
Höhe, zusammen 24,4 % der Bildfläche, die niemand je zu sehen bekam.

Solange alles weichgezeichnet war, fiel das nicht auf; ein verwischter
Rand sieht wie jeder andere aus. Scharf beginnt der Inhalt mitten im
Motiv — bei den Bergrettern mit einem angeschnittenen Kopf direkt an der
Kante der Seitenleiste.

Jetzt sitzt das Bild in dem Feld, in dem es auch zu sehen ist, und wird
darin ganz zugeschnitten: links die Seitenleistenbreite, oben die
Kopfleistenhöhe. Der Kontrast bleibt, wo er war — 3,95∶1 scharf statt
3,97∶1, derselbe Zuschnitt in einem anderen Feld.

Am Telefon gibt es keine Seitenleiste; dort nimmt die Navigationszeile
oben noch einen Streifen weg, solange man ganz oben steht, und ist nach
dem ersten Bildlauf weg.

Die beiden älteren Begründungen über der Regel standen noch da und sagten
inzwischen das Gegenteil — die eine erklärte, warum das Bild über die
volle Breite gehört. Sie sind zu einer zusammengefasst, die den ganzen Weg
erzählt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 20:16:17 +02:00
ScarriffleandClaude Opus 5 3c7c0d8799 Der Hintergrund wird erst weich, wenn etwas darüberläuft 
Er war es immer: 28 Bildpunkte Weichzeichnung über die ganze Detailseite,
damit der Text darüber lesbar bleibt. Oben steht aber gar nichts darüber —
dort ist das Bild das Beste, was die Seite zu bieten hat, und es lag als
Farbschlieren da. Unscharf gehört es erst, wenn wirklich etwas darüber
hinwegläuft: die Folgen, die Besetzung, die Medienangaben.

Jetzt folgt die Weichzeichnung dem Bildlauf, über etwa siebzig Prozent
einer Bildschirmhöhe und quadratisch statt geradlinig — die ersten
Bildpunkte sollen nichts tun, sonst wäre „scharf, solange nichts
darüberliegt" nach einem Fingerbreit schon dahin. Gerundet auf ganze
Bildpunkte, weil jeder neue Wert eine bildschirmfüllende Fläche neu
zeichnen lässt; über die ganze Strecke sind das 28 Male. Gemessen über 58
Bilder beim Hinunterrollen: 8,3 ms im Mittel, kein Bild über 9,2 ms.

**Und die Deckung geht mit, das ist der unscheinbare Teil.** Eine
Weichzeichnung verrührt die hellen Stellen mit den dunklen; ein scharfes
Bild hat die weisse Stelle genau dort, wo die Zeile steht. Gemessen an der
dunklen Vorlage von „Dark": vorher 4,07∶1, scharf bei derselben Deckung
nur noch 2,44∶1. An einer hellen — Hubschrauber vor blauem Himmel —
vorher 2,75∶1. Mit 0,28 scharf und 0,45 weich stehen beide wieder bei rund
4,0∶1, die helle sogar besser als zuvor.

Der Zuhörer räumt sich selbst ab: die Detailseite wird nicht gemerkt, und
für ungemerkte Ansichten ruft `einhaengen` kein Abbruchsignal.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 19:53:25 +02:00
ScarriffleandClaude Opus 5 6dc7be9822 Ein eigenes Bild bringt auch seinen Ausschnitt mit 
Hochladen konnte man Plakat, Hintergrund und Schriftzug schon lange — der
Knopf stand da, der Endpunkt nahm an. Nur ankommen tat nichts: die Ablage
baute einen Schlüssel, den sie selbst nicht wiederfand (heute früh
repariert). Was blieb, waren drei Lücken, die man erst sieht, wenn der Weg
überhaupt funktioniert.

**Der Ausschnitt.** Ein Plakat steht hochkant im Verhältnis 2∶3, ein
Hintergrund liegt quer. Was man aussucht, passt selten von selbst — und
den Rest beschnitt bisher der Browser beim Anzeigen: mittig. Jetzt wählt
man selbst, zieht und vergrössert, und hochgeladen wird genau dieser
Ausschnitt: 600×900 beim Plakat, 1920×1080 beim Hintergrund. Gerechnet
wird im Browser; das spart die Leitung und dem Server eine Bildbibliothek.

**Der Schriftzug nicht.** Er ist ein PNG mit durchsichtigem Grund. Durch
dieselbe Mühle geschickt würde aus der Durchsicht ein weisses Rechteck —
ein Aufkleber über dem Bild. Er geht unverändert hinaus, Byte für Byte.

**Die Kachel merkte nichts.** Nach dem Hochladen fehlte der Anstoss nach
aussen; die Oberfläche zeigte weiter das alte Bild, bis man sie neu lud.

**Und zurück ging es gar nicht.** „Von Hand gesetzt" heisst auch: beim
Auffrischen bleibt es stehen. Ohne Rückweg wäre ein Fehlgriff ein
Dauerzustand — jetzt steht „Wieder automatisch" daneben, sobald etwas
festgesetzt ist.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 19:41:04 +02:00
ScarriffleandClaude Opus 5 327e2e9195 Einstellungen hat jeder, Verwaltung nicht 
Die Seite hiess „Verwaltung" und war für alle anderen gar nicht
erreichbar — „Meine Sprache" lag dadurch hinter einer Tür, die den meisten
verschlossen ist. Jetzt heisst sie **Einstellungen**, steht jedem offen und
hat zwei beschriftete Gruppen: oben, was einem selbst gehört (Mein Konto,
Geschaut), darunter — nur für Administratoren — **Verwaltung**. Die
Überschrift ist hier die halbe Aussage: sie sagt ohne weiteren Satz, wem
der untere Teil gehört.

In der Hauptleiste steht der Eintrag jetzt unten, ohne Gruppenüberschrift.
Eine Überschrift über einem einzigen Eintrag ist eine Überschrift über
nichts, und am Fuss sucht man Einstellungen ohnehin. `#/profil` und
`#/verwaltung/…` leiten weiter; ein Lesezeichen merkt davon nichts.

**Ein kurzes Menü am Bild.** Erst meldete der Klick ab — ohne Rückfrage.
Dann führte er auf die eigene Seite, und zum Abmelden musste man erst
dorthin. Beides sind zwei Punkte; ein Menü mit zwei Punkten ist ehrlicher
als eine Tür, hinter der eine zweite liegt.

**Und das Profilbild lässt sich zuschneiden.** Ein Profilbild ist rund,
was hochgeladen wird selten quadratisch — den Ausschnitt dem Browser zu
überlassen hiesse: mittig, und das trifft bei einem Porträt den Hals. Der
Dialog zeigt den runden Ausschnitt, man zieht und vergrössert, und
hochgeladen wird genau das: ein Quadrat von 512 Pixeln. Gemessen, es kommt
auch so an.

**Dazu die Spielerleiste.** Beide Knopfgruppen durften schrumpfen, ihre
Knöpfe aber nicht — wird es eng, steht der äusserste halb hinter dem
Fensterrand. Rechts sind es nur Knöpfe, da gibt es nichts nachzugeben;
links schon. Dazu seitlich `env(safe-area-inset-*)`, damit auf einem Gerät
mit runden Ecken nichts darunter liegt. Gemessen: vorher riss es ab 420
Pixeln, jetzt bis 320 nicht mehr.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 18:24:44 +02:00
ScarriffleandClaude Opus 5 9c2e2b5f47 „Kenne ich" heisst nicht „kann ich diese Datei" 
Der Spieler schickte sein Profil aus `canPlayType` — und das ist eine
Auskunft des `<video>`-Elements. Ein Strom läuft aber nicht durch das
Element, sondern durch den MSE-Puffer, und die beiden sind sich nicht
einig.

Gemessen in Chromium:

| | canPlayType | MediaSource.isTypeSupported |
|---|---|---|
| `audio/flac` | probably | **false** |
| `audio/mp4; codecs="mp3"` | probably | **false** |

Der Server glaubte dem Profil, packte die Datei pflichtschuldig um und
liess die Spur unberührt — und der Browser stand vor etwas, das er nach
eigener Auskunft können müsste. Heraus kam „Dieser Browser kann die
Spuren dieser Datei nicht öffnen".

Jetzt zählt ein Codec nur, wenn **beide** Auskünfte ihn bestätigen; welcher
der beiden Wege es wird, entscheidet der Server erst danach. Und geprüft
wird jeder Typ in der Form, in der er wirklich ankommt — `audio/mp4` und
nicht `audio/flac`: genau dieser Unterschied entschied bei FLAC zwischen
„geht" und „geht nicht". Gemessen: MP3 fällt dadurch aus dem Profil, der
Server rechnet es um, statt es durchzureichen.

**Und wenn doch etwas durchrutscht, wird gerechnet statt gemeldet.**
Scheitert die Wiedergabe mit einem Codec- oder Dekodierfehler, baut der
Spieler den Strom genau einmal neu auf — mit `transcode: true`, an
derselben Stelle. Der Satz „über das Zahnrad lässt sich eine Fassung
wählen, die er versteht" ist weg: wer das liest, weiss weder welche, noch
warum der Server sie nicht gleich gegeben hat.

Lief schon ein gerechneter Strom, unterbleibt der zweite Versuch — dann
liegt es nicht am Codec, und dreissig Sekunden Warten auf dasselbe sind
keine Hilfe.

**Nicht geprüft:** dass der Rückfall im Betrieb auslöst. Jede Datei im
Prüfbestand spielt; ein echtes Scheitern liess sich hier nicht
herbeiführen. Gemessen ist der Serverteil (`remux` wird zu `transcode`)
und das neue Profil.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 17:44:11 +02:00
ScarriffleandClaude Opus 5 e30158b84c Eine Sekunde heisst nicht „Weiterschauen" 
Die Schwelle aus den Einstellungen wirkt serverseitig, also sofort überall:
`/home/continue` liest die gespeicherte Spalte. Eine Stelle blieb trotzdem
widersprüchlich — die **Beschriftung**.

Web und Apps entschieden „Weiterschauen" gegen „Abspielen" selbst, allein
daran, ob eine Stelle über null steht. Nach einer Sekunde stand der Titel
damit nicht mehr in der Reihe, hiess aber weiter „Weiterschauen", trug
einen Fortschrittsbalken unter der Kachel und bot „Aus Weiterschauen
entfernen" an.

Der Server hatte diese Frage längst beantwortet. `ItemStateResponse` bringt
sie jetzt mit; `MediaItem.isResumable` und `.resumeProgress` sind die
einzigen Stellen, die sie noch stellen. Im Simulator nachgeprüft: nach
einer Sekunde heisst der Knopf „Abspielen", „Von vorn" fehlt, und der
Balken unter der Kachel ist weg.

Kennt ein Server das Feld nicht — Jellyfin, oder ein älterer Flaro —, gilt
wie früher die blosse Stelle.

**Und das Profilbild steht in den Apps.** `FlaroAccount` führt es mit,
`/auth/me` bringt es bei jedem Start frisch, und der Buchstabenkreis tritt
zurück, sobald eines da ist. Jellyfin bleibt beim Buchstaben — dort gibt es
kein Profilbild, und das ist keine Lücke, sondern der Stand der Dinge.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 17:30:38 +02:00
ScarriffleandClaude Opus 5 579a49b73b Der Server wusste, was du zuletzt gesehen hast — und sonst nichts 
Für „wie viel habe ich letzte Woche geschaut" gab es keine Daten.
`UserItemState` ist eine Zeile je Titel: der letzte Stand. Wer einen Film
zweimal sieht, überschreibt den ersten Durchgang; wann etwas lief, wusste
der Server nur fürs jeweils letzte Mal. Nachträglich erfinden lässt sich
das nicht.

Jetzt gibt es ein Sehprotokoll: **eine Zeile je Nutzer, Tag und Titel.**
Keine Sitzungen — die brauchen ein Ende, und das kommt oft nie an, wenn
der Browser zugemacht oder das Telefon zugeklappt wird. Tagesbündel haben
diesen Lebenslauf nicht, es wird nur addiert.

**Gezählt wird, was wirklich lief.** Der Zuwachs zwischen zwei Meldungen,
gedeckelt auf die Zeit, die dazwischen verstrichen ist (mal zwei als
Toleranz für doppelte Geschwindigkeit und ausgefallene Meldungen). Sonst
ergäbe ein Sprung von Minute 5 auf Minute 90 anderthalb Stunden Sehzeit in
zehn Sekunden. Gemessen an fünf Meldungen im Abstand von elf Sekunden:
88 Sekunden statt 190.

Dabei fiel ein zweiter Fall auf: war **gar keine** Zeit verstrichen, griff
kein Deckel statt eines engen — eine frisch angelegte Zeile hätte ihre
Anfangsstelle voll mitgezählt. Wer einen Film öffnet und sofort auf Minute
fünf springt, hat keine fünf Minuten gesehen.

Im Profil stehen drei Zahlen, und jede sagt, woher sie kommt: die
aufgezeichnete Zeit fängt heute an, die Zahl gesehener Titel steht seit
jeher fest. Dazu eine Wochenkurve, die häufigsten Genres und was zuletzt
lief. **Jeder sieht nur sich selbst, auch ein Administrator** — es gibt
keinen Weg, ein fremdes Konto zu meinen.

Zwei Dinge auf dem Weg dorthin:

**Eine stellbare Uhr für die Tests.** Zwei Minuten Film lassen sich nicht
in fünf Millisekunden sehen, und das ist richtig so — prüfen liess es sich
nur, indem die Zeit vergeht, ohne sie zu verbringen.

**Ein Namenskonflikt im CSS.** Die leeren Wochenbalken trugen die Klasse
`leer`, und die gehört längst der Fläche „hier ist nichts" — mitsamt
24 Pixeln Polster. Jeder leere Balken war dadurch 48 Pixel hoch, egal
welche Höhe dastand.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 17:20:01 +02:00
ScarriffleandClaude Opus 5 d8a1633cf4 Das eigene Bild führte aus dem Server heraus 
Ein Klick auf den Buchstabenkreis meldete ab. Keine Rückfrage, kein Menü,
kein Weg zurück — hinter einer Geste, die überall sonst „mein Konto"
heisst. Jetzt führt er auf `#/profil`; Abmelden steht dort als Knopf, mit
Nachfrage.

Auf der Seite: Bild wählen, tauschen, entfernen. Dazu „Meine Sprache" —
**umgezogen, nicht kopiert.** Sie stand mitten in der Verwaltung, und die
zeigt der Client nur Administratoren; der Endpunkt erlaubte sie längst
jedem. Wer kein Admin war, konnte seine eigene Sprache nirgends ändern.
Der Warnhinweis „weicht ab" bleibt in der Verwaltung, denn dort entsteht
die Verwirrung — er verweist jetzt aufs Profil.

**Vorher musste ein Fehler weg, der seit Monaten dasteht.**
`ImageCache.StoreStreamAsync` baute den Schlüssel aus 32 Hexzeichen plus
Dateiendung; `PfadFür` verlangt genau 64 Hexzeichen und nichts sonst. Es
gab keinen Wert, den beide gelten liessen: **jeder Bildupload gab `null`
zurück und endete in einem 502.** Kein Test fragte je danach — jetzt vier.
Damit geht nebenbei auch „eigenes Bild hochladen" für Filme und Serien
wieder.

Weil der Schlüssel keine Endung mehr trägt, kommt der Medientyp beim
Ausliefern aus den ersten Bytes der Datei. Vorher ging alles als
`image/jpeg` hinaus — bei TMDB stimmte das, bei einem hochgeladenen PNG
nicht.

**Und die gemerkte Sitzung war eine Kopie, die nie nachzog.** Sie wurde
bei der Anmeldung geschrieben und danach nie wieder. Wer sein Bild am
Telefon setzt und den Browser am Schreibtisch öffnet, fand dort den alten
Buchstaben — bis zum nächsten Anmelden. Gemessen und behoben: beim
Hochfahren wird das Konto abgeglichen, und das Profil meldet Änderungen
an die Kopfleiste, damit sie ohne Neuladen nachzieht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 17:07:40 +02:00
ScarriffleandClaude Opus 5 9622da0284 Eine Sekunde ist kein Anfang 
Drei Zahlen standen als Konstante im Quelltext und bestimmten, wie sich
der Server anfühlt. Jetzt stehen sie in der Verwaltung, unter
„Wiedergabe".

**Weiterschauen ab.** Gemessen: `BelongsInContinueWatching` verlangte nur
`Position.Ticks > 0` — ein Tick genügte. Wer im Aufmacher eine Sekunde
hineinschaute, fand den Titel danach in „Fortsetzen". Jetzt gibt es eine
Untergrenze, voreingestellt auf 1½ Minuten.

Was sich dabei **nicht** ändert: die Stelle wird weiter gemerkt. Das ist
der Unterschied zu Jellyfin, um dessentwillen es diesen Server gibt — die
Schwelle entscheidet, ob der Titel in der Reihe steht, nicht ob man ihn
wiederfindet. Nachgemessen: nach dem Umstellen ist „Heat" aus der Reihe
verschwunden und steht weiterhin bei Sekunde 1.

**Gesehen ab.** War 90 % als `const`, ist jetzt 85/90/95.

**Umkodieren.** `-preset veryfast -crf 21` und VAAPI `-qp 23` waren fest
verdrahtet, ohne Einstellung und ohne Umgebungsvariable. Drei Stufen:
Qualität (medium/19, qp 21), Ausgewogen (wie bisher), Tempo
(ultrafast/23, qp 26). Mit dem Warnsatz daneben, und der ist ernst
gemeint: was in Echtzeit laufen muss, darf nicht langsamer rechnen als es
abspielt.

**Und das Vorhandene wird neu bewertet.** `InProgress` ist eine
gespeicherte Spalte — die Bruchrechnung lässt sich nicht nach SQL
übersetzen. Eine neue Schwelle wirkte sonst nur auf künftige Meldungen.
Der Endpunkt läuft deshalb einmal in Stapeln durch und meldet zurück, wie
viele Zeilen das umgeworfen hat: „Übernommen — 2 Einträge wurden neu
bewertet." Ohne diesen Satz änderte sich die Startseite scheinbar von
selbst.

`ProgressRule` bleibt ein reiner Typ: die Regeln kommen als Wert herein.
Nebenbei zieht der doppelte `zeile()`-Bauer nach `teile.ts` — er stand
zweimal wortgleich da.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 16:52:53 +02:00
ScarriffleandClaude Opus 5 1e4a231d1b Elf Abschnitte in einer Spalte waren zehn zu viel 
Die Verwaltung war eine Seite mit 1786 Zeilen. Wer das Protokoll sehen
wollte, scrollte an Mediatheken, Prüfliste, Benutzern und Speicher
vorbei — und jede neue Einstellung hätte sie länger gemacht.

Jetzt hat sie eine eigene Leiste mit sieben Bereichen, jeder mit seiner
Adresse: `#/verwaltung/protokolle` lässt sich ablegen, und ein Neuladen
bleibt dort stehen. Die Leiste sieht aus wie die Hauptleiste daneben,
damit sie als Navigation gelesen wird und nicht als Knopfreihe; am
Telefon wird aus der Spalte ein Streifen zum Schieben.

**Gebaut wird nur, was offen ist.** Das ist nicht nur sparsamer: das
Abspielfenster fragt im Fünf-Sekunden-Takt nach, die Mediathekenliste
beobachtet laufende Scans. Gemessen: nach dem Wechsel in einen anderen
Bereich kommt zwölf Sekunden lang keine Anfrage mehr.

`admin.ts` ist in acht Dateien zerlegt — eine je Bereich, dazu `teile.ts`
für die gemeinsame Überschrift und `index.ts` für Leiste und Weiche.

Zwei Dinge mussten dabei nachziehen:

**Die Markierung in der Hauptleiste.** Sie verglich stur zwei Segmente;
bei `#/verwaltung/metadaten` traf das auf keinen Eintrag, und
„Verwaltung" verlor seinen Balken. Jetzt gilt auch ein Segment.

**„5 Titel warten — ansehen".** Der Knopf sprang mit `scrollIntoView` zur
Prüfliste. Die steht nicht mehr im selben Dokument — er wechselt jetzt
den Bereich. Die Hervorhebung danach entfällt damit, und mit ihr ihr CSS.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 16:39:50 +02:00
ScarriffleandClaude Opus 5 94c6604e8b Pfeile am Bildrand, und „Mehr" bleibt, wo es ist 
**Pfeile.** Der Aufmacher hatte nur die Punkte; die Pfeile, die du gedrückt
hast, gehörten zur Reihe darunter. Jetzt stehen links und rechts über dem
Bild zwei grosse Knöpfe. Am Telefon gibt es sie nicht — dort nähme ein
Knopf über dem Bild ein Drittel der Breite —, dafür lässt sich wischen.
Nur waagerecht und erst ab 48 Pixeln, sonst käme man am Aufmacher nicht
mehr vorbeigescrollt.

**Und die Knöpfe springen nicht mehr.** „Abspielen" ist 128 Pixel breit,
„Fortsetzen ab 1:23:45" 207, der Terminhinweis 257 — alles in derselben
Flexreihe, also wanderte „Mehr" bei jedem Umblättern mit, und das
Karussell blättert von allein. Der vordere Platz hat jetzt eine feste
Breite. Gemessen: „Mehr" steht auf allen sieben Folien an derselben Stelle.

Dabei fielen zwei Dinge auf, die nicht am Umbau lagen:

**Der Textblock war so breit wie sein längster Satz.** Als blosses Flexkind
richtete er sich nach dem Inhalt — bei einer kurzen Inhaltsangabe schmaler
als bei einer langen. Auf dem Telefon rückte „Mehr" dadurch um fünfzig
Pixel, und mit dem festen Platz lief die Zeile sogar über den Bildschirm
hinaus; `overflow: hidden` schnitt die rechte Hälfte des Textes ab.

**Ein fehlender Schriftzug liess den Aufmacher namenlos.** Steht ein Logo
in den Metadaten, wurde der Titel daneben versteckt — auch wenn das Bild
gar nicht lud. Zu sehen war ein Platzhalter und sonst nichts. Jetzt tritt
der Name an seine Stelle.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 16:32:55 +02:00
ScarriffleandClaude Opus 5 10a5070e58 Eine Folge ist weder ein Film noch eine Serie 
Die App meldete auf der Startseite „Dieser Titel ist auf dem Server nicht
mehr vorhanden" — über eine Folge, die sie selbst gerade anzeigte.

Gemessen im Quelltext: `item(id:)` probiert `/movies/{id}`, dann
`/series/{id}`, und wirft sonst `.notFound`. In „Weiterschauen" steht
eine Folge mit ihrer eigenen Kennung, und einen Endpunkt für eine
einzelne Folge gab es gar nicht. Jetzt gibt es `GET /api/v1/episodes/{id}`
— mit `SeriesId`, denn ohne die Serie fehlen der Folge Titel und Bild.
Im Simulator nachgestellt und nachgeprüft: die Seite steht.

**Zuletzt hinzugefügt.** Die App zeigte „Filme" und „Serien" — den Anfang
der Mediathek in der Reihenfolge der Datenbank, also immer denselben.
Jetzt je Mediathek eine Reihe „Neu in …", sortiert nach Zugang. Die
Kennungen beginnen nun mit `latest`, und daran hängen zwei Einstellungen,
die an einem Flaro-Server deshalb nichts taten: „Gesehenes in Neuzugängen
ausblenden" und „Aufmacher nur aus Neuzugängen".

**Geplante Titel.** `MediaItem` kennt jetzt `availableFrom`. Aufmacher und
Detailseite zeigen statt des Knopfes „Bald ist es soweit" mit dem Termin.
Die Kachel spielte trotzdem los — im Simulator kam der Spieler bis „Wird
vorbereitet …" —, also zählt ein geplanter Titel jetzt wie eine Sammlung:
nichts zu starten, der Tipp führt auf die Seite.

**Und das Bild im Aufmacher.** Bei einer angefangenen Folge stand dort ihr
Standbild statt des Bildes der Serie; wer der Serie eines ausgesucht
hatte, fand ein anderes vor. Die Kachel behält das Standbild — sie zeigt,
wo man steht —, der Aufmacher bekommt `SeriesBackdropImage`.

**Die Punkte im Karussell waren 26 × 3 Pixel.** Von drei Klicks auf
denselben Punkt traf nur der auf der Mittellinie; fünf Pixel daneben
geschah nichts. Der Knopf ist jetzt 27 Pixel hoch, sichtbar bleiben 3.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 16:06:58 +02:00
ScarriffleandClaude Opus 5 f10fb4c1bc Abspielen spielt ab 
Im Aufmacher der Startseite stand „Abspielen", und wer draufdrückte,
landete auf der Detailseite. Gemessen am laufenden Server: beide Knöpfe
riefen dieselbe Funktion — `oeffnen` —, der eine hiess nur anders.

Drei Dinge waren falsch, alle an derselben Stelle:

**Der Knopf log.** Jetzt startet er den Spieler, mit Fortsetzen ab der
Stelle, an der man war. Ohne Datei — eine ganze Serie — heisst er
„Ansehen" und führt dorthin, wo man wählen kann.

**Eine angefangene Folge war kein Film.** Sie lief durch `alsHero` mit
`art: 'filme'` und ihrer eigenen Kennung; der Klick ging auf
`#/filme/<Folgenkennung>` und endete in „Diesen Film gibt es nicht
mehr". Nachgemessen im Browser, dann `angefangenAlsHero` dafür gebaut:
die Detailseite gehört der Serie, der Fortschritt der Folge.

**Ein geplanter Titel sah aus wie jeder andere.** Jetzt steht statt des
Knopfes „Bald ist es soweit" mit dem Termin, wie auf der Detailseite.

Dafür nennt `/home/continue` und `/home/next` nun Datei, Länge und
Termin, und die Vorschläge bringen ihre Dateien mit — ohne die konnte
der Aufmacher gar nicht abspielen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 15:42:42 +02:00
ScarriffleandClaude Opus 5 343b0cdcfb Ein Knopf, der nichts tut, ist schlimmer als keiner 
Der geplante Film zeigte weiter „Abspielen" und „Herunterladen", und wer
drückte, bekam „Dieser Titel ist ab dem 6.10. um 18 Uhr verfügbar". Die
Sperre im Server war richtig; die Oberfläche wusste nur nichts davon.

Gemessen: die Liste führte `PublishAt` seit jeher mit, die Einzelabfrage
`GET /api/v1/movies/{id}` nicht — und die Detailseite entscheidet genau
daran. `publishAt` kam also immer als `null` an, die Prüfung lief ins
Leere. Dasselbe fehlte bei `GET /api/v1/series/{id}` und bei den Folgen.

Jetzt steht dort, wo sonst der Knopf stünde: „Bald ist es soweit", mit
dem Termin darunter. Kein Versprechen, das beim Klicken zurückgenommen
wird.

Der Test prüfte bisher nur die Liste — darum fiel es nicht auf. Er fragt
jetzt die Detailseite und schlägt ohne die Korrektur fehl.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 15:10:30 +02:00
ScarriffleandClaude Opus 5 255eb7c2f0 Spider-Man ist nicht 720p, er ist breit 
Die Auflösung wurde allein aus der Höhe gebildet. Ein Kinoformat von 2.39:1
liegt als 1920×800 vor — nach der Höhe gerechnet kam „720p" heraus, und das
stand so in der Oberfläche. Jetzt zählt die grössere von Breite und Höhe;
Hochformat kippt damit nicht, und 4K-Breitbild heisst nicht mehr 1440p.

Die Detailansicht hat zwei Leserschaften, und bisher bekamen beide dasselbe.
Wer schauen will, sieht jetzt Laufzeit, Auflösung und die Sprachen — jede
einmal, statt „Englisch · Englisch · Englisch · Englisch · Deutsch". Wer die
Mediathek betreut, sieht darunter Dateiformat, Grösse und den Ordner. Der
Ordner verrät eine falsche Zuordnung in einer Sekunde: steht über der
Beschreibung „Hanni & Nanni 3" und der Ordner heisst „Hanni und Nanni", ist
die Sache klar. Er kommt nur für Administratoren überhaupt vom Server —
versteckt im Client wäre er weiterhin auslesbar.

Ein geplanter Titel war unsichtbar. Das ist die Hälfte, die nichts bringt:
dass er kommt, ist der Sinn des Planens. Er steht jetzt mit „Verfügbar ab …"
in der Mediathek, und die Datei geht trotzdem nicht heraus — Download wie
Strom lehnen bis zum Termin ab, auch für Administratoren. Wer vorziehen will,
hat „Jetzt veröffentlichen"; eine Hintertür für eine Rolle wäre eine Regel,
die manchmal gilt.

Was ein Auffrischen geändert hat, steht jetzt unter „Zu prüfen" — in einer
eigenen Gruppe mit „Zur Kenntnis" statt „Veröffentlichen". Diese Titel sind
sichtbar; es gibt nichts freizugeben, nur etwas abzuhaken.

Und das Protokoll sagt endlich, wo es knallt. „InvalidOperationException:
Nullable object must have a value." ohne eine einzige Zeile Herkunft ist für
niemanden eine Diagnose — weder für den Betreiber noch für mich.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 14:51:00 +02:00
ScarriffleandClaude Opus 5 f44779c899 Eine Zahl ohne das, worauf sie sich bezieht 
„4 warten auf Freigabe" stand in der Mediathekenzeile, und die Liste darüber
war leer — sogar versteckt. Zwei Gründe, beide behoben.

Die Prüfliste wurde einmal beim Öffnen geholt und nie wieder. Findet ein
laufender Scan danach etwas Neues, zählt die Zeile es mit, die Liste aber
nicht. Sie hört jetzt auf dieselbe Meldung wie die Seitenleiste: Scan durch,
etwas freigegeben, Mediathek geändert — nachladen.

Und der Knopf gab blind frei. Auf die Frage „wo sehe ich die vier Filme?"
war das keine Antwort: er veröffentlichte sie, ohne sie zu zeigen. Jetzt
führt er dorthin, wo sie mit Plakat, Jahr und Dateiname stehen und sich
einzeln anhaken lassen — und hebt die Stelle kurz hervor, damit man nicht
weitersucht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 13:56:12 +02:00
ScarriffleandClaude Opus 5 58e06d0539 Hanni und Nanni ist nicht Hanni und Nanni 3 
Deine drei Fälle haben eines gemeinsam, und es ist nicht das, was ich zuerst
vermutet hatte: keiner der Dateinamen nennt ein Jahr. Der Riegel von gestern
greift deshalb nicht.

Gemessen, woran es wirklich liegt. Bei TMDB heisst der Film „Hanni & Nanni",
auf der Platte „Hanni und Nanni". Das Kaufmanns-Und fällt im Vergleichs-
schlüssel als Sonderzeichen heraus, das Wort „und" bleibt stehen — die
Namensgleichheit griff also nie. Gewählt wurde stattdessen der erstbeste
Treffer, und das war „Hanni & Nanni 3". Der richtige stand auf Platz zwei,
und alle vier Treffer hatten dieselbe Beliebtheit: die Reihenfolge war
Zufall.

Bindewörter zwischen zwei Namen zählen jetzt nicht mehr mit — gestrichen,
nicht übersetzt, sonst bliebe „Batman and Robin" aussen vor. Am Wortanfang
bleiben sie stehen: „Und dann kam Polly" ist kein „dann kam Polly". Und die
Suche vergleicht über den Schlüssel statt Zeichen für Zeichen.

Das verhindert aber nur Neues. Was schon zusammengelegt ist, bleibt es —
deshalb gibt es jetzt „Eigener Film": eine Datei löst sich aus ihrem Titel
und wird ein eigener Eintrag, mit dem Titel aus dem Dateinamen und ohne
Kennung. Eine zu raten hiesse, denselben Fehler zu wiederholen; so steht sie
unter „Ohne Zuordnung" und ist in zwei Klicks richtig.

Der Super-Mario-Fall liegt anders: beide Titel treffen heute richtig. Der
steckt noch aus einem früheren Lauf fest und braucht das Trennen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 13:40:21 +02:00
ScarriffleandClaude Opus 5 c3124ba27c Zwei Teile, ein Treffer — und einer verschwand 
Du hast drei Filme vermisst, und die Zahlen sagten schon, wo sie sind: 448
Filme plus 13 zweite Fassungen sind genau die 461 Dateien. Es fehlte keine
Datei; drei Filme steckten als Fassung in einem anderen.

Gemessen, warum. Der Dateinamenleser ist unschuldig — „Teil 2" bleibt im
Titel. TMDB aber liefert für „Heiligtümer des Todes Teil 1" wie für „Teil 2"
denselben Treffer zuerst, sobald ohne Jahr gesucht werden muss. Und weil
zwei Einträge dieselbe Kennung nicht teilen dürfen, wurde der zweite
geschluckt.

Zwei Dateien, deren Namen verschiedene Jahre nennen, sind jetzt verschiedene
Filme. Der erste Anlauf hatte ein Jahr Abstand als Toleranz erlaubt — für
Dezember-Erstaufführungen — und verschluckte damit genau den Fall, um den es
geht: Teil 1 ist von 2010, Teil 2 von 2011.

Dazu sieht man endlich, was nicht zugeordnet werden konnte. „Nicht
zugeordnet" listete bisher nur Dateien ganz ohne Titel, und die gibt es bei
Filmen nie — deshalb standen dort nur Serien. Daneben eine Liste der Titel
mit mehreren Dateien: zwei Fassungen sind die Regel, zwei verschiedene Filme
der Fehler, und an den Dateinamen sieht man es sofort.

Der Bearbeiten-Dialog hat jetzt Reiter statt Knöpfe, die weitere Fenster
öffnen — ein Fenster über einem Fenster, und man wusste nicht mehr, was man
zumacht. „Titel ändern" und „Bilder bearbeiten" sind aus dem Kontextmenü
raus; über „Bearbeiten" kommt man an beides.

Beim Prüfen gefunden: ein Dialog blieb nach einem Seitenwechsel über der
neuen Seite stehen. Er hängt an body, nicht am Inhaltsbereich.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-06 13:21:42 +02:00
ScarriffleandClaude Opus 5 fcf40e4394 Der Orden des Phönix stand vor dem Stein der Weisen 
Alphabetisch stimmt das, nur sieht man sie andersherum. Es gibt jetzt einen
Sortiertitel: „Harry Potter 1", „Harry Potter 2" — und die Reihe steht in
der Ordnung, in der man sie schaut. Leer gelassen bleibt alles wie bisher,
beim Titel ohne Artikel davor.

Er hat einen eigenen Merker, nicht den des Titels. Wer die Reihenfolge
festlegt, soll den Titel trotzdem weiter automatisch bekommen; beides an
einem Schalter hiesse, für das eine auf das andere zu verzichten. Eine
Korrektur der Zuordnung lässt ihn ebenfalls stehen.

Und WALL·E bleibt nicht mehr unter E. Die Kachel wurde nach einer Korrektur
zwar neu beschriftet, blieb aber an ihrem Platz — jetzt rutscht sie dorthin,
wo sie hingehört. Liegt der Platz im noch nicht geladenen Teil der Liste,
geht sie weg und sagt wohin, statt falsch stehenzubleiben.

Dazu ein Dialog, in dem alles zu einem Titel beieinander steht: Titel,
Sortiertitel, Bilder, Zuordnung. Die vier Menüpunkte gab es schon, jeder für
sich richtig — zusammen aber kein Ort. Wer einen Film geraderückt, macht
selten nur eines davon. Die Abkürzungen bleiben.

Beim Bauen gefunden: das Zurücksetzen des Sortiertitels endete in einer 500.
SortTitle.For ist eine C#-Methode, und EF Core übersetzt sie nicht nach SQL.
Es geht um eine Zeile — die wird jetzt geladen und zurückgeschrieben, statt
die Regel ein zweites Mal als SQL zu schreiben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 22:25:31 +02:00
ScarriffleandClaude Opus 5 e70c33f7e2 Not Found war weder deutsch noch wahr 
Beim Korrigieren einer Zuordnung geht der bearbeitete Eintrag im vorhandenen
auf — er wird gelöscht. Die Antwort nannte aber nur die Daten des
überlebenden, nicht seine Kennung, und so zeigte die Kachel weiter auf etwas,
das es nicht mehr gab. Wer sie dann bearbeiten wollte, bekam „Not Found".

Zwei Fehler in einer Meldung. Der Server sagt jetzt, welcher Eintrag
überlebt hat und ob zusammengelegt wurde; die Kachel nimmt sich weg statt
auf ein Loch zu zeigen, und sagt wohin.

Und das Englische: in `detail` steht der Satz, den der Server selbst
geschrieben hat — deutsch und mit einem Hinweis, was zu tun ist. `title` ist
dagegen der Statusname aus dem Rahmenwerk, und genau der wurde angezeigt, wo
`detail` fehlte. Er wird nicht mehr gelesen; wo der Server nichts zu sagen
hat, schreibt der Client selbst einen deutschen Satz.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 22:05:36 +02:00
ScarriffleandClaude Opus 5 c46063637f Die Kachel zeigte auf die Folge und wollte zur Serie 
„Nächste Folge" führte ins Leere, und es lag weder am Scan noch am
Auffrischen: die Kachel trug die Folgenkennung und öffnete damit eine
Serienseite — die es unter dieser Kennung nie gibt. Heraus kam ausgerechnet
dort „Diese Serie gibt es nicht mehr", wo man gerade weiterschauen wollte.
Der Server kannte die Serie an beiden Stellen und schickte sie nur nicht mit.

Wohin die Kachel führt und was sie misst, ist jetzt getrennt. Beides auf
dieselbe Kennung zu legen wäre der nächste Fehler gewesen: „Als gesehen
markieren" hätte die ganze Serie abgehakt statt der einen Folge, die man zur
Hälfte gesehen hat.

Dazu Streichen wie im Dateimanager: gedrückt halten und darüberfahren wählt
aus, rückwärts über Gewähltes nimmt wieder weg. Ein kurzer Klick bleibt, was
er war. Abgetastet wird die Strecke zwischen zwei Zeigerereignissen, nicht
nur deren Endpunkte — gemessen: ein Zug über vier Kacheln erwischte sonst die
erste und die letzte. Plakate lassen sich nicht mehr durch die Gegend
schleppen.

„Abwählen" ist ein Kreuz geworden; als vierter Knopf neben drei Aktionen sah
es aus, als täte es etwas mit den Titeln.

In der kleinen Leiste lag das Vorschaubild über dem Fortschrittsstrich und
verdeckte ihn rechts. Und ein Klick genau darauf tat nichts, obwohl das die
Stelle ist, auf die man zeigt — jetzt holt auch das Bild den Film zurück.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 21:48:00 +02:00
ScarriffleandClaude Opus 5 7df9fa6c01 Zwei Dinge in derselben Ecke, und ein Modus, den niemand bestellt hat 
Der Gesehen-Haken und die drei Punkte sassen beide oben rechts — auf dem
Plakat sah das aus wie ein Fehler. Jetzt hat jede Ecke eine Aufgabe: oben
links die Auswahl, oben rechts der Stand, unten links Abspielen, unten rechts
das Menü.

Der Knopf „Auswählen" ist weg. Gemessen, warum er stören musste: der längere
Text „Auswahl beenden" brach die Filterzeile um und schob das Raster um
zwanzig Bildpunkte nach unten. Und grundsätzlicher ist ein Modus ein Zustand,
den man kennen muss, bevor man etwas tun kann. Jetzt trägt jede Kachel oben
links ein Kästchen, das beim Überfahren erscheint — wie die drei Punkte auch.
Der erste Haken fängt die Auswahl an, der letzte beendet sie.

Der Spieler lässt sich verkleinern. Er rutscht in eine Leiste am unteren Rand
und läuft weiter, während man die Mediathek aufräumt; ein Klick darauf holt
ihn zurück. Dasselbe Videoelement, nur anders eingerahmt — ein zweiter
Spieler unten hiesse, das Video auszuhängen, und dabei hört es auf zu
spielen.

Das Zahnrad mit acht Strahlen sah aus wie eine Sonne. Jetzt: Wellenform für
den Ton, CC-Kasten für die Untertitel, Schieberegler für die Qualität. Alle
drei Menüs stehen immer da — vorher verschwanden sie bei nur einer Tonspur
oder ohne Untertitel, und wer sie suchte, fand nichts und wusste nicht warum.

Dabei gefunden und behoben: die Wiedergabe blieb nach zwanzig Sekunden
stehen, obwohl längst der ganze Rest auf der Platte lag. Results.File setzte
Last-Modified, der Browser legte die Playlist mit zwei Einträgen ab, und
hls.js bekam bei jedem Nachfragen dieselben zwei zurück. Eine wachsende Liste
ist das Gegenteil von zwischenspeicherbar.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 20:31:12 +02:00
ScarriffleandClaude Opus 5 eda9e67802 Wo die Grafikeinheit eingetragen wird, und was passiert wenn sie fehlt 
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 18:53:00 +02:00
ScarriffleandClaude Opus 5 4853200d5c Er packte um, was gar nicht am Umpacken lag 
Der Browser bekam stillschweigend Apples Geräteprofil — und mit ihm HEVC, AC3
und EAC3, von denen er keines öffnet. Der Server packte die Datei
pflichtschuldig nach MP4 um, liess Bild und Ton dabei unberührt, und heraus
kam eine tadellose Datei, mit der Chrome nichts anfangen konnte. Umpacken
fasst das Bild nun einmal nicht an.

Jetzt sagt das Gerät selbst, was es kann, und es gibt einen zweiten Weg neben
der fertigen Datei: HLS, das nach Sekunden anfängt statt nach Minuten.
Dasselbe Rohr erledigt beides — mkv nach fMP4 mit „-c:v copy", 4K nach 480p
mit libx264 — und eine MP4, die der Browser ohnehin öffnet, geht ganz ohne
ffmpeg hinaus.

Dazu eine eigene Steuerleiste: Tonspur und Untertitel während der Wiedergabe
umschaltbar, vier Auflösungsstufen, Tastenkürzel, und bei einem Fehler ein
deutscher Satz statt eines schwarzen Bildes.

Gemessen statt vermutet: Chromium antwortet auf canPlayType für HLS mit
"maybe" und kann es dann doch nicht — deshalb entscheidet Hls.isSupported().
hls.js wiegt 372 KB und wird erst beim Abspielen geholt; die Oberfläche
bleibt bei 109.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 18:52:27 +02:00
ScarriffleandClaude Opus 5 557708b769 Ein Klick, der nichts tat, und niemand sagte warum 
Eine Serienkachel kannte der Server als Titel nicht: „als gesehen markieren"
lief in eine 404, und weil das Kontextmenü die Ablehnung verschluckte, geschah
sichtbar gar nichts. Dasselbe beim Favoriten. UserItemState bekommt eine
Serienkennung, das Häkchen zieht alle Folgen mit, und was wirft, erscheint als
Meldung statt in der Browserkonsole.

Dazu eine Mehrfachauswahl in der Mediathek — gesehen, ungesehen, Metadaten
neu holen für das Gewählte, in einer Anfrage statt in zweihundert. Ein neues
Plakat steht sofort auf der Kachel, und ein Titel, den es nicht mehr gibt,
endet nicht mehr in einer Sackgasse.

Gemessen: ein POST auf /refresh ohne Rumpf antwortete nach der Erweiterung mit
404 — also genau der Aufruf „alles auffrischen", den es länger gibt als die
Auswahl. Der Rumpf wird jetzt von Hand gelesen, und beide Formen stehen in
einer Prüfung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-05 18:28:33 +02:00
ScarriffleandClaude Opus 5 c854c4a09a 451 gegen 461, und ein Band für das, was noch wartet 
Drei Zahlen, die alle stimmen und Verschiedenes meinen: Plex zählte 451
Filme, Flaro 449, und der Scan lief über 461 Dateien. Die
Mediathekszeile nennt sie jetzt getrennt — Titel, Folgen, Dateien,
zweite Fassungen und nicht Zugeordnetes. Damit beantwortet sich die
Frage selbst, statt offen zu bleiben.

Die Rechnung dahinter war beim ersten Versuch falsch: sie verglich
gegen alle Folgen und kam auf 1223 Titel bei 324 Dateien. Gezählt wird
jetzt, zu wie vielen Titeln überhaupt noch eine Datei daliegt — dann
geht Dateien = Titel + Fassungen + ohne auf, auch wenn etwas vermisst
wird. Nachgemessen mit einer echten Plex-Kopie: 3 Titel, 4 Dateien, 1
zweite Fassung.

Dazu trägt eine Kachel, die noch auf Freigabe wartet, jetzt ein Band —
„Wartet" oder „Geplant". Für einen Administrator standen wartende Titel
bisher mitten zwischen den freigegebenen, ohne dass etwas sie
unterschied; wer einen suchte, fand ihn nur über die Prüfliste. Dafür
reicht `PublishAt` jetzt bis in die Kachel durch.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 22:04:17 +02:00
ScarriffleandClaude Opus 5 5a5cf3d006 Dieselbe Kennung zweimal zu vergeben war kein Fehler, sah aber so aus 
Im Zuordnungsdialog stand „An error occurred while processing your
request." — englisch, ohne Grund, ohne nächsten Schritt. Dahinter steckte
der Eindeutigkeitsindex: der gewählte Film war in derselben Mediathek
schon vergeben, und die Kennung wurde trotzdem blind gesetzt.

Es ist aber gar kein Fehler. Zwei Dateien, die denselben Film meinen,
gehören zusammengelegt — genau das tut der Scan am Ende jedes Laufs, und
der Sehfortschritt wird dabei gefaltet. Die Korrektur von Hand tut es
jetzt auch, für Filme wie für Serien.

Dazu die zweite Hälfte: auch das Letzte, was durchrutscht, spricht
Deutsch. Der Fehlerbehandler am Ende der Kette gab bisher die Vorgabe von
ASP.NET aus. Jetzt bekommt jede Ausnahme einen deutschen Satz, und die
Einzelheiten gehen ins Tagesprotokoll — dorthin, wo man sie sucht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 21:53:20 +02:00
ScarriffleandClaude Opus 5 0c07d4efc7 Ein falscher Treffer verhinderte seine eigene Korrektur 
„Doctor Strange" war fälschlich auf ein Making-of von 2022 gelaufen. Beim
Korrigieren hängte die Vorschlagssuche `year=2022` an — aus genau der
Zuordnung, die weg sollte — und lieferte nur noch Titel von 2022. Der
richtige Film von 2016 konnte gar nicht erscheinen, egal wie oft man
suchte.

An TMDB nachgemessen:

  query='Doctor Strange' ohne Jahr     → 2016 Doctor Strange, 2022 Multiverse …
  query='Doctor Strange' mit year=2022 → genau die drei Treffer aus der Meldung

Gesucht wird jetzt mit dem Jahr aus dem Dateinamen, nie mit dem aus dem
Treffer. Die Oberfläche trägt ebenfalls keines mehr vor: das angezeigte
stammt aus derselben falschen Zuordnung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 21:14:55 +02:00
ScarriffleandClaude Opus 5 74c625b829 Das Dreipunktemenü in der Prüfliste ging gar nicht auf 
Der öffnende Klick blubbert nach dem eigenen Zuhörer weiter zum Dokument,
und der dortige schliesst alles, was nicht im Menü liegt — also auch
dieses, im selben Augenblick. In der Mediathek stand deshalb ein
`stopPropagation()` am Griff; in der Prüfliste fehlte es.

Eine Regel, an die sich jeder Aufrufer erinnern muss, ist keine Regel.
Deshalb nicht die Kopie nachgezogen, sondern das Menü merkt sich jetzt
selbst, woran es hängt, und der globale Zuhörer lässt den Griff in Ruhe.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 21:07:36 +02:00
ScarriffleandClaude Opus 5 d2fbaad871 Jeder Titel war seine eigene Dublette, und das seit Monaten 
„Metadaten auffrischen" hat an allem, was schon zugeordnet war, schlicht
nichts getan. Die Dublettenprüfung schlägt jeden Titel nach, der eine
TMDB-Kennung hat — beim Auffrischen also auch den gerade bearbeiteten.
Ohne Vergleich auf Gleichheit fand sich jeder als "Dublette seiner
selbst", wurde übersprungen und nie fortgeschrieben. Titel, Beschreibung
und Bilder blieben für immer so, wie sie beim allerersten Lauf
hereinkamen.

In der Oberfläche sah das aus, als wirke die Spracheinstellung nicht —
und genau so wurde es gemeldet. Gemessen, Ende zu Ende:

  Serversprache en-US:  101 Dalmatians  ·  The Lion King
  Serversprache de-DE:  101 Dalmatiner  ·  Der König der Löwen

Damit das nie wieder unbemerkt bleibt, weiss der Server jetzt, in welcher
Sprache er die Titel hat: eine Spalte MetadataLanguage, gesetzt beim
Anreichern, und in der Verwaltung eine Zeile mit der Verteilung. Weicht
etwas ab, frischt ein Knopf genau diese Titel auf — nicht den ganzen
Bestand, und ohne das Dateisystem noch einmal abzulaufen.

Dazu zwei Dinge, die ohne das nicht gingen: ein Titel lässt sich von Hand
setzen und wird dabei festgeschrieben wie ein Plakat, mit einem Weg
zurück. Und ein Titel, der auf Freigabe wartet, trägt jetzt dasselbe
Dreipunktemenü wie eine Kachel — Bilder, Zuordnung, Titel. Ausgerechnet
dort fehlte es, obwohl das der Eintrag ist, den man vor der Freigabe
geradeziehen will.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 20:49:06 +02:00
ScarriffleandClaude Opus 5 ce38da1376 Die Auswahlliste klappte hinter dem Dialog auf 
Ein `<dialog>` mit `showModal()` liegt in der Top-Layer des Browsers,
über allem — unabhängig von `z-index`. Die Liste hing am `body` und
verschwand deshalb hinter genau dem Dialog, in dem ihr Knopf steht.
Jetzt wird sie in den Dialog gehängt, wenn es einen gibt. Mit
`elementFromPoint` nachgeprüft: an ihrer Stelle liegt wirklich ein
Listeneintrag obenauf.

Dazu zwei Stellen, die zu der Vermutung geführt haben, die
Spracheinstellung wirke nicht:

„Übersetzungen holen" stand stur auf en-US. Neben einem Server, der auf
Deutsch steht, liest sich das wie eine Aussage über den Server.
Vorgewählt wird jetzt die eigene Sprache, sonst die erste, die nicht
schon die des Servers ist — und der Text nennt die Serversprache.

Und „Meine Sprache" sagt jetzt deutlich, wenn sie abweicht. Sie ändert
nicht, was der Server holt, nur was man selbst sieht: steht sie auf
Englisch, während der Server auf Deutsch holt, sieht die ganze
Mediathek englisch aus und jedes Auffrischen scheint wirkungslos.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 20:03:01 +02:00
ScarriffleandClaude Opus 5 e87d50e470 Wer die Genreliste durchblättern wollte, schloss sie dabei 
Der Zuhörer hängt mit `capture` am Fenster, damit auch ein Bildlauf in
einem inneren Behälter die Liste schliesst — sie steht `position: fixed`
und bliebe sonst neben einem Knopf stehen, der längst weggescrollt ist.
Nur scrollt eine Liste mit zwanzig Genres selbst, und dieses Ereignis
kam dort ebenfalls an. Jetzt wird geprüft, woher es stammt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 19:22:42 +02:00
ScarriffleandClaude Opus 5 aeaf6eb578 „highschool musical 3" fand TMDB nicht, „high school musical 3" schon 
Drei gemeldete Fälle, alle an TMDB nachgemessen statt vermutet:

  highschool musical 3              0 Treffer
  high school musical 3             2 Treffer, der richtige zuerst
  Harry Potter im Orden des Phoenix 0 Treffer
  Harry Potter                     20 Treffer, der richtige darunter
  dr dolittle                      13 Treffer, der richtige zuerst

Der fehlende Punkt bei Dr. Dolittle war nie das Problem — diese Vermutung
ist in Suchvarianten.cs festgehalten, damit sie nicht wiederkommt.

Die Suche versucht jetzt der Reihe nach: den Titel wie er dasteht, dann
das längste Wort an jeder Stelle getrennt (von der Mitte nach aussen,
ohne Wörterbuch — „highschool" trifft nach 2 Versuchen, „jurassicpark"
nach 5), dann von hinten gekürzt, bis zwei Worte übrig sind. Höchstens
zehn Anfragen, und nur dann, wenn die erste gar nichts brachte.

Und die Treffer werden nach Ähnlichkeit zum gesuchten Titel sortiert,
nicht nach Beliebtheit. Über gemeinsame Worte ohne Akzente: so trennt
„Harry Potter" den „Orden des Phönix" von „Harry Potter: Fireplace", und
„Phoenix" findet „Phönix".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 19:13:24 +02:00
ScarriffleandClaude Opus 5 4b0323f955 Drei Auswahlfelder liessen sich gleichzeitig aufklappen 
Jedes merkte sich nur seine eigene Liste. Nebeneinander geöffnet lagen
sie übereinander, und keine wusste von den anderen. Ein Auswahlfeld ist
ein Menü, und von denen ist höchstens eines offen — jetzt modulweit
vermerkt, genau wie beim Kontextmenü. Escape schliesst zusätzlich von
überall, nicht nur mit dem Fokus in der Liste.

Dazu stand unter jeder Mediathek „0 Titel freigeben". Der Knopf wurde
über `hidden` versteckt — das Attribut wirkt über `display: none` mit der
Spezifität von Null, und `.btn` setzt `display: inline-flex`. Die Klasse
`.hidden` trägt ein `!important` und setzt sich durch.

Und das Favicon kommt jetzt aus `icon.png`, dem gerenderten App-Icon
selbst. Meine nachgezeichnete Fassung war falsch: die Grafik füllt die
Fläche, statt klein in der Mitte zu sitzen. Ein Icon, das dem echten nur
ähnelt, driftet beim nächsten Entwurf wieder auseinander.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 19:01:58 +02:00
ScarriffleandClaude Opus 5 8809b9f46f Die Mediathek hörte bei I auf, und jede Folge stand doppelt 
Zwei Befunde aus dem laufenden Betrieb.

Die Liste holte genau eine Seite. Der Server gibt höchstens 200 Einträge
je Zug — das ist richtig so —, nur fragte die Oberfläche nie nach der
zweiten. Bei 455 Filmen endete die Mediathek mitten im Alphabet, ohne
Hinweis, dass da noch etwas kommt. Jetzt wird beim Scrollen nachgeladen,
und die Zahl sagt „200 von 455" statt einer Behauptung, die man beim
Scrollen widerlegt.

Dabei kam heraus, dass ein IntersectionObserver eine Seite braucht, die
auch gezeichnet wird: im Fenster im Hintergrund löst er nicht aus, und
beim Prüfen blieb die Liste genau deshalb bei 200 stehen. Daneben steht
jetzt eine Prüfung am Scrollereignis, die überall greift.

Der zweite Befund: jede Folge zeigte zwei gleich aussehende Knopfreihen.
Es sind zwei Dateien — Plex' „Optimized for Mobile"-Kopien. Flaro kannte
„optimized", aber nicht „Optimized for Mobile", und sah ohnehin nur den
unmittelbaren Elternordner; Plex legt die Fassung aber als
`Plex Versions/Optimized for Mobile/<Serie>/<Staffel>/…` ab. Jetzt wird
drei Ebenen hoch gesucht, die Schublade `Plex Versions` benennt keine
Serie mehr, und an der Folge steht „Mobil" statt einer zweiten,
unerklärten Reihe.

Nicht um Plex zu bedienen — die Dateien liegen nun einmal so auf der
Platte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 18:45:07 +02:00
ScarriffleandClaude Opus 5 960cca3dae Der Abschnitt verschwand alle drei Sekunden und kam wieder 
`laden()` setzte `innerHTML = ''` und baute die Mediathekenliste neu —
während eines Scans alle drei Sekunden. Der ganze Abschnitt flackerte
sichtbar, und wer gerade auf einen Knopf zielte, klickte ins Leere.
Schlimmer: jeder Neuaufbau startete über `verfolgen(false)` einen
weiteren Takt. Nach einer Minute liefen zwanzig davon nebeneinander.

Jetzt wird fortgeschrieben statt neu gezeichnet: eine Zeile je
Mediathek, die bleibt, und nur Kopfzeile, Prüfungsknopf und
Freigabeknopf ändern sich. Belegt im Browser — nach einem Auffrischen
sind es dieselben Knoten, nur die Beschriftung ist eine andere.

Dieselbe Behandlung für die Seitenleiste. Und weil Seitenleiste und
Verwaltung getrennt nachfragten, zeigten sie zwei Momente — 95 hier, 84
dort, während im Hintergrund Doppelte zusammengelegt wurden. Die
Verwaltung reicht ihren Stand jetzt weiter: ein Abruf, zwei Anzeigen.

Dazu zwei Dinge, die beim Prüfen auffielen. Zurücksetzen und Entfernen
prallen jetzt serverseitig mit 409 ab, solange ein Lauf läuft — die
Oberfläche sperrt die Knöpfe, aber darauf darf sich der Server nicht
verlassen; ein Aufruf von Hand während eines Scans liess den Lauf an
einer DbUpdateConcurrencyException sterben. Und in der
Fortschrittszeile steht beim Holen der Folgenmetadaten jetzt der
Serienname: „Folge 2×13" allein sagt bei 3815 Folgen nichts.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 18:21:43 +02:00
ScarriffleandClaude Opus 5 a6e9a6e425 Ein Klick auf einen Vorschlag sah aus wie gar kein Klick 
Hinter der Auswahl steckt ein Abruf bei TMDB, der Titel, Besetzung und
Bilder nachlädt — mehrere Sekunden, in denen die Oberfläche aussah wie
vorher. Wer nichts sieht, klickt noch einmal, und dann laufen zwei.
Jetzt tritt die Liste zurück, die gewählte Zeile bekommt einen
Akzentrahmen und daneben steht „Wird zugeordnet…" mit laufendem Kreis.

Dazu das Plakat je Vorschlag. „Dark" von 2017 und „Dark Shadows" von
1966 sind an einer Textzeile kaum zu unterscheiden, am Bild in einer
Zehntelsekunde — und der Server lieferte die Adresse ohnehin schon mit,
sie wurde nur weggeworfen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 17:58:06 +02:00
ScarriffleandClaude Opus 5 193a23a904 Ein Unterstrich ist ein Wortzeichen, und das kostete 3445 Dateien 
In `The Good Doctor_S02E18_Trampolin.mkv` steht vor dem S ein
Unterstrich. Das Muster verlangte dort `\b` — eine Wortgrenze sitzt aber
zwischen Wortzeichen und Nicht-Wortzeichen, und der Unterstrich ist
selbst eines. Zwischen `r` und `S` gab es damit keine Grenze, und der
gesamte Bestand aus einem Mediathek-Download fiel durch die Erkennung.
Die Rückschau verlangt jetzt ausdrücklich: kein Buchstabe, keine Ziffer
davor — ein Unterstrich schon.

Zwei weitere Muster kamen dabei ans Licht. Mediatheken nummerieren nach
Jahr (`Die Anstalt_S2024E04`); drei Ziffern für die Staffel waren zu
wenig. Und `# Folge 12 #` ist eine Folgennummer, nur auf Deutsch — die
Staffel kommt dann vom Ordner darüber, und nur wenn auch der keine
nennt, gilt die Übereinkunft Staffel 1.

Gemessen an den 3559 Pfaden aus dem Protokoll: 3554 werden jetzt
erkannt. Die fünf übrigen tragen wirklich keine Nummer — ein Titel in
einem Staffelordner, sonst nichts. Die Zahl der Serien steigt damit von
58 auf 95, und 95 ist die Zahl, die von Anfang an richtig war.

Die neuen Tests arbeiten mit genau diesen Namen. Die alten hatten den
Fehler nicht gefunden, weil in jedem ausgedachten Namen ein Leerzeichen
vor der Folgennummer stand.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 17:50:29 +02:00
ScarriffleandClaude Opus 5 cfb1e71762 3559 von 5884 Dateien verschwanden lautlos 
Der Scan erfindet keine Serie mehr, wenn weder Ordner noch Dateiname
eine nennen — richtig so. Nur wurde die Datei dann übersprungen, ohne
Zeile, ohne Spur. In der Mediathek standen 58 Serien und niemand konnte
sagen, wo die anderen geblieben sind.

Jetzt bekommt jede solche Datei eine Zeile ohne Zuordnung. Damit ist sie
zählbar, auflistbar und nach einer besseren Regel nachträglich
zuzuordnen. Untersucht wird sie nicht: ffprobe auf 3559 Dateien kostet
eine halbe Stunde für Angaben, die niemand zu sehen bekommt, und sobald
die Zuordnung steht, holt der nächste Lauf es nach.

Dazu ein Abschnitt "Nicht zugeordnet" in der Verwaltung, nach Grund
gebündelt und mit den Pfaden zum Aufklappen. Zwei Gründe gibt es, und
sie verlangen Verschiedenes: fehlt die Folgennummer, muss umbenannt
werden; fehlt der Serienname, genügt ein Ordner darum herum. Die Liste
lässt sich als Datei herunterladen — eine, die man markieren und
kopieren muss, schickt niemand.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 17:23:36 +02:00
ScarriffleandClaude Opus 5 a8bb98c44c Umsortiert wird gezogen, nicht geklickt 
Die Pfeile sind weg; eine Mediathek wird in der Seitenleiste an ihren
Platz gezogen. Mit Pointer Events statt HTML5-Drag: letzteres kennt kein
Telefon, zeichnet ein Geisterbild, das sich nicht gestalten lässt, und
liefert während des Ziehens keine brauchbaren Koordinaten.

Mit Schwelle von sechs Bildpunkten — sonst verschiebt jeder leicht
wackelige Klick die Reihenfolge, und ein Klick ohne Bewegung führt
weiterhin zur Mediathek, auch im Bearbeitungsmodus. Die weichenden
Zeilen gleiten, die gezogene folgt dem Zeiger ohne Verzögerung; bei
„Bewegung reduzieren" gleitet nichts.

Die Pfeiltasten bleiben auf der fokussierten Zeile, nur ohne sichtbare
Knöpfe. Ziehen ist mit der Tastatur nicht bedienbar, und eine Funktion,
die nur mit der Maus erreichbar ist, ist für den, der keine benutzt, gar
keine.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 17:09:28 +02:00
ScarriffleandClaude Opus 5 a22fa9b58e Drei Zähler für dieselbe Sache, und keiner davon offensichtlich falsch 
Während eines Scans stand in der Mediathek 20, in der Verwaltung 14 und
in der Seitenleiste 0. Die Verwaltung frischte alle fünf Runden auf, die
Seitenleiste erst am Ende des Laufs. Jetzt laufen beide auf demselben
Takt, alle drei Runden.

Dazu: während ein Lauf läuft, sind Scannen, Metadaten auffrischen,
Zurücksetzen und Entfernen gesperrt — die ersten beiden prallen am
Server ab und sind nur verwirrend, die anderen beiden löschen Zeilen,
während der Lauf welche schreibt. Umbenennen und Prüfung bleiben
bedienbar. Die Sperre richtet sich nach dem Zustand, den der Server
meldet, nicht nach dem Klick: wer die Seite neu lädt, während ein Lauf
läuft, findet sie ebenfalls gesperrt vor.

Die Reihenfolge der Mediatheken wird jetzt in der Seitenleiste
umsortiert, über „Seitenleiste bearbeiten" neben der Überschrift. Sie
wirkt dort, also gehört der Griff dorthin — vorher schob man in den
Einstellungen und musste danach nachsehen, ob es das war, was man
wollte.

Der Zuordnungsdialog zeigt die Herkunft: Ordner, Zahl der Dateien und
ein paar Namen. Liegt eine Zuordnung völlig daneben, sagt der angezeigte
Titel nichts mehr darüber, welche Datei gemeint ist.

Und SQLite läuft jetzt im WAL-Modus. In der Vorgabe sperrt ein Schreiber
die ganze Datei: solange der Scan schrieb, kam keine Leseanfrage durch.
Genau so sah es aus — Bilddialog und Protokoll liefen während eines
Laufs sporadisch ins Leere.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 16:31:50 +02:00
ScarriffleandClaude Opus 5 e1b3625809 Das Würfeln der Build-Kennung brach den ganzen Lauf ab 
`tr -dc … < /dev/urandom | head -c 6`: head schliesst die Pipe nach sechs
Zeichen, tr bekommt SIGPIPE, und mit `set -o pipefail` gilt das als
Fehlschlag. Das Skript endete mit 141, bevor es irgendetwas gebaut hatte
— dieselbe Falle, vor der dreissig Zeilen weiter oben eine Anmerkung
wegen `grep -q` steht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 15:58:18 +02:00
ScarriffleandClaude Opus 5 ac04901ccc Neun gemeldete Fehler, und die Frage, welcher Build gerade läuft 
Ein grosser Commit, weil die Punkte einander bedingen: ohne lesbare
Fehlermeldung war die Serienerkennung nicht zu diagnostizieren, und ohne
Build-Kennung nicht einmal festzustellen, ob überhaupt der gebaute Stand
läuft. Zwei der neun Meldungen betrafen Funktionen, die seit Stunden im
Quelltext stehen.

Version und Build. Die Version steht fest; daneben eine Kennung aus
sechs Zeichen, die sich bei jedem Docker-Bau ändert. Sie steht in der
Verwaltung, unter /health und im Protokoll bei jedem Start. Damit ist
"reden wir vom selben Build?" in zwei Sekunden beantwortet statt in
einem halben Tag.

Serien. Lag eine Datei direkt im Serienordner und trug vor der
Folgennummer nichts, wurde der ganze Dateiname zum Serientitel: aus 95
Serien wurden 737, jede mit einer Folge, bei jedem Lauf neu. Dazu lief
der Scan in Verweise hinein — derselbe Ordner unter zwei Namen ergab
zwei Serien. Und weder neue noch umgezogene Dateien standen in der
Pfadliste des Laufs, weshalb ein doppelt gesehener Pfad eine zweite
Zeile mit gleichem (LibraryId, Path) anlegte und der
Eindeutigkeitsindex den ganzen Speichervorgang scheitern liess. Jede
Serienanlage wird jetzt im Tagesprotokoll begründet.

Fehlermeldungen. "An error occurred while saving the entity changes"
stand englisch in einer deutschen Oberfläche und nannte weder Ursache
noch nächsten Schritt. Jetzt geht der vollständige Text ins Protokoll
und ein deutscher Satz ohne Fehlercode in die Anzeige — auch für
"Failed to fetch", das aus dem Browser kam und nie übersetzt wurde.

Protokolle. Die Ansicht holte die ganze Datei und zeigte 800 Zeilen
davon; bei zwei Megabyte brach die Verbindung ab. Gelesen wird jetzt
serverseitig rückwärts, mit einem Knopf für mehr.

Auswahlfelder. Die drei <select> zeichnete das Betriebssystem: ein
helles Systemmenü mitten in der dunklen Oberfläche. Ersetzt durch ein
eigenes Listenfeld mit Tastaturbedienung.

Bildwahl. Drei Raster untereinander in einem scrollenden Dialog hiess
zwei Scrollebenen übereinander. Jetzt ein Reiter je Bildtyp.

Sprache. Die Serversprache stand in der Serverliste zwischen Name,
Metadaten und Fassung — gesucht und nicht gefunden. Sie hat jetzt einen
eigenen Abschnitt ganz oben.

Dazu: ein Knopf, der den erfassten Inhalt einer Mediathek verwirft, ohne
Name und Pfad mitzunehmen; ein Abschnitt Speicher mit den drei Pfaden,
ihrer Belegung und dem Leeren des Bildspeichers; und die Korrektur einer
Zuordnung frischt nur noch die Kachel auf statt die ganze Seite.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 15:55:56 +02:00
ScarriffleandClaude Opus 5 ab8a66d898 Die Veröffentlichung meldete Erfolg, obwohl nichts ankam 
docker buildx build --push beendete mit Rückgabewert 0, nachdem es
"ERROR: failed to build" gedruckt hatte — ein TLS-Zeitlimit mitten im
Hochladen. Das Skript meldete "Fertig", in der Registry lag das alte Image,
und auf dem NAS wäre eine Fassung angekommen, die niemand gebaut hat.

Das ist die schlimmste Sorte Fehler: einer, der wie Erfolg aussieht.

Jetzt wird der Digest vor und nach dem Bau abgefragt. Antwortet die
Registry nicht, oder liegt dort noch derselbe Stand wie vorher, bricht das
Skript mit Rückgabewert 1 ab und sagt es.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 14:41:39 +02:00
ScarriffleandClaude Opus 5 fe44d45323 Verschobene Dateien hinterliessen eine Leiche 
Seit verschwundene Dateien markiert statt gelöscht werden, blieb nach jeder
Umbenennung die alte Zeile als "vermisst" stehen. Damit galt die alte Folge
nicht als verwaist, die alte Serie nicht als leer — und nach dem Umbenennen
eines Serienordners stand alles doppelt da.

Jetzt erkennt der Scan eine Verschiebung an Grösse und Änderungszeit und
hängt den vorhandenen Eintrag um, statt einen zweiten anzulegen.

Der Zeitstempel musste dafür auf Sekunden gerundet werden: er geht durch
die Datenbank und kommt nicht auf den Tick genau zurück. Mit Vergleich auf
Gleichheit schlug die Erkennung ausnahmslos fehl — der Test zeigte es,
nachdem er zweimal dasselbe falsche Ergebnis lieferte.

Grösse und Zeit müssen beide stimmen, und das Merkmal muss eindeutig sein.
Grösse allein reichte nicht: zwei gleich grosse Dateien gibt es, und die zu
vertauschen wäre schlimmer als eine Leiche.

Dazu: die Zahl der Titel läuft während eines Scans mit, statt erst am Ende
zu springen. Alle fünf Runden, nicht jede — ein Abruf je Sekunde für eine
Zahl wäre Verschwendung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 14:34:49 +02:00
ScarriffleandClaude Opus 5 b64497acd5 Nicht jede erfolgreiche Antwort hat einen Körper 
Bei jedem Scanstart stand in der Verwaltung "JSON.parse: unexpected end of
data" — eine Fehlermeldung für etwas, das tadellos funktioniert hatte.

Gemessen: der Scan-Endpunkt antwortet mit 202 Accepted, Content-Length 0
und ohne Content-Type. Er läuft im Hintergrund weiter, da gibt es noch
nichts zu melden. Der Abruf-Helfer behandelte aber nur 204 als leer und
liess JSON.parse auf eine leere Zeichenkette los.

Jetzt entscheidet der Inhalt, nicht der Status. Eine Liste von
Status-Codes wäre wieder eine, die beim nächsten Endpunkt unvollständig
ist.

Dazu: die Zeile "Metadaten" nannte die Sprache ein zweites Mal, obwohl sie
seit kurzem eine eigene Zeile hat.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 14:22:47 +02:00
ScarriffleandClaude Opus 5 98565e14b5 Der Ordner bestimmt die Serie, nicht der Dateiname 
Aus einer Serie wurden siebenhundert. Dateien wie "S01E001_Aang.mkv"
tragen vor der Folgennummer nichts, also wurde der ganze Dateiname zum
Serientitel — jede Folge eine eigene Serie. Und umgekehrt ergab
"Doctor Who (2005) - S12E04.mkv" im Ordner "Doctor Who" zwei Serien, weil
die Jahresangabe nur im Dateinamen stand.

Jetzt gilt: was unter Serien/Pingu/ liegt, gehört zu Pingu. Egal wie tief,
egal wie die Datei heisst. Der Ordner ist die verlässlichere Angabe, weil
ihn ein Mensch angelegt hat; so macht es Plex seit je und aus demselben
Grund. Staffel und Folge liest weiterhin der Dateiname.

Ohne bekannte Wurzel bleibt es beim Dateinamen — dort könnte über dem
Staffelordner irgendetwas stehen. Diesen Weg gehen nur die Tests.

Dazu vier Dinge aus der Benutzung:

Die Mediatheken standen scheinbar in zufälliger Reihenfolge. SQLite
vergleicht Text zeichengenau, und dort stehen alle Grossbuchstaben vor
allen kleinen: "Serien" landete über "film". Jetzt ohne Rücksicht auf
Gross- und Kleinschreibung — und umsortierbar über zwei Pfeile. Nicht über
Ziehen: das ist schöner, aber mit der Tastatur unbedienbar und auf dem
Telefon ein Glücksspiel.

Die Sprache des Servers steckte im Dialog "Metadaten", zusammen mit dem
TMDB-Schlüssel — also dort, wo niemand nach einer Sprache sucht. Wer die
Mediathek auf Englisch vorfand, sah nur "Meine Sprache" und hielt das für
die einzige Möglichkeit. Jetzt eine eigene Zeile.

Das Kontextmenü gab es nur per Rechtsklick, und den findet nur, wer ihn
vermutet — auf dem Telefon gibt es ihn gar nicht. Jetzt drei Punkte auf
jeder Kachel, beim Überfahren und bei Tastaturfokus, auf Geräten ohne
Zeiger dauerhaft. Und "Zuordnung korrigieren" steht endlich darin: wer
zwanzig falsch erkannte Titel vor sich hat, soll sie dort geradeziehen
können statt über vierzig Seitenwechsel.

Folgen ohne eigenes Bild nehmen das der Serie. TMDB liefert Folgenbilder
nur für einen Teil der Folgen und bei kleineren Serien für gar keine; eine
graue Fläche sagt nichts.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 14:20:00 +02:00
ScarriffleandClaude Opus 5 fa18c0d7fa Zwei Namen für denselben Titel brachen den ganzen Lauf ab 
Der Eindeutigkeitsindex aus Punkt 3 stellte die Regel auf, dichtete aber
den einen Weg nicht ab, auf dem sie verletzt wird: der Enricher setzt die
TMDB-Kennung, und sobald zwei Einträge derselben Mediathek dieselbe
bekamen, brach EF die gesamte Speicherung ab — mit "An error occurred
while saving the entity changes", einer Meldung, die den Grund nicht nennt
und den ganzen Scan mitnimmt.

Jetzt wird die Kennung nicht blind gesetzt, sondern vorgemerkt und nach
der Schleife zusammengelegt. Zwei Tests halten den Fall fest: der Anbieter
antwortet auf jede Anfrage mit demselben Film beziehungsweise derselben
Serie, also genau die Lage, die vorher den Lauf zerriss.

Dazu der wahrscheinliche Grund für die siebenhundert Serien: der
Serientitel kam ausschliesslich aus dem Dateinamen. Heisst eine Datei nur
"S01E01.mkv", steht vor der Folgennummer nichts, und der ganze Dateiname
wurde zum Serientitel — zwanzig Folgen ergaben zwanzig Serien namens
"S01E01", "S01E02", und so weiter. Jetzt sagt der Ordner den Namen, wenn
die Datei ihn nicht nennt; der Staffelordner wird dabei übersprungen, sonst
hiesse die Serie "Staffel 1". Plex und Jellyfin lesen ihn seit je so.

Dazu die Prüfliste: Folgen werden nach Serie gebündelt, weil zwanzig neue
Folgen eine Entscheidung sind und nicht zwanzig. Mit Mehrfachauswahl —
anhaken und gemeinsam freigeben oder auf einen Zeitpunkt legen. Und der
Zeitpunkt ist ein datetime-local statt eines Textfelds mit Formvorschrift,
bei dem jeder Tippfehler erst nach dem Absenden auffiel.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 13:58:33 +02:00
ScarriffleandClaude Opus 5 228c318ad2 Die Medientabelle spricht durchgehend dieselbe Sprache 
Die Tonzeile nahm bereits die Formulierung vom Server, die Videozeile baute
ihren Text weiter selbst — "240p (H264)" neben "AAC · Mono", zwei
Schreibweisen in derselben Tabelle untereinander. Die gemessene Auflösung
wandert in den Tooltip, wo sie hingehört: 1040 ist keine Stufe, sondern ein
beschnittenes Bild.

Dazu: ein Spurtitel, der nur die Sprache wiederholt, fällt weg. "Deutsch ·
AAC · Mono · ‚Deutsch'" sagt dasselbe zweimal.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 13:19:21 +02:00
ScarriffleandClaude Opus 5 632d3efa35 Neue Funde erst prüfen, dann veröffentlichen 
Je Mediathek einstellbar, Vorgabe aus: wer eine Mediathek anlegt, will sie
sehen. Angeschaltet warten neue Funde unter "Zu prüfen", bis jemand sie
freigibt — oder ihnen einen Termin gibt.

Ein Zeitpunkt, kein Zustandsfeld. PublishAt null heisst wartet, in der
Vergangenheit heisst veröffentlicht, in der Zukunft heisst geplant. Die
Sichtbarkeit wird bei der Abfrage gerechnet statt von einem Dienst
umgeschaltet; damit stimmt sie nach einem Neustart, nach einer
Zeitumstellung und auch dann, wenn der Server zum geplanten Zeitpunkt gar
nicht lief. Ein Ticker hätte in jedem dieser Fälle das Falsche getan.

Das eigentliche Risiko waren die zwanzig Abfragestellen in vier Dateien.
Schriebe jede ihren eigenen Filter, reichte eine vergessene — und
auffallen würde es nicht beim Programmieren, sondern wenn jemand im
Haushalt einen Titel sieht, den er nicht sehen sollte. Deshalb ein
globaler Abfragefilter in FlaroContext, der sich nicht vergessen lässt,
und eine Middleware, die je Anfrage setzt, wer Unveröffentlichtes sehen
darf. Vorgabe am Kontext ist "alles sehen", damit Scanner und Metadaten
ohne Benutzer arbeiten können; für jede HTTP-Anfrage entscheidet die
Middleware.

Der Test zählt die Inhaltsrouten auf und prüft jede einzeln auf die
Abwesenheit eines wartenden Titels. Eine neue Route, die den Filter
umgeht, fällt dort durch.

Die Migration trägt für alle vorhandenen Titel das Hinzufügedatum als
Veröffentlichung nach. Ohne diese zwei Zeilen stünde jeder auf null — und
der gesamte Bestand wäre für alle ausser Administratoren verschwunden,
sofort beim Start im Container und ohne Meldung.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 13:03:24 +02:00
ScarriffleandClaude Opus 5 eb63271e92 Ein Kontextmenü auf jeder Kachel — mitsamt Bildauswahl 
Gesehen, Favorit und Weglegen gab es ausschliesslich auf der Detailseite.
In einer Übersicht mit zwanzig Titeln hiess "die hab ich alle gesehen"
vierzig Seitenwechsel. Im ganzen Quelltext stand kein einziger
contextmenu-Zuhörer.

Drei Wege hinein, weil es drei Arten gibt zu bedienen: Rechtsklick für die
Maus, Shift+F10 und die Kontextmenü-Taste für die Tastatur, langer Druck
für den Finger. Nur den Rechtsklick anzubieten hiesse, das Menü auf dem
Telefon zu verstecken. Der lange Druck bricht bei jeder Bewegung ab, sonst
löst Scrollen ihn aus.

Die Aktionen wirken auf der Kachel selbst. Die Liste neu zu laden verlöre
Bildlauf und Filter — für einen Haken.

Dazu die Bildauswahl. Es gab genau einen Bild-Endpunkt, und der lieferte
nur aus: wählte TMDB ein schlechtes Plakat, blieb es. Jetzt stehen Plakat,
Hintergrund und Schriftzug zur Wahl, dazu eigene Bilder bis 10 MB. Die
Kandidaten kosten nichts — TMDB liefert sie beim Einzelabruf ohnehin mit,
und bisher wurde alles ausser dem Schriftzug weggeworfen.

Drei Merker je Titel, nicht einer: man kann ein eigenes Plakat wollen und
trotzdem automatische Hintergründe. Ohne sie überschriebe das nächste
Auffrischen jede Handauswahl, und wer einmal ein besseres Plakat gesucht
hat, suchte es jedes Mal neu.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:43:52 +02:00
ScarriffleandClaude Opus 5 e1399c808f Die Detailseite trägt wieder 
Drei Dinge, eins davon war mein Fehlbefund: Regie und Drehbuch werden sehr
wohl angezeigt — nur standen sie irgendwo zwischen dreissig Gesichtern.
Jetzt kommt der Stab zuerst, weil man beim Suchen eher die Regie im Kopf
hat als den zwölften Darsteller.

Bei Zeichentrick hängt TMDB "(voice)" an den Rollennamen, und so stand es
auch da — englisch, mitten im deutschen Text. Daraus wird "Stimme: Gru".

Ähnliche Titel als eigene Reihe, nachgeladen, damit die Seite sofort
steht. Aus dem eigenen Bestand gerechnet, nicht aus TMDBs
Empfehlungsliste: ein Vorschlag, den man nicht abspielen kann, ist
Werbung. Gemeinsame Menschen wiegen dreifach gegenüber gemeinsamen
Genres — dass zwei Filme "Drama" sind, sagt wenig; dieselbe Regie sagt
viel. Kostet keine einzige fremde Anfrage, der Katalog steht ohnehin in
der Datenbank. Findet sich nichts, erscheint die Reihe gar nicht.

Und der Hintergrund: er begann bei left: 240px, also hinter der
Seitenleiste, und war mit opacity .28 und blur(2px) weder Bild noch
Fläche. Jetzt über die volle Breite, kräftiger unscharf — er taucht die
Seite in die Farbe des Films, so wie bei Plex.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:37:55 +02:00
ScarriffleandClaude Opus 5 11a44f6a90 Ein Aufmacher über die volle Breite 
Die Startseite begann bei einer Reihe aus 150 px breiten Plakaten — das
grösste Element über dem Falz war 225 px hoch. Plex und Netflix öffnen mit
einem Bild über die ganze Breite, und das ist der grösste Einzelunterschied
im Eindruck. Ein Layout-, kein Farbproblem.

Bis zu sieben Titel, aus dem, was die Startseite ohnehin holt: erst
Angefangenes, dann Neuzugänge, dann Vorschläge. Kein zusätzlicher Abruf.

Nur mit Hintergrundbild. Ein Hero ohne Bild ist schlechter als keiner —
eine graue Fläche über den halben Bildschirm sagt nichts und nimmt den
Reihen den Platz. Gibt es keinen einzigen Titel mit Backdrop, entfällt er
ersatzlos.

Zwei Verläufe statt einem: der von unten lässt die erste Reihe sich
darüberschieben, der von links sorgt dafür, dass der Text trägt, auch wenn
das Bild dort hell ist.

Pause bei Mauszeiger und bei Tastaturfokus — wer gerade liest, soll nicht
nach neun Sekunden woanders landen. Bei "Bewegung reduzieren" wechselt er
gar nicht von selbst. Die Punkte sind echte Knöpfe mit Beschriftung; ein
div ist für Tastatur und Vorlesesoftware kein Bedienelement.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:34:57 +02:00
ScarriffleandClaude Opus 5 6bd9cdb12d Eine Formensprache statt vier Radien und sechs Schriftgrössen 
Die Oberfläche wirkte zusammengesetzt, nicht entworfen. Vier Gründe, alle
am Quelltext belegbar.

Die Farben waren von der App abgedriftet: elevated, placeholder, text,
text-dim, text-muted und die Trennlinie wichen in der letzten Stelle ab,
und der Standardakzent war in der App Lilac, im Browser Orchid. Einzeln
unsichtbar, zusammen genau der Grund, warum App und Browser nicht wie
dasselbe Programm aussahen. Alles auf FlaroDesign zurückgeführt.

Vier konkurrierende Radien — 6 auf Plakaten, 8 auf Karten, 999 auf jedem
Knopf, zweimal nacktes 3 — sind jetzt drei, und die ersten beiden stimmen
wieder mit FlaroDesign überein. Pillen bleiben, wo sie hingehören: Suche
und Filter.

Sechs Überschriftengrössen ohne Verhältnis zueinander sind eine Skala.
Der Kacheltitel war mit 13 px/500 leiser als die Metazeile daneben; das
erzeugt keine Hierarchie, sondern Rauschen.

Und der Akzent sass auf neun Dingen gleichzeitig. Wenn alles Akzent ist,
markiert er nichts. Der Primärknopf ist jetzt hell mit dunkler Schrift —
genau das macht Netflix, dessen Rot nur im Schriftzug vorkommt.

Dazu drei Dinge, die vorher ganz fehlten: ein sichtbarer Fokusring auf
allem Bedienbaren, ohne den die Oberfläche mit der Tastatur praktisch
unbedienbar war; Rücksicht auf "Bewegung reduzieren", das im Projekt
nirgends vorkam; und ein Hover, der mehr tut als zwei Bildpunkte zu
heben — mitsamt einem Abspielknopf, der nicht länger das halbe Plakat
verdeckt.

Tools/tokens-pruefen.py vergleicht beide Quellen und läuft im
Veröffentlichungsskript mit. Kein Generator: erzeugter Swift liest sich
schlechter als geschriebener, und die Prüfung fängt dasselbe ab.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:31:00 +02:00
ScarriffleandClaude Opus 5 0cd88acf70 Aus "DEU EAC3 6.0" wird "Deutsch · Dolby Digital Plus · 5.1" 
Die Werte gingen roh von ffprobe in die Anzeige. Jedes Stück war richtig
und keines verständlich: EAC3 heisst Dolby Digital Plus, MOV_TEXT heisst
schlicht Text, und sechs Kanäle sind 5.1 — "6.0" ist eine Schreibweise,
die es nicht gibt. Die Auflösung stand als gemessene Höhe da, also "1040p"
für ein beschnittenes Breitbild, was aussieht wie ein Fehler.

Benennung macht daraus Sätze, und zwar im Kern: die Apps brauchen
dieselben, und zweimal formuliert heisst dieselbe Tonspur am Fernseher
anders als im Browser.

CultureInfo taugte dafür nicht, zweimal gemessen: sein NativeName liefert
den Namen in der Sprache selbst — "English", "français" —, und für ein
erfundenes Kürzel wie "xyz" erfindet es stillschweigend eine Kultur, statt
zu scheitern. Also eine eigene Liste, über das zwei- und das
dreibuchstabige Kürzel, weil beide in Mediendateien vorkommen und ISO
639-2 für manche Sprachen zwei kennt.

Unbekanntes bleibt stehen statt zu "Unbekannt" zu werden — die rohe
Angabe ist immer noch eine Auskunft. Und "und" verschwindet ganz: ffmpeg
schreibt das für unbekannt, und als Sprache angezeigt sieht es aus wie
eine.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:28:17 +02:00
ScarriffleandClaude Opus 5 921533050b Zwei Titel je Film, und die Sprache lässt sich wählen 
Die Mediathek sah zweisprachig aus — "Despicable Me" neben "Ich einfach
unverbesserlich". Es gab nur ein Titelfeld, und welche Sprache darin
landete, entschied die Einstellung zum Zeitpunkt des Scans.

Movie und Series tragen jetzt zusätzlich OriginalTitle. Gesucht wird über
beide: wer "Despicable Me" tippt, findet "Ich einfach unverbesserlich".
Auf der Detailseite steht der Originaltitel unter dem übersetzten, wenn er
abweicht.

Die Sprache der Metadaten ist in der Verwaltung eine Auswahl statt eines
Textfelds. Vorher musste man "de-DE" wissen, und ein Tippfehler darin nahm
TMDB stillschweigend als Englisch an.

Dazu eine eigene Sprache je Benutzer. Das Ehrliche daran steht im Dialog:
die Daten liegen in einer Sprache vor, und wer eine andere wählt, bekommt,
was übersetzt vorliegt — für den Rest die Serversprache, nicht ein leeres
Feld. ItemTranslation hält die zweite Sprache, gefüllt über eine
Sammelaktion. Nicht nebenbei beim Öffnen: das verteilte die Wartezeit über
Wochen und träfe immer den, der gerade etwas sucht.

Alle Sprachen für alle Titel vorzuhalten wäre der Bestand mal Sprachen an
Abrufen und Speicher, für einen Haushalt mit zweien. Deshalb auf Ansage.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:23:47 +02:00
ScarriffleandClaude Opus 5 f359807561 Der Fortschritt sagt, woran er gerade ist — und schreibt es mit 
Vorher stand in der Verwaltung minutenlang "Wird durchsucht…", ohne
Hinweis, ob überhaupt etwas passiert. Bei vierzigtausend Dateien ist das
nicht zu unterscheiden von einem hängenden Lauf.

Scanschritt trägt Phase, Gegenstand und Zählstand und bildet daraus den
Satz selbst — im Kern und nicht in der Oberfläche, weil die Apps denselben
brauchen und zweimal formuliert er auseinanderdriftet. Sechs Phasen von
"Suche Medien in /media/Filme" über "Suche ‚Ich einfach unverbesserlich'
bei der Metadatenquelle — 44 von 1204" bis "Räume auf und lege Doppeltes
zusammen". Pfade werden auf die letzten zwei Bestandteile gekürzt.

ScanAsync und EnrichAsync bekommen je einen optionalen IProgress; optional
heisst, dass kein vorhandener Aufrufer bricht. Der Koordinator hält nur
den letzten Schritt — eine Liste über vierzigtausend Titel wäre ein Leck
im Arbeitsspeicher.

Dazu das Tagebuch: eine Datei je Tag unter config/logs, nach lokaler Zeit
und nicht nach UTC, weil ein Scan um 23 Uhr am heutigen Datum gesucht
wird. Dreissig Tage Aufbewahrung, einstellbar über FLARO_LOG_TAGE — ohne
Grenze läuft die config-Partition eines NAS lautlos voll. Es wirft nie:
ein volles Dateisystem darf keinen Scan abbrechen.

In der Verwaltung lesbar, nach Fehlern filterbar und herunterladbar. Das
Containerprotokoll ist nach einem Neustart weg und nur über SSH
erreichbar — die Frage "warum wurde der Film gestern Nacht nicht erkannt?"
liess sich damit nicht beantworten.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:15:18 +02:00
ScarriffleandClaude Opus 5 637e95fbb1 Die Verwaltung zeichnete sich endlos neu 
Gemessen am laufenden Server: nach dem Scan lief eine Schleife mit zwei
Abrufen je Runde, sichtbar als vier dauernd drehende Spinner.

Der Weg dahin: verfolgen() lief bei jedem Aufbau der Mediathekenzeile, sah
den Zustand finished, meldete das über geaendert(), und geaendert() war
mediathekenNeuLaden — also neu zeichnen. Der Neuaufbau startete verfolgen()
erneut, das wieder finished sah. Dass der Lauf längst vorbei war, machte
keinen Unterschied; der Zustand bleibt im Speicher stehen.

Zwei Dinge dagegen. verfolgen() meldet nur noch, wenn es selbst einen Lauf
angestossen hat — beim Aufbau zeigt es den Stand an und schweigt. Und die
Verwaltung frischt über zaehlerAuffrischen() nur noch die Seitenleiste auf
statt die ganze Seite neu zu zeichnen.

Dazu zwei Befunde aus dem Plan, die sich beim Nachsehen als falsch
erwiesen: die Takte werden sehr wohl abbestellt, dafür gibt es seit je
einen MutationObserver, und das Dashboard tauscht seinen Inhalt erst nach
dem Abruf. Geblieben ist der Spinner in den Listen, der bei jedem
Auffrischen erschien — der kommt jetzt nur noch beim ersten Aufbau.

Dazu der Zwischenspeicher für Ansichten. Der Router hängt sie aus statt
sie zu zerstören; beim Zurückkommen stehen sie sofort wieder da, mitsamt
Bildlauf, offenem Reiter und gesetzten Filtern, und laden leise nach.
Gemessen: null Abrufe und 4 von 4 Kacheln beim Zurückkommen aus der
Verwaltung. Höchstens fünf Ansichten, Verfall nach fünf Minuten,
weggeworfen bei allem, was den Bestand ändert. Detailseite und Verwaltung
sind ausgenommen — beide zeigen Laufendes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 12:11:06 +02:00
ScarriffleandClaude Opus 5 8b67a7ec88 Verschwundene Dateien werden gemeldet, nicht stillschweigend gelöscht 
Vorher räumte der Scan jede Datei weg, die er nicht mehr sah, und mit der
letzten Datei fiel der Titel samt Sehfortschritt aller Benutzer. Für eine
wirklich gelöschte Datei ist das richtig. Für eine Platte im Ruhezustand,
ein noch nicht eingehängtes Volume oder einen umbenannten Ordner ist es
Datenverlust — und für den Scan sehen alle vier Fälle gleich aus.

Jetzt trägt MediaFile ein MissingSince. Der Eintrag bleibt stehen, steht
in der Verwaltung unter "Nicht mehr gefunden", und gelöscht wird auf
Ansage. Taucht die Datei wieder auf, verschwindet die Markierung von
selbst.

Dazu die Notbremse, und sie ist der eigentliche Grund für den ganzen
Punkt: Fehlt der Wurzelpfad, oder liegt dort keine einzige Mediendatei
mehr, obwohl vorher welche da waren, bricht der Lauf ab und sagt warum.
Ohne sie erklärte ein nicht eingehängtes Volume beim Start des NAS den
gesamten Bestand für verschwunden — bei 458 Titeln.

Der Abschnitt in der Verwaltung erscheint nur, wenn es etwas zu melden
gibt. Ein dauerhaft leerer wäre Rauschen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 11:46:55 +02:00
ScarriffleandClaude Opus 5 01ff41fd71 Der Testhelfer wartet dreissig Sekunden statt fünf 
Die alte Grenze war für zwei, drei Dateien bemessen. Der neue Test über
120 Dateien schaffte sie allein, fiel aber durch, sobald die ganze Suite
nebenher lief — kein Fehler im Scan, sondern zu knappe Geduld.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 11:42:09 +02:00
ScarriffleandClaude Opus 5 63c7ebb6d5 Ein Film kommt je Mediathek genau einmal vor 
Der Scan verglich den Titel aus dem Dateinamen zeichengenau. Ein Punkt
Unterschied — Dr. Dolittle 2 gegen Dr Dolittle 2 —, oder eine Datei mit
Jahresangabe neben einer ohne, und es entstanden zwei Einträge. Die
Metadaten ordneten beide demselben TMDB-Eintrag zu, beide bekamen
denselben Titel, dasselbe Jahr, dasselbe Plakat, und nichts führte sie je
wieder zusammen.

Drei Ebenen, weil eine nicht trägt.

Titelschluessel vergleicht ohne Satzzeichen, ohne Akzente und ohne
Grossschreibung; ein fehlendes Jahr passt auf jedes, zwei bekannte
verschiedene trennen. Bewusst nicht aggressiver: Spider-Man und
Spiderman bleiben getrennt, und die beiden Dune von 1984 und 2021
sowieso. Ein zusammengelegter Film lässt sich nicht mehr trennen, ohne
zu wissen, welche Datei wohin gehörte.

Ein gefilterter Eindeutigkeitsindex auf (LibraryId, TmdbId) stellt die
Regel in die Datenbank statt in Code, der sie einhalten soll. Gefiltert,
weil ohne Metadaten alle Einträge null tragen.

Zusammenlegung räumt auf, was kein Vergleich erkennen könnte: Ich
einfach unverbesserlich und Despicable Me sind derselbe Film, und das
verrät allein die TMDB-Kennung. Läuft nach jedem Scan, und von Hand über
einen Knopf in der Verwaltung. Der Sehfortschritt wird gefaltet, nicht
umgehängt — die weitere Stelle gewinnt, gesehen gewinnt, weggelegt
gewinnt nicht.

Die Migration räumt zuerst auf und legt dann erst den Index an.
Andersherum scheiterte sie auf jeder Datenbank mit Dubletten, und zwar
beim Start im Container, wo die Meldung niemand sieht. Gemessen an einer
Datenbank mit zwei Dubletten und zwei Sehständen: 3 Filme auf 2, beide
Dateien erhalten, Position 1800 statt 300 behalten.

Dazu Fassungen. MediaFile.VersionLabel liest Mobil, 4K oder Director's
Cut aus dem Namen, sonst aus der gemessenen Bildhöhe. Die Liste ist
geschlossen, damit eine Fassung nicht YIFY heisst. Und der Fassungsname
beendet jetzt den Titel wie jedes andere Beiwerk — vorher wurde aus
"The Matrix (1999) - Mobil.mp4" der Film "The Matrix - Mobil", also ein
zweiter Eintrag neben dem Original. Genau die Dublette, um die es ging.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 11:39:10 +02:00
ScarriffleandClaude Opus 5 d01c5d43f4 Der Scan schreibt auch dann zwischendurch, wenn ffprobe scheitert 
Gemessen an achtzig Dateien: der Zählstand steht nach einer Sekunde bei
38, nach zwei bei 75, nach drei bei 80. Der Scan liefert also längst
laufend — anders als ich behauptet hatte. Der Grund steht in
UntersuchenAsync, das je Datei speichert; ich hatte nur das
SaveChangesAsync nach der Schleife gesehen.

Eine Lücke bleibt: scheitert die Untersuchung, kehrt sie vor dem
Speichern um. Ein Bestand aus Dateien, die ffprobe nicht lesen kann,
bliebe damit bis zum Schluss unsichtbar, und wer zusieht, hält den Scan
für hängend. Deshalb jetzt zusätzlich alle fünfzig Dateien ein Schreiben
aus der Schleife heraus — fünfzig und nicht jede, weil ein Schreibvorgang
je Datei bei vierzigtausend mehr kostet, als die Sichtbarkeit wert ist.

Für das Aufräumen danach ist das unbedenklich, aber nicht offensichtlich:
es löscht alles mit älterer SeenAt-Zeit als der Lauf, und würde die Zeit
irgendwo neu genommen statt vor der Schleife festgehalten, risse es den
halben Bestand mit. Ein Test über 120 Nulldateien — an denen ffprobe
scheitert, also genau der neue Weg — hält das fest.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 11:27:41 +02:00
ScarriffleandClaude Opus 5 b25c7a4712 Ordner durchklicken, statt den Pfad zu wissen 
Beim Anlegen einer Mediathek verlangte das Feld den Pfad im Container —
nicht den auf dem NAS. Diese Unterscheidung kennt nur, wer die
Compose-Datei selbst geschrieben hat, und ein Tippfehler darin ergibt
eine leere Mediathek ohne erkennbaren Grund.

Neben dem Feld steht jetzt ein Knopf, der die Ordner des Servers im
selben Dialog aufklappt: Pfadzeile in anklickbaren Stücken, Unterordner
darunter, unten der Knopf mit dem gewählten Pfad darauf.

Im selben Dialog und nicht in einem zweiten darüber: zwei gestapelte
Dialoge sind beim Schliessen immer eine Frage zu viel.

Das Feld bleibt tippbar. Wer den Pfad kennt, ist damit schneller, und
bei einem tiefen Baum ist es die einzige geduldschonende Möglichkeit.

An der Wurzel bleiben /proc, /sys, /usr und Verwandte aussen vor. Das
ist keine Absperrung — wer den Pfad kennt, tippt ihn weiterhin ein —,
sondern eine Liste aus zwanzig Einträgen, von denen achtzehn nie eine
Mediathek enthalten, ist unbrauchbar.

Ein Ordner ohne Leserecht wird gemeldet, nicht geworfen. Ohne das flöge
eine UnauthorizedAccessException bis in die Antwort und würde zur 500,
während die ehrliche Auskunft lautet: den darfst du nicht lesen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 11:22:16 +02:00
ScarriffleandClaude Opus 5 64fb61f2dc Ein typografisches Anführungszeichen zerriss die Zeichenkette 
Beim Einhängen des Ordner-Endpunkts stand „{path}" in einer
interpolierten Zeichenkette. Das schliessende Zeichen beendete sie
mitten im Satz, und der Rest las sich für den Übersetzer als Folge
unbekannter Bezeichner — zehn Fehler aus einer Zeile.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 10:45:05 +02:00
ScarriffleandClaude Opus 5 8a191d0faf Die Einrichtung läuft auch ohne HTTPS 
crypto.randomUUID gibt es nur im secure context — HTTPS oder localhost,
sonst nichts. Wer Flaro auf einem NAS betreibt und ihn unter
http://192.168.x.x:8097 aufruft, hat die Funktion nicht, und die
Geräteerkennung warf mitten in die Einrichtung „crypto.randomUUID is not
a function". Das Konto liess sich nicht anlegen.

Das ist nicht der Sonderfall. Ein Heimserver im eigenen Netz hat kein
Zertifikat, und genau dort wird die Einrichtung durchlaufen.

crypto.getRandomValues ist nicht so beschränkt und liefert denselben
Zufall; daraus wird die UUID von Hand zusammengesetzt. Fällt auch das
aus, bleibt Math.random — kein Zufall für Geheimnisse, aber hier geht es
nur darum, zwei Browser auseinanderzuhalten, und gar keine Kennung wäre
schlechter als eine schwache.

Geprüft mit 20000 Durchläufen: alle entsprechen der Form von Fassung 4,
keine Dublette.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 09:04:30 +02:00
ScarriffleandClaude Opus 5 3df873c8cd Der Arbeitsrechner baut, das NAS lädt nur 
Der Runner auf dem NAS scheitert an der Docker-App des UGREEN: sie lehnt
den Einhängepunkt /var/run/docker.sock ab. Nachgewiesen durch Halbieren
der Compose-Datei — ohne diese eine Zeile wird das Projekt angelegt, mit
ihr nicht, und die Meldung nennt keinen Grund.

Übrig blieben Docker-in-Docker mit privileged oder der Weg über SSH an
der Oberfläche vorbei. Beide geben dem Runner faktisch Root auf dem NAS,
und das für eine Aufgabe, die der Arbeitsrechner ohnehin erledigen kann:
er ist für die Apps nötig, weil Xcode nirgendwo sonst läuft.

Der Workflow löst deshalb nicht mehr bei jedem Push aus. Sonst sammelt
Gitea Läufe an, die niemand abarbeitet, und die Actions-Seite füllt sich
mit Leichen. Er bleibt als workflow_dispatch stehen, der Auslöser ist mit
drei Zeilen wieder da.

Die Anleitung stellt das Bauen vom Arbeitsrechner nach vorn und hält zwei
Dinge fest, die beim Einrichten Zeit gekostet haben: die Docker-App zieht
Images nicht selbst, und die Anmeldung an der Registry will ein
Zugriffstoken statt des Kontopassworts.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 08:47:42 +02:00
ScarriffleandClaude Opus 5 aa1e14cdab Der Runner fürs NAS, fertig zum Einsetzen
Image bauen und veröffentlichen / image (push) Canceled after 0s
Details 
Gitea verteilt Arbeit nur, es baut nicht selbst. Der Workflow ist auf dem
Server und hat einen Lauf angelegt — der bleibt liegen, weil niemand ihn
ausführt. Das ist keine Eigenheit dieser Installation, sondern wie Gitea
Actions arbeitet.

`server/docker-compose.runner.yml` ist der fehlende Teil, und er gehört
**auf das NAS**: dort läuft Docker ohnehin, und damit braucht ein neues
Image nie wieder einen Arbeitsrechner.

Zwei Dinge darin sind nicht offensichtlich und stehen deshalb als Kommentar
daneben: der Docker-Socket ist der Kern — der Runner baut nicht selbst,
sondern lässt den Docker des NAS bauen, und wer in diesen Container kommt,
kann Docker auf dem NAS steuern. Und `GITEA_RUNNER_LABELS` muss
`ubuntu-latest` nennen, weil der Flaro-Workflow genau das in `runs-on`
verlangt; ohne die Zeile meldet sich der Runner mit anderen Marken an und
der Lauf findet ihn nicht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 08:27:14 +02:00
ScarriffleandClaude Opus 5 fbf4a29461 Der Bildname kommt nicht mehr vom Repositoriumsnamen
Image bauen und veröffentlichen / image (push) Canceled after 0s
Details 
Das Repo heisst auf Gitea noch „halo", das Programm aber Flaro. Der
Workflow leitete den Bildnamen aus `gitea.repository` ab — das Image hiesse
`git.scarriffle.com/scarriffle/halo` und wäre die eine Stelle, an der der
alte Name überlebt. Das Skript daneben schreibt `flaro`; beides zusammen
ergäbe zwei Images für dieselbe Sache.

Gitea legt Pakete am **Besitzer** ab, nicht am Repository — sie dürfen
deshalb anders heissen als das Repo. Jetzt nehmen beide Wege
`<besitzer>/flaro`, überschreibbar über die Variable `IMAGE_NAME`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 08:10:41 +02:00
ScarriffleandClaude Opus 5 c12748e262 Ein Weg vom Quelltext in die Registry — und von dort aufs NAS 
Damit das Image dort landet, wo das NAS es holen kann.

**`.gitea/workflows/image.yml`** — Gitea baut selbst. Bei jedem Push auf
`main` entsteht das Image für **beide** Architekturen und landet in der
Registry desselben Gitea. Niemand muss daran denken, niemand muss angemeldet
sein, und niemand kann die Architektur vergessen.

Voraussetzung ist ein registrierter Act-Runner. Hat deiner keinen, läuft die
Datei nie an — dafür gibt es den zweiten Weg.

**`Tools/image-veroeffentlichen.sh`** — ein Befehl vom Arbeitsrechner, baut
amd64 und arm64 und lädt hoch. Angemeldet wird einmalig von Hand; das
Passwort tippt nur, wer es kennt.

Beides legt `:latest` ab, dazu den Kurz-Hash und auf einem Git-Tag dessen
Namen — damit sich eine Fassung festnageln lässt, statt immer „latest" zu
ziehen.

Die Anleitung bekommt vier neue Abschnitte: Gitea baut selbst, von Hand
bauen, das Paket öffentlich stellen, und **die Registry im NAS eintragen** —
also genau der Dialog „Quellname des Images", mit Alias `gitea` und Link
`https://git.scarriffle.com/`. Für ein privates Paket ein Zugriffstoken mit
`read:package`, nicht das Kontopasswort: ein Token lässt sich einzeln
widerrufen.

Die Beispiel-Compose zeigte auf `ghcr.io/scarriffle/flaro` — dort liegt
nichts und lag nie etwas. Jetzt auf die Gitea-Registry.

---

**Ein Fehler im eigenen Skript, gefunden beim ersten Lauf.** Die Prüfung
„läuft Docker?" war `docker info | grep -q .` — und `grep -q` beendet die
Pipe beim ersten Treffer, Docker bekommt SIGPIPE, und mit `set -o pipefail`
gilt das als Fehlschlag. Das Skript meldete „Docker läuft nicht", während
Docker lief und gerade ein Image gebaut hatte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 08:08:22 +02:00
ScarriffleandClaude Opus 5 f2b5ee633b Dialoge statt Blöcke, bessere Filter, ein Dashboard — und eine NAS-Anleitung 
**Was etwas anlegt oder ändert, steht jetzt in einem Dialog.** Das Formular
zum Anlegen einer Mediathek nahm als Block in der Seite Platz für etwas weg,
das man einmal im Monat braucht — und sah aus wie eine Eingabe, die noch
aussteht. Dasselbe für Benutzer, Umbenennen, den Servernamen und die
Metadaten-Einstellungen.

Gebaut mit dem `<dialog>` des Browsers, nicht mit einem nachgebauten: Escape
schliesst, der Hintergrund wird unbedienbar, der Tastaturfokus bleibt
gefangen, Vorlesesoftware kündigt ihn als Dialog an. Jede Zeile, die das
selbst baut, ist eine Zeile, die es schlechter kann. Scheitert das
Speichern, bleibt der Dialog offen — ihn zu schliessen hiesse, die Eingabe
wegzuwerfen und die Meldung dorthin zu schreiben, wo gerade niemand hinsieht.

**Die Filter sehen nicht mehr nach Eingabe aus.** Bei Plex stehen dort
Wörter mit einem kleinen Pfeil; ein umrandetes Auswahlfeld sagt „hier fehlt
noch etwas", und das stimmt nicht. Gesetzte Filter werden farbig, daneben
steht die Anzahl, und „Filter zurücksetzen" erscheint nur, wenn es etwas
zurückzusetzen gibt. Dazu neu: gesehen / noch nicht gesehen.

Das siebt vorerst in der Oberfläche, nicht am Server — er kann es noch
nicht. Der Preis steht in der Zahl daneben: sie zeigt dann „3 von 7".

---

**„Wird abgespielt" — wer gerade was schaut.**

Abgeleitet aus den Fortschrittsmeldungen, nicht aus einer eigenen Anmeldung
am Spieler: jeder Client meldet beim Abspielen ohnehin alle zehn Sekunden,
wo er steht. Wer das als Lebenszeichen liest, braucht kein zweites
Verfahren, das ein Client vergessen könnte — bleibt die Meldung aus, läuft
der Eintrag nach einer Minute von selbst ab.

Im Arbeitsspeicher, nicht in der Datenbank: „wer schaut gerade was" ist eine
Frage über den Augenblick. Nach einem Neustart lautet die Antwort „niemand",
und das zu speichern hiesse, Wiedergaben anzuzeigen, die es nicht gibt.

Zwei Geräte desselben Menschen sind zwei Zeilen — derselbe Mensch kann auf
dem Fernseher und auf dem Telefon gleichzeitig etwas laufen lassen.
Geschlüsselt wird deshalb über das Gerätetoken, nicht über den Benutzer und
nicht über den Gerätenamen: zwei iPhones heissen beide „iPhone".

**Nur für Administratoren.** Wer wann welchen Film anschaut, ist eine
Auskunft über Menschen, nicht über den Server. In einem Haushalt mag das
harmlos sein; die Vorgabe eines offenen Projekts darf es trotzdem nicht sein.

Der Spieler meldet beim Schliessen ausdrücklich „beendet". Ohne das stünde
ein geschlossener Film noch eine Minute als „läuft" — und wer gerade den
Spieler zugemacht hat, sähe sich selbst beim Schauen zu.

---

**`docs/NAS-EINRICHTEN.md`** beantwortet die Frage, die offen war: **es ist
ein einziges Image.** Die Weboberfläche wird beim Bauen hineingelegt und vom
Server selbst ausgeliefert — ein Container, drei Volumes, kein Proxy, keine
Datenbank daneben.

Drei Wege aufs NAS: über die Container-Registry deines Gitea (die läuft —
nachgeprüft), als Datei über `docker save`, oder dort bauen. Dazu der
Schritt, den man am leichtesten überspringt und am teuersten bezahlt: die
Architektur. Ein Mac baut ohne Angabe arm64, ein Intel-NAS braucht amd64,
und `exec format error` sagt das nicht deutlich.

Eine Zahl darin war geraten und ist korrigiert: `docker save | gzip` ergibt
nicht 90 MB, sondern 230 — die Ebenen eines Images sind bereits gepackt.

378 Tests grün, sechs davon neu.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 08:03:07 +02:00
ScarriffleandClaude Opus 5 a7ec3a73ba Angemeldet bleiben — und eine 401 reisst nicht mehr die Sitzung ab 
Erst die ehrliche Hälfte: dass es heute **andauernd** abgemeldet hat, geht
auf mein Konto. Ich habe die Datenbank dreimal geleert, um mit frischen
Metadaten zu bauen; jedes Mal verfallen alle Token. Kein Schalter der Welt
hätte das verhindert.

Die andere Hälfte ist ein echter Fehler, und er macht aus einem Aussetzer
eine Abmeldung:

**Eine einzelne 401 warf die Anmeldung weg** — und rief dabei
`/auth/logout`, der Server zog das Token also *aktiv zurück*. War die
Ablehnung nur ein Aussetzer, war eine intakte Anmeldung damit absichtlich
zerstört, und zwar unwiderruflich. Jetzt wird einmal nachgefragt: gilt das
Token wirklich nicht mehr, ist die Sitzung vorbei; antwortet der Server, war
es diese eine Anfrage. Mehrere gleichzeitige Anfragen laufen in dieselbe
Prüfung — sonst stellte eine Startseite mit acht Abfragen achtmal dieselbe
Frage. Antwortet der Server **gar nicht**, ist das kein Beleg gegen das
Token: jemanden abzumelden, weil das WLAN hakt, ist der falsche Schluss.

**Abmelden scheitert nie mehr.** Vorher verlangte der Weg eine gültige
Anmeldung — und genau dann, wenn man ihn am dringendsten braucht, gibt es
keine. Nach dem Leeren des Datenbestands zeigte das Cookie im Browser auf
ein Token, das es nicht mehr gab; es ging bei jedem Bild erneut hinaus, und
der Server lehnte es jedes Mal ab. Achtzig Ablehnungen in einer Stunde, und
nichts davon liess sich von aussen beenden. Jetzt wird das Cookie immer
gelöscht; widerrufen wird, was sich widerrufen lässt.

---

**Und der Schalter, um den es ging.** „Angemeldet bleiben" steht jetzt im
Anmeldefeld, mit Haken als Vorgabe — am eigenen Rechner will sich niemand
täglich neu anmelden.

Umgesetzt über die beiden Speicher, die der Browser ohnehin richtig
aufräumt: mit Haken `localStorage` und ein Cookie für ein Jahr, ohne Haken
`sessionStorage` und ein Sitzungscookie, das mit dem Fenster verschwindet.
Ein eigenes Verfallsdatum zu verwalten wäre die schlechtere Variante — eine
Uhr, die man stellen kann, gegen zwei Mechanismen, die es schon gibt.

Das Token selbst läuft weiterhin **nie** ab; es wird widerrufen, nicht
vergessen. Was hier entschieden wird, ist allein, wie lange der Browser sich
erinnert.

372 Tests grün, vier davon neu. Am Container nachgemessen: mit Haken
`max-age=31536000`, ohne Haken kein `max-age`, und ein Abmelden mit
ungültigem Cookie antwortet 204 statt 401.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 07:40:19 +02:00
ScarriffleandClaude Opus 5 8c395ac051 Die Oberfläche nach Plex' Vorbild — Hintergrund, Schriftzug, Besetzung 
Nach den Bildern deiner Plex-Installation umgebaut. Übernommen ist der
Aufbau, nicht die Farbe: Plex ist bernsteingelb, Flaro bleibt Orchidee.

**Kopfleiste oben** mit Marke, Suche und Konto. Die Suche gehört dorthin und
nicht in jede Mediathek: wer einen Titel sucht, weiss oft gar nicht, in
welcher er liegt. Sie geht quer durch alles.

**Seitenleiste mit Icons** — echte SVG, keine Zeichen aus einer Schriftart.
Ein ▶ aus Unicode sieht auf jedem System anders aus, lässt sich nicht
einfärben und springt in der Grundlinie. Die aktive Zeile bekommt einen
schmalen Balken links statt eines leuchtenden Blocks; das liest sich in
einer langen Liste ruhiger.

**Die Kachel steht jetzt an einer Stelle** statt an fünfen. Sie trägt den
Haken für Gesehenes in der Ecke — wie bei Plex, ein Blick über das Raster
genügt —, die Zahl offener Folgen an derselben Stelle, den Fortschrittsbalken
unten und beim Überfahren einen Abspielknopf. Folgen sind dreizeilig: Serie,
Folgentitel, „S14 · F22".

**Reihen haben Pfeile.** Zwanzig Kacheln passen nicht in den Bildschirm, und
quer zu scrollen geht mit dem Rad nur mit Umschalttaste. Die Überschrift
nennt die Mediathek beim Namen: „Zuletzt in Dokumentationen hinzugefügt".

**Mediatheken haben drei Reiter** — Empfehlungen, Mediathek, Kategorien.
Darunter eine Filterzeile mit Genre, Sortierung und der Anzahl. Die
Kategorien sind farbige Kacheln; die Farbe kommt aus dem Namen, nicht aus
einer festen Liste, die jedes Genre kennen müsste, das TMDB je erfindet.

**Die Detailseite** hat jetzt den unscharfen Hintergrund über die ganze
Seite, den **Schriftzug des Films** statt der Systemschrift, eine Zeile mit
Jahr, Genres, Laufzeit, Altersfreigabe und Bewertung, runde Knöpfe für
gesehen/Favorit/weglegen, die Medienangaben als Tabelle — Datei, Video, Ton,
Untertitel — und zuletzt Besetzung & Stab mit runden Porträts.

**Dazu am Server:** ein Name. Ohne ihn zeigten die Clients den Hostnamen,
und die App schrieb „localhost" über die Anmeldung. Vorgabe ist der
Rechnername des Containers.

---

**Der Fehler, den das erste Bild zeigte:** die Lupe in der Suchleiste war
dreihundert Bildpunkte gross und lag über der halben Seite. Ein rohes
`<svg>` ohne Breite füllt seinen Container; die Regel galt nur für `.icon`.
Jetzt für jedes.

368 Tests grün. Am Container nachgesehen: „Der Untergang" mit eigenem
Schriftzug, FSK 12, Bewertung 7,9, Genres Drama/Historie/Kriegsfilm, beide
Tonspuren in der Tabelle, 22 Porträts darunter.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-04 01:04:27 +02:00
ScarriffleandClaude Opus 5 ede4069cd4 Der Server weiss jetzt mehr als Titel und Plakat 
Bisher standen zu einem Film vier Angaben in der Datenbank: Titel, Jahr,
Beschreibung, zwei Bilder. Damit lässt sich eine Kachel zeichnen und sonst
nichts — keine Detailseite, die mehr sagt als der Dateiname, keine
Vorschläge, kein Filter nach Genre. Alles drei hing daran.

Jetzt kommen dazu: **Laufzeit, Bewertung, Werbezeile, Altersfreigabe,
Genres, Besetzung, Stab — und der Schriftzug des Titels.** Letzterer ist
das, was eine Startseite teuer aussehen lässt: „Blade Runner 2049" in seiner
eigenen Schrift über dem Hintergrundbild statt in der Systemschrift.

**Alles in einer Anfrage.** `append_to_response` hängt Besetzung,
Fremdkennungen, Freigaben und Bilder an den Einzelabruf. Vier getrennte
Anfragen je Titel wären bei vierhundert Filmen sechzehnhundert, und TMDB
begrenzt, wie oft man fragen darf. Der eigene Abruf der IMDb-Kennung ist
dabei entfallen — sie hängt jetzt mit dran.

Freigaben sind national: die FSK gilt in Deutschland, die MPAA in den USA,
und TMDB führt beide nebeneinander. Genommen wird die des eingestellten
Landes. Beim Schriftzug entscheidet zuerst die Sprache und erst danach die
Bildbewertung — ein deutscher Titel in deutscher Schrift schlägt den besser
bewerteten englischen.

Vom Stab nur Regie und Drehbuch. TMDB führt dort auch Beleuchter und
Caterer; eine Detailseite, die alle nennt, nennt nichts.

**Genres und Personen als eigene Tabellen**, nicht als Text im Film. Sonst:
filtern über `LIKE`, Tippfehler als eigenes Genre, und bei einer Umbenennung
vierhundert Zeilen anfassen. Personen über die Kennung der Quelle geführt,
nicht über den Namen — es gibt zwei Schauspieler namens „Chris Evans".

Darauf sitzen zwei neue Endpunkte: ein Filter nach Genre (nur die, die in
der Mediathek auch vorkommen — ein Knopf zu einer leeren Liste ist schlimmer
als kein Knopf) und **Vorschläge** über die Genres des zuletzt Gesehenen.
Keine Empfehlungsmaschine: ein Haushaltsserver hat keine Millionen
Sehverläufe, aus denen sich etwas lernen liesse. Eine schlichte Regel ist
nachvollziehbar, was eine undurchschaubare Empfehlung nie ist.

---

**Zwei Fehler, beide fand erst der echte Lauf.**

`UNIQUE constraint failed: Genres.Name`, und damit scheiterte der ganze
Scan — in der Mediathek erschien kein einziger Titel. Vier Bibliotheken
scannen gleichzeitig, jede mit eigenem Datenbankkontext; zwei stossen auf
„Drama", keine sieht die ungespeicherte Zeile der anderen. Statt die Läufe
zu serialisieren — das kostete bei zehn Bibliotheken das Zehnfache an Zeit —
wird der Fehlschlag hingenommen und die Zeile des anderen benutzt. Sie steht
ja genau dafür da.

Und: **eine geänderte Sprache erreichte vorhandene Titel nie.** Ein zweiter
Scan fragt nichts erneut, das ist Absicht. Wer aber von Englisch auf Deutsch
stellt, bekam deutsche Titel erst beim nächsten neuen Film. Dafür gibt es
jetzt „Metadaten auffrischen" je Bibliothek — geholt über die bekannte
Kennung, nicht über eine neue Suche, damit eine Zuordnung von Hand
stehenbleibt.

368 Tests grün, zehn davon neu. Am Container nachgewiesen: „Der Untergang",
156 Minuten, FSK 12, Bewertung 7,9, Genres Drama/Historie/Kriegsfilm,
22 Mitwirkende mit Rollennamen, Schriftzug und Hintergrund da — und nach dem
Umstellen auf de-DE heisst er nicht mehr „Downfall".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 23:12:35 +02:00
ScarriffleandClaude Opus 5 230beb9664 Mehrere Mediatheken, jede für sich 
Bisher gab es in der Seitenleiste „Filme" und „Serien" — zwei feste Zeilen,
hinter denen alles zusammenfiel, was der Server kannte. Wer „Filme" und
„Dokumentationen" getrennt angelegt hatte, sah sie wieder in einem Topf.
Das nahm die Entscheidung zurück, sie zu trennen.

Jetzt führt die Seitenleiste **jede Mediathek einzeln**, mit Namen und Zahl,
wie bei Plex und Jellyfin. Die Startseite bekommt je Mediathek eine Reihe
mit dem zuletzt Hinzugefügten; steht mehr drin, als die Reihe zeigt, führt
„Alle zeigen" dorthin. Die Mediathekenseite trägt den Namen im Titel, sucht
innerhalb der Mediathek und lässt sich sortieren.

**Am Server dafür:**

`?sort=` auf `/movies` und `/series` — `title`, `added`, `year`. Der Titel
immer als letzter Vergleich, sonst hätten zwei Filme aus demselben Jahr keine
feste Reihenfolge und Seite 2 zeigte denselben Film noch einmal oder gar
nicht.

Die Liste der Bibliotheken nennt je Zeile einen Zählwert. „Dokumentationen ·
0" sagt mehr als ein Eintrag, hinter dem sich nach dem Klick nichts findet —
da ist der Unterschied zwischen „noch nicht gescannt" und „falscher Pfad"
wenigstens sichtbar. `null` heisst „nicht gezählt", nicht „leer".

Umbenennen und Entfernen, beides nur für Administratoren. **Umbenennen, mehr
nicht:** die Art zu ändern hiesse, Filme in Serien zu verwandeln; den Pfad
zu ändern hiesse, einen Bestand gegen einen anderen zu tauschen, während die
Einträge stehenbleiben. Beides ist kein Bearbeiten, sondern eine neue
Bibliothek.

**Beim Entfernen bleiben die Mediendateien liegen.** Weg sind der Eintrag,
die Zuordnungen und der Sehfortschritt aller Benutzer dazu; die Oberfläche
sagt das vorher, und eine Prüfung hält fest, dass die Datei danach noch da
ist. Ein Server, der beim Aufräumen in der Oberfläche fremde Filme löscht,
ist einer, den man nicht noch einmal benutzt.

---

**Der Fehler, den der Browser zeigte, und er betrifft jeden Betrieb:** nach
einem Server-Update lief weiter die alte Oberfläche.

Die Dateien unter `assets/` tragen eine Prüfsumme im Namen — ändert sich der
Inhalt, ändert sich der Name. `index.html` trägt keine; sie nennt nur deren
Namen. Lag sie im Zwischenspeicher, bekam der Browser weiter die alte App:
nicht kaputt, sondern veraltet, und das fällt niemandem auf. Nachgemessen:
geladen war `index-C0K3V8eg.js`, ausgeliefert wurde längst
`index-DomHN4_b.js`.

Jetzt zwei Lebensdauern — `no-cache` für die Seite, ein Jahr und `immutable`
für die Bausteine. Mit Prüfung, und am Container nachgemessen.

Der Beispielbestand bekommt zwei weitere Mediatheken, „Dokumentationen" und
„Konzerte". Mit nur Filme und Serien liesse sich gar nicht prüfen, ob
mehrere wirklich getrennt bleiben — zwei Bestände **derselben Art** sind der
Fall, in dem es auffällt.

358 Tests grün. Am Container nachgewiesen: vier Mediatheken in der
Seitenleiste mit Zählwerten, je eine Reihe auf der Startseite, und
„Dokumentationen" zeigt zwei Titel statt sieben.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 22:57:25 +02:00
ScarriffleandClaude Opus 5 172b38da06 Die Apps können jetzt beides: Jellyfin oder Flaro 
`FlaroServerKit` steht neben `JellyfinKit`, nicht darin — genau auf dem
Steckplatz, den Plex geräumt hat. Dass `MediaBackend` zwei Server zugleich
trägt, war schon einmal bewiesen; die Naht hat gehalten, und keine einzige
Ansicht musste dafür neu geschrieben werden.

`ServerKind` ist zurück. Es wurde beim Entfernen von Plex gestrichen, weil
ein Aufzählungstyp mit einem Fall ein umständliches Bool ist. Jetzt gibt es
wieder zwei, und es ist wieder eine Unterscheidung — einer zur Zeit, nicht
beide nebeneinander.

**Flaro steht oben auf dem Anmeldebildschirm.** Nicht aus Eitelkeit: dort
bringt ein Download alle Tonspuren mit und der Fortschritt wird ab der
ersten Sekunde gemerkt. Wer Jellyfin benutzt, sucht gezielt danach — wer neu
anfängt, soll nicht in der schwächeren Hälfte landen, weil ihr Knopf
auffälliger war. Am Fernseher steht bei beiden der sechsstellige Code voran.

---

**Der Zugang geht als Cookie, nicht in der Adresse.** Jellyfin hängt sein
Token an jede Bildadresse, weil eine Bildansicht keine Kopfzeilen schickt;
es steht damit in jedem Zugriffsprotokoll und jedem weitergegebenen Link.
Flaro tut das nicht, und deshalb legt der Client sein Token selbst im
gemeinsamen Keksspeicher ab — auch beim Wiederaufnehmen aus dem
Schlüsselbund, wo gar keine Anmeldung stattfindet und der Server es nie
setzen könnte.

`URLSession` schickt es von allein mit; **AVFoundation nicht**. Der
Systemplayer bekommt die Kekse jetzt ausdrücklich. Serverneutral: wo keine
liegen, ist die Liste leer.

**`BackendCapability.allTracksDownload`** statt einer Spurwahl, die ins
Leere führt. Die Frage „welche Tonspur?" gibt es nur, weil Jellyfins
Transcoder eine je Sitzung abbildet. Bei Flaro führen beide Antworten zum
selben Ergebnis — also wird nicht gefragt, und das Umpacken mit einer
einzigen Spur entfällt gleich mit.

**Die Adressraterei wandert nach `MediaKit`.** Sechzig Zeilen sorgfältig
begründeter Reihenfolge — IP-Adressen sprechen selten HTTPS, Domänennamen
fast immer — unterscheiden sich zwischen beiden Servern nur im Standardport.
Zweimal hingeschrieben wäre die eine Fassung beim nächsten Sonderfall
nachgezogen worden und die andere nicht. Jellyfins Prüfungen laufen
unverändert gegen die verschobene Fassung; das ist der Beweis.

**Nebenbei zwei Altlasten:** `player.jellyfinPending` war unerreichbar — der
Player zeigt diese Meldung nur, wenn gar kein Server da ist, dann aber nie
die mit Jellyfin. Und `signIn.jellyfin.userName` hiess „Benutzername"; der
Schlüssel heisst jetzt so neutral wie der Text.

---

**Der Fehler, den erst der Simulator zeigte:** „Stelle wird
wiederhergestellt", 0:00, für immer.

Muss der Server umpacken, antwortet er auf den Download mit 202 und fängt
an. AVPlayer bekommt darauf kein Video, sondern eine leere Antwort — und
wartet, unbegrenzt, ohne Fehler. Die Weboberfläche fragt in einer Schleife
nach; `preparePlayback` tat es nicht. Jetzt wartet es, mit Obergrenze und
einer Begründung, wenn sie reisst. Mit Prüfung, die zwei Runden erzwingt.

413 Tests grün. Im Simulator gegen den echten Server nachgewiesen: Adresse
eintippen, Server gefunden, angemeldet, Mediathek mit Plakaten, Neustart
ohne erneute Anmeldung — und eine MKV abgespielt, die der Server dafür erst
umpacken musste. Danach stand auf dem Server: Matrix, 2,0 s von 2,0 s,
gesehen, ein Durchlauf.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 22:00:02 +02:00
ScarriffleandClaude Opus 5 6d5824b889 Weiterschauen, sichtbar gemacht 
Die Oberfläche zeigt jetzt, was der Server seit Stufe 4 weiss.

Auf der Startseite zwei neue Reihen, ganz oben: **Weiterschauen** und
**Nächste Folge**. Sie überschneiden sich nicht — was angefangen ist, steht
links, was ansteht, rechts. Eine leere Reihe wird gar nicht erst gezeigt.

Auf jeder Kachel ein Balken, und zwar **ab der ersten Sekunde**. Bei einem
Zweieinhalbstünder sind zwei Minuten 1,3 % — anderthalb Bildpunkte. Der
Balken hat deshalb eine Mindestbreite, sonst wäre das Versprechen „wir merken
uns jede Sekunde" ausgerechnet dort unsichtbar, wo es zählt. Serien tragen
die Zahl offener Folgen als Plakette in der Ecke.

Auf der Detailseite stehen **beide Knöpfe nebeneinander**: „Weiterschauen ab
0:42" und „Von vorn". Auch bei einem gesehenen Film — der Server wirft die
Stelle nicht weg, wenn das Häkchen kommt, und sie hier zu verschweigen hiesse,
genau den Unterschied wegzuwerfen, um dessentwillen er sie behält. Dazu ein
Schalter für gesehen/ungesehen.

Der Spieler meldet alle zehn Sekunden, beim Pausieren, am Ende und beim
Schliessen. Nicht bei jedem `timeupdate`: das feuert viermal je Sekunde, und
daraus Anfragen zu machen hiesse, den Server mit Meldungen zu bewerfen, die
sich um 250 ms unterscheiden. Eine verlorene Meldung kostet ein paar Sekunden
Fortschritt — dafür mitten im Film einen Fehler einzublenden wäre die
schlechtere Hälfte des Tauschs.

**Nebenbei ein Fehler beseitigt, der nur mit grosser Mediathek aufgefallen
wäre:** die Detailseite holte 200 Titel und suchte darin nach der Kennung.
Bei 201 Filmen hätte sie vom letzten behauptet, es gebe ihn nicht mehr. Jetzt
gibt es den Einzelabruf, und sie benutzt ihn.

Im Container durchgespielt: „Der Untergang" von vorn, die MKV wird umgepackt,
läuft durch — danach steht „Gesehen" unter dem Titel, der Balken ist voll,
und der Knopf bietet beides an.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 21:33:56 +02:00
ScarriffleandClaude Opus 5 67cf0fd1d9 HEAD auf den Download, und /api verschluckt nichts mehr 
Zwei Fehler, derselbe Grund — und beide zeigte erst der Browser.

**Der Spieler bekam die Webseite statt des Films.** „MEDIA_ELEMENT_ERROR:
Format error", 531 Byte, `Content-Type: text/html`. Das ist genau die Grösse
von `index.html`.

`MapGet` nimmt HEAD nicht an. Die Oberfläche fragt aber mit HEAD nach, ob das
Umpacken fertig ist — einen halbfertigen Film herunterzuladen, nur um das zu
erfahren, wäre absurd. Die Anfrage fiel durch den Methodenabgleich hindurch
bis zum SPA-Rückfall, und der nimmt jeden Pfad ohne Dateiendung. Antwort:
200, mit der Startseite im Rumpf. Der Client hielt das Umpacken für fertig
und reichte HTML an `<video>` weiter.

Jetzt `MapMethods` mit GET und HEAD. Kestrel lässt den Rumpf bei HEAD selbst
weg.

**Und ein vertippter Aufruf sah aus wie ein Erfolg.** `GET /api/v1/gibtsnicht`
gab 200 und die Webseite zurück — derselbe Rückfall. Ein Fehler, der erst
dort auffällt, wo jemand HTML durch einen JSON-Parser schickt.

`app.Map("/api/{*rest}", 404)` davor. Buchstaben schlagen Platzhalter, also
gewinnt jeder echte Endpunkt; was übrig bleibt, ist nicht da und sagt das
auch.

350 Tests grün, die zwei neuen eingerechnet. Am Container nachgemessen: HEAD
auf den Download gibt 200 `video/mp4` mit 71 920 Byte, `/api/v1/gibtsnicht`
gibt 404, und ein Neuladen auf `/verwaltung` bekommt weiterhin die Seite.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 21:33:56 +02:00
ScarriffleandClaude Opus 5 c4081ff251 Stufe 4: Fortschritt ab der ersten Sekunde, ohne Schwelle 
Der Anlass für diesen Server, jetzt als Code. Fortschritt, Gesehen-Status,
Weiterschauen, Nächste Folge, Favoriten und Bewertungen — alles je Benutzer.

**Die Jellyfin-Werte sind jetzt belegt statt behauptet.** Das Entwurfsdokument
hatte das ausdrücklich offengelassen („aus dem Gedächtnis"); hier stehen sie
aus `MediaBrowser.Model/Configuration/ServerConfiguration.cs` und
`Emby.Server.Implementations/Library/UserDataManager.cs`:

| | Vorgabe | Was passiert |
|---|---|---|
| `MinResumePct` | 5 | darunter `positionTicks = 0` — Kommentar im Quelltext: „ignore progress during the beginning" |
| `MaxResumePct` | 90 | darüber gesehen, Position **auf 0** |
| `MinResumeDurationSeconds` | 300 | alles unter fünf Minuten gilt nach dem ersten Lebenszeichen als gesehen |

Bei einem Zweistünder sind die ersten sechs Minuten damit weg. Eine
vierminütige Folge gilt nach dreissig Sekunden als vollständig gesehen. Und
fehlt die Laufzeit, nimmt Jellyfin an, der Titel sei durch — wörtlich:
„we'll just have to assume it was fully played".

**Flaro legt jede Meldung ab und wirft nie eine Position weg.** Eine Grenze
fürs Häkchen gibt es trotzdem — 90 %, sonst stünde jeder zu Ende geschaute
Film für immer bei 98 % in Weiterschauen. Der Unterschied ist nicht, *dass*
es die Grenze gibt, sondern was sie anrichtet: hier wird ein Häkchen gesetzt,
dort zusätzlich die Stelle vernichtet. Wer einen gesehenen Film noch einmal
anfängt, hat beides — das Häkchen und den Punkt, an dem er steht.

Ohne bekannte Laufzeit wird nichts vermutet. Das ist der Fehler, den man
nicht zurücknehmen kann, ohne ihn zu bemerken.

---

**Eine Spalte statt einer zweiten Regel.** „Gehört in Weiterschauen" vergleicht
die Stelle mit einem Anteil der Laufzeit, und diese Rechnung lässt sich nicht
nach SQL übersetzen. Die Regel daneben noch einmal als Abfrage zu schreiben
wäre die Variante, bei der beide irgendwann auseinanderlaufen — unbemerkt,
weil keine von beiden dabei falsch aussieht. Stattdessen hält `InProgress`
das Ergebnis fest, geschrieben an genau einer Stelle. Eine Prüfung hält Reihe
und Regel über vier Stände gegeneinander.

**„Weiterschauen" und „Nächste Folge" überschneiden sich nicht.** Was
angefangen ist, steht links; was ansteht, rechts. Jellyfin zeigt beides
doppelt, und auf einer Startseite mit zwei Reihen nebeneinander sieht das
nach einem Fehler aus.

Dazu, weil die App sie braucht: Einzelabruf für Film und Serie, die nächste
Folge nach einer gegebenen, und der Zustand hängt an jeder Liste mit dran —
in einer Abfrage je Seite, nicht in einer je Titel.

Ein Titel wird über seine Kennung allein angesprochen, ohne dass der Aufrufer
sagen muss, ob es ein Film oder eine Folge ist. Die App hat diese Auskunft an
der Stelle nicht.

348 Tests grün. Im Container nachgewiesen: fünf Minuten „Der Untergang" von
2:36 bleiben stehen, bei Minute 150 kommt das Häkchen und die Stelle bleibt,
beim zweiten Anlauf steht der Film mit beidem wieder in der Reihe — und nach
Folge 1 von Dark zeigt „Nächste Folge" S01E02.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 21:25:55 +02:00
ScarriffleandClaude Opus 5 705ec87416 Ein lokaler Server mit Beispielmedien, zum Ausprobieren 
`Tools/demo-medien.sh` legt unter `~/.flaro-medien` einen kleinen Bestand
an: Der Untergang, Matrix, Blade Runner 2049, Inception, Dark mit drei
Folgen, Notruf Hafenkante. Echte Namen, damit TMDB etwas zu finden hat —
aber jede Datei ist zwei Sekunden Testbild mit Ton und wiegt ein paar
Kilobyte.

**Eine davon hat zwei Tonspuren**, Deutsch und Audiodeskription, mit
gesetzter Sprache und gesetztem Namen. Das ist der Fall, um dessentwillen
der ganze Server existiert: Jellyfins Transcode-Endpunkt bildet eine
Tonspur je Sitzung ab, und einmal hat die App dabei still die
Audiodeskription gewählt — drei Gigabyte Mobilfunk für eine unbrauchbare
Datei. Wer das nachstellen will, braucht eine Datei, die es kann.

`docker-compose.local.yml` daneben: benannte Volumes statt NAS-Pfaden,
Port 18080 statt 8080, Beiwerk eingeschaltet.

**`user: "0:0"` ist eine Mac-Eigenheit und steht deshalb kommentiert da.**
Colimas Dateifreigabe reicht die Besitzverhältnisse des Wirts nicht in die
VM durch — eingehängte Ordner erscheinen im Container als root, und ein
Server, der als 1000 läuft, kann dort keine NFO ablegen. Auf einem
Linux-NAS gehört die Zeile weg.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 21:07:44 +02:00
ScarriffleandClaude Opus 5 91eb934048 Die Weboberfläche — im Zuschnitt von Plex, vom Server selbst ausgeliefert 
Einrichtung, Anmeldung, Mediathek, Detailseite mit Abspielen und
Herunterladen, Zuordnung korrigieren, Verwaltung. Die Oberfläche aus der
Jellyfin-Zeit ist dabei vollständig ersetzt: `types.ts`, `prefs.ts`,
`contrast.ts`, `views/cards.ts`, `views/player.ts` und `views/settings.ts`
sprachen Jellyfins Schnittstelle und hatten hier nichts mehr zu suchen.

Seitenleiste links, waagerechte Reihen auf der Startseite, Plakate im
Verhältnis 2:3, unscharfer Hintergrund hinter dem Kopf der Detailseite —
das ist der Zuschnitt von Plex, weil er gefällt. **Die Farbe bleibt Flaros
Orchidee**, nicht Plex' Orange; der Aufbau ist das Vorbild, nicht das
Aussehen.

Welche Bibliothek gezeigt wird, entscheidet die Seitenleiste. Eine zweite
Umschaltung innerhalb der Seite wäre dieselbe Entscheidung an zwei Orten.

---

**Der Zugang liegt jetzt auch in einem Cookie.** Ein `<img>`, ein `<video>`
und ein Download-Link senden keine eigenen Kopfzeilen — eine App kann ihr
Token in jede Anfrage legen, ein Browser nicht. Das Token stattdessen in
die Adresse zu schreiben wäre der naheliegende Ausweg und stünde danach in
jedem Zugriffsprotokoll, in jedem Verlauf und in jedem weitergegebenen
Link.

`HttpOnly`, damit kein eingeschlichenes Skript herankommt. `SameSite=Strict`
gegen Anfragen von fremden Seiten. `Secure` nur über https — sonst liesse
sich die Oberfläche im Heimnetz über http gar nicht benutzen. Die Apps
benutzen weiterhin die Kopfzeile: ein zweiter Weg zum selben Token, kein
zweites Verfahren.

---

**Der Fehler, den erst der echte Container zeigte:** eine weisse Seite,
ohne Hinweis worauf.

Die Rückfallregel verlangt für jede Anfrage ohne eigenen Endpunkt einen
angemeldeten Benutzer, und `/assets/index.js` hat keinen. Die statischen
Dateien standen unter `UseAuthorization` — ein neuer Besucher bekam 401 auf
genau das Skript, das ihm die Anmeldemaske zeichnen sollte. `/` kam durch,
weil der SPA-Rückfall `AllowAnonymous` trägt; alles mit Dateiendung nicht.
Jetzt liegen sie davor. Mit Prüfung.

Beim Bau desselben Images der zweite: seit der Kontext die Projektwurzel
ist, überschrieb `COPY server/` die `obj/`-Verzeichnisse aus dem Container
mit denen vom Arbeitsrechner — die zeigen auf osx-arm64, gebaut wird
linux-arm64, `dotnet publish` brach mit NETSDK1047 ab. Dafür gibt es jetzt
eine `.dockerignore` in der Wurzel; die unter `server/` sucht Docker seit
dem Umzug nicht mehr.

---

Vier Prüfungen schlugen danach fehl, und zwar zu Recht: sie hiessen „ohne
Anmeldung gibt es nichts", benutzten aber den Client, der nach dem Anmelden
ein Cookie hält. Sie prüften also den Angemeldeten. Jetzt sagen sie
ausdrücklich, dass sie ohne Zugang fragen.

313 Tests grün. Im Container nachgewiesen: Anmelden, Plakate, Abspielen,
Staffeln und Folgen, Verwaltung — und ein Neuladen auf `/verwaltung`, das
nicht in einem 404 endet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-10-03 21:07:29 +02:00
379 changed files with 87880 additions and 2979 deletions
Expand all files Collapse all files
.dockerignore
+26
View File
@@ -0,0 +1,26 @@
# Der Bau-Kontext ist die Wurzel des Projekts, seit die Oberfläche
# mitgebaut wird. Diese Datei gehört deshalb hierher und nicht nach server/ —
# Docker sucht sie neben dem Kontext, nicht neben dem Dockerfile.
# **Der Grund für diese Datei.** Ohne sie überschreibt `COPY server/ ./server/`
# die obj/-Verzeichnisse, die `dotnet restore` im Container gerade angelegt
# hat, mit denen vom Arbeitsrechner. Die zeigen auf osx-arm64, der Bau will
# linux-arm64, und `dotnet publish` bricht mit NETSDK1047 ab.
**/bin/
**/obj/
**/*.user
# Gebaute Oberfläche und ihre Abhängigkeiten: der web-Abschnitt baut beides neu.
**/node_modules/
web/app/dist/
# Laufzeitdaten eines lokalen Starts.
server/data/
server/cache/
server/transcode/
# Was im Server-Image nichts verloren hat.
.git/
.build/
DerivedData/
*.xcodeproj/
.gitea/workflows/image.yml
+89
View File
@@ -0,0 +1,89 @@
# Baut das Flaro-Image und legt es in die Registry dieses Gitea.
#
# **Zur Zeit schläft diese Datei.** Gebaut wird auf dem Arbeitsrechner mit
# `Tools/image-veroeffentlichen.sh` — der Rechner ist für die Apps ohnehin
# nötig, weil Xcode nirgendwo sonst läuft.
#
# **Weil Gitea nicht selbst baut.** Es verteilt Arbeit an einen Act-Runner,
# und der müsste auf dem NAS laufen. Dort scheitert er: sein Zweck ist das
# Bauen von Images, also braucht er Zugriff auf Docker, und die Docker-App
# des UGREEN lehnt den Einhängepunkt `/var/run/docker.sock` ab. Übrig
# blieben `privileged: true` oder der Weg über SSH an der Oberfläche vorbei
# — beides gibt dem Runner faktisch Root auf dem NAS.
#
# **Deshalb nur `workflow_dispatch`.** Mit einem Push-Auslöser legt Gitea
# bei jedem Push einen Lauf an, den niemand abarbeitet; nach einer Woche
# steht die Actions-Seite voll mit Leichen. Kommt irgendwann ein Runner
# dazu, lässt sich der Lauf von Hand starten — und der Auslöser unten ist
# mit drei Zeilen wieder da.
name: Image bauen und veröffentlichen
on:
# Wieder automatisch, sobald ein Runner existiert:
# push:
# branches: [main]
# tags: ['v*']
workflow_dispatch:
jobs:
image:
runs-on: ubuntu-latest
steps:
- name: Quelltext holen
uses: actions/checkout@v4
# **buildx, nicht das eingebaute `docker build`.** Nur damit lassen
# sich zwei Architekturen in einem Manifest ablegen; ohne das bekommt
# ein Intel-NAS ein arm64-Image und meldet „exec format error".
- name: buildx vorbereiten
uses: docker/setup-buildx-action@v3
- name: QEMU für die fremde Architektur
uses: docker/setup-qemu-action@v3
- name: An der Registry anmelden
uses: docker/login-action@v3
with:
registry: ${{ vars.REGISTRY || 'git.scarriffle.com' }}
username: ${{ gitea.actor }}
password: ${{ secrets.GITEA_TOKEN }}
- name: Marken bestimmen
id: marken
run: |
REGISTRY="${{ vars.REGISTRY || 'git.scarriffle.com' }}"
# **Der Name des Pakets, nicht der des Repos.** Gitea legt Pakete
# am Besitzer ab, nicht am Repository — sie dürfen deshalb anders
# heissen. Hier ist das nötig: das Repo heisst noch „halo", das
# Programm aber Flaro, und ein Image namens `halo` wäre die eine
# Stelle, an der der alte Name überlebt.
#
# Kleinbuchstaben, weil die Registry nichts anderes annimmt.
BESITZER=$(echo "${{ gitea.repository_owner }}" | tr '[:upper:]' '[:lower:]')
BILD="$REGISTRY/$BESITZER/${{ vars.IMAGE_NAME || 'flaro' }}"
MARKEN="$BILD:latest,$BILD:${GITHUB_SHA::7}"
# Auf einem Git-Tag zusätzlich dessen Namen — damit sich eine
# Fassung festnageln lässt, statt immer „latest" zu ziehen.
if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
MARKEN="$MARKEN,$BILD:${GITHUB_REF_NAME#v}"
fi
echo "marken=$MARKEN" >> "$GITHUB_OUTPUT"
echo "Gebaut wird: $MARKEN"
- name: Bauen und hochladen
uses: docker/build-push-action@v5
with:
context: .
file: server/Dockerfile
# **Beide Architekturen.** amd64 für die Intel-NAS, arm64 für
# ARM-Geräte und für den Apple-Rechner.
platforms: linux/amd64,linux/arm64
push: true
tags: ${{ steps.marken.outputs.marken }}
# Zwischenergebnisse behalten: ohne das lädt jeder Lauf alle
# Pakete neu, und ein Bau dauert statt zwei Minuten zwölf.
cache-from: type=gha
cache-to: type=gha,mode=max
Flaro/AppIcon.icon/Assets/flare (1).svg
+1
View File
@@ -0,0 +1 @@
<svg fill="none" height="24" viewBox="0 0 24 24" width="24" xmlns="http://www.w3.org/2000/svg"><path clip-rule="evenodd" d="m11.0721 5.13152c.3321-.84203 1.5237-.84203 1.8558 0l1.6803 4.26031 4.2603 1.68027c.842.3321.842 1.5237 0 1.8558l-4.2603 1.6803-1.6803 4.2603c-.3321.842-1.5237.842-1.8558 0l-1.68027-4.2603-4.26031-1.6803c-.84203-.3321-.84203-1.5237 0-1.8558l4.26031-1.68027zm.9279 1.73562-1.2928 3.27806c-.1014.2571-.3049.4606-.562.562l-3.27806 1.2928 3.27806 1.2928c.2571.1014.4606.3049.562.562l1.2928 3.2781 1.2928-3.2781c.1014-.2571.3049-.4606.562-.562l3.2781-1.2928-3.2781-1.2928c-.2571-.1014-.4606-.3049-.562-.562z" fill="rgb(0,0,0)" fill-rule="evenodd"/></svg>
Side by Side

After

Width:  |  Height:  |  Size: 673 B

Flaro/AppIcon.icon/Assets/play.svg
-1
View File
@@ -1 +0,0 @@
<svg id="Layer_1" height="512" viewBox="0 0 512 512" width="512" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" data-name="Layer 1"><linearGradient id="linear-gradient" gradientUnits="userSpaceOnUse" x1="-52.588" x2="390.826" y1="178.158" y2="434.163"><stop offset="0" stop-color="#55d6ff"/><stop offset="1" stop-color="#ce55ff"/></linearGradient><path d="m485.036 256a54.706 54.706 0 0 1 -27.636 47.868l-347.527 200.644a54.742 54.742 0 0 1 -55.272 0 54.713 54.713 0 0 1 -27.637-47.868v-401.288a54.718 54.718 0 0 1 27.636-47.869 54.75 54.75 0 0 1 55.273 0l347.527 200.645a54.708 54.708 0 0 1 27.636 47.868z" fill="url(#linear-gradient)"/></svg>
Side by Side

Before

Width:  |  Height:  |  Size: 675 B

Flaro/AppIcon.icon/icon.json
+7 -7
View File
@@ -2,7 +2,7 @@
"fill-specializations" : [ "fill-specializations" : [
{ {
"value" : { "value" : {
"automatic-gradient" : "display-p3:0.44346,0.27892,0.96783,1.00000" "automatic-gradient" : "display-p3:0.56409,0.38672,0.96783,1.00000"
} }
}, },
{ {
@@ -17,15 +17,15 @@
"layers" : [ "layers" : [
{ {
"fill" : { "fill" : {
"automatic-gradient" : "display-p3:0.73918,0.46760,0.96783,1.00000" "automatic-gradient" : "display-p3:0.51566,0.11264,0.96783,1.00000"
}, },
"image-name" : "play.svg", "image-name" : "flare (1).svg",
"name" : "play", "name" : "flare (1)",
"position" : { "position" : {
"scale" : 1.18, "scale" : 100,
"translation-in-points" : [ "translation-in-points" : [
49.7265625, 0,
1.468530916781674e-05 0
] ]
} }
} }
Flaro/FlaroApp.swift
+8
View File
@@ -6,6 +6,7 @@ import UIKit
import FlaroDesign import FlaroDesign
import FlaroDownloads import FlaroDownloads
import FlaroPlayback import FlaroPlayback
import FlaroServerKit
import JellyfinKit import JellyfinKit
import MediaKit import MediaKit
@@ -35,6 +36,9 @@ struct FlaroApp: App {
@State private var network = NetworkConditions() @State private var network = NetworkConditions()
@State private var homeLayout = HomeLayoutSettings() @State private var homeLayout = HomeLayoutSettings()
@State private var diagnostics = PlaybackDiagnostics() @State private var diagnostics = PlaybackDiagnostics()
/// Fortschritt, der den Server nicht erreicht hat — siehe
/// `Fortschrittspost`. Hier, weil er die Wiedergabe überleben muss.
@State private var post = Fortschrittspost.shared
@State private var downloads: DownloadCoordinator @State private var downloads: DownloadCoordinator
private let modelContainer: ModelContainer private let modelContainer: ModelContainer
@@ -45,6 +49,7 @@ struct FlaroApp: App {
client: Branding.appName, client: Branding.appName,
version: Branding.version version: Branding.version
), ),
flaroIdentity: FlaroIdentity.current(),
tokenStore: KeychainTokenStore(service: Branding.keychainService) tokenStore: KeychainTokenStore(service: Branding.keychainService)
)) ))
@@ -90,6 +95,7 @@ struct FlaroApp: App {
.environment(downloads) .environment(downloads)
.environment(homeLayout) .environment(homeLayout)
.environment(diagnostics) .environment(diagnostics)
.environment(post)
.environment(theme) .environment(theme)
// Akzentfarbe und Tönung setzt RootView, nicht diese Stelle. // Akzentfarbe und Tönung setzt RootView, nicht diese Stelle.
// //
@@ -115,6 +121,8 @@ struct FlaroApp: App {
backend: session.backend, backend: session.backend,
coordinator: downloads coordinator: downloads
).refill() ).refill()
// Was im Flugzeug liegengeblieben ist, geht jetzt raus.
await post.zustellen(über: session.backend)
} }
} }
.modelContainer(modelContainer) .modelContainer(modelContainer)
Flaro/Resources/Localizable.xcstrings
+645 -53
View File
@@ -25,6 +25,18 @@
} }
} }
}, },
"%@: %@": {
"comment": "A label that shows the audio or subtitle language. The argument is the language name.",
"isCommentAutoGenerated": true,
"localizations": {
"en": {
"stringUnit": {
"state": "new",
"value": "%1$@: %2$@"
}
}
}
},
"4K": { "4K": {
"comment": "A label for a 4K video.", "comment": "A label for a 4K video.",
"isCommentAutoGenerated": true "isCommentAutoGenerated": true
@@ -108,6 +120,23 @@
} }
} }
}, },
"action.back": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Zurück"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Back"
}
}
}
},
"action.cancel": { "action.cancel": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -1224,6 +1253,22 @@
} }
} }
}, },
"downloads.episodeCount %lld": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "%lld Folgen geladen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "%lld episodes downloaded"
}
}
}
},
"downloads.failed": { "downloads.failed": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -1705,7 +1750,7 @@
"de": { "de": {
"stringUnit": { "stringUnit": {
"state": "translated", "state": "translated",
"value": "Staffel %lld · Episode %lld" "value": "Staffel %lld · Folge %lld"
} }
}, },
"en": { "en": {
@@ -1869,6 +1914,23 @@
} }
} }
}, },
"filter.downloadedOnly": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Nur Heruntergeladene"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Downloaded only"
}
}
}
},
"filter.filters": { "filter.filters": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -2105,6 +2167,22 @@
} }
} }
}, },
"home.downloaded": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Heruntergeladen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Downloaded"
}
}
}
},
"home.empty.description": { "home.empty.description": {
"localizations": { "localizations": {
"de": { "de": {
@@ -2322,6 +2400,22 @@
} }
} }
}, },
"home.offline": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Kein Server erreichbar. Was hier steht, stammt vom letzten Mal — ansehen lässt sich nur, was auf dem Gerät liegt."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "No server reachable. What you see is from last time — only what is on this device can be played."
}
}
}
},
"home.rowsHeader": { "home.rowsHeader": {
"localizations": { "localizations": {
"de": { "de": {
@@ -2451,6 +2545,23 @@
} }
} }
}, },
"languages.audioShort": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Ton"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Audio"
}
}
}
},
"languages.avoidAudioDescription": { "languages.avoidAudioDescription": {
"extractionState": "manual", "extractionState": "manual",
"localizations": { "localizations": {
@@ -2604,6 +2715,23 @@
} }
} }
}, },
"languages.forThisTitle": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Tonsprache für diesen Titel"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Audio language for this title"
}
}
}
},
"languages.headerExplanation": { "languages.headerExplanation": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -2638,6 +2766,44 @@
} }
} }
}, },
"languages.none": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Keine"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "None"
}
}
}
},
"languages.partial %@": {
"comment": "Eine kleine Schriftart, die",
"isCommentAutoGenerated": true
},
"languages.partial %lld": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Nur Sprachen, die in jeder Folge vorkommen. %lld weitere gibt es nur in einem Teil."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Only languages present in every episode. %lld more exist in some episodes only."
}
}
}
},
"languages.serverDefault": { "languages.serverDefault": {
"localizations": { "localizations": {
"de": { "de": {
@@ -2687,6 +2853,40 @@
} }
} }
}, },
"languages.subtitlesForThisSeries": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Untertitel für diese Serie"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Subtitles for this series"
}
}
}
},
"languages.subtitlesForThisTitle": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Untertitel für diesen Titel"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Subtitles for this title"
}
}
}
},
"languages.subtitlesHeader": { "languages.subtitlesHeader": {
"localizations": { "localizations": {
"de": { "de": {
@@ -2719,6 +2919,23 @@
} }
} }
}, },
"languages.subtitlesShort": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Untertitel"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Subtitles"
}
}
}
},
"languages.title": { "languages.title": {
"localizations": { "localizations": {
"de": { "de": {
@@ -3854,23 +4071,6 @@
} }
} }
}, },
"player.jellyfinPending": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Die Wiedergabe von Jellyfin ist noch nicht fertig — sie ist der nächste Schritt."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Playback from Jellyfin isn't finished yet — it's the next step."
}
}
}
},
"player.loadFailed": { "player.loadFailed": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -3905,7 +4105,6 @@
} }
}, },
"player.nextEpisode": { "player.nextEpisode": {
"extractionState": "stale",
"localizations": { "localizations": {
"de": { "de": {
"stringUnit": { "stringUnit": {
@@ -4041,6 +4240,22 @@
} }
} }
}, },
"player.previousEpisode": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Vorige Folge"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Previous episode"
}
}
}
},
"player.quality": { "player.quality": {
"localizations": { "localizations": {
"de": { "de": {
@@ -5039,6 +5254,10 @@
} }
} }
}, },
"season.short %@": {
"comment": "A label that shows the number of the selected season.",
"isCommentAutoGenerated": true
},
"season.short %lld": { "season.short %lld": {
"comment": "Platzhalter: Staffelnummer", "comment": "Platzhalter: Staffelnummer",
"extractionState": "stale", "extractionState": "stale",
@@ -5912,6 +6131,22 @@
} }
} }
}, },
"settings.skipExtraScenes": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Zusätzliche Szenen mit überspringen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Skip extra scenes too"
}
}
}
},
"settings.storageLimit": { "settings.storageLimit": {
"extractionState": "stale", "extractionState": "stale",
"localizations": { "localizations": {
@@ -6254,6 +6489,312 @@
} }
} }
}, },
"signIn.flaro.addressHint": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Schema und Port darfst du weglassen — Flaro probiert die üblichen durch."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "You can leave out the scheme and port — Flaro tries the usual ones."
}
}
}
},
"signIn.flaro.addressMissing": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Trag eine Adresse ein."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Enter an address."
}
}
}
},
"signIn.flaro.addressPlaceholder": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "z. B. 192.168.1.50 oder medien.example.com"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "e.g. 192.168.1.50 or media.example.com"
}
}
}
},
"signIn.flaro.addressPrompt": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Wo steht dein Server?"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Where is your server?"
}
}
}
},
"signIn.flaro.changeAddress": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Andere Adresse"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Change address"
}
}
}
},
"signIn.flaro.codeExpired": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Der Code ist abgelaufen. Fordere einen neuen an."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The code has expired. Request a new one."
}
}
}
},
"signIn.flaro.codeHint": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Öffne Flaro auf deinem Telefon und gib diesen Code ein."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Open Flaro on your phone and enter this code."
}
}
}
},
"signIn.flaro.credentialsMissing": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Benutzername und Passwort fehlen."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Username and password are missing."
}
}
}
},
"signIn.flaro.findServer": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Server suchen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Find server"
}
}
}
},
"signIn.flaro.needsSetup": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Dieser Server ist noch nicht eingerichtet. Öffne ihn im Browser und lege ein Konto an."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "This server isn't set up yet. Open it in a browser and create an account."
}
}
}
},
"signIn.flaro.notFound": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Unter dieser Adresse antwortet kein Flaro-Server."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "No Flaro server answers at this address."
}
}
}
},
"signIn.flaro.searching": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Server wird gesucht …"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Looking for the server…"
}
}
}
},
"signIn.flaro.signIn": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Anmelden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Sign in"
}
}
}
},
"signIn.flaro.signingIn": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Wird angemeldet …"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Signing in…"
}
}
}
},
"signIn.flaro.title": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Flaro-Server"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Flaro Server"
}
}
}
},
"signIn.flaro.useCode": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Stattdessen Code"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Use a code instead"
}
}
}
},
"signIn.flaro.usePassword": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Stattdessen Passwort"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Use a password instead"
}
}
}
},
"signIn.flaro.waitingForApproval": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Warte auf Bestätigung"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Waiting for approval"
}
}
}
},
"signIn.jellyfin.addressHint": { "signIn.jellyfin.addressHint": {
"localizations": { "localizations": {
"de": { "de": {
@@ -6403,23 +6944,6 @@
} }
} }
}, },
"signIn.jellyfin.password": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Passwort"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Password"
}
}
}
},
"signIn.jellyfin.passwordNote": { "signIn.jellyfin.passwordNote": {
"localizations": { "localizations": {
"de": { "de": {
@@ -6568,23 +7092,6 @@
} }
} }
}, },
"signIn.jellyfin.userName": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Benutzername"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Username"
}
}
}
},
"signIn.jellyfin.waitingForApproval": { "signIn.jellyfin.waitingForApproval": {
"localizations": { "localizations": {
"de": { "de": {
@@ -6601,6 +7108,23 @@
} }
} }
}, },
"signIn.password": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Passwort"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Password"
}
}
}
},
"signIn.privacy": { "signIn.privacy": {
"localizations": { "localizations": {
"de": { "de": {
@@ -6634,6 +7158,40 @@
} }
} }
}, },
"signIn.userName": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Benutzername"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Username"
}
}
}
},
"signIn.withFlaro": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Mit Flaro verbinden"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Connect to Flaro"
}
}
}
},
"signIn.withJellyfin": { "signIn.withJellyfin": {
"localizations": { "localizations": {
"de": { "de": {
@@ -7514,6 +8072,40 @@
} }
} }
} }
},
"upcoming.from %@": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Ab %@ Uhr"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "From %@"
}
}
}
},
"upcoming.title": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Bald ist es soweit"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Coming soon"
}
}
}
} }
}, },
"version": "1.1" "version": "1.1"
Flaro/Session/DownloadService.swift
+77 -2
View File
@@ -122,7 +122,8 @@ struct DownloadService {
// hinterher niemanden mehr, der das nachholen könnte — und seit es // hinterher niemanden mehr, der das nachholen könnte — und seit es
// keine zweite Engine mehr gibt, wäre die Datei schlicht stumm und // keine zweite Engine mehr gibt, wäre die Datei schlicht stumm und
// schwarz. Also wird schon beim Herunterladen umgepackt. // schwarz. Also wird schon beim Herunterladen umgepackt.
let umpacken = quality == .original && !systemPlayerOpens(media: media, part: part) let umpacken = quality == .original && !kannAlleSpuren
&& !systemPlayerOpens(media: media, part: part)
let url: URL? let url: URL?
switch quality { switch quality {
@@ -195,9 +196,76 @@ struct DownloadService {
quality: DownloadQuality = .original, quality: DownloadQuality = .original,
audioStream: MediaStream? = nil audioStream: MediaStream? = nil
) throws(DownloadRefusal) -> DownloadItem { ) throws(DownloadRefusal) -> DownloadItem {
try coordinator.enqueue( let eintrag = try coordinator.enqueue(
try plan(for: item, mediaIndex: mediaIndex, quality: quality, audioStream: audioStream) try plan(for: item, mediaIndex: mediaIndex, quality: quality, audioStream: audioStream)
) )
plakatHolen(for: item)
return eintrag
}
/// Holt das Plakat mit herunter.
///
/// **Ohne Verbindung gibt es keine Adresse mehr, von der eines käme.**
/// Ein Download ohne Bild ist offline eine graue Fläche mit einem Titel
/// darunter — und genau dann, wenn man etwas zum Ansehen sucht, ist das
/// Bild die halbe Auskunft. Ein paar Kilobyte je Eintrag.
///
/// Nebenher und ohne Fehlerweg: scheitert es, fehlt ein Bild. Den
/// Download deshalb scheitern zu lassen wäre die schlechtere Hälfte.
func plakatHolen(for item: MediaItem) {
if let adresse = backend?.rawImageURL(path: item.thumb) {
Task { await coordinator.fetchArtwork(for: item.id, from: adresse) }
}
// **Und das Plakat der Serie, unter deren Schlüssel.**
//
// `thumb` ist bei einer Folge ihr Szenenbild — quer, und hochkant
// beschnitten zeigt es einen zufälligen Ausschnitt. Die Downloads
// stehen aber als Serie in der Reihe, und eine Serienkachel ist ein
// Plakat. Ohne diesen zweiten Griff gäbe es für die Serie gar kein
// Bild: heruntergeladen wird sie nie, nur ihre Folgen.
if let serie = item.seriesID,
let pfad = item.seriesThumb ?? item.parentThumb,
let adresse = backend?.rawImageURL(path: pfad) {
Task { await coordinator.fetchArtwork(for: serie, from: adresse) }
}
}
/// Holt Plakate nach, die früheren Downloads fehlen.
///
/// **Weil bis vor Kurzem gar keines mitkam.** Der Dateiname dafür stand
/// im Modell, gesetzt hat ihn nie jemand — alles, was vorher
/// heruntergeladen wurde, hat kein Bild und stünde in der neuen Reihe
/// als graue Fläche.
///
/// Einmal je Serverwechsel, nur für die Einträge ohne Bild; danach
/// findet die Schleife nichts mehr.
func plakateNachholen() async {
guard let backend else { return }
for eintrag in coordinator.items where fehltEinBild(eintrag) {
guard let titel = try? await backend.item(id: eintrag.ratingKey) else { continue }
plakatHolen(for: titel)
}
}
/// Ob zu diesem Eintrag noch ein Bild fehlt — seines oder das seiner
/// Serie.
private func fehltEinBild(_ eintrag: DownloadItem) -> Bool {
if coordinator.artworkURL(forRatingKey: eintrag.ratingKey) == nil { return true }
if let serie = eintrag.seriesKey,
coordinator.artworkURL(forRatingKey: serie) == nil { return true }
return false
}
/// Ob der Server beim Herunterladen alle Spuren mitgibt.
///
/// **Der Unterschied, um dessentwillen Flaro gebaut wurde.** Flaros
/// Download liefert eine MP4 mit jeder Ton- und Textspur, auch wenn dafür
/// umgepackt werden muss. Dann entfällt die Spurwahl, und das Umpacken
/// mit genau einer Spur entfällt gleich mit — es gäbe nichts zu
/// verbessern, nur etwas zu verlieren.
private var kannAlleSpuren: Bool {
backend?.capabilities.contains(.allTracksDownload) == true
} }
/// Ob beim Herunterladen eine Tonspur verlorengeht — und deshalb gefragt /// Ob beim Herunterladen eine Tonspur verlorengeht — und deshalb gefragt
@@ -211,6 +279,12 @@ struct DownloadService {
/// falsche Weg. /// falsche Weg.
func needsAudioChoice(for item: MediaItem, mediaIndex: Int = 0, quality: DownloadQuality) -> Bool { func needsAudioChoice(for item: MediaItem, mediaIndex: Int = 0, quality: DownloadQuality) -> Bool {
guard quality == .original else { return false } guard quality == .original else { return false }
// **Kann der Server alles mitgeben, gibt es nichts zu entscheiden.**
// Die Frage ist nur deshalb da, weil Jellyfins Transcoder eine
// Tonspur je Sitzung abbildet. Wo das nicht gilt, wäre sie eine
// Entscheidung, die der Nutzer treffen soll, obwohl beide Antworten
// zum selben Ergebnis führen.
guard !kannAlleSpuren else { return false }
guard let media = mediaIndex < item.versions.count guard let media = mediaIndex < item.versions.count
? item.versions[mediaIndex] : item.preferredVersion, ? item.versions[mediaIndex] : item.preferredVersion,
let part = media.files.first let part = media.files.first
@@ -276,6 +350,7 @@ struct DownloadService {
_ = try coordinator.enqueue( _ = try coordinator.enqueue(
try plan(for: detailed, quality: quality, audioStream: ton) try plan(for: detailed, quality: quality, audioStream: ton)
) )
plakatHolen(for: detailed)
accepted += 1 accepted += 1
} catch DownloadRefusal.noDownloadableFile { } catch DownloadRefusal.noDownloadableFile {
// Einzelne Folgen ohne Datei stoppen den Stapel nicht — sie // Einzelne Folgen ohne Datei stoppen den Stapel nicht — sie
Flaro/Session/FlaroSession.swift
+224 -17
View File
@@ -1,4 +1,5 @@
import Foundation import Foundation
import FlaroServerKit
import JellyfinKit import JellyfinKit
import MediaKit import MediaKit
import Observation import Observation
@@ -31,12 +32,41 @@ final class FlaroSession {
// stillschweigend als „ungleich" behandelt. // stillschweigend als „ungleich" behandelt.
} }
/// Mit welcher Art Server gesprochen wird.
///
/// **Diese Unterscheidung gab es schon einmal** — damals für Plex und
/// Jellyfin — und sie wurde beim Entfernen von Plex gestrichen, weil ein
/// Aufzählungstyp mit einem Fall ein umständliches Bool ist. Jetzt gibt
/// es wieder zwei, und es ist wieder eine Unterscheidung.
///
/// **Einer zur Zeit, nicht beide.** Zwei gleichzeitig hiessen: zwei
/// Startseiten, zwei Mediatheken, zwei Suchergebnisse — und bei jedem
/// Titel die Frage, woher er stammt.
enum ServerKind: String, CaseIterable, Sendable, Identifiable {
case jellyfin, flaro
var id: String { rawValue }
}
private enum Key { private enum Key {
/// Welche Art zuletzt angemeldet war.
///
/// Nicht `flaro.backend.kind`: so hiess der Schlüssel zu Plex-Zeiten,
/// und der steht in der Aufräumliste weiter unten. Denselben Namen
/// mit anderer Bedeutung zu benutzen wäre eine Falle für den
/// Nächsten, der die Liste liest.
static let activeKind = "flaro.backend.active"
static let jellyfinAddress = "flaro.jellyfin.address" static let jellyfinAddress = "flaro.jellyfin.address"
static let jellyfinUserID = "flaro.jellyfin.userID" static let jellyfinUserID = "flaro.jellyfin.userID"
static let jellyfinUserName = "flaro.jellyfin.userName" static let jellyfinUserName = "flaro.jellyfin.userName"
static let jellyfinServerName = "flaro.jellyfin.serverName" static let jellyfinServerName = "flaro.jellyfin.serverName"
static let jellyfinIsAdministrator = "flaro.jellyfin.isAdministrator" static let jellyfinIsAdministrator = "flaro.jellyfin.isAdministrator"
static let flaroAddress = "flaro.flaroServer.address"
static let flaroUserID = "flaro.flaroServer.userID"
static let flaroUserName = "flaro.flaroServer.userName"
static let flaroServerName = "flaro.flaroServer.serverName"
static let flaroIsAdministrator = "flaro.flaroServer.isAdministrator"
} }
/// Unter welchem Namen das Server-Token im Schlüsselbund liegt. /// Unter welchem Namen das Server-Token im Schlüsselbund liegt.
@@ -45,6 +75,7 @@ final class FlaroSession {
/// Mediathek. Der Name trägt die Serverart, damit ein zweiter Server /// Mediathek. Der Name trägt die Serverart, damit ein zweiter Server
/// später daneben passt, ohne diesen zu verdrängen. /// später daneben passt, ohne diesen zu verdrängen.
private static let jellyfinTokenAccount = "jellyfin.server" private static let jellyfinTokenAccount = "jellyfin.server"
private static let flaroTokenAccount = "flaro.server"
/// Was die Plex-Zeit auf dem Gerät hinterlassen hat. /// Was die Plex-Zeit auf dem Gerät hinterlassen hat.
/// ///
@@ -90,8 +121,24 @@ final class FlaroSession {
/// Das angemeldete Jellyfin-Konto, solange Jellyfin aktiv ist. /// Das angemeldete Jellyfin-Konto, solange Jellyfin aktiv ist.
private(set) var jellyfinAccount: JellyfinAccount? private(set) var jellyfinAccount: JellyfinAccount?
/// Das angemeldete Flaro-Konto, solange Flaro aktiv ist.
private(set) var flaroAccount: FlaroAccount?
/// Mit welcher Art Server gerade gesprochen wird.
private(set) var activeKind: ServerKind?
/// Wer angemeldet ist — sofern der Server einen Namen dafür kennt. /// Wer angemeldet ist — sofern der Server einen Namen dafür kennt.
var accountName: String? { jellyfinAccount?.userName } var accountName: String? { jellyfinAccount?.userName ?? flaroAccount?.userName }
/// Das Profilbild des angemeldeten Kontos, als Adresse.
///
/// **Nur Flaro hat eines.** Jellyfin gibt kein Profilbild heraus; dort
/// bleibt es beim Buchstaben, und das ist keine Lücke, sondern der Stand
/// der Dinge.
var accountAvatarURL: URL? {
guard let schluessel = flaroAccount?.avatarImage else { return nil }
return backend?.rawImageURL(path: schluessel)
}
/// Die Mediatheken, die Flaro darstellen kann — Musik und Fotos /// Die Mediatheken, die Flaro darstellen kann — Musik und Fotos
/// erscheinen gar nicht erst. /// erscheinen gar nicht erst.
@@ -101,7 +148,12 @@ final class FlaroSession {
var serverName: String { backend?.serverName ?? "" } var serverName: String { backend?.serverName ?? "" }
/// Unter welcher Adresse er erreicht wird. /// Unter welcher Adresse er erreicht wird.
var serverAddress: String? { defaults.string(forKey: Key.jellyfinAddress) } var serverAddress: String? {
switch activeKind {
case .flaro: defaults.string(forKey: Key.flaroAddress)
case .jellyfin, nil: defaults.string(forKey: Key.jellyfinAddress)
}
}
/// Wie die Verbindung zum Server zu beschreiben ist. /// Wie die Verbindung zum Server zu beschreiben ist.
/// ///
@@ -136,30 +188,28 @@ final class FlaroSession {
/// Warum gerade nicht abgespielt werden kann. /// Warum gerade nicht abgespielt werden kann.
/// ///
/// Zwei verschiedene Lagen, und sie dürfen nicht verwechselt werden: ist /// **Nur noch ein Fall, und das ist eine Bereinigung.** Hier stand eine
/// ein Server da, ist die Anmeldung fertig und nur die Wiedergabe noch /// Fallunterscheidung aus der Plex-Zeit: war Jellyfin aktiv, hiess es
/// nicht — „nicht erreichbar" wäre dann gelogen. Ist **keiner** da, ist /// „die Wiedergabe von Jellyfin ist noch nicht fertig". Sie ist längst
/// niemand angemeldet, und „Wiedergabe steht aus" wäre es. /// fertig — und der Satz war ohnehin unerreichbar, denn der Player zeigt
/// /// diese Meldung ausschliesslich dann, wenn gar kein Server da ist.
/// Die Unterscheidung hing früher an der Serverart, und deren `nil`-Fall
/// lief stillschweigend im selben Zweig mit. Jetzt steht sie da, wo sie
/// hingehört: an der Frage, ob überhaupt ein Server da ist.
var playbackUnavailableMessage: String { var playbackUnavailableMessage: String {
backend != nil String(localized: "error.serverUnreachable")
? String(localized: "player.jellyfinPending")
: String(localized: "error.serverUnreachable")
} }
private let jellyfinIdentity: JellyfinIdentity private let jellyfinIdentity: JellyfinIdentity
private let flaroIdentity: FlaroIdentity
private let tokenStore: any TokenStoring private let tokenStore: any TokenStoring
private let defaults: UserDefaults private let defaults: UserDefaults
init( init(
jellyfinIdentity: JellyfinIdentity, jellyfinIdentity: JellyfinIdentity,
flaroIdentity: FlaroIdentity,
tokenStore: any TokenStoring, tokenStore: any TokenStoring,
defaults: UserDefaults = .standard defaults: UserDefaults = .standard
) { ) {
self.jellyfinIdentity = jellyfinIdentity self.jellyfinIdentity = jellyfinIdentity
self.flaroIdentity = flaroIdentity
self.tokenStore = tokenStore self.tokenStore = tokenStore
self.defaults = defaults self.defaults = defaults
} }
@@ -174,7 +224,13 @@ final class FlaroSession {
if await adoptStubServerIfRequested() { return } if await adoptStubServerIfRequested() { return }
#endif #endif
if await restoreJellyfin() { return } // **Die gespeicherte Art zuerst.** Wer ohne sie startet, war vor
// dieser Fassung angemeldet — damals gab es nur Jellyfin, und genau
// das ist dann gemeint.
switch defaults.string(forKey: Key.activeKind).flatMap(ServerKind.init(rawValue:)) {
case .flaro: if await restoreFlaro() { return }
case .jellyfin, nil: if await restoreJellyfin() { return }
}
phase = .signedOut phase = .signedOut
} }
@@ -212,12 +268,24 @@ final class FlaroSession {
/// Der Knopf heißt „Abmelden" und nicht „diesen Server verlassen": nach /// Der Knopf heißt „Abmelden" und nicht „diesen Server verlassen": nach
/// dem Abmelden soll beim nächsten Start keine Mediathek mehr dastehen. /// dem Abmelden soll beim nächsten Start keine Mediathek mehr dastehen.
func signOut() { func signOut() {
// **Dem Flaro-Server sagen, dass dieses Gerät geht.** Jellyfin
// erfährt es über das Verfallen des Tokens; Flaro zieht es auf
// Zuruf zurück, und ein nicht zurückgezogenes Token stünde sonst
// bis zum Ablauf in der Geräteliste.
if let client = flaroClient {
Task { await FlaroSignIn.signOut(client: client) }
}
forgetJellyfin() forgetJellyfin()
forgetFlaro()
defaults.removeObject(forKey: Key.activeKind)
clearActiveServer() clearActiveServer()
// Titel, Zusammenfassungen und Sehfortschritt sind persönlich. Was // Titel, Zusammenfassungen und Sehfortschritt sind persönlich. Was
// einem abgemeldeten Konto gehörte, hat auf der Platte nichts mehr // einem abgemeldeten Konto gehörte, hat auf der Platte nichts mehr
// verloren. // verloren.
Task { await LibraryCache.shared.clearAll() } Task { await LibraryCache.shared.clearAll() }
// Dasselbe gilt für den Fortschritt, der noch auf den Server
// wartet: er gehört dem Konto, das gerade gegangen ist.
Fortschrittspost.shared.leeren()
phase = .signedOut phase = .signedOut
} }
@@ -276,14 +344,14 @@ final class FlaroSession {
let backend = JellyfinBackend(client: client, account: account, serverName: serverName) let backend = JellyfinBackend(client: client, account: account, serverName: serverName)
clearActiveServer() clearActiveServer()
jellyfinAccount = account jellyfinAccount = account
activeKind = .jellyfin
self.backend = backend self.backend = backend
isLocalConnection = await backend.isInLocalNetwork() isLocalConnection = await backend.isInLocalNetwork()
do { do {
libraries = try await loadLibraries(from: backend) libraries = try await loadLibraries(from: backend)
} catch { } catch {
self.backend = nil clearActiveServer()
jellyfinAccount = nil
phase = .failed(message: ErrorText.describe(error)) phase = .failed(message: ErrorText.describe(error))
return return
} }
@@ -320,6 +388,7 @@ final class FlaroSession {
clearActiveServer() clearActiveServer()
jellyfinAccount = account jellyfinAccount = account
activeKind = .jellyfin
self.backend = backend self.backend = backend
// Auch hier fragen: dasselbe Konto kann heute zuhause und morgen im // Auch hier fragen: dasselbe Konto kann heute zuhause und morgen im
// Zug wiederhergestellt werden, und die Antwort gilt je Sitzung. // Zug wiederhergestellt werden, und die Antwort gilt je Sitzung.
@@ -341,7 +410,130 @@ final class FlaroSession {
} }
} }
// MARK: - Verbinden mit Flaro
/// Übernimmt eine fertige Flaro-Anmeldung.
///
/// Dieselbe Form wie bei Jellyfin, und das ist der Beweis für die Naht:
/// was danach kommt — Mediatheken laden, Phase setzen, merken — steht
/// zweimal genau gleich da, weil `MediaBackend` dazwischen liegt.
func adoptFlaro(client: FlaroClient, account: FlaroAccount) async {
phase = .connecting(serverName: account.serverName)
let backend = FlaroBackend(client: client, account: account)
clearActiveServer()
flaroAccount = account
flaroClient = client
activeKind = .flaro
self.backend = backend
// **Flaro fragt danach nicht.** Jellyfin meldet, ob die Verbindung
// im selben Netz liegt; Flaro hat dafür keinen Endpunkt und rechnet
// auch nichts daran fest. Im Zweifel vorsichtig: lieber einmal zu
// stark gedeckelt als eine Wiedergabe, die unterwegs nicht anläuft.
isLocalConnection = false
do {
libraries = try await loadLibraries(from: backend)
} catch {
clearActiveServer()
phase = .failed(message: ErrorText.describe(error))
return
}
rememberFlaro(account: account, token: nil)
phase = .ready
}
/// Dasselbe mit frischem Token — nach einer Anmeldung mit Passwort.
func adoptFlaro(client: FlaroClient, account: FlaroAccount, token: String) async {
await adoptFlaro(client: client, account: account)
guard phase == .ready else { return }
rememberFlaro(account: account, token: token)
}
/// Nimmt eine gespeicherte Flaro-Anmeldung wieder auf.
private func restoreFlaro() async -> Bool {
guard let address = defaults.string(forKey: Key.flaroAddress),
let baseURL = URL(string: address),
let token = tokenStore.token(for: Self.flaroTokenAccount)
else { return false }
phase = .connecting(serverName: defaults.string(forKey: Key.flaroServerName) ?? "")
do {
let (account, client) = try await FlaroSignIn.restore(
baseURL: baseURL, token: token, identity: flaroIdentity)
await adoptFlaro(client: client, account: account)
return true
} catch MediaBackendError.unauthorized {
// Am Server zurückgezogen. Ihn zu behalten erzeugte bei jedem
// Start denselben Fehler.
forgetFlaro()
clearActiveServer()
return false
} catch {
// Nur gerade nicht erreichbar — auf dem Weg zur Arbeit ist jeder
// Server das, und es ist kein Grund, jemanden abzumelden.
//
// **Und auch kein Grund, vor der Tür stehen zu bleiben.** Vorher
// endete es hier bei einem Fehlerbildschirm mit zwei Knöpfen:
// „Erneut versuchen" und „Abmelden". Beide nützen im Flugzeug
// nichts, und das Heruntergeladene lag unerreichbar dahinter.
//
// Der Token liegt im Schlüsselbund, das Konto in den
// Voreinstellungen — beides reicht, um die App zu betreten.
// Jede einzelne Anfrage scheitert dann weiterhin, und jeder
// Bildschirm sagt das für sich.
await adoptFlaro(client: FlaroClient(
baseURL: baseURL, identity: flaroIdentity, token: token
), account: gemerktesFlaroKonto(baseURL: baseURL))
if case .failed = phase {
// Nicht einmal eine Mediathekenliste gemerkt — dann ist die
// App leer, und der Fehlerbildschirm ist die ehrlichere
// Antwort.
phase = .failed(message: ErrorText.describe(error))
activeKind = .flaro
}
return true
}
}
/// Das Konto aus den Voreinstellungen, ohne den Server zu fragen.
///
/// Alles darin wurde beim letzten erfolgreichen Anmelden geschrieben.
/// Es ist vielleicht veraltet — ein umbenannter Server, ein geänderter
/// Anzeigename —, aber es ist richtiger als gar keins.
private func gemerktesFlaroKonto(baseURL: URL) -> FlaroAccount {
FlaroAccount(
baseURL: baseURL,
serverName: defaults.string(forKey: Key.flaroServerName)
?? baseURL.host() ?? "Flaro",
userID: defaults.string(forKey: Key.flaroUserID) ?? "",
userName: defaults.string(forKey: Key.flaroUserName) ?? "",
isAdministrator: defaults.bool(forKey: Key.flaroIsAdministrator)
)
}
private func rememberFlaro(account: FlaroAccount, token: String?) {
defaults.set(ServerKind.flaro.rawValue, forKey: Key.activeKind)
defaults.set(account.baseURL.absoluteString, forKey: Key.flaroAddress)
defaults.set(account.userID, forKey: Key.flaroUserID)
defaults.set(account.userName, forKey: Key.flaroUserName)
defaults.set(account.serverName, forKey: Key.flaroServerName)
defaults.set(account.isAdministrator, forKey: Key.flaroIsAdministrator)
if let token { try? tokenStore.store(token, for: Self.flaroTokenAccount) }
}
private func forgetFlaro() {
for key in [Key.flaroAddress, Key.flaroUserID, Key.flaroUserName,
Key.flaroServerName, Key.flaroIsAdministrator] {
defaults.removeObject(forKey: key)
}
tokenStore.remove(for: Self.flaroTokenAccount)
}
private func rememberJellyfin(account: JellyfinAccount, serverName: String, baseURL: URL) { private func rememberJellyfin(account: JellyfinAccount, serverName: String, baseURL: URL) {
defaults.set(ServerKind.jellyfin.rawValue, forKey: Key.activeKind)
defaults.set(baseURL.absoluteString, forKey: Key.jellyfinAddress) defaults.set(baseURL.absoluteString, forKey: Key.jellyfinAddress)
defaults.set(account.userID, forKey: Key.jellyfinUserID) defaults.set(account.userID, forKey: Key.jellyfinUserID)
defaults.set(account.userName, forKey: Key.jellyfinUserName) defaults.set(account.userName, forKey: Key.jellyfinUserName)
@@ -385,12 +577,18 @@ final class FlaroSession {
private func clearActiveServer() { private func clearActiveServer() {
backend = nil backend = nil
jellyfinAccount = nil jellyfinAccount = nil
flaroAccount = nil
flaroClient = nil
activeKind = nil
libraries = [] libraries = []
} }
/// Nach einem Fehler noch einmal versuchen, ohne die Anmeldung zu verlieren. /// Nach einem Fehler noch einmal versuchen, ohne die Anmeldung zu verlieren.
func retry() async { func retry() async {
if await restoreJellyfin() { return } switch defaults.string(forKey: Key.activeKind).flatMap(ServerKind.init(rawValue:)) {
case .flaro: if await restoreFlaro() { return }
case .jellyfin, nil: if await restoreJellyfin() { return }
}
phase = .signedOut phase = .signedOut
} }
@@ -400,4 +598,13 @@ final class FlaroSession {
/// Sitzung gibt — er braucht dieselbe Gerätekennung, sonst steht die App /// Sitzung gibt — er braucht dieselbe Gerätekennung, sonst steht die App
/// nach dem Anmelden ein zweites Mal in der Geräteliste des Servers. /// nach dem Anmelden ein zweites Mal in der Geräteliste des Servers.
var jellyfinDeviceIdentity: JellyfinIdentity { jellyfinIdentity } var jellyfinDeviceIdentity: JellyfinIdentity { jellyfinIdentity }
/// Dasselbe für Flaro.
var flaroDeviceIdentity: FlaroIdentity { flaroIdentity }
/// Der Client des aktiven Flaro-Servers — zum Abmelden.
///
/// Nicht `@Observable`-sichtbar: keine Ansicht liest ihn, und eine
/// Änderung daran soll kein Neuzeichnen auslösen.
@ObservationIgnored private var flaroClient: FlaroClient?
} }
Flaro/Session/FlaroSignInModel.swift
+211
View File
@@ -0,0 +1,211 @@
import Foundation
import FlaroServerKit
import MediaKit
import Observation
/// Führt durch die Anmeldung an einem Flaro-Server.
///
/// Zwei Fragen am Telefon: wo steht der Server, und wer bist du.
///
/// **Am Fernseher andersherum.** Dort steht der sechsstellige Code vorn:
/// es gibt keinen Passwortspeicher, getippt wird mit dem Steuerkreuz, und
/// das Gerät, auf dem man bestätigt, liegt sowieso auf dem Sofa. Am Telefon
/// führt derselbe Weg nirgendwohin — der Code braucht ein zweites, bereits
/// angemeldetes Gerät, und das erste ist gerade dieses hier.
///
/// Welcher Fall gilt, weiss die Oberfläche; dieses Modell bekommt es im
/// Initialisierer gesagt.
@MainActor
@Observable
final class FlaroSignInModel {
enum Step: Equatable {
case address
case checking
/// Der Code steht auf dem Bildschirm, jetzt wird gewartet.
case code(String)
case credentials
case signingIn
}
enum PreferredMethod { case credentials, code }
var address = ""
var userName = ""
var password = ""
private(set) var step: Step = .address
private(set) var errorMessage: String?
/// Wie der gefundene Server heißt — die Bestätigung, dass die Adresse
/// stimmt, noch bevor jemand Anmeldedaten eintippt.
private(set) var serverName: String?
/// Der Pflichthinweis auf die Metadatenquelle, schon vor der Anmeldung.
private(set) var attributions: [FlaroSignIn.MetadataAttribution] = []
var onAuthenticated: ((FlaroClient, FlaroAccount, String) -> Void)?
private let identity: FlaroIdentity
private let preferred: PreferredMethod
private var baseURL: URL?
private var pollTask: Task<Void, Never>?
/// Der Vorgabewert hält iOS unverändert.
init(identity: FlaroIdentity, preferring: PreferredMethod = .credentials) {
self.identity = identity
self.preferred = preferring
}
// Kein `deinit`, der abbricht: `pollTask` gehört dem Hauptakteur, und
// ein `deinit` läuft nicht dort. Abgebrochen wird über `cancel()` beim
// Verschwinden der Ansicht — wie beim Jellyfin-Modell auch.
/// Hält die Abfrageschleife an.
///
/// Ohne das läuft sie nach dem Wegwischen des Sheets noch minutenlang
/// weiter — unsichtbar und für nichts.
func cancel() {
pollTask?.cancel()
pollTask = nil
}
// MARK: - Schritt 1: den Server finden
func findServer() async {
errorMessage = nil
let kandidaten = FlaroAddress.candidates(for: address)
guard !kandidaten.isEmpty else {
errorMessage = String(localized: "signIn.flaro.addressMissing")
return
}
step = .checking
for kandidat in kandidaten {
guard let gruss = try? await FlaroSignIn.greet(
baseURL: kandidat, identity: identity) else { continue }
// **Ein frischer Server ist kein falsches Passwort.** Wer hier
// weitermachte, bekäme „Benutzername oder Passwort stimmt nicht"
// für ein Konto, das es noch gar nicht gibt.
guard !gruss.needsSetup else {
baseURL = kandidat
serverName = gruss.serverName
step = .address
errorMessage = String(localized: "signIn.flaro.needsSetup")
return
}
baseURL = kandidat
address = kandidat.absoluteString
serverName = gruss.serverName
attributions = gruss.attributions
if preferred == .code {
await beginCode()
} else {
step = .credentials
}
return
}
step = .address
errorMessage = String(localized: "signIn.flaro.notFound")
}
/// Zurück zur Adresse — etwa, weil der gefundene Server der falsche ist.
func changeAddress() {
cancel()
baseURL = nil
serverName = nil
errorMessage = nil
step = .address
}
// MARK: - Schritt 2a: der Code
/// Fordert einen Code an und wartet auf die Bestätigung.
func beginCode() async {
guard let baseURL else { return }
cancel()
errorMessage = nil
let offen: FlaroSignIn.PendingCode
do {
offen = try await FlaroSignIn.requestCode(baseURL: baseURL, identity: identity)
} catch {
step = .credentials
errorMessage = ErrorText.describe(error)
return
}
step = .code(offen.code)
// **Nachfragen, nicht offen halten.** Eine Anfrage, die fünf Minuten
// auf eine Bestätigung wartet, läuft hinter jedem Reverse Proxy ins
// Zeitlimit.
pollTask = Task { [weak self] in
while !Task.isCancelled {
try? await Task.sleep(for: .seconds(2))
if Task.isCancelled { return }
guard let self else { return }
guard await self.checkCode(baseURL: baseURL, pending: offen) else { return }
}
}
}
/// Eine Runde der Abfrage. `false` heisst: es gibt nichts mehr zu warten.
private func checkCode(baseURL: URL, pending: FlaroSignIn.PendingCode) async -> Bool {
guard let antwort = try? await FlaroSignIn.pollCode(
baseURL: baseURL, pending: pending, identity: identity)
else { return true } // Ein Aussetzer ist kein Abbruch.
switch antwort.state {
case .pending:
return true
case .expired:
errorMessage = String(localized: "signIn.flaro.codeExpired")
step = .credentials
return false
case .approved(let token, let konto):
guard let client = antwort.client else { return false }
onAuthenticated?(client, konto, token)
return false
}
}
/// Zurück zum Passwort — für Server, auf denen niemand bestätigen kann.
func useCredentials() {
cancel()
errorMessage = nil
step = .credentials
}
// MARK: - Schritt 2b: anmelden
func signIn() async {
guard let baseURL else { return }
cancel()
errorMessage = nil
let name = userName.trimmingCharacters(in: .whitespacesAndNewlines)
guard !name.isEmpty, !password.isEmpty else {
errorMessage = String(localized: "signIn.flaro.credentialsMissing")
return
}
step = .signingIn
do {
let (token, konto, client) = try await FlaroSignIn.signIn(
baseURL: baseURL, userName: name, password: password, identity: identity)
// **Das Passwort sofort wegwerfen.** Es wird für die Dauer einer
// Anfrage gehalten und danach nicht mehr gebraucht; es stehen zu
// lassen hiesse, es in einem Speicherabbild wiederzufinden.
password = ""
onAuthenticated?(client, konto, token)
} catch {
password = ""
step = .credentials
errorMessage = ErrorText.describe(error)
}
}
}
Flaro/Session/HeroArtwork.swift
+4 -1
View File
@@ -101,7 +101,10 @@ enum HeroArtwork {
? [item.posterArtworkPath, item.thumb, item.parentThumb, item.seriesThumb, item.art] ? [item.posterArtworkPath, item.thumb, item.parentThumb, item.seriesThumb, item.art]
// Quer: das eigene Hintergrundbild, dann das der Staffel, dann // Quer: das eigene Hintergrundbild, dann das der Staffel, dann
// das der Serie — und erst danach das Vorschaubild der Folge. // das der Serie — und erst danach das Vorschaubild der Folge.
: [item.art, item.parentThumb, item.seriesArt, item.seriesThumb, item.thumb] // **Das Aufmacherbild zuerst.** Es ist das, was für genau diese
// Fläche ausgesucht wurde; der Hintergrund ist die Vorgabe
// dahinter.
: [item.heroArt, item.art, item.parentThumb, item.seriesArt, item.seriesThumb, item.thumb]
var gesehen = Set<String>() var gesehen = Set<String>()
return pfade return pfade
Flaro/Session/Heruntergeladenes.swift
+173
View File
@@ -0,0 +1,173 @@
import FlaroDownloads
import Foundation
import MediaKit
/// Was auf dem Gerät liegt, als gewöhnliche Titel.
///
/// **Damit ein Download aussieht wie alles andere.** Bisher waren Downloads
/// eine eigene Welt: eine eigene Liste, eine eigene Zeile, ein eigener
/// Bereich. Wer etwas ansehen wollte, musste erst wissen, dass er dorthin
/// wechseln muss. Als `MediaItem` fügt sich ein Download in jede Reihe und
/// jedes Raster ein, das es ohnehin gibt — Kachel, Fortschrittsbalken,
/// Kontextmenü inbegriffen.
///
/// **Und es ist die Grundlage fürs Offline-Arbeiten.** Ohne Server gibt es
/// keine andere Quelle für einen Titel; alles, was dann noch dasteht, kommt
/// von hier.
@MainActor
enum Heruntergeladenes {
/// Die fertigen Downloads, neueste zuerst.
///
/// **Nur fertige.** Ein halb geladener Film ist nichts zum Ansehen; er
/// steht im Downloads-Bereich mit seinem Balken, und dort gehört er hin.
static func fertige(in coordinator: DownloadCoordinator) -> [DownloadItem] {
coordinator.items
.filter(\.isComplete)
.sorted { ($0.completedAt ?? $0.addedAt) > ($1.completedAt ?? $1.addedAt) }
}
/// Was auf dem Gerät liegt — Filme einzeln, Serien als **eine** Kachel.
///
/// **Zwanzig Folgen sind keine zwanzig Titel.** Vorher stand jede
/// einzeln in der Reihe, und eine heruntergeladene Staffel schob alles
/// andere aus dem Bild. Was man im Kopf hat, ist die Serie; welche
/// Folgen davon da sind, ist die Frage danach — und die beantwortet die
/// Seite der Serie.
static func reihe(in coordinator: DownloadCoordinator) -> [MediaItem] {
var ergebnis: [MediaItem] = []
var gesehen = Set<String>()
for eintrag in fertige(in: coordinator) {
guard let serie = eintrag.seriesKey else {
ergebnis.append(titel(eintrag, in: coordinator))
continue
}
// Die Reihenfolge der Folgen ist die der Serie: die zuletzt
// fertige Folge bestimmt, wo die Serie steht.
guard gesehen.insert(serie).inserted else { continue }
ergebnis.append(self.serie(serie, in: coordinator))
}
return ergebnis
}
/// Eine Serie, von der Folgen auf dem Gerät liegen.
static func serie(_ schluessel: String, in coordinator: DownloadCoordinator) -> MediaItem {
let folgen = folgenEintraege(derSerie: schluessel, in: coordinator)
return MediaItem(
id: schluessel,
kind: .show,
title: folgen.first?.seriesTitle ?? folgen.first?.title ?? "",
// **Erst das Plakat der Serie, dann irgendein Folgenbild.** Ein
// Szenenbild hochkant ist ein zufälliger Ausschnitt — aber immer
// noch besser als eine graue Fläche.
thumb: coordinator.artworkURL(forRatingKey: schluessel)?.absoluteString
?? folgen.lazy
.compactMap { coordinator.artworkURL(forRatingKey: $0.ratingKey)?.absoluteString }
.first
)
}
/// Wie viele Folgen dieser Serie hier liegen — als Zeile unter der
/// Kachel.
///
/// `nil` für alles, was keine Serie mit Downloads ist: dann gilt, was
/// sonst unter einer Kachel steht.
static func untertitel(für titel: MediaItem, in coordinator: DownloadCoordinator) -> String? {
guard titel.kind == .show else { return nil }
let anzahl = folgenEintraege(derSerie: titel.id, in: coordinator).count
guard anzahl > 0 else { return nil }
return String(localized: "downloads.episodeCount \(anzahl)")
}
/// Die heruntergeladenen Folgen einer Serie, aufsteigend sortiert.
///
/// Für die Seite der Serie, wenn kein Server antwortet: dann ist das
/// hier die ganze Liste, die es gibt.
static func folgen(derSerie schluessel: String, in coordinator: DownloadCoordinator) -> [MediaItem] {
folgenEintraege(derSerie: schluessel, in: coordinator)
.sorted {
($0.seasonIndex ?? 0, $0.episodeIndex ?? 0) < ($1.seasonIndex ?? 0, $1.episodeIndex ?? 0)
}
.map { titel($0, in: coordinator) }
}
private static func folgenEintraege(
derSerie schluessel: String,
in coordinator: DownloadCoordinator
) -> [DownloadItem] {
fertige(in: coordinator).filter { $0.seriesKey == schluessel }
}
/// Ein Download als Titel.
///
/// **Das Bild kommt von der Platte, nicht vom Server.** `thumb` ist sonst
/// ein Pfad, den erst ein Server zu einer Adresse macht; hier steht
/// stattdessen die fertige lokale Adresse. Ansichten, die `rawImageURL`
/// darauf anwenden, müssen das wissen — siehe `bildAdresse`.
static func titel(_ eintrag: DownloadItem, in coordinator: DownloadCoordinator) -> MediaItem {
MediaItem(
id: eintrag.ratingKey,
kind: eintrag.seriesKey == nil ? .movie : .episode,
title: eintrag.title,
duration: eintrag.durationMilliseconds,
thumb: coordinator.artworkURL(forRatingKey: eintrag.ratingKey)?.absoluteString,
index: eintrag.episodeIndex,
parentIndex: eintrag.seasonIndex,
parentTitle: eintrag.seriesTitle,
seriesTitle: eintrag.seriesTitle,
seriesID: eintrag.seriesKey,
versions: [fassung(eintrag)]
)
}
/// Die Datei auf dem Gerät als Fassung.
///
/// **Ohne sie bleibt der Abspielknopf grau.** Die Detailseite schaltet
/// ihn an `currentMedia?.files.first` fest, und das ist richtig: ein
/// Titel ohne Datei lässt sich nicht abspielen. Offline *gibt* es die
/// Datei aber — sie liegt nur woanders. Was der Server beim Herunterladen
/// über sie gesagt hat, steht in `offlineMediaData`.
private static func fassung(_ eintrag: DownloadItem) -> MediaVersion {
let angaben = eintrag.offlineMediaData.flatMap {
try? JSONDecoder().decode(OfflineMedia.self, from: $0)
}
return MediaVersion(
id: eintrag.ratingKey,
container: angaben?.container,
videoCodec: angaben?.videoCodec,
audioCodec: angaben?.audioCodec,
videoResolution: angaben?.videoResolution,
bitrate: angaben?.bitrate,
duration: eintrag.durationMilliseconds,
files: [MediaFile(
id: eintrag.ratingKey,
itemID: eintrag.ratingKey,
container: angaben?.container,
size: eintrag.totalBytes > 0 ? eintrag.totalBytes : nil,
duration: eintrag.durationMilliseconds
)]
)
}
/// Die Adresse eines Bildes, das schon eine ist.
///
/// **Ein Umweg, der nötig ist.** Die Kacheln bauen ihre Bildadresse über
/// den Server (`rawImageURL`), weil `thumb` dort ein Pfad ist. Bei einem
/// Download steht darin bereits eine `file:`-Adresse — durch denselben
/// Bau geschickt käme Unsinn heraus.
static func bildAdresse(_ titel: MediaItem) -> URL? {
guard let roh = titel.thumb, roh.hasPrefix("file:") else { return nil }
return URL(string: roh)
}
/// Ob dieser Titel auf dem Gerät liegt.
///
/// **Eine Serie gilt als da, wenn Folgen von ihr da sind.** Die Serie
/// selbst wird nie heruntergeladen — ihre Folgen schon, und wer die
/// Kachel sieht, will wissen, ob er etwas davon ansehen kann.
static func liegtBereit(_ titelID: String, in coordinator: DownloadCoordinator) -> Bool {
coordinator.items.contains {
$0.isComplete && ($0.ratingKey == titelID || $0.seriesKey == titelID)
}
}
}
Flaro/Session/HomeFeed.swift
+55 -5
View File
@@ -1,3 +1,4 @@
import Foundation
import MediaKit import MediaKit
import Observation import Observation
@@ -19,6 +20,14 @@ import Observation
final class HomeFeed { final class HomeFeed {
private(set) var state: LoadState<[MediaRowGroup]> = .loading private(set) var state: LoadState<[MediaRowGroup]> = .loading
/// Ob das Gezeigte vom letzten Mal stammt, weil der Server nicht
/// antwortet.
///
/// Die Startseite ist dann **nicht** falsch, nur alt — und das muss
/// dranstehen. Ein Stand von gestern, der sich als heute ausgibt, ist
/// schlimmer als gar keiner.
private(set) var ausDemSpeicher = false
/// Holt die Reihen vom Server. /// Holt die Reihen vom Server.
/// ///
/// Der Server kommt als Argument, nicht als gespeicherter Wert — dasselbe /// Der Server kommt als Argument, nicht als gespeicherter Wert — dasselbe
@@ -29,6 +38,24 @@ final class HomeFeed {
state = await LoadState.load(keepingPrevious: state) { state = await LoadState.load(keepingPrevious: state) {
try await backend.homeRows() try await backend.homeRows()
} }
switch state {
case .loaded(let reihen):
ausDemSpeicher = false
await LibraryCache.shared.storeHomeRows(reihen, server: backend.identity)
case .failed:
// **Der Abzug erst hier, nicht vorweg.** Ihn sofort zu zeigen
// hiesse, bei jedem Start eine alte Startseite aufzublitzen, die
// eine Sekunde später ersetzt wird. Er ist ein Rettungsanker,
// kein Beschleuniger.
if let gemerkt = await LibraryCache.shared.homeRows(server: backend.identity),
!gemerkt.isEmpty {
state = .loaded(gemerkt)
ausDemSpeicher = true
}
case .loading:
break
}
#if os(tvOS) #if os(tvOS)
// Das Regal über der App im Menü. Es wird gezeichnet, wenn die App // Das Regal über der App im Menü. Es wird gezeichnet, wenn die App
// **nicht** läuft — also legen wir hier ab, was dort stehen soll. // **nicht** läuft — also legen wir hier ab, was dort stehen soll.
@@ -38,10 +65,33 @@ final class HomeFeed {
#endif #endif
} }
/// Die Kennung der Downloadreihe.
///
/// Fest und nicht vom Server: nur so lässt sie sich wie jede andere
/// Reihe verschieben oder ausblenden.
static let downloadsRow = "flaro.downloads"
/// Die Reihen in der eingestellten Form. /// Die Reihen in der eingestellten Form.
func rows(for layout: HomeLayoutSettings) -> [MediaRowGroup] { ///
guard case .loaded(let alle) = state else { return [] } /// `downloaded` kommt von aussen, weil `HomeFeed` nichts von Downloads
return layout.apply(to: prepared(alle, layout: layout)) /// weiss und auch nichts davon wissen muss — es ist eine Reihe wie jede
/// andere, nur mit einer anderen Quelle.
/// **Auch ohne geladene Reihen**: scheitert der Server und liegt nichts
/// im Speicher, bleibt immer noch, was auf dem Gerät liegt.
func rows(for layout: HomeLayoutSettings, downloaded: [MediaItem] = []) -> [MediaRowGroup] {
var reihen: [MediaRowGroup] = []
if case .loaded(let alle) = state { reihen = prepared(alle, layout: layout) }
if !downloaded.isEmpty {
reihen.insert(
MediaRowGroup(
id: Self.downloadsRow,
title: String(localized: "home.downloaded"),
items: downloaded
),
at: 0
)
}
return layout.apply(to: reihen)
} }
// MARK: - Ordnen // MARK: - Ordnen
@@ -155,8 +205,8 @@ final class HomeFeed {
case .continueFirst: case .continueFirst:
// Innerhalb der Gruppen ziehen, nicht über sie hinweg: // Innerhalb der Gruppen ziehen, nicht über sie hinweg:
// Angefangenes bleibt vorn, wechselt aber untereinander. // Angefangenes bleibt vorn, wechselt aber untereinander.
let ordered = HeroSelection.ordered(unique.filter { $0.watchProgress != nil }) let ordered = HeroSelection.ordered(unique.filter(\.isResumable))
+ HeroSelection.ordered(unique.filter { $0.watchProgress == nil }) + HeroSelection.ordered(unique.filter { !$0.isResumable })
return Array(ordered.prefix(layout.heroCount)) return Array(ordered.prefix(layout.heroCount))
case .latestOnly: case .latestOnly:
return Array(HeroSelection.ordered(unique).prefix(layout.heroCount)) return Array(HeroSelection.ordered(unique).prefix(layout.heroCount))
Flaro/Session/LanguagePreferences.swift
+39
View File
@@ -34,6 +34,7 @@ final class LanguagePreferences {
static let avoidsAudioDescription = "flaro.languages.avoidsAudioDescription" static let avoidsAudioDescription = "flaro.languages.avoidsAudioDescription"
static let perLibrary = "flaro.languages.library" static let perLibrary = "flaro.languages.library"
static let perSeries = "flaro.languages.series" static let perSeries = "flaro.languages.series"
static let perSeriesSubtitles = "flaro.languages.seriesSubtitles"
static let rememberedTracks = "flaro.languages.seriesTrack" static let rememberedTracks = "flaro.languages.seriesTrack"
} }
@@ -98,6 +99,14 @@ final class LanguagePreferences {
/// deutsch ausgezeichnete Spur die mit Audiodeskription und die als /// deutsch ausgezeichnete Spur die mit Audiodeskription und die als
/// englisch ausgezeichnete die eigentliche deutsche. Eine Sprache /// englisch ausgezeichnete die eigentliche deutsche. Eine Sprache
/// abzulegen hiesse dort, den Fehler festzuschreiben. /// abzulegen hiesse dort, den Fehler festzuschreiben.
/// Die Untertitelsprache je Titel — Serie oder Film.
///
/// **Ein Topf für beide.** Die Kennung eines Films kollidiert mit keiner
/// Serie; zwei Wörterbücher für dieselbe Frage liefen auseinander.
private var perSeriesSubtitles: [String: String] {
didSet { defaults.set(perSeriesSubtitles, forKey: Key.perSeriesSubtitles) }
}
private var rememberedTracks: [String: AudioTrackChooser.TrackSignature] { private var rememberedTracks: [String: AudioTrackChooser.TrackSignature] {
didSet { didSet {
guard let daten = try? JSONEncoder().encode(rememberedTracks) else { return } guard let daten = try? JSONEncoder().encode(rememberedTracks) else { return }
@@ -117,6 +126,8 @@ final class LanguagePreferences {
(defaults.object(forKey: Key.avoidsAudioDescription) as? Bool) ?? true (defaults.object(forKey: Key.avoidsAudioDescription) as? Bool) ?? true
self.perLibrary = defaults.dictionary(forKey: Key.perLibrary) as? [String: String] ?? [:] self.perLibrary = defaults.dictionary(forKey: Key.perLibrary) as? [String: String] ?? [:]
self.perSeries = defaults.dictionary(forKey: Key.perSeries) as? [String: String] ?? [:] self.perSeries = defaults.dictionary(forKey: Key.perSeries) as? [String: String] ?? [:]
self.perSeriesSubtitles =
defaults.dictionary(forKey: Key.perSeriesSubtitles) as? [String: String] ?? [:]
self.rememberedTracks = (defaults.data(forKey: Key.rememberedTracks)).flatMap { self.rememberedTracks = (defaults.data(forKey: Key.rememberedTracks)).flatMap {
try? JSONDecoder().decode([String: AudioTrackChooser.TrackSignature].self, from: $0) try? JSONDecoder().decode([String: AudioTrackChooser.TrackSignature].self, from: $0)
} ?? [:] } ?? [:]
@@ -136,6 +147,34 @@ final class LanguagePreferences {
perSeries[id] = code perSeries[id] = code
} }
/// Was „keine Untertitel" im Speicher heisst.
///
/// **Abgewählt ist eine Aussage, kein Fehlen einer.** Wer sie für diese
/// Serie abgeschaltet hat, will sie auch in Folge 7 nicht; ein fehlender
/// Eintrag hiesse dagegen „nie etwas gesagt", und dann darf eine
/// erzwungene Spur durchaus erscheinen.
static let noSubtitles = "keine"
func subtitleLanguage(forSeries id: String) -> String? { perSeriesSubtitles[id] }
func setSubtitleLanguage(_ code: String?, forSeries id: String) {
perSeriesSubtitles[id] = code
}
/// Welche Untertitelsprache für diesen Titel gilt — `nil` heisst: keine.
///
/// **Die Ebene schlägt das Allgemeine.** Dieselbe Rangfolge wie beim Ton,
/// nur ohne Mediathek: eine Untertitelsprache je Mediathek hat noch
/// niemand verlangt, und eine Einstellung, die niemand sucht, ist eine
/// Stelle mehr, an der etwas auseinanderlaufen kann.
func subtitleWish(titleID: String?) -> String? {
if let eigen = titleID.flatMap({ perSeriesSubtitles[$0] }) {
return eigen == Self.noSubtitles ? nil : eigen
}
return subtitleLanguage.isEmpty ? nil : subtitleLanguage
}
func rememberedTrack(forSeries id: String) -> AudioTrackChooser.TrackSignature? { func rememberedTrack(forSeries id: String) -> AudioTrackChooser.TrackSignature? {
rememberedTracks[id] rememberedTracks[id]
} }
Flaro/Session/PlaybackSettings.swift
+10
View File
@@ -32,6 +32,7 @@ final class PlaybackSettings {
static let cellularQuality = "flaro.playback.quality.cellular" static let cellularQuality = "flaro.playback.quality.cellular"
static let autoSkipIntro = "flaro.playback.autoSkipIntro" static let autoSkipIntro = "flaro.playback.autoSkipIntro"
static let autoSkipCredits = "flaro.playback.autoSkipCredits" static let autoSkipCredits = "flaro.playback.autoSkipCredits"
static let skipExtraScenes = "flaro.playback.skipExtraScenes"
static let autoPlayNext = "flaro.playback.autoPlayNext" static let autoPlayNext = "flaro.playback.autoPlayNext"
static let locksLandscape = "flaro.playback.locksLandscape" static let locksLandscape = "flaro.playback.locksLandscape"
static let rewindSeconds = "flaro.playback.rewindSeconds" static let rewindSeconds = "flaro.playback.rewindSeconds"
@@ -58,6 +59,14 @@ final class PlaybackSettings {
var cellularQuality: Quality { didSet { defaults.set(cellularQuality.rawValue, forKey: Key.cellularQuality) } } var cellularQuality: Quality { didSet { defaults.set(cellularQuality.rawValue, forKey: Key.cellularQuality) } }
var autoSkipIntro: Bool { didSet { defaults.set(autoSkipIntro, forKey: Key.autoSkipIntro) } } var autoSkipIntro: Bool { didSet { defaults.set(autoSkipIntro, forKey: Key.autoSkipIntro) } }
var autoSkipCredits: Bool { didSet { defaults.set(autoSkipCredits, forKey: Key.autoSkipCredits) } } var autoSkipCredits: Bool { didSet { defaults.set(autoSkipCredits, forKey: Key.autoSkipCredits) } }
/// Ob „Abspann überspringen" auch über Post-Credit-Szenen hinweggeht.
///
/// **Eine Gerätesache, keine Servereinstellung.** Ob jemand die Szene
/// sehen will, entscheidet er am Gerät, auf dem er sitzt — wie bei
/// `autoSkipIntro`. Vorgabe aus: wer den Knopf drückt, landet bei der
/// Szene und kann sie wegdrücken, wenn er mag.
var skipExtraScenes: Bool { didSet { defaults.set(skipExtraScenes, forKey: Key.skipExtraScenes) } }
var autoPlayNext: Bool { didSet { defaults.set(autoPlayNext, forKey: Key.autoPlayNext) } } var autoPlayNext: Bool { didSet { defaults.set(autoPlayNext, forKey: Key.autoPlayNext) } }
/// ISO-Sprachcode, etwa `deu`. Leer heißt: nehmen, was der Server vorgibt. /// ISO-Sprachcode, etwa `deu`. Leer heißt: nehmen, was der Server vorgibt.
@@ -117,6 +126,7 @@ final class PlaybackSettings {
self.autoSkipIntro = defaults.object(forKey: Key.autoSkipIntro) as? Bool ?? false self.autoSkipIntro = defaults.object(forKey: Key.autoSkipIntro) as? Bool ?? false
self.autoSkipCredits = defaults.object(forKey: Key.autoSkipCredits) as? Bool ?? false self.autoSkipCredits = defaults.object(forKey: Key.autoSkipCredits) as? Bool ?? false
self.skipExtraScenes = defaults.object(forKey: Key.skipExtraScenes) as? Bool ?? false
self.autoPlayNext = defaults.object(forKey: Key.autoPlayNext) as? Bool ?? true self.autoPlayNext = defaults.object(forKey: Key.autoPlayNext) as? Bool ?? true
self.locksLandscape = defaults.object(forKey: Key.locksLandscape) as? Bool ?? true self.locksLandscape = defaults.object(forKey: Key.locksLandscape) as? Bool ?? true
Flaro/Session/TopShelfWriter.swift
+1 -1
View File
@@ -61,7 +61,7 @@ enum TopShelfWriter {
width: posterWidth, width: posterWidth,
height: posterHeight height: posterHeight
), ),
progress: item.watchProgress progress: item.resumeProgress
) )
} }
) )
Flaro/Views/Components/ItemActionEntries.swift
+1 -1
View File
@@ -44,7 +44,7 @@ struct ItemActionEntries: View {
// **Nur, wenn es etwas zu entfernen gibt.** Ohne gemerkte Stelle // **Nur, wenn es etwas zu entfernen gibt.** Ohne gemerkte Stelle
// stünde hier ein Eintrag, der nichts tut — und der Nutzer suchte den // stünde hier ein Eintrag, der nichts tut — und der Nutzer suchte den
// Fehler bei sich. // Fehler bei sich.
if item.watchProgress != nil { if item.isResumable {
Button { Button {
run { try await $0.removeFromContinueWatching(item) } run { try await $0.removeFromContinueWatching(item) }
} label: { } label: {
Flaro/Views/Components/QuickPlayTile.swift
+46 -23
View File
@@ -17,14 +17,18 @@ import MediaKit
/// und wäre für VoiceOver gar nicht mehr da. /// und wäre für VoiceOver gar nicht mehr da.
struct QuickPlayTile<Card: View>: View { struct QuickPlayTile<Card: View>: View {
let item: MediaItem let item: MediaItem
/// Ob ein Tipp auf die Detailseite führt, statt abzuspielen. /// Ob ein Tipp sofort abspielt, statt auf die Detailseite zu führen.
/// ///
/// **Für die Suche.** Dort weiß man gerade *nicht*, was man sehen will — /// **Nur beim Weiterschauen.** Dort ist die Absicht eindeutig: der Titel
/// sonst hätte man nicht gesucht. Ein Tipp, der sofort abspielt, ist auf /// steht in dieser Reihe, *weil* man ihn angefangen hat.
/// der Startseite richtig (die Kachel stand schon da, man kennt sie) und ///
/// in einer Trefferliste falsch: der erste Treffer ist eine Vermutung des /// **Überall sonst führt der Tipp auf die Seite.** Vorher war es
/// Servers, keine Entscheidung des Nutzers. /// umgekehrt, mit dem Argument „wer eine Kachel antippt, weiss meistens
var opensDetails: Bool = false /// schon, was er sehen will". Im Gebrauch stimmte das nicht: wer nur
/// nachsehen will, wie viele Staffeln eine Serie hat, bekam den Film.
/// Ein Umweg von einem Schritt ist ärgerlich; eine Wiedergabe, die man
/// nicht wollte, ist schlimmer.
var startsPlayback: Bool = false
@ViewBuilder let card: () -> Card @ViewBuilder let card: () -> Card
@Environment(FlaroSession.self) private var session @Environment(FlaroSession.self) private var session
@@ -57,7 +61,11 @@ struct QuickPlayTile<Card: View>: View {
/// Ob es überhaupt etwas zu starten gibt. /// Ob es überhaupt etwas zu starten gibt.
/// ///
/// Eine Sammlung ist kein Titel — dort wäre der Knopf eine Behauptung. /// Eine Sammlung ist kein Titel — dort wäre der Knopf eine Behauptung.
private var isPlayable: Bool { item.kind != .collection } /// Ein geplanter Titel ebenso: der Server lehnt ihn bis zum Termin ab,
/// und ein Tipp auf die Kachel startete trotzdem — gemessen am Simulator,
/// der Spieler kam bis „Wird vorbereitet …". Dort führt der Tipp jetzt
/// auf die Seite, wo der Termin steht.
private var isPlayable: Bool { item.kind != .collection && !item.isUpcoming }
private var route: MediaRoute { MediaRoute(ratingKey: item.id, title: item.title) } private var route: MediaRoute { MediaRoute(ratingKey: item.id, title: item.title) }
@@ -65,8 +73,9 @@ struct QuickPlayTile<Card: View>: View {
/// ///
/// Drei Gründe, derselbe Ausgang: am Mac ist der Klick seit jeher der Weg /// Drei Gründe, derselbe Ausgang: am Mac ist der Klick seit jeher der Weg
/// auf die Seite (zum Starten gibt es den Knopf beim Überfahren), eine /// auf die Seite (zum Starten gibt es den Knopf beim Überfahren), eine
/// Sammlung hat nichts abzuspielen, und in der Suche ist es gewollt. /// Sammlung hat nichts abzuspielen, und überall ausser beim
private var tapOpensDetails: Bool { isMac || opensDetails || !isPlayable } /// Weiterschauen ist die Seite das Ziel.
private var tapOpensDetails: Bool { isMac || !startsPlayback || !isPlayable }
var body: some View { var body: some View {
kachel kachel
@@ -80,6 +89,11 @@ struct QuickPlayTile<Card: View>: View {
.overlay(alignment: .topTrailing) { .overlay(alignment: .topTrailing) {
if isPlayable, isMac { playButton } if isPlayable, isMac { playButton }
} }
// **Links, weil rechts schon etwas sitzt** — am Mac der Abspielknopf
// beim Überfahren, unten der Fortschrittsbalken.
.overlay(alignment: .topLeading) {
if Heruntergeladenes.liegtBereit(item.id, in: downloads) { downloadMarke }
}
.onContinuousHover { phase in .onContinuousHover { phase in
// Zur Laufzeit, nicht beim Übersetzen: „für iPad angepasst" ist // Zur Laufzeit, nicht beim Übersetzen: „für iPad angepasst" ist
// der iOS-Bau und läuft trotzdem auf dem Mac. // der iOS-Bau und läuft trotzdem auf dem Mac.
@@ -95,11 +109,9 @@ struct QuickPlayTile<Card: View>: View {
// Kachel steht. // Kachel steht.
.contextMenu { .contextMenu {
if isPlayable { if isPlayable {
// **Am Telefon und am iPad führt der Weg zur Detailseite // **Nur dort, wo der Tipp abspielt.** Sonst führt er
// hierher.** Antippen spielt dort ab; wer stattdessen // schon auf die Seite, und ein zweiter Weg dorthin im Menü
// nachsehen will, was das überhaupt ist, drückt lang. Am Mac // wäre ein Eintrag, der nichts Neues anbietet.
// ist es umgekehrt: dort öffnet der Klick die Seite, und zum
// Starten gibt es den Knopf beim Überfahren.
if !tapOpensDetails { if !tapOpensDetails {
Button("hero.details", systemImage: "info.circle") { push(route) } Button("hero.details", systemImage: "info.circle") { push(route) }
Divider() Divider()
@@ -195,14 +207,11 @@ struct QuickPlayTile<Card: View>: View {
/// Die Kachel selbst — und was ein Antippen bedeutet. /// Die Kachel selbst — und was ein Antippen bedeutet.
/// ///
/// **Am Telefon und am iPad spielt es ab.** Wer eine Kachel antippt, weiss /// **Der Tipp führt auf die Detailseite**, am Telefon wie am iPad wie am
/// meistens schon, was er sehen will; der Umweg über die Detailseite /// Mac. Nur in „Weiterschauen" spielt er ab: dort steht der Titel,
/// kostete zwei Schritte für eine Absicht. Die Seite ist weiter da — über /// *weil* man ihn angefangen hat. Abspielen ist sonst einen Schritt
/// langes Drücken, wo auch „gesehen" und „entfernen" stehen. /// weiter — über den Knopf auf der Seite, über langes Drücken, oder am
/// /// Mac über den Knopf beim Überfahren.
/// **Am Mac bleibt der Klick die Detailseite.** Dort gibt es den
/// Abspielknopf beim Überfahren, und langes Drücken ist keine übliche
/// Geste — ein Rechtsklick ist der Weg ins Menü, nicht in den Film.
/// ///
/// Ein `NavigationLink` schiebt selbst; ein Knopf braucht dafür den Weg /// Ein `NavigationLink` schiebt selbst; ein Knopf braucht dafür den Weg
/// aus der Umgebung. Deshalb zwei Fassungen und nicht eine mit `if` im /// aus der Umgebung. Deshalb zwei Fassungen und nicht eine mit `if` im
@@ -243,6 +252,20 @@ struct QuickPlayTile<Card: View>: View {
.accessibilityHidden(true) .accessibilityHidden(true)
} }
/// Das Zeichen für „liegt auf diesem Gerät".
///
/// **Damit man es sieht, ohne danach zu suchen.** Bisher stand ein
/// Download nur im Downloads-Bereich; in der Mediathek sah eine
/// heruntergeladene Folge aus wie jede andere, und wer wissen wollte,
/// was im Flugzeug läuft, musste zwei Listen vergleichen.
private var downloadMarke: some View {
Image(systemName: "arrow.down.circle.fill")
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(.white, Color.black.opacity(0.55))
.padding(FlaroSpacing.snug)
.accessibilityLabel(Text("downloads.available"))
}
/// Ob es etwas herunterzuladen gibt — und ob es nicht schon da ist. /// Ob es etwas herunterzuladen gibt — und ob es nicht schon da ist.
/// ///
/// Sammlungen, Serien und Staffeln fallen heraus: dort lädt man nicht /// Sammlungen, Serien und Staffeln fallen heraus: dort lädt man nicht
Flaro/Views/Components/UpcomingNotice.swift
+44
View File
@@ -0,0 +1,44 @@
import SwiftUI
import FlaroDesign
import MediaKit
/// Steht dort, wo sonst „Abspielen" stünde.
///
/// **Ein Knopf, der nichts tut, ist schlimmer als keiner.** Ein geplanter
/// Titel steht in der Mediathek, damit man weiss, dass er kommt — das ist der
/// Sinn des Planens. Der Server lehnt ihn bis zum Termin ab; stünde der Knopf
/// trotzdem da, wäre die Reihenfolge: draufdrücken, freuen, Absage lesen.
///
/// Ein Baustein für Aufmacher und Detailseite, weil sonst an der einen Stelle
/// der Termin stünde und an der anderen weiter der Knopf.
struct UpcomingNotice: View {
@Environment(\.flaroAccent) private var accent
let date: Date
var body: some View {
HStack(spacing: FlaroSpacing.regular) {
Image(systemName: "clock")
.font(.flaroCardTitle)
.foregroundStyle(accent)
VStack(alignment: .leading, spacing: 2) {
Text("upcoming.title")
.font(.flaroCardTitle)
Text("upcoming.from \(Self.formatted(date))")
.font(.flaroCaption)
.foregroundStyle(Color.flaroTextSecondary)
}
}
.padding(.horizontal, FlaroSpacing.loose)
.padding(.vertical, FlaroSpacing.snug)
.background(Color.flaroElevated, in: .rect(cornerRadius: FlaroRadius.control))
.accessibilityElement(children: .combine)
}
/// „Dienstag, 6. Oktober 2026 um 18:00" — in der Sprache des Geräts.
static func formatted(_ date: Date) -> String {
date.formatted(
.dateTime.weekday(.wide).day().month(.wide).year().hour().minute())
}
}
Flaro/Views/Detail/MediaDetailView.swift
+37 -1
View File
@@ -1,5 +1,6 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroDownloads
import MediaKit import MediaKit
/// Die Detailseite eines Titels. /// Die Detailseite eines Titels.
@@ -11,6 +12,7 @@ struct MediaDetailView: View {
let route: MediaRoute let route: MediaRoute
@Environment(FlaroSession.self) private var session @Environment(FlaroSession.self) private var session
@Environment(DownloadCoordinator.self) private var downloads
@State private var state: LoadState<MediaItem> = .loading @State private var state: LoadState<MediaItem> = .loading
var body: some View { var body: some View {
@@ -50,10 +52,44 @@ struct MediaDetailView: View {
.task(id: route.ratingKey) { await load() } .task(id: route.ratingKey) { await load() }
} }
/// Holt den Titel — vom Server, und sonst vom Gerät.
///
/// **Sonst führte ein Download ins Leere.** Ausserhalb von
/// „Fortsetzen" öffnet ein Tipp auf eine Kachel diese Seite; ohne
/// Server endete sie bei einem Fehlerbild, und die Datei, die daneben
/// auf der Platte lag, war von hier aus nicht mehr zu erreichen.
///
/// Der Server bleibt massgeblich: nur wenn er nicht antwortet, tritt
/// das Wenige ein, was ein Download über sich selbst weiss.
private func load() async { private func load() async {
guard let server = session.backend else { return } guard let server = session.backend else {
state = vomGeraet.map { .loaded($0) }
?? .failed(message: String(localized: "error.serverUnreachable"))
return
}
state = await LoadState.load { state = await LoadState.load {
try await server.item(id: route.ratingKey) try await server.item(id: route.ratingKey)
} }
if case .failed(let message) = state {
state = vomGeraet.map { .loaded($0) } ?? .failed(message: message)
}
}
/// Was über diesen Titel auf dem Gerät liegt.
///
/// **Auch eine Serie**, obwohl keine Serie je heruntergeladen wird: in
/// der Downloadreihe steht sie als eine Kachel, und ein Tipp darauf
/// führt hierher. Ohne diesen Zweig endete er ohne Verbindung im
/// Nichts.
private var vomGeraet: MediaItem? {
if let eintrag = downloads.items.first(
where: { $0.isComplete && $0.ratingKey == route.ratingKey }
) {
return Heruntergeladenes.titel(eintrag, in: downloads)
}
guard downloads.items.contains(
where: { $0.isComplete && $0.seriesKey == route.ratingKey }
) else { return nil }
return Heruntergeladenes.serie(route.ratingKey, in: downloads)
} }
} }
Flaro/Views/Detail/PlayableDetailView.swift
+102 -25
View File
@@ -1,6 +1,7 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import MediaKit import MediaKit
import FlaroPlayback
/// Die Detailseite von etwas, das sich direkt abspielen lässt — Film oder /// Die Detailseite von etwas, das sich direkt abspielen lässt — Film oder
/// einzelne Folge. /// einzelne Folge.
@@ -67,6 +68,41 @@ struct PlayableDetailView: View {
return item.versions[selectedVersion] return item.versions[selectedVersion]
} }
/// Welche Sprachen in dieser Datei liegen.
///
/// **Kein Serverweg nötig.** Bei einem Film ist die Datei der Titel; ihre
/// Spuren stehen in der Antwort, die diese Seite ohnehin geholt hat. Nur
/// bei einer Serie muss gerechnet werden, und dafür gibt es den
/// Endpunkt.
private var sprachen: AvailableLanguages? {
guard let part = currentMedia?.files.first else { return nil }
return AvailableLanguages(
audio: optionen(part.audioStreams),
subtitles: optionen(part.subtitleStreams),
partial: 0)
}
/// Aus Spuren werden Sprachen — jede einmal, auch bei zwei Tonspuren.
private func optionen(_ spuren: [MediaStream]) -> [LanguageOption] {
var gesehen = Set<String>()
var liste: [LanguageOption] = []
for spur in spuren {
guard let roh = spur.languageCode ?? spur.language,
let code = LanguageCode.normalized(roh),
gesehen.insert(code).inserted
else { continue }
let name = Locale.current.localizedString(forLanguageCode: code)?.capitalized
?? spur.language
?? code.uppercased()
liste.append(LanguageOption(code: code, name: name))
}
return liste
}
private var header: some View { private var header: some View {
HeroBanner( HeroBanner(
title: item.rowTitle, title: item.rowTitle,
@@ -97,35 +133,76 @@ struct PlayableDetailView: View {
// Karussell auf dem Telefon quer ist. // Karussell auf dem Telefon quer ist.
aspectRatio: HeroArtwork.aspectRatio(.detailHeader, compact: sizeClass == .compact) aspectRatio: HeroArtwork.aspectRatio(.detailHeader, compact: sizeClass == .compact)
) { ) {
Button { // Geplant heisst sichtbar, nicht abspielbar. Weder Abspielen
playback.play(item, mediaIndex: selectedVersion) // noch Herunterladen — der Server lehnt beides bis zum Termin ab.
} label: { if item.isUpcoming, let ab = item.availableFrom {
Label( UpcomingNotice(date: ab)
item.watchProgress == nil ? "hero.play" : "hero.resume", } else {
systemImage: "play.fill"
)
.font(.flaroCardTitle)
.padding(.horizontal, FlaroSpacing.loose)
.padding(.vertical, FlaroSpacing.snug)
}
.buttonStyle(.borderedProminent)
.tint(accent)
.disabled(currentMedia?.files.first == nil)
if let progress = item.watchProgress, progress > 0 {
Button { Button {
playback.play(item, mediaIndex: selectedVersion, resuming: false) playback.play(item, mediaIndex: selectedVersion)
} label: { } label: {
Label("detail.playFromStart", systemImage: "gobackward") Label(
.labelStyle(.iconOnly) item.isResumable ? "hero.resume" : "hero.play",
.font(.flaroCardTitle) systemImage: "play.fill"
.padding(FlaroSpacing.snug) )
.font(.flaroCardTitle)
.padding(.horizontal, FlaroSpacing.loose)
.padding(.vertical, FlaroSpacing.snug)
} }
.buttonStyle(.bordered) .buttonStyle(.borderedProminent)
.tint(Color.flaroTextSecondary) .tint(accent)
} .disabled(currentMedia?.files.first == nil)
DownloadButton(item: item, mediaIndex: selectedVersion) // „Von vorn" nur, wenn es ein „weiter" gibt — dieselbe
// Entscheidung wie beim Knopf daneben.
if item.isResumable {
Button {
playback.play(item, mediaIndex: selectedVersion, resuming: false)
} label: {
Label("detail.playFromStart", systemImage: "gobackward")
.labelStyle(.iconOnly)
.font(.flaroCardTitle)
.padding(FlaroSpacing.snug)
}
.buttonStyle(.bordered)
.tint(Color.flaroTextSecondary)
}
DownloadButton(item: item, mediaIndex: selectedVersion)
// **Die Sprache vor dem Start, nicht erst mitten im Film.**
//
// Im Spieler umzustellen heisst, den Strom neu aufzubauen —
// und bei einem Film, den man immer im Original sehen will,
// jedes Mal von Neuem. Welche Spuren es gibt, steht hier
// ohnehin schon, also gehört die Wahl neben den Knopf, der
// sie anwendet.
//
// **Nur bei einem Film.** Bei einer Folge gilt, was für die
// Serie eingestellt ist; dieselbe Frage zwanzigmal zu
// stellen wäre keine Wahl, sondern eine Prüfung der Geduld.
if item.kind != .episode, let angebot = sprachen {
if !angebot.audio.isEmpty {
AudioLanguagePicker(
scope: .series(item.id),
title: "languages.audioShort",
kind: .audio,
form: .knopf,
available: angebot.audio
)
}
if !angebot.subtitles.isEmpty {
AudioLanguagePicker(
scope: .series(item.id),
title: "languages.subtitlesShort",
kind: .subtitles,
form: .knopf,
available: angebot.subtitles
)
}
}
}
} }
} }
Flaro/Views/Detail/SeriesDetailView.swift
+126 -12
View File
@@ -33,6 +33,17 @@ struct SeriesDetailView: View {
@State private var isWorking = false @State private var isWorking = false
@State private var summary: String? @State private var summary: String?
/// Welche Staffel die Liste zeigt — `nil` heisst: die erste.
///
/// **Weil der Server die Folgen am Stück liefert.** Eine Serie mit zwei
/// Staffeln ergab eine Liste, in der nach Folge 8 wieder eine Folge 1
/// kam, ohne dass irgendwo stünde, dass dazwischen eine Staffel endet.
@State private var gewaehlteStaffel: Int?
/// Welche Sprachen diese Serie durchgehend führt — `nil`, solange es
/// niemand weiss.
@State private var sprachen: AvailableLanguages?
var body: some View { var body: some View {
ScrollView { ScrollView {
VStack(alignment: .leading, spacing: FlaroSpacing.section) { VStack(alignment: .leading, spacing: FlaroSpacing.section) {
@@ -54,11 +65,35 @@ struct SeriesDetailView: View {
// dieselbe Einstellung zu haben, von denen einer nie gelesen // dieselbe Einstellung zu haben, von denen einer nie gelesen
// wird. // wird.
if item.kind == .show { if item.kind == .show {
AudioLanguagePicker( VStack(alignment: .leading, spacing: FlaroSpacing.snug) {
scope: .series(item.id), AudioLanguagePicker(
title: "languages.forThisSeries" scope: .series(item.id),
) title: "languages.forThisSeries",
kind: .audio,
available: sprachen?.audio
)
AudioLanguagePicker(
scope: .series(item.id),
title: "languages.subtitlesForThisSeries",
kind: .subtitles,
available: sprachen?.subtitles
)
// **Was fehlt, wird gesagt.** Eine gekürzte Liste
// sieht sonst aus wie die ganze Wahrheit, und wer
// eine Sprache vermisst, die er in Staffel 1 gesehen
// hat, hält es für einen Fehler.
if let partial = sprachen?.partial, partial > 0 {
Text("languages.partial \(partial)")
.font(.flaroCaption)
.foregroundStyle(Color.flaroTextMuted)
}
}
.padding(.horizontal, FlaroSpacing.screenMargin) .padding(.horizontal, FlaroSpacing.screenMargin)
.task(id: item.id) {
sprachen = await session.backend?.availableLanguages(inSeries: item.id)
}
} }
childList childList
@@ -172,23 +207,33 @@ struct SeriesDetailView: View {
.padding(.horizontal, FlaroSpacing.screenMargin) .padding(.horizontal, FlaroSpacing.screenMargin)
case .loaded(let entries): case .loaded(let entries):
let nummern = staffelnummern(in: entries)
let sichtbar = sichtbareFolgen(in: entries, staffeln: nummern)
VStack(alignment: .leading, spacing: FlaroSpacing.regular) { VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
// **Der Auswählen-Knopf steht bei dem, was er auswählt.** // **Der Auswählen-Knopf steht bei dem, was er auswählt.**
// Oben in der Werkzeugleiste wäre er weiter weg von der Liste // Oben in der Werkzeugleiste wäre er weiter weg von der Liste
// als von allem anderen auf dieser Seite. // als von allem anderen auf dieser Seite.
HStack { HStack {
Text(item.kind == .show ? "detail.seasons" : "detail.episodes") if nummern.count > 1 {
.font(.flaroRowHeader) staffelwahl(nummern)
.foregroundStyle(Color.flaroTextPrimary) } else {
Text(item.kind == .show ? "detail.seasons" : "detail.episodes")
.font(.flaroRowHeader)
.foregroundStyle(Color.flaroTextPrimary)
}
Spacer() Spacer()
if entries.contains(where: { $0.kind == .episode }) { if sichtbar.contains(where: { $0.kind == .episode }) {
selectionControls(for: entries) // **Nur die gezeigte Staffel.** „Alle auswählen" soll
// das meinen, was dasteht — sonst lädt ein Griff
// sechzehn Folgen herunter statt acht.
selectionControls(for: sichtbar)
} }
} }
.padding(.horizontal, FlaroSpacing.screenMargin) .padding(.horizontal, FlaroSpacing.screenMargin)
LazyVStack(spacing: 0) { LazyVStack(spacing: 0) {
ForEach(entries) { entry in ForEach(sichtbar) { entry in
row(for: entry) row(for: entry)
Divider().overlay(Color.flaroSeparator) Divider().overlay(Color.flaroSeparator)
} }
@@ -197,6 +242,55 @@ struct SeriesDetailView: View {
} }
} }
/// Welche Staffeln in dieser Liste vorkommen.
///
/// Leer, wenn die Einträge selbst Staffeln sind — dann gibt es nichts zu
/// wählen, die Liste **ist** die Wahl.
private func staffelnummern(in entries: [MediaItem]) -> [Int] {
Set(entries.compactMap { $0.kind == .episode ? $0.parentIndex : nil }).sorted()
}
private func sichtbareFolgen(in entries: [MediaItem], staffeln: [Int]) -> [MediaItem] {
guard staffeln.count > 1 else { return entries }
let gewaehlt = gewaehlteStaffel ?? staffeln[0]
return entries.filter { $0.kind != .episode || $0.parentIndex == gewaehlt }
}
/// Die Staffel als Menü — an der Stelle, an der sonst „Folgen" steht.
///
/// **Kein `Picker`.** Diese Seite ist eine `ScrollView`, kein `Form`;
/// dort hat ein `Picker` kein Aussehen, auf das man sich verlassen kann.
/// Dieselbe Begründung wie bei `AudioLanguagePicker`.
private func staffelwahl(_ nummern: [Int]) -> some View {
let gewaehlt = gewaehlteStaffel ?? nummern[0]
return Menu {
ForEach(nummern, id: \.self) { nummer in
Button {
gewaehlteStaffel = nummer
// Eine Auswahl aus der vorigen Staffel meint hier nichts
// mehr — stehen zu lassen, was man nicht mehr sieht,
// lädt unsichtbare Folgen herunter.
selection.removeAll()
} label: {
Label(
String(localized: "season.short \(nummer)"),
systemImage: nummer == gewaehlt ? "checkmark" : ""
)
}
}
} label: {
HStack(spacing: FlaroSpacing.tight) {
Text("season.short \(gewaehlt)")
.font(.flaroRowHeader)
.foregroundStyle(Color.flaroTextPrimary)
Image(systemName: "chevron.up.chevron.down")
.font(.flaroCaption)
.foregroundStyle(accent)
}
}
}
/// Eine Zeile — als Weg zur Folge oder als Kreuz zum Ankreuzen. /// Eine Zeile — als Weg zur Folge oder als Kreuz zum Ankreuzen.
@ViewBuilder @ViewBuilder
private func row(for entry: MediaItem) -> some View { private func row(for entry: MediaItem) -> some View {
@@ -376,11 +470,31 @@ struct SeriesDetailView: View {
return pieces.isEmpty ? nil : pieces.joined(separator: " · ") return pieces.isEmpty ? nil : pieces.joined(separator: " · ")
} }
/// Holt die Staffeln oder Folgen — und sonst, was auf dem Gerät liegt.
///
/// **Sonst wäre die Seite einer heruntergeladenen Serie leer.** Sie ist
/// das Ziel, auf das die Downloadreihe zeigt; dort anzukommen und einen
/// Fehler zu lesen, während die Folgen daneben auf der Platte liegen,
/// wäre die Umkehrung dessen, wofür man sie geladen hat.
private func loadChildren() async { private func loadChildren() async {
guard let server = session.backend else { return } guard let server = session.backend else {
children = vomGeraet.isEmpty
? .failed(message: String(localized: "error.serverUnreachable"))
: .loaded(vomGeraet)
return
}
children = await LoadState.load { children = await LoadState.load {
try await server.children(of: item.id) try await server.children(of: item.id)
} }
if case .failed = children, !vomGeraet.isEmpty {
children = .loaded(vomGeraet)
}
}
/// Die Folgen dieser Serie, die auf dem Gerät liegen.
private var vomGeraet: [MediaItem] {
guard item.kind == .show else { return [] }
return Heruntergeladenes.folgen(derSerie: item.id, in: downloads)
} }
} }
@@ -403,7 +517,7 @@ private struct ChildRow: View {
.frame(width: item.kind == .season ? 48 : 96) .frame(width: item.kind == .season ? 48 : 96)
.clipShape(.rect(cornerRadius: 4)) .clipShape(.rect(cornerRadius: 4))
.overlay(alignment: .bottom) { .overlay(alignment: .bottom) {
if let progress = item.watchProgress { if let progress = item.resumeProgress {
WatchProgressBar(fraction: progress) WatchProgressBar(fraction: progress)
} }
} }
Flaro/Views/Home/HeroSection.swift
+22 -15
View File
@@ -47,21 +47,28 @@ struct HeroSection: View {
// Bildschirm leer. // Bildschirm leer.
fillsAvailableSpace: sizeClass != .compact fillsAvailableSpace: sizeClass != .compact
) { ) {
Button { // Geplant heisst sichtbar, nicht abspielbar — statt des Knopfes
// **Über QuickPlay, nicht unmittelbar.** Steht im Aufmacher // der Termin.
// eine Serie — und Jellyfins „Zuletzt hinzugefügt" liefert if item.isUpcoming, let ab = item.availableFrom {
// neue Folgen als ihre Serie —, schickte der direkte Weg UpcomingNotice(date: ab)
// deren eigene Kennung an den Player, und der scheiterte mit } else {
// „keine abspielbare Datei". Eine Serie hat keine Fassungen. Button {
quickPlay.start(item, backend: session.backend, coordinator: playback) // **Über QuickPlay, nicht unmittelbar.** Steht im
} label: { // Aufmacher eine Serie — und Jellyfins „Zuletzt
Label(playLabel, systemImage: "play.fill") // hinzugefügt" liefert neue Folgen als ihre Serie —,
.font(.flaroCardTitle) // schickte der direkte Weg deren eigene Kennung an den
.padding(.horizontal, FlaroSpacing.loose) // Player, und der scheiterte mit „keine abspielbare
.padding(.vertical, FlaroSpacing.snug) // Datei". Eine Serie hat keine Fassungen.
quickPlay.start(item, backend: session.backend, coordinator: playback)
} label: {
Label(playLabel, systemImage: "play.fill")
.font(.flaroCardTitle)
.padding(.horizontal, FlaroSpacing.loose)
.padding(.vertical, FlaroSpacing.snug)
}
.buttonStyle(.borderedProminent)
.tint(accent)
} }
.buttonStyle(.borderedProminent)
.tint(accent)
NavigationLink(value: MediaRoute(ratingKey: item.id, title: item.title)) { NavigationLink(value: MediaRoute(ratingKey: item.id, title: item.title)) {
Label("hero.details", systemImage: "info.circle") Label("hero.details", systemImage: "info.circle")
@@ -77,7 +84,7 @@ struct HeroSection: View {
/// „Weiterschauen" statt „Abspielen", wenn schon etwas gesehen wurde — /// „Weiterschauen" statt „Abspielen", wenn schon etwas gesehen wurde —
/// sonst wäre nicht erkennbar, dass der Film an der alten Stelle weitergeht. /// sonst wäre nicht erkennbar, dass der Film an der alten Stelle weitergeht.
private var playLabel: LocalizedStringKey { private var playLabel: LocalizedStringKey {
item.watchProgress == nil ? "hero.play" : "hero.resume" item.isResumable ? "hero.resume" : "hero.play"
} }
private var metadata: String? { Self.metadata(for: item) } private var metadata: String? { Self.metadata(for: item) }
Flaro/Views/Home/HomeView.swift
+75 -7
View File
@@ -1,5 +1,6 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroDownloads
import MediaKit import MediaKit
/// Die Startseite: Aufmacher oben, darunter die Reihen vom Server. /// Die Startseite: Aufmacher oben, darunter die Reihen vom Server.
@@ -11,15 +12,26 @@ import MediaKit
struct HomeView: View { struct HomeView: View {
@Environment(FlaroSession.self) private var session @Environment(FlaroSession.self) private var session
@Environment(HomeLayoutSettings.self) private var layout @Environment(HomeLayoutSettings.self) private var layout
@Environment(DownloadCoordinator.self) private var downloads
@Environment(Fortschrittspost.self) private var post
@State private var feed = HomeFeed() @State private var feed = HomeFeed()
/// Was auf dem Gerät liegt, als Reihe ganz oben.
///
/// Wird bei jeder Änderung an den Downloads neu berechnet, weil
/// `DownloadCoordinator` beobachtet wird — eine fertige Folge steht
/// ohne Neuladen der Startseite da.
private var heruntergeladen: [MediaItem] {
Heruntergeladenes.reihe(in: downloads)
}
var body: some View { var body: some View {
Group { Group {
switch feed.state { switch feed.state {
case .loading: case .loading:
ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity) ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
case .failed(let message): case .failed(let message) where heruntergeladen.isEmpty:
ContentUnavailableView { ContentUnavailableView {
Label("error.title", systemImage: "exclamationmark.triangle") Label("error.title", systemImage: "exclamationmark.triangle")
} description: { } description: {
@@ -28,8 +40,12 @@ struct HomeView: View {
Button("action.retry") { Task { await feed.load(from: session.backend) } } Button("action.retry") { Task { await feed.load(from: session.backend) } }
} }
case .loaded: // **Mit Downloads ist „kein Server" kein Fehlerbildschirm.**
let hubs = feed.rows(for: layout) // Was auf dem Gerät liegt, lässt sich auch ohne ihn ansehen —
// genau dafür wurde es heruntergeladen. Ein Fehlerbild davor zu
// stellen hiesse, dem Nutzer etwas wegzunehmen, das er hat.
case .failed, .loaded:
let hubs = feed.rows(for: layout, downloaded: heruntergeladen)
if hubs.isEmpty { if hubs.isEmpty {
ContentUnavailableView { ContentUnavailableView {
Label("home.empty.title", systemImage: "film.stack") Label("home.empty.title", systemImage: "film.stack")
@@ -59,7 +75,18 @@ struct HomeView: View {
// daneben, und genau diese Kante sah man. Auf den geschobenen // daneben, und genau diese Kante sah man. Auf den geschobenen
// Bildschirmen bleibt sie, dort trägt sie den Zurück-Weg. // Bildschirmen bleibt sie, dort trägt sie den Zurück-Weg.
.toolbar(.hidden, for: .navigationBar) .toolbar(.hidden, for: .navigationBar)
.task(id: session.serverName) { await feed.load(from: session.backend) } .task(id: session.serverName) {
await feed.load(from: session.backend)
// Siehe `DownloadService.plakateNachholen`: ältere Downloads
// haben kein Bild, und hier ist die Stelle, an der man es merken
// würde.
await DownloadService(backend: session.backend, coordinator: downloads)
.plakateNachholen()
// **Der Server hat geantwortet — dann nimmt er auch Post an.**
// Der Start der App ist dafür der falsche Zeitpunkt: da ist oft
// noch gar keine Verbindung.
if !feed.ausDemSpeicher { await post.zustellen(über: session.backend) }
}
.refreshable { await feed.load(from: session.backend) } .refreshable { await feed.load(from: session.backend) }
// Was eine Kachel am Server ändert, ändert auch, was hier steht: // Was eine Kachel am Server ändert, ändert auch, was hier steht:
// eine abgehakte Folge gehört nicht mehr in „Weiterschauen". // eine abgehakte Folge gehört nicht mehr in „Weiterschauen".
@@ -69,13 +96,22 @@ struct HomeView: View {
private func content(hubs: [MediaRowGroup]) -> some View { private func content(hubs: [MediaRowGroup]) -> some View {
ScrollView { ScrollView {
LazyVStack(alignment: .leading, spacing: FlaroSpacing.section) { LazyVStack(alignment: .leading, spacing: FlaroSpacing.section) {
let featured = feed.heroItems(for: layout) if ohneServer {
if !featured.isEmpty { offlinehinweis
HeroCarousel(items: featured) } else {
let featured = feed.heroItems(for: layout)
if !featured.isEmpty {
HeroCarousel(items: featured)
}
} }
ForEach(hubs) { hub in ForEach(hubs) { hub in
MediaRow(row: hub) MediaRow(row: hub)
// **Ausgegraut, aber nicht gesperrt.** Was hier steht,
// stammt vom letzten Mal; antippen darf man es
// trotzdem — dann kommt ein Satz, der sagt warum, und
// das ist ehrlicher als ein Knopf, der nichts tut.
.opacity(ohneServer && hub.id != HomeFeed.downloadsRow ? 0.4 : 1)
} }
} }
.padding(.bottom, FlaroSpacing.section) .padding(.bottom, FlaroSpacing.section)
@@ -83,4 +119,36 @@ struct HomeView: View {
.scrollIndicators(.never) .scrollIndicators(.never)
.flaroRevealsTopChrome() .flaroRevealsTopChrome()
} }
/// Ob gerade kein Server antwortet.
///
/// Zwei Wege führen hierher: gar nichts geladen, oder ein Abzug vom
/// letzten Mal. Für den Nutzer ist es dieselbe Lage.
private var ohneServer: Bool {
if case .failed = feed.state { return true }
return feed.ausDemSpeicher
}
/// Statt des Aufmachers, wenn der Server fehlt.
///
/// **An seiner Stelle, nicht darüber.** Ein grosses Bild vom letzten Mal
/// über einer Startseite, die nicht stimmt, wäre die falsche Betonung —
/// und die Downloads sollen oben stehen.
private var offlinehinweis: some View {
HStack(alignment: .firstTextBaseline, spacing: FlaroSpacing.regular) {
Image(systemName: "wifi.slash")
.foregroundStyle(Color.flaroTextMuted)
Text("home.offline")
.font(.flaroCaption)
.foregroundStyle(Color.flaroTextMuted)
.fixedSize(horizontal: false, vertical: true)
Spacer(minLength: 0)
Button("action.retry") { Task { await feed.load(from: session.backend) } }
.buttonStyle(.bordered)
.controlSize(.small)
}
.padding(FlaroSpacing.regular)
.background(Color.flaroElevated, in: .rect(cornerRadius: 12))
.padding(.horizontal, FlaroSpacing.screenMargin)
}
} }
Flaro/Views/Home/MediaRow.swift
+28 -9
View File
@@ -1,16 +1,21 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroDownloads
import MediaKit import MediaKit
/// Eine waagerechte Reihe von Titeln. /// Eine waagerechte Reihe von Titeln.
struct MediaRow: View { struct MediaRow: View {
let row: MediaRowGroup let row: MediaRowGroup
/// Wird durchgereicht — siehe `QuickPlayTile`. /// Ob ein Tipp sofort abspielt — siehe `QuickPlayTile`.
var opensDetails: Bool = false ///
/// **Die Reihe weiss es, nicht die Kachel.** „Weiterschauen" ist eine
/// Eigenschaft der Reihe; eine Kachel kennt nur ihren Titel.
private var startsPlayback: Bool { row.isContinueWatching }
@Environment(FlaroSession.self) private var session @Environment(FlaroSession.self) private var session
@Environment(HomeLayoutSettings.self) private var layout @Environment(HomeLayoutSettings.self) private var layout
@Environment(DownloadCoordinator.self) private var downloads
/// Breit genug, dass die übernächste Kachel angeschnitten ist — das zeigt, /// Breit genug, dass die übernächste Kachel angeschnitten ist — das zeigt,
/// dass es weitergeht, ohne einen Pfeil dafür zu brauchen. /// dass es weitergeht, ohne einen Pfeil dafür zu brauchen.
@@ -32,7 +37,7 @@ struct MediaRow: View {
ScrollView(.horizontal) { ScrollView(.horizontal) {
LazyHStack(spacing: FlaroSpacing.regular) { LazyHStack(spacing: FlaroSpacing.regular) {
ForEach(row.items) { item in ForEach(row.items) { item in
QuickPlayTile(item: item, opensDetails: opensDetails) { card(for: item) } QuickPlayTile(item: item, startsPlayback: startsPlayback) { card(for: item) }
} }
} }
.padding(.horizontal, FlaroSpacing.screenMargin) .padding(.horizontal, FlaroSpacing.screenMargin)
@@ -55,27 +60,41 @@ struct MediaRow: View {
if row.isContinueWatching { if row.isContinueWatching {
LandscapeCard( LandscapeCard(
title: item.rowTitle, title: item.rowTitle,
subtitle: item.cardSubtitle, subtitle: untertitel(for: item),
artworkURL: session.backend?.artworkURL( artworkURL: Heruntergeladenes.bildAdresse(item) ?? session.backend?.artworkURL(
path: item.rowArtworkPath, path: item.rowArtworkPath,
width: 440, width: 440,
height: 248 height: 248
), ),
progress: item.watchProgress progress: item.resumeProgress
) )
.frame(width: landscapeWidth) .frame(width: landscapeWidth)
} else { } else {
PosterCard( PosterCard(
title: item.rowTitle, title: item.rowTitle,
subtitle: item.cardSubtitle, subtitle: untertitel(for: item),
artworkURL: session.backend?.artworkURL( artworkURL: Heruntergeladenes.bildAdresse(item) ?? session.backend?.artworkURL(
path: item.posterArtworkPath, path: item.posterArtworkPath,
width: 300, width: 300,
height: 450 height: 450
), ),
progress: item.watchProgress progress: item.resumeProgress
) )
.frame(width: posterWidth) .frame(width: posterWidth)
} }
} }
/// Was unter der Kachel steht.
///
/// **In der Downloadreihe zählt, wie viel da ist.** Eine Serie steht
/// dort als eine Kachel; „2019" darunter beantwortet nicht die Frage,
/// die man an dieser Stelle hat — nämlich wie viele Folgen man dabei
/// hat.
private func untertitel(for item: MediaItem) -> String? {
if row.id == HomeFeed.downloadsRow,
let zahl = Heruntergeladenes.untertitel(für: item, in: downloads) {
return zahl
}
return item.cardSubtitle
}
} }
Flaro/Views/Library/LibraryFilterSheet.swift
+15 -2
View File
@@ -5,6 +5,9 @@ import MediaKit
/// Filter und Sortierung einer Mediathek. /// Filter und Sortierung einer Mediathek.
struct LibraryFilterSheet: View { struct LibraryFilterSheet: View {
@Binding var query: MediaQuery @Binding var query: MediaQuery
/// Steht getrennt von `query`, weil der Server ihn nicht auswerten kann —
/// siehe `LibraryView.nurHeruntergeladene`.
@Binding var nurHeruntergeladene: Bool
/// Die Mediathek selbst, nicht nur ihre Art. /// Die Mediathek selbst, nicht nur ihre Art.
/// ///
/// Vorher stand hier die Art, und die Genres wurden über *irgendeine* /// Vorher stand hier die Art, und die Genres wurden über *irgendeine*
@@ -23,11 +26,18 @@ struct LibraryFilterSheet: View {
/// Sonst löste jeder Tipp im Sheet sofort eine neue Serverabfrage aus — /// Sonst löste jeder Tipp im Sheet sofort eine neue Serverabfrage aus —
/// bei drei Änderungen hintereinander drei verworfene Ladevorgänge. /// bei drei Änderungen hintereinander drei verworfene Ladevorgänge.
@State private var draft: MediaQuery @State private var draft: MediaQuery
@State private var entwurfHeruntergeladene: Bool
init(query: Binding<MediaQuery>, library: MediaLibrary) { init(
query: Binding<MediaQuery>,
nurHeruntergeladene: Binding<Bool>,
library: MediaLibrary
) {
self._query = query self._query = query
self._nurHeruntergeladene = nurHeruntergeladene
self.library = library self.library = library
self._draft = State(initialValue: query.wrappedValue) self._draft = State(initialValue: query.wrappedValue)
self._entwurfHeruntergeladene = State(initialValue: nurHeruntergeladene.wrappedValue)
} }
var body: some View { var body: some View {
@@ -45,6 +55,7 @@ struct LibraryFilterSheet: View {
Section("filter.filters") { Section("filter.filters") {
Toggle("filter.unwatchedOnly", isOn: $draft.unwatchedOnly) Toggle("filter.unwatchedOnly", isOn: $draft.unwatchedOnly)
Toggle("filter.downloadedOnly", isOn: $entwurfHeruntergeladene)
Picker("filter.genre", selection: $draft.genre) { Picker("filter.genre", selection: $draft.genre) {
Text("filter.any").tag(String?.none) Text("filter.any").tag(String?.none)
@@ -80,8 +91,9 @@ struct LibraryFilterSheet: View {
Section { Section {
Button("filter.reset", role: .destructive) { Button("filter.reset", role: .destructive) {
draft = MediaQuery(sort: draft.sort) draft = MediaQuery(sort: draft.sort)
entwurfHeruntergeladene = false
} }
.disabled(!draft.isFiltering) .disabled(!draft.isFiltering && !entwurfHeruntergeladene)
} }
} }
// Ausdrücklich, nicht nur geerbt. // Ausdrücklich, nicht nur geerbt.
@@ -102,6 +114,7 @@ struct LibraryFilterSheet: View {
} }
ToolbarItem(placement: .confirmationAction) { ToolbarItem(placement: .confirmationAction) {
Button("action.apply") { Button("action.apply") {
nurHeruntergeladene = entwurfHeruntergeladene
query = draft query = draft
dismiss() dismiss()
} }
Flaro/Views/Library/LibraryView.swift
+61 -7
View File
@@ -1,5 +1,6 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroDownloads
import MediaKit import MediaKit
/// Eine Mediathek zum Durchblättern. /// Eine Mediathek zum Durchblättern.
@@ -10,6 +11,7 @@ struct LibraryView: View {
/// Nur für die Kachelgröße. „layout“ heißt hier schon die Wahl /// Nur für die Kachelgröße. „layout“ heißt hier schon die Wahl
/// zwischen Raster und Liste. /// zwischen Raster und Liste.
@Environment(HomeLayoutSettings.self) private var sizing @Environment(HomeLayoutSettings.self) private var sizing
@Environment(DownloadCoordinator.self) private var downloads
@AppStorage("flaro.library.layout") private var layout: LibraryLayout = .grid @AppStorage("flaro.library.layout") private var layout: LibraryLayout = .grid
@Environment(\.horizontalSizeClass) private var sizeClass @Environment(\.horizontalSizeClass) private var sizeClass
@@ -25,6 +27,14 @@ struct LibraryView: View {
@State private var loadMoreFailed = false @State private var loadMoreFailed = false
@State private var isLoadingMore = false @State private var isLoadingMore = false
@State private var showsFilters = false @State private var showsFilters = false
/// Ob nur gezeigt wird, was auf diesem Gerät liegt.
///
/// **Kein Teil von `MediaQuery`**, und das ist der Kern der Sache: die
/// Abfrage wertet der Server aus, und der weiss nicht, was auf diesem
/// Gerät liegt. Steht der Filter an, wird gar nicht erst gefragt — die
/// Liste kommt aus den Downloads. Das ist genau, vollständig, und
/// funktioniert ohne Verbindung.
@State private var nurHeruntergeladene = false
var body: some View { var body: some View {
Group { Group {
@@ -48,8 +58,9 @@ struct LibraryView: View {
} description: { } description: {
Text("library.empty.description") Text("library.empty.description")
} actions: { } actions: {
if query.isFiltering { if query.isFiltering || nurHeruntergeladene {
Button("library.clearFilters") { Button("library.clearFilters") {
nurHeruntergeladene = false
query = MediaQuery(sort: query.sort) query = MediaQuery(sort: query.sort)
} }
} }
@@ -64,7 +75,11 @@ struct LibraryView: View {
.flaroInlineTitle() .flaroInlineTitle()
.toolbar { toolbar } .toolbar { toolbar }
.sheet(isPresented: $showsFilters) { .sheet(isPresented: $showsFilters) {
LibraryFilterSheet(query: $query, library: library) LibraryFilterSheet(
query: $query,
nurHeruntergeladene: $nurHeruntergeladene,
library: library
)
} }
.task(id: library.id) { .task(id: library.id) {
// Beim Wechsel auf eine andere Mediathek zuerst leeren: sonst hält // Beim Wechsel auf eine andere Mediathek zuerst leeren: sonst hält
@@ -78,6 +93,11 @@ struct LibraryView: View {
// Liste — Nachladen mit altem Versatz würde sonst Einträge aus zwei // Liste — Nachladen mit altem Versatz würde sonst Einträge aus zwei
// verschiedenen Abfragen vermischen. // verschiedenen Abfragen vermischen.
.onChange(of: query) { _, _ in Task { await reload() } } .onChange(of: query) { _, _ in Task { await reload() } }
.onChange(of: nurHeruntergeladene) { _, _ in
items = []
page = nil
Task { await reload() }
}
.refreshable { await reload() } .refreshable { await reload() }
// Siehe `HomeView`: was eine Kachel ändert, muss im Raster ankommen. // Siehe `HomeView`: was eine Kachel ändert, muss im Raster ankommen.
.environment(\.flaroItemChanged, { await reload() }) .environment(\.flaroItemChanged, { await reload() })
@@ -104,9 +124,13 @@ struct LibraryView: View {
QuickPlayTile(item: item) { QuickPlayTile(item: item) {
PosterCard( PosterCard(
title: item.title, title: item.title,
subtitle: item.cardSubtitle, subtitle: nurHeruntergeladene
artworkURL: session.backend?.artworkURL(path: item.thumb, width: 300, height: 450), ? Heruntergeladenes.untertitel(für: item, in: downloads)
progress: item.watchProgress ?? item.cardSubtitle
: item.cardSubtitle,
artworkURL: Heruntergeladenes.bildAdresse(item)
?? session.backend?.artworkURL(path: item.thumb, width: 300, height: 450),
progress: item.resumeProgress
) )
} }
.task { await loadMoreIfNeeded(reaching: item) } .task { await loadMoreIfNeeded(reaching: item) }
@@ -232,7 +256,7 @@ struct LibraryView: View {
Button { Button {
showsFilters = true showsFilters = true
} label: { } label: {
Image(systemName: query.isFiltering Image(systemName: query.isFiltering || nurHeruntergeladene
? "line.3.horizontal.decrease.circle.fill" ? "line.3.horizontal.decrease.circle.fill"
: "line.3.horizontal.decrease.circle") : "line.3.horizontal.decrease.circle")
} }
@@ -276,6 +300,16 @@ struct LibraryView: View {
/// stehen. Eine Liste von gestern ist im Zug brauchbarer als ein /// stehen. Eine Liste von gestern ist im Zug brauchbarer als ein
/// Fehlerbildschirm. /// Fehlerbildschirm.
private func reload() async { private func reload() async {
// **Vor dem Server, nicht danach.** Was auf dem Gerät liegt, weiss
// nur das Gerät — und es weiss es auch im Flugmodus.
if nurHeruntergeladene {
items = geraeteliste
page = MediaPage(items: items, totalCount: items.count)
loadMoreFailed = false
state = .loaded(())
return
}
guard let server = session.backend else { return } guard let server = session.backend else { return }
let schlüssel = query.cacheKey let schlüssel = query.cacheKey
let kennung = server.identity let kennung = server.identity
@@ -319,6 +353,25 @@ struct LibraryView: View {
} }
} }
/// Die Downloads, die in diese Mediathek gehören.
///
/// **Zugeordnet über die Art der Mediathek**, weil ein Download seine
/// Mediathek nicht kennt: er führt einen Serienschlüssel oder keinen,
/// und mehr braucht es nicht. Eine Folge gehört in eine Serien-,
/// ein Film in eine Filmmediathek.
///
/// shortcut: zwei Filmmediatheken bekämen beide dieselbe Liste — erst
/// wenn `DownloadItem` die Mediathek mitführt, lässt sich das trennen.
private var geraeteliste: [MediaItem] {
Heruntergeladenes.reihe(in: downloads).filter { titel in
switch library.kind {
case .movie: titel.kind != .show
case .show: titel.kind == .show
default: true
}
}
}
/// Lädt nach, sobald die Ansicht sich dem Ende der Liste nähert. /// Lädt nach, sobald die Ansicht sich dem Ende der Liste nähert.
private func loadMoreIfNeeded(reaching item: MediaItem) async { private func loadMoreIfNeeded(reaching item: MediaItem) async {
guard guard
@@ -385,7 +438,8 @@ private struct LibraryListRow: View {
var body: some View { var body: some View {
HStack(spacing: FlaroSpacing.regular) { HStack(spacing: FlaroSpacing.regular) {
FlaroArtwork( FlaroArtwork(
url: session.backend?.artworkURL(path: item.thumb, width: 120, height: 180), url: Heruntergeladenes.bildAdresse(item)
?? session.backend?.artworkURL(path: item.thumb, width: 120, height: 180),
aspectRatio: PosterCard.aspectRatio aspectRatio: PosterCard.aspectRatio
) )
.frame(width: 44) .frame(width: 44)
Flaro/Views/Navigation/AccountAvatar.swift
+33 -12
View File
@@ -1,24 +1,46 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
/// Der erste Buchstabe auf einer Scheibe. /// Das eigene Bild auf einer Scheibe — oder der erste Buchstabe.
/// ///
/// **Kein Platzhalterbild.** Jellyfin gibt kein Profilbild heraus, ohne dass /// **Der Buchstabe ist keine Notlösung.** Jellyfin gibt kein Profilbild
/// eines hinterlegt ist, und am Konto führt die App heute keines mit. Ein /// heraus, und auch an einem Flaro-Konto muss keines hängen. Ein Buchstabe
/// Buchstabe ist ehrlicher als eine graue Silhouette, die bei jedem gleich /// ist ehrlicher als eine graue Silhouette, die bei jedem gleich aussieht —
/// aussieht — und man erkennt an ihm wenigstens, mit welchem Konto man /// und man erkennt an ihm wenigstens, mit welchem Konto man angemeldet ist.
/// angemeldet ist.
/// ///
/// Stand bis eben in `AccountBar` und wird jetzt zweimal gebraucht: dort in /// Steht ein Bild im Konto, tritt es an seine Stelle. Lädt es nicht, kommt
/// der Seitenleiste und auf dem iPhone oben rechts, wo seit dem Wegfall des /// der Buchstabe zurück: eine leere Scheibe sagt weniger als ein P.
/// Einstellungen-Tabs der Weg dorthin liegt. ///
/// Stand einmal in `AccountBar` und wird inzwischen dreimal gebraucht: dort in
/// der Seitenleiste, auf dem iPhone oben rechts und in der Werkzeugleiste.
struct AccountAvatar: View { struct AccountAvatar: View {
let name: String let name: String
var diameter: CGFloat = 26 var diameter: CGFloat = 26
/// Das Bild des Kontos, falls eines hinterlegt ist.
var image: URL?
@Environment(\.flaroAccent) private var accent @Environment(\.flaroAccent) private var accent
var body: some View { var body: some View {
buchstabe
.frame(width: diameter, height: diameter)
.background(accent, in: .circle)
.overlay {
if let image {
AsyncImage(url: image) { bild in
bild.resizable().scaledToFill()
} placeholder: {
// Nichts: darunter liegt der Buchstabe und füllt die
// Lücke, bis das Bild da ist.
Color.clear
}
.frame(width: diameter, height: diameter)
.clipShape(.circle)
}
}
}
private var buchstabe: some View {
Text(name.prefix(1).uppercased()) Text(name.prefix(1).uppercased())
// Mit der Scheibe wachsen, nicht fest: oben rechts auf dem // Mit der Scheibe wachsen, nicht fest: oben rechts auf dem
// Telefon ist er grösser als in der Leiste, und ein Buchstabe in // Telefon ist er grösser als in der Leiste, und ein Buchstabe in
@@ -26,8 +48,6 @@ struct AccountAvatar: View {
// Fehler. // Fehler.
.font(.system(size: diameter * 0.46, weight: .semibold)) .font(.system(size: diameter * 0.46, weight: .semibold))
.foregroundStyle(Color.flaroCanvas) .foregroundStyle(Color.flaroCanvas)
.frame(width: diameter, height: diameter)
.background(accent, in: .circle)
} }
} }
@@ -53,7 +73,8 @@ struct AccountToolbarButton: View {
var body: some View { var body: some View {
Button(action: openSettings) { Button(action: openSettings) {
AccountAvatar(name: session.accountName ?? session.serverName, diameter: 34) AccountAvatar(name: session.accountName ?? session.serverName, diameter: 34,
image: session.accountAvatarURL)
} }
.buttonStyle(.plain) .buttonStyle(.plain)
.accessibilityLabel(Text("sidebar.settings")) .accessibilityLabel(Text("sidebar.settings"))
Flaro/Views/Navigation/AccountBar.swift
+1 -1
View File
@@ -78,7 +78,7 @@ struct AccountBar: View {
isExpanded.toggle() isExpanded.toggle()
} label: { } label: {
HStack(spacing: FlaroSpacing.snug) { HStack(spacing: FlaroSpacing.snug) {
AccountAvatar(name: title) AccountAvatar(name: title, image: session.accountAvatarURL)
VStack(alignment: .leading, spacing: 0) { VStack(alignment: .leading, spacing: 0) {
Text(title) Text(title)
Flaro/Views/Navigation/RootView.swift
+4 -1
View File
@@ -19,6 +19,7 @@ struct RootView: View {
@Environment(SubtitleAppearance.self) private var subtitleAppearance @Environment(SubtitleAppearance.self) private var subtitleAppearance
@Environment(NetworkConditions.self) private var network @Environment(NetworkConditions.self) private var network
@Environment(DownloadCoordinator.self) private var downloads @Environment(DownloadCoordinator.self) private var downloads
@Environment(Fortschrittspost.self) private var post
@Environment(PlaybackDiagnostics.self) private var diagnostics @Environment(PlaybackDiagnostics.self) private var diagnostics
/// Der laufende Player — hier gehalten, weil diese Ansicht immer da ist. /// Der laufende Player — hier gehalten, weil diese Ansicht immer da ist.
@@ -229,6 +230,7 @@ struct RootView: View {
backend: session.backend, backend: session.backend,
liveTV: session.liveTV, liveTV: session.liveTV,
downloads: downloads, downloads: downloads,
post: post,
diagnostics: diagnostics, diagnostics: diagnostics,
policy: settings.policy(for: network), policy: settings.policy(for: network),
settings: settings, settings: settings,
@@ -514,7 +516,8 @@ struct RootView: View {
Button { Button {
showsSettings = true showsSettings = true
} label: { } label: {
AccountAvatar(name: session.accountName ?? session.serverName, diameter: 34) AccountAvatar(name: session.accountName ?? session.serverName, diameter: 34,
image: session.accountAvatarURL)
.padding(FlaroSpacing.snug) .padding(FlaroSpacing.snug)
// Damit er auch über einem hellen Aufmacher steht. // Damit er auch über einem hellen Aufmacher steht.
.background(.black.opacity(0.28), in: .circle) .background(.black.opacity(0.28), in: .circle)
Flaro/Views/Player/PlaybackScrubber.swift
+94
View File
@@ -1,5 +1,6 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import MediaKit
/// Der Regler unter dem Film — mit dem, was schon geladen ist. /// Der Regler unter dem Film — mit dem, was schon geladen ist.
/// ///
@@ -34,6 +35,11 @@ struct PlaybackScrubber: View {
/// Bei jeder Berührung — damit die Bedienung stehen bleibt. /// Bei jeder Berührung — damit die Bedienung stehen bleibt.
let onActivity: () -> Void let onActivity: () -> Void
/// Wie die Vorschaubilder liegen — `nil`, solange der Server keine hat.
var vorschau: Vorschauplan?
/// Woher ein Blatt kommt.
var blatt: (Int) -> URL? = { _ in nil }
@Environment(\.flaroAccent) private var accent @Environment(\.flaroAccent) private var accent
private static let trackHeight: CGFloat = 5 private static let trackHeight: CGFloat = 5
@@ -71,6 +77,22 @@ struct PlaybackScrubber: View {
.offset(x: gespielt - Self.thumbSize / 2) .offset(x: gespielt - Self.thumbSize / 2)
.animation(.easeOut(duration: 0.15), value: scrubbing == nil) .animation(.easeOut(duration: 0.15), value: scrubbing == nil)
} }
// **Die Vorschau steht über dem Griff, nicht darunter.** Unter
// dem Finger verdeckte sie genau die Stelle, die man sucht.
.overlay(alignment: .bottomLeading) {
if let plan = vorschau,
let gezogen = scrubbing,
let stelle = plan.stelle(bei: gezogen) {
Vorschaukachel(plan: plan, stelle: stelle, blatt: blatt)
.offset(
x: min(
breite - plan.kachelBreite,
max(0, gespielt - plan.kachelBreite / 2)),
y: -Self.hitHeight / 2 - 8)
.allowsHitTesting(false)
.transition(.opacity)
}
}
.frame(height: Self.hitHeight) .frame(height: Self.hitHeight)
.contentShape(.rect) .contentShape(.rect)
.gesture( .gesture(
@@ -117,3 +139,75 @@ struct PlaybackScrubber: View {
return min(max(Double(x / width), 0), 1) * duration.seconds return min(max(Double(x / width), 0), 1) * duration.seconds
} }
} }
/// Ein Standbild aus dem Film, ausgeschnitten aus einem Blatt.
///
/// **Ausgeschnitten, nicht einzeln geladen.** Ein Blatt trägt hundert
/// Bilder; beim Ziehen über die Leiste wird nur der Ausschnitt verschoben,
/// und nach dem ersten Blatt kommt kein Abruf mehr. Einzelne Bilder zu
/// holen hiesse, bei jeder Fingerbewegung ins Netz zu greifen.
///
/// **Geladen wird von Hand, nicht über `FlaroArtwork`.** Jenes rechnet mit
/// Seitenverhältnissen und schneidet selbst zu — hier wird ein Blatt
/// gebraucht, das genau so gross dasteht, wie es ist, damit der Versatz
/// auf den Bildpunkt stimmt.
struct Vorschaukachel: View {
let plan: Vorschauplan
let stelle: Vorschauplan.Stelle
/// Woher das Blatt kommt — der Spieler weiss, welche Datei läuft.
let blatt: (Int) -> URL?
@State private var bild: PlatformImage?
var body: some View {
Rechteck
.frame(width: plan.kachelBreite, height: plan.kachelHoehe)
.background(.black)
.clipShape(.rect(cornerRadius: FlaroRadius.card))
.overlay(
RoundedRectangle(cornerRadius: FlaroRadius.card)
.stroke(.white.opacity(0.18), lineWidth: 1))
.shadow(color: .black.opacity(0.6), radius: 10, y: 4)
.task(id: stelle.blatt) { await laden() }
}
@ViewBuilder
private var Rechteck: some View {
if let bild {
// `Image(platform:)` liegt in FlaroDesign und ist paketintern;
// dieselbe Fallunterscheidung, zwei Zeilen.
bildAnsicht(bild)
.resizable()
.frame(
width: plan.kachelBreite * Double(plan.spalten),
height: plan.kachelHoehe * Double(plan.zeilen))
// Der Ausschnitt entsteht durch Verschieben hinter einem
// Rahmen in Kachelgrösse — dieselbe Rechnung wie
// `background-position` im Web.
.offset(
x: -plan.kachelBreite * Double(stelle.spalte),
y: -plan.kachelHoehe * Double(stelle.zeile))
.frame(
width: plan.kachelBreite, height: plan.kachelHoehe,
alignment: .topLeading)
.clipped()
} else {
Color.black
}
}
private func bildAnsicht(_ bild: PlatformImage) -> Image {
#if canImport(UIKit)
Image(uiImage: bild)
#else
Image(nsImage: bild)
#endif
}
private func laden() async {
guard let adresse = blatt(stelle.blatt) else { return }
// Der Lader hält Blätter im Speicher: beim Ziehen über die Leiste
// wird dasselbe Blatt hundertmal gebraucht.
bild = await ArtworkLoader.shared.image(for: adresse)
}
}
Flaro/Views/Player/PlayerModel.swift
+350 -49
View File
@@ -61,9 +61,20 @@ final class PlayerModel {
/// Die Marke, in der wir uns gerade befinden — Grundlage für den /// Die Marke, in der wir uns gerade befinden — Grundlage für den
/// Überspringen-Knopf. /// Überspringen-Knopf.
private(set) var activeMarker: MediaMarker? private(set) var activeMarker: MediaMarker?
/// Wie die Vorschaubilder liegen — `nil`, solange der Server keine hat.
///
/// **Einmal gefragt, bei „noch nicht" einmal nachgefasst.** Die Blätter
/// entstehen beim Abspielen im Hintergrund; nach zehn Sekunden sind sie
/// bei den meisten Dateien da. Weiter zu fragen hiesse, für eine
/// Annehmlichkeit dauernd am Server zu ziehen.
private(set) var vorschau: Vorschauplan?
/// Die nächste Folge, sofern es eine gibt. Wird im Hintergrund geholt, /// Die nächste Folge, sofern es eine gibt. Wird im Hintergrund geholt,
/// damit sie am Ende ohne Wartezeit bereitsteht. /// damit sie am Ende ohne Wartezeit bereitsteht.
private(set) var nextEpisode: MediaItem? private(set) var nextEpisode: MediaItem?
/// Die Folge davor — für den Rückwärtsknopf. `nil` heisst: es ist die
/// erste, oder es ist gar keine Folge.
private(set) var previousEpisode: MediaItem?
private(set) var hasReachedEnd = false private(set) var hasReachedEnd = false
/// Ob aus dem Download-Ordner gespielt wird. Dann gibt es keinen /// Ob aus dem Download-Ordner gespielt wird. Dann gibt es keinen
/// Fortschritt zu melden und keine nächste Folge nachzuschlagen. /// Fortschritt zu melden und keine nächste Folge nachzuschlagen.
@@ -105,6 +116,26 @@ final class PlayerModel {
/// und ausgerechnet da will man zusehen, wie der Vorrat wächst. /// und ausgerechnet da will man zusehen, wie der Vorrat wächst.
private(set) var bufferedUntil: Duration? private(set) var bufferedUntil: Duration?
/// Ab welcher Stelle des Films der laufende Strom beginnt.
///
/// **Null ist der Normalfall.** Dann ist der Strom der ganze Film, und
/// die Uhr des Spielers ist die Uhr des Films.
///
/// **Darüber heisst: der Server hat schon gesprungen.** Flaros
/// Abspielliste wächst von der gewünschten Stelle an vorwärts; was davor
/// liegt, gibt es in diesem Strom nicht. Der Spieler zählt trotzdem ab
/// null — ohne diesen Wert stünde bei „Fortsetzen ab 1:32" eine Null auf
/// der Uhr, und genau die würde auch gemeldet.
private var streamOffset: Duration = .zero
/// Bis wohin der laufende Strom reicht.
///
/// **Nicht dasselbe wie <see cref="duration"/>.** Das ist die Länge des
/// Films; dies ist, was davon in diesem Strom liegt. Bei einer
/// wachsenden Abspielliste wächst es mit. Ein Sprung darüber hinaus
/// braucht einen neuen Strom, keinen Sprung.
private var streamEnd: Duration?
/// Was der eigene Vorratsspeicher gerade tut — in einem Satz. /// Was der eigene Vorratsspeicher gerade tut — in einem Satz.
/// ///
/// **Damit man es ablesen kann statt zu raten.** Ob ein Speicher /// **Damit man es ablesen kann statt zu raten.** Ob ein Speicher
@@ -211,6 +242,9 @@ final class PlayerModel {
/// Protokoll mit Null-Objekt wäre die dritte Möglichkeit und die /// Protokoll mit Null-Objekt wäre die dritte Möglichkeit und die
/// schlechteste: ein Typ mehr, um drei `if let` zu vermeiden. /// schlechteste: ein Typ mehr, um drei `if let` zu vermeiden.
private let downloads: DownloadCoordinator? private let downloads: DownloadCoordinator?
/// Siehe `Fortschrittspost`: was der Server nicht annimmt, wird
/// zurückgelegt und nachgereicht.
private let post: Fortschrittspost?
private let diagnostics: PlaybackDiagnostics private let diagnostics: PlaybackDiagnostics
private let policy: PlaybackPolicy private let policy: PlaybackPolicy
private let settings: PlaybackSettings private let settings: PlaybackSettings
@@ -461,6 +495,8 @@ final class PlayerModel {
backend: (any MediaBackend)?, backend: (any MediaBackend)?,
liveTV: (any LiveTVBackend)?, liveTV: (any LiveTVBackend)?,
downloads: DownloadCoordinator? = nil, downloads: DownloadCoordinator? = nil,
/// Wohin ein Fortschritt kommt, den der Server nicht annimmt.
post: Fortschrittspost? = nil,
diagnostics: PlaybackDiagnostics, diagnostics: PlaybackDiagnostics,
policy: PlaybackPolicy, policy: PlaybackPolicy,
settings: PlaybackSettings, settings: PlaybackSettings,
@@ -474,6 +510,7 @@ final class PlayerModel {
self.backend = backend self.backend = backend
self.liveTV = liveTV self.liveTV = liveTV
self.downloads = downloads self.downloads = downloads
self.post = post
self.diagnostics = diagnostics self.diagnostics = diagnostics
self.policy = policy self.policy = policy
self.settings = settings self.settings = settings
@@ -499,6 +536,18 @@ final class PlayerModel {
// nicht erreichbar ist — der eigentliche Sinn des Herunterladens. // nicht erreichbar ist — der eigentliche Sinn des Herunterladens.
if let downloads, let localURL = downloads.localURL(forRatingKey: request.ratingKey) { if let downloads, let localURL = downloads.localURL(forRatingKey: request.ratingKey) {
await startLocal(url: localURL) await startLocal(url: localURL)
// **Die Angaben trotzdem holen, nur eben hinterher.**
//
// Hier wurde früher schlicht zurückgekehrt — und damit blieb
// `item` leer. Daran hing mehr, als es aussieht: keine Marken,
// also kein „Intro überspringen"; keine nächste Folge, also
// keine Knöpfe zum Blättern. Bei allem, was heruntergeladen
// war, fehlte das, und nur dort — weshalb es so lange aussah
// wie ein Fehler in der Erkennung.
//
// Nebenher und nicht davor: das Bild soll sofort laufen, und
// ohne Verbindung gibt es ohnehin nichts zu holen.
metadatenNachladen()
return return
} }
@@ -557,6 +606,7 @@ final class PlayerModel {
await load(source, decision: decision) await load(source, decision: decision)
preloadNextEpisode() preloadNextEpisode()
vorschauHolen()
} }
/// Stellt auf eine andere Qualitätsstufe um. /// Stellt auf eine andere Qualitätsstufe um.
@@ -718,7 +768,58 @@ final class PlayerModel {
await load(PlaybackSource(url: url, origin: .remote), decision: decision) await load(PlaybackSource(url: url, origin: .remote), decision: decision)
} }
/// Holt Titelangaben nach, während die lokale Datei schon läuft.
///
/// Scheitert es — kein Server, kein Netz —, bleibt es, wie es war: die
/// Datei läuft, es gibt bloss keine Marken und keine Nachbarfolgen.
/// Welche Datei läuft — die Vorschau hängt an ihr, nicht am Titel.
///
/// `MediaVersion.id` ist die Kennung der Mediendatei; eine Fassung
/// besteht aus genau einer.
private var vorschaudatei: String?
/// Holt den Vorschauplan — einmal sofort, einmal nach zehn Sekunden.
private func vorschauHolen() {
guard vorschau == nil, let backend, let item else { return }
guard let datei = version(of: item)?.id else { return }
vorschaudatei = datei
Task { [weak self] in
for warten in [Duration.zero, .seconds(10)] {
if warten > .zero { try? await Task.sleep(for: warten) }
guard let self, self.vorschau == nil else { return }
if let plan = await backend.vorschauplan(fileId: datei) {
self.vorschau = plan
return
}
}
}
}
/// Woher ein Vorschaublatt kommt.
func vorschaublatt(_ nummer: Int) -> URL? {
guard let backend, let datei = vorschaudatei else { return nil }
return backend.vorschaublatt(fileId: datei, blatt: nummer)
}
private func metadatenNachladen() {
guard item == nil, let backend else { return }
Task { [weak self] in
guard let geholt = try? await backend.item(id: self?.request.ratingKey ?? "") else { return }
guard let self, self.item == nil else { return }
self.item = geholt
self.updateActiveMarker()
self.preloadNextEpisode()
self.vorschauHolen()
}
}
private func startLocal(url: URL) async { private func startLocal(url: URL) async {
// Eine Datei auf dem Gerät ist der ganze Film; es gibt keinen
// Vorlauf, den der Spieler aufrechnen müsste.
streamOffset = .zero
streamEnd = nil
let offline = downloads?.offlineMedia(forRatingKey: request.ratingKey) ?? nil let offline = downloads?.offlineMedia(forRatingKey: request.ratingKey) ?? nil
let decision = PlaybackDecider().decide( let decision = PlaybackDecider().decide(
@@ -839,6 +940,26 @@ final class PlayerModel {
playbackSession = target.sessionID playbackSession = target.sessionID
playbackVersionID = target.versionID playbackVersionID = target.versionID
// **Wer schon gesprungen ist, springt nicht noch einmal.**
//
// Flaro legt den Strom an der gewünschten Stelle an; Jellyfin
// liefert den ganzen Film und lässt den Spieler springen. Beides
// zugleich hiesse bei einundzwanzig Minuten Fortschritt, bei
// zweiundvierzig zu landen.
streamOffset = target.startOffset
streamEnd = nil
// **Die Länge kommt aus der Datei, nicht vom Player.**
//
// Eine wachsende Abspielliste hat für AVPlayer keine Länge — sie
// trägt kein `EXT-X-ENDLIST`, also bleibt die Dauer unbestimmt
// und `durationResolved` kommt nie. Ohne diese Zeile blieb
// `duration` auf nichts, und die Ansicht rechnet dann mit einer
// Sekunde: der Regler stand bei 1:50:07 am Anschlag.
if let bekannt = part.duration ?? item.duration {
duration = .milliseconds(bekannt)
}
// **Der Vorrat läuft voraus, nicht der Player.** // **Der Vorrat läuft voraus, nicht der Player.**
// //
// AVPlayer entscheidet selbst, wie weit er puffert, und bei einer // AVPlayer entscheidet selbst, wie weit er puffert, und bei einer
@@ -856,7 +977,7 @@ final class PlayerModel {
return PlaybackSource( return PlaybackSource(
url: adresse, url: adresse,
origin: .remote, origin: .remote,
startTime: start, startTime: target.startOffset > .zero ? .zero : start,
// **Mit eigenem Vorrat ein kleiner Puffer.** // **Mit eigenem Vorrat ein kleiner Puffer.**
// //
// Er bestimmt, wie viel AVPlayer beisammenhaben will, bevor // Er bestimmt, wie viel AVPlayer beisammenhaben will, bevor
@@ -1504,6 +1625,10 @@ final class PlayerModel {
// Der Sprung **ist** angekommen, in dem Moment, in dem man ihn // Der Sprung **ist** angekommen, in dem Moment, in dem man ihn
// auslöst. Alles Weitere ist Warten auf Daten, und dafür gibt es den // auslöst. Alles Weitere ist Warten auf Daten, und dafür gibt es den
// Kreisel. // Kreisel.
// **Vor dem Aufräumen entscheiden.** Die Antwort hängt daran, wie
// weit der Vorrat reicht — und der wird gleich verworfen.
let neuerStrom = ausserhalbDesStroms(time)
currentTime = time currentTime = time
seekTarget = time seekTarget = time
// Der Vorrat von vorhin gilt für die alte Stelle. Ihn stehen zu lassen // Der Vorrat von vorhin gilt für die alte Stelle. Ihn stehen zu lassen
@@ -1512,7 +1637,55 @@ final class PlayerModel {
NowPlaying.shared.update(from: self) NowPlaying.shared.update(from: self)
updateActiveMarker() updateActiveMarker()
Task { await engine.seek(to: time) } // **Ausserhalb dieses Stroms springt nicht der Spieler, sondern der
// Server.**
//
// Flaros Abspielliste beginnt an der gewünschten Stelle und wächst
// von dort vorwärts. Was davor liegt und was noch nicht gerechnet
// ist, gibt es darin nicht; ein Sprung dorthin ginge ins Leere und
// der Spieler bliebe mit einem Kreisel stehen. Also wird der Strom
// neu aufgebaut — `restart` steigt bei `currentTime` wieder ein, und
// das ist genau die Stelle, die eben gesetzt wurde.
if neuerStrom {
Task { await restart() }
return
}
Task { await engine.seek(to: time - streamOffset) }
}
/// Ob diese Stelle in dem Strom liegt, der gerade läuft.
///
/// **Innerhalb des Erzeugten springt der Spieler selbst.** Dafür eine
/// neue Sitzung zu starten hiesse, Sekunden zu warten, um fünf Sekunden
/// zurückzugehen.
private func ausserhalbDesStroms(_ time: Duration) -> Bool {
// **Eine Datei mit bekannter Länge: überallhin.** `streamEnd` steht
// nur, wenn der Player eine Dauer ermitteln konnte, und das kann er
// genau dann, wenn das Ganze schon dasteht — eine Mediendatei oder
// eine fertige Abspielliste.
if streamEnd != nil, streamOffset == .zero { return false }
// Vor dem Anfang des Stroms gibt es in ihm nichts.
if time < streamOffset { return true }
// **Eine wachsende Liste reicht so weit, wie Daten da sind.**
//
// Hier stand ein Vergleich mit `streamEnd`, und der ging nie auf:
// bei einer wachsenden Liste bleibt die Dauer unbestimmt, also ist
// `streamEnd` nichts, und jeder Sprung galt als innerhalb. AVPlayer
// bekam ein Ziel, zu dem es keine Schnipsel gibt, verwarf es, und
// der Regler sprang zurück — beim Ziehen sichtbar, im Pausieren
// nicht, weil die Liste dort weiterwuchs und ihn irgendwann einholte.
//
// **Weiss niemand, wie weit es reicht, wird neu gebaut.** Ein neuer
// Strom dauert ein paar Sekunden; ein Sprung, der nichts tut, ist
// kaputt.
guard let bis = bufferedUntil else { return true }
// Eine halbe Sekunde Nachsicht an der Kante: dort einen neuen Strom
// zu bauen wäre Aufwand für nichts.
return time > bis + .milliseconds(500)
} }
/// Springt relativ zur aktuellen Stelle — für die ±10-Sekunden-Knöpfe. /// Springt relativ zur aktuellen Stelle — für die ±10-Sekunden-Knöpfe.
@@ -1523,9 +1696,20 @@ final class PlayerModel {
/// Springt ans Ende der laufenden Marke. /// Springt ans Ende der laufenden Marke.
func skipActiveMarker() { func skipActiveMarker() {
guard let marker = activeMarker else { return } guard let marker = activeMarker, let item else { return }
skippedMarkers.insert(marker.id) skippedMarkers.insert(marker.id)
seek(to: .milliseconds(marker.endMilliseconds))
// **Mit dem Schalter in einem Zug bis ans Ende.** Sonst endet der
// Sprung an dieser Marke, also bei der Post-Credit-Szene — wer sie
// nicht sehen will, stellt es einmal um und drückt einmal.
let ziel = settings.skipExtraScenes
? item.markers
.filter { $0.kind == marker.kind && $0.startMilliseconds >= marker.startMilliseconds }
.map(\.endMilliseconds)
.max() ?? marker.endMilliseconds
: marker.endMilliseconds
seek(to: .milliseconds(ziel))
} }
/// Ob es bei der Tonspur überhaupt etwas zu wählen gibt. /// Ob es bei der Tonspur überhaupt etwas zu wählen gibt.
@@ -1660,26 +1844,43 @@ final class PlayerModel {
private func report(state: PlaybackReportState) async { private func report(state: PlaybackReportState) async {
guard let backend, let item else { return } guard let backend, let item else { return }
// Die Laufzeit der Engine ist die genauere, aber sie steht erst ein // **Die Laufzeit des Titels schlägt die der Engine.**
// paar Sekunden nach dem Öffnen fest. Für die erste Meldung tut es die //
// des Servers — sonst fiele ausgerechnet der Bericht aus, der die // Vorher war es umgekehrt, mit dem Argument, die Engine messe
// Sitzung anlegt, und der Titel erschiene nirgends als „läuft gerade". // genauer. Sie misst aber am Strom und nicht am Film: bei einem
guard let total = duration ?? item.duration.map({ Duration.milliseconds($0) }) // gerechneten Strom ist das eine Playlist, die noch wächst, und
// anfangs sieht die Engine davon nur einen Stummel. Gemeldet hat sie
// ihn als Laufzeit — und daraus machte der Server die Laufzeit des
// Films: Stelle zusammengestaucht, Häkchen „gesehen" gesetzt, Titel
// aus „Weiterschauen" verschwunden. Gemessen an einem Film, der bei
// 46 Minuten stand und danach wieder bei null anfing.
guard let total = item.duration.map({ Duration.milliseconds($0) }) ?? duration
else { return } else { return }
// Beim Beginn steht die Zeit noch auf null — das ist keine fehlende // **Keine Null melden, die der Spieler gar nicht meint.**
// Angabe, sondern der Anfang. Alle anderen Meldungen ohne Zeit wären //
// dagegen wertlos und würden einen gemerkten Fortschritt überschreiben. // Beim Öffnen steht die Zeit der Engine auf null, obwohl der Spieler
guard currentTime > .zero || state == .started else { return } // gleich an einer ganz anderen Stelle einsteigt. Diese Meldung darf
// nicht ausfallen — erst sie legt beim Server die Sitzung an, unter
// der der Titel als „läuft gerade" erscheint. Sie muss nur die
// Stelle nennen, die gemeint ist, statt der, die noch nicht gesetzt
// ist.
let stelle = currentTime > .zero ? currentTime : request.startTime
guard stelle > .zero || state == .started else { return }
await backend.reportProgress(PlaybackReport( let bericht = PlaybackReport(
itemID: item.id, itemID: item.id,
sessionID: playbackSession, sessionID: playbackSession,
versionID: playbackVersionID, versionID: playbackVersionID,
state: state, state: state,
time: currentTime, time: stelle,
duration: total duration: total
)) )
// **Was nicht ankommt, wird zurückgelegt.** Ohne das war eine Folge,
// die man offline zu Ende gesehen hat, für den Server nie gelaufen.
if await backend.reportProgress(bericht) == false {
post?.zuruecklegen(bericht, server: backend.identity)
}
} }
// MARK: - Marken und nächste Folge // MARK: - Marken und nächste Folge
@@ -1688,14 +1889,14 @@ final class PlayerModel {
guard let item else { return } guard let item else { return }
let milliseconds = currentTime.milliseconds let milliseconds = currentTime.milliseconds
activeMarker = item.markers.first { marker in // **Was der Server schickt, gilt.** Hier stand eine eigene Regel:
guard marker.contains(milliseconds) else { return false } // bei einem Film wurde die Abspannmarke verworfen, weil
// Der Abspann zählt nur als Marke, wenn danach noch etwas kommt — // „überspringen" dort gleichbedeutend mit „beenden" war. Das ist
// bei einem Film ist „Abspann überspringen" gleichbedeutend mit // eine Entscheidung über Marken, und die trifft der Server — er
// „Film beenden". // schickt sie nur, wenn er einen Abspann gefunden hat, und seit
if marker.isCredits && item.kind != .episode { return false } // ein Abspann geteilt sein darf, führt der Knopf zur
return true // Post-Credit-Szene statt ins Nichts.
} activeMarker = item.markers.first { $0.contains(milliseconds) }
guard let marker = activeMarker, !skippedMarkers.contains(marker.id) else { return } guard let marker = activeMarker, !skippedMarkers.contains(marker.id) else { return }
let shouldSkip = (marker.isIntro && settings.autoSkipIntro) let shouldSkip = (marker.isIntro && settings.autoSkipIntro)
@@ -1703,21 +1904,43 @@ final class PlayerModel {
if shouldSkip { skipActiveMarker() } if shouldSkip { skipActiveMarker() }
} }
/// **Beide Nachbarn, nicht nur der nächste.**
///
/// Die nächste Folge wurde schon immer vorgeladen — für den Knopf am
/// Ende. Seit es im Spieler Knöpfe zum Blättern gibt, gilt dasselbe für
/// die vorige: wer eine zu weit gesprungen ist, soll zurück können, ohne
/// den Spieler zu verlassen.
private func preloadNextEpisode() { private func preloadNextEpisode() {
guard let item, item.kind == .episode, let backend else { return } guard let item, item.kind == .episode, let backend else { return }
Task { [weak self] in Task { [weak self] in
let next = try? await backend.nextEpisode(after: item) let next = try? await backend.nextEpisode(after: item)
self?.nextEpisode = next self?.nextEpisode = next
} }
Task { [weak self] in
let vorige = try? await backend.previousEpisode(before: item)
self?.previousEpisode = vorige
}
} }
/// Der Abspielwunsch für die nächste Folge — die Ansicht reicht ihn an den /// Der Abspielwunsch für die nächste Folge — die Ansicht reicht ihn an den
/// Koordinator weiter. /// Koordinator weiter.
func nextEpisodeRequest() -> PlaybackRequest? { func nextEpisodeRequest() -> PlaybackRequest? { wunsch(für: nextEpisode) }
guard let nextEpisode else { return nil }
/// Dasselbe rückwärts.
func previousEpisodeRequest() -> PlaybackRequest? { wunsch(für: previousEpisode) }
/// **Von vorn, nicht von der gemerkten Stelle.**
///
/// Wer blättert, will die Folge sehen. Beim Vorwärtsblättern ist sie
/// ohnehin meist ungesehen; beim Zurückblättern stünde man sonst im
/// Abspann der Folge, die man gerade noch einmal anfangen wollte. Wer
/// fortsetzen will, nimmt den Weg über die Serienseite — dort steht die
/// Stelle dabei.
private func wunsch(für folge: MediaItem?) -> PlaybackRequest? {
guard let folge else { return nil }
return PlaybackRequest( return PlaybackRequest(
ratingKey: nextEpisode.id, ratingKey: folge.id,
title: nextEpisode.playbackTitle, title: folge.playbackTitle,
mediaIndex: 0, mediaIndex: 0,
startTime: .zero startTime: .zero
) )
@@ -1859,7 +2082,14 @@ final class PlayerModel {
String(describing: failure), String(describing: failure),
].joined(separator: "\n\n")) ].joined(separator: "\n\n"))
} }
case .timeChanged(let time): case .timeChanged(let stromzeit):
// **Die Uhr des Spielers ist nicht die Uhr des Films.**
//
// Beginnt der Strom bei 1:32, zählt der Spieler trotzdem
// ab null. Ab hier wird in Filmzeit gerechnet — alles
// darunter, von der Anzeige bis zur Fortschrittsmeldung,
// meint denselben Punkt im Film.
let time = streamOffset + stromzeit
// **Nachzügler verwerfen.** Nach einem Sprung meldet der // **Nachzügler verwerfen.** Nach einem Sprung meldet der
// Player noch ein paar Mal die alte Stelle, bis er dort // Player noch ein paar Mal die alte Stelle, bis er dort
// ankommt. Ungeprüft übernommen zöge das den Regler wieder // ankommt. Ungeprüft übernommen zöge das den Regler wieder
@@ -1889,7 +2119,22 @@ final class PlayerModel {
} }
updateActiveMarker() updateActiveMarker()
case .durationResolved(let value): case .durationResolved(let value):
duration = value streamEnd = streamOffset + value
// **Die Länge des Films, nicht die des Stroms.**
//
// Eine wachsende Abspielliste meldet anfangs ein paar
// Sekunden. Als Filmlänge genommen stünde der Regler
// sofort am Ende, und ein Sprung nach vorn wäre
// unmöglich.
// **Die Datei weiss es genau, der Titel oft gar nicht.**
// `item.duration` kommt aus der Liste, und dort stehen
// keine Dateien — bei einem Titel, der aus einer Reihe
// geöffnet wurde, ist es nichts. Dann blieb nur die Länge
// des Stroms, und die ist am Anfang ein paar Sekunden:
// Regler am Ende, obwohl noch zwanzig Minuten kommen.
duration = currentPart?.duration.map { Duration.milliseconds($0) }
?? item?.duration.map { Duration.milliseconds($0) }
?? streamEnd
NowPlaying.shared.update(from: self) NowPlaying.shared.update(from: self)
case .reachedEnd: case .reachedEnd:
isPlaying = false isPlaying = false
@@ -1931,14 +2176,52 @@ final class PlayerModel {
/// Einstellungen eine Untertitelsprache steht. Wer keine eingestellt /// Einstellungen eine Untertitelsprache steht. Wer keine eingestellt
/// hatte, schaltete die Untertitel ein und sah nichts. /// hatte, schaltete die Untertitel ein und sah nichts.
/// ///
/// **Die erste ist die richtige.** Rechnet der Server um, liegt genau /// **Die erste ist nicht mehr die richtige.**
/// eine im Stream — nämlich die bestellte. Es gibt nichts zu verwechseln. ///
/// Das galt, solange der Server genau eine Spur auslieferte — die
/// bestellte. Flaro legt seit dem Strom **alle** Textspuren als eigene
/// Spuren in die Abspielliste, und dann ist die erste schlicht die
/// erste: wer Deutsch wählte, sah Englisch.
///
/// Gesucht wird deshalb die Spur, die zur Bestellung passt — erst über
/// das Sprachkürzel, dann über den Namen. Findet sich keine, bleibt es
/// bei der ersten: bei einem umgerechneten Strom gibt es nur sie, und
/// gar keinen Untertitel zu zeigen wäre schlechter als den einen.
private func showOrderedSubtitle() { private func showOrderedSubtitle() {
guard selectedSubtitleStream != nil, selectedSubtitleTrack == nil else { return } guard let bestellt = selectedSubtitleStream, selectedSubtitleTrack == nil else { return }
guard let erste = subtitleTracks.first else { return } guard let treffer = passendeSpur(zu: bestellt) ?? subtitleTracks.first else { return }
diagnostics.note("Untertitel eingeschaltet: \(erste.displayName)") diagnostics.note("Untertitel eingeschaltet: \(treffer.displayName)")
selectSubtitleTrack(erste) selectSubtitleTrack(treffer)
}
/// Die Spur im Strom, die zu der bestellten aus den Metadaten gehört.
private func passendeSpur(zu bestellt: MediaStream) -> MediaTrack? {
// **Die Sprache zuerst.** Sie steht in der Abspielliste als
// `LANGUAGE` und ist das, was ein Spieler verlässlich durchreicht.
if let code = bestellt.languageCode ?? bestellt.language,
let treffer = subtitleTracks.first(where: {
LanguageCode.matches(code, $0.languageCode)
&& $0.isForced == bestellt.isForced
})
{
return treffer
}
// **Dann der Name.** Zwei Spuren in derselben Sprache — Dialoge und
// Schilder etwa — unterscheiden sich nur darüber.
if let name = bestellt.displayTitle,
let treffer = subtitleTracks.first(where: { $0.displayName == name })
{
return treffer
}
// Ohne Sprachkürzel bleibt die Sprache allein.
if let code = bestellt.languageCode ?? bestellt.language {
return subtitleTracks.first { LanguageCode.matches(code, $0.languageCode) }
}
return nil
} }
/// Wählt die Untertitelspur, sofern eine gewünscht ist. /// Wählt die Untertitelspur, sofern eine gewünscht ist.
@@ -1952,9 +2235,15 @@ final class PlayerModel {
/// Nur beim ersten Mal: hat jemand während der Wiedergabe umgestellt, darf /// Nur beim ersten Mal: hat jemand während der Wiedergabe umgestellt, darf
/// eine später gemeldete Spurliste das nicht zurücksetzen. /// eine später gemeldete Spurliste das nicht zurücksetzen.
private func applyPreferredLanguages() { private func applyPreferredLanguages() {
guard selectedSubtitleTrack == nil, !languages.subtitleLanguage.isEmpty, // **Die Ebene schlägt das Allgemeine.** Hier stand nur die
// allgemeine Sprache; eine Serie, die man im Original mit deutschen
// Untertiteln sieht, liess sich damit nicht einstellen, ohne sie für
// alles andere auch einzuschalten. Bei einer Folge gilt die Serie,
// bei einem Film der Titel selbst.
guard selectedSubtitleTrack == nil,
let wunsch = languages.subtitleWish(titleID: titelbereich),
let treffer = subtitleTracks.first(where: { let treffer = subtitleTracks.first(where: {
LanguageCode.matches(languages.subtitleLanguage, $0.languageCode) LanguageCode.matches(wunsch, $0.languageCode)
}) })
else { return } else { return }
selectSubtitleTrack(treffer) selectSubtitleTrack(treffer)
@@ -1972,6 +2261,14 @@ final class PlayerModel {
/// Netz und ohne Einstellungen, damit sich der ZDF-Fall wörtlich /// Netz und ohne Einstellungen, damit sich der ZDF-Fall wörtlich
/// hinschreiben und durchspielen lässt. Hier steht nur, woher der Wunsch /// hinschreiben und durchspielen lässt. Hier steht nur, woher der Wunsch
/// kommt. /// kommt.
/// Unter welcher Kennung die Vorwahl dieses Titels liegt.
///
/// **Bei einer Folge die Serie, bei einem Film er selbst.** „Diese Serie
/// auf Japanisch" gilt für alle Folgen; „dieser Film auf Englisch" gilt
/// für ihn. Beides ist dieselbe Frage auf der Ebene, die der Benutzer
/// vor sich hatte, als er sie beantwortet hat.
private var titelbereich: String? { item?.seriesID ?? item?.id }
private func chooseAudioStream( private func chooseAudioStream(
in part: MediaFile, in part: MediaFile,
of item: MediaItem, of item: MediaItem,
@@ -1981,10 +2278,9 @@ final class PlayerModel {
subtitleStreams = part.subtitleStreams subtitleStreams = part.subtitleStreams
// Untertitel sind eine Zutat, keine Voraussetzung: der Wunsch gilt, // Untertitel sind eine Zutat, keine Voraussetzung: der Wunsch gilt,
// wenn es einen passenden gibt, und sonst bleibt es ohne. // wenn es einen passenden gibt, und sonst bleibt es ohne.
selectedSubtitleStream = languages.subtitleLanguage.isEmpty ? nil selectedSubtitleStream = languages.subtitleWish(titleID: titelbereich).flatMap { wunsch in
: subtitleStreams.first { subtitleStreams.first { LanguageCode.matches(wunsch, $0.languageCode) }
LanguageCode.matches(languages.subtitleLanguage, $0.languageCode) }
}
guard !audioStreams.isEmpty else { guard !audioStreams.isEmpty else {
selectedAudioStream = nil selectedAudioStream = nil
@@ -2000,7 +2296,12 @@ final class PlayerModel {
selectedAudioStream = AudioTrackChooser.choose( selectedAudioStream = AudioTrackChooser.choose(
from: part.streams, from: part.streams,
wish: languages.wish(seriesID: item.seriesID, libraryID: libraryID) // **Bei einem Film seine eigene Kennung.** Hier stand nur
// `item.seriesID`, und die ist bei einem Film nichts: die
// Vorwahl auf der Filmseite wurde abgelegt und nie wieder
// gelesen. Untertitel gingen durch, Ton nicht — weil die beiden
// an verschiedenen Stellen nachsehen.
wish: languages.wish(seriesID: titelbereich, libraryID: libraryID)
) )
if let gewählt = selectedAudioStream { if let gewählt = selectedAudioStream {
@@ -2020,8 +2321,8 @@ final class PlayerModel {
guard stream != selectedAudioStream else { return } guard stream != selectedAudioStream else { return }
selectedAudioStream = stream selectedAudioStream = stream
if let seriesID = item?.seriesID { if let bereich = titelbereich {
languages.remember(stream, forSeries: seriesID) languages.remember(stream, forSeries: bereich)
} }
// **Der billige Weg, wenn er offensteht.** Wird die Datei unverändert // **Der billige Weg, wenn er offensteht.** Wird die Datei unverändert
@@ -2069,16 +2370,16 @@ final class PlayerModel {
/// Was für diese Serie gemerkt ist — für die Anzeige im Spurenblatt. /// Was für diese Serie gemerkt ist — für die Anzeige im Spurenblatt.
var rememberedTrackName: String? { var rememberedTrackName: String? {
guard let seriesID = item?.seriesID, guard let bereich = titelbereich,
let signatur = languages.rememberedTrack(forSeries: seriesID) let signatur = languages.rememberedTrack(forSeries: bereich)
else { return nil } else { return nil }
return signatur.title ?? signatur.languageCode return signatur.title ?? signatur.languageCode
} }
/// Vergisst die gemerkte Spur dieser Serie. /// Vergisst die gemerkte Spur dieser Serie.
func forgetRememberedTrack() { func forgetRememberedTrack() {
guard let seriesID = item?.seriesID else { return } guard let bereich = titelbereich else { return }
languages.forgetTrack(forSeries: seriesID) languages.forgetTrack(forSeries: bereich)
} }
private func playerSubtitle(for item: MediaItem) -> String? { private func playerSubtitle(for item: MediaItem) -> String? {
Flaro/Views/Player/PlayerView.swift
+115 -5
View File
@@ -52,6 +52,15 @@ struct PlayerView: View {
@State private var trackPicker: TrackPickerSheet.Kind? @State private var trackPicker: TrackPickerSheet.Kind?
@State private var showsQualityChoice = false @State private var showsQualityChoice = false
@State private var hideTask: Task<Void, Never>? @State private var hideTask: Task<Void, Never>?
/// Ob die Marken-Knöpfe inzwischen an der Bedienung hängen.
///
/// **Erst für sich, dann mit der Bedienung.** Eine neue Marke zeigt
/// ihre Knöpfe von selbst — sonst müsste man erst das Bild antippen,
/// um das Intro überspringen zu können, und dann hätte man die
/// Bedienung ohnehin. Sobald man sie aber einmal eingeblendet hat,
/// gehören die Knöpfe dazu und gehen mit ihr. Keine Frist, kein
/// Zeitgeber: der Zuschauer sagt selbst, wann er genug gesehen hat.
@State private var markenGebunden = false
@State private var scrubbing: Double? @State private var scrubbing: Double?
/// Welche Richtung gerade als Hinweis eingeblendet ist. /// Welche Richtung gerade als Hinweis eingeblendet ist.
@State private var seekHint: Double? @State private var seekHint: Double?
@@ -106,8 +115,29 @@ struct PlayerView: View {
// Jetzt rechnet das Layout. Der schwarze Rand ist schlicht // Jetzt rechnet das Layout. Der schwarze Rand ist schlicht
// der Hintergrund dahinter, und wer ihn anklickt, klickt // der Hintergrund dahinter, und wer ihn anklickt, klickt
// nicht aufs Bild — das muss niemand mehr feststellen. // nicht aufs Bild — das muss niemand mehr feststellen.
// **Im Vollbild über alles, sonst nicht unter die
// Insel.**
//
// Bei 21∶9 auf einem Telefon reicht das Bild über die
// ganze Breite — und damit hinter die Dynamic Island, die
// links einen Streifen davon verdeckt. Wer Vollbild
// wählt, hat sich fürs Beschneiden entschieden; dort ist
// Rand an Rand folgerichtig. Im normalen Modus ist der
// Anspruch gerade, dass nichts fehlt — dann darf auch
// nichts verdeckt sein. Plex macht es genauso.
Color.clear Color.clear
.ignoresSafeArea() //
// **Ein Modifikator mit leeren Kanten, kein `if`.**
// Hier stand ein eigener `ViewModifier`, der
// zwischen `ignoresSafeArea()` und gar nichts
// umschaltete — und genau das ist in SwiftUI ein
// Zweig: beim Umschalten wurde der Baum darunter
// neu aufgebaut, die Bildebene mit ihm, und der
// Spieler stand ohne sie da. Schwarz, sobald
// jemand auf „Bildfüllend" wechselte. `edges: []`
// ignoriert nichts und ist doch derselbe
// Modifikator — die Ansicht bleibt dieselbe.
.ignoresSafeArea(.container, edges: model.videoFit == .fill ? .all : [])
.overlay { .overlay {
surface(for: model) surface(for: model)
.contentShape(.rect) .contentShape(.rect)
@@ -341,6 +371,17 @@ struct PlayerView: View {
.environment(settings) .environment(settings)
.environment(\.flaroAccent, accent) .environment(\.flaroAccent, accent)
} }
// Eine neue Marke ist ein neues Angebot: sie steht wieder für sich,
// bis die Bedienung das nächste Mal auftaucht.
.onChange(of: model.activeMarker?.id, initial: true) { _, _ in
markenGebunden = false
}
// **Der Übergang zählt, nicht der Zustand.** Beim Start liegt die
// Bedienung ohnehin da; das als „einmal gezeigt" zu werten hiesse,
// dem Intro seinen Knopf zu nehmen, bevor es ihn je hatte.
.onChange(of: showsControls) { vorher, jetzt in
if !vorher && jetzt { markenGebunden = true }
}
.onChange(of: showsQualityChoice) { _, isShown in .onChange(of: showsQualityChoice) { _, isShown in
// Nach dem Schließen die Bedienelemente stehen lassen und die // Nach dem Schließen die Bedienelemente stehen lassen und die
// Ausblendfrist neu starten. Ohne das verschwänden sie sofort, // Ausblendfrist neu starten. Ohne das verschwänden sie sofort,
@@ -594,7 +635,25 @@ struct PlayerView: View {
} }
private func transport(for model: PlayerModel) -> some View { private func transport(for model: PlayerModel) -> some View {
HStack(spacing: FlaroSpacing.section * 2) { // **Enger, seit zwei Knöpfe dazukommen.** Bei fünf Knöpfen in einer
// Reihe wird der alte Abstand auf einem Telefon im Hochformat zu
// breit; bei drei bleibt er, wie er war.
let folgen = model.previousEpisode != nil || model.nextEpisode != nil
return HStack(spacing: folgen ? FlaroSpacing.section : FlaroSpacing.section * 2) {
// **Eine Folge zurück — nur bei Serien, nur wenn es eine gibt.**
//
// Bei einem Film bleibt die Reihe, wie sie war: ein Knopf, der
// nie etwas tut, ist schlechter als keiner.
if model.previousEpisode != nil {
Button {
if let wunsch = model.previousEpisodeRequest() { playback.play(wunsch) }
} label: {
Image(systemName: "backward.end.fill").font(.title2)
}
.accessibilityLabel(Text("player.previousEpisode"))
}
Button { Button {
model.skip(by: .seconds(-settings.rewindSeconds)) model.skip(by: .seconds(-settings.rewindSeconds))
scheduleControlsHide() scheduleControlsHide()
@@ -638,6 +697,15 @@ struct PlayerView: View {
Image(systemName: "goforward.\(settings.forwardSeconds)").font(.largeTitle) Image(systemName: "goforward.\(settings.forwardSeconds)").font(.largeTitle)
} }
.accessibilityLabel(Text("player.forward10")) .accessibilityLabel(Text("player.forward10"))
if model.nextEpisode != nil {
Button {
if let wunsch = model.nextEpisodeRequest() { playback.play(wunsch) }
} label: {
Image(systemName: "forward.end.fill").font(.title2)
}
.accessibilityLabel(Text("player.nextEpisode"))
}
} }
.foregroundStyle(.white) .foregroundStyle(.white)
} }
@@ -662,7 +730,9 @@ struct PlayerView: View {
// springen lässt das Bild flackern und hält bei großen // springen lässt das Bild flackern und hält bei großen
// Dateien den Puffer dauerhaft leer. // Dateien den Puffer dauerhaft leer.
onCommit: { model.seek(to: $0) }, onCommit: { model.seek(to: $0) },
onActivity: { scheduleControlsHide() } onActivity: { scheduleControlsHide() },
vorschau: model.vorschau,
blatt: { model.vorschaublatt($0) }
) )
HStack { HStack {
@@ -683,12 +753,31 @@ struct PlayerView: View {
/// Überspringen-Knopf und „Nächste Folge". /// Überspringen-Knopf und „Nächste Folge".
@ViewBuilder @ViewBuilder
/// Ob jetzt „Nächste Folge" dransteht.
///
/// Am Ende immer, im Abspann auch — dort ist es die Antwort auf die
/// Frage, die der Abspann stellt. Gibt es keine nächste Folge, bleibt
/// es beim Überspringen.
private func naechsteAnbieten(_ model: PlayerModel) -> Bool {
guard model.nextEpisodeRequest() != nil else { return false }
return model.hasReachedEnd || model.activeMarker?.isCredits == true
}
private func overlayActions(for model: PlayerModel) -> some View { private func overlayActions(for model: PlayerModel) -> some View {
VStack { VStack {
Spacer() Spacer()
HStack { HStack {
Spacer() Spacer()
if model.hasReachedEnd, model.nextEpisodeRequest() != nil { // **Im Abspann ist „überspringen" die falsche Frage — aber
// nicht die einzige.**
//
// Was man dort meistens will, ist die nächste Folge; ans
// Ende dieser zu springen bringt niemanden weiter. Wer den
// Abspann aber sehen wollte und es sich anders überlegt,
// soll ihn trotzdem überspringen können. Zwei Antworten,
// zwei Knöpfe — welche gemeint ist, weiss nur der
// Zuschauer.
if naechsteAnbieten(model) {
Button { Button {
if let next = model.nextEpisodeRequest() { if let next = model.nextEpisodeRequest() {
playback.play(next) playback.play(next)
@@ -701,7 +790,9 @@ struct PlayerView: View {
} }
.buttonStyle(.borderedProminent) .buttonStyle(.borderedProminent)
.tint(accent) .tint(accent)
} else if let marker = model.activeMarker { }
if let marker = model.activeMarker {
Button { Button {
model.skipActiveMarker() model.skipActiveMarker()
} label: { } label: {
@@ -721,9 +812,28 @@ struct PlayerView: View {
// Über dem Schieberegler, damit sich beides nicht überdeckt, wenn // Über dem Schieberegler, damit sich beides nicht überdeckt, wenn
// die Bedienelemente eingeblendet sind. // die Bedienelemente eingeblendet sind.
.padding(.bottom, (showsControls ? 110 : FlaroSpacing.section) + safeArea.bottom) .padding(.bottom, (showsControls ? 110 : FlaroSpacing.section) + safeArea.bottom)
// **Am Ende bleibt es stehen, sonst nicht.**
//
// Ist der Film aus, ist der Knopf die einzige Frage, die noch
// offen ist — der darf warten. Mitten in einer Marke ist er ein
// Angebot, und ein Angebot, das nicht angenommen wird, nimmt
// man zurück.
.opacity(markenSichtbar(model) ? 1 : 0)
.allowsHitTesting(markenSichtbar(model))
} }
.animation(.snappy, value: model.activeMarker?.id) .animation(.snappy, value: model.activeMarker?.id)
.animation(.snappy, value: model.hasReachedEnd) .animation(.snappy, value: model.hasReachedEnd)
.animation(.easeIn(duration: 0.28), value: markenGebunden)
}
/// **Dieselbe Regel für Vorspann und Abspann, Web wie App.**
///
/// Sichtbar, solange die Knöpfe noch für sich stehen; danach genau
/// dann, wenn die Bedienung da ist. Am Ende des Films bleiben sie
/// trotzdem: dort ist „Nächste Folge" die einzige noch offene Frage,
/// und es gibt kein Bild mehr, das sie verdecken könnten.
private func markenSichtbar(_ model: PlayerModel) -> Bool {
model.hasReachedEnd || showsControls || !markenGebunden
} }
/// Die Abdeckung während des Umstellens. /// Die Abdeckung während des Umstellens.
Flaro/Views/Search/SearchView.swift
+1 -1
View File
@@ -48,7 +48,7 @@ struct SearchView: View {
// weiß aber noch nicht, was er sehen will; der erste // weiß aber noch nicht, was er sehen will; der erste
// Treffer ist eine Vermutung des Servers. Starten geht // Treffer ist eine Vermutung des Servers. Starten geht
// weiter, über langes Drücken. // weiter, über langes Drücken.
MediaRow(row: hub, opensDetails: true) MediaRow(row: hub)
} }
} }
.padding(.vertical, FlaroSpacing.loose) .padding(.vertical, FlaroSpacing.loose)
Flaro/Views/Settings/AudioLanguagePicker.swift
+132 -31
View File
@@ -1,13 +1,18 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import MediaKit
/// „Welche Tonsprache gilt hier?" — an genau zwei Orten dieselbe Frage. /// „Welche Sprache gilt hier?" — an mehreren Orten dieselbe Frage.
/// ///
/// **Warum ein gemeinsamer Typ.** Die Frage steht einmal auf der Serienseite /// **Warum ein gemeinsamer Typ.** Die Frage steht auf der Serienseite, auf
/// und einmal bei der Mediathek, und die Antwort bedeutet beide Male dasselbe: /// der Filmseite und bei der Mediathek, und die Antwort bedeutet jedes Mal
/// diese Ebene setzt sich gegen die darüber durch, oder sie tut es nicht. Zwei /// dasselbe: diese Ebene setzt sich gegen die darüber durch, oder sie tut es
/// Auswahlknöpfe mit demselben Inhalt liefen unweigerlich auseinander — einer /// nicht. Mehrere Auswahlknöpfe mit demselben Inhalt liefen unweigerlich
/// bekäme eine Sprache dazu, der andere nicht. /// auseinander — einer bekäme eine Sprache dazu, der andere nicht.
///
/// **Ton und Untertitel im selben Typ.** Sie unterscheiden sich in genau
/// zwei Punkten: woher der Wert kommt, und ob es „keine" gibt. Ein zweiter
/// Typ dafür wäre dieselbe Datei mit zwei geänderten Zeilen.
/// ///
/// **Ein Menü, kein `Picker`.** Die Serienseite ist eine `ScrollView`, kein /// **Ein Menü, kein `Picker`.** Die Serienseite ist eine `ScrollView`, kein
/// `Form`; dort hätte ein `Picker` kein Aussehen, auf das man sich verlassen /// `Form`; dort hätte ein `Picker` kein Aussehen, auf das man sich verlassen
@@ -15,25 +20,98 @@ import FlaroDesign
struct AudioLanguagePicker: View { struct AudioLanguagePicker: View {
/// Für welche Ebene gewählt wird. /// Für welche Ebene gewählt wird.
enum Scope { enum Scope {
/// Eine Serie oder ein Film — beides eine Kennung, beides ein Titel.
case series(String) case series(String)
case library(String) case library(String)
} }
/// Ton oder Text.
enum Kind {
case audio
case subtitles
}
/// Wie der Knopf aussieht.
enum Form {
/// Eine Zeile: Beschriftung links, Wahl rechts. Für Listen.
case zeile
/// Ein Knopf wie „Ton: Deutsch". Für die Reihe neben „Abspielen".
case knopf
}
let scope: Scope let scope: Scope
let title: LocalizedStringKey let title: LocalizedStringKey
var kind: Kind = .audio
var form: Form = .zeile
/// Welche Sprachen es wirklich gibt — `nil` heisst: alle anbieten.
///
/// **Eine Liste mit zwanzig Sprachen für eine Serie mit zweien** ist
/// keine Auswahl, sondern eine Suche. Weiss niemand, welche es gibt,
/// bleibt es bei der vollen Liste: eine zu lange ist besser als eine
/// leere.
var available: [LanguageOption]?
@Environment(LanguagePreferences.self) private var languages @Environment(LanguagePreferences.self) private var languages
@Environment(\.flaroAccent) private var accent @Environment(\.flaroAccent) private var accent
var body: some View { var body: some View {
HStack(spacing: FlaroSpacing.regular) { switch form {
Text(title) case .zeile:
.font(.flaroBody) HStack(spacing: FlaroSpacing.regular) {
Text(title)
.font(.flaroBody)
.foregroundStyle(Color.flaroTextPrimary)
Spacer(minLength: FlaroSpacing.regular)
menü { auswahl }
}
case .knopf:
// **Beschriftung und Wert in einem.** Neben „Abspielen" ist kein
// Platz für eine Zeile mit Spalten; „Ton: Deutsch" sagt dasselbe
// in einem Wort mehr.
menü {
HStack(spacing: FlaroSpacing.tight) {
Image(systemName: kind == .audio ? "waveform" : "captions.bubble")
Text("\(Text(title)): \(currentLabel)")
.font(.flaroCardTitle)
// **Eine Zeile, keine Säule.** Umbrochen wird die
// Reihe, nicht der einzelne Knopf — sonst steht
// „Untertitel" wieder Buchstabe für Buchstabe
// untereinander.
.lineLimit(1)
.fixedSize(horizontal: true, vertical: false)
Image(systemName: "chevron.up.chevron.down")
.font(.flaroCaption)
}
.padding(.horizontal, FlaroSpacing.regular)
.padding(.vertical, FlaroSpacing.snug)
.background(Color.flaroElevated, in: Capsule())
.foregroundStyle(Color.flaroTextPrimary) .foregroundStyle(Color.flaroTextPrimary)
}
}
}
Spacer(minLength: FlaroSpacing.regular) /// Das Menü selbst — zweimal dieselben Einträge, zwei Aufhänger.
private func menü(@ViewBuilder label: () -> some View) -> some View {
Menu { auswahlEintraege } label: { label() }
}
Menu { private var auswahl: some View {
HStack(spacing: FlaroSpacing.tight) {
Text(currentLabel)
.font(.flaroBody)
Image(systemName: "chevron.up.chevron.down")
.font(.flaroCaption)
}
.foregroundStyle(accent)
}
@ViewBuilder
private var auswahlEintraege: some View {
Group {
// „Wie allgemein" zuerst und als Vorgabe: die meisten Ebenen // „Wie allgemein" zuerst und als Vorgabe: die meisten Ebenen
// sollen nichts Eigenes sagen, sondern die Frage nach oben // sollen nichts Eigenes sagen, sondern die Frage nach oben
// durchreichen. // durchreichen.
@@ -43,42 +121,65 @@ struct AudioLanguagePicker: View {
Label("languages.inherit", systemImage: current == nil ? "checkmark" : "") Label("languages.inherit", systemImage: current == nil ? "checkmark" : "")
} }
Divider() // **„Keine" nur beim Untertitel.** Beim Ton gibt es sie
// nicht: ein Film ohne Tonspur ist kein Wunsch, sondern ein
ForEach(LanguagePreferences.offeredCodes, id: \.self) { code in // Fehler.
if kind == .subtitles {
Button { Button {
set(code) set(LanguagePreferences.noSubtitles)
} label: { } label: {
Label(name(of: code), systemImage: current == code ? "checkmark" : "") Label(
"languages.none",
systemImage: current == LanguagePreferences.noSubtitles
? "checkmark" : ""
)
} }
} }
} label: {
HStack(spacing: FlaroSpacing.tight) { Divider()
Text(currentLabel)
.font(.flaroBody) ForEach(options, id: \.code) { option in
Image(systemName: "chevron.up.chevron.down") Button {
.font(.flaroCaption) set(option.code)
} label: {
Label(
option.name,
systemImage: current == option.code ? "checkmark" : ""
)
}
} }
.foregroundStyle(accent) }
} }
/// Was zur Wahl steht — das Vorhandene, sonst die allgemeine Liste.
private var options: [LanguageOption] {
available ?? LanguagePreferences.offeredCodes.map {
LanguageOption(code: $0, name: name(of: $0))
} }
} }
private var current: String? { private var current: String? {
switch scope { switch (scope, kind) {
case .series(let id): languages.audioLanguage(forSeries: id) case (.series(let id), .audio): languages.audioLanguage(forSeries: id)
case .library(let id): languages.audioLanguage(forLibrary: id) case (.series(let id), .subtitles): languages.subtitleLanguage(forSeries: id)
case (.library(let id), .audio): languages.audioLanguage(forLibrary: id)
// Je Mediathek gibt es keine Untertitelsprache — siehe `subtitleWish`.
case (.library, .subtitles): nil
} }
} }
private var currentLabel: String { private var currentLabel: String {
current.map(name(of:)) ?? String(localized: "languages.inherit") guard let current else { return String(localized: "languages.inherit") }
if current == LanguagePreferences.noSubtitles { return String(localized: "languages.none") }
return options.first { $0.code == current }?.name ?? name(of: current)
} }
private func set(_ code: String?) { private func set(_ code: String?) {
switch scope { switch (scope, kind) {
case .series(let id): languages.setAudioLanguage(code, forSeries: id) case (.series(let id), .audio): languages.setAudioLanguage(code, forSeries: id)
case .library(let id): languages.setAudioLanguage(code, forLibrary: id) case (.series(let id), .subtitles): languages.setSubtitleLanguage(code, forSeries: id)
case (.library(let id), .audio): languages.setAudioLanguage(code, forLibrary: id)
case (.library, .subtitles): break
} }
} }
Flaro/Views/Settings/PlaybackSettingsView.swift
+1
View File
@@ -102,6 +102,7 @@ struct PlaybackSettingsView: View {
Section { Section {
Toggle("settings.autoSkipIntro", isOn: $settings.autoSkipIntro) Toggle("settings.autoSkipIntro", isOn: $settings.autoSkipIntro)
Toggle("settings.autoSkipCredits", isOn: $settings.autoSkipCredits) Toggle("settings.autoSkipCredits", isOn: $settings.autoSkipCredits)
Toggle("settings.skipExtraScenes", isOn: $settings.skipExtraScenes)
Toggle("settings.autoPlayNext", isOn: $settings.autoPlayNext) Toggle("settings.autoPlayNext", isOn: $settings.autoPlayNext)
} header: { } header: {
Text("settings.episodes") Text("settings.episodes")
Flaro/Views/SignIn/FlaroSignInView.swift
+176
View File
@@ -0,0 +1,176 @@
import SwiftUI
import FlaroDesign
import FlaroServerKit
/// Die Anmeldung an einem Flaro-Server.
///
/// Zwei Schritte: wo steht er, und wer bist du. Mehr Fragen gibt es nicht —
/// und eine davon beantwortet der Server selbst, indem er seinen Namen nennt.
struct FlaroSignInView: View {
@Environment(FlaroSession.self) private var session
@Environment(\.dismiss) private var dismiss
@Environment(\.flaroAccent) private var accent
@State private var model: FlaroSignInModel?
@FocusState private var focusedField: Field?
private enum Field { case address, userName, password }
var body: some View {
NavigationStack {
ScrollView {
if let model {
content(for: model)
.padding(.horizontal, FlaroSpacing.section)
.padding(.vertical, FlaroSpacing.section)
.frame(maxWidth: 420)
.frame(maxWidth: .infinity)
}
}
.scrollDismissesKeyboard(.interactively)
.background(Color.flaroCanvas)
.navigationTitle(Text("signIn.flaro.title"))
.flaroInlineTitle()
.toolbar {
ToolbarItem(placement: .cancellationAction) {
Button("action.cancel") { dismiss() }
}
}
}
.tint(accent)
.task {
guard model == nil else { return }
let fresh = FlaroSignInModel(identity: session.flaroDeviceIdentity)
fresh.onAuthenticated = { client, konto, token in
dismiss()
Task { await session.adoptFlaro(client: client, account: konto, token: token) }
}
model = fresh
}
}
@ViewBuilder
private func content(for model: FlaroSignInModel) -> some View {
VStack(alignment: .leading, spacing: FlaroSpacing.section) {
switch model.step {
case .address, .checking:
addressStep(model: model)
case .credentials, .signingIn:
credentialsStep(model: model)
case .code:
// **Am Telefon führt der Code nirgendwohin.** Er braucht ein
// zweites, bereits angemeldetes Gerät — und das erste ist
// gerade dieses hier. Das Modell bietet ihn deshalb nur an,
// wenn es mit `preferring: .code` gebaut wurde; am Fernseher
// ist das so, hier nicht. Der Fall steht trotzdem da, weil
// ein `default` die nächste neue Lage verschlucken würde.
EmptyView()
}
if let message = model.errorMessage {
Text(message)
.font(.flaroCaption)
.foregroundStyle(Color.flaroDestructive)
}
}
}
@ViewBuilder
private func addressStep(model: FlaroSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
Text("signIn.flaro.addressPrompt")
.font(.flaroRowHeader)
.foregroundStyle(Color.flaroTextPrimary)
TextField("signIn.flaro.addressPlaceholder", text: $model.address)
.textFieldStyle(.roundedBorder)
.textContentType(.URL)
#if os(iOS)
.keyboardType(.URL)
.textInputAutocapitalization(.never)
#endif
.autocorrectionDisabled()
.focused($focusedField, equals: .address)
.onSubmit { Task { await model.findServer() } }
Text("signIn.flaro.addressHint")
.font(.flaroCaption)
.foregroundStyle(Color.flaroTextMuted)
Button {
Task { await model.findServer() }
} label: {
if model.step == .checking {
ProgressView().frame(maxWidth: .infinity)
} else {
Text("signIn.flaro.findServer").frame(maxWidth: .infinity)
}
}
.buttonStyle(.borderedProminent)
.tint(accent)
.disabled(model.step == .checking)
}
.onAppear { focusedField = .address }
}
@ViewBuilder
private func credentialsStep(model: FlaroSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
if let name = model.serverName {
// Der Name des Servers steht hier, damit sichtbar ist,
// **wo** man sich gleich anmeldet — eine Adresse allein sagt
// das nicht.
HStack {
Text(name)
.font(.flaroRowHeader)
.foregroundStyle(Color.flaroTextPrimary)
Spacer()
Button("signIn.flaro.changeAddress") { model.changeAddress() }
.font(.flaroCaption)
}
}
TextField("signIn.userName", text: $model.userName)
.textFieldStyle(.roundedBorder)
.textContentType(.username)
#if os(iOS)
.textInputAutocapitalization(.never)
#endif
.autocorrectionDisabled()
.focused($focusedField, equals: .userName)
.onSubmit { focusedField = .password }
SecureField("signIn.password", text: $model.password)
.textFieldStyle(.roundedBorder)
.textContentType(.password)
.focused($focusedField, equals: .password)
.onSubmit { Task { await model.signIn() } }
Button {
Task { await model.signIn() }
} label: {
if model.step == .signingIn {
ProgressView().frame(maxWidth: .infinity)
} else {
Text("signIn.flaro.signIn").frame(maxWidth: .infinity)
}
}
.buttonStyle(.borderedProminent)
.tint(accent)
.disabled(model.step == .signingIn)
// Der Pflichthinweis auf TMDB — Bedingung ihrer Lizenz, und der
// Server liefert ihn ohne Anmeldung genau dafür.
ForEach(model.attributions, id: \.text) { hinweis in
Text(hinweis.text)
.font(.flaroCaption)
.foregroundStyle(Color.flaroTextMuted)
}
}
.onAppear { focusedField = .userName }
}
}
Flaro/Views/SignIn/JellyfinSignInView.swift
+2 -2
View File
@@ -184,7 +184,7 @@ struct JellyfinSignInView: View {
VStack(alignment: .leading, spacing: FlaroSpacing.regular) { VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
foundServerHeader(model: model) foundServerHeader(model: model)
TextField("signIn.jellyfin.userName", text: $model.userName) TextField("signIn.userName", text: $model.userName)
.textContentType(.username) .textContentType(.username)
.flaroPlainEntry() .flaroPlainEntry()
.submitLabel(.next) .submitLabel(.next)
@@ -203,7 +203,7 @@ struct JellyfinSignInView: View {
.padding(FlaroSpacing.regular) .padding(FlaroSpacing.regular)
.background(Color.flaroElevated, in: .rect(cornerRadius: FlaroRadius.control)) .background(Color.flaroElevated, in: .rect(cornerRadius: FlaroRadius.control))
SecureField("signIn.jellyfin.password", text: $model.password) SecureField("signIn.password", text: $model.password)
.textContentType(.password) .textContentType(.password)
.submitLabel(.go) .submitLabel(.go)
.focused($focusedField, equals: .password) .focused($focusedField, equals: .password)
Flaro/Views/SignIn/SignInView.swift
+29 -9
View File
@@ -3,16 +3,23 @@ import FlaroDesign
/// Der Anmeldebildschirm. /// Der Anmeldebildschirm.
/// ///
/// **Ein Weg, seit es einen Server gibt.** Hier standen zwei Knöpfe /// **Wieder zwei Knöpfe, und diesmal zu zwei Servern.** Hier standen schon
/// nebeneinander, und der obere war der auffälligere — er führte zu Plex. /// einmal zwei — Plex oben, Jellyfin darunter —, und nach dem Entfernen von
/// Bleibt einer übrig, erbt er die Hervorhebung: ein Knopf, der aussieht wie /// Plex blieb einer übrig. Jetzt gibt es Flaro, und die Frage stellt sich
/// die zweite Wahl, lässt den Benutzer nach der ersten suchen. /// neu: welcher steht oben?
/// ///
/// Jellyfin hat kein Verzeichnis, an dem die eigenen Server hängen. Deshalb /// **Flaro.** Nicht aus Eitelkeit, sondern weil die App dort mehr kann: der
/// wird die Adresse eingetippt und, wann immer der Server es anbietet, ein /// Download bringt alle Tonspuren mit, der Fortschritt wird ab der ersten
/// Code bestätigt statt eines Passworts — das führt `JellyfinSignInView`. /// Sekunde gemerkt. Wer Jellyfin benutzt, sucht gezielt danach — wer neu
/// anfängt, soll nicht in der schwächeren Hälfte landen, weil ihr Knopf
/// auffälliger war.
///
/// Beide Server haben kein Verzeichnis, an dem die eigenen Instanzen hängen.
/// Die Adresse wird deshalb eingetippt; den Rest führen die beiden
/// Anmeldeansichten.
struct SignInView: View { struct SignInView: View {
@Environment(\.flaroAccent) private var accent @Environment(\.flaroAccent) private var accent
@State private var showsFlaroSignIn = false
@State private var showsJellyfinSignIn = false @State private var showsJellyfinSignIn = false
var body: some View { var body: some View {
@@ -37,6 +44,17 @@ struct SignInView: View {
Spacer() Spacer()
VStack(spacing: FlaroSpacing.regular) { VStack(spacing: FlaroSpacing.regular) {
Button {
showsFlaroSignIn = true
} label: {
Text("signIn.withFlaro")
.font(.flaroRowHeader)
.frame(maxWidth: .infinity)
.padding(.vertical, FlaroSpacing.regular)
}
.buttonStyle(.borderedProminent)
.tint(accent)
Button { Button {
showsJellyfinSignIn = true showsJellyfinSignIn = true
} label: { } label: {
@@ -45,8 +63,7 @@ struct SignInView: View {
.frame(maxWidth: .infinity) .frame(maxWidth: .infinity)
.padding(.vertical, FlaroSpacing.regular) .padding(.vertical, FlaroSpacing.regular)
} }
.buttonStyle(.borderedProminent) .buttonStyle(.bordered)
.tint(accent)
Text("signIn.privacy") Text("signIn.privacy")
.font(.flaroCaption) .font(.flaroCaption)
@@ -60,6 +77,9 @@ struct SignInView: View {
.frame(maxWidth: 420) .frame(maxWidth: 420)
.frame(maxWidth: .infinity, maxHeight: .infinity) .frame(maxWidth: .infinity, maxHeight: .infinity)
.background(Color.flaroCanvas) .background(Color.flaroCanvas)
.sheet(isPresented: $showsFlaroSignIn) {
FlaroSignInView()
}
.sheet(isPresented: $showsJellyfinSignIn) { .sheet(isPresented: $showsJellyfinSignIn) {
JellyfinSignInView() JellyfinSignInView()
} }
FlaroTV/FlaroTVApp.swift
+2
View File
@@ -2,6 +2,7 @@ import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroPlayback import FlaroPlayback
import MediaKit import MediaKit
import FlaroServerKit
import JellyfinKit import JellyfinKit
/// Die App auf dem Fernseher. /// Die App auf dem Fernseher.
@@ -45,6 +46,7 @@ struct FlaroTVApp: App {
client: Branding.appName, client: Branding.appName,
version: Branding.version version: Branding.version
), ),
flaroIdentity: FlaroIdentity.current(),
tokenStore: KeychainTokenStore(service: Branding.keychainService) tokenStore: KeychainTokenStore(service: Branding.keychainService)
)) ))
} }
FlaroTV/Views/Home/TVHeroSection.swift
+1 -1
View File
@@ -44,7 +44,7 @@ struct TVHeroSection: View {
/// „Weiterschauen" statt „Abspielen", wenn schon etwas gesehen wurde. /// „Weiterschauen" statt „Abspielen", wenn schon etwas gesehen wurde.
private var abspielTitel: LocalizedStringKey { private var abspielTitel: LocalizedStringKey {
item.watchProgress == nil ? "hero.play" : "hero.resume" item.isResumable ? "hero.resume" : "hero.play"
} }
private var metadaten: String? { private var metadaten: String? {
FlaroTV/Views/Home/TVMediaRow.swift
+2 -2
View File
@@ -55,7 +55,7 @@ struct TVMediaRow: View {
artworkURL: session.backend?.artworkURL( artworkURL: session.backend?.artworkURL(
path: item.rowArtworkPath, width: 880, height: 496 path: item.rowArtworkPath, width: 880, height: 496
), ),
progress: item.watchProgress, progress: item.resumeProgress,
onFocusChange: { if $0 { onFocus(item) } } onFocusChange: { if $0 { onFocus(item) } }
) { onSelect(item) } ) { onSelect(item) }
} else { } else {
@@ -65,7 +65,7 @@ struct TVMediaRow: View {
artworkURL: session.backend?.artworkURL( artworkURL: session.backend?.artworkURL(
path: item.thumb, width: 560, height: 840 path: item.thumb, width: 560, height: 840
), ),
progress: item.watchProgress, progress: item.resumeProgress,
onFocusChange: { if $0 { onFocus(item) } } onFocusChange: { if $0 { onFocus(item) } }
) { onSelect(item) } ) { onSelect(item) }
} }
FlaroTV/Views/Library/TVLibraryView.swift
+1 -1
View File
@@ -78,7 +78,7 @@ struct TVLibraryView: View {
artworkURL: session.backend?.artworkURL( artworkURL: session.backend?.artworkURL(
path: item.posterArtworkPath, width: 560, height: 840 path: item.posterArtworkPath, width: 560, height: 840
), ),
progress: item.watchProgress progress: item.resumeProgress
) { ) {
// **Über QuickPlay, nicht unmittelbar.** Steht im // **Über QuickPlay, nicht unmittelbar.** Steht im
// Raster eine Serie, hat die keine Fassungen; der // Raster eine Serie, hat die keine Fassungen; der
FlaroTV/Views/SignIn/TVFlaroSignInView.swift
+130
View File
@@ -0,0 +1,130 @@
import SwiftUI
import FlaroDesign
import FlaroServerKit
/// Die Anmeldung an einem Flaro-Server, am Fernseher.
///
/// Dasselbe Modell wie am Telefon, nur mit `preferring: .code`: sechs Ziffern
/// auf dem Bildschirm, bestätigt am Telefon. Das Passwort bleibt der Rückfall
/// — für den Fall, dass gerade kein angemeldetes Gerät zur Hand ist.
struct TVFlaroSignInView: View {
@Environment(FlaroSession.self) private var session
let zurueck: () -> Void
@State private var model: FlaroSignInModel?
var body: some View {
Group {
if let model {
inhalt(for: model)
} else {
ProgressView()
}
}
.task {
guard model == nil else { return }
let frisch = FlaroSignInModel(
identity: session.flaroDeviceIdentity, preferring: .code)
frisch.onAuthenticated = { client, konto, token in
Task { await session.adoptFlaro(client: client, account: konto, token: token) }
}
model = frisch
}
.onDisappear { model?.cancel() }
}
@ViewBuilder
private func inhalt(for model: FlaroSignInModel) -> some View {
@Bindable var model = model
VStack(alignment: .leading, spacing: FlaroSpacing.section) {
Text(Branding.appName).font(.flaroHero)
Text("signIn.flaro.title").font(.flaroBody).foregroundStyle(Color.flaroTextMuted)
switch model.step {
case .address:
adresse(model: model)
case .checking:
warten("signIn.flaro.searching")
case .code(let code):
codeAnzeigen(model: model, code: code)
case .credentials:
zugangsdaten(model: model)
case .signingIn:
warten("signIn.flaro.signingIn")
}
if let fehler = model.errorMessage {
Text(fehler).font(.flaroBody).foregroundStyle(Color.flaroDestructive)
}
}
.padding(FlaroSpacing.section)
}
private func adresse(model: FlaroSignInModel) -> some View {
@Bindable var model = model
return VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
Text("signIn.flaro.addressPrompt").font(.flaroRowHeader)
TextField("signIn.flaro.addressPlaceholder", text: $model.address)
.flaroPlainEntry(isAddress: true)
Text("signIn.flaro.addressHint")
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
HStack(spacing: FlaroSpacing.regular) {
Button("signIn.flaro.findServer") { Task { await model.findServer() } }
Button("action.back", action: zurueck)
}
}
}
private func codeAnzeigen(model: FlaroSignInModel, code: String) -> some View {
VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
if let name = model.serverName {
Text(name).font(.flaroRowHeader)
}
// **Der Code ist hier der Inhalt, nicht eine Beschriftung.**
// Er wird aus drei Metern abgelesen und in ein Telefon getippt;
// in Fliesstextgrösse ist das eine Zumutung.
Text(code)
.font(.system(size: 96, weight: .bold, design: .monospaced))
.kerning(12)
.foregroundStyle(.white)
Text("signIn.flaro.codeHint").font(.flaroBody)
Label("signIn.flaro.waitingForApproval", systemImage: "hourglass")
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
HStack(spacing: FlaroSpacing.regular) {
Button("signIn.flaro.usePassword") { model.useCredentials() }
Button("signIn.flaro.changeAddress") { model.changeAddress() }
}
}
}
private func zugangsdaten(model: FlaroSignInModel) -> some View {
@Bindable var model = model
return VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
if let name = model.serverName {
Text(name).font(.flaroRowHeader)
}
TextField("signIn.userName", text: $model.userName)
.flaroPlainEntry()
SecureField("signIn.password", text: $model.password)
HStack(spacing: FlaroSpacing.regular) {
Button("signIn.flaro.signIn") { Task { await model.signIn() } }
Button("signIn.flaro.useCode") { Task { await model.beginCode() } }
Button("signIn.flaro.changeAddress") { model.changeAddress() }
}
}
}
private func warten(_ text: LocalizedStringKey) -> some View {
HStack(spacing: FlaroSpacing.regular) {
ProgressView()
Text(text).font(.flaroBody)
}
}
}
FlaroTV/Views/SignIn/TVSignInView.swift
+42 -18
View File
@@ -1,40 +1,51 @@
import SwiftUI import SwiftUI
import FlaroDesign import FlaroDesign
import FlaroServerKit
import JellyfinKit import JellyfinKit
/// Die Anmeldung am Fernseher. /// Die Anmeldung am Fernseher.
/// ///
/// **Dieselben vier Schritte wie am Telefon, andere Reihenfolge.** Das Modell /// **Erst die Frage, welcher Server.** Seit es zwei gibt, steht sie vorn —
/// `JellyfinSignInModel` ist unverändert dasselbe — nur bekommt es hier /// und Flaro oben, weil die App dort mehr kann.
/// `preferring: .quickConnect`. Vor einem Fernseher ist der Code der bequemere
/// Weg: es gibt keinen Passwortspeicher, getippt wird mit dem Steuerkreuz, und
/// das Gerät, auf dem man den Code bestätigt, liegt sowieso auf dem Sofa.
/// ///
/// Der Weg über Benutzername und Passwort bleibt erreichbar — für Server, auf /// Danach dieselben Schritte wie am Telefon, nur andere Reihenfolge: beide
/// denen Quick Connect abgeschaltet ist. /// Modelle bekommen hier den Code-Weg voran. Vor einem Fernseher ist er der
/// bequemere: es gibt keinen Passwortspeicher, getippt wird mit dem
/// Steuerkreuz, und das Gerät, auf dem man bestätigt, liegt sowieso auf dem
/// Sofa. Benutzername und Passwort bleiben erreichbar.
struct TVSignInView: View { struct TVSignInView: View {
@Environment(FlaroSession.self) private var session @Environment(FlaroSession.self) private var session
@State private var art: FlaroSession.ServerKind?
@State private var model: JellyfinSignInModel? @State private var model: JellyfinSignInModel?
var body: some View { var body: some View {
ZStack { ZStack {
Color.flaroCanvas.ignoresSafeArea() Color.flaroCanvas.ignoresSafeArea()
if let model { Group {
inhalt(for: model) switch art {
// Eine Spalte, nicht die volle Breite: 1760 Punkte Zeile case nil:
// liest sich aus drei Metern nicht mehr als Zeile. auswahl()
.frame(maxWidth: 900) case .flaro:
} else { TVFlaroSignInView(zurueck: { art = nil })
ProgressView() case .jellyfin:
if let model {
inhalt(for: model)
} else {
ProgressView()
}
}
} }
// Eine Spalte, nicht die volle Breite: 1760 Punkte Zeile
// liest sich aus drei Metern nicht mehr als Zeile.
.frame(maxWidth: 900)
} }
.task { .onChange(of: art) { _, neu in
guard neu == .jellyfin, model == nil else { return }
// Erst hier, nicht im Eigenschaftswert: das Modell braucht die // Erst hier, nicht im Eigenschaftswert: das Modell braucht die
// Gerätekennung der Sitzung. Baut es sich eine eigene, steht die // Gerätekennung der Sitzung. Baut es sich eine eigene, steht die
// App nach dem Anmelden ein zweites Mal in der Geräteliste. // App nach dem Anmelden ein zweites Mal in der Geräteliste.
guard model == nil else { return }
let frisch = JellyfinSignInModel( let frisch = JellyfinSignInModel(
identity: session.jellyfinDeviceIdentity, identity: session.jellyfinDeviceIdentity,
preferring: .quickConnect preferring: .quickConnect
@@ -51,6 +62,19 @@ struct TVSignInView: View {
.onDisappear { model?.cancel() } .onDisappear { model?.cancel() }
} }
private func auswahl() -> some View {
VStack(alignment: .leading, spacing: FlaroSpacing.section) {
Text(Branding.appName).font(.flaroHero)
Text("signIn.tagline").font(.flaroBody).foregroundStyle(Color.flaroTextMuted)
VStack(spacing: FlaroSpacing.regular) {
Button("signIn.withFlaro") { art = .flaro }
Button("signIn.withJellyfin") { art = .jellyfin }
}
}
.padding(FlaroSpacing.section)
}
@ViewBuilder @ViewBuilder
private func inhalt(for model: JellyfinSignInModel) -> some View { private func inhalt(for model: JellyfinSignInModel) -> some View {
@Bindable var model = model @Bindable var model = model
@@ -129,9 +153,9 @@ struct TVSignInView: View {
if let name = model.serverName { if let name = model.serverName {
Text(name).font(.flaroRowHeader) Text(name).font(.flaroRowHeader)
} }
TextField("signIn.jellyfin.userName", text: $model.userName) TextField("signIn.userName", text: $model.userName)
.flaroPlainEntry() .flaroPlainEntry()
SecureField("signIn.jellyfin.password", text: $model.password) SecureField("signIn.password", text: $model.password)
Text("signIn.jellyfin.passwordNote") Text("signIn.jellyfin.passwordNote")
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted) .font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
Icon.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.0 MiB

Packages/FlaroKit/Package.swift
+7
View File
@@ -14,6 +14,7 @@ let package = Package(
products: [ products: [
.library(name: "MediaKit", targets: ["MediaKit"]), .library(name: "MediaKit", targets: ["MediaKit"]),
.library(name: "JellyfinKit", targets: ["JellyfinKit"]), .library(name: "JellyfinKit", targets: ["JellyfinKit"]),
.library(name: "FlaroServerKit", targets: ["FlaroServerKit"]),
.library(name: "FlaroDesign", targets: ["FlaroDesign"]), .library(name: "FlaroDesign", targets: ["FlaroDesign"]),
.library(name: "FlaroPlayback", targets: ["FlaroPlayback"]), .library(name: "FlaroPlayback", targets: ["FlaroPlayback"]),
.library(name: "FlaroDownloads", targets: ["FlaroDownloads"]), .library(name: "FlaroDownloads", targets: ["FlaroDownloads"]),
@@ -39,6 +40,12 @@ let package = Package(
resources: [.copy("Fixtures")] resources: [.copy("Fixtures")]
), ),
// Flaros eigener Server. Daneben, nicht darin — genau der Steckplatz,
// den Plex geräumt hat. Dass die Naht zwei Server zugleich trägt, war
// schon einmal bewiesen; hier wird es wieder gebraucht.
.target(name: "FlaroServerKit", dependencies: ["MediaKit"], resources: [.process("Localizable.xcstrings")]),
.testTarget(name: "FlaroServerKitTests", dependencies: ["FlaroServerKit"]),
// Ein Werkzeug für die Fragen, die reines HTTP sind — ohne Oberfläche, // Ein Werkzeug für die Fragen, die reines HTTP sind — ohne Oberfläche,
// ohne Gerät, ohne Upload. Eine Runde dauert damit Sekunden statt // ohne Gerät, ohne Upload. Eine Runde dauert damit Sekunden statt
// eines halben Tages, und das Upload-Kontingent bleibt für Builds. // eines halben Tages, und das Upload-Kontingent bleibt für Builds.
Packages/FlaroKit/Sources/FlaroDesign/Components/ArtworkLoader.swift
+13
View File
@@ -101,6 +101,19 @@ public actor ArtworkLoader {
using session: URLSession, using session: URLSession,
attempts: Int = 3 attempts: Int = 3
) async -> PlatformImage? { ) async -> PlatformImage? {
// **Eine Datei auf der Platte ist kein Server.**
//
// Hier stand nur der Weg über HTTP, und die Antwort einer
// `file:`-Adresse ist keine `HTTPURLResponse` — die Prüfung darunter
// gab also `nil` zurück, immer. Sichtbar wurde das erst, als die
// Downloads ihre Plakate mitbrachten: sie lagen auf der Platte, und
// die Kacheln blieben trotzdem grau. Kein Wiederholen, kein
// Zeitablauf: eine Datei ist entweder da oder nicht.
if url.isFileURL {
guard let data = try? Data(contentsOf: url) else { return nil }
return PlatformImage(data: data)
}
for attempt in 1...attempts { for attempt in 1...attempts {
if Task.isCancelled { return nil } if Task.isCancelled { return nil }
Packages/FlaroKit/Sources/FlaroDesign/Components/Flusszeile.swift
+103
View File
@@ -0,0 +1,103 @@
import SwiftUI
/// Eine Reihe, die umbricht statt zu quetschen.
///
/// **Der Anlass.** Im Kopf einer Detailseite stehen Abspielen, Von vorn,
/// Herunterladen und zwei Sprachknöpfe nebeneinander. In einem `HStack`
/// teilen sie sich die Breite — auf einem Telefon wurde daraus eine Reihe
/// von Säulen aus einzelnen Buchstaben, untereinander gesetzt. Lesbar war
/// nichts mehr, und angetippt hätte man trotzdem das Richtige.
///
/// **Umbrechen ist die Antwort, nicht Weglassen.** Ein Knopf, der auf einem
/// schmalen Gerät verschwindet, ist eine zweite Oberfläche, die gepflegt
/// werden will. Zwei Zeilen sind kein Mangel; sie sind, was dort hinpasst.
///
/// **Warum eigener `Layout` und kein `ViewThatFits`.** Das wählt zwischen
/// fertigen Entwürfen — man müsste jede Aufteilung von Hand hinschreiben,
/// und bei fünf Knöpfen sind das fünf. Hier wird gerechnet.
public struct Flusszeile: Layout {
private let abstand: CGFloat
private let zeilenabstand: CGFloat
public init(abstand: CGFloat = FlaroSpacing.regular, zeilenabstand: CGFloat? = nil) {
self.abstand = abstand
self.zeilenabstand = zeilenabstand ?? abstand
}
public func sizeThatFits(
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Void
) -> CGSize {
let breite = proposal.width ?? .infinity
let zeilen = umbrechen(subviews, in: breite)
let hoehe = zeilen.reduce(CGFloat.zero) { $0 + $1.hoehe }
+ CGFloat(max(0, zeilen.count - 1)) * zeilenabstand
// **Die breiteste Zeile, nicht die angebotene Breite.** Sonst nimmt
// die Reihe das ganze Fenster ein, auch wenn zwei Knöpfe darin
// stehen — und alles daneben rutscht weg.
let genutzt = zeilen.map(\.breite).max() ?? 0
return CGSize(width: min(genutzt, breite), height: hoehe)
}
public func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Void
) {
var y = bounds.minY
for zeile in umbrechen(subviews, in: bounds.width) {
var x = bounds.minX
for index in zeile.teile {
let groesse = subviews[index].sizeThatFits(.unspecified)
subviews[index].place(
at: CGPoint(x: x, y: y + (zeile.hoehe - groesse.height) / 2),
proposal: ProposedViewSize(groesse)
)
x += groesse.width + abstand
}
y += zeile.hoehe + zeilenabstand
}
}
private struct Zeile {
var teile: [Int] = []
var breite: CGFloat = 0
var hoehe: CGFloat = 0
}
private func umbrechen(_ subviews: Subviews, in breite: CGFloat) -> [Zeile] {
var zeilen: [Zeile] = []
var jetzt = Zeile()
for index in subviews.indices {
let groesse = subviews[index].sizeThatFits(.unspecified)
let dazu = jetzt.teile.isEmpty ? groesse.width : jetzt.breite + abstand + groesse.width
// **Das erste Element bleibt immer stehen.** Ein Knopf, der
// allein schon breiter ist als die Zeile, käme sonst in eine
// leere Zeile und von dort in die nächste, endlos.
if !jetzt.teile.isEmpty, dazu > breite {
zeilen.append(jetzt)
jetzt = Zeile()
jetzt.teile = [index]
jetzt.breite = groesse.width
jetzt.hoehe = groesse.height
continue
}
jetzt.teile.append(index)
jetzt.breite = dazu
jetzt.hoehe = max(jetzt.hoehe, groesse.height)
}
if !jetzt.teile.isEmpty { zeilen.append(jetzt) }
return zeilen
}
}
Packages/FlaroKit/Sources/FlaroDesign/Components/HeroBanner.swift
+4 -1
View File
@@ -291,7 +291,10 @@ public struct HeroBanner<Actions: View>: View {
.frame(maxWidth: 640 * scale, alignment: .leading) .frame(maxWidth: 640 * scale, alignment: .leading)
} }
HStack(spacing: FlaroSpacing.regular) { // **Umbrechen statt quetschen.** In einem `HStack` teilen sich
// fünf Knöpfe die Breite; auf einem Telefon wurde daraus eine
// Reihe von Säulen aus einzelnen Buchstaben.
Flusszeile {
actions actions
} }
.padding(.top, FlaroSpacing.tight) .padding(.top, FlaroSpacing.tight)
Packages/FlaroKit/Sources/FlaroDownloads/Engine/DownloadCoordinator.swift
+125
View File
@@ -395,9 +395,16 @@ public final class DownloadCoordinator {
forgetTransfer(item.ratingKey) forgetTransfer(item.ratingKey)
fileStore.remove(fileName: item.localFileName) fileStore.remove(fileName: item.localFileName)
fileStore.remove(fileName: item.artworkFileName) fileStore.remove(fileName: item.artworkFileName)
let serie = item.seriesKey
context.delete(item) context.delete(item)
save() save()
reloadItems() reloadItems()
// **Das Serienplakat geht mit der letzten Folge.** Es hängt an
// keinem Eintrag — ohne diese Zeile bliebe es für immer liegen.
if let serie, !items.contains(where: { $0.seriesKey == serie }) {
fileStore.remove(fileName: fileStore.artworkFileName(forRatingKey: serie))
}
refreshUsage() refreshUsage()
} }
@@ -422,6 +429,58 @@ public final class DownloadCoordinator {
return fileStore.url(forFileName: fileName) return fileStore.url(forFileName: fileName)
} }
/// Das lokale Plakat eines Downloads — `nil`, wenn keines geholt wurde.
///
/// **Weil eine Reihe ohne Bilder keine Reihe ist.** Ohne Verbindung gibt
/// es keine Adresse, von der ein Plakat nachzuladen wäre; was nicht beim
/// Herunterladen mitkam, bleibt eine graue Fläche.
/// **Nach der Datei gefragt, nicht nach dem Eintrag.** Hier wurde erst
/// der Download gesucht und dann sein Dateiname gelesen — damit gab es
/// nur Bilder zu Dingen, die selbst heruntergeladen wurden. Das Plakat
/// einer **Serie** gehört aber keiner einzelnen Folge; es liegt unter
/// dem Serienschlüssel, zu dem es keinen Eintrag gibt und nie geben
/// wird.
public func artworkURL(forRatingKey key: String) -> URL? {
let name = fileStore.artworkFileName(forRatingKey: key)
guard fileStore.exists(fileName: name) else { return nil }
return fileStore.url(forFileName: name)
}
/// Holt das Plakat zu einem Eintrag nach und legt es ab.
///
/// **Beim Anlegen, nicht erst beim Fertigwerden.** Die Liste zeigt den
/// Eintrag, sobald er in der Warteschlange steht; bis dahin wäre sonst
/// nichts zu sehen. Es sind ein paar Kilobyte.
/// Der Schlüssel muss zu keinem Download gehören: unter dem Schlüssel
/// einer Serie liegt ihr Plakat, obwohl die Serie selbst nie
/// heruntergeladen wird.
public func fetchArtwork(for ratingKey: String, from url: URL) async {
let name = fileStore.artworkFileName(forRatingKey: ratingKey)
guard !fileStore.exists(fileName: name) else {
vermerken(name, bei: ratingKey)
return
}
guard let (daten, antwort) = try? await URLSession.shared.data(from: url),
(antwort as? HTTPURLResponse).map({ (200..<300).contains($0.statusCode) }) ?? true,
!daten.isEmpty
else { return }
guard fileStore.store(daten, as: name) != nil else { return }
vermerken(name, bei: ratingKey)
}
/// Hält am Eintrag fest, dass es ein Bild gibt — damit es beim Entfernen
/// mitgeht. Zum Serienschlüssel gibt es keinen Eintrag; dann bleibt die
/// Datei stehen, bis die letzte Folge der Serie geht.
private func vermerken(_ name: String, bei ratingKey: String) {
guard let item = items.first(where: { $0.ratingKey == ratingKey }),
item.artworkFileName != name
else { return }
item.artworkFileName = name
save()
}
public func offlineMedia(forRatingKey key: String) -> OfflineMedia? { public func offlineMedia(forRatingKey key: String) -> OfflineMedia? {
guard let data = items.first(where: { $0.ratingKey == key })?.offlineMediaData else { return nil } guard let data = items.first(where: { $0.ratingKey == key })?.offlineMediaData else { return nil }
return try? JSONDecoder().decode(OfflineMedia.self, from: data) return try? JSONDecoder().decode(OfflineMedia.self, from: data)
@@ -458,6 +517,13 @@ public final class DownloadCoordinator {
} }
} }
/// Wie oft je Eintrag schon auf ein Umpacken gewartet wurde.
///
/// **Im Arbeitsspeicher und nicht im Eintrag.** Nach einem Neustart
/// beginnt das Zählen von vorn — und das ist richtig: der Server hat
/// inzwischen vermutlich fertig gepackt.
private var wartend: [String: Int] = [:]
private func start(_ item: DownloadItem) { private func start(_ item: DownloadItem) {
guard let url = URL(string: item.sourceURLString) else { guard let url = URL(string: item.sourceURLString) else {
fail(item, message: "Ungültige Adresse") fail(item, message: "Ungültige Adresse")
@@ -526,6 +592,7 @@ public final class DownloadCoordinator {
} }
func handleCompletion(ratingKey: String, temporaryFile: URL) { func handleCompletion(ratingKey: String, temporaryFile: URL) {
wartend[ratingKey] = nil
guard let item = items.first(where: { $0.ratingKey == ratingKey }), guard let item = items.first(where: { $0.ratingKey == ratingKey }),
let sourceURL = URL(string: item.sourceURLString) let sourceURL = URL(string: item.sourceURLString)
else { return } else { return }
@@ -608,6 +675,49 @@ public final class DownloadCoordinator {
} }
/// Der Server hat die Anfrage abgelehnt. /// Der Server hat die Anfrage abgelehnt.
/// Wie oft auf ein Umpacken gewartet wird, bevor aufgegeben wird.
///
/// **Grosszügig, und das mit Absicht.** Ein Dreistünder in 4K braucht auf
/// einem NAS Minuten; abzubrechen, während die Arbeit läuft, wäre die
/// eine Antwort, die niemandem hilft. Zwanzig Versuche im Abstand von
/// fünfzehn Sekunden sind fünf Minuten.
private static let hoechstensWarten = 20
private static let wartezeit = Duration.seconds(15)
/// Der Server packt noch um — später noch einmal fragen.
///
/// **Nicht sofort.** Ein Umpacken dauert Minuten, und im Sekundentakt
/// nachzufragen hiesse, dieselbe Datei hundertmal anzufangen und wieder
/// wegzuwerfen.
func handleNotReady(ratingKey: String) {
guard let item = items.first(where: { $0.ratingKey == ratingKey }) else { return }
let versuche = (wartend[ratingKey] ?? 0) + 1
wartend[ratingKey] = versuche
guard versuche <= Self.hoechstensWarten else {
wartend[ratingKey] = nil
fail(item, message: String(localized: "downloads.failed.notReady", bundle: .module))
Task { await startNextIfPossible() }
return
}
// **Zurück in die Warteschlange, nicht in den Fehler.** Es ist
// nichts schiefgegangen; es ist nur noch nicht fertig.
item.state = .waiting
save()
// **Nicht `resume`.** Das nimmt nur auf, was angehalten oder
// gescheitert ist — ein wartender Eintrag lief dort in die
// Schutzklausel und blieb für immer auf „wartet" stehen, während der
// Server längst fertig gepackt hatte. Die Warteschlange abzuarbeiten
// ist das, was hier gebraucht wird: `.waiting` steht darin.
Task { [weak self] in
try? await Task.sleep(for: Self.wartezeit)
await self?.startNextIfPossible()
}
}
func handleServerRejection(ratingKey: String, status: Int) { func handleServerRejection(ratingKey: String, status: Int) {
guard let item = items.first(where: { $0.ratingKey == ratingKey }) else { return } guard let item = items.first(where: { $0.ratingKey == ratingKey }) else { return }
fail(item, message: String(localized: "downloads.failed.status \(status)", bundle: .module)) fail(item, message: String(localized: "downloads.failed.status \(status)", bundle: .module))
@@ -740,6 +850,21 @@ final class DownloadSessionDelegate: NSObject, URLSessionDownloadDelegate, @unch
) { ) {
guard let key = downloadTask.taskDescription else { return } guard let key = downloadTask.taskDescription else { return }
// **202 heisst: noch nicht, komm wieder.**
//
// Der Server packt eine Datei um, die so nicht ausgeliefert werden
// kann, und antwortet währenddessen mit 202 und einem kurzen Text.
// Das ist ein Erfolgscode, also ging er durch die Prüfung darunter
// glatt hindurch: 163 Byte Antworttext lagen danach als Film auf dem
// Gerät, „in einer Sekunde heruntergeladen".
if let response = downloadTask.response as? HTTPURLResponse,
response.statusCode == 202 {
Task { @MainActor [weak coordinator] in
coordinator?.handleNotReady(ratingKey: key)
}
return
}
// `URLSessionDownloadTask` gilt auch bei 404 oder 500 als erfolgreich // `URLSessionDownloadTask` gilt auch bei 404 oder 500 als erfolgreich
// und legt die Fehlerseite als Datei ab. Ohne diese Prüfung wurde eine // und legt die Fehlerseite als Datei ab. Ohne diese Prüfung wurde eine
// zwei Kilobyte große HTML-Seite als fertiger Film verbucht — in einer // zwei Kilobyte große HTML-Seite als fertiger Film verbucht — in einer
Packages/FlaroKit/Sources/FlaroDownloads/Engine/DownloadFileStore.swift
+23
View File
@@ -58,6 +58,29 @@ public struct DownloadFileStore: Sendable {
return "\(key).\(ext)" return "\(key).\(ext)"
} }
/// Der Name des Plakats zu einem Titel.
///
/// **Eine eigene Datei, kein Anhängsel am Film.** Sie ist ein paar
/// Kilobyte gross und wird gebraucht, solange der Eintrag steht — auch
/// während der Film noch lädt und noch gar keine Datei hat.
public func artworkFileName(forRatingKey key: String) -> String { "\(key).bild" }
/// Legt ein geholtes Plakat ab. Schlägt es fehl, gibt es eben keines.
///
/// **Wirft nicht.** Ein Download ohne Bild ist ein Download; ein
/// Download, der am Bild scheitert, wäre keiner.
@discardableResult
public func store(_ data: Data, as name: String) -> URL? {
let ziel = url(forFileName: name)
do {
try createRootIfNeeded()
try data.write(to: ziel, options: .atomic)
return ziel
} catch {
return nil
}
}
/// Verschiebt die fertige Datei aus dem temporären Ordner an ihren Platz. /// Verschiebt die fertige Datei aus dem temporären Ordner an ihren Platz.
/// ///
/// Verschieben, nicht kopieren: iOS löscht die temporäre Datei, sobald der /// Verschieben, nicht kopieren: iOS löscht die temporäre Datei, sobald der
Packages/FlaroKit/Sources/FlaroDownloads/Localizable.xcstrings
+34 -17
View File
@@ -1,6 +1,40 @@
{ {
"sourceLanguage": "en", "sourceLanguage": "en",
"strings": { "strings": {
"downloads.failed.notReady": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Der Server packt diese Datei noch um. Versuch es in ein paar Minuten noch einmal."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The server is still repackaging this file. Try again in a few minutes."
}
}
}
},
"downloads.failed.status %lld": {
"comment": "Der Server hat die Download-Anfrage abgelehnt",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Der Server hat den Download mit Fehler %lld abgelehnt."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The server refused the download with error %lld."
}
}
}
},
"downloads.failed.tooSmall %@": { "downloads.failed.tooSmall %@": {
"comment": "Die heruntergeladene Datei ist zu klein, um ein Video zu sein", "comment": "Die heruntergeladene Datei ist zu klein, um ein Video zu sein",
"localizations": { "localizations": {
@@ -34,23 +68,6 @@
} }
} }
} }
},
"downloads.failed.status %lld": {
"comment": "Der Server hat die Download-Anfrage abgelehnt",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Der Server hat den Download mit Fehler %lld abgelehnt."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "The server refused the download with error %lld."
}
}
}
} }
}, },
"version": "1.0" "version": "1.0"
Packages/FlaroKit/Sources/FlaroPlayback/Engine/AVPlayerEngine.swift
+13
View File
@@ -125,11 +125,24 @@ public final class AVPlayerEngine: VideoPlayerEngine {
pendingStartTime = source.startTime pendingStartTime = source.startTime
// **Cookies muss man AVFoundation ausdrücklich mitgeben.**
//
// `URLSession` liest den gemeinsamen Speicher von allein, `AVURLAsset`
// nicht. Für Jellyfin ist das belanglos — dort steht der Zugang in
// der Adresse. Flaro schreibt ihn bewusst nicht dorthin: er stünde
// sonst in jedem Zugriffsprotokoll und in jedem weitergegebenen Link.
// Ohne diese Zeile bekäme der Spieler dort 401 und zeigte Schwarz.
//
// Serverneutral: wo kein Cookie liegt, ist die Liste leer und es
// ändert sich nichts.
let cookies = HTTPCookieStorage.shared.cookies(for: source.url) ?? []
let asset = AVURLAsset(url: source.url, options: [ let asset = AVURLAsset(url: source.url, options: [
// Keine genaue Dauer verlangen. Sonst durchsucht AVFoundation bei // Keine genaue Dauer verlangen. Sonst durchsucht AVFoundation bei
// manchen Formaten die ganze Datei, bevor es überhaupt anfängt — // manchen Formaten die ganze Datei, bevor es überhaupt anfängt —
// und „ganze Datei" heißt bei einem Remux vierzig Gigabyte. // und „ganze Datei" heißt bei einem Remux vierzig Gigabyte.
AVURLAssetPreferPreciseDurationAndTimingKey: false, AVURLAssetPreferPreciseDurationAndTimingKey: false,
AVURLAssetHTTPCookiesKey: cookies,
]) ])
let item = AVPlayerItem(asset: asset) let item = AVPlayerItem(asset: asset)
Packages/FlaroKit/Sources/FlaroPlayback/Prefetch/StreamCache.swift
+11
View File
@@ -80,6 +80,17 @@ public actor StreamCache {
configuration.urlCache = nil configuration.urlCache = nil
configuration.httpMaximumConnectionsPerHost = 4 configuration.httpMaximumConnectionsPerHost = 4
configuration.timeoutIntervalForRequest = 30 configuration.timeoutIntervalForRequest = 30
// **Die Anmeldung muss mit.**
//
// Eine flüchtige Sitzung bringt ihren eigenen, leeren Cookie-Speicher
// mit — jede Anfrage von hier ging also unangemeldet hinaus. Bei
// Jellyfin fiel das nie auf: dort steht der Schlüssel in der Adresse.
// Flaro meldet über ein Cookie an, und im Protokoll stand genau das:
// `FlaroToken was challenged`, einmal je Wiedergabe, gefolgt von
// zwölf Sekunden Stille und einer zweiten Bestellung.
configuration.httpCookieStorage = HTTPCookieStorage.shared
configuration.httpShouldSetCookies = true
self.session = URLSession(configuration: configuration) self.session = URLSession(configuration: configuration)
self.directory = FileManager.default.temporaryDirectory self.directory = FileManager.default.temporaryDirectory
Packages/FlaroKit/Sources/FlaroServerKit/FlaroAddress.swift
+19
View File
@@ -0,0 +1,19 @@
import Foundation
import MediaKit
/// Die Adressraterei für Flaro.
///
/// Der Inhalt steht in `ServerAddress`. Hier steht nur, was Flaro von
/// Jellyfin unterscheidet: der Port.
public enum FlaroAddress {
/// Der Standardport eines Flaro-Servers.
///
/// 8080, nicht 8096. Die Beispiel-Compose-Datei bildet ihn so ab, und
/// einen fremden Port zu erben hiesse, dass jede Anmeldung einmal ins
/// Leere läuft, bevor sie den richtigen findet.
public static let defaultPort = 8080
public static func candidates(for input: String) -> [URL] {
ServerAddress.candidates(for: input, defaultPort: defaultPort)
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroBackend.swift
+611
View File
@@ -0,0 +1,611 @@
import Foundation
import MediaKit
/// Ein Flaro-Server, gesehen durch `MediaBackend`.
///
/// Der zweite Server an derselben Naht, an der vorher Plex und Jellyfin
/// nebeneinander hingen. Was hier steht, ist die Übersetzung von Flaros
/// Schnittstelle in den Vertrag — nichts weiter: keine Oberfläche, keine
/// Entscheidung über Wiedergabe, keine Zwischenspeicher.
public actor FlaroBackend: MediaBackend {
private let client: FlaroClient
private let account: FlaroAccount
/// Die Mediatheken, einmal geholt.
///
/// Sie ändern sich nur, wenn jemand in der Verwaltung eine anlegt — und
/// jede Seite der Mediathek bräuchte sie sonst erneut, nur um zu wissen,
/// ob sie nach Filmen oder nach Serien fragt.
private var libraryMemo: [MediaLibrary]?
public init(client: FlaroClient, account: FlaroAccount) {
self.client = client
self.account = account
}
// MARK: - Wer dieser Server ist
public nonisolated var serverName: String { account.serverName }
/// **Die Adresse, nicht der Name.** Zwei Server dürfen „Medien" heissen,
/// und derselbe darf umbenannt werden. Was hier steht, überlebt beides.
public nonisolated var identity: String { "flaro:" + account.baseURL.absoluteString }
public nonisolated var capabilities: Set<BackendCapability> {
[
.favourites,
.ratings,
.libraryScan,
.transcoding,
// **Der Grund, aus dem es diesen Server gibt.** Flaros Download
// bringt jede Ton- und Textspur mit; die App muss vorher nichts
// wählen und kann offline umstellen.
.allTracksDownload,
]
}
// MARK: - Blättern
public func libraries() async throws(MediaBackendError) -> [MediaLibrary] {
if let libraryMemo { return libraryMemo }
let roh = try await client.send(FlaroRequest(path: "/api/v1/libraries"), as: [Wire.Library].self)
let liste = roh.map { $0.neutral() }
libraryMemo = liste
return liste
}
public func homeRows() async throws(MediaBackendError) -> [MediaRowGroup] {
// **Mehrere Anfragen, nicht eine.** Flaro hat keinen Endpunkt, der
// eine fertige Startseite liefert, und das ist Absicht: welche Reihen
// eine App zeigt, entscheidet die App. Der Server liefert die Zutaten.
async let weiter = reihe(pfad: "/api/v1/home/continue")
async let naechste = reihe(pfad: "/api/v1/home/next")
let mediatheken = (try? await libraries()) ?? []
var reihen: [MediaRowGroup] = []
if let eintraege = try? await weiter, !eintraege.isEmpty {
reihen.append(MediaRowGroup(
id: "flaro.continue",
title: String(localized: "flaro.row.continue", bundle: .module),
items: eintraege))
}
if let eintraege = try? await naechste, !eintraege.isEmpty {
reihen.append(MediaRowGroup(
id: "flaro.nextup",
title: String(localized: "flaro.row.nextUp", bundle: .module),
items: eintraege))
}
// **Je Mediathek eine Reihe mit dem zuletzt Hinzugefügten.**
//
// Vorher standen hier zwei Reihen, „Filme" und „Serien", mit dem
// Anfang der Mediathek in der Reihenfolge der Datenbank — also immer
// demselben. Drei Dinge waren damit falsch: es war kein Neuzugang,
// es warf getrennte Mediatheken wieder zusammen, und die Kennungen
// begannen nicht mit `latest`. An dieser Vorsilbe hängen zwei
// Einstellungen — „Gesehenes in Neuzugängen ausblenden" und
// „Aufmacher nur aus Neuzugängen" —, und beide taten an einem
// Flaro-Server deshalb nichts.
// **Nebeneinander, nicht nacheinander.**
//
// Hier stand eine Schleife mit `await` darin: bei vier Mediatheken
// vier Rundreisen hintereinander, jede erst nach der vorigen. Die
// Weboberfläche holt dieselben Reihen in einem `Promise.all` — und
// sie holt sogar mehr davon. Genau das war der Unterschied, den man
// der App ansah.
//
// Ein Actor steht dem nicht im Weg: jede Anfrage gibt ihn beim
// Warten wieder frei, so wie die beiden darüber es schon tun.
let neuzugaenge = await withTaskGroup(of: (Int, MediaRowGroup?).self) { gruppe in
for (platz, mediathek) in mediatheken.enumerated() {
gruppe.addTask { (platz, await self.neuzugang(in: mediathek)) }
}
// **Die Reihenfolge der Mediatheken, nicht die der Antworten.**
// Sonst stünden die Reihen nach jedem Start woanders — je
// nachdem, welche Abfrage zuerst zurückkam.
var gesammelt: [(Int, MediaRowGroup?)] = []
for await ergebnis in gruppe { gesammelt.append(ergebnis) }
return gesammelt.sorted { $0.0 < $1.0 }.compactMap(\.1)
}
reihen.append(contentsOf: neuzugaenge)
return reihen
}
/// Die Reihe „Zuletzt hinzugefügt" einer Mediathek — oder nichts.
///
/// **Ein Fehler bei einer Mediathek nimmt nicht die anderen mit.** Die
/// Startseite mit drei von vier Reihen ist besser als gar keine.
private func neuzugang(in mediathek: MediaLibrary) async -> MediaRowGroup? {
let pfad = mediathek.kind == .show ? "/api/v1/series" : "/api/v1/movies"
let abfrage = [
URLQueryItem(name: "library", value: mediathek.id),
URLQueryItem(name: "sort", value: "added"),
URLQueryItem(name: "take", value: "24"),
]
let titel: [MediaItem]
if mediathek.kind == .show {
guard let seite = try? await client.send(
FlaroRequest(path: pfad, query: abfrage),
as: Wire.Page<Wire.Series>.self) else { return nil }
titel = seite.items.map { $0.neutral() }
} else {
guard let seite = try? await client.send(
FlaroRequest(path: pfad, query: abfrage),
as: Wire.Page<Wire.Movie>.self) else { return nil }
titel = seite.items.map { $0.neutral() }
}
guard !titel.isEmpty else { return nil }
return MediaRowGroup(
id: "latest.\(mediathek.id)",
title: String(localized: "flaro.row.latestIn \(mediathek.title)", bundle: .module),
libraryID: mediathek.id,
items: titel)
}
public func availableLanguages(inSeries id: String) async -> AvailableLanguages? {
guard let roh = try? await client.send(
FlaroRequest(path: "/api/v1/series/\(id)/languages"),
as: Wire.Sprachauswahl.self)
else { return nil }
return AvailableLanguages(
audio: roh.audio.map { LanguageOption(code: $0.code, name: $0.name) },
subtitles: roh.subtitles.map { LanguageOption(code: $0.code, name: $0.name) },
partial: roh.partial)
}
public func items(
inLibrary library: MediaLibrary,
query: MediaQuery,
offset: Int,
limit: Int
) async throws(MediaBackendError) -> MediaPage {
var abfrage = [
URLQueryItem(name: "library", value: library.id),
URLQueryItem(name: "skip", value: String(offset)),
URLQueryItem(name: "take", value: String(limit)),
]
if let text = query.searchText, !text.isEmpty {
abfrage.append(URLQueryItem(name: "search", value: text))
}
if library.kind == .show {
let seite = try await client.send(
FlaroRequest(path: "/api/v1/series", query: abfrage),
as: Wire.Page<Wire.Series>.self)
return MediaPage(
items: gesiebt(seite.items.map { $0.neutral() }, query),
offset: offset, totalCount: seite.total)
}
let seite = try await client.send(
FlaroRequest(path: "/api/v1/movies", query: abfrage),
as: Wire.Page<Wire.Movie>.self)
return MediaPage(
items: gesiebt(seite.items.map { $0.neutral() }, query),
offset: offset, totalCount: seite.total)
}
public func item(id: String) async throws(MediaBackendError) -> MediaItem {
// **Erst Film, dann Serie, dann Folge.** Die App reicht eine Kennung
// durch und weiss nicht, was dahintersteckt — sie hat sie aus einer
// Liste. Drei Anfragen im schlechtesten Fall; der Normalfall ist eine.
if let film = try? await client.send(
FlaroRequest(path: "/api/v1/movies/\(id)"), as: Wire.Movie.self) {
return film.neutral()
}
if let serie = try? await client.send(
FlaroRequest(path: "/api/v1/series/\(id)"), as: Wire.Series.self) {
return serie.neutral()
}
// **Und zuletzt eine Folge.**
//
// Sie fehlte, und das war der Grund für „Dieser Titel ist auf dem
// Server nicht mehr vorhanden" direkt von der Startseite: in
// „Weiterschauen" steht eine Folge mit ihrer eigenen Kennung, und die
// ist weder ein Film noch eine Serie.
if let folge = try? await client.send(
FlaroRequest(path: "/api/v1/episodes/\(id)"), as: Wire.Episode.self) {
var serie: Wire.Series?
if let kennung = folge.seriesId {
serie = try? await client.send(
FlaroRequest(path: "/api/v1/series/\(kennung)"), as: Wire.Series.self)
}
return folge.neutral(series: serie)
}
throw .notFound
}
public func children(of id: String) async throws(MediaBackendError) -> [MediaItem] {
try await episodes(inSeries: id)
}
/// Alle Folgen einer Serie — in einer Anfrage.
///
/// Der allgemeine Weg über Staffeln kostete bei zwölf Staffeln dreizehn
/// Anfragen. Flaro kann es in einer, also tut es das.
public func episodes(inSeries id: String) async throws(MediaBackendError) -> [MediaItem] {
let serie = try? await client.send(
FlaroRequest(path: "/api/v1/series/\(id)"), as: Wire.Series.self)
let folgen = try await client.send(
FlaroRequest(path: "/api/v1/series/\(id)/episodes"),
as: Wire.Page<Wire.Episode>.self)
return folgen.items.map { $0.neutral(series: serie) }
}
public func nextEpisode(after item: MediaItem) async throws(MediaBackendError) -> MediaItem? {
try await nachbar(von: item, weg: "next")
}
public func previousEpisode(before item: MediaItem) async throws(MediaBackendError) -> MediaItem? {
try await nachbar(von: item, weg: "previous")
}
/// Die Folge vor oder nach dieser.
///
/// 204 heisst: es gibt keine. Kein Fehler, nur das Ende der Serie —
/// oder ihr Anfang.
private func nachbar(von item: MediaItem, weg: String) async throws(MediaBackendError) -> MediaItem? {
guard item.kind == .episode else { return nil }
let daten = try await client.send(FlaroRequest(path: "/api/v1/episodes/\(item.id)/\(weg)"))
guard !daten.isEmpty else { return nil }
// **Der eingerichtete Dekoder, nicht ein frischer.** Ein frischer
// kennt das Datumsformat des Servers nicht; sobald die Nachbarfolge
// ein `publishAt` oder ein `lastPlayedAt` mitbringt — und mit
// eingeschalteter Prüfung bringt sie es —, scheiterte das Lesen.
// Das `try?` schluckte den Fehler, und von aussen sah es aus, als
// gäbe es keine nächste Folge: der Knopf blieb weg.
guard let folge = try? FlaroClient.decoder.decode(
Wire.Episode.self, from: daten) else { return nil }
return folge.neutral()
}
public func search(_ text: String, limit: Int) async throws(MediaBackendError) -> [MediaRowGroup] {
let abfrage = [
URLQueryItem(name: "search", value: text),
URLQueryItem(name: "take", value: String(limit)),
]
async let filme = client.send(
FlaroRequest(path: "/api/v1/movies", query: abfrage), as: Wire.Page<Wire.Movie>.self)
async let serien = client.send(
FlaroRequest(path: "/api/v1/series", query: abfrage), as: Wire.Page<Wire.Series>.self)
var reihen: [MediaRowGroup] = []
if let gefunden = try? await filme, !gefunden.items.isEmpty {
reihen.append(MediaRowGroup(
id: "flaro.search.movies",
title: String(localized: "flaro.row.movies", bundle: .module),
items: gefunden.items.map { $0.neutral() }))
}
if let gefunden = try? await serien, !gefunden.items.isEmpty {
reihen.append(MediaRowGroup(
id: "flaro.search.series",
title: String(localized: "flaro.row.series", bundle: .module),
items: gefunden.items.map { $0.neutral() }))
}
return reihen
}
/// Flaro kennt noch keine Schlagwörter.
///
/// Eine leere Liste, kein Fehler: die Oberfläche blendet den Filter dann
/// aus, statt einen Knopf zu zeigen, hinter dem nichts ist.
public func filterOptions(
inLibrary library: MediaLibrary,
field: MediaQuery.Field
) async throws(MediaBackendError) -> [MediaFilterOption] { [] }
public func libraryID(for item: MediaItem) async -> String? { nil }
// MARK: - Bilder
/// **Ohne Grössenangabe.** Flaro legt die Bilder so ab, wie TMDB sie
/// liefert, und rechnet nicht um. Ein Plakat wiegt achtzig Kilobyte; ein
/// Server, der jede Kachel einzeln skaliert, spart Leitung und kostet
/// Rechenzeit, die auf einem NAS knapper ist.
/// Wie die Vorschaubilder einer Datei liegen.
///
/// **Der Server erzeugt sie beim Abspielen.** Steht noch nichts da,
/// antwortet er mit `fertig: false` — dann gibt es hier nichts, und
/// der Spieler fragt später noch einmal.
public func vorschauplan(fileId: String) async -> Vorschauplan? {
guard let auskunft = try? await client.send(
FlaroRequest(path: "/api/v1/files/\(fileId)/vorschau"),
as: Wire.Vorschau.self), auskunft.fertig
else { return nil }
return Vorschauplan(
intervall: auskunft.intervall,
spalten: auskunft.spalten,
zeilen: auskunft.zeilen,
kachelBreite: Double(auskunft.kachelBreite),
kachelHoehe: Double(auskunft.kachelHoehe),
blaetter: auskunft.blaetter)
}
/// **Ohne Kopfzeilen, wie bei den Plakaten.** Die Anmeldung hängt am
/// Cookie; der Bildlader holt die Adresse roh und kommt damit durch.
public nonisolated func vorschaublatt(fileId: String, blatt: Int) -> URL? {
client.url(path: "/api/v1/files/\(fileId)/vorschau/\(blatt).jpg")
}
public nonisolated func artworkURL(path: String?, width: Int, height: Int) -> URL? {
rawImageURL(path: path)
}
public nonisolated func rawImageURL(path: String?) -> URL? {
guard let path, !path.isEmpty else { return nil }
return client.url(path: "/api/v1/images/\(path)")
}
// MARK: - Herunterladen
/// **Eine Adresse für alles.** Flaro entscheidet selbst, ob die Datei
/// unverändert hinausgeht oder erst umgepackt wird — und packt dabei
/// *alle* Ton- und Textspuren mit ein.
public nonisolated func downloadURL(for file: MediaFile) -> URL? {
client.url(path: "/api/v1/files/\(file.id)/download")
}
/// **Dieselbe Adresse, und das ist der Punkt.**
///
/// Der Vertrag nimmt hier je eine Spurnummer entgegen, weil Jellyfins
/// Transcoder genau eine Tonspur je Sitzung abbildet. Flaro braucht die
/// Wahl nicht: was herauskommt, hat alles. Die Nummern werden deshalb
/// nicht ignoriert, sondern sind gegenstandslos — und die Oberfläche
/// fragt bei `.allTracksDownload` gar nicht erst danach.
public nonisolated func remuxDownloadURL(
itemID: String,
versionIndex: Int,
audioStreamIndex: Int?,
subtitleStreamIndex: Int?
) -> URL? { nil }
/// Noch nicht da: das Herunterrechnen auf eine Bitrate kommt mit Stufe 3.
public nonisolated func compressedDownloadURL(
itemID: String,
versionIndex: Int,
maximumBitrate: Int,
resolution: String?
) -> URL? { nil }
// MARK: - Abspielen
/// Wie lange auf ein Umpacken gewartet wird, bevor aufgegeben wird.
///
/// Grosszügig: ein Dreistünder in 4K braucht auf einem NAS Minuten, und
/// abzubrechen, während die Arbeit läuft, wäre die eine Antwort, die
/// niemandem hilft. Irgendwann muss es trotzdem eine geben — ein Spieler,
/// der unbegrenzt auf einen hängengebliebenen Prozess wartet, zeigt
/// Schwarz ohne Begründung.
private static let packWartezeit = Duration.seconds(600)
public func preparePlayback(
_ intent: PlaybackIntent
) async throws(MediaBackendError) -> PlaybackTarget {
// **Erst der Strom, und nur bei dessen Scheitern die fertige Datei.**
//
// Hier stand ausschliesslich der zweite Weg: `/download`, und dann
// im Sekundentakt nachfragen, bis die ganze MP4 auf der Platte liegt.
// Gemessen an einem Spielfilm waren das dreissig Sekunden Schwarz,
// während die Weboberfläche nach einer Sekunde lief — die holt sich
// eine HLS-Sitzung, und deren erstes Stück ist beim Umpacken in
// deutlich unter einer Sekunde da.
if let strom = try? await client.send(
.json(.post, "/api/v1/files/\(intent.file.id)/stream", Wire.StreamRequest(
height: intent.transcode?.resolution.flatMap(Self.hoehe),
// Ohne diese Angabe wählt der Server, und bei einem
// umgerechneten Strom kommt danach nur noch eine Spur an.
audioStream: intent.audioStreamIndex,
startSeconds: max(0, intent.startTime.seconds),
// Nur wenn der Spieler es ausdrücklich verlangt: das Profil
// entscheidet der Server, und er entscheidet es besser.
transcode: intent.transcode?.prefersRemux == false
&& intent.transcode?.maximumBitrate != nil)),
as: Wire.Stromauskunft.self),
// **Die Hauptliste, wo es sie gibt.** Nur dort stehen die
// Textspuren; die Medienliste trägt bloss Bild und Ton.
let adresse = client.url(path: strom.masterUrl ?? strom.url)
{
return PlaybackTarget(
url: adresse,
// Eine Direktwiedergabe legt nichts an, das aufzuräumen wäre.
sessionID: strom.method == "direct" ? nil : strom.sessionId,
versionID: intent.file.id,
startOffset: .seconds(strom.startSeconds))
}
return try await mitgenommeneDatei(intent)
}
/// Der alte Weg: warten, bis die fertige Datei auf der Platte liegt.
///
/// **Bleibt als Rückfall.** Er ist langsam, aber er kommt ohne
/// Stromsitzung aus — und wenn die nicht zustande kommt, ist eine späte
/// Wiedergabe besser als keine.
private func mitgenommeneDatei(
_ intent: PlaybackIntent
) async throws(MediaBackendError) -> PlaybackTarget {
guard let adresse = client.url(path: "/api/v1/files/\(intent.file.id)/download") else {
throw .transport(description: "Adresse nicht baubar")
}
var auskunft = try await client.send(
FlaroRequest(path: "/api/v1/files/\(intent.file.id)/delivery"),
as: Wire.Delivery.self)
if let fehler = auskunft.error { throw .refused(reason: fehler) }
// **Erst warten, dann die Adresse herausgeben.**
//
// Muss der Server umpacken, antwortet er auf den Download mit 202 und
// fängt an. AVPlayer bekommt darauf kein Video, sondern eine leere
// Antwort — und wartet. Unbegrenzt, ohne Fehler, mit einem Spinner.
//
// Das Anstossen besorgt der Server beim ersten Abruf selbst; hier
// wird nur nachgefragt, bis es so weit ist.
if auskunft.method != "directFile", auskunft.packageState != "ready" {
let bis = ContinuousClock.now + Self.packWartezeit
while ContinuousClock.now < bis {
// Ein HEAD stösst an und fragt zugleich nach. Die Datei dafür
// herunterzuladen wäre absurd.
_ = try? await client.send(FlaroRequest(
method: .head, path: "/api/v1/files/\(intent.file.id)/download"))
auskunft = try await client.send(
FlaroRequest(path: "/api/v1/files/\(intent.file.id)/delivery"),
as: Wire.Delivery.self)
if let fehler = auskunft.error { throw .refused(reason: fehler) }
if auskunft.packageState == "ready" { break }
try? await Task.sleep(for: .seconds(1))
}
guard auskunft.packageState == "ready" else {
throw .refused(reason: String(
localized: "flaro.remux.tooLong", bundle: .module))
}
}
return PlaybackTarget(url: adresse, sessionID: nil, versionID: intent.file.id)
}
/// „1080p" wird zu 1080 — der Server kennt nur Zahlen.
private static func hoehe(_ aufloesung: String) -> Int? {
Int(aufloesung.filter(\.isNumber))
}
/// Schliesst die Sitzung, damit nichts weiterrechnet.
///
/// **Das war eine leere Methode**, und sie passte zu einer Zeit, in der
/// es gar keine Sitzung gab: eine fertige Datei auf der Platte rechnet
/// nicht weiter. Mit dem Strom gibt es wieder einen Prozess, der ohne
/// diesen Aufruf den ganzen Film zu Ende schreibt, während längst
/// niemand mehr zusieht.
public func endPlayback(sessionID: String) async {
_ = try? await client.send(FlaroRequest(
method: .delete, path: "/api/v1/stream/\(sessionID)"))
}
public func reportProgress(_ report: PlaybackReport) async -> Bool {
// Wirft nicht: eine verlorene Meldung kostet ein paar Sekunden
// Fortschritt, und dafür mitten im Film eine Fehlermeldung zu zeigen
// wäre die schlechtere Hälfte des Tauschs.
//
// Auch `.started` wird gemeldet. Flaro kennt dafür keinen eigenen
// Endpunkt, aber die Stelle ist dieselbe — und sie abzuschneiden
// hiesse, den ersten Bericht wegzuwerfen.
do {
try await client.send(.json(.post, "/api/v1/items/\(report.itemID)/progress",
Wire.ProgressRequest(
positionSeconds: report.time.seconds,
runtimeSeconds: report.duration > .zero ? report.duration.seconds : nil)))
return true
} catch {
return false
}
}
// MARK: - Zustand melden
public func markWatched(id: String) async throws(MediaBackendError) {
try await client.send(.json(.put, "/api/v1/items/\(id)/watched", Wire.WatchedRequest(watched: true)))
}
public func markUnwatched(id: String) async throws(MediaBackendError) {
try await client.send(.json(.put, "/api/v1/items/\(id)/watched", Wire.WatchedRequest(watched: false)))
}
/// Aus „Weiterschauen" nehmen, ohne als gesehen zu gelten.
///
/// **Flaro hat dafür einen eigenen Weg**, und nur deshalb bleibt die
/// Stelle erhalten. Bei Jellyfin wird hier das Benutzerdatenblatt
/// geschrieben, und darin steht auch „gesehen" — wer es nicht mitschickt,
/// löscht es.
public func removeFromContinueWatching(_ item: MediaItem) async throws(MediaBackendError) {
try await client.send(FlaroRequest(method: .post, path: "/api/v1/items/\(item.id)/dismiss"))
}
public func setFavourite(_ isFavourite: Bool, id: String) async throws(MediaBackendError) {
try await client.send(.json(.put, "/api/v1/items/\(id)/favourite",
Wire.FavouriteRequest(favourite: isFavourite)))
}
public func rate(id: String, rating: Int) async throws(MediaBackendError) {
try await client.send(.json(.put, "/api/v1/items/\(id)/rating",
Wire.RatingRequest(rating: rating > 0 ? rating : nil)))
}
public func refreshLibrary(_ library: MediaLibrary) async throws(MediaBackendError) {
try await client.send(FlaroRequest(method: .post, path: "/api/v1/libraries/\(library.id)/scan"))
}
// MARK: - Gemeinsames
private func seite<T: Decodable & Sendable>(
pfad: String, take: Int, as type: T.Type
) async throws(MediaBackendError) -> Wire.Page<T> {
try await client.send(
FlaroRequest(path: pfad, query: [URLQueryItem(name: "take", value: String(take))]),
as: Wire.Page<T>.self)
}
private func reihe(pfad: String) async throws(MediaBackendError) -> [MediaItem] {
let seite = try await client.send(FlaroRequest(path: pfad), as: Wire.Page<Wire.Started>.self)
return seite.items.map { $0.neutral() }
}
/// Was der Server noch nicht kann, siebt die App — aber nur das.
///
/// **Nicht alles.** Gefiltert wird hier über eine *Seite*, nicht über die
/// Mediathek: wer bei fünftausend Titeln „nur ungesehene" wählt, bekommt
/// die ungesehenen der ersten fünfzig. Das ist ein Zwischenstand, kein
/// Entwurf — sobald Flaro die Einschränkung selbst kann, fällt das hier
/// weg. Es jetzt wegzulassen hiesse, einen Schalter anzubieten, der
/// nichts tut.
private func gesiebt(_ titel: [MediaItem], _ query: MediaQuery) -> [MediaItem] {
var liste = titel
if query.unwatchedOnly { liste = liste.filter { !$0.isWatched } }
if query.favouritesOnly { liste = liste.filter(\.isFavourite) }
return liste
}
}
/// Mit wem die App spricht und als wer.
public struct FlaroAccount: Sendable, Equatable {
public let baseURL: URL
public let serverName: String
public let userID: String
public let userName: String
public let isAdministrator: Bool
/// Das eigene Bild, als Schlüssel in die Bildablage — `nil`: der Buchstabe.
///
/// **Mit Vorgabewert, damit Jellyfin unberührt bleibt.** Dort gibt es
/// kein Profilbild, und ein Pflichtfeld hier zwänge jeden Aufrufer, sich
/// dazu zu äussern.
public let avatarImage: String?
public init(
baseURL: URL,
serverName: String,
userID: String,
userName: String,
isAdministrator: Bool,
avatarImage: String? = nil
) {
self.baseURL = baseURL
self.serverName = serverName
self.userID = userID
self.userName = userName
self.isAdministrator = isAdministrator
self.avatarImage = avatarImage
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroClient.swift
+294
View File
@@ -0,0 +1,294 @@
import Foundation
import MediaKit
/// Wer wir für einen Flaro-Server sind.
///
/// Anders als bei Jellyfin steht davon nichts in einer Kopfzeile: Flaro nimmt
/// den Gerätenamen einmal bei der Anmeldung entgegen und führt das Gerät
/// danach über das Token. Die Kennung muss trotzdem über Starts hinweg
/// gleich bleiben — wechselt sie, meldet sich dasselbe Gerät als neues an,
/// und in der Geräteliste sammelt sich Müll.
public struct FlaroIdentity: Sendable, Equatable {
public let deviceName: String
public let deviceID: String
public init(deviceName: String, deviceID: String) {
self.deviceName = deviceName
self.deviceID = deviceID
}
}
/// Spricht mit einem Flaro-Server.
public actor FlaroClient {
public nonisolated let baseURL: URL
private let identity: FlaroIdentity
private let transport: any FlaroTransport
private let cookieJar: (any FlaroCookieJar)?
private var token: String?
public init(
baseURL: URL,
identity: FlaroIdentity,
token: String? = nil,
transport: any FlaroTransport = URLSession.shared,
cookieJar: (any FlaroCookieJar)? = HTTPCookieStorage.shared
) {
self.baseURL = baseURL
self.identity = identity
self.token = token
self.transport = transport
self.cookieJar = cookieJar
if let token { plant(token) }
}
public func setToken(_ token: String?) {
self.token = token
if let token { plant(token) } else { clearCookie() }
}
public nonisolated var deviceID: String { identity.deviceID }
public nonisolated var deviceName: String { identity.deviceName }
// MARK: - Das Cookie
/// Legt den Zugang als Cookie ab, damit auch fremde Lader ihn mitschicken.
///
/// **Warum überhaupt.** Flaro nimmt kein Token in der Adresse — es stünde
/// sonst in jedem Zugriffsprotokoll, in jedem Verlauf und in jedem
/// weitergegebenen Link. Jellyfin macht das anders, und `artworkURL`
/// heisst deshalb im Vertrag ausdrücklich „der Token steckt in der
/// Adresse selbst".
///
/// Bleibt der Weg, den der Browser längst geht: ein Cookie. Der
/// Bilderlader und die Hintergrundübertragung benutzen `URLSession` mit
/// der Standardkonfiguration und schicken es von sich aus mit; dem
/// Systemplayer wird es ausdrücklich mitgegeben (siehe
/// `playbackCookies`), weil AVFoundation den gemeinsamen Speicher nicht
/// von allein liest.
///
/// **Gesetzt, nicht abgewartet.** Der Server schickt es bei der Anmeldung
/// auch selbst — aber nach einem Neustart hat die App nur das Token aus
/// dem Schlüsselbund und meldet sich gar nicht erst neu an. Dann wäre
/// kein Cookie da, und jedes Plakat bliebe grau.
private nonisolated func plant(_ token: String) {
guard let cookie = Self.cookie(for: baseURL, token: token) else { return }
cookieJar?.store(cookie)
}
private nonisolated func clearCookie() {
guard let host = baseURL.host() else { return }
cookieJar?.removeCookie(named: Self.cookieName, host: host)
}
public static let cookieName = "flaro_session"
nonisolated static func cookie(for baseURL: URL, token: String) -> HTTPCookie? {
guard let host = baseURL.host() else { return nil }
return HTTPCookie(properties: [
.name: cookieName,
.value: token,
.domain: host,
.path: "/",
// Ein Jahr, wie der Server es auch setzt. Kürzer hiesse: das
// Plakat lädt nicht mehr, obwohl das Token noch gilt.
.expires: Date(timeIntervalSinceNow: 365 * 24 * 3600),
])
}
/// Die Cookies, die der Systemplayer für diese Adresse mitschicken soll.
public nonisolated func cookies(for url: URL, token: String?) -> [HTTPCookie] {
guard let token, let cookie = Self.cookie(for: url, token: token) else { return [] }
return [cookie]
}
// MARK: - Adressen
/// Die Adresse eines Endpunkts.
///
/// **Ohne Token.** Das ist der Unterschied zu Jellyfin und kein Versehen —
/// wer die Adresse abruft, bringt das Cookie mit.
public nonisolated func url(path: String, query: [URLQueryItem] = []) -> URL? {
guard var components = URLComponents(
url: baseURL.appending(path: path),
resolvingAgainstBaseURL: false
) else { return nil }
components.queryItems = query.isEmpty ? nil : query
return components.url
}
// MARK: - Anfragen
public func send<Value: Decodable & Sendable>(
_ request: FlaroRequest,
as type: Value.Type
) async throws(MediaBackendError) -> Value {
let data = try await send(request)
do {
return try Self.decoder.decode(Value.self, from: data)
} catch {
throw .decoding(description: String(describing: error))
}
}
@discardableResult
public func send(_ request: FlaroRequest) async throws(MediaBackendError) -> Data {
guard var components = URLComponents(
url: baseURL.appending(path: request.path),
resolvingAgainstBaseURL: false
) else {
throw .transport(description: "Adresse nicht baubar")
}
components.queryItems = request.query.isEmpty ? nil : request.query
guard let url = components.url else {
throw .transport(description: "Adresse nicht baubar")
}
var urlRequest = URLRequest(url: url)
urlRequest.httpMethod = request.method.rawValue
urlRequest.timeoutInterval = request.timeout.seconds
// Die App schickt die Kopfzeile. Das Cookie ist der zweite Weg zum
// selben Token, für Lader, die keine Kopfzeilen können.
if let token { urlRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
urlRequest.setValue("application/json", forHTTPHeaderField: "Accept")
if let body = request.body {
urlRequest.httpBody = body
urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
}
let data: Data
let response: URLResponse
do {
(data, response) = try await transport.data(for: urlRequest)
} catch {
throw .transport(description: error.localizedDescription)
}
guard let http = response as? HTTPURLResponse else {
throw .transport(description: "Keine HTTP-Antwort")
}
switch http.statusCode {
case 200..<300: return data
case 401, 403: throw .unauthorized
case 404: throw .notFound
default:
// **Flaro begründet seine Absagen.** Ein Problem-Dokument nach
// RFC 9457 trägt einen Satz, den der Server selbst formuliert
// hat — und der ist mehr wert als die Zahl davor. Genau daran
// hing beim Live-TV tagelang alles, weil die Antwort weggeworfen
// wurde.
if let grund = Self.begruendung(in: data) { throw .refused(reason: grund) }
throw .server(status: http.statusCode)
}
}
/// Der Satz aus einem Problem-Dokument, falls einer dasteht.
private static func begruendung(in data: Data) -> String? {
struct Problem: Decodable { let detail: String?; let title: String? }
guard let problem = try? JSONDecoder().decode(Problem.self, from: data) else { return nil }
let text = problem.detail ?? problem.title
return text?.isEmpty == false ? text : nil
}
/// Flaro schreibt klein und rechnet in Sekunden.
///
/// Kein `convertFromSnakeCase`: die Felder heissen schon so, wie sie
/// heissen sollen. ASP.NET Core schreibt sie in `camelCase` hinaus, und
/// Swift liest sie genauso.
///
/// Nicht `private`, damit die Prüfungen denselben Dekoder benutzen. Mit
/// einem frisch gebauten `JSONDecoder()` scheitern sie — und zwar an
/// genau dem Datumsformat, für das die Strategie unten da ist.
static let decoder: JSONDecoder = {
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601WithFraction
return decoder
}()
}
/// Eine Anfrage an Flaro.
public struct FlaroRequest: Sendable {
public enum Method: String, Sendable { case get = "GET", head = "HEAD", post = "POST", put = "PUT", delete = "DELETE" }
public let method: Method
public let path: String
public let query: [URLQueryItem]
public let body: Data?
public let timeout: Duration
public init(
method: Method = .get,
path: String,
query: [URLQueryItem] = [],
body: Data? = nil,
timeout: Duration = .seconds(30)
) {
self.method = method
self.path = path
self.query = query
self.body = body
self.timeout = timeout
}
/// Eine Anfrage mit einem Rumpf aus einem beliebigen Wert.
public static func json(
_ method: Method, _ path: String, _ value: some Encodable
) -> FlaroRequest {
FlaroRequest(method: method, path: path, body: try? JSONEncoder().encode(value))
}
}
/// Wie Anfragen tatsächlich verschickt werden.
///
/// Dieselbe Trennung wie bei Jellyfin: Tests brauchen keinen Server, sondern
/// vorbereitete Antworten.
public protocol FlaroTransport: Sendable {
func data(for request: URLRequest) async throws -> (Data, URLResponse)
}
extension URLSession: FlaroTransport {}
/// Wo Cookies landen.
///
/// Eigenes Protokoll, damit ein Test nachsehen kann, ob eines abgelegt wurde,
/// ohne den Cookie-Speicher des ganzen Systems anzufassen.
public protocol FlaroCookieJar: Sendable {
func store(_ cookie: HTTPCookie)
func removeCookie(named name: String, host: String)
}
extension HTTPCookieStorage: FlaroCookieJar {
public func store(_ cookie: HTTPCookie) { setCookie(cookie) }
public func removeCookie(named name: String, host: String) {
cookies?
.filter { $0.name == name && $0.domain.hasSuffix(host) }
.forEach(deleteCookie)
}
}
extension JSONDecoder.DateDecodingStrategy {
/// ASP.NET Core schreibt Bruchteile von Sekunden mit.
///
/// `.iso8601` kommt damit nicht zurecht und wirft — ein Datum, das
/// „2026-10-03T19:25:04.5209555+00:00" lautet, ist für den
/// Standarddekoder kein Datum. Der Fehler fällt erst dort auf, wo ein
/// Feld gelesen wird, das die meisten Antworten leer lassen.
static var iso8601WithFraction: Self {
.custom { decoder in
let text = try decoder.singleValueContainer().decode(String.self)
let mitBruch = ISO8601DateFormatter()
mitBruch.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
if let datum = mitBruch.date(from: text) { return datum }
let ohne = ISO8601DateFormatter()
ohne.formatOptions = [.withInternetDateTime]
if let datum = ohne.date(from: text) { return datum }
throw DecodingError.dataCorrupted(.init(
codingPath: decoder.codingPath,
debugDescription: "Kein ISO-8601-Datum: \(text)"))
}
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroContracts.swift
+276
View File
@@ -0,0 +1,276 @@
import Foundation
/// Was Flaro über die Leitung schickt.
///
/// Ein Spiegel der `Contracts.cs` auf der Serverseite, und nur das: hier wird
/// nichts gerechnet und nichts gedeutet. Die Übersetzung in die neutralen
/// Typen steht in `FlaroBackend+Mapping`.
///
/// **Die Felder heissen wie dort.** Keine `CodingKeys`, keine Umbenennung:
/// ASP.NET Core schreibt `camelCase`, Swift liest `camelCase`, und jede
/// Abweichung wäre eine Stelle, an der beim nächsten Serverfeld jemand
/// nachziehen müsste.
enum Wire {
struct Page<T: Decodable & Sendable>: Decodable, Sendable {
let items: [T]
let total: Int
}
struct SystemInfo: Decodable, Sendable {
let version: String?
let serverName: String?
let needsSetup: Bool
let attributions: [Attribution]?
}
struct Attribution: Decodable, Sendable {
let text: String
let logoUrl: String
let url: String
}
struct LoginResponse: Decodable, Sendable {
let token: String
let user: User
}
struct User: Decodable, Sendable {
let id: String
let userName: String
let isAdministrator: Bool
/// Das Profilbild, als Schlüssel in die Bildablage des Servers.
let avatarImage: String?
}
struct Library: Decodable, Sendable {
let id: String
let name: String
let kind: String
let path: String
}
struct Stream: Decodable, Sendable {
let index: Int
let kind: String
let codec: String?
let language: String?
let title: String?
let isDefault: Bool
let isForced: Bool
let channels: Int?
let width: Int?
let height: Int?
}
struct File: Decodable, Sendable {
let id: String
let fileName: String
let sizeBytes: Int64
let container: String?
let durationSeconds: Double?
let streams: [Stream]
}
struct ItemState: Decodable, Sendable {
let positionSeconds: Double
let runtimeSeconds: Double?
let watched: Bool
let playCount: Int
let favourite: Bool
let rating: Int?
let dismissed: Bool
let lastPlayedAt: Date?
/// Ob der Server den Titel in „Weiterschauen" führt.
///
/// **Nicht dasselbe wie „Stelle über null".** Seit es eine
/// einstellbare Untergrenze gibt, sind das zwei Fragen: eine Sekunde
/// wird gemerkt, zählt aber nicht als angefangen.
let inProgress: Bool?
}
struct Movie: Decodable, Sendable {
let id: String
let title: String
let year: Int?
let overview: String?
let posterImage: String?
let backdropImage: String?
/// Das Bild, das jetzt im Aufmacher gilt — vom Server gewählt.
let heroImage: String?
let files: [File]
let state: ItemState?
/// Ab wann abspielbar. In der Zukunft heisst: noch nicht.
let publishAt: Date?
/// Der Abspann, sofern er im Bild gefunden wurde.
let markers: [Marker]?
}
struct Series: Decodable, Sendable {
let id: String
let title: String
let year: Int?
let overview: String?
let posterImage: String?
let backdropImage: String?
/// Das Bild, das jetzt im Aufmacher gilt — vom Server gewählt.
let heroImage: String?
let episodeCount: Int
let seasons: [Int]
let unwatchedCount: Int
let publishAt: Date?
}
struct Episode: Decodable, Sendable {
let id: String
let season: Int
let episode: Int
let title: String?
let overview: String?
let stillImage: String?
let files: [File]
let state: ItemState?
let publishAt: Date?
/// Zu welcher Serie sie gehört — ohne das ist eine Folge für sich
/// nicht darstellbar: Titel und Bild der Serie fehlten.
let seriesId: String?
/// Vorspann und Abspann, sofern der Server sie gefunden hat.
///
/// Fehlt bei älteren Servern ganz — deshalb optional und nicht eine
/// leere Liste: ein `[]` im Vertrag zwänge jeden Server, das Feld zu
/// schicken.
let markers: [Marker]?
}
/// Ein überspringbarer Abschnitt.
struct Marker: Decodable, Sendable {
/// „intro" oder „credits" — dieselben Wörter wie bei Jellyfin.
let kind: String
let startSeconds: Double
let endSeconds: Double
}
/// Eine Kachel aus „Weiterschauen" oder „Nächste Folge".
struct Started: Decodable, Sendable {
let id: String
let kind: String
let title: String
let subTitle: String?
let season: Int?
let episode: Int?
let year: Int?
let posterImage: String?
let backdropImage: String?
/// Das Bild, das jetzt im Aufmacher gilt — vom Server gewählt.
let heroImage: String?
let state: ItemState
/// Zu welcher Serie die Folge gehört.
let seriesId: String?
/// Das breite Bild der Serie — für den Aufmacher, nicht für die
/// Kachel: die will das Standbild der Folge.
let seriesBackdropImage: String?
let publishAt: Date?
}
struct CodeResponse: Decodable, Sendable {
let code: String
let handle: String
let expiresAt: Date
}
/// `state` ist „pending", „approved" oder „expired".
struct CodeState: Decodable, Sendable {
let state: String
let login: LoginResponse?
}
struct CodeRequest: Encodable, Sendable {
let deviceName: String
let deviceId: String
}
struct Delivery: Decodable, Sendable {
let method: String
let reasons: [String]
let audioToEncode: [Int]
let subtitlesDropped: [Int]
let packageState: String
let progress: Double
let error: String?
}
// --- Was hinausgeht --------------------------------------------------
/// Was das Gerät kann und was gewünscht ist.
///
/// **Ohne Codec-Angaben nimmt der Server Apples Profil an**, und das ist
/// hier genau richtig: dieses Gerät *ist* Apple. Eine eigene Liste wäre
/// eine zweite Wahrheit neben der, die der Server ohnehin pflegt.
struct StreamRequest: Encodable, Sendable {
var height: Int?
var audioStream: Int?
var startSeconds: Double
var transcode: Bool
}
struct Stromspur: Decodable, Sendable {
let index: Int
let label: String
let language: String?
let isDefault: Bool
}
struct Stromauskunft: Decodable, Sendable {
let sessionId: String
let url: String
/// Dieselbe Wiedergabe mit Untertitelspuren — fehlt bei Direktwiedergabe.
let masterUrl: String?
/// „direct", „remux" oder „transcode".
let method: String
/// Ab welcher Sekunde des Films dieser Strom beginnt.
let startSeconds: Double
let height: Int?
let audioStream: Int?
let audioStreams: [Stromspur]
let subtitleStreams: [Stromspur]
}
struct Sprachangabe: Decodable, Sendable {
let code: String
let name: String
}
struct Sprachauswahl: Decodable, Sendable {
let audio: [Sprachangabe]
let subtitles: [Sprachangabe]
let partial: Int
}
struct LoginRequest: Encodable, Sendable {
let userName: String
let password: String
let deviceName: String
let deviceId: String
}
struct ProgressRequest: Encodable, Sendable {
let positionSeconds: Double
let runtimeSeconds: Double?
}
struct WatchedRequest: Encodable, Sendable { let watched: Bool }
struct FavouriteRequest: Encodable, Sendable { let favourite: Bool }
struct RatingRequest: Encodable, Sendable { let rating: Int? }
}
extension Wire {
/// Was der Server über die Vorschaubilder sagt.
struct Vorschau: Decodable, Sendable {
let fertig: Bool
let intervall: Double
let spalten: Int
let zeilen: Int
let kachelBreite: Int
let kachelHoehe: Int
let blaetter: Int
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroIdentity+Current.swift
+39
View File
@@ -0,0 +1,39 @@
import Foundation
#if canImport(UIKit)
import UIKit
#endif
extension FlaroIdentity {
private static let storageKey = "flaro.flaroServer.deviceID"
/// Baut die Kennung für das laufende Gerät und merkt sie sich.
///
/// **Eine eigene, nicht die von Jellyfin.** Beide Server führen eigene
/// Geräteverzeichnisse; dieselbe Kennung doppelt zu vergeben hiesse, dass
/// ein Widerruf auf dem einen Server im anderen verwirrt — und wer von
/// Jellyfin zu Flaro wechselt, hinterliesse auf dem alten Server ein
/// Gerät, das es dort gar nicht mehr gibt.
///
/// Gleichbleiben muss sie trotzdem: wechselt sie, gilt die App als neues
/// Gerät, und in der Liste steht bei jedem Start ein Eintrag mehr.
///
/// `@MainActor`, weil `UIDevice.current` dort beheimatet ist.
@MainActor
public static func current(defaults: UserDefaults = .standard) -> FlaroIdentity {
let deviceID: String
if let stored = defaults.string(forKey: storageKey) {
deviceID = stored
} else {
deviceID = UUID().uuidString
defaults.set(deviceID, forKey: storageKey)
}
#if canImport(UIKit)
let name = UIDevice.current.name
#else
let name = ProcessInfo.processInfo.hostName
#endif
return FlaroIdentity(deviceName: name, deviceID: deviceID)
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroMapping.swift
+214
View File
@@ -0,0 +1,214 @@
import Foundation
import MediaKit
/// Aus Flaros Antworten werden neutrale Typen.
///
/// Die einzige Stelle, an der Flaros Schreibweise in die der App übersetzt
/// wird. Alles darüber kennt nur noch `MediaItem`.
extension Wire.Movie {
func neutral() -> MediaItem {
MediaItem(
id: id,
kind: .movie,
title: title,
summary: overview,
year: year,
duration: files.first?.durationSeconds.map { Int($0 * 1000) },
thumb: posterImage,
art: backdropImage,
heroArt: heroImage,
playCount: state?.playCount,
resumeMilliseconds: state.map { Int($0.positionSeconds * 1000) },
lastPlayedAt: state?.lastPlayedAt,
isFavourite: state?.favourite ?? false,
isInProgress: state?.inProgress,
availableFrom: publishAt,
versions: [Wire.fassung(id: id, files: files)],
// **Nur der Abspann.** Einen Vorspann gibt es bei einem Film
// nicht zu finden: erkannt wird er daran, dass er sich über
// die Folgen einer Staffel wiederholt.
markers: (markers ?? []).map {
MediaMarker(
kind: MediaMarker.Kind(rawValue: $0.kind) ?? .unknown,
startMilliseconds: Int($0.startSeconds * 1000),
endMilliseconds: Int($0.endSeconds * 1000))
}
)
}
}
extension Wire.Series {
func neutral() -> MediaItem {
MediaItem(
id: id,
kind: .show,
title: title,
summary: overview,
year: year,
thumb: posterImage,
art: backdropImage,
heroArt: heroImage,
// **Gesehene Folgen, nicht ungesehene.** Der Server zählt, was
// offen ist — die App zeigt daraus die Plakette, rechnet aber
// intern mit der Gegenzahl. Beides anzubieten hiesse, zwei Wege
// zu derselben Aussage zu haben.
availableFrom: publishAt,
episodeCount: episodeCount,
playedEpisodeCount: episodeCount - unwatchedCount,
childCount: seasons.count
)
}
}
extension Wire.Episode {
func neutral(series: Wire.Series? = nil) -> MediaItem {
MediaItem(
id: id,
kind: .episode,
title: title ?? "Folge \(episode)",
summary: overview,
duration: files.first?.durationSeconds.map { Int($0 * 1000) },
thumb: stillImage,
seriesThumb: series?.posterImage,
seriesArt: series?.backdropImage,
index: episode,
parentIndex: season,
seriesTitle: series?.title,
// Die Serie aus dem Vertrag, wenn sie nicht mitgegeben wurde:
// ohne sie führte der Weg zurück zur Serie ins Leere.
seriesID: series?.id ?? seriesId,
playCount: state?.playCount,
resumeMilliseconds: state.map { Int($0.positionSeconds * 1000) },
lastPlayedAt: state?.lastPlayedAt,
isFavourite: state?.favourite ?? false,
isInProgress: state?.inProgress,
availableFrom: publishAt,
versions: [Wire.fassung(id: id, files: files)],
// **Vorspann und Abspann, wenn der Server sie kennt.**
// Ältere Server schicken das Feld gar nicht; dann ist die
// Liste leer und die Spieler zeigen schlicht keinen Knopf.
markers: (markers ?? []).map {
MediaMarker(
kind: MediaMarker.Kind(rawValue: $0.kind) ?? .unknown,
startMilliseconds: Int($0.startSeconds * 1000),
endMilliseconds: Int($0.endSeconds * 1000))
}
)
}
}
extension Wire.Started {
/// Die Kachel aus „Weiterschauen" als Titel.
///
/// **Ohne Fassungen.** Die Reihe nennt keine Dateien, und das ist
/// richtig so: eine Kachel zeigt Plakat, Titel und Balken. Wer sie
/// antippt, holt den Titel einzeln — und bekommt dann alles.
func neutral() -> MediaItem {
let folge = kind == "episode"
return MediaItem(
id: id,
kind: folge ? .episode : .movie,
title: folge ? (subTitle ?? "Folge \(episode ?? 0)") : title,
year: year,
duration: state.runtimeSeconds.map { Int($0 * 1000) },
thumb: folge ? backdropImage : posterImage,
// **Für die Fläche über den halben Bildschirm das Bild der
// Serie.** `backdropImage` ist bei einer Folge ihr Standbild —
// richtig für die Kachel, falsch für den Aufmacher: wer der
// Serie ein Bild ausgesucht hatte, fand dort ein anderes vor.
art: folge ? (seriesBackdropImage ?? backdropImage) : backdropImage,
seriesThumb: folge ? posterImage : nil,
heroArt: heroImage,
index: episode,
parentIndex: season,
seriesTitle: folge ? title : nil,
seriesID: folge ? seriesId : nil,
playCount: state.playCount,
resumeMilliseconds: Int(state.positionSeconds * 1000),
lastPlayedAt: state.lastPlayedAt,
isFavourite: state.favourite,
isInProgress: state.inProgress,
availableFrom: publishAt
)
}
}
extension Wire.Library {
func neutral() -> MediaLibrary {
MediaLibrary(
id: id,
title: name,
// Flaro kennt genau zwei Arten. Was es nicht gibt, als `.other`
// durchzulassen wäre eine Vorsorge für einen Fall, den der
// Server gar nicht erzeugen kann.
kind: kind.lowercased() == "shows" ? .show : .movie)
}
}
extension Wire.File {
func neutral(itemID: String) -> MediaFile {
MediaFile(
id: id,
key: "/api/v1/files/\(id)/download",
itemID: itemID,
container: container,
size: sizeBytes,
duration: durationSeconds.map { Int($0 * 1000) },
file: fileName,
streams: streams.map { $0.neutral() })
}
}
extension Wire.Stream {
func neutral() -> MediaStream {
let art: MediaStream.Kind = switch kind.lowercased() {
case "video": .video
case "subtitle": .subtitle
default: .audio
}
return MediaStream(
// **Die Spurnummer ist die Kennung.** `MediaStream.index` liest
// sie aus `id` zurück, und daran hängt die Spurwahl beim
// Umpacken. Eine eigene Kennung wäre hier eine, die niemand
// zurückrechnen kann.
id: String(index),
kind: art,
codec: codec,
language: language,
languageCode: language,
displayTitle: title ?? language,
channels: channels,
isSelected: isDefault,
isForced: isForced,
title: title,
isDefault: isDefault)
}
}
extension Wire {
/// Eine Fassung aus den Dateien eines Titels.
///
/// **Alle Dateien in einer Fassung**, nicht eine Fassung je Datei: Flaro
/// führt mehrere Dateien zu einem Titel als Fassungen desselben Films —
/// 4K und 1080p nebeneinander — und `MediaVersion.files` ist genau dafür
/// da. Die Eckdaten kommen aus der ersten Datei; welche gespielt wird,
/// entscheidet die App.
static func fassung(id: String, files: [Wire.File]) -> MediaVersion {
let erste = files.first
let bild = erste?.streams.first { $0.kind.lowercased() == "video" }
let ton = erste?.streams.first { $0.kind.lowercased() == "audio" }
return MediaVersion(
id: erste?.id ?? id,
container: erste?.container,
videoCodec: bild?.codec,
audioCodec: ton?.codec,
videoResolution: bild?.height.map(String.init),
width: bild?.width,
height: bild?.height,
audioChannels: ton?.channels,
duration: erste?.durationSeconds.map { Int($0 * 1000) },
files: files.map { $0.neutral(itemID: id) })
}
}
Packages/FlaroKit/Sources/FlaroServerKit/FlaroSignIn.swift
+198
View File
@@ -0,0 +1,198 @@
import Foundation
import MediaKit
/// Die Anmeldung an einem Flaro-Server.
///
/// Getrennt vom Backend, weil sie vorher stattfindet: hier gibt es noch
/// keinen Zugang und nichts, was `MediaBackend` versprechen könnte.
public enum FlaroSignIn {
/// Was der Server über sich sagt, bevor sich jemand anmeldet.
public struct Greeting: Sendable, Equatable {
public let serverName: String
public let version: String?
/// Ob der Server überhaupt schon eingerichtet ist.
///
/// **Ein eigener Fall, keine Fehlermeldung.** Wer einen frischen
/// Server anspricht, hat kein Konto — und „Benutzername oder
/// Passwort stimmt nicht" wäre dann die unbrauchbarste aller
/// Antworten.
public let needsSetup: Bool
/// Der Pflichthinweis auf die Metadatenquelle.
public let attributions: [MetadataAttribution]
}
public struct MetadataAttribution: Sendable, Equatable {
public let text: String
public let logoURL: URL?
public let url: URL?
}
/// Fragt einen Server, wer er ist — ohne Anmeldung.
///
/// Das ist zugleich die Prüfung, ob unter der eingegebenen Adresse
/// überhaupt ein Flaro steht. Ein Jellyfin antwortet hier mit 404, ein
/// Router mit seiner Anmeldeseite, und beides fällt beim Lesen auf.
public static func greet(
baseURL: URL,
identity: FlaroIdentity,
transport: any FlaroTransport = URLSession.shared
) async throws(MediaBackendError) -> Greeting {
let client = FlaroClient(
baseURL: baseURL, identity: identity, transport: transport, cookieJar: nil)
let auskunft = try await client.send(
FlaroRequest(path: "/api/v1/system/info"), as: Wire.SystemInfo.self)
return Greeting(
serverName: auskunft.serverName ?? baseURL.host() ?? "Flaro",
version: auskunft.version,
needsSetup: auskunft.needsSetup,
attributions: (auskunft.attributions ?? []).map {
MetadataAttribution(
text: $0.text, logoURL: URL(string: $0.logoUrl), url: URL(string: $0.url))
})
}
/// Meldet an und liefert den Zugang samt fertigem Backend.
public static func signIn(
baseURL: URL,
userName: String,
password: String,
identity: FlaroIdentity,
transport: any FlaroTransport = URLSession.shared,
cookieJar: (any FlaroCookieJar)? = HTTPCookieStorage.shared
) async throws(MediaBackendError) -> (token: String, account: FlaroAccount, client: FlaroClient) {
let gruss = try await greet(baseURL: baseURL, identity: identity, transport: transport)
let client = FlaroClient(
baseURL: baseURL, identity: identity, transport: transport, cookieJar: cookieJar)
let antwort = try await client.send(
.json(.post, "/api/v1/auth/login", Wire.LoginRequest(
userName: userName,
password: password,
deviceName: identity.deviceName,
deviceId: identity.deviceID)),
as: Wire.LoginResponse.self)
// **Erst jetzt das Token setzen.** Vorher hätte die Anmeldung ihre
// eigene Kopfzeile mitgeschickt — harmlos, aber auch das Cookie wäre
// dann schon gesetzt, bevor feststeht, dass es gilt.
await client.setToken(antwort.token)
return (antwort.token, FlaroAccount(
baseURL: baseURL,
serverName: gruss.serverName,
userID: antwort.user.id,
userName: antwort.user.userName,
isAdministrator: antwort.user.isAdministrator,
avatarImage: antwort.user.avatarImage), client)
}
/// Nimmt ein gespeichertes Token wieder auf.
///
/// **Ohne Passwort und ohne neue Anmeldung.** Der Server führt das Gerät
/// über das Token; ein zweiter Anmeldevorgang legte ein zweites Gerät an,
/// und in der Liste stünde dann bei jedem Start eines mehr.
public static func restore(
baseURL: URL,
token: String,
identity: FlaroIdentity,
transport: any FlaroTransport = URLSession.shared,
cookieJar: (any FlaroCookieJar)? = HTTPCookieStorage.shared
) async throws(MediaBackendError) -> (account: FlaroAccount, client: FlaroClient) {
let client = FlaroClient(
baseURL: baseURL, identity: identity, token: token,
transport: transport, cookieJar: cookieJar)
let wer = try await client.send(FlaroRequest(path: "/api/v1/auth/me"), as: Wire.User.self)
let gruss = try? await greet(baseURL: baseURL, identity: identity, transport: transport)
return (FlaroAccount(
baseURL: baseURL,
serverName: gruss?.serverName ?? baseURL.host() ?? "Flaro",
userID: wer.id,
userName: wer.userName,
isAdministrator: wer.isAdministrator,
avatarImage: wer.avatarImage), client)
}
// MARK: - Der Weg über einen Code
/// Ein angeforderter Code samt Abholschein.
public struct PendingCode: Sendable, Equatable {
/// Die sechs Ziffern, die auf dem Fernseher stehen.
public let code: String
/// **Der Abholschein, und er ist das eigentliche Geheimnis.**
///
/// Abgeholt wird das Token hiermit, nicht mit dem Code. Täte es der
/// Code allein, liessen sich eine Million Möglichkeiten durchprobieren
/// — und die sechs Ziffern stehen zum Mitlesen auf einem Bildschirm
/// im Wohnzimmer.
public let handle: String
public let expiresAt: Date
}
public enum CodeState: Sendable, Equatable {
case pending
case approved(token: String, account: FlaroAccount)
case expired
}
/// Fordert einen Code an. Der Fernseher zeigt ihn, das Telefon bestätigt.
public static func requestCode(
baseURL: URL,
identity: FlaroIdentity,
transport: any FlaroTransport = URLSession.shared
) async throws(MediaBackendError) -> PendingCode {
let client = FlaroClient(
baseURL: baseURL, identity: identity, transport: transport, cookieJar: nil)
let antwort = try await client.send(
.json(.post, "/api/v1/auth/code", Wire.CodeRequest(
deviceName: identity.deviceName, deviceId: identity.deviceID)),
as: Wire.CodeResponse.self)
return PendingCode(
code: antwort.code, handle: antwort.handle, expiresAt: antwort.expiresAt)
}
/// Fragt nach, ob jemand den Code inzwischen bestätigt hat.
public static func pollCode(
baseURL: URL,
pending: PendingCode,
identity: FlaroIdentity,
transport: any FlaroTransport = URLSession.shared,
cookieJar: (any FlaroCookieJar)? = HTTPCookieStorage.shared
) async throws(MediaBackendError) -> (state: CodeState, client: FlaroClient?) {
let client = FlaroClient(
baseURL: baseURL, identity: identity, transport: transport, cookieJar: cookieJar)
// **Mit dem Abholschein, nicht mit dem Code.** Siehe `PendingCode`.
let zustand = try await client.send(
FlaroRequest(path: "/api/v1/auth/code/\(pending.handle)"), as: Wire.CodeState.self)
switch zustand.state {
case "approved":
guard let anmeldung = zustand.login else { return (.expired, nil) }
await client.setToken(anmeldung.token)
let gruss = try? await greet(
baseURL: baseURL, identity: identity, transport: transport)
return (.approved(token: anmeldung.token, account: FlaroAccount(
baseURL: baseURL,
serverName: gruss?.serverName ?? baseURL.host() ?? "Flaro",
userID: anmeldung.user.id,
userName: anmeldung.user.userName,
isAdministrator: anmeldung.user.isAdministrator,
avatarImage: anmeldung.user.avatarImage)), client)
case "expired":
return (.expired, nil)
default:
return (.pending, nil)
}
}
/// Meldet dieses Gerät ab und widerruft sein Token.
public static func signOut(client: FlaroClient) async {
_ = try? await client.send(FlaroRequest(method: .post, path: "/api/v1/auth/logout"))
await client.setToken(nil)
}
}
Packages/FlaroKit/Sources/FlaroServerKit/Localizable.xcstrings
+108
View File
@@ -0,0 +1,108 @@
{
"sourceLanguage": "en",
"strings": {
"flaro.remux.tooLong": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Das Umpacken dauert ungewöhnlich lange. Sieh im Serverprotokoll nach."
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Remuxing is taking unusually long. Check the server log."
}
}
}
},
"flaro.row.continue": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Weiterschauen"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Continue Watching"
}
}
}
},
"flaro.row.latestIn %@": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Neu in %@"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "New in %@"
}
}
}
},
"flaro.row.movies": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Filme"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Movies"
}
}
}
},
"flaro.row.nextUp": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Nächste Folge"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Next Up"
}
}
}
},
"flaro.row.series": {
"extractionState": "manual",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Serien"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Shows"
}
}
}
}
},
"version": "1.0"
}
Packages/FlaroKit/Sources/JellyfinKit/JellyfinAddress.swift
+7 -55
View File
@@ -1,65 +1,17 @@
import Foundation import Foundation
import MediaKit
/// Macht aus dem, was jemand eintippt, eine Adresse, die antwortet. /// Die Adressraterei für Jellyfin.
/// ///
/// Jellyfin hat kein Verzeichnis wie plex.tv — die Adresse kommt vom Nutzer. /// Der Inhalt steht in `ServerAddress` — beide Server haben dasselbe Problem,
/// Und die tippt niemand vollständig: „192.168.1.50" ohne Schema, ohne Port, /// und es unterscheidet sie nur der Standardport. Dieser Typ bleibt stehen,
/// oder „medien.example.com" ohne „https://". Dieser Typ rät nicht **eine** /// weil Aufrufer und Prüfungen ihn beim Namen nennen und weil „welcher Port
/// Ergänzung, sondern nennt die plausiblen in der Reihenfolge, in der sie es /// gilt hier" eine Auskunft über Jellyfin ist, nicht über Adressen.
/// wahrscheinlich sind; der Aufrufer probiert sie durch und nimmt die erste,
/// die sich als Jellyfin-Server ausweist.
///
/// Die Reihenfolge ist der ganze Inhalt dieser Datei, und sie ist nicht
/// beliebig: eine IP-Adresse im eigenen Netz spricht fast nie HTTPS, ein
/// Domänenname fast immer.
public enum JellyfinAddress { public enum JellyfinAddress {
/// Der Standardport eines Jellyfin-Servers. /// Der Standardport eines Jellyfin-Servers.
public static let defaultPort = 8096 public static let defaultPort = 8096
public static func candidates(for input: String) -> [URL] { public static func candidates(for input: String) -> [URL] {
var text = input.trimmingCharacters(in: .whitespacesAndNewlines) ServerAddress.candidates(for: input, defaultPort: defaultPort)
while text.hasSuffix("/") { text.removeLast() }
guard !text.isEmpty else { return [] }
// Wer ein Schema hinschreibt, meint es auch so. Daran wird nichts
// ergänzt — sonst landet eine Anfrage unverschlüsselt, obwohl jemand
// ausdrücklich „https" getippt hat.
if text.contains("://") {
return URL(string: text).map { [$0] } ?? []
}
// IPv6 in eckigen Klammern: hier wird nicht geraten, weil die
// Doppelpunkte sonst als Port gelesen würden.
if text.hasPrefix("[") {
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
let authority = String(text.split(separator: "/", maxSplits: 1).first ?? "")
let host = String(authority.split(separator: ":").first ?? "")
let hasExplicitPort = authority.contains(":")
&& Int(authority.split(separator: ":").last ?? "") != nil
if hasExplicitPort {
// Port genannt, Schema nicht: erst unverschlüsselt, weil ein
// eigener Port fast immer ein Server ohne Zertifikat ist.
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
// Eine reine Zahlenadresse, ein Bonjour-Name oder ein Wort ohne Punkt
// — alles Dinge, die es nur im eigenen Netz gibt.
let isLocalLooking = host.allSatisfy { $0.isNumber || $0 == "." }
|| host.hasSuffix(".local")
|| !host.contains(".")
let forms = isLocalLooking
? ["http://\(withDefaultPort(text))", "http://\(text)", "https://\(text)"]
: ["https://\(text)", "http://\(text)", "http://\(withDefaultPort(text))"]
return forms.compactMap(URL.init(string:))
}
/// Hängt den Standardport an — vor einen etwaigen Pfad, nicht dahinter.
private static func withDefaultPort(_ text: String) -> String {
guard let slash = text.firstIndex(of: "/") else { return "\(text):\(defaultPort)" }
return "\(text[text.startIndex..<slash]):\(defaultPort)\(text[slash...])"
} }
} }
Packages/FlaroKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift
+13 -8
View File
@@ -106,7 +106,7 @@ extension JellyfinBackend {
)) ))
} }
public func reportProgress(_ report: PlaybackReport) async { public func reportProgress(_ report: PlaybackReport) async -> Bool {
var fields: [String: Any] = [ var fields: [String: Any] = [
"ItemId": report.itemID, "ItemId": report.itemID,
"PositionTicks": report.time.milliseconds.ticksFromMilliseconds, "PositionTicks": report.time.milliseconds.ticksFromMilliseconds,
@@ -126,13 +126,18 @@ extension JellyfinBackend {
default: "/Sessions/Playing/Progress" default: "/Sessions/Playing/Progress"
} }
guard let body = try? JSONSerialization.data(withJSONObject: fields) else { return } guard let body = try? JSONSerialization.data(withJSONObject: fields) else { return false }
_ = try? await client.send(JellyfinRequest( do {
method: .post, try await client.send(JellyfinRequest(
path: path, method: .post,
body: body, path: path,
timeout: .seconds(10) body: body,
)) timeout: .seconds(10)
))
return true
} catch {
return false
}
} }
// MARK: - Hilfen // MARK: - Hilfen
Packages/FlaroKit/Sources/JellyfinKit/JellyfinBackend.swift
+40 -11
View File
@@ -130,19 +130,34 @@ public func isInLocalNetwork() async -> Bool {
// sind zwei verschiedene Fragen — in einer gemeinsamen Reihe steht am // sind zwei verschiedene Fragen — in einer gemeinsamen Reihe steht am
// Ende beides durcheinander, und wer nach einem Film sucht, blättert // Ende beides durcheinander, und wer nach einem Film sucht, blättert
// an Folgen vorbei. // an Folgen vorbei.
for library in libraries { //
let items = try? await latestItems(limit: 20, inLibrary: library.id) // **Nebeneinander, nicht nacheinander.** Hier stand ein `await` in
rows.append(MediaRowGroup( // der Schleife: bei vier Mediatheken vier Rundreisen hintereinander.
id: "latest.\(library.id)", // Die Reihenfolge der Mediatheken bleibt trotzdem erhalten — sonst
title: String( // stünden die Reihen nach jedem Start woanders.
localized: "row.latestIn \(library.title)", let latest = await withTaskGroup(of: (Int, MediaRowGroup).self) { group in
bundle: .module for (place, library) in libraries.enumerated() {
), group.addTask {
libraryID: library.id, let items = try? await self.latestItems(limit: 20, inLibrary: library.id)
items: items ?? [] return (place, MediaRowGroup(
)) id: "latest.\(library.id)",
title: String(
localized: "row.latestIn \(library.title)",
bundle: .module
),
libraryID: library.id,
items: items ?? []
))
}
}
var collected: [(Int, MediaRowGroup)] = []
for await result in group { collected.append(result) }
return collected.sorted { $0.0 < $1.0 }.map(\.1)
} }
rows.append(contentsOf: latest)
rows.append(MediaRowGroup( rows.append(MediaRowGroup(
id: "favourites", id: "favourites",
title: String(localized: "row.favourites", bundle: .module), title: String(localized: "row.favourites", bundle: .module),
@@ -333,6 +348,20 @@ public func isInLocalNetwork() async -> Bool {
return next.first { $0.id != item.id } return next.first { $0.id != item.id }
} }
/// Die Folge davor.
///
/// **Über die Folgenliste der Serie, nicht über einen eigenen
/// Endpunkt.** Jellyfin hat ein „NextUp", aber kein Gegenstück dazu —
/// und die Liste gibt es ohnehin, weil die Serienseite sie zeigt. Eine
/// Anfrage für einen Knopf, der selten gedrückt wird, ist der bessere
/// Tausch gegenüber gar keinem Knopf.
public func previousEpisode(before item: MediaItem) async throws(MediaBackendError) -> MediaItem? {
guard let seriesID = item.seriesID else { return nil }
let folgen = try await episodes(inSeries: seriesID)
guard let stelle = folgen.firstIndex(where: { $0.id == item.id }), stelle > 0 else { return nil }
return folgen[stelle - 1]
}
// MARK: - Bilder // MARK: - Bilder
public nonisolated func artworkURL(path: String?, width: Int, height: Int) -> URL? { public nonisolated func artworkURL(path: String?, width: Int, height: Int) -> URL? {
Packages/FlaroKit/Sources/MediaKit/Fortschrittspost.swift
+126
View File
@@ -0,0 +1,126 @@
import Foundation
import Observation
import OSLog
/// Fortschritt, der den Server nicht erreicht hat.
///
/// **Was ohne sie verlorenging.** Eine Folge im Flugzeug zur Hälfte
/// anzusehen, war für den Server ein Vorgang, der nie stattgefunden hat:
/// jede Meldung lief in die tote Leitung, und beim nächsten Verbinden stand
/// der Titel wieder bei null — auf dem Fernseher, im Web, überall. Genau
/// dieser Fall ist der Grund, aus dem man etwas herunterlädt.
///
/// **Eine Meldung je Titel, die letzte gewinnt.** Wer eine Stunde schaut,
/// erzeugt an die hundert Meldungen; nachzureichen ist davon genau eine
/// sinnvoll — die, an der er aufgehört hat. Alles andere wäre ein Protokoll
/// der Vergangenheit, das der Server erst wieder zusammenrechnen müsste.
///
/// Auf der Platte, nicht im Speicher: wer die App im Flugmodus beendet, hat
/// sonst umsonst geschaut.
@MainActor
@Observable
public final class Fortschrittspost {
/// Der Briefkasten der App.
///
/// Einer, wie bei `LibraryCache`: zwei Instanzen auf dieselbe Datei
/// würden einander überschreiben. Der Bauweg mit eigener Ablage bleibt
/// für Prüfungen offen.
public static let shared = Fortschrittspost()
/// Ein zurückgelegter Stand.
public struct Eintrag: Codable, Sendable, Equatable {
/// Zu welchem Server er gehört.
///
/// **Sonst ginge er an den falschen.** Wer sich abmeldet und an
/// einem anderen Server anmeldet, bekäme sonst fremde Kennungen
/// mit dem eigenen Sehfortschritt gemeldet.
let server: String
let titelID: String
let sekunden: Double
let laufzeitSekunden: Double?
let zeitpunkt: Date
}
private let ablage: URL
private let logger = Logger(subsystem: "app.flaro", category: "Fortschrittspost")
private var offen: [String: Eintrag]
/// Wie viele Stände noch auf einen Server warten.
public var wartend: Int { offen.count }
public init(ablage: URL? = nil) {
self.ablage = ablage ?? FileManager.default
.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
.appending(path: "flaro-fortschritt.json")
self.offen = Self.lesen(from: self.ablage) ?? [:]
}
/// Legt einen Stand zurück, weil er nicht ankam.
public func zuruecklegen(_ report: PlaybackReport, server: String) {
offen[report.itemID] = Eintrag(
server: server,
titelID: report.itemID,
sekunden: report.time.seconds,
laufzeitSekunden: report.duration > .zero ? report.duration.seconds : nil,
zeitpunkt: Date()
)
schreiben()
}
/// Versucht, alles Liegengebliebene loszuwerden.
///
/// **Was weiterhin scheitert, bleibt liegen.** Ein halb geleerter
/// Briefkasten ist kein Fehler — beim nächsten Versuch geht der Rest.
///
/// Nacheinander und nicht nebeneinander: es sind selten mehr als eine
/// Handvoll, und zwanzig gleichzeitige Anfragen an einen Server, der
/// gerade erst wieder da ist, wären der falsche erste Gruß.
public func zustellen(über backend: (any Fortschrittsempfaenger)?) async {
guard let backend, !offen.isEmpty else { return }
let kennung = backend.identity
// **Nicht ewig aufheben.** Ein Stand von vor einem halben Jahr sagt
// nichts mehr darüber, wo jemand heute weiterschauen will — und ein
// Server, der nie wiederkommt, hinterliesse sonst eine Datei, die
// nur wächst.
let frist = Date().addingTimeInterval(-30 * 24 * 60 * 60)
offen = offen.filter { $0.value.zeitpunkt > frist }
for eintrag in offen.values.sorted(by: { $0.zeitpunkt < $1.zeitpunkt })
where eintrag.server == kennung {
let angekommen = await backend.reportProgress(PlaybackReport(
itemID: eintrag.titelID,
state: .stopped,
time: .seconds(eintrag.sekunden),
duration: .seconds(eintrag.laufzeitSekunden ?? 0)
))
guard angekommen else { break }
// **Nur den, der tatsächlich ankam.** Währenddessen kann
// derselbe Titel neu zurückgelegt worden sein; den zu
// entfernen hiesse, den neueren Stand wegzuwerfen.
if offen[eintrag.titelID] == eintrag { offen[eintrag.titelID] = nil }
}
schreiben()
}
/// Alles vergessen — beim Abmelden.
public func leeren() {
offen = [:]
try? FileManager.default.removeItem(at: ablage)
}
// MARK: - Platte
private func schreiben() {
do {
try JSONEncoder().encode(offen).write(to: ablage, options: .atomic)
} catch {
logger.warning("Nicht gespeichert: \(error.localizedDescription, privacy: .public)")
}
}
private static func lesen(from url: URL) -> [String: Eintrag]? {
guard let daten = try? Data(contentsOf: url) else { return nil }
return try? JSONDecoder().decode([String: Eintrag].self, from: daten)
}
}
Packages/FlaroKit/Sources/MediaKit/LibraryCache.swift
+39
View File
@@ -111,6 +111,41 @@ public actor LibraryCache {
} }
} }
/// Die Reihen der Startseite.
///
/// **Weil es sonst nichts gibt, womit sie sich füllen liesse.** Die
/// Mediathekenliste und die Titel darin liegen schon auf der Platte; die
/// Startseite dagegen entstand bei jedem Aufruf neu am Server, und ohne
/// ihn blieb sie leer. Im Flugzeug ist das der Unterschied zwischen
/// „sehen, was es gibt" und einem Fehlerbildschirm.
public func homeRows(server: String) -> [MediaRowGroup]? {
guard let daten = try? Data(contentsOf: homeRowsFile(server: server)) else { return nil }
return try? JSONDecoder().decode([MediaRowGroup].self, from: daten)
}
public func storeHomeRows(_ rows: [MediaRowGroup], server: String) {
// Je Reihe eine Bildschirmbreite, mehr sieht ohnehin niemand, bevor
// der Server wieder antwortet.
let gekürzt = rows.map {
MediaRowGroup(
id: $0.id,
title: $0.title,
moreKey: $0.moreKey,
libraryID: $0.libraryID,
items: $0.items.prefix(20).map(\.listEssentials)
)
}
let ziel = homeRowsFile(server: server)
do {
try FileManager.default.createDirectory(
at: ziel.deletingLastPathComponent(), withIntermediateDirectories: true
)
try JSONEncoder().encode(gekürzt).write(to: ziel, options: .atomic)
} catch {
logger.warning("Startseite nicht gespeichert: \(error.localizedDescription, privacy: .public)")
}
}
// MARK: - Aufräumen // MARK: - Aufräumen
/// Alles zu einem Server vergessen — beim Abmelden. /// Alles zu einem Server vergessen — beim Abmelden.
@@ -139,6 +174,10 @@ public actor LibraryCache {
directory(server: server).appending(path: "libraries.json") directory(server: server).appending(path: "libraries.json")
} }
private func homeRowsFile(server: String) -> URL {
directory(server: server).appending(path: "home.json")
}
/// Ein Name, der als Datei taugt. /// Ein Name, der als Datei taugt.
/// ///
/// Kennungen kommen vom Server: bei Jellyfin GUIDs, bei Plex Zahlen, und /// Kennungen kommen vom Server: bei Jellyfin GUIDs, bei Plex Zahlen, und
Packages/FlaroKit/Sources/MediaKit/MediaBackend.swift
+112 -10
View File
@@ -6,9 +6,13 @@ import Foundation
/// Anmeldung, Jellyfins Verwaltung, die Eigenheiten des Programmführers — /// Anmeldung, Jellyfins Verwaltung, die Eigenheiten des Programmführers —
/// steht **nicht** hier, sondern als eigene Fähigkeit. Ein gemeinsamer Nenner, /// steht **nicht** hier, sondern als eigene Fähigkeit. Ein gemeinsamer Nenner,
/// der alles umfasst, wäre kein Nenner mehr. /// der alles umfasst, wäre kein Nenner mehr.
public protocol MediaBackend: Sendable { /// Wer Sehfortschritt entgegennimmt.
/// Wie der Server heißt, so wie er sich selbst nennt. ///
nonisolated var serverName: String { get } /// **Ein Ausschnitt aus `MediaBackend`, und zwar genau der, den die
/// `Fortschrittspost` braucht.** Ohne ihn müsste jeder, der das Nachreichen
/// prüfen will, einen vollständigen Server nachbauen — vierzig Methoden für
/// die zwei, die zur Sache gehören.
public protocol Fortschrittsempfaenger: Sendable {
/// Wer dieser Server ist — für alles, was ihn über einen Start hinaus /// Wer dieser Server ist — für alles, was ihn über einen Start hinaus
/// wiedererkennen muss. /// wiedererkennen muss.
/// ///
@@ -17,6 +21,24 @@ public protocol MediaBackend: Sendable {
/// beides überlebt und beim nächsten Start noch gleich lautet. Es ist /// beides überlebt und beim nächsten Start noch gleich lautet. Es ist
/// eine Kennung und geht nirgends an die Oberfläche. /// eine Kennung und geht nirgends an die Oberfläche.
nonisolated var identity: String { get } nonisolated var identity: String { get }
/// Meldet, wo man gerade steht.
///
/// Wirft nicht: eine verlorene Meldung kostet ein paar Sekunden
/// Fortschritt, und dafür mitten im Film eine Fehlermeldung zu zeigen
/// wäre die schlechtere Hälfte des Tauschs.
///
/// **Gibt aber zurück, ob sie ankam.** Im Flugzeug geht jede einzelne
/// verloren, und am Ende stünde ein zur Hälfte gesehener Film auf dem
/// Server weiter bei null. Der Aufrufer legt sie dann beiseite und
/// meldet sie nach — siehe `Fortschrittspost`.
@discardableResult
func reportProgress(_ report: PlaybackReport) async -> Bool
}
public protocol MediaBackend: Sendable, Fortschrittsempfaenger {
/// Wie der Server heißt, so wie er sich selbst nennt.
nonisolated var serverName: String { get }
/// Was dieser Server darüber hinaus beherrscht. /// Was dieser Server darüber hinaus beherrscht.
nonisolated var capabilities: Set<BackendCapability> { get } nonisolated var capabilities: Set<BackendCapability> { get }
@@ -60,9 +82,26 @@ public protocol MediaBackend: Sendable {
/// dreizehn Anfragen — für einen Klick auf eine Kachel ist das zu viel. /// dreizehn Anfragen — für einen Klick auf eine Kachel ist das zu viel.
/// Ein Server, der es in einer Anfrage kann, soll das dürfen. /// Ein Server, der es in einer Anfrage kann, soll das dürfen.
func episodes(inSeries id: String) async throws(MediaBackendError) -> [MediaItem] func episodes(inSeries id: String) async throws(MediaBackendError) -> [MediaItem]
/// Welche Sprachen eine Serie durchgehend führt — für die Vorwahl.
func availableLanguages(inSeries id: String) async -> AvailableLanguages?
/// Die nächste Folge nach dieser, sofern es eine gibt. /// Die nächste Folge nach dieser, sofern es eine gibt.
func nextEpisode(after item: MediaItem) async throws(MediaBackendError) -> MediaItem? func nextEpisode(after item: MediaItem) async throws(MediaBackendError) -> MediaItem?
/// Die Folge davor — für den Rückwärtsknopf im Spieler.
///
/// **Mit Vorgabe, anders als die nächste.** Die nächste Folge braucht
/// jeder Server: ohne sie gibt es kein Weiterlaufen am Ende. Die vorige
/// ist eine Bequemlichkeit, und ein Server, der sie nicht kennt, soll
/// deshalb nicht unbaubar werden.
func previousEpisode(before item: MediaItem) async throws(MediaBackendError) -> MediaItem?
/// Wie die Vorschaubilder einer Datei liegen — `nil`, wenn es keine gibt.
func vorschauplan(fileId: String) async -> Vorschauplan?
/// Die Adresse eines Vorschaublattes.
nonisolated func vorschaublatt(fileId: String, blatt: Int) -> URL?
// MARK: - Bilder // MARK: - Bilder
/// Ein Bild in der gewünschten Größe. /// Ein Bild in der gewünschten Größe.
@@ -125,13 +164,6 @@ public protocol MediaBackend: Sendable {
/// niemand mehr zusieht. /// niemand mehr zusieht.
func endPlayback(sessionID: String) async func endPlayback(sessionID: String) async
/// Meldet, wo man gerade steht.
///
/// Wirft nicht: eine verlorene Meldung kostet ein paar Sekunden
/// Fortschritt, und dafür mitten im Film eine Fehlermeldung zu zeigen
/// wäre die schlechtere Hälfte des Tauschs.
func reportProgress(_ report: PlaybackReport) async
// MARK: - Zustand melden // MARK: - Zustand melden
func markWatched(id: String) async throws(MediaBackendError) func markWatched(id: String) async throws(MediaBackendError)
@@ -173,6 +205,18 @@ public enum BackendCapability: String, Sendable, Hashable {
/// Die Verwaltung des Servers aus der App heraus. /// Die Verwaltung des Servers aus der App heraus.
case administration case administration
case transcoding case transcoding
/// Ein Download bringt **alle** Ton- und Textspuren mit.
///
/// **Der Unterschied, um dessentwillen Flaro gebaut wurde.** Jellyfins
/// Transcode-Endpunkt bildet eine Tonspur je Sitzung ab: was
/// heruntergeladen wird, ist einspurig, und die Sprachwahl ist offline
/// weg. Einmal hat die App dabei still die Audiodeskription genommen —
/// drei Gigabyte Mobilfunk für eine unbrauchbare Datei.
///
/// Kann der Server es besser, soll die App nicht so tun, als müsste
/// vorher gewählt werden: `remuxDownloadURL` entfällt, die Spurauswahl
/// im Sheet entfällt, und der gewöhnliche Download liefert alles.
case allTracksDownload
} }
/// Ein Ausschnitt aus einer Mediathek. /// Ein Ausschnitt aus einer Mediathek.
@@ -199,6 +243,19 @@ public struct MediaPage: Sendable, Equatable {
} }
public extension MediaBackend { public extension MediaBackend {
/// Vorgabe: kein Weg zurück.
func previousEpisode(before item: MediaItem) async throws(MediaBackendError) -> MediaItem? { nil }
/// Wie die Vorschaubilder einer Datei liegen — `nil`, wenn es keine gibt.
///
/// **Mit Vorgabe, damit nicht jeder Server es können muss.** Jellyfin
/// hat sein eigenes Trickplay mit anderem Zuschnitt; bis das angebunden
/// ist, sagt es hier schlicht nichts.
func vorschauplan(fileId: String) async -> Vorschauplan? { nil }
/// Die Adresse eines Vorschaublattes.
nonisolated func vorschaublatt(fileId: String, blatt: Int) -> URL? { nil }
/// Vorgabe: der Server kann es nicht. /// Vorgabe: der Server kann es nicht.
/// ///
/// So muss nicht jeder Server eine Adresse erfinden, die es bei ihm nicht /// So muss nicht jeder Server eine Adresse erfinden, die es bei ihm nicht
@@ -215,6 +272,13 @@ public extension MediaBackend {
subtitleStreamIndex: Int? subtitleStreamIndex: Int?
) -> URL? { nil } ) -> URL? { nil }
/// Welche Sprachen eine Serie durchgehend führt.
///
/// **`nil` heisst: der Server weiss es nicht.** Dann bleibt es bei der
/// vollen Liste — eine leere Auswahl anzubieten wäre schlimmer als eine
/// zu lange.
func availableLanguages(inSeries id: String) async -> AvailableLanguages? { nil }
/// Der allgemeine Weg: Staffeln, dann je Staffel die Folgen. /// Der allgemeine Weg: Staffeln, dann je Staffel die Folgen.
/// ///
/// Langsam, aber überall gültig — wer es besser kann, überschreibt es. /// Langsam, aber überall gültig — wer es besser kann, überschreibt es.
@@ -249,3 +313,41 @@ public struct MediaFilterOption: Sendable, Equatable, Identifiable {
self.title = title self.title = title
} }
} }
/// Eine Sprache, wie sie in einem Menü steht.
public struct LanguageOption: Sendable, Equatable, Identifiable, Hashable {
public let code: String
public let name: String
public var id: String { code }
public init(code: String, name: String) {
self.code = code
self.name = name
}
}
/// Welche Sprachen ein Titel durchgehend führt.
///
/// **Durchgehend, nicht irgendwo.** Bei einer Serie ist das die
/// Schnittmenge über alle Folgen: eine Sprache anzubieten, die es nur in
/// Staffel 1 gibt, hiesse eine Einstellung für die Serie, die ab Staffel 2
/// stillschweigend etwas anderes tut.
public struct AvailableLanguages: Sendable, Equatable {
public let audio: [LanguageOption]
public let subtitles: [LanguageOption]
/// Wie viele Sprachen es nur in einem Teil der Folgen gibt.
///
/// **Damit die Oberfläche es sagen kann.** Eine gekürzte Liste sieht
/// sonst aus wie die ganze Wahrheit, und wer eine Sprache vermisst, die
/// er in Staffel 1 gesehen hat, hält es für einen Fehler.
public let partial: Int
public init(audio: [LanguageOption], subtitles: [LanguageOption], partial: Int) {
self.audio = audio
self.subtitles = subtitles
self.partial = partial
}
}
Packages/FlaroKit/Sources/MediaKit/MediaItem.swift
+56
View File
@@ -48,6 +48,13 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
/// die Serie, und so heißt es jetzt auch. /// die Serie, und so heißt es jetzt auch.
public let seriesThumb: String? public let seriesThumb: String?
public let seriesArt: String? public let seriesArt: String?
/// Das Bild, das jetzt im Aufmacher gilt.
///
/// **Vom Server gewählt, nicht hier.** Wer zu einem Titel mehrere
/// Aufnahmen ausgesucht hat, bekommt alle paar Stunden eine andere — und
/// zwar überall dieselbe. `nil` heisst: keine ausgesucht, dann gilt das
/// Hintergrundbild.
public let heroArt: String?
// Einordnung bei Folgen: `index` ist die Folgennummer, `parentIndex` die // Einordnung bei Folgen: `index` ist die Folgennummer, `parentIndex` die
// Staffel. // Staffel.
@@ -71,6 +78,26 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
/// eine Fähigkeit, die es nur auf einem gibt. /// eine Fähigkeit, die es nur auf einem gibt.
public let isFavourite: Bool public let isFavourite: Bool
/// Ob der Server den Titel als angefangen führt.
///
/// **Die Entscheidung gehört dem Server, nicht der Beschriftung.** „Hat
/// eine Stelle über null" und „ist angefangen" waren dasselbe, bis es eine
/// einstellbare Untergrenze gab. Seitdem heisst ein Titel, in den jemand
/// eine Sekunde hineingeschaut hat, nicht mehr „Weiterschauen" — er steht
/// ja auch nicht mehr in der Reihe.
///
/// `nil` heisst: der Server sagt nichts dazu (Jellyfin, oder ein älterer
/// Flaro). Dann gilt wie früher die blosse Stelle.
public let isInProgress: Bool?
/// Ab wann es den Titel gibt — `nil` heisst: jetzt.
///
/// **Ein geplanter Titel steht in der Mediathek, läuft aber nicht.** Das
/// ist der Sinn des Planens: man soll sehen, dass er kommt. Ohne dieses
/// Feld bot die App „Abspielen" an und bekam vom Server eine Absage —
/// ein Knopf, der ein Versprechen gibt und es zurücknimmt.
public let availableFrom: Date?
// Zählwerte bei Serien und Staffeln. // Zählwerte bei Serien und Staffeln.
public let episodeCount: Int? public let episodeCount: Int?
public let playedEpisodeCount: Int? public let playedEpisodeCount: Int?
@@ -106,6 +133,7 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
parentThumb: String? = nil, parentThumb: String? = nil,
seriesThumb: String? = nil, seriesThumb: String? = nil,
seriesArt: String? = nil, seriesArt: String? = nil,
heroArt: String? = nil,
index: Int? = nil, index: Int? = nil,
parentIndex: Int? = nil, parentIndex: Int? = nil,
parentTitle: String? = nil, parentTitle: String? = nil,
@@ -117,6 +145,8 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
lastPlayedAt: Date? = nil, lastPlayedAt: Date? = nil,
addedAt: Date? = nil, addedAt: Date? = nil,
isFavourite: Bool = false, isFavourite: Bool = false,
isInProgress: Bool? = nil,
availableFrom: Date? = nil,
episodeCount: Int? = nil, episodeCount: Int? = nil,
playedEpisodeCount: Int? = nil, playedEpisodeCount: Int? = nil,
childCount: Int? = nil, childCount: Int? = nil,
@@ -144,6 +174,7 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
self.parentThumb = parentThumb self.parentThumb = parentThumb
self.seriesThumb = seriesThumb self.seriesThumb = seriesThumb
self.seriesArt = seriesArt self.seriesArt = seriesArt
self.heroArt = heroArt
self.index = index self.index = index
self.parentIndex = parentIndex self.parentIndex = parentIndex
self.parentTitle = parentTitle self.parentTitle = parentTitle
@@ -155,6 +186,8 @@ public struct MediaItem: Sendable, Equatable, Identifiable, Codable {
self.lastPlayedAt = lastPlayedAt self.lastPlayedAt = lastPlayedAt
self.addedAt = addedAt self.addedAt = addedAt
self.isFavourite = isFavourite self.isFavourite = isFavourite
self.isInProgress = isInProgress
self.availableFrom = availableFrom
self.episodeCount = episodeCount self.episodeCount = episodeCount
self.playedEpisodeCount = playedEpisodeCount self.playedEpisodeCount = playedEpisodeCount
self.childCount = childCount self.childCount = childCount
@@ -225,6 +258,29 @@ extension MediaItem {
public var isWatched: Bool { (playCount ?? 0) > 0 } public var isWatched: Bool { (playCount ?? 0) > 0 }
/// Ob die Beschriftung „Weiterschauen" heissen soll.
///
/// Eine Stelle, die beide Fälle kennt: was der Server sagt, und was ohne
/// seine Auskunft gilt. Stünde der Zweifel an jedem Knopf einzeln, hiesse
/// derselbe Titel auf der Startseite anders als auf seiner Seite.
public var isResumable: Bool { isInProgress ?? (watchProgress != nil) }
/// Der Balken unter der Kachel — nur, wenn der Titel wirklich angefangen ist.
///
/// **Sonst sagt die Kachel etwas anderes als der Knopf.** Ein Strich unter
/// dem Plakat heisst „du bist mittendrin". Für eine Sekunde, in die jemand
/// hineingeschaut hat, ist das keine Auskunft, sondern ein Fussel.
public var resumeProgress: Double? { isResumable ? watchProgress : nil }
/// Ob der Titel erst noch kommt.
///
/// Gefragt wird an einer Stelle, beantwortet an einer: sonst steht an
/// einem Bildschirm „Abspielen" und am nächsten der Termin.
public var isUpcoming: Bool {
guard let availableFrom else { return false }
return availableFrom > Date()
}
/// Ab wo fortgesetzt wird. /// Ab wo fortgesetzt wird.
public var resumeTime: Duration { public var resumeTime: Duration {
.milliseconds(resumeMilliseconds ?? 0) .milliseconds(resumeMilliseconds ?? 0)
Packages/FlaroKit/Sources/MediaKit/MediaLibrary.swift
+1 -1
View File
@@ -49,7 +49,7 @@ public struct MediaLibrary: Sendable, Equatable, Identifiable, Codable {
} }
/// Eine Reihe auf der Startseite oder in den Suchergebnissen. /// Eine Reihe auf der Startseite oder in den Suchergebnissen.
public struct MediaRowGroup: Sendable, Equatable, Identifiable { public struct MediaRowGroup: Sendable, Equatable, Identifiable, Codable {
/// Eine stabile Kennung für diese Reihe. /// Eine stabile Kennung für diese Reihe.
/// ///
/// Sie entscheidet, welche Reihe der Nutzer ausgeblendet oder verschoben /// Sie entscheidet, welche Reihe der Nutzer ausgeblendet oder verschoben
Packages/FlaroKit/Sources/MediaKit/MediaPlayback.swift
+20 -1
View File
@@ -112,10 +112,29 @@ public struct PlaybackTarget: Sendable, Equatable {
/// ordnet es die Meldung keiner Wiedergabe zu. /// ordnet es die Meldung keiner Wiedergabe zu.
public let versionID: String? public let versionID: String?
public init(url: URL, sessionID: String? = nil, versionID: String? = nil) { /// Ab welcher Stelle des Films dieser Strom beginnt.
///
/// **Null heisst: der Strom ist der ganze Film.** Dann springt der
/// Spieler selbst, und das ist der Normalfall — bei Jellyfin immer.
///
/// **Ein Wert darüber heisst: der Server hat schon gesprungen.** Flaros
/// Abspielliste wächst von der gewünschten Stelle an vorwärts; was davor
/// liegt, gibt es in diesem Strom nicht. Der Spieler zählt trotzdem ab
/// null — ohne diesen Wert ginge jede angezeigte Zeit und jede gemeldete
/// Stelle um den Vorlauf daneben, und ein Sprung dorthin wäre ein Sprung
/// ins Leere.
public let startOffset: Duration
public init(
url: URL,
sessionID: String? = nil,
versionID: String? = nil,
startOffset: Duration = .zero
) {
self.url = url self.url = url
self.sessionID = sessionID self.sessionID = sessionID
self.versionID = versionID self.versionID = versionID
self.startOffset = startOffset
} }
} }
Packages/FlaroKit/Sources/MediaKit/ServerAddress.swift
+68
View File
@@ -0,0 +1,68 @@
import Foundation
/// Macht aus dem, was jemand eintippt, eine Adresse, die antwortet.
///
/// Weder Jellyfin noch Flaro haben ein Verzeichnis wie plex.tv — die Adresse
/// kommt vom Nutzer. Und die tippt niemand vollständig: „192.168.1.50" ohne
/// Schema, ohne Port, oder „medien.example.com" ohne „https://". Dieser Typ
/// rät nicht **eine** Ergänzung, sondern nennt die plausiblen in der
/// Reihenfolge, in der sie es wahrscheinlich sind; der Aufrufer probiert sie
/// durch und nimmt die erste, die sich ausweist.
///
/// Die Reihenfolge ist der ganze Inhalt dieser Datei, und sie ist nicht
/// beliebig: eine IP-Adresse im eigenen Netz spricht fast nie HTTPS, ein
/// Domänenname fast immer.
///
/// **In der neutralen Schicht, weil beide Server dasselbe Problem haben.**
/// Nur der Standardport unterscheidet sich, und der ist ein Wert, kein
/// Gedanke. Diese Überlegungen zweimal hinzuschreiben hiesse, dass die eine
/// Fassung beim nächsten Sonderfall nachgezogen wird und die andere nicht.
public enum ServerAddress {
public static func candidates(for input: String, defaultPort: Int) -> [URL] {
var text = input.trimmingCharacters(in: .whitespacesAndNewlines)
while text.hasSuffix("/") { text.removeLast() }
guard !text.isEmpty else { return [] }
// Wer ein Schema hinschreibt, meint es auch so. Daran wird nichts
// ergänzt — sonst landet eine Anfrage unverschlüsselt, obwohl jemand
// ausdrücklich „https" getippt hat.
if text.contains("://") {
return URL(string: text).map { [$0] } ?? []
}
// IPv6 in eckigen Klammern: hier wird nicht geraten, weil die
// Doppelpunkte sonst als Port gelesen würden.
if text.hasPrefix("[") {
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
let authority = String(text.split(separator: "/", maxSplits: 1).first ?? "")
let host = String(authority.split(separator: ":").first ?? "")
let hasExplicitPort = authority.contains(":")
&& Int(authority.split(separator: ":").last ?? "") != nil
if hasExplicitPort {
// Port genannt, Schema nicht: erst unverschlüsselt, weil ein
// eigener Port fast immer ein Server ohne Zertifikat ist.
return ["http://\(text)", "https://\(text)"].compactMap(URL.init(string:))
}
// Eine reine Zahlenadresse, ein Bonjour-Name oder ein Wort ohne Punkt
// — alles Dinge, die es nur im eigenen Netz gibt.
let isLocalLooking = host.allSatisfy { $0.isNumber || $0 == "." }
|| host.hasSuffix(".local")
|| !host.contains(".")
let mitPort = withDefaultPort(text, port: defaultPort)
let forms = isLocalLooking
? ["http://\(mitPort)", "http://\(text)", "https://\(text)"]
: ["https://\(text)", "http://\(text)", "http://\(mitPort)"]
return forms.compactMap(URL.init(string:))
}
/// Hängt den Standardport an — vor einen etwaigen Pfad, nicht dahinter.
private static func withDefaultPort(_ text: String, port: Int) -> String {
guard let slash = text.firstIndex(of: "/") else { return "\(text):\(port)" }
return "\(text[text.startIndex..<slash]):\(port)\(text[slash...])"
}
}
Packages/FlaroKit/Sources/MediaKit/Vorschauplan.swift
+55
View File
@@ -0,0 +1,55 @@
import Foundation
/// Wie die Vorschaubilder eines Titels zusammengesetzt sind.
///
/// **Dieselbe Rechnung wie im Server und im Web.** Dort heisst der Typ
/// genauso; die Kachel zu einer Sekunde wird an drei Stellen ausgerechnet,
/// und wenn eine davon abweicht, sieht man es nicht als Fehler — man hält
/// die Vorschau für ein ungenaues Bild.
///
/// **Die Kachelmasse stehen nicht fest.** Skaliert wird auf eine feste
/// Breite, die Höhe folgt dem Seitenverhältnis des Films. Deshalb misst
/// der Server sie und teilt sie mit, statt dass sie hier stünden.
public struct Vorschauplan: Sendable, Equatable, Decodable {
public let intervall: Double
public let spalten: Int
public let zeilen: Int
public let kachelBreite: Double
public let kachelHoehe: Double
public let blaetter: Int
public init(
intervall: Double, spalten: Int, zeilen: Int,
kachelBreite: Double, kachelHoehe: Double, blaetter: Int
) {
self.intervall = intervall
self.spalten = spalten
self.zeilen = zeilen
self.kachelBreite = kachelBreite
self.kachelHoehe = kachelHoehe
self.blaetter = blaetter
}
/// Wie eine Kachel adressiert wird: welches Blatt, und wo darin.
public struct Stelle: Sendable, Equatable {
public let blatt: Int
public let spalte: Int
public let zeile: Int
}
public var proBlatt: Int { spalten * zeilen }
/// Welche Kachel die Stelle zeigt — oder nichts.
///
/// **Hinter dem letzten Bild bleibt das letzte stehen.** Das Raster
/// endet dort, wo ffmpeg aufgehört hat; eine Sekunde darüber hinaus —
/// bei ungenauer Laufzeit durchaus möglich — soll die Vorschau nicht
/// verschwinden.
public func stelle(bei sekunde: Double) -> Stelle? {
guard blaetter > 0, spalten > 0, zeilen > 0, intervall > 0 else { return nil }
let nummer = min(Int(max(0, sekunde) / intervall), proBlatt * blaetter - 1)
let rest = nummer % proBlatt
return Stelle(blatt: nummer / proBlatt, spalte: rest % spalten, zeile: rest / spalten)
}
}
Packages/FlaroKit/Tests/FlaroDesignTests/ArtworkLoaderTests.swift
+52
View File
@@ -0,0 +1,52 @@
import Foundation
import Testing
@testable import FlaroDesign
/// Ein Bild von der Platte muss ankommen.
///
/// **Der Fehler, für den diese Prüfung steht.** Der Lader verlangte von jeder
/// Antwort eine `HTTPURLResponse` — eine `file:`-Adresse antwortet aber mit
/// einer schlichten `URLResponse`, und die Prüfung gab darauf `nil` zurück.
/// Sichtbar wurde das erst, als die Downloads ihre Plakate mitbrachten: die
/// Dateien lagen da, und die Kacheln blieben trotzdem grau.
@Suite("Bilder von der Platte")
struct ArtworkLoaderTests {
/// Ein gültiges PNG, ein Bildpunkt gross.
private static let winzigesPNG = Data(base64Encoded: """
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmM\
IQAAAABJRU5ErkJggg==
""")!
private func ablegen(_ daten: Data, als name: String) throws -> URL {
let ziel = FileManager.default.temporaryDirectory
.appending(path: "artwork-\(UUID().uuidString)-\(name)")
try daten.write(to: ziel)
return ziel
}
@Test("Eine Datei wird gelesen, nicht abgefragt")
func dateiWirdGelesen() async throws {
let datei = try ablegen(Self.winzigesPNG, als: "plakat.bild")
defer { try? FileManager.default.removeItem(at: datei) }
let bild = await ArtworkLoader.shared.image(for: datei)
#expect(bild != nil)
}
@Test("Eine Datei, die es nicht gibt, ergibt kein Bild")
func fehlendeDatei() async {
let nirgends = FileManager.default.temporaryDirectory
.appending(path: "gibt-es-nicht-\(UUID().uuidString).bild")
let bild = await ArtworkLoader.shared.image(for: nirgends)
#expect(bild == nil)
}
@Test("Was keine Bilddaten sind, ergibt kein Bild")
func keinBild() async throws {
let datei = try ablegen(Data("kein Bild, nur Text".utf8), als: "text.bild")
defer { try? FileManager.default.removeItem(at: datei) }
let bild = await ArtworkLoader.shared.image(for: datei)
#expect(bild == nil)
}
}
Packages/FlaroKit/Tests/FlaroServerKitTests/AdressenTests.swift
+150
View File
@@ -0,0 +1,150 @@
import Foundation
import Testing
import MediaKit
@testable import FlaroServerKit
/// Adressen und Zugang — alles, was ohne Netz entsteht.
@Suite("Flaro: Adressen und Zugang")
struct AdressenTests {
private func backend(_ transport: Attrappe, cookieglas: Cookieglas? = nil) -> FlaroBackend {
FlaroBackend(
client: FlaroClient(
baseURL: Proben.adresse, identity: Proben.kennung, token: "geheim-123",
transport: transport, cookieJar: cookieglas),
account: FlaroAccount(
baseURL: Proben.adresse, serverName: "Wohnzimmer",
userID: "u1", userName: "guido", isAdministrator: true))
}
/// **Kein Token in der Adresse — das ist der Unterschied zu Jellyfin.**
///
/// Dort steckt der Zugang als `?ApiKey=` in jeder Bildadresse, weil eine
/// Bildansicht keine Kopfzeilen schickt. Er steht damit in jedem
/// Zugriffsprotokoll, in jedem Verlauf und in jedem weitergegebenen Link.
/// Flaro geht über ein Cookie.
@Test("Bildadressen tragen keinen Zugang")
func bildAdresseOhneToken() {
let url = backend(Attrappe(rumpf: "{}")).rawImageURL(path: "abc123")
#expect(url?.path == "/api/v1/images/abc123")
#expect(url?.query == nil)
#expect(url?.absoluteString.contains("geheim") == false)
}
@Test("Ein Zugang wird als Cookie abgelegt")
func tokenWirdZuCookie() async {
let glas = Cookieglas()
_ = FlaroClient(
baseURL: Proben.adresse, identity: Proben.kennung, token: "geheim-123",
transport: Attrappe(rumpf: "{}"), cookieJar: glas)
let cookie = glas.cookies.first
#expect(cookie?.name == "flaro_session")
#expect(cookie?.value == "geheim-123")
#expect(cookie?.path == "/")
#expect(cookie?.domain.hasSuffix("nas") == true)
}
/// **Nach einem Neustart meldet sich niemand neu an.**
///
/// Die App hat dann nur das Token aus dem Schlüsselbund. Käme das Cookie
/// allein aus der Antwort des Servers, wäre keines da — und jedes Plakat
/// bliebe grau, obwohl der Zugang gilt.
@Test("Auch ein wiederaufgenommenes Token legt das Cookie an")
func cookieAuchOhneAnmeldung() async throws {
let glas = Cookieglas()
let transport = Attrappe([
("/api/v1/auth/me", 200, #"{"id":"u1","userName":"guido","isAdministrator":false}"#),
("/api/v1/system/info", 200, Proben.info),
])
_ = try await FlaroSignIn.restore(
baseURL: Proben.adresse, token: "geheim-123",
identity: Proben.kennung, transport: transport, cookieJar: glas)
#expect(glas.cookies.contains { $0.name == "flaro_session" && $0.value == "geheim-123" })
}
@Test("Die Download-Adresse zeigt auf die Datei, nicht auf den Titel")
func downloadAdresse() {
let url = backend(Attrappe(rumpf: "{}")).downloadURL(
for: MediaFile(id: "datei-1", itemID: "film-1"))
#expect(url?.path == "/api/v1/files/datei-1/download")
}
/// **Der Vertrag fragt nach einer Tonspur, Flaro braucht keine.**
///
/// `remuxDownloadURL` gibt es nur, weil Jellyfins Transcoder genau eine
/// Tonspur je Sitzung abbildet. Hier wäre eine Adresse mit Spurnummer
/// eine Lüge über das, was herauskommt — also gibt es keine, und die
/// Oberfläche erkennt an der Fähigkeit, dass sie nicht fragen muss.
@Test("Kein Umpacken mit Spurwahl — stattdessen die Fähigkeit")
func alleSpuren() {
let b = backend(Attrappe(rumpf: "{}"))
#expect(b.capabilities.contains(.allTracksDownload))
#expect(b.remuxDownloadURL(
itemID: "film-1", versionIndex: 0,
audioStreamIndex: 1, subtitleStreamIndex: nil) == nil)
}
/// Zwei Server dürfen „Medien" heissen; derselbe darf umbenannt werden.
@Test("Die Kennung hängt an der Adresse, nicht am Namen")
func kennung() {
#expect(backend(Attrappe(rumpf: "{}")).identity == "flaro:http://nas:8080")
}
@Test("Anmelden schickt Gerätename und Kennung mit")
func anmeldung() async throws {
let transport = Attrappe([
("/api/v1/system/info", 200, Proben.info),
("/api/v1/auth/login", 200, Proben.anmeldung),
])
let (token, konto, _) = try await FlaroSignIn.signIn(
baseURL: Proben.adresse, userName: "guido", password: "geheim",
identity: Proben.kennung, transport: transport, cookieJar: Cookieglas())
let rumpf = try #require(transport.rumpf(von: "/api/v1/auth/login"))
#expect(token == "geheim-123")
#expect(konto.userName == "guido")
#expect(konto.isAdministrator)
#expect(konto.serverName == "Wohnzimmer")
#expect(rumpf["deviceName"] as? String == "Prüfgerät")
#expect(rumpf["deviceId"] as? String == "geraet-1")
}
/// **Ein frischer Server ist kein falsches Passwort.**
@Test("Ein nicht eingerichteter Server sagt das")
func nochNichtEingerichtet() async throws {
let transport = Attrappe(rumpf: #"{"version":"0.1.0","serverName":null,"needsSetup":true}"#)
let gruss = try await FlaroSignIn.greet(
baseURL: Proben.adresse, identity: Proben.kennung, transport: transport)
#expect(gruss.needsSetup)
}
/// **Flaro begründet seine Absagen, und der Satz zählt mehr als die Zahl.**
@Test("Eine Absage mit Begründung kommt als Begründung an")
func begruendeteAbsage() async {
let transport = Attrappe(rumpf: #"{"detail":"Für diese Bibliothek läuft bereits ein Scan."}"#, status: 409)
let b = backend(transport)
await #expect(throws: MediaBackendError.refused(
reason: "Für diese Bibliothek läuft bereits ein Scan.")) {
try await b.refreshLibrary(MediaLibrary(id: "b1", title: "Filme", kind: .movie))
}
}
@Test("Ein abgelaufener Zugang führt zur Abmeldung, nicht zu einer Meldung")
func abgelaufen() async {
let b = backend(Attrappe(rumpf: "", status: 401))
await #expect(throws: MediaBackendError.unauthorized) {
_ = try await b.libraries()
}
}
}
Packages/FlaroKit/Tests/FlaroServerKitTests/Hilfsmittel.swift
+104
View File
@@ -0,0 +1,104 @@
import Foundation
@testable import FlaroServerKit
/// Ein Transport, der vorbereitete Antworten gibt und mitschreibt.
///
/// Dieselbe Trennung wie bei Jellyfin: Prüfungen brauchen keinen Server,
/// sondern eine Antwort und die Frage, die gestellt wurde.
final class Attrappe: FlaroTransport, @unchecked Sendable {
/// Antworten je Pfad. Der erste Treffer gewinnt — so kann eine Prüfung
/// `/api/v1/movies` und `/api/v1/movies/{id}` getrennt bedienen.
private let antworten: [(pfad: String, status: Int, rumpf: String)]
private let sperre = NSLock()
private var protokoll: [URLRequest] = []
init(_ antworten: [(pfad: String, status: Int, rumpf: String)]) {
self.antworten = antworten
}
convenience init(rumpf: String, status: Int = 200) {
self.init([("", status, rumpf)])
}
var anfragen: [URLRequest] { sperre.withLock { protokoll } }
var letzte: URLRequest? { anfragen.last }
func anfrage(auf pfad: String) -> URLRequest? {
anfragen.last { $0.url?.path == pfad }
}
func rumpf(von pfad: String) -> [String: Any]? {
guard let daten = anfrage(auf: pfad)?.httpBody else { return nil }
return try? JSONSerialization.jsonObject(with: daten) as? [String: Any]
}
func data(for request: URLRequest) async throws -> (Data, URLResponse) {
sperre.withLock { protokoll.append(request) }
let pfad = request.url?.path ?? ""
let treffer = antworten.first { $0.pfad.isEmpty || pfad.hasSuffix($0.pfad) || pfad == $0.pfad }
?? ("", 404, "")
return (
Data(treffer.rumpf.utf8),
HTTPURLResponse(url: request.url!, statusCode: treffer.status,
httpVersion: nil, headerFields: nil)!
)
}
}
/// Ein Cookieglas, das nur mitschreibt.
///
/// Der Speicher des Systems anzufassen hiesse, dass eine Prüfung die nächste
/// beeinflusst — und auf einem Entwicklerrechner auch den Browser.
final class Cookieglas: FlaroCookieJar, @unchecked Sendable {
private let sperre = NSLock()
private var inhalt: [HTTPCookie] = []
var cookies: [HTTPCookie] { sperre.withLock { inhalt } }
func store(_ cookie: HTTPCookie) { sperre.withLock { inhalt.append(cookie) } }
func removeCookie(named name: String, host: String) {
sperre.withLock { inhalt.removeAll { $0.name == name } }
}
}
enum Proben {
static let adresse = URL(string: "http://nas:8080")!
static let kennung = FlaroIdentity(deviceName: "Prüfgerät", deviceID: "geraet-1")
/// Ein Film mit zwei Tonspuren — der Fall, um den es geht.
static let film = """
{
"id": "film-1", "title": "Der Untergang", "year": 2004,
"overview": "Berlin, April 1945.",
"posterImage": "aaa", "backdropImage": "bbb",
"files": [{
"id": "datei-1", "fileName": "Der Untergang (2004).mkv",
"sizeBytes": 9000000000, "container": "matroska", "durationSeconds": 9360.0,
"streams": [
{"index":0,"kind":"Video","codec":"h264","language":null,"title":null,
"isDefault":true,"isForced":false,"channels":null,"width":1920,"height":1080},
{"index":1,"kind":"Audio","codec":"ac3","language":"deu","title":"Deutsch",
"isDefault":true,"isForced":false,"channels":6,"width":null,"height":null},
{"index":2,"kind":"Audio","codec":"ac3","language":"deu","title":"Audiodeskription",
"isDefault":false,"isForced":false,"channels":2,"width":null,"height":null},
{"index":3,"kind":"Subtitle","codec":"subrip","language":"deu","title":"Deutsch",
"isDefault":false,"isForced":false,"channels":null,"width":null,"height":null}
]
}],
"state": {"positionSeconds":300.0,"runtimeSeconds":9360.0,"watched":false,
"playCount":0,"favourite":false,"rating":null,"dismissed":false,
"lastPlayedAt":"2026-10-03T19:25:04.5209555+00:00"}
}
"""
static let info = """
{"version":"0.1.0","serverName":"Wohnzimmer","needsSetup":false,
"attributions":[{"text":"This product uses TMDB","logoUrl":"https://x/t.svg","url":"https://x"}]}
"""
static let anmeldung = """
{"token":"geheim-123","user":{"id":"u1","userName":"guido","isAdministrator":true}}
"""
}
Packages/FlaroKit/Tests/FlaroServerKitTests/MarkenTests.swift
+73
View File
@@ -0,0 +1,73 @@
import Foundation
import Testing
import MediaKit
@testable import FlaroServerKit
/// Vorspann und Abspann auf dem Weg vom Server in den Spieler.
///
/// **Der Anlass:** im Web erschien der Überspringen-Knopf, in der App nie.
/// Dazwischen liegt genau diese Übersetzung — und ohne Prüfung liesse sich
/// nicht sagen, ob sie der Grund ist oder etwas dahinter.
@Suite("Flaro: Marken")
struct MarkenTests {
private static let folge = """
{
"id": "folge-1", "season": 1, "episode": 6,
"title": "Bestimmung", "overview": null, "stillImage": null,
"files": [{
"id": "datei-1", "fileName": "F.mkv", "sizeBytes": 1,
"container": "mkv", "durationSeconds": 2700, "streams": []
}],
"state": null, "publishAt": null, "seriesId": "serie-1",
"markers": [
{ "kind": "intro", "startSeconds": 30.5, "endSeconds": 65 },
{ "kind": "credits", "startSeconds": 2500, "endSeconds": 2700 }
]
}
"""
@Test("Eine Folge bringt Vorspann und Abspann mit")
func folgeMitMarken() throws {
let roh = try #require(
try? FlaroClient.decoder.decode(Wire.Episode.self, from: Data(Self.folge.utf8)))
let titel = roh.neutral()
#expect(titel.markers.count == 2)
let intro = try #require(titel.markers.first { $0.kind == .intro })
#expect(intro.startMilliseconds == 30_500)
#expect(intro.endMilliseconds == 65_000)
#expect(intro.contains(45_000))
let abspann = try #require(titel.markers.first { $0.kind == .credits })
#expect(abspann.startMilliseconds == 2_500_000)
}
/// Ein älterer Server schickt das Feld gar nicht — das ist kein Fehler.
@Test("Ohne Marken bleibt die Liste leer")
func ohneMarken() throws {
let ohne = """
{
"id": "folge-1", "season": 1, "episode": 6,
"title": "Bestimmung", "overview": null, "stillImage": null,
"files": [], "state": null, "publishAt": null, "seriesId": "serie-1"
}
"""
let roh = try #require(
try? FlaroClient.decoder.decode(Wire.Episode.self, from: Data(ohne.utf8)))
#expect(roh.neutral().markers.isEmpty)
}
/// Ein unbekanntes Wort wirft die Marke nicht weg — sie zählt nur nicht.
@Test("Eine unbekannte Art wird nicht zur falschen")
func unbekannteArt() throws {
let fremd = Self.folge.replacingOccurrences(of: "\"intro\"", with: "\"werbung\"")
let roh = try #require(
try? FlaroClient.decoder.decode(Wire.Episode.self, from: Data(fremd.utf8)))
let titel = roh.neutral()
#expect(titel.markers.count == 2)
#expect(titel.markers.first?.kind == .unknown)
}
}
Packages/FlaroKit/Tests/FlaroServerKitTests/NachbarfolgeTests.swift
+100
View File
@@ -0,0 +1,100 @@
import Foundation
import Testing
import MediaKit
@testable import FlaroServerKit
/// Die Folge nach dieser — über die Staffelgrenze hinweg.
///
/// **Der Anlass.** Im Web stand am Abspann „Nächste Folge", in der App nur
/// „Abspann überspringen". Der Server war es nicht: beide fragen denselben
/// Endpunkt, und er ordnet nach Staffel und dann nach Nummer, findet also
/// auch die erste Folge der nächsten Staffel.
///
/// **Es war der Dekoder.** `nachbar` baute sich einen frischen
/// `JSONDecoder()`, und der kennt das Datumsformat des Servers nicht.
/// Solange die Nachbarfolge weder `publishAt` noch `lastPlayedAt` hatte,
/// ging es gut — mit eingeschalteter Prüfung hat sie ein `publishAt`. Das
/// `try?` schluckte den Fehler, und von aussen sah es aus, als gäbe es
/// keine nächste Folge.
@Suite("Flaro: Nachbarfolge")
struct NachbarfolgeTests {
private func backend(_ transport: any FlaroTransport) -> FlaroBackend {
FlaroBackend(
client: FlaroClient(
baseURL: Proben.adresse, identity: Proben.kennung, token: "t",
transport: transport, cookieJar: nil),
account: FlaroAccount(
baseURL: Proben.adresse, serverName: "Wohnzimmer",
userID: "u1", userName: "guido", isAdministrator: false))
}
private static func folge(
id: String, staffel: Int, nummer: Int,
publishAt: String = "null", zuletzt: String = "null"
) -> String {
"""
{
"id": "\(id)", "season": \(staffel), "episode": \(nummer),
"title": "Neuanfang", "overview": null, "stillImage": null,
"files": [{
"id": "d-\(id)", "fileName": "F.mkv", "sizeBytes": 1,
"container": "mkv", "durationSeconds": 2700, "streams": []
}],
"state": { "positionSeconds": 0, "runtimeSeconds": 2700,
"watched": false, "playCount": 0, "favourite": false,
"rating": null, "dismissed": false,
"lastPlayedAt": \(zuletzt), "inProgress": false },
"publishAt": \(publishAt), "seriesId": "serie-1", "markers": []
}
"""
}
private static let folgeJetzt = MediaItem(
id: "s1e10", kind: .episode, title: "Finale", index: 10, parentIndex: 1)
/// Das Staffelfinale: die nächste Folge ist die erste der nächsten Staffel.
@Test("Über die Staffelgrenze hinweg")
func ueberDieStaffelgrenze() async throws {
let backend = backend(Attrappe(rumpf: Self.folge(id: "s2e1", staffel: 2, nummer: 1)))
let naechste = try #require(await backend.nextEpisode(after: Self.folgeJetzt))
#expect(naechste.id == "s2e1")
#expect(naechste.parentIndex == 2)
#expect(naechste.index == 1)
}
/// **Der Fehler selbst.** Mit `publishAt` und `lastPlayedAt` scheiterte
/// das Lesen stillschweigend, und der Knopf blieb weg. Mit dem frischen
/// `JSONDecoder()` von vorher ist diese Prüfung rot.
@Test("Auch mit Datumsangaben — daran scheiterte es")
func mitDatumsangaben() async throws {
let backend = backend(Attrappe(rumpf: Self.folge(
id: "s2e1", staffel: 2, nummer: 1,
publishAt: "\"2026-10-01T18:00:00Z\"",
zuletzt: "\"2026-10-11T21:14:03.482Z\"")))
let naechste = try #require(await backend.nextEpisode(after: Self.folgeJetzt))
#expect(naechste.id == "s2e1")
#expect(naechste.availableFrom != nil)
}
/// Nach der letzten Folge kommt keine — 204, und das ist kein Fehler.
@Test("Hinter der letzten Folge kommt nichts")
func hinterDerLetzten() async throws {
let backend = backend(Attrappe(rumpf: "", status: 204))
#expect(try await backend.nextEpisode(after: Self.folgeJetzt) == nil)
}
/// Ein Film hat keine Nachbarn — und fragt gar nicht erst.
@Test("Ein Film fragt nicht nach Nachbarn")
func filmFragtNicht() async throws {
let attrappe = Attrappe(rumpf: Self.folge(id: "x", staffel: 1, nummer: 1))
let film = MediaItem(id: "f1", kind: .movie, title: "Arrival")
#expect(try await backend(attrappe).nextEpisode(after: film) == nil)
#expect(attrappe.anfragen.isEmpty)
}
}
Packages/FlaroKit/Tests/FlaroServerKitTests/UebersetzungTests.swift
+262
View File
@@ -0,0 +1,262 @@
import Foundation
import Testing
import MediaKit
@testable import FlaroServerKit
/// Aus Flaros Antworten werden neutrale Typen — ohne Verlust.
@Suite("Flaro: Übersetzung")
struct UebersetzungTests {
private func backend(_ transport: any FlaroTransport) -> FlaroBackend {
FlaroBackend(
client: FlaroClient(
baseURL: Proben.adresse, identity: Proben.kennung, token: "t",
transport: transport, cookieJar: nil),
account: FlaroAccount(
baseURL: Proben.adresse, serverName: "Wohnzimmer",
userID: "u1", userName: "guido", isAdministrator: false))
}
/// **Beide Tonspuren kommen an, mit Namen und Nummer.**
///
/// Das ist der ganze Anlass: eine Datei mit „Deutsch" und
/// „Audiodeskription", und die App muss beide sehen, um nicht blind die
/// falsche zu nehmen.
@Test("Ein Film behält alle Spuren")
func filmMitZweiTonspuren() async throws {
let film = try #require(try? FlaroClient.decoder.decode(Wire.Movie.self, from: Data(Proben.film.utf8)))
let titel = film.neutral()
let datei = try #require(titel.versions.first?.files.first)
#expect(titel.title == "Der Untergang")
#expect(titel.year == 2004)
#expect(datei.audioStreams.count == 2)
#expect(datei.audioStreams.map(\.title) == ["Deutsch", "Audiodeskription"])
// Die Nummer muss zurückrechenbar sein — daran hängt die Spurwahl.
#expect(datei.audioStreams.map(\.index) == [1, 2])
#expect(datei.subtitleStreams.count == 1)
#expect(datei.videoStream?.codec == "h264")
}
/// Fünf Minuten von zwei Stunden sechsunddreissig — die Stelle, die
/// Jellyfin wegwirft.
@Test("Der Stand kommt als Fortschritt an")
func standWirdFortschritt() throws {
let film = try #require(try? FlaroClient.decoder.decode(Wire.Movie.self, from: Data(Proben.film.utf8)))
let titel = film.neutral()
#expect(titel.resumeMilliseconds == 300_000)
#expect(titel.duration == 9_360_000)
#expect(titel.isWatched == false)
let anteil = try #require(titel.watchProgress)
#expect(abs(anteil - 300.0 / 9360.0) < 0.0001)
}
/// ASP.NET Core schreibt Bruchteile von Sekunden mit.
///
/// **Der Standarddekoder scheitert daran**, und zwar stumm bis zur
/// Stelle, an der jemand das Datum liest. Hier stehen beide nebeneinander,
/// damit sichtbar bleibt, dass die eigene Strategie keine Verzierung ist.
@Test("Ein Datum mit Sekundenbruchteilen wird gelesen")
func datumMitBruch() async throws {
let roh = Data(Proben.film.utf8)
#expect((try? JSONDecoder().decode(Wire.Movie.self, from: roh)) == nil,
"2026-10-03T19:25:04.5209555+00:00 ist für .iso8601 kein Datum")
#expect((try? FlaroClient.decoder.decode(Wire.Movie.self, from: roh)) != nil)
let transport = Attrappe(rumpf: #"{"items":[\#(Proben.film)],"total":1}"#)
let seite = try await backend(transport).items(
inLibrary: MediaLibrary(id: "b1", title: "Filme", kind: .movie),
query: MediaQuery(), offset: 0, limit: 50)
#expect(seite.items.first?.lastPlayedAt != nil)
}
/// Der Server zählt, was offen ist; die App rechnet mit der Gegenzahl.
@Test("Offene Folgen werden zu gesehenen")
func serieZaehlt() throws {
let roh = """
{"id":"s1","title":"Dark","year":2017,"overview":null,
"posterImage":"p","backdropImage":"b",
"episodeCount":10,"seasons":[1,2],"unwatchedCount":3}
"""
let serie = try FlaroClient.decoder.decode(Wire.Series.self, from: Data(roh.utf8))
let titel = serie.neutral()
#expect(titel.kind == .show)
#expect(titel.episodeCount == 10)
#expect(titel.playedEpisodeCount == 7)
#expect(titel.childCount == 2)
}
/// **Oben die Serie, darunter die Folge.** Eine Kachel, die nur
/// „Lügen" sagt, hilft beim Wiedererkennen nicht.
@Test("Eine Folge aus Weiterschauen trägt ihre Serie mit")
func weiterschauenFolge() throws {
let roh = """
{"id":"f2","kind":"episode","title":"Dark","subTitle":"Lügen",
"season":1,"episode":2,"year":null,"posterImage":"p","backdropImage":"still",
"state":{"positionSeconds":400.0,"runtimeSeconds":2700.0,"watched":false,
"playCount":0,"favourite":false,"rating":null,"dismissed":false,
"lastPlayedAt":null}}
"""
let eintrag = try FlaroClient.decoder.decode(Wire.Started.self, from: Data(roh.utf8))
let titel = eintrag.neutral()
#expect(titel.kind == .episode)
#expect(titel.title == "Lügen")
#expect(titel.seriesTitle == "Dark")
#expect(titel.parentIndex == 1)
#expect(titel.index == 2)
#expect(titel.resumeMilliseconds == 400_000)
}
@Test("Mediatheken: Shows werden Serien, alles andere Filme")
func mediatheken() async throws {
let transport = Attrappe(rumpf: """
[{"id":"b1","name":"Filme","kind":"Movies","path":"/media/Filme"},
{"id":"b2","name":"Serien","kind":"Shows","path":"/media/Serien"}]
""")
let liste = try await backend(transport).libraries()
#expect(liste.map(\.kind) == [.movie, .show])
#expect(liste.map(\.title) == ["Filme", "Serien"])
}
/// Nach der letzten Folge kommt keine — 204, kein Fehler.
@Test("Hinter der letzten Folge steht nichts")
func keineNaechsteFolge() async throws {
let transport = Attrappe(rumpf: "", status: 204)
let folge = MediaItem(id: "f9", kind: .episode, title: "Letzte")
let naechste = try await backend(transport).nextEpisode(after: folge)
#expect(naechste == nil)
}
@Test("Eine Fortschrittsmeldung geht in Sekunden hinaus")
func fortschrittMelden() async {
let transport = Attrappe(rumpf: "{}")
await backend(transport).reportProgress(PlaybackReport(
itemID: "film-1", state: .playing,
time: .seconds(300), duration: .seconds(9360)))
let rumpf = transport.rumpf(von: "/api/v1/items/film-1/progress")
#expect(transport.letzte?.httpMethod == "POST")
#expect(rumpf?["positionSeconds"] as? Double == 300)
#expect(rumpf?["runtimeSeconds"] as? Double == 9360)
}
/// **Flaro hat einen eigenen Weg dafür — nur deshalb bleibt die Stelle.**
/// Bei Jellyfin wird hier das Benutzerdatenblatt überschrieben.
@Test("Weglegen ist nicht dasselbe wie gesehen")
func weglegen() async throws {
let transport = Attrappe(rumpf: "{}")
try await backend(transport).removeFromContinueWatching(
MediaItem(id: "film-1", title: "Der Untergang"))
#expect(transport.letzte?.url?.path == "/api/v1/items/film-1/dismiss")
#expect(transport.letzte?.httpMethod == "POST")
}
@Test("Gesehen und ungesehen gehen an dieselbe Stelle, mit anderem Wert")
func gesehenMelden() async throws {
let transport = Attrappe(rumpf: "{}")
let b = backend(transport)
try await b.markWatched(id: "film-1")
#expect(transport.rumpf(von: "/api/v1/items/film-1/watched")?["watched"] as? Bool == true)
try await b.markUnwatched(id: "film-1")
#expect(transport.rumpf(von: "/api/v1/items/film-1/watched")?["watched"] as? Bool == false)
#expect(transport.letzte?.httpMethod == "PUT")
}
// --- Abspielen -----------------------------------------------------
/// **Direkt spielbar: sofort los.**
@Test("Eine MP4 geht ohne Umweg hinaus")
func direkteWiedergabe() async throws {
let transport = Attrappe(rumpf: """
{"method":"directFile","reasons":[],"audioToEncode":[],"subtitlesDropped":[],
"packageState":"none","progress":0.0,"error":null}
""")
let ziel = try await backend(transport).preparePlayback(PlaybackIntent(
itemID: "film-1", versionIndex: 0, file: MediaFile(id: "datei-1")))
#expect(ziel.url.path == "/api/v1/files/datei-1/download")
// Flaro legt für eine Wiedergabe nichts an, das aufzuräumen wäre.
#expect(ziel.sessionID == nil)
}
/// **Der Fehler, den erst der Simulator zeigte.**
///
/// Muss der Server umpacken, antwortet er auf den Download mit 202 und
/// fängt an. AVPlayer bekommt darauf kein Video, sondern eine leere
/// Antwort — und wartet. Unbegrenzt, ohne Fehler, mit einem Spinner:
/// „Stelle wird wiederhergestellt", 0:00, für immer.
@Test("Ein Umpacken wird abgewartet, nicht überholt")
func wartetAufsUmpacken() async throws {
let transport = Fortschrittsattrappe()
let ziel = try await backend(transport).preparePlayback(PlaybackIntent(
itemID: "film-1", versionIndex: 0, file: MediaFile(id: "datei-1")))
#expect(ziel.url.path == "/api/v1/files/datei-1/download")
#expect(transport.abfragen >= 2, "es wurde nachgefragt, nicht einmal geschaut")
}
/// Eine Absage des Servers ist eine Absage, kein Weiterwarten.
@Test("Ein gescheitertes Umpacken kommt als Begründung an")
func gescheitertesUmpacken() async {
let transport = Attrappe(rumpf: """
{"method":"remux","reasons":["matroska"],"audioToEncode":[],"subtitlesDropped":[],
"packageState":"failed","progress":0.0,"error":"ffmpeg ist abgestürzt."}
""")
let b = backend(transport)
await #expect(throws: MediaBackendError.refused(reason: "ffmpeg ist abgestürzt.")) {
_ = try await b.preparePlayback(PlaybackIntent(
itemID: "film-1", versionIndex: 0, file: MediaFile(id: "datei-1")))
}
}
/// Flaro kennt noch keine Schlagwörter — eine leere Liste, kein Fehler.
@Test("Ohne Schlagwörter bleibt der Filter leer statt kaputt")
func keineSchlagwoerter() async throws {
let optionen = try await backend(Attrappe(rumpf: "{}")).filterOptions(
inLibrary: MediaLibrary(id: "b1", title: "Filme", kind: .movie), field: .genre)
#expect(optionen.isEmpty)
}
}
/// Antwortet beim ersten Mal „läuft noch", danach „fertig".
///
/// Damit prüfbar ist, dass gewartet wird — eine Attrappe mit immer derselben
/// Antwort könnte das nicht von „einmal geschaut und losgelaufen" trennen.
final class Fortschrittsattrappe: FlaroTransport, @unchecked Sendable {
private let sperre = NSLock()
private var runde = 0
var abfragen: Int { sperre.withLock { runde } }
func data(for request: URLRequest) async throws -> (Data, URLResponse) {
let pfad = request.url?.path ?? ""
let fertig: Bool = sperre.withLock {
if pfad.hasSuffix("/delivery") { runde += 1 }
return runde > 1
}
let rumpf = """
{"method":"remux","reasons":["matroska"],"audioToEncode":[],"subtitlesDropped":[],
"packageState":"\(fertig ? "ready" : "running")","progress":\(fertig ? 1.0 : 0.4),"error":null}
"""
return (Data(rumpf.utf8),
HTTPURLResponse(url: request.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!)
}
}
Packages/FlaroKit/Tests/MediaKitTests/FortschrittspostTests.swift
+117
View File
@@ -0,0 +1,117 @@
import Foundation
import Testing
@testable import MediaKit
/// Ein Server, der auf Ansage annimmt oder nicht.
private final class Briefkasten: Fortschrittsempfaenger, @unchecked Sendable {
nonisolated let identity: String
/// Ob Meldungen angenommen werden.
var nimmtAn: Bool
private(set) var angekommen: [PlaybackReport] = []
init(identity: String = "server-a", nimmtAn: Bool = true) {
self.identity = identity
self.nimmtAn = nimmtAn
}
func reportProgress(_ report: PlaybackReport) async -> Bool {
guard nimmtAn else { return false }
angekommen.append(report)
return true
}
}
private func bericht(_ titel: String, sekunden: Double) -> PlaybackReport {
PlaybackReport(
itemID: titel,
state: .stopped,
time: .seconds(sekunden),
duration: .seconds(3600)
)
}
@Suite("Nachgereichter Fortschritt")
@MainActor
struct FortschrittspostTests {
/// Eine eigene Datei je Prüfung — sonst sähe die zweite, was die erste
/// liegen gelassen hat.
private func ablage() -> URL {
FileManager.default.temporaryDirectory
.appending(path: "post-\(UUID().uuidString).json")
}
@Test("Was ankam, wird nicht aufgehoben")
func nichtsLiegenLassen() async {
let post = Fortschrittspost(ablage: ablage())
let server = Briefkasten()
post.zuruecklegen(bericht("film", sekunden: 600), server: server.identity)
#expect(post.wartend == 1)
await post.zustellen(über: server)
#expect(post.wartend == 0)
#expect(server.angekommen.count == 1)
#expect(server.angekommen.first?.itemID == "film")
}
@Test("Was nicht ankommt, bleibt liegen")
func liegenbleiben() async {
let post = Fortschrittspost(ablage: ablage())
let server = Briefkasten(nimmtAn: false)
post.zuruecklegen(bericht("film", sekunden: 600), server: server.identity)
await post.zustellen(über: server)
#expect(post.wartend == 1)
server.nimmtAn = true
await post.zustellen(über: server)
#expect(post.wartend == 0)
}
@Test("Je Titel nur der letzte Stand")
func nurDerLetzteStand() async {
let post = Fortschrittspost(ablage: ablage())
let server = Briefkasten()
post.zuruecklegen(bericht("film", sekunden: 60), server: server.identity)
post.zuruecklegen(bericht("film", sekunden: 1800), server: server.identity)
#expect(post.wartend == 1)
await post.zustellen(über: server)
#expect(server.angekommen.count == 1)
#expect(server.angekommen.first?.time == .seconds(1800))
}
@Test("Ein fremder Server bekommt nichts")
func nichtAnDenFalschen() async {
let post = Fortschrittspost(ablage: ablage())
post.zuruecklegen(bericht("film", sekunden: 600), server: "server-a")
let anderer = Briefkasten(identity: "server-b")
await post.zustellen(über: anderer)
#expect(anderer.angekommen.isEmpty)
#expect(post.wartend == 1)
}
@Test("Der Briefkasten überlebt den Neustart")
func aufDerPlatte() async {
let datei = ablage()
let erste = Fortschrittspost(ablage: datei)
erste.zuruecklegen(bericht("folge", sekunden: 900), server: "server-a")
let zweite = Fortschrittspost(ablage: datei)
#expect(zweite.wartend == 1)
let server = Briefkasten()
await zweite.zustellen(über: server)
#expect(server.angekommen.first?.time == .seconds(900))
}
@Test("Leeren wirft alles weg")
func leeren() async {
let post = Fortschrittspost(ablage: ablage())
post.zuruecklegen(bericht("film", sekunden: 600), server: "server-a")
post.leeren()
#expect(post.wartend == 0)
}
}
Packages/FlaroKit/Tests/MediaKitTests/LibraryCacheHomeTests.swift
+65
View File
@@ -0,0 +1,65 @@
import Foundation
import Testing
@testable import MediaKit
@Suite("Die gemerkte Startseite")
struct LibraryCacheHomeTests {
private func speicher() -> LibraryCache {
LibraryCache(root: FileManager.default.temporaryDirectory
.appending(path: "cache-\(UUID().uuidString)", directoryHint: .isDirectory))
}
private func titel(_ nummer: Int) -> MediaItem {
MediaItem(id: "t\(nummer)", kind: .movie, title: "Titel \(nummer)", thumb: "/bild/\(nummer)")
}
@Test("Was gespeichert wurde, kommt zurück")
func hinUndZurueck() async {
let cache = speicher()
let reihen = [
MediaRowGroup(id: "continue", title: "Weiterschauen",
libraryID: "mediathek", items: [titel(1), titel(2)]),
MediaRowGroup(id: "latest.1", title: "Neu", moreKey: "/mehr", items: [titel(3)]),
]
await cache.storeHomeRows(reihen, server: "server-a")
let gemerkt = await cache.homeRows(server: "server-a")
#expect(gemerkt?.map(\.id) == ["continue", "latest.1"])
#expect(gemerkt?.first?.title == "Weiterschauen")
#expect(gemerkt?.first?.libraryID == "mediathek")
#expect(gemerkt?.last?.moreKey == "/mehr")
#expect(gemerkt?.first?.items.map(\.id) == ["t1", "t2"])
// Ohne den Bildpfad wäre der Abzug wertlos: die Plakate liegen
// bereits auf der Platte, nur findet sie dann niemand.
#expect(gemerkt?.first?.items.first?.thumb == "/bild/1")
}
@Test("Ein anderer Server hat seine eigene Startseite")
func getrenntJeServer() async {
let cache = speicher()
await cache.storeHomeRows(
[MediaRowGroup(id: "continue", title: "Weiterschauen", items: [titel(1)])],
server: "server-a"
)
let fremd = await cache.homeRows(server: "server-b")
#expect(fremd == nil)
}
@Test("Ohne gespeicherten Stand kommt nichts")
func nochNichtsDa() async {
let gemerkt = await speicher().homeRows(server: "server-a")
#expect(gemerkt == nil)
}
@Test("Lange Reihen werden gekürzt")
func nichtAlles() async {
let cache = speicher()
let lang = (1...80).map(titel)
await cache.storeHomeRows(
[MediaRowGroup(id: "latest", title: "Neu", items: lang)], server: "server-a"
)
let gemerkt = await cache.homeRows(server: "server-a")
#expect(gemerkt?.first?.items.count == 20)
}
}
Tools/demo-medien.sh
Executable
+53
View File
@@ -0,0 +1,53 @@
#!/bin/bash
# Erzeugt einen kleinen Bestand zum Ausprobieren: echte Dateinamen, winzige
# Dateien. Jede ist eine Sekunde Testbild mit Ton — damit der Scan, die
# Metadaten und das Umpacken etwas zu tun haben, ohne Gigabytes zu brauchen.
set -euo pipefail
ZIEL="${1:-$HOME/.flaro-medien}"
command -v ffmpeg >/dev/null || { echo "ffmpeg fehlt."; exit 1; }
mach() { # mach <pfad> <schachtel> [zweite-tonspur]
mkdir -p "$(dirname "$1")"
if [ "${3:-}" = "zwei" ]; then
ffmpeg -y -loglevel error \
-f lavfi -i "testsrc=duration=2:size=320x240:rate=12" \
-f lavfi -i "sine=frequency=440:duration=2" \
-f lavfi -i "sine=frequency=880:duration=2" \
-map 0:v -map 1:a -map 2:a \
-metadata:s:a:0 language=deu -metadata:s:a:0 title=Deutsch \
-metadata:s:a:1 language=deu -metadata:s:a:1 title=Audiodeskription \
-c:v libx264 -preset ultrafast -c:a aac "$1"
else
ffmpeg -y -loglevel error \
-f lavfi -i "testsrc=duration=2:size=320x240:rate=12" \
-f lavfi -i "sine=frequency=440:duration=2" \
-c:v libx264 -preset ultrafast -c:a aac "$1"
fi
echo " $(basename "$1")"
}
echo "Filme:"
mach "$ZIEL/Filme/Der Untergang (2004)/Der Untergang (2004).mkv" mkv zwei
mach "$ZIEL/Filme/The Matrix (1999)/The Matrix (1999).mkv" mkv
mach "$ZIEL/Filme/Blade Runner 2049 (2017)/Blade Runner 2049 (2017).mp4" mp4
mach "$ZIEL/Filme/Inception (2010)/Inception (2010).mkv" mkv
echo "Serien:"
mach "$ZIEL/Serien/Dark/Staffel 1/Dark - S01E01.mkv" mkv
mach "$ZIEL/Serien/Dark/Staffel 1/Dark - S01E02.mkv" mkv
mach "$ZIEL/Serien/Dark/Staffel 2/Dark - S02E01.mkv" mkv
mach "$ZIEL/Serien/Notruf Hafenkante/Staffel 1/Notruf Hafenkante - S01E01.mkv" mkv zwei
# **Eine zweite Filmbibliothek, und das ist Absicht.** Mit nur „Filme" und
# „Serien" lässt sich nicht prüfen, ob mehrere Mediatheken wirklich getrennt
# bleiben — zwei Bestände derselben Art sind der Fall, in dem es auffällt.
echo "Dokumentationen:"
mach "$ZIEL/Dokus/Nomaden der Lüfte (2001)/Nomaden der Lüfte (2001).mkv" mkv
mach "$ZIEL/Dokus/Unsere Erde (2007)/Unsere Erde (2007).mp4" mp4
echo "Konzerte:"
mach "$ZIEL/Konzerte/Stop Making Sense (1984)/Stop Making Sense (1984).mkv" mkv zwei
chmod -R a+rwX "$ZIEL"
echo
echo "Fertig: $ZIEL"
Tools/image-veroeffentlichen.sh
Executable
+148
View File
@@ -0,0 +1,148 @@
#!/bin/bash
# Baut das Flaro-Image für beide Architekturen und legt es in die Registry.
#
# **Der Weg von Hand** — für den Fall, dass kein Gitea-Runner läuft. Sonst
# macht das `.gitea/workflows/image.yml` bei jedem Push von selbst.
#
# Tools/image-veroeffentlichen.sh → :latest
# Tools/image-veroeffentlichen.sh 0.2.0 → :latest und :0.2.0
#
# Nur eine Architektur — deutlich schneller, weil die fremde sonst unter
# Emulation läuft:
#
# FLARO_PLATTFORMEN=linux/amd64 Tools/image-veroeffentlichen.sh
#
# Vorher einmalig anmelden — das Passwort tippst du selbst ein:
#
# docker login git.scarriffle.com
set -euo pipefail
REGISTRY="${FLARO_REGISTRY:-git.scarriffle.com}"
PFAD="${FLARO_IMAGE_PATH:-scarriffle/flaro}"
BILD="$REGISTRY/$PFAD"
FASSUNG="${1:-}"
PLATTFORMEN="${FLARO_PLATTFORMEN:-linux/amd64,linux/arm64}"
cd "$(dirname "$0")/.."
command -v docker >/dev/null || { echo "docker fehlt."; exit 1; }
# **Ohne Anmeldung bricht der Push erst nach dem ganzen Bau ab.** Zwei
# Minuten Arbeit für eine Fehlermeldung, die am Anfang gestanden hätte.
# Kein `docker info | grep -q`: `grep -q` beendet die Pipe beim ersten
# Treffer, Docker bekommt SIGPIPE, und mit `set -o pipefail` gilt das als
# Fehlschlag. Die Prüfung meldete dann „Docker läuft nicht", während es lief.
if ! docker info >/dev/null 2>&1; then
echo "Docker läuft nicht."; exit 1
fi
if ! grep -q "$REGISTRY" ~/.docker/config.json 2>/dev/null; then
echo "Nicht an $REGISTRY angemeldet. Erst:"
echo
echo " docker login $REGISTRY"
exit 1
fi
# **Vor dem Bauen, nicht danach.** Laufen App und Browser farblich
# auseinander, soll das auffallen, bevor ein Image daraus wird.
if command -v python3 >/dev/null && [ -f Tools/tokens-pruefen.py ]; then
python3 Tools/tokens-pruefen.py || {
echo
echo "Abgebrochen. Mit FLARO_DRIFT_EGAL=1 trotzdem bauen."
[ "${FLARO_DRIFT_EGAL:-}" = "1" ] || exit 1
}
fi
# Fragt die Registry, welcher Stand dort unter `latest` liegt.
#
# Anonym — das Paket ist öffentlich lesbar. Schlägt es fehl, ist die Antwort
# leer, und der Aufrufer entscheidet, was das bedeutet.
registry_digest() {
local token
token=$(curl -fsS --max-time 20 \
"https://$REGISTRY/v2/token?scope=repository:$PFAD:pull&service=container_registry" \
| python3 -c 'import json,sys;print(json.load(sys.stdin).get("token",""))' 2>/dev/null) || return 1
[ -n "$token" ] || return 1
curl -fsS --max-time 20 -D- -o /dev/null \
-H "Authorization: Bearer $token" \
-H "Accept: application/vnd.oci.image.index.v1+json" \
"https://$REGISTRY/v2/$PFAD/manifests/latest" 2>/dev/null \
| awk 'BEGIN{IGNORECASE=1} /^docker-content-digest:/ {print $2}' | tr -d '\r'
}
MARKEN=(-t "$BILD:latest")
[ -n "$FASSUNG" ] && MARKEN+=(-t "$BILD:$FASSUNG")
# **Eine Kennung je Bau.**
#
# Sechs Zeichen, jedes Mal neu — auch bei unverändertem Quelltext. Sie landet
# im Abbild und steht danach in der Oberfläche unter „Einstellungen" sowie
# unter `/health`. Damit ist die Frage „läuft auf dem NAS wirklich der Bau von
# eben?" in zwei Sekunden beantwortet statt in einem halben Tag.
#
# Ohne I, O, 0 und 1: diese Kennung wird vorgelesen und abgetippt.
#
# **Nicht `tr < /dev/urandom | head -c 6`.** `head` schliesst die Pipe nach
# sechs Zeichen, `tr` bekommt SIGPIPE, und mit `set -o pipefail` gilt das als
# Fehlschlag — das Skript brach mit 141 ab, bevor es irgendetwas gebaut hatte.
# Dieselbe Falle wie oben bei `grep -q`, und sie hat hier zweimal zugeschlagen.
BUILD=$(python3 -c "import secrets; print(''.join(secrets.choice('ABCDEFGHJKLMNPQRSTUVWXYZ23456789') for _ in range(6)))")
echo "Build-Kennung dieses Laufs: $BUILD"
# **Ein eigener Builder.** Der Vorgabe-Builder von Docker Desktop kann kein
# Manifest mit zwei Architekturen bauen; `docker buildx create` schon.
docker buildx inspect flaro-bauer >/dev/null 2>&1 \
|| docker buildx create --name flaro-bauer --use >/dev/null
# **Den Digest festhalten, bevor gebaut wird.** Nur so lässt sich hinterher
# sagen, ob wirklich etwas Neues angekommen ist.
vorher=$(registry_digest || true)
echo "Baue $BILD für $PLATTFORMEN."
if ! docker buildx build \
--builder flaro-bauer \
--platform "$PLATTFORMEN" \
-f server/Dockerfile \
--build-arg "FLARO_BUILD=$BUILD" \
"${MARKEN[@]}" \
--push . ; then
echo
echo "Der Bau oder das Hochladen ist gescheitert. In der Registry liegt weiter:"
echo " ${vorher:-nichts}"
exit 1
fi
# **Nachsehen, statt zu glauben.**
#
# `docker buildx build --push` hat bei einem abgebrochenen Upload schon mit
# Rückgabewert 0 beendet, nachdem es „ERROR: failed to build" gedruckt hatte —
# ein TLS-Zeitlimit mitten im Hochladen. Das Skript meldete Erfolg, in der
# Registry lag das alte Image, und auf dem NAS kam eine Fassung an, die
# niemand gebaut hatte. Seitdem wird gefragt, nicht vertraut.
nachher=$(registry_digest || true)
if [ -z "$nachher" ]; then
echo
echo "Die Registry antwortet nicht auf $BILD:latest — hochgeladen wurde offenbar nichts."
exit 1
fi
if [ -n "$vorher" ] && [ "$vorher" = "$nachher" ]; then
echo
echo "In der Registry liegt noch derselbe Stand wie vorher:"
echo " $nachher"
echo "Das Hochladen ist also nicht durchgekommen. Noch einmal versuchen."
exit 1
fi
echo
echo "Fertig. In der Registry liegt jetzt:"
echo " $nachher"
echo
echo "Build-Kennung: $BUILD"
echo " Dieselbe muss nach dem Ziehen unter Einstellungen stehen."
echo " Steht dort eine andere, läuft auf dem NAS ein älteres Abbild."
echo
echo "Auf dem NAS:"
echo " image: $BILD:${FASSUNG:-latest}"
Tools/tokens-pruefen.py
Executable
+142
View File
@@ -0,0 +1,142 @@
#!/usr/bin/env python3
"""Prüft, ob App und Weboberfläche dieselben Farben und Formen benutzen.
**Warum es das braucht.** Die Werte stehen an mehreren Stellen von Hand
abgeschrieben — in Swift für die Apps, in CSS für den Browser. Sie sind
auseinandergelaufen, und zwar unsichtbar: `#1D1D21` gegen `#1D1D22`,
`#A0A0A8` gegen `#B4B4BE`, Radius 8 gegen 6. Einzeln merkt das niemand.
Zusammen sorgen sie dafür, dass App und Browser nicht wie dasselbe Programm
aussehen.
**Warum kein Generator.** Einer müsste Swift erzeugen, und erzeugter Swift
lässt sich schlechter lesen und kommentieren als geschriebener. Diese Prüfung
kostet weniger und fängt dasselbe ab: sie sagt, dass etwas auseinanderläuft,
und überlässt die Entscheidung dem Menschen.
Aufruf: python3 Tools/tokens-pruefen.py
Rückgabe: 0, wenn alles übereinstimmt; sonst 1.
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
SWIFT_FARBEN = WURZEL / "Packages/FlaroKit/Sources/FlaroDesign/Color/FlaroColor.swift"
SWIFT_AKZENT = WURZEL / "Packages/FlaroKit/Sources/FlaroDesign/Color/AccentOption.swift"
SWIFT_FORMEN = WURZEL / "Packages/FlaroKit/Sources/FlaroDesign/FlaroFont.swift"
CSS = WURZEL / "web/app/src/style.css"
# Was womit zusammengehört. Links der Swift-Name, rechts das CSS-Token.
FARBEN = {
"canvas": "--canvas",
"surface": "--surface",
"elevated": "--elevated",
"placeholder": "--placeholder",
"textPrimary": "--text",
"textSecondary": "--text-dim",
"textMuted": "--text-muted",
"destructive": "--destructive",
}
# Radien: Swift-Name → CSS-Token. `sheet` und `panel` haben im Browser kein
# Gegenstück — dort gibt es keine Blätter und keine schwebende Seitenleiste.
RADIEN = {
"card": "--r-karte",
"control": "--r-flaeche",
}
def hex_aus_swift(text: str, name: str) -> str | None:
"""Liest `static let name = RGB(hex: 0xAABBCC)` oder `RGB(0xAABBCC)`."""
m = re.search(rf"\b{name}\b[^\n=]*=\s*[^\n]*?0x([0-9A-Fa-f]{{6}})", text)
return "#" + m.group(1).upper() if m else None
def ohne_tvos(text: str) -> str:
"""Entfernt die tvOS-Zweige.
**Sonst vergleicht man den falschen Wert.** `FlaroRadius.card` ist 8 —
und auf tvOS 12, weil aus drei Metern eine stärkere Rundung nötig ist.
Der Browser läuft nie auf einem Fernseher; massgeblich ist der andere Zweig.
"""
return re.sub(r"#if os\(tvOS\).*?(?:#else(.*?))?#endif", lambda m: m.group(1) or "",
text, flags=re.S)
def zahl_aus_swift(text: str, name: str) -> float | None:
"""Liest den ersten Zahlenwert hinter `static let name`."""
m = re.search(rf"\b{name}\b\s*:\s*CGFloat\s*(?:\{{[^}}]*?return\s*)?([0-9]+(?:\.[0-9]+)?)", text, re.S)
if m:
return float(m.group(1))
m = re.search(rf"\b{name}\b[^\n=]*=\s*([0-9]+(?:\.[0-9]+)?)", text)
return float(m.group(1)) if m else None
def token_aus_css(text: str, name: str) -> str | None:
m = re.search(rf"{re.escape(name)}\s*:\s*([^;]+);", text)
return m.group(1).strip() if m else None
def main() -> int:
fehlend = [p for p in (SWIFT_FARBEN, SWIFT_AKZENT, SWIFT_FORMEN, CSS) if not p.exists()]
if fehlend:
for p in fehlend:
print(f"Nicht gefunden: {p.relative_to(WURZEL)}")
return 1
farben_swift = SWIFT_FARBEN.read_text(encoding="utf-8")
akzent_swift = SWIFT_AKZENT.read_text(encoding="utf-8")
formen_swift = ohne_tvos(SWIFT_FORMEN.read_text(encoding="utf-8"))
css = CSS.read_text(encoding="utf-8")
abweichungen: list[str] = []
geprueft = 0
for swift_name, css_name in FARBEN.items():
a = hex_aus_swift(farben_swift, swift_name)
b = token_aus_css(css, css_name)
if a is None or b is None:
abweichungen.append(f" {swift_name} / {css_name}: nicht gefunden ({a} / {b})")
continue
geprueft += 1
if a.upper() != b.upper():
abweichungen.append(f" {swift_name}: Swift {a}, CSS {css_name} {b}")
# Die Vorgabefarbe der App gegen den Akzent im Browser.
vorgabe = re.search(r'identifier\s*==\s*"([a-z]+)"', akzent_swift)
if not vorgabe:
vorgabe = re.search(r'\.first\s*\{\s*\$0\.id\s*==\s*"([a-z]+)"', akzent_swift)
if vorgabe:
hex_vorgabe = hex_aus_swift(akzent_swift, vorgabe.group(1))
akzent_css = token_aus_css(css, "--accent")
if hex_vorgabe and akzent_css:
geprueft += 1
if hex_vorgabe.upper() != akzent_css.upper():
abweichungen.append(
f" Vorgabe-Akzent: Swift {vorgabe.group(1)} {hex_vorgabe}, CSS {akzent_css}")
for swift_name, css_name in RADIEN.items():
a = zahl_aus_swift(formen_swift, swift_name)
b = token_aus_css(css, css_name)
if a is None or b is None:
abweichungen.append(f" Radius {swift_name} / {css_name}: nicht gefunden ({a} / {b})")
continue
geprueft += 1
b_zahl = float(re.sub(r"[^0-9.]", "", b) or 0)
if abs(a - b_zahl) > 0.01:
abweichungen.append(f" Radius {swift_name}: Swift {a:g}, CSS {css_name} {b}")
if abweichungen:
print(f"App und Weboberfläche laufen auseinander ({len(abweichungen)} Stelle(n)):")
print("\n".join(abweichungen))
print("\nFlaroDesign ist massgeblich — die CSS zieht nach.")
return 1
print(f"App und Weboberfläche stimmen überein ({geprueft} Werte geprüft).")
return 0
if __name__ == "__main__":
sys.exit(main())
docs/ABSPANN-IM-BILD.md
+167
View File
@@ -0,0 +1,167 @@
# Den Abspann im Bild finden — Entwurf
Der Tonabgleich findet Vorspann und Abspann, **weil sie sich wiederholen**:
dieselbe Musik in Folge 1 und Folge 2. Ein Film hat nichts, womit er sich
vergleichen liesse. Sein Abspann kommt genau einmal vor.
Was bleibt, ist das Bild. Dieser Entwurf sagt, was daran messbar ist, was es
kostet, und wo das Verfahren danebenliegt.
Kapitelmarken sind hier bewusst **nicht** der Weg: sie sind exakt, wo sie
stehen, aber bei einer gemischten Sammlung stehen sie selten.
---
## 1 · Das Signal, nachgemessen
Ein Abspann ist dunkel. Das ist keine Vermutung — nachgestellt mit einem
erzeugten Film (90 Sekunden Bild, danach 40 Sekunden weisse Schrift auf
schwarzem Grund), abgetastet mit zwei Bildern je Sekunde:
| Stelle | mittlere Helligkeit (`YAVG`, 0–255) |
|---|---|
| 0–89,5 s (Handlung) | **125** |
| ab 90,0 s (Abspann) | **18** |
Der Sprung liegt auf dem Bild genau, an dem der Abspann anfängt. Kein
Übergang, keine Grauzone — und das ist der Punkt: gesucht wird nicht „ein
dunkles Bild", sondern **die Kante**.
Dieselbe Richtung geht Jellyfins Intro Skipper. Dort heisst es
„Add support for using black frames to locate ending credits"; die Suche
läuft rückwärts vom Ende und hört auf, wenn der Bereich auf vier Sekunden
geschrumpft ist.
## 2 · Was es kostet
Das Rechnen ist umsonst, das **Dekodieren** ist der Preis. Gemessen an einer
erzeugten Datei, 1080p, h264, 180 Sekunden:
| Weg | Zeit |
|---|---|
| Jedes zweite Bild dekodieren (`fps=2`) | **2,89 s** |
| Nur Schlüsselbilder (`-skip_frame nokey`) | **0,24 s** |
Hochgerechnet auf die letzten 15 Minuten eines Films: der erste Weg kostet
rund anderthalb Minuten je Film, der zweite ein paar Sekunden. *Das ist eine
Hochrechnung, keine Messung an echtem Material.*
Es geht noch billiger, und so macht es Jellyfin: **nicht am Stück abtasten,
sondern zielen.** Binäre Suche mit Sonden von zwei Sekunden zwischen „sicher
Handlung" und „sicher Abspann" — zehn Sonden genügen für eine Genauigkeit von
vier Sekunden, und zehn mal zwei Sekunden Dekodierung sind nichts.
**Vorschlag: beides.** Erst eine grobe Reihe von Schlüsselbildern über die
letzten zwanzig Minuten (ein Durchlauf, wenige Sekunden) — die sagt, *ob* es
überhaupt eine dunkle Strecke am Ende gibt und ungefähr wo. Dann eine binäre
Suche mit kurzen Sonden auf die Kante. Der erste Schritt verhindert, dass die
binäre Suche in einem Film ohne dunklen Abspann wild herumspringt; der zweite
macht sie genau.
## 3 · Der Zuschnitt
Dieselbe Trennung wie beim Tonabgleich: **das Schwierige rein, das Dreckige
dünn.**
**`Bildabtaster` (Flaro.Media)** — der einzige Teil, der ffmpeg anfasst.
```
helligkeiten(pfad, ab, bis, schritt) -> [(sekunde, helligkeit)]
istDunkel(pfad, ab, dauer) -> bool
```
Beides über `signalstats` beziehungsweise `blackdetect`, als eigener Prozess
wie `FfprobeRunner`. Fehlt ffmpeg oder scheitert der Lauf: leere Antwort,
keine Marke, kein Abbruch.
**`Abspannkante` (Flaro.Core)** — reine Rechnung, ohne Datei:
```
Suchen(messpunkte, laufzeit, regeln) -> Kante?
```
Nimmt die Reihe aus Schritt eins und gibt zurück, wo die dunkle Strecke
anfängt — oder nichts. Hier liegen alle Schwellen, und hier liegen die
Prüfungen. Dieselbe Rolle wie `Tonabgleich`.
**`Markenerkennung`** bekommt einen zweiten Zweig: Serien über den Ton,
Filme über das Bild. Die Tabelle, der Vertrag, die Knöpfe in App und Web
stehen schon — ein Abspann ist ein Abspann, egal woher er kommt.
Dafür braucht `Marke` eine Spalte `MovieId` neben `EpisodeId` (heute nur
Folgen), und `MovieResponse` die Marken, wie `EpisodeResponse` sie schon hat.
## 4 · Die Schwellen
Alles hier ist eine Setzung und gehört an **eine** Stelle, damit man sie
gemeinsam verschieben kann:
| Grösse | Vorschlag | Warum |
|---|---|---|
| Helligkeit „dunkel" | `YAVG < 35` | Gemessen: Abspann 18, Handlung 125. Fünfunddreissig liegt weit von beiden. |
| Anteil dunkler Bilder in einer Sonde | 85 % | Eine Schrifttafel blitzt hell auf; eine einzelne helle Sonde darf die Strecke nicht brechen. |
| Kürzester Abspann | 45 s | Darunter lohnt kein Knopf, und zufällige Dunkelheit ist häufiger. |
| Längster Abspann | 12 min | Darüber ist es kein Abspann, sondern ein Fehlfund. |
| Suchbereich | letzte 20 min | Bei einem Dreistünder wäre „die letzten 10 %" zu viel, bei einem Kurzfilm zu wenig. |
| Genauigkeit | 4 s | Wie bei Jellyfin. Feiner zu suchen kostet Sonden und bringt niemandem etwas. |
## 5 · Wo es danebenliegt — und was dann passiert
**Das muss vorher dastehen, nicht hinterher.**
- **Abspann über laufendem Bild.** Marvel, Pixar, jede zweite Komödie: die
Namen laufen über eine Szene. Keine dunkle Strecke, kein Fund. → Kein
Knopf. Das ist die richtige Antwort; ein geratener Knopf schnitte Handlung
weg.
- **Dunkle Schlussszene.** Ein Film, der im Dunkeln endet, bekommt die Kante
zu früh. Dagegen hilft die Mindestlänge und die Obergrenze — und dass die
Kante die **früheste** dunkle Stelle einer durchgehenden Strecke bis zum
Ende sein muss, nicht irgendeine.
- **Schwarzblende mitten im Film.** Kommt vor, hält aber selten bis zum Ende
durch. Die Forderung „bis zum Dateiende dunkel" fängt das.
- **Szene nach dem Abspann.** Dann ist die Strecke unterbrochen, und der Fund
fällt heraus. Lieber keiner als einer, der über die Szene springt.
Grobe Erwartung, **ungemessen**: bei Serien greift das Verfahren oft, bei
Kinofilmen vielleicht bei der Hälfte. Mehr lässt sich erst sagen, wenn es an
echtem Material gelaufen ist — und dafür braucht es einen Weg, die Funde
nachzusehen.
## 6 · Nachsehen können
Ohne das wird aus dem Verfahren eine Blackbox, die manchmal recht hat.
Vorschlag: auf der Detailseite steht bei einem Film mit Marke, **wo** sie
liegt, mit einem Knopf „stimmt nicht" — der die Marke löscht und den Titel
für weitere Läufe sperrt. Drei Zeilen Oberfläche, und man hat eine Messung
statt eines Gefühls.
## 7 · Stufen
| | Schritt | Prüfbar an |
|---|---|---|
| 1 | `Abspannkante` als reine Rechnung samt Prüfungen | erfundenen Messreihen |
| 2 | `Bildabtaster` über ffmpeg | der erzeugten Prüfdatei aus Abschnitt 1 |
| 3 | `Marke.MovieId`, Wanderung, Marken im Filmvertrag | Serverprüfungen |
| 4 | Filme im Lauf nach dem Scan | am Bestand, im Protokoll |
| 5 | „stimmt nicht" auf der Detailseite | von Hand |
## Prüfliste
- **V.1** Ein Film mit schwarzem Abspann bekommt eine Marke, und sie liegt
innerhalb von fünf Sekunden an der richtigen Stelle.
- **V.2** Ein Film mit Abspann über laufendem Bild bekommt **keine** Marke.
- **V.3** Ein Film, der im Dunkeln endet, ohne Abspann, bekommt keine Marke.
- **V.4** Der Lauf über hundert Filme belastet die Platte nicht länger als
der Scan selbst.
- **V.5** Der Überspringen-Knopf erscheint bei einem Film genauso wie bei
einer Folge.
- **V.6** Mit erkanntem Abspann gilt ein Film als gesehen, sobald er anfängt
— dieselbe Regel wie bei Folgen, sie steht schon.
---
## Quellen
- [intro-skipper auf GitHub](https://github.com/intro-skipper/intro-skipper)
- [Intro Skipper, README](https://cdn.jsdelivr.net/gh/intro-skipper/intro-skipper@10.11/README.md)
- [Forenbeitrag zu Abspann-Erkennung](https://forum.jellyfin.org/t-how-to-skip-ending-credits-with-confusedpolarbear-intro-skipper)
docs/NAS-EINRICHTEN.md
+314
View File
@@ -0,0 +1,314 @@
# Flaro auf dem NAS einrichten
Für ein UGREEN-NAS mit der mitgelieferten Docker-App, und für jedes andere
System, auf dem Docker Compose läuft.
## Die kurze Antwort auf „ein Image oder mehrere?"
**Ein einziges.** Die Weboberfläche wird beim Bauen mit hineingelegt und vom
Server selbst ausgeliefert; es gibt keinen zweiten Container, keine Datenbank
daneben, keinen Proxy davor. Ein Container, drei Volumes, fertig.
```
flaro:<fassung> 231 MB
├── .NET-Laufzeit + Flaro
├── wwwroot/ die Weboberfläche
└── ffmpeg + VAAPI-Treiber
```
---
## Schritt 1: Die Architektur bestimmen
**Das ist der Schritt, den man am leichtesten überspringt und am teuersten
bezahlt.** Ein Image für `arm64` läuft auf einem Intel-NAS nicht, und die
Fehlermeldung (`exec format error`) sagt das nicht deutlich.
Auf dem NAS, über SSH oder die Konsole der Docker-App:
```bash
uname -m
```
| Ausgabe | Architektur | Was du bauen musst |
|---|---|---|
| `x86_64` | amd64 | `--platform linux/amd64` |
| `aarch64` | arm64 | `--platform linux/arm64` |
Die meisten UGREEN-Geräte mit Intel-Prozessor (N100, i5) melden `x86_64`.
Ein Mac baut ohne Angabe **arm64** — also gehört die Angabe dazu.
---
## Schritt 2: Das Image auf das NAS bringen
**Das NAS baut nicht, es lädt nur.** Genau wie bei Jellyfin oder jedem
anderen Container: dort baut jemand anderes und veröffentlicht, du ziehst
das Ergebnis. Bei Flaro ist dieser Jemand dein Arbeitsrechner — er ist für
die Apps ohnehin nötig, weil Xcode nirgendwo sonst läuft.
Drei Wege. Der erste ist der vorgesehene; der zweite braucht keine Registry.
### Weg A — über die Registry deines Gitea (empfohlen)
Dein Gitea unter `git.scarriffle.com` bringt eine Container-Registry mit.
Einmal einrichten, danach ist jedes Update ein `docker compose pull`.
#### A1 · Anmelden, einmalig
Nicht mit dem Kontopasswort, sondern mit einem Zugriffstoken: *Gitea →
Einstellungen → Anwendungen → Zugriffstoken*, Berechtigungen
`write:package` und `read:package`. Ein Token lässt sich einzeln widerrufen,
und bei eingeschalteter Zwei-Faktor-Anmeldung funktioniert das Passwort hier
gar nicht.
```bash
docker login git.scarriffle.com
```
Benutzername ist dein Gitea-Name, als Passwort das Token.
#### A2 · Bauen und hochladen
Ein Befehl; er baut amd64 **und** arm64 und lädt beides als ein Manifest
hoch:
```bash
Tools/image-veroeffentlichen.sh
```
Mit einer Fassungsnummer, wenn du sie festnageln willst:
```bash
Tools/image-veroeffentlichen.sh 0.2.0
```
Nur die Architektur des NAS — deutlich schneller, weil die fremde sonst
unter Emulation gebaut wird:
```bash
FLARO_PLATTFORMEN=linux/amd64 Tools/image-veroeffentlichen.sh
```
#### A3 · Das Paket öffentlich stellen
Sonst muss sich auch das NAS anmelden. In Gitea unter
*dein Profil → Pakete → flaro → Einstellungen* auf öffentlich stellen. Der
Quelltext ist ohnehin offen; das Image enthält nichts, was er nicht auch
enthält.
#### A4 · Die Registry im NAS eintragen
In der Docker-App des UGREEN: **Repository → Zahnrad → Quellname des
Images → Hinzufügen**. Dort stehen schon DockerHub und `ghcr.io`; daneben
kommt:
| Feld | Wert |
|---|---|
| Alias | `gitea` |
| Link | `https://git.scarriffle.com/` |
**Bestätigen** — danach findet die Suche in der Docker-App auch
`scarriffle/flaro`. Ist das Paket privat, trägst du unter
*Registierungseinstellungen* Benutzername und dasselbe Zugriffstoken ein.
#### A5 · Das Image herunterladen, bevor du das Projekt anlegst
**Die Docker-App zieht Images nicht selbst.** Steht in einer Compose-Datei
ein Image, das lokal fehlt, bricht sie das Anlegen mit „Bitte überprüfen Sie
die Konfigurationsinformationen" ab — ohne zu sagen, woran es liegt. Also
vorher **Image → Herunterladen**, Registry `gitea`, Quellname
`scarriffle/flaro:latest`.
In der Compose-Datei steht dann:
```yaml
image: git.scarriffle.com/scarriffle/flaro:latest
```
### Weg B — als Datei hochladen
Ohne Registry, dafür bei jedem Update von Hand.
```bash
docker buildx build --platform linux/amd64 \
-f server/Dockerfile -t flaro:latest --load .
```
```bash
docker save flaro:latest | gzip > flaro.tar.gz
```
Das ergibt rund **230 MB** — gemessen, nicht geschätzt. Das `gzip` bringt
dabei fast nichts: die Ebenen eines Docker-Images sind bereits gepackt.
Die Datei über die Dateiverwaltung auf das NAS legen, dann dort:
```bash
docker load < /volume1/docker/flaro.tar.gz
```
In der Compose-Datei steht dann schlicht `image: flaro:latest`.
### Weg C — Gitea baut selbst
`.gitea/workflows/image.yml` liegt im Projekt und kann denselben Bau auf
einem Act-Runner ausführen. **Gitea verteilt Arbeit nur, es baut nicht
selbst** — ohne registrierten Runner passiert nichts.
Der Runner müsste auf dem NAS laufen, und daran scheitert es dort: er
braucht Zugriff auf Docker, denn sein Zweck ist das Bauen von Images. Die
Docker-App des UGREEN lehnt den Einhängepunkt `/var/run/docker.sock` ab —
geprüft, indem die Compose-Datei Zeile für Zeile aufgebaut wurde: ohne diese
eine Zeile wird das Projekt angelegt, mit ihr nicht. Übrig bleiben
`privileged: true` mit einem Docker-in-Docker-Image oder der Weg über SSH an
der Oberfläche vorbei. Beide geben dem Runner faktisch Root auf dem NAS.
Deshalb löst der Workflow **nicht** mehr bei jedem Push aus — sonst sammeln
sich Läufe an, die nie jemand abarbeitet. Er steht auf `workflow_dispatch`
und lässt sich in Gitea von Hand starten, sobald einmal ein Runner da ist.
---
## Schritt 3: Die Compose-Datei
```yaml
services:
flaro:
image: git.scarriffle.com/scarriffle/flaro:latest
container_name: flaro
restart: unless-stopped
ports:
- "8096:8080"
environment:
- TZ=Europe/Zurich
# Schreibt Plakate und NFO neben die Mediendateien. Ohne das bleibt
# der Medienordner unangetastet.
- FLARO_WRITE_SIDECARS=true
volumes:
# Datenbank und Konfiguration. **Das ist das Volume, das du sichern
# musst** — darin stehen Benutzer, Zuordnungen und Sehfortschritt.
- /volume1/docker/flaro/config:/config
# Heruntergeladene Plakate. Verlierbar: wird neu geholt.
- /volume1/docker/flaro/cache:/cache
# Umgepackte Dateien. Ebenfalls verlierbar, kann aber gross werden.
- /volume1/docker/flaro/transcode:/transcode
# Die Medien. Links der Pfad auf dem NAS, rechts der im Container —
# und **rechts** ist der, den du in Flaro einträgst.
- /volume1/Medien/Filme:/media/Filme
- /volume1/Medien/Serien:/media/Serien
# Hardware-Beschleunigung. Weglassen, wenn das NAS keine hat.
devices:
- /dev/dri:/dev/dri
```
### Rechte
Der Container läuft als Benutzer `1000:1000` — der erste Benutzer auf fast
jedem Linux und auf den üblichen NAS-Geräten. Gehören deine Ordner jemand
anderem, setz es ausdrücklich:
```yaml
user: "1001:100"
```
Welche Kennung gilt, sagt auf dem NAS:
```bash
id
```
### Der Port
`8096` ist frei gewählt. Läuft dort schon Jellyfin, nimm etwas anderes —
links die Zahl, unter der du Flaro erreichst, rechts bleibt `8080`.
---
## Schritt 4: Starten und einrichten
```bash
docker compose up -d
```
Dann im Browser `http://<nas>:8096` öffnen. Es erscheint der
Einrichtungsassistent:
1. **Administratorkonto** anlegen — Benutzername und Passwort, mindestens
acht Zeichen.
2. Unter **Verwaltung → Mediatheken** eine Mediathek hinzufügen. Beim Ordner
gehört der Pfad **im Container** hinein, also `/media/Filme`, nicht
`/volume1/Medien/Filme`.
3. **Scannen.** Der Scan liest die Dateien, danach holt Flaro die Metadaten.
4. Unter **Verwaltung → Server → Metadaten** die Sprache einstellen, etwa
`de-DE`. Danach einmal **Metadaten auffrischen** — vorhandene Titel
ändern sich sonst nicht.
---
## Sichern
Was unersetzlich ist, liegt in **einem** Verzeichnis:
```
/volume1/docker/flaro/config/
```
Darin: die SQLite-Datenbank mit Benutzern, Zuordnungen, Sehfortschritt und
Einstellungen. Eine Kopie dieser Datei ist die ganze Sicherung — kein
Datenbank-Dump, kein Export.
`cache` und `transcode` dürfen weg; beides baut sich neu auf.
**Die Mediendateien fasst Flaro nicht an.** Es liest sie, und es legt —
sofern `FLARO_WRITE_SIDECARS=true` gesetzt ist — Plakate und NFO-Dateien
daneben. Umbenannt oder gelöscht wird nie etwas; es gibt im ganzen Programm
keine Stelle, die das könnte.
---
## Aktualisieren
**Zwei Schritte, zwei Maschinen.** Erst baut der Arbeitsrechner die neue
Fassung und legt sie in die Registry:
```bash
Tools/image-veroeffentlichen.sh
```
Dann holt das NAS sie. In der Docker-App genügt das Aktualisieren des
Projekts; über die Kommandozeile:
```bash
docker compose pull && docker compose up -d
```
Migrationen der Datenbank laufen beim Start von selbst. Ein Rückschritt auf
eine ältere Fassung ist **nicht** vorgesehen — vor einem Sprung lohnt eine
Kopie von `config/`.
---
## Wenn etwas nicht geht
```bash
docker compose logs -f flaro
```
| Zeichen | Ursache |
|---|---|
| `exec format error` | falsche Architektur — siehe Schritt 1 |
| Mediathek bleibt leer | der Pfad in Flaro ist der des NAS statt der im Container |
| „Zugriff verweigert" im Protokoll | Rechte, siehe `user:` oben |
| Keine Plakate, Titel wie Dateinamen | kein TMDB-Zugang oder kein Netz |
| Hardware-Beschleunigung greift nicht | `/dev/dri` nicht durchgereicht |
Ein Gesundheitsendpunkt ohne Anmeldung:
```bash
curl http://<nas>:8096/health
```
project.yml
+4
View File
@@ -57,6 +57,8 @@ targets:
# zweiter dazu, steht er daneben. # zweiter dazu, steht er daneben.
- package: FlaroKit - package: FlaroKit
product: JellyfinKit product: JellyfinKit
- package: FlaroKit
product: FlaroServerKit
- package: FlaroKit - package: FlaroKit
product: FlaroDesign product: FlaroDesign
- package: FlaroKit - package: FlaroKit
@@ -188,6 +190,8 @@ targets:
product: MediaKit product: MediaKit
- package: FlaroKit - package: FlaroKit
product: JellyfinKit product: JellyfinKit
- package: FlaroKit
product: FlaroServerKit
- package: FlaroKit - package: FlaroKit
product: FlaroDesign product: FlaroDesign
- package: FlaroKit - package: FlaroKit
scratchpad/neu/data/flaro.db
BIN
View File
Binary file not shown.
scratchpad/neu/data/keys/key-15706be2-d1ec-4fa7-918b-920e87c4acce.xml
+16
View File
@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="utf-8"?>
<key id="15706be2-d1ec-4fa7-918b-920e87c4acce" version="1">
<creationDate>2026-10-07T19:35:00.68989Z</creationDate>
<activationDate>2026-10-07T19:35:00.68989Z</activationDate>
<expirationDate>2027-01-05T19:35:00.68989Z</expirationDate>
<descriptor deserializerType="Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.AuthenticatedEncryptorDescriptorDeserializer, Microsoft.AspNetCore.DataProtection, Version=10.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
<descriptor>
<encryption algorithm="AES_256_CBC" />
<validation algorithm="HMACSHA256" />
<masterKey p4:requiresEncryption="true" xmlns:p4="http://schemas.asp.net/2015/03/dataProtection">
<!-- Warning: the key below is in an unencrypted form. -->
<value>oyFqIl0Q27Th3X+CX07TX95s7kMGEQ2OkjOUJEJVkgK7LeTccP4tp3FeJnMzLSuu7rsKVIJa4xINONp+0AOAWg==</value>
</masterKey>
</descriptor>
</descriptor>
</key>
scratchpad/neu/data/logs/flaro-2026-10-07.log
+5
View File
@@ -0,0 +1,5 @@
21:35:00 INFO Server gestartet — 1.0.0 · DEV
21:55:29 INFO Server fährt herunter.
22:00:35 INFO Server gestartet — 1.0.0 · DEV
22:11:06 INFO Server fährt herunter.
22:14:53 INFO Server gestartet — 1.0.0 · DEV
scratchpad/neu/data/logs/flaro-2026-10-08.log
+17
View File
@@ -0,0 +1,17 @@
06:38:47 INFO Server fährt herunter.
06:44:02 INFO Server gestartet — 1.0.0 · DEV
06:57:23 INFO Server fährt herunter.
06:59:45 INFO Server gestartet — 1.0.0 · DEV
17:38:34 INFO Server fährt herunter.
17:57:11 INFO Server gestartet — 1.0.0 · DEV
19:05:40 INFO Server fährt herunter.
19:08:22 INFO Server gestartet — 1.0.0 · DEV
21:03:32 INFO Server fährt herunter.
21:08:04 INFO Server gestartet — 1.0.0 · DEV
21:10:04 INFO Wartung — Sicherung: flaro-2026-10-08-1910.db, 0 MB
21:10:04 INFO Wartung — Optimieren: nichts zusammenzupacken
21:10:04 INFO Wartung — Bilder: kein Bildspeicher da
21:45:40 INFO Server fährt herunter.
21:45:44 INFO Server gestartet — 1.0.0 · DEV
22:06:03 INFO Server fährt herunter.
22:12:27 INFO Server gestartet — 1.0.0 · DEV
scratchpad/neu/data/logs/flaro-2026-10-11.log
+1
View File
@@ -0,0 +1 @@
21:17:00 INFO Wartung — Sicherung: flaro-2026-10-11-1917.db, 0 MB
scratchpad/neu/data/logs/flaro-2026-10-14.log
+1
View File
@@ -0,0 +1 @@
21:26:01 INFO Wartung — Sicherung: flaro-2026-10-14-1926.db, 0 MB
scratchpad/neu/data/logs/flaro-2026-10-15.log
+2
View File
@@ -0,0 +1,2 @@
21:10:21 INFO Wartung — Optimieren: nichts zusammenzupacken
21:10:21 INFO Wartung — Bilder: kein Bildspeicher da
scratchpad/neu/data/sicherungen/flaro-2026-10-08-1910.db
BIN
View File
Binary file not shown.
scratchpad/neu/data/sicherungen/flaro-2026-10-11-1917.db
BIN
View File
Binary file not shown.
scratchpad/neu/data/sicherungen/flaro-2026-10-14-1926.db
BIN
View File
Binary file not shown.
server/.dockerignore
-6
View File
@@ -1,6 +0,0 @@
**/bin/
**/obj/
**/*.user
data/
cache/
transcode/
server/Directory.Build.props
+23
View File
@@ -0,0 +1,23 @@
<Project>
<!--
Eine kaputte Protokollvorlage ist kein Schönheitsfehler.
`log.LogInformation("… {Folgen} … {Folgen}.", a, b, c, d, e)` wirft zur
Laufzeit — jeder Platzhalter verbraucht ein Argument, auch ein
wiederholter. Geschieht das in einem Hintergrundlauf, reisst die
Ausnahme den ganzen Lauf mit, und alles, was er bis dahin gefunden
hatte, ist verloren. Genau so ist es der Markenerkennung ergangen.
CA2017 hatte das längst gemeldet — als Warnung unter hundert anderen
Zeilen, und damit übersehen. Als Fehler ist es nicht zu übersehen.
Nur diese eine Regel, nicht alle Warnungen: ein pauschales
`TreatWarningsAsErrors` wäre eine andere Entscheidung und gehört nicht
nebenbei getroffen.
-->
<PropertyGroup>
<WarningsAsErrors>$(WarningsAsErrors);CA2017</WarningsAsErrors>
</PropertyGroup>
</Project>

Some files were not shown because too many files have changed in this diff Show More