Halo heisst ab hier Flaro — die Marke stand im Weg
Der Upload zu App Store Connect scheiterte am Namen. „Halo" ist eine eingetragene Marke von Microsoft; im App Store heisst zwar keine App exakt so, aber reservierte und markenrechtlich belegte Namen tauchen in keiner Suche auf. Der einzige verlässliche Test war die Eingabe dort, und die ging daneben. **Der Name wurde diesmal vorher geprüft.** Zwanzig Kandidaten gegen den deutschen und amerikanischen App Store, auf exakte Treffer und auf ähnliche Namen. „Kavo" wäre dieselbe Wand gewesen — exakt belegt in beiden Stores, in Deutschland von KaVo Dental GmbH. „Flare" ist mit 42 ähnlichen Apps je Store der am dichtesten besetzte Name der ganzen Runde. **Flaro** ist in beiden frei und liest sich als eigenes Wort, nicht als Flare mit Tippfehler. Das bleibt eine Store-Suche und keine Markenrecherche — reservierte Namen ohne veröffentlichte App sieht sie nicht. Aber es ist mehr Prüfung, als beim letzten Mal stattfand. --- 2160 Textvorkommen in 273 Dateien, 49 Pfade. Betroffen ist diesmal auch der Server: `Flaro.Api`, `Flaro.Core`, `Flaro.Data`, `Flaro.Media`, `Flaro.Metadata`, `FlaroContext`, `FlaroPaths`, `flaro.db`, die Variablen `FLARO_DATA`, `FLARO_CACHE`, `FLARO_TRANSCODE`, `FLARO_WRITE_SIDECARS`, und das Image. **Vor dem Ersetzen geprüft**, ob „halo" irgendwo als Teil eines anderen Wortes steckt — und ob es im TMDB-Token vorkommt. Tat es nicht; ein blindes Ersetzen hätte den sonst zerlegt. `docs/superpowers/specs/` bleibt wie beim letzten Mal unangetastet: datierte Entwurfsdokumente sind ein Protokoll getroffener Entscheidungen. Das Server-Dokument hat stattdessen einen Nachtrag bekommen, damit es niemanden in die Irre führt. **Die Bundle-ID wandert mit**, zum zweiten Mal an einem Tag: `com.scarriffleservices.flaro`. Wer die vorige Fassung installiert hat, hat jetzt zwei Karteileichen auf dem Gerät — beide löschen, dann ist Ruhe. 308 Server-Tests grün, 368 im Swift-Paket, null Warnungen. iOS und tvOS bauen, das Image baut, und ein frischer Container läuft durch Einrichtung und Anmeldung. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
f98b995050
commit
a7cf6c5def
@@ -0,0 +1,10 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>com.apple.security.application-groups</key>
|
||||
<array>
|
||||
<string>group.com.scarriffleservices.flaro</string>
|
||||
</array>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -0,0 +1,72 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import FlaroPlayback
|
||||
import MediaKit
|
||||
import JellyfinKit
|
||||
|
||||
/// Die App auf dem Fernseher.
|
||||
///
|
||||
/// **Eine eigene Wurzel statt eines Zweigs in `FlaroApp`.** Der Unterschied
|
||||
/// zwischen Telefon und Fernseher ist keine Feinheit der Darstellung, sondern
|
||||
/// die Bedienart: kein Finger, keine Grössenklasse, keine Werkzeugleiste, kein
|
||||
/// Ziehen zum Aktualisieren, keine halbhohen Sheets — und dafür ein Fokus, den
|
||||
/// es auf iOS gar nicht gibt. Ein `#if os(tvOS)` in der bestehenden Wurzel
|
||||
/// wäre kein Zweig, sondern ein zweiter Rumpf in derselben Datei, und der
|
||||
/// nächste, der die iOS-Seite ändert, bräche die andere, ohne es zu merken.
|
||||
///
|
||||
/// **Die Modelle dagegen werden geteilt**, nicht kopiert: `Flaro/Session/`
|
||||
/// kommt über einen Pfadeintrag in `project.yml` mit. Die Naht verläuft
|
||||
/// zwischen Modell und Ansicht, nicht zwischen den Plattformen.
|
||||
///
|
||||
/// **Kein SwiftData und kein Download-Koordinator.** Der `ModelContainer` der
|
||||
/// iOS-App trägt ausschliesslich Downloads, und die gibt es hier nicht — damit
|
||||
/// fällt beides weg.
|
||||
@main
|
||||
struct FlaroTVApp: App {
|
||||
@State private var session: FlaroSession
|
||||
@State private var theme = FlaroTheme()
|
||||
@State private var playback = PlaybackCoordinator()
|
||||
@State private var playbackSettings = PlaybackSettings()
|
||||
@State private var languages = LanguagePreferences()
|
||||
@State private var quickPlay = QuickPlay()
|
||||
@State private var subtitleAppearance = SubtitleAppearance()
|
||||
@State private var homeLayout = HomeLayoutSettings()
|
||||
@State private var diagnostics = PlaybackDiagnostics()
|
||||
/// Beobachtet die Verbindung. Lebt hier, damit der Beobachter einmal läuft
|
||||
/// statt bei jedem Öffnen des Players neu zu starten.
|
||||
///
|
||||
/// Ein Apple TV hängt fast immer am Kabel oder an festem WLAN — aber
|
||||
/// „fast" ist kein Grund, die Entscheidungen des Players zu raten.
|
||||
@State private var network = NetworkConditions()
|
||||
|
||||
init() {
|
||||
_session = State(initialValue: FlaroSession(
|
||||
jellyfinIdentity: JellyfinIdentity.current(
|
||||
client: Branding.appName,
|
||||
version: Branding.version
|
||||
),
|
||||
tokenStore: KeychainTokenStore(service: Branding.keychainService)
|
||||
))
|
||||
}
|
||||
|
||||
var body: some Scene {
|
||||
WindowGroup {
|
||||
TVRootView()
|
||||
.environment(session)
|
||||
.environment(theme)
|
||||
.environment(playback)
|
||||
.environment(playbackSettings)
|
||||
.environment(languages)
|
||||
.environment(quickPlay)
|
||||
.environment(subtitleAppearance)
|
||||
.environment(homeLayout)
|
||||
.environment(diagnostics)
|
||||
.environment(network)
|
||||
.flaroAccent(theme)
|
||||
.tint(theme.accentColor)
|
||||
// Ein Fernseher ist immer dunkel. Der Schalter in der
|
||||
// Info.plist gilt fürs System, diese Zeile für die Vorschauen.
|
||||
.preferredColorScheme(.dark)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>CFBundleDevelopmentRegion</key>
|
||||
<string>$(DEVELOPMENT_LANGUAGE)</string>
|
||||
<key>CFBundleDisplayName</key>
|
||||
<string>Flaro</string>
|
||||
<key>CFBundleExecutable</key>
|
||||
<string>$(EXECUTABLE_NAME)</string>
|
||||
<key>CFBundleIdentifier</key>
|
||||
<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
|
||||
<key>CFBundleInfoDictionaryVersion</key>
|
||||
<string>6.0</string>
|
||||
<key>CFBundleName</key>
|
||||
<string>$(PRODUCT_NAME)</string>
|
||||
<key>CFBundlePackageType</key>
|
||||
<string>APPL</string>
|
||||
<key>CFBundleShortVersionString</key>
|
||||
<string>1.0</string>
|
||||
<key>CFBundleURLTypes</key>
|
||||
<array>
|
||||
<dict>
|
||||
<key>CFBundleURLName</key>
|
||||
<string>com.scarriffleservices.flaro.topshelf</string>
|
||||
<key>CFBundleURLSchemes</key>
|
||||
<array>
|
||||
<string>flaro</string>
|
||||
</array>
|
||||
</dict>
|
||||
</array>
|
||||
<key>CFBundleVersion</key>
|
||||
<string>1</string>
|
||||
<key>ITSAppUsesNonExemptEncryption</key>
|
||||
<false/>
|
||||
<key>NSAppTransportSecurity</key>
|
||||
<dict>
|
||||
<key>NSAllowsLocalNetworking</key>
|
||||
<true/>
|
||||
</dict>
|
||||
<key>NSLocalNetworkUsageDescription</key>
|
||||
<string>Flaro benötigt Zugriff auf das lokale Netzwerk, um deinen Jellyfin-Server zu erreichen.</string>
|
||||
<key>UIUserInterfaceStyle</key>
|
||||
<string>Dark</string>
|
||||
</dict>
|
||||
</plist>
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "back.png",
|
||||
"scale": "1x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 5.7 KiB |
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"layers": [
|
||||
{
|
||||
"filename": "Front.imagestacklayer"
|
||||
},
|
||||
{
|
||||
"filename": "Back.imagestacklayer"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "front.png",
|
||||
"scale": "1x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 38 KiB |
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "back.png",
|
||||
"scale": "1x"
|
||||
},
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "back@2x.png",
|
||||
"scale": "2x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 1012 B |
BIN
Binary file not shown.
|
After Width: | Height: | Size: 2.7 KiB |
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"layers": [
|
||||
{
|
||||
"filename": "Front.imagestacklayer"
|
||||
},
|
||||
{
|
||||
"filename": "Back.imagestacklayer"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "front.png",
|
||||
"scale": "1x"
|
||||
},
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "front@2x.png",
|
||||
"scale": "2x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 8.6 KiB |
BIN
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
{
|
||||
"assets": [
|
||||
{
|
||||
"filename": "App Icon.imagestack",
|
||||
"idiom": "tv",
|
||||
"role": "primary-app-icon",
|
||||
"size": "400x240"
|
||||
},
|
||||
{
|
||||
"filename": "App Icon - App Store.imagestack",
|
||||
"idiom": "tv",
|
||||
"role": "primary-app-icon",
|
||||
"size": "1280x768"
|
||||
},
|
||||
{
|
||||
"filename": "Top Shelf Image.imageset",
|
||||
"idiom": "tv",
|
||||
"role": "top-shelf-image",
|
||||
"size": "1920x720"
|
||||
},
|
||||
{
|
||||
"filename": "Top Shelf Image Wide.imageset",
|
||||
"idiom": "tv",
|
||||
"role": "top-shelf-image-wide",
|
||||
"size": "2320x720"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "topshelfwide.png",
|
||||
"scale": "1x"
|
||||
},
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "topshelfwide@2x.png",
|
||||
"scale": "2x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 49 KiB |
BIN
Binary file not shown.
|
After Width: | Height: | Size: 131 KiB |
+18
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"images": [
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "topshelf.png",
|
||||
"scale": "1x"
|
||||
},
|
||||
{
|
||||
"idiom": "tv",
|
||||
"filename": "topshelf@2x.png",
|
||||
"scale": "2x"
|
||||
}
|
||||
],
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 44 KiB |
BIN
Binary file not shown.
|
After Width: | Height: | Size: 121 KiB |
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"info": {
|
||||
"author": "xcode",
|
||||
"version": 1
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Die Detailseite auf dem Fernseher.
|
||||
///
|
||||
/// Fassung eins zeigt, worum es geht, und lässt es abspielen. Staffeln und
|
||||
/// Folgen kommen im nächsten Schritt — bis dahin führt eine Serie über
|
||||
/// `QuickPlay` zur nächsten ungesehenen Folge, genau wie die Kachel.
|
||||
struct TVDetailView: View {
|
||||
let route: MediaRoute
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(QuickPlay.self) private var quickPlay
|
||||
|
||||
@State private var state: LoadState<MediaItem> = .loading
|
||||
|
||||
var body: some View {
|
||||
Group {
|
||||
switch state {
|
||||
case .loading:
|
||||
ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
|
||||
case .failed(let meldung):
|
||||
VStack(spacing: FlaroSpacing.regular) {
|
||||
Text(meldung).font(.flaroBody).foregroundStyle(.white)
|
||||
Button("action.retry") { Task { await lade() } }
|
||||
}
|
||||
case .loaded(let item):
|
||||
TVHeroSection(
|
||||
item: item,
|
||||
onPlay: {
|
||||
quickPlay.start(item, backend: session.backend, coordinator: playback)
|
||||
},
|
||||
onDetails: {}
|
||||
)
|
||||
.ignoresSafeArea()
|
||||
}
|
||||
}
|
||||
.task { await lade() }
|
||||
}
|
||||
|
||||
private func lade() async {
|
||||
guard let backend = session.backend else { return }
|
||||
state = await LoadState.load(keepingPrevious: state) {
|
||||
try await backend.item(id: route.ratingKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Der Aufmacher oben auf der Startseite des Fernsehers.
|
||||
///
|
||||
/// Derselbe `HeroBanner` wie am Telefon — das Bauteil kennt keine Plattform,
|
||||
/// es setzt Bild, Verlauf und Text. Anders sind nur die Knöpfe: hier sind es
|
||||
/// Fokusziele, und sie müssen gross genug sein, dass man aus drei Metern
|
||||
/// sieht, welcher gerade dran ist.
|
||||
struct TVHeroSection: View {
|
||||
let item: MediaItem
|
||||
let onPlay: () -> Void
|
||||
let onDetails: () -> Void
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(\.flaroAccent) private var accent
|
||||
|
||||
var body: some View {
|
||||
HeroBanner(
|
||||
title: item.rowTitle,
|
||||
metadata: metadaten,
|
||||
summary: item.summary,
|
||||
artworkURLs: session.backend.map {
|
||||
HeroArtwork.backdropURLs(for: item, backend: $0, compact: false)
|
||||
} ?? [],
|
||||
logoURL: session.backend.flatMap { HeroArtwork.logoURL(for: item, backend: $0) },
|
||||
aspectRatio: FlaroAspectRatio.hero,
|
||||
// Der Aufmacher nimmt die Höhe, die das Karussell ihm gibt.
|
||||
fillsAvailableSpace: true
|
||||
) {
|
||||
Button(action: onPlay) {
|
||||
Label(abspielTitel, systemImage: "play.fill")
|
||||
}
|
||||
.buttonStyle(.borderedProminent)
|
||||
.tint(accent)
|
||||
|
||||
Button(action: onDetails) {
|
||||
Label("hero.details", systemImage: "info.circle")
|
||||
}
|
||||
.buttonStyle(.bordered)
|
||||
}
|
||||
}
|
||||
|
||||
/// „Weiterschauen" statt „Abspielen", wenn schon etwas gesehen wurde.
|
||||
private var abspielTitel: LocalizedStringKey {
|
||||
item.watchProgress == nil ? "hero.play" : "hero.resume"
|
||||
}
|
||||
|
||||
private var metadaten: String? {
|
||||
var teile: [String] = []
|
||||
if item.kind == .episode, let staffel = item.parentIndex, let folge = item.index {
|
||||
// Ausgeschrieben: der Aufmacher am Fernseher ist 1760 Punkte
|
||||
// breit, und gelesen wird er aus drei Metern.
|
||||
teile.append(String(localized: "episode.long \(staffel) \(folge)"))
|
||||
}
|
||||
if let jahr = item.year { teile.append(String(jahr)) }
|
||||
if let dauer = item.duration {
|
||||
teile.append(Duration.milliseconds(dauer).runtimeLabel)
|
||||
}
|
||||
if let freigabe = item.contentRating { teile.append(freigabe) }
|
||||
return teile.isEmpty ? nil : teile.joined(separator: " · ")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Die Startseite auf dem Fernseher.
|
||||
///
|
||||
/// **Dasselbe Modell wie am Telefon.** `HomeFeed` lädt, ordnet und lost den
|
||||
/// Aufmacher aus; hier steht nur, wie das aussieht. Der Unterschied ist die
|
||||
/// Bedienart, nicht der Inhalt.
|
||||
struct TVHomeView: View {
|
||||
/// Wohin ein Link aus dem Regal führen soll.
|
||||
///
|
||||
/// **Als Bindung von aussen**, nicht als eigener Zustand: das Regal
|
||||
/// erreicht die Wurzel, der Navigationsstapel liegt hier. Einen zweiten
|
||||
/// Stapel eine Ebene höher anzulegen, nur um ein Ziel durchzureichen,
|
||||
/// hiesse zwei Stapel gleich zu halten.
|
||||
@Binding var deepLinkTarget: MediaRoute?
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(HomeLayoutSettings.self) private var layout
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(QuickPlay.self) private var quickPlay
|
||||
|
||||
@State private var feed = HomeFeed()
|
||||
@State private var pfad = NavigationPath()
|
||||
/// Welcher Titel gerade oben gross steht.
|
||||
///
|
||||
/// **Der Fokus bestimmt ihn, nicht eine Uhr.** Am Telefon wechselt der
|
||||
/// Aufmacher alle sieben Sekunden von selbst — dort blättert man ihn auch
|
||||
/// mit dem Daumen. Vor einem Fernseher wäre ein Bild, das sich von allein
|
||||
/// austauscht, während man es ansieht, eine Zumutung: man verliert den
|
||||
/// Titel, den man gerade lesen wollte.
|
||||
@State private var aufmacher: MediaItem?
|
||||
|
||||
var body: some View {
|
||||
NavigationStack(path: $pfad) {
|
||||
inhalt
|
||||
.navigationDestination(for: MediaRoute.self) { route in
|
||||
TVDetailView(route: route)
|
||||
}
|
||||
}
|
||||
.task(id: session.serverName) { await feed.load(from: session.backend) }
|
||||
.onChange(of: deepLinkTarget) { _, neu in
|
||||
guard let neu else { return }
|
||||
pfad.append(neu)
|
||||
deepLinkTarget = nil
|
||||
}
|
||||
}
|
||||
|
||||
@ViewBuilder
|
||||
private var inhalt: some View {
|
||||
switch feed.state {
|
||||
case .loading:
|
||||
ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
|
||||
|
||||
case .failed(let meldung):
|
||||
VStack(spacing: FlaroSpacing.regular) {
|
||||
Text(meldung).font(.flaroBody).foregroundStyle(.white)
|
||||
Button("action.retry") {
|
||||
Task { await feed.load(from: session.backend) }
|
||||
}
|
||||
}
|
||||
|
||||
case .loaded:
|
||||
let reihen = feed.rows(for: layout)
|
||||
if reihen.isEmpty && session.libraries.isEmpty {
|
||||
Text("home.empty.title").font(.flaroRowHeader).foregroundStyle(.white)
|
||||
} else {
|
||||
seite(reihen: reihen)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func seite(reihen: [MediaRowGroup]) -> some View {
|
||||
ScrollView {
|
||||
LazyVStack(alignment: .leading, spacing: FlaroSpacing.section) {
|
||||
if let gezeigt = aufmacher ?? feed.heroItems(for: layout).first {
|
||||
TVHeroSection(
|
||||
item: gezeigt,
|
||||
onPlay: { spiele(gezeigt) },
|
||||
onDetails: { zeige(gezeigt) }
|
||||
)
|
||||
.frame(height: 720)
|
||||
}
|
||||
|
||||
ForEach(reihen) { reihe in
|
||||
// **Der Fokus setzt den Aufmacher.** Wer durch „Zuletzt
|
||||
// hinzugefügt" wandert, sieht oben, was er gerade
|
||||
// anschaut — ohne irgendwo hindrücken zu müssen.
|
||||
TVMediaRow(
|
||||
row: reihe,
|
||||
onSelect: { spiele($0) },
|
||||
onFocus: { aufmacher = $0 }
|
||||
)
|
||||
}
|
||||
}
|
||||
.padding(.bottom, FlaroSpacing.screenMargin)
|
||||
}
|
||||
.scrollIndicators(.never)
|
||||
// **Bildfüllend, und der Rand steckt in `screenMargin`.** Der
|
||||
// Aufmacher muss bis an die Bildschirmkante reichen; ein Bild, das
|
||||
// achtzig Punkte davor aufhört, sieht nach Fehler aus.
|
||||
.ignoresSafeArea()
|
||||
// Als Überlagerung und nicht als letzte Zeile der Liste: dorthin
|
||||
// müsste man erst an allen Reihen vorbeiscrollen, und wer nachsieht,
|
||||
// warum das Regal leer ist, soll es sofort sehen.
|
||||
.overlay(alignment: .bottom) { regalStatus }
|
||||
}
|
||||
|
||||
/// Was das Regal über der App zuletzt bekommen hat.
|
||||
///
|
||||
/// **Nur im Entwicklerbau.** Es gehört nicht in die fertige App — aber
|
||||
/// solange das Regal leer bleibt, sieht man von aussen nicht, woran es
|
||||
/// liegt: fehlende App-Gruppe, fehlende Datei und ein System, das nicht
|
||||
/// fragt, sehen alle gleich aus. Diese Zeile unterscheidet sie.
|
||||
@ViewBuilder
|
||||
private var regalStatus: some View {
|
||||
#if DEBUG
|
||||
VStack(alignment: .leading, spacing: FlaroSpacing.tight) {
|
||||
Text("topShelf.title")
|
||||
.font(.flaroCaption)
|
||||
.foregroundStyle(Color.flaroTextMuted)
|
||||
Text(TopShelfWriter.status)
|
||||
.font(.flaroCaption)
|
||||
.foregroundStyle(Color.flaroTextSecondary)
|
||||
}
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
.padding(.bottom, FlaroSpacing.regular)
|
||||
.frame(maxWidth: .infinity, alignment: .leading)
|
||||
.background(Color.black.opacity(0.6))
|
||||
#endif
|
||||
}
|
||||
|
||||
// MARK: - Was ein Druck auslöst
|
||||
|
||||
/// **Über QuickPlay, nicht unmittelbar.** Steht in der Reihe eine Serie —
|
||||
/// und Jellyfins „Zuletzt hinzugefügt" liefert neue Folgen als ihre Serie
|
||||
/// —, schickte der direkte Weg deren eigene Kennung an den Player, und der
|
||||
/// scheiterte mit „keine abspielbare Datei". Eine Serie hat keine
|
||||
/// Fassungen.
|
||||
private func spiele(_ item: MediaItem) {
|
||||
quickPlay.start(item, backend: session.backend, coordinator: playback)
|
||||
}
|
||||
|
||||
private func zeige(_ item: MediaItem) {
|
||||
pfad.append(MediaRoute(ratingKey: item.id, title: item.title))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Eine waagerechte Reihe von Titeln auf dem Fernseher.
|
||||
///
|
||||
/// Dieselben Daten wie `MediaRow` am Telefon, aber eine andere Bedienung: es
|
||||
/// gibt keinen Finger, der die Reihe schiebt, sondern einen Fokus, der von
|
||||
/// Karte zu Karte springt und die Reihe hinter sich herzieht.
|
||||
struct TVMediaRow: View {
|
||||
let row: MediaRowGroup
|
||||
let onSelect: (MediaItem) -> Void
|
||||
/// Wer gerade dran ist — damit der Aufmacher oben mitwandert.
|
||||
var onFocus: (MediaItem) -> Void = { _ in }
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
|
||||
/// Breit genug, dass die übernächste Karte angeschnitten ist — das zeigt,
|
||||
/// dass es weitergeht, ohne einen Pfeil dafür zu brauchen.
|
||||
private var breite: CGFloat { row.isContinueWatching ? 500 : 280 }
|
||||
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
|
||||
Text(row.title)
|
||||
.font(.flaroRowHeader)
|
||||
.foregroundStyle(Color.flaroTextPrimary)
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
|
||||
ScrollView(.horizontal) {
|
||||
LazyHStack(spacing: FlaroSpacing.regular) {
|
||||
ForEach(row.items) { item in
|
||||
karte(for: item).frame(width: breite)
|
||||
}
|
||||
}
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
// **Platz zum Anheben.** Eine fokussierte Karte wächst über
|
||||
// ihren Rahmen hinaus, und eine ScrollView beschneidet am
|
||||
// Rand. Ohne Polster und ohne das abgeschaltete Beschneiden
|
||||
// fehlt der obersten Reihe die Anhebung — und zwar nur ihr,
|
||||
// was wie ein Zufall aussieht statt wie ein Fehler.
|
||||
.padding(.vertical, FlaroSpacing.regular)
|
||||
}
|
||||
.scrollClipDisabled()
|
||||
.scrollIndicators(.never)
|
||||
}
|
||||
}
|
||||
|
||||
/// Szenenbild beim Weiterschauen, sonst das Plakat.
|
||||
@ViewBuilder
|
||||
private func karte(for item: MediaItem) -> some View {
|
||||
if row.isContinueWatching {
|
||||
TVLandscapeCard(
|
||||
title: item.rowTitle,
|
||||
subtitle: item.cardSubtitle,
|
||||
artworkURL: session.backend?.artworkURL(
|
||||
path: item.rowArtworkPath, width: 880, height: 496
|
||||
),
|
||||
progress: item.watchProgress,
|
||||
onFocusChange: { if $0 { onFocus(item) } }
|
||||
) { onSelect(item) }
|
||||
} else {
|
||||
TVPosterCard(
|
||||
title: item.rowTitle,
|
||||
subtitle: item.cardSubtitle,
|
||||
artworkURL: session.backend?.artworkURL(
|
||||
path: item.thumb, width: 560, height: 840
|
||||
),
|
||||
progress: item.watchProgress,
|
||||
onFocusChange: { if $0 { onFocus(item) } }
|
||||
) { onSelect(item) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Eine Mediathek als Raster auf dem Fernseher.
|
||||
///
|
||||
/// **Nachgeladen wird am Fokus, nicht am Erscheinen.** Am Telefon hängt es
|
||||
/// daran, dass eine Kachel sichtbar wird — bei sechzig Kacheln auf einem
|
||||
/// breiten Raster erscheinen die aber alle beim ersten Zeichnen, und das
|
||||
/// Nachladen liefe sofort los statt beim Blättern. Der Fokus steht dagegen
|
||||
/// immer nur an einer Stelle, und genau die ist die Frage.
|
||||
struct TVLibraryView: View {
|
||||
let libraryID: String
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(QuickPlay.self) private var quickPlay
|
||||
|
||||
@State private var feed: LibraryFeed?
|
||||
@FocusState private var fokus: String?
|
||||
|
||||
/// Sechs Spalten auf 1760 Punkten Nutzbreite: rund 250 Punkte je Plakat,
|
||||
/// aus drei Metern noch erkennbar.
|
||||
private static let spalten = 6
|
||||
|
||||
private var raster: [GridItem] {
|
||||
Array(repeating: GridItem(.flexible(), spacing: FlaroSpacing.section), count: Self.spalten)
|
||||
}
|
||||
|
||||
var body: some View {
|
||||
Group {
|
||||
if let feed {
|
||||
inhalt(feed: feed)
|
||||
} else {
|
||||
ProgressView()
|
||||
}
|
||||
}
|
||||
.task {
|
||||
guard feed == nil,
|
||||
let mediathek = session.libraries.first(where: { $0.id == libraryID })
|
||||
else { return }
|
||||
let frisch = LibraryFeed(library: mediathek)
|
||||
feed = frisch
|
||||
await frisch.reload(from: session.backend)
|
||||
}
|
||||
}
|
||||
|
||||
@ViewBuilder
|
||||
private func inhalt(feed: LibraryFeed) -> some View {
|
||||
switch feed.state {
|
||||
case .loading where feed.items.isEmpty:
|
||||
ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
|
||||
|
||||
case .failed(let meldung) where feed.items.isEmpty:
|
||||
VStack(spacing: FlaroSpacing.regular) {
|
||||
Text(meldung).font(.flaroBody).foregroundStyle(.white)
|
||||
Button("action.retry") { Task { await feed.reload(from: session.backend) } }
|
||||
}
|
||||
|
||||
default:
|
||||
raster(feed: feed)
|
||||
}
|
||||
}
|
||||
|
||||
private func raster(feed: LibraryFeed) -> some View {
|
||||
ScrollView {
|
||||
VStack(alignment: .leading, spacing: FlaroSpacing.section) {
|
||||
Text(feed.library.title)
|
||||
.font(.flaroHero)
|
||||
.foregroundStyle(.white)
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
|
||||
LazyVGrid(columns: raster, spacing: FlaroSpacing.section) {
|
||||
ForEach(Array(feed.items.enumerated()), id: \.element.id) { stelle, item in
|
||||
TVPosterCard(
|
||||
title: item.rowTitle,
|
||||
subtitle: item.cardSubtitle,
|
||||
artworkURL: session.backend?.artworkURL(
|
||||
path: item.posterArtworkPath, width: 560, height: 840
|
||||
),
|
||||
progress: item.watchProgress
|
||||
) {
|
||||
// **Über QuickPlay, nicht unmittelbar.** Steht im
|
||||
// Raster eine Serie, hat die keine Fassungen; der
|
||||
// direkte Weg schickte ihre eigene Kennung an den
|
||||
// Player und scheiterte mit „keine abspielbare
|
||||
// Datei". QuickPlay löst stattdessen die nächste
|
||||
// ungesehene Folge auf.
|
||||
//
|
||||
// Ein Kontextmenü wie am Telefon gibt es hier
|
||||
// nicht: langes Drücken ist auf der Fernbedienung
|
||||
// keine verlässliche Geste.
|
||||
quickPlay.start(item, backend: session.backend, coordinator: playback)
|
||||
}
|
||||
.focused($fokus, equals: item.id)
|
||||
.onChange(of: fokus) { _, neu in
|
||||
guard neu == item.id,
|
||||
feed.shouldLoadMore(at: stelle, columns: Self.spalten)
|
||||
else { return }
|
||||
Task { await feed.loadMore(from: session.backend) }
|
||||
}
|
||||
}
|
||||
|
||||
// **Die Platzhalter bleiben.** Am Fernseher sind sie
|
||||
// wichtiger als am Telefon: hört das Raster einfach auf,
|
||||
// läuft der Fokus gegen eine unsichtbare Wand. Sie dürfen
|
||||
// ihn aber nicht annehmen, sonst landet er auf einem
|
||||
// grauen Kasten.
|
||||
ForEach(0..<min(feed.pendingCount, Self.spalten * 2), id: \.self) { _ in
|
||||
PlaceholderCard()
|
||||
.focusable(false)
|
||||
}
|
||||
}
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
|
||||
if feed.loadMoreFailed {
|
||||
Button("library.loadMore") {
|
||||
Task { await feed.loadMore(from: session.backend) }
|
||||
}
|
||||
.padding(.horizontal, FlaroSpacing.screenMargin)
|
||||
}
|
||||
}
|
||||
.padding(.vertical, FlaroSpacing.screenMargin)
|
||||
}
|
||||
.scrollClipDisabled()
|
||||
.scrollIndicators(.never)
|
||||
// Siehe `FlaroSpacing.screenMargin`: bildfüllend, Rand im Wert.
|
||||
.ignoresSafeArea()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
import AVKit
|
||||
import UIKit
|
||||
import FlaroPlayback
|
||||
import MediaKit
|
||||
|
||||
/// Führt Apples Player — und hält ihn über einen Neuaufbau hinweg am Leben.
|
||||
///
|
||||
/// **Das Problem, um das es hier geht.** Unsere Ton- und Untertitelwahl geht
|
||||
/// als `audioStreamIndex` an Jellyfin und verlangt bei einem Transcode einen
|
||||
/// **neuen Stream**. Apples eingebauter Spurwähler zeigt dagegen die
|
||||
/// `AVMediaSelectionGroup`s des **laufenden** Streams — beim Transcode genau
|
||||
/// eine. Er ist also die richtige Oberfläche für die falsche Liste.
|
||||
///
|
||||
/// Deshalb bekommt die Transportleiste unsere eigenen Menüs über
|
||||
/// `transportBarCustomMenuItems`. Nicht `customInfoViewControllers`: die Wahl
|
||||
/// der Tonspur ist ein Bedienelement der Wiedergabe, kein Begleitmaterial —
|
||||
/// Apples eigene Beispiele dafür sind Bonusinhalte und Verwandtes, und dort
|
||||
/// erwartet niemand „Sprache".
|
||||
@MainActor
|
||||
final class TVPlayerCoordinator: NSObject, @MainActor AVPlayerViewControllerDelegate {
|
||||
let controller = AVPlayerViewController()
|
||||
|
||||
private let onDismiss: () -> Void
|
||||
private let appearance: SubtitleAppearance
|
||||
private var letzteAufnahme: TVPlayerSnapshot?
|
||||
/// Wacht darüber, wann es etwas zu beschriften gibt.
|
||||
///
|
||||
/// **Nicht beim Austausch des Players.** In dem Moment ist `currentItem`
|
||||
/// noch `nil` — das Item entsteht erst, wenn das Asset geladen ist, und
|
||||
/// bis dahin zeigt Apples Titelzeile, was es selbst aus der Datei liest:
|
||||
/// „Unbekannt". Also wird gewartet, bis das Item wirklich da ist.
|
||||
private var itemBeobachter: NSKeyValueObservation?
|
||||
/// Was drinstehen soll, sobald es ein Item gibt.
|
||||
private var beschriftung: (titel: String, untertitel: String?)?
|
||||
/// Die Abdeckung für das schwarze Bild während eines Neuaufbaus.
|
||||
private lazy var abdeckung = TVRebuildOverlay()
|
||||
private var abdeckungsAufgabe: Task<Void, Never>?
|
||||
|
||||
init(appearance: SubtitleAppearance, onDismiss: @escaping () -> Void) {
|
||||
self.appearance = appearance
|
||||
self.onDismiss = onDismiss
|
||||
super.init()
|
||||
controller.delegate = self
|
||||
controller.videoGravity = .resizeAspect
|
||||
// Nie auf dem Fernseher — ein Apple TV hat kein zweites Fenster.
|
||||
controller.allowsPictureInPicturePlayback = false
|
||||
controller.transportBarIncludesTitleView = true
|
||||
|
||||
// **Apples eigenen Untertitelknopf abschalten.**
|
||||
//
|
||||
// Sonst stehen zwei Sprechblasen nebeneinander, und welche was tut,
|
||||
// sieht man erst nach dem Drücken. Schlimmer noch: Apples Menü
|
||||
// verstellt die **Systemeinstellung** für Untertitel, während unsere
|
||||
// Engine `AVTextStyleRule`s aus `SubtitleAppearance` setzt — zwei
|
||||
// Stilregler, von denen nur einer wirkt.
|
||||
//
|
||||
// `nil` heisst „alle Sprachen anbieten", eine leere Liste also keine.
|
||||
// Das ist der einzige dokumentierte Hebel dafür; die Auswahl von Hand
|
||||
// (`AVPlayerEngine`) bleibt davon unberührt, hier geht es nur um das,
|
||||
// was die Leiste anbietet.
|
||||
controller.allowedSubtitleOptionLanguages = []
|
||||
|
||||
// **Hinter den Bedienelementen und ohne Fokus.** `contentOverlayView`
|
||||
// liegt über dem Bild, aber unter Apples Leiste, und nimmt keine
|
||||
// Eingaben an. `customOverlayViewController` täte beides nicht: der
|
||||
// ersetzt die ganze Überlagerung und zieht den Fokus an sich — damit
|
||||
// wäre die Fernbedienung während des Umschaltens tot.
|
||||
if let ebene = controller.contentOverlayView {
|
||||
abdeckung.translatesAutoresizingMaskIntoConstraints = false
|
||||
ebene.addSubview(abdeckung)
|
||||
NSLayoutConstraint.activate([
|
||||
abdeckung.topAnchor.constraint(equalTo: ebene.topAnchor),
|
||||
abdeckung.bottomAnchor.constraint(equalTo: ebene.bottomAnchor),
|
||||
abdeckung.leadingAnchor.constraint(equalTo: ebene.leadingAnchor),
|
||||
abdeckung.trailingAnchor.constraint(equalTo: ebene.trailingAnchor),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Nachführen
|
||||
|
||||
func apply(_ aufnahme: TVPlayerSnapshot, model: PlayerModel) {
|
||||
defer { letzteAufnahme = aufnahme }
|
||||
|
||||
// **Den Player nur austauschen, wenn es ein anderer ist.** `restart()`
|
||||
// baut eine neue Engine mit einem neuen `AVPlayer`; genau dann — und
|
||||
// nur dann — wird das Bild schwarz.
|
||||
if aufnahme.playerIdentity != letzteAufnahme?.playerIdentity {
|
||||
controller.player = model.systemPlayer
|
||||
beobachteItem()
|
||||
}
|
||||
beschriftung = (aufnahme.title, aufnahme.subtitle)
|
||||
beschrifte()
|
||||
|
||||
zeigeAbdeckung(aufnahme.isRebuilding)
|
||||
controller.transportBarCustomMenuItems = TVTrackMenuBuilder.items(
|
||||
for: aufnahme,
|
||||
appearance: appearance,
|
||||
onAudio: { [weak model] index in
|
||||
guard let model, let stream = model.audioStreams.first(where: { $0.index == index })
|
||||
else { return }
|
||||
Task { await model.selectAudioStream(stream) }
|
||||
},
|
||||
onSubtitle: { [weak model] index in
|
||||
guard let model else { return }
|
||||
let stream = index.flatMap { i in
|
||||
model.subtitleStreams.first { $0.index == i }
|
||||
}
|
||||
Task { await model.selectSubtitleStream(stream) }
|
||||
}
|
||||
)
|
||||
controller.contextualActions = TVTrackMenuBuilder.contextualActions(
|
||||
for: aufnahme,
|
||||
onSkip: { [weak model] in model?.skipActiveMarker() }
|
||||
)
|
||||
}
|
||||
|
||||
private func beobachteItem() {
|
||||
itemBeobachter = controller.player?.observe(\.currentItem, options: [.initial, .new]) {
|
||||
[weak self] _, _ in
|
||||
MainActor.assumeIsolated { self?.beschrifte() }
|
||||
}
|
||||
}
|
||||
|
||||
/// Titel und Untertitel in Apples Titelzeile.
|
||||
///
|
||||
/// Über `externalMetadata` am `AVPlayerItem`, weil die Transportleiste
|
||||
/// genau dort nachsieht. Auf iOS zeichnet unsere eigene Kopfzeile das;
|
||||
/// hier gäbe es sonst gar keine Auskunft darüber, was läuft — ausser dem,
|
||||
/// was AVKit selbst aus der Datei liest, und das ist bei einem
|
||||
/// Transcode-Stream „Unbekannt".
|
||||
private func beschrifte() {
|
||||
guard let item = controller.player?.currentItem,
|
||||
let beschriftung
|
||||
else { return }
|
||||
var einträge: [AVMetadataItem] = [eintrag(.commonIdentifierTitle, beschriftung.titel)]
|
||||
if let untertitel = beschriftung.untertitel {
|
||||
einträge.append(eintrag(.iTunesMetadataTrackSubTitle, untertitel))
|
||||
}
|
||||
item.externalMetadata = einträge
|
||||
}
|
||||
|
||||
private func eintrag(_ kennung: AVMetadataIdentifier, _ wert: String) -> AVMetadataItem {
|
||||
let eintrag = AVMutableMetadataItem()
|
||||
eintrag.identifier = kennung
|
||||
eintrag.value = wert as NSString
|
||||
eintrag.extendedLanguageTag = "und"
|
||||
return eintrag
|
||||
}
|
||||
|
||||
/// Blendet die Abdeckung ein — aber erst nach einer Viertelsekunde.
|
||||
///
|
||||
/// Der häufige Fall (unverändert gespielt, unter fünfzig Millisekunden)
|
||||
/// soll nicht aufblitzen. Wer nur umschaltet, sieht dann gar nichts.
|
||||
private func zeigeAbdeckung(_ sichtbar: Bool) {
|
||||
abdeckungsAufgabe?.cancel()
|
||||
guard sichtbar else {
|
||||
abdeckung.setVisible(false)
|
||||
return
|
||||
}
|
||||
abdeckungsAufgabe = Task { [weak self] in
|
||||
try? await Task.sleep(for: .milliseconds(250))
|
||||
guard !Task.isCancelled else { return }
|
||||
self?.abdeckung.setVisible(true)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Der Menü-Knopf der Fernbedienung
|
||||
|
||||
/// Fängt den Menü-Knopf ab, statt in SwiftUI `onExitCommand` zu raten.
|
||||
func playerViewControllerShouldDismiss(_ controller: AVPlayerViewController) -> Bool {
|
||||
onDismiss()
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
/// Die Abdeckung, die das schwarze Bild während eines Neuaufbaus zudeckt.
|
||||
///
|
||||
/// Ohne sie sieht man Sekunden lang nichts und hält es für einen Absturz —
|
||||
/// dabei ist es die angekündigte Folge einer Spurwahl.
|
||||
@MainActor
|
||||
final class TVRebuildOverlay: UIView {
|
||||
private let kreisel = UIActivityIndicatorView(style: .large)
|
||||
private let zeile = UILabel()
|
||||
|
||||
override init(frame: CGRect) {
|
||||
super.init(frame: frame)
|
||||
backgroundColor = UIColor.black.withAlphaComponent(0.75)
|
||||
isUserInteractionEnabled = false
|
||||
alpha = 0
|
||||
|
||||
kreisel.color = .white
|
||||
kreisel.startAnimating()
|
||||
zeile.text = String(localized: "player.rebuilding")
|
||||
zeile.textColor = .white
|
||||
zeile.font = .preferredFont(forTextStyle: .headline)
|
||||
|
||||
let stapel = UIStackView(arrangedSubviews: [kreisel, zeile])
|
||||
stapel.axis = .vertical
|
||||
stapel.alignment = .center
|
||||
stapel.spacing = 24
|
||||
stapel.translatesAutoresizingMaskIntoConstraints = false
|
||||
addSubview(stapel)
|
||||
NSLayoutConstraint.activate([
|
||||
stapel.centerXAnchor.constraint(equalTo: centerXAnchor),
|
||||
stapel.centerYAnchor.constraint(equalTo: centerYAnchor),
|
||||
])
|
||||
}
|
||||
|
||||
@available(*, unavailable)
|
||||
required init?(coder: NSCoder) { fatalError("nicht aus einem Storyboard") }
|
||||
|
||||
func setVisible(_ sichtbar: Bool) {
|
||||
UIView.animate(withDuration: 0.2) { self.alpha = sichtbar ? 1 : 0 }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
import AVKit
|
||||
import SwiftUI
|
||||
import FlaroPlayback
|
||||
import MediaKit
|
||||
|
||||
/// Hängt Apples Player in den SwiftUI-Baum.
|
||||
///
|
||||
/// **Wem was gehört.** Der `AVPlayerViewController` gehört dem Coordinator,
|
||||
/// nicht der SwiftUI-Struktur — die wird bei jedem Neuzeichnen neu gebaut —
|
||||
/// und nicht dem `PlayerModel`, das frei von UIKit bleiben soll. Das Modell
|
||||
/// gibt nur seinen `AVPlayer` heraus, und das ist AVFoundation.
|
||||
@MainActor
|
||||
struct TVPlayerHost: UIViewControllerRepresentable {
|
||||
let model: PlayerModel
|
||||
/// Eine Momentaufnahme dessen, was den Controller betrifft.
|
||||
///
|
||||
/// **Als Wert, nicht als Verweis.** SwiftUI ruft `updateUIViewController`
|
||||
/// nur, wenn sich am Repräsentanten etwas geändert hat. Stünde hier allein
|
||||
/// das Modell, änderte sich nie etwas: es ist eine Klasse, und ihre
|
||||
/// Kennung bleibt über jeden Spurwechsel hinweg dieselbe. Der Wert wird im
|
||||
/// Rumpf der umgebenden Ansicht gebildet — dort und nur dort entsteht die
|
||||
/// Beobachtungsbeziehung zu `@Observable`.
|
||||
let snapshot: TVPlayerSnapshot
|
||||
/// Der Untertitelstil — er steht im selben Menü wie die Spurwahl.
|
||||
let appearance: SubtitleAppearance
|
||||
let onDismiss: () -> Void
|
||||
|
||||
func makeUIViewController(context: Context) -> AVPlayerViewController {
|
||||
context.coordinator.controller
|
||||
}
|
||||
|
||||
func updateUIViewController(_ controller: AVPlayerViewController, context: Context) {
|
||||
context.coordinator.apply(snapshot, model: model)
|
||||
}
|
||||
|
||||
func makeCoordinator() -> TVPlayerCoordinator {
|
||||
TVPlayerCoordinator(appearance: appearance, onDismiss: onDismiss)
|
||||
}
|
||||
}
|
||||
|
||||
/// Was der Controller von der Wiedergabe wissen muss — und mehr nicht.
|
||||
struct TVPlayerSnapshot: Equatable {
|
||||
/// Wechselt bei jedem Neuaufbau. Daran hängt der Austausch des Players.
|
||||
let playerIdentity: ObjectIdentifier?
|
||||
let audio: [TrackMenu.Entry]
|
||||
let subtitles: [TrackMenu.Entry]
|
||||
/// Läuft gerade ein Neuaufbau? Dann ist das Bild schwarz und das Menü
|
||||
/// gesperrt.
|
||||
let isRebuilding: Bool
|
||||
let title: String
|
||||
let subtitle: String?
|
||||
/// Der Zeitbereich einer Marke — für „Intro überspringen".
|
||||
let markerLabel: String?
|
||||
/// Der eingestellte Untertitelstil.
|
||||
///
|
||||
/// **Gehört in die Momentaufnahme, obwohl der Player ihn nicht braucht.**
|
||||
/// Er steht im selben Menü wie die Spurwahl, und ohne ihn hier merkte
|
||||
/// SwiftUI nicht, dass sich etwas geändert hat — die Haken blieben beim
|
||||
/// alten Wert stehen, während die Untertitel längst anders aussähen.
|
||||
let subtitleStyle: SubtitleStyle
|
||||
|
||||
/// `@MainActor`, weil das Modell es ist: gelesen wird hier zwölfmal aus
|
||||
/// ihm, und zwar im Rumpf einer View — also ohnehin auf dem Hauptakteur.
|
||||
@MainActor
|
||||
init(_ model: PlayerModel, appearance: SubtitleAppearance, offLabel: String) {
|
||||
subtitleStyle = appearance.style
|
||||
playerIdentity = model.systemPlayer.map(ObjectIdentifier.init)
|
||||
let direkt: Bool = if case .directPlay = model.decision?.method { true } else { false }
|
||||
audio = TrackMenu.audio(
|
||||
from: model.audioStreams,
|
||||
selected: model.selectedAudioStream,
|
||||
isDirectPlay: direkt,
|
||||
playerTrackCount: model.audioTracks.count
|
||||
)
|
||||
subtitles = TrackMenu.subtitles(
|
||||
from: model.subtitleStreams,
|
||||
selected: model.selectedSubtitleStream,
|
||||
isDirectPlay: direkt,
|
||||
playerTrackLanguages: model.subtitleTracks.map(\.languageCode),
|
||||
offLabel: offLabel
|
||||
)
|
||||
isRebuilding = model.isChangingQuality
|
||||
title = model.title
|
||||
subtitle = model.subtitle
|
||||
markerLabel = model.activeMarker.map {
|
||||
String(localized: $0.isIntro ? "player.skipIntro" : "player.skipCredits")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import FlaroPlayback
|
||||
import MediaKit
|
||||
|
||||
/// Der Player auf dem Fernseher.
|
||||
///
|
||||
/// **Das Modell lebt hier und stirbt hier.** Auf dem Telefon hält `RootView`
|
||||
/// es fest, damit die Wiedergabe den Wechsel zwischen Kachel und Vollbild
|
||||
/// überlebt. Ohne Mini-Player gibt es diesen Wechsel nicht, und ein
|
||||
/// hochgehaltenes Modell hielte nur eine tote Engine, einen laufenden
|
||||
/// Transcoder und eine offene Jellyfin-Sitzung am Leben, nachdem der Player
|
||||
/// längst weg ist.
|
||||
struct TVPlayerScreen: View {
|
||||
let request: PlaybackRequest
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(PlaybackSettings.self) private var settings
|
||||
@Environment(LanguagePreferences.self) private var languages
|
||||
@Environment(SubtitleAppearance.self) private var subtitleAppearance
|
||||
@Environment(NetworkConditions.self) private var network
|
||||
@Environment(PlaybackDiagnostics.self) private var diagnostics
|
||||
|
||||
@State private var model: PlayerModel?
|
||||
|
||||
var body: some View {
|
||||
ZStack {
|
||||
Color.black.ignoresSafeArea()
|
||||
|
||||
if let model {
|
||||
// **Die Momentaufnahme entsteht hier, im Rumpf einer View.**
|
||||
// Nur so entsteht die Beobachtungsbeziehung zu `@Observable`
|
||||
// — ein Repräsentant, der bloss das Modell hält, bekäme nie
|
||||
// ein `updateUIViewController`.
|
||||
TVPlayerHost(
|
||||
model: model,
|
||||
snapshot: TVPlayerSnapshot(
|
||||
model,
|
||||
appearance: subtitleAppearance,
|
||||
offLabel: String(localized: "player.subtitlesOff")
|
||||
),
|
||||
appearance: subtitleAppearance,
|
||||
onDismiss: { playback.close() }
|
||||
)
|
||||
.ignoresSafeArea()
|
||||
} else {
|
||||
ProgressView()
|
||||
}
|
||||
}
|
||||
// **Der Stil wirkt sofort, ohne Neuaufbau.**
|
||||
//
|
||||
// Auf `style` und nicht auf die Klasse: ein `@Observable` meldet jede
|
||||
// Berührung, und dann liefe das hier auch, wenn sich nichts geändert
|
||||
// hat. `SubtitleStyle` ist vergleichbar und feuert nur bei einer
|
||||
// echten Änderung.
|
||||
//
|
||||
// Dass es hier steht und nicht im Coordinator, hat denselben Grund
|
||||
// wie die Momentaufnahme: nur im Rumpf einer View entsteht die
|
||||
// Beobachtungsbeziehung.
|
||||
.onChange(of: subtitleAppearance.style) { _, neu in
|
||||
model?.engine?.applySubtitleStyle(neu)
|
||||
}
|
||||
// **Der Menü-Knopf wirkt auch, solange noch nichts läuft.**
|
||||
//
|
||||
// `AVPlayerViewController` fängt ihn selbst ab — aber erst, wenn er
|
||||
// einen Player mit einem Item hat. Solange der Stream noch
|
||||
// ausgehandelt wird oder der Server erst anfängt zu rechnen, gibt es
|
||||
// den nicht, und man sass fest: schwarzes Bild, Kreisel, kein Weg
|
||||
// zurück. Hier liegt der Griff eine Ebene darüber, wo es ihn vom
|
||||
// ersten Bild an gibt.
|
||||
//
|
||||
// Doppelt ist er nicht: greift Apples Player zu, kommt der Befehl
|
||||
// hier gar nicht mehr an.
|
||||
.onExitCommand { playback.close() }
|
||||
.task {
|
||||
guard model == nil else { return }
|
||||
let frisch = PlayerModel(
|
||||
request: request,
|
||||
backend: session.backend,
|
||||
liveTV: nil, // Kein Live-TV in Fassung eins.
|
||||
downloads: nil, // Nie auf dem Fernseher.
|
||||
diagnostics: diagnostics,
|
||||
policy: settings.policy(for: network),
|
||||
settings: settings,
|
||||
languages: languages,
|
||||
subtitles: subtitleAppearance,
|
||||
isLocalConnection: session.isLocalConnection,
|
||||
connectionDescription: session.connectionDescription,
|
||||
unavailableMessage: session.playbackUnavailableMessage
|
||||
)
|
||||
model = frisch
|
||||
await frisch.start()
|
||||
}
|
||||
// Beim Verschwinden wirklich Schluss: Engine abräumen, Fortschritt
|
||||
// melden, die Jellyfin-Sitzung schliessen. Ohne das liefe der
|
||||
// Transcoder auf dem Server weiter, obwohl niemand mehr zusieht.
|
||||
.onDisappear { [model] in Task { await model?.stop() } }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
import AVKit
|
||||
import UIKit
|
||||
import FlaroPlayback
|
||||
|
||||
/// Baut aus unseren Spurlisten die Menüs für Apples Transportleiste.
|
||||
///
|
||||
/// Die reine Abbildung steht in `TrackMenu` und ist dort geprüft; hier geht es
|
||||
/// nur noch um UIKit.
|
||||
@MainActor
|
||||
enum TVTrackMenuBuilder {
|
||||
/// - Parameter appearance: Der Untertitelstil. Er steht **in** diesem
|
||||
/// Menü und nicht daneben: vorher gab es zwei Knöpfe mit derselben
|
||||
/// Sprechblase — einen für die Spur, einen für den Stil —, und welcher
|
||||
/// was tat, sah man erst nach dem Drücken.
|
||||
static func items(
|
||||
for aufnahme: TVPlayerSnapshot,
|
||||
appearance: SubtitleAppearance,
|
||||
onAudio: @escaping (Int?) -> Void,
|
||||
onSubtitle: @escaping (Int?) -> Void
|
||||
) -> [UIMenuElement] {
|
||||
var menüs: [UIMenuElement] = []
|
||||
|
||||
// **Unser Tonmenü nur, wenn Apples eigenes es nicht kann.**
|
||||
//
|
||||
// Wird die Datei unverändert gespielt und stimmt die Spurzahl, liegen
|
||||
// alle Spuren im Stream — dann zeigt Apple sie selbst, und zwei
|
||||
// Knöpfe nebeneinander wären dasselbe zweimal. Beim Umrechnen liegt
|
||||
// im Stream dagegen genau eine, und nur unser Menü führt weiter.
|
||||
if aufnahme.audio.count > 1, aufnahme.audio.contains(where: \.rebuilds) {
|
||||
menüs.append(UIMenu(
|
||||
title: String(localized: "player.audioTracks"),
|
||||
image: UIImage(systemName: "waveform"),
|
||||
options: [.singleSelection],
|
||||
children: einträge(aufnahme.audio, gesperrt: aufnahme.isRebuilding, aktion: onAudio)
|
||||
))
|
||||
}
|
||||
|
||||
// **Untertitel immer über uns**, auch wenn Apple es könnte: hier hängt
|
||||
// der Stil mit drin, und der ist unserer — `AVTextStyleRule`s aus
|
||||
// `SubtitleAppearance`, nicht die Systemeinstellung, die Apples Menü
|
||||
// verstellt. Apples eigener Knopf ist deshalb abgeschaltet; siehe
|
||||
// `TVPlayerCoordinator`.
|
||||
menüs.append(UIMenu(
|
||||
title: String(localized: "player.subtitleTracks"),
|
||||
image: UIImage(systemName: "captions.bubble"),
|
||||
children: [
|
||||
// Inline: die Spuren stehen ohne Umweg da, der Stil darunter
|
||||
// als eigene Untermenüs. Tiefer geht es nicht — die
|
||||
// Transportleiste zeigt genau eine Ebene.
|
||||
UIMenu(options: [.displayInline, .singleSelection],
|
||||
children: einträge(aufnahme.subtitles,
|
||||
gesperrt: aufnahme.isRebuilding,
|
||||
aktion: onSubtitle)),
|
||||
größenMenü(appearance),
|
||||
darstellungsMenü(appearance),
|
||||
]
|
||||
))
|
||||
|
||||
return menüs
|
||||
}
|
||||
|
||||
// MARK: - Die Spuren
|
||||
|
||||
private static func einträge(
|
||||
_ liste: [TrackMenu.Entry],
|
||||
gesperrt: Bool,
|
||||
aktion: @escaping (Int?) -> Void
|
||||
) -> [UIMenuElement] {
|
||||
liste.map { eintrag in
|
||||
UIAction(
|
||||
title: eintrag.title,
|
||||
// **Vorher ansagen, nicht hinterher erklären.** Steht hier
|
||||
// nichts, ist die Sekundenpause danach eine Panne; steht es
|
||||
// hier, ist sie eine angekündigte Folge. Das ist der billigste
|
||||
// Teil dieser ganzen Sache und der wirksamste.
|
||||
subtitle: eintrag.rebuilds ? String(localized: "player.rebuilds") : nil,
|
||||
// **Keine zweite Bestellung, solange die erste läuft.** Sonst
|
||||
// räumt `restart()` eine Engine ab, die eine andere gerade baut.
|
||||
attributes: gesperrt ? [.disabled] : [],
|
||||
state: eintrag.isSelected ? .on : .off
|
||||
) { auslöser in
|
||||
// **Sofort quittieren.** Das Menü schliesst sich beim Drücken,
|
||||
// und darin ist kein Platz für einen Kreisel. Der Haken
|
||||
// wandert, bevor sich am Bild etwas tut.
|
||||
auslöser.state = .on
|
||||
aktion(eintrag.id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Der Stil
|
||||
|
||||
private static func größenMenü(_ appearance: SubtitleAppearance) -> UIMenu {
|
||||
UIMenu(
|
||||
title: String(localized: "subtitleStyle.sizeHeader"),
|
||||
image: UIImage(systemName: "textformat.size"),
|
||||
options: [.singleSelection],
|
||||
children: SubtitleStyle.Size.allCases.map { größe in
|
||||
UIAction(
|
||||
title: größe.label,
|
||||
state: appearance.size == größe ? .on : .off
|
||||
) { auslöser in
|
||||
auslöser.state = .on
|
||||
appearance.size = größe
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
private static func darstellungsMenü(_ appearance: SubtitleAppearance) -> UIMenu {
|
||||
UIMenu(
|
||||
title: String(localized: "subtitleStyle.paletteHeader"),
|
||||
image: UIImage(systemName: "paintpalette"),
|
||||
options: [.singleSelection],
|
||||
children: SubtitleStyle.Palette.allCases.map { palette in
|
||||
UIAction(
|
||||
title: palette.label,
|
||||
state: appearance.palette == palette ? .on : .off
|
||||
) { auslöser in
|
||||
auslöser.state = .on
|
||||
appearance.palette = palette
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
/// „Intro überspringen" unten rechts, solange eine Marke läuft.
|
||||
///
|
||||
/// Die tvOS-Entsprechung zu dem Knopf, den der iOS-Player selbst zeichnet.
|
||||
static func contextualActions(
|
||||
for aufnahme: TVPlayerSnapshot,
|
||||
onSkip: @escaping () -> Void
|
||||
) -> [UIAction] {
|
||||
guard let beschriftung = aufnahme.markerLabel else { return [] }
|
||||
return [UIAction(title: beschriftung) { _ in onSkip() }]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Die Suche am Fernseher.
|
||||
///
|
||||
/// **`.searchable` und keine eigene Tastatur.** tvOS macht daraus einen
|
||||
/// eigenen Bildschirm mit Rastertastatur links und Ergebnissen rechts — die
|
||||
/// Bedienung, die jeder von Apples eigenen Apps kennt. Etwas Eigenes zu bauen
|
||||
/// hiesse, sie nachzuahmen und dabei die Diktierfunktion zu verlieren.
|
||||
///
|
||||
/// Das Modell dahinter ist dasselbe wie am Telefon: `SearchFeed` entprellt,
|
||||
/// fragt und merkt sich die letzten Begriffe.
|
||||
struct TVSearchView: View {
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(QuickPlay.self) private var quickPlay
|
||||
|
||||
@State private var text = ""
|
||||
@State private var feed = SearchFeed()
|
||||
@State private var pfad = NavigationPath()
|
||||
|
||||
var body: some View {
|
||||
NavigationStack(path: $pfad) {
|
||||
inhalt
|
||||
.navigationDestination(for: MediaRoute.self) { route in
|
||||
TVDetailView(route: route)
|
||||
}
|
||||
}
|
||||
.searchable(text: $text, prompt: Text("search.hint"))
|
||||
// Jeder Tastendruck löst eine Anfrage aus — aber erst nach einer
|
||||
// kurzen Pause. Siehe `SearchFeed`.
|
||||
.task(id: text) { await feed.search(text, from: session.backend) }
|
||||
}
|
||||
|
||||
@ViewBuilder
|
||||
private var inhalt: some View {
|
||||
if text.isEmpty {
|
||||
zuletzt
|
||||
} else if feed.hubs.isEmpty {
|
||||
// Kein Unterschied zwischen „sucht noch" und „nichts gefunden":
|
||||
// auf dem Fernseher tippt man langsam, und ein Text, der bei
|
||||
// jedem Buchstaben zwischen beiden wechselt, flackert nur.
|
||||
leer
|
||||
} else {
|
||||
ergebnisse
|
||||
}
|
||||
}
|
||||
|
||||
private var ergebnisse: some View {
|
||||
ScrollView {
|
||||
LazyVStack(alignment: .leading, spacing: FlaroSpacing.section) {
|
||||
ForEach(feed.hubs) { reihe in
|
||||
TVMediaRow(
|
||||
row: reihe,
|
||||
onSelect: { quickPlay.start($0, backend: session.backend, coordinator: playback) }
|
||||
)
|
||||
}
|
||||
}
|
||||
.padding(.vertical, FlaroSpacing.section)
|
||||
}
|
||||
.scrollClipDisabled()
|
||||
.scrollIndicators(.never)
|
||||
}
|
||||
|
||||
/// Die letzten Begriffe — als Knöpfe, nicht als Liste.
|
||||
///
|
||||
/// Am Fernseher ist das der eigentliche Wert der Suche: einmal getippt,
|
||||
/// danach ein Druck. Eine Zeile mit Wischen zum Löschen gibt es hier
|
||||
/// nicht, deshalb steht das Vergessen als eigener Knopf daneben.
|
||||
@ViewBuilder
|
||||
private var zuletzt: some View {
|
||||
if feed.recent.isEmpty {
|
||||
hinweis("search.hint")
|
||||
} else {
|
||||
VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
|
||||
Text("search.recent")
|
||||
.font(.flaroRowHeader)
|
||||
.foregroundStyle(Color.flaroTextPrimary)
|
||||
|
||||
ForEach(feed.recent, id: \.self) { eintrag in
|
||||
Button(eintrag) { text = eintrag }
|
||||
}
|
||||
|
||||
Button("search.forgetRecent", role: .destructive) { feed.forgetRecent() }
|
||||
.padding(.top, FlaroSpacing.regular)
|
||||
}
|
||||
.frame(maxWidth: 700, alignment: .leading)
|
||||
.padding(FlaroSpacing.section)
|
||||
}
|
||||
}
|
||||
|
||||
private var leer: some View {
|
||||
hinweis("search.noResults")
|
||||
}
|
||||
|
||||
private func hinweis(_ text: LocalizedStringKey) -> some View {
|
||||
Text(text)
|
||||
.font(.flaroBody)
|
||||
.foregroundStyle(Color.flaroTextMuted)
|
||||
.frame(maxWidth: 700)
|
||||
.padding(FlaroSpacing.section)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import JellyfinKit
|
||||
|
||||
/// Die Anmeldung am Fernseher.
|
||||
///
|
||||
/// **Dieselben vier Schritte wie am Telefon, andere Reihenfolge.** Das Modell
|
||||
/// `JellyfinSignInModel` ist unverändert dasselbe — nur bekommt es hier
|
||||
/// `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
|
||||
/// denen Quick Connect abgeschaltet ist.
|
||||
struct TVSignInView: View {
|
||||
@Environment(FlaroSession.self) private var session
|
||||
|
||||
@State private var model: JellyfinSignInModel?
|
||||
|
||||
var body: some View {
|
||||
ZStack {
|
||||
Color.flaroCanvas.ignoresSafeArea()
|
||||
|
||||
if let model {
|
||||
inhalt(for: model)
|
||||
// Eine Spalte, nicht die volle Breite: 1760 Punkte Zeile
|
||||
// liest sich aus drei Metern nicht mehr als Zeile.
|
||||
.frame(maxWidth: 900)
|
||||
} else {
|
||||
ProgressView()
|
||||
}
|
||||
}
|
||||
.task {
|
||||
// Erst hier, nicht im Eigenschaftswert: das Modell braucht die
|
||||
// Gerätekennung der Sitzung. Baut es sich eine eigene, steht die
|
||||
// App nach dem Anmelden ein zweites Mal in der Geräteliste.
|
||||
guard model == nil else { return }
|
||||
let frisch = JellyfinSignInModel(
|
||||
identity: session.jellyfinDeviceIdentity,
|
||||
preferring: .quickConnect
|
||||
)
|
||||
frisch.onAuthenticated = { client, account, serverName in
|
||||
Task {
|
||||
await session.adoptJellyfin(
|
||||
client: client, account: account, serverName: serverName
|
||||
)
|
||||
}
|
||||
}
|
||||
model = frisch
|
||||
}
|
||||
.onDisappear { model?.cancel() }
|
||||
}
|
||||
|
||||
@ViewBuilder
|
||||
private func inhalt(for model: JellyfinSignInModel) -> some View {
|
||||
@Bindable var model = model
|
||||
|
||||
VStack(alignment: .leading, spacing: FlaroSpacing.section) {
|
||||
Text(Branding.appName).font(.flaroHero)
|
||||
Text("signIn.tagline").font(.flaroBody).foregroundStyle(Color.flaroTextMuted)
|
||||
|
||||
switch model.step {
|
||||
case .address:
|
||||
adresse(model: model)
|
||||
case .checking:
|
||||
warten("signIn.jellyfin.searching")
|
||||
case .quickConnect(let code):
|
||||
codeAnzeigen(model: model, code: code)
|
||||
case .credentials:
|
||||
zugangsdaten(model: model)
|
||||
case .signingIn:
|
||||
warten("signIn.jellyfin.signingIn")
|
||||
}
|
||||
|
||||
if let fehler = model.errorMessage {
|
||||
Text(fehler).font(.flaroBody).foregroundStyle(Color.flaroDestructive)
|
||||
}
|
||||
}
|
||||
.padding(FlaroSpacing.section)
|
||||
}
|
||||
|
||||
// MARK: - Die vier Schritte
|
||||
|
||||
private func adresse(model: JellyfinSignInModel) -> some View {
|
||||
@Bindable var model = model
|
||||
|
||||
return VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
|
||||
Text("signIn.jellyfin.addressPrompt").font(.flaroRowHeader)
|
||||
// Auf tvOS öffnet ein Textfeld beim Fokussieren die
|
||||
// Bildschirmtastatur ganzseitig — deshalb steht hier nur das Feld
|
||||
// und keine Maske drumherum.
|
||||
TextField("signIn.jellyfin.addressPlaceholder", text: $model.address)
|
||||
.flaroPlainEntry(isAddress: true)
|
||||
Text("signIn.jellyfin.addressHint")
|
||||
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
|
||||
Button("signIn.jellyfin.connect") {
|
||||
Task { await model.findServer() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func codeAnzeigen(model: JellyfinSignInModel, 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.jellyfin.quickConnectHint").font(.flaroBody)
|
||||
Label("signIn.jellyfin.waitingForApproval", systemImage: "hourglass")
|
||||
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
|
||||
|
||||
HStack(spacing: FlaroSpacing.regular) {
|
||||
Button("signIn.jellyfin.usePassword") { model.useCredentials() }
|
||||
Button("signIn.jellyfin.otherAddress") { model.startOver() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func zugangsdaten(model: JellyfinSignInModel) -> some View {
|
||||
@Bindable var model = model
|
||||
|
||||
return VStack(alignment: .leading, spacing: FlaroSpacing.regular) {
|
||||
if let name = model.serverName {
|
||||
Text(name).font(.flaroRowHeader)
|
||||
}
|
||||
TextField("signIn.jellyfin.userName", text: $model.userName)
|
||||
.flaroPlainEntry()
|
||||
SecureField("signIn.jellyfin.password", text: $model.password)
|
||||
Text("signIn.jellyfin.passwordNote")
|
||||
.font(.flaroCaption).foregroundStyle(Color.flaroTextMuted)
|
||||
|
||||
HStack(spacing: FlaroSpacing.regular) {
|
||||
Button("signIn.jellyfin.submit") {
|
||||
Task { await model.signInWithPassword() }
|
||||
}
|
||||
if model.offersQuickConnect {
|
||||
Button("signIn.jellyfin.useCode") {
|
||||
Task { await model.beginQuickConnect() }
|
||||
}
|
||||
}
|
||||
Button("signIn.jellyfin.otherAddress") { model.startOver() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func warten(_ text: LocalizedStringKey) -> some View {
|
||||
HStack(spacing: FlaroSpacing.regular) {
|
||||
ProgressView()
|
||||
Text(text).font(.flaroBody)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
import Foundation
|
||||
|
||||
/// Was ein Link aus dem Regal bedeutet.
|
||||
///
|
||||
/// **Ein reiner Typ, ohne Ansicht und ohne Netz.** Ein Tippfehler im Schema
|
||||
/// lässt nichts abstürzen: ein Druck auf ein Plakat täte einfach nichts, ohne
|
||||
/// Fehler und ohne Hinweis.
|
||||
///
|
||||
/// Geprüft ist er trotzdem nicht — das Fernseh-Ziel hat kein Testziel, und
|
||||
/// ihn dafür nach MediaKit zu schieben hiesse, ein Schema dieser App in ein
|
||||
/// Paket zu legen, das keine App kennt. Wer ihn anfasst, prüft ihn am Gerät:
|
||||
/// `xcrun simctl openurl … flaro://play/<kennung>`.
|
||||
enum TVDeepLink: Equatable {
|
||||
/// Abspielen, was dahintersteckt.
|
||||
case play(id: String)
|
||||
/// Die Detailseite zeigen.
|
||||
case detail(id: String)
|
||||
|
||||
/// Muss mit `CFBundleURLSchemes` in der Info.plist übereinstimmen.
|
||||
static let scheme = "flaro"
|
||||
|
||||
init?(_ url: URL) {
|
||||
guard url.scheme == Self.scheme else { return nil }
|
||||
|
||||
// **`host` und nicht `pathComponents[0]`.** Bei `flaro://play/42`
|
||||
// steht „play" im Rechnernamen, nicht im Pfad — der lautet schlicht
|
||||
// „/42". Wer hier den Pfad zerlegt, bekommt die Kennung als Aktion
|
||||
// und wundert sich.
|
||||
let kennung = url.pathComponents.dropFirst().joined(separator: "/")
|
||||
guard !kennung.isEmpty else { return nil }
|
||||
|
||||
switch url.host() {
|
||||
case "play": self = .play(id: kennung)
|
||||
case "item": self = .detail(id: kennung)
|
||||
default: return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
|
||||
/// Was auf dem Fernseher zu sehen ist.
|
||||
///
|
||||
/// **Nur der Zustandswechsel, keine Navigation.** Das ist alles, was von
|
||||
/// `RootView` auf tvOS übrig bleibt: dort sind es 556 Zeilen Seitenleiste,
|
||||
/// Tab-Anpassung, gemessene Statusleistenhöhe und Mini-Player-Übergang, und
|
||||
/// nichts davon gibt es hier. Deshalb eine eigene Datei und kein `#if` in der
|
||||
/// bestehenden — ein `#if` wäre kein Zweig gewesen, sondern ein zweiter Rumpf
|
||||
/// in derselben Datei.
|
||||
struct TVRootView: View {
|
||||
@Environment(FlaroSession.self) private var session
|
||||
@Environment(PlaybackCoordinator.self) private var playback
|
||||
@Environment(QuickPlay.self) private var quickPlay
|
||||
|
||||
/// Wohin ein Link aus dem Regal führt, sobald der Titel geladen ist.
|
||||
@State private var ziel: MediaRoute?
|
||||
|
||||
var body: some View {
|
||||
ZStack {
|
||||
Color.flaroCanvas.ignoresSafeArea()
|
||||
|
||||
switch session.phase {
|
||||
case .launching:
|
||||
ProgressView()
|
||||
|
||||
case .signedOut:
|
||||
TVSignInView()
|
||||
|
||||
case .connecting(let name):
|
||||
verbinden(mit: name)
|
||||
|
||||
case .failed(let meldung):
|
||||
fehlgeschlagen(meldung)
|
||||
|
||||
case .ready:
|
||||
TVShell(deepLinkTarget: $ziel)
|
||||
}
|
||||
}
|
||||
.task { await session.restore() }
|
||||
// **Hier und nicht in der Startseite.** Von einer Kachel, aus dem
|
||||
// Aufmacher und aus der Detailseite wird dasselbe gestartet; läge der
|
||||
// Übergang weiter innen, gäbe es ihn dreimal.
|
||||
//
|
||||
// `fullScreenCover(item:)` gibt es auf tvOS seit 14, und
|
||||
// `PlaybackRequest` ist bereits `Identifiable`.
|
||||
.fullScreenCover(
|
||||
item: Binding(
|
||||
get: { playback.request },
|
||||
set: { if $0 == nil { playback.close() } }
|
||||
)
|
||||
) { request in
|
||||
TVPlayerScreen(request: request)
|
||||
}
|
||||
// Der Weg zurück aus dem Regal über der App.
|
||||
.onOpenURL { adresse in
|
||||
guard let link = TVDeepLink(adresse) else { return }
|
||||
Task { await öffne(link) }
|
||||
}
|
||||
}
|
||||
|
||||
/// Holt den Titel und macht damit, was der Link sagt.
|
||||
///
|
||||
/// **Nachgeschlagen, nicht geraten.** Im Regal steht nur eine Kennung;
|
||||
/// was dahintersteckt — Film, Serie, Folge — weiss erst der Server. Und
|
||||
/// bei einer Serie ist „abspielen" die nächste ungesehene Folge, was
|
||||
/// wiederum `QuickPlay` entscheidet.
|
||||
private func öffne(_ link: TVDeepLink) async {
|
||||
guard let backend = session.backend else { return }
|
||||
let kennung = switch link {
|
||||
case .play(let id), .detail(let id): id
|
||||
}
|
||||
guard let item = try? await backend.item(id: kennung) else { return }
|
||||
|
||||
switch link {
|
||||
case .play:
|
||||
quickPlay.start(item, backend: backend, coordinator: playback)
|
||||
case .detail:
|
||||
ziel = MediaRoute(ratingKey: item.id, title: item.title)
|
||||
}
|
||||
}
|
||||
|
||||
private func verbinden(mit name: String) -> some View {
|
||||
VStack(spacing: FlaroSpacing.regular) {
|
||||
ProgressView()
|
||||
Text(name).font(.flaroRowHeader).foregroundStyle(.white)
|
||||
}
|
||||
}
|
||||
|
||||
private func fehlgeschlagen(_ meldung: String) -> some View {
|
||||
VStack(spacing: FlaroSpacing.regular) {
|
||||
Text(meldung).font(.flaroBody).foregroundStyle(.white)
|
||||
HStack(spacing: FlaroSpacing.regular) {
|
||||
Button("action.retry") { Task { await session.retry() } }
|
||||
Button("action.signOut") { session.signOut() }
|
||||
}
|
||||
}
|
||||
.frame(maxWidth: 900)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
import SwiftUI
|
||||
import FlaroDesign
|
||||
import MediaKit
|
||||
|
||||
/// Start, die Mediatheken und die Suche nebeneinander.
|
||||
///
|
||||
/// **Die Mediatheken als Reiter, nicht als Reihe.** Sie standen unten auf der
|
||||
/// Startseite, und dorthin musste man erst scrollen — an allen Vorschlägen
|
||||
/// vorbei, obwohl „ich will in die Filme" genau der Fall ist, in dem einem
|
||||
/// die Vorschläge egal sind. Oben sind sie einen Wisch entfernt.
|
||||
///
|
||||
/// Damit fällt die Reihe unten weg: zwei Wege zum selben Raster sind auf
|
||||
/// einem Fernseher kein Komfort, sondern eine Frage, welcher der richtige ist.
|
||||
struct TVShell: View {
|
||||
@Binding var deepLinkTarget: MediaRoute?
|
||||
|
||||
@Environment(FlaroSession.self) private var session
|
||||
|
||||
/// Welcher Reiter offen ist.
|
||||
///
|
||||
/// Ausdrücklich gehalten, nicht dem System überlassen: ein Link aus dem
|
||||
/// Regal über der App führt immer zur Startseite, und stünde gerade die
|
||||
/// Suche offen, passierte sichtbar nichts.
|
||||
@State private var reiter = Reiter.start
|
||||
|
||||
private enum Reiter: Hashable {
|
||||
case start
|
||||
case mediathek(String)
|
||||
case suche
|
||||
}
|
||||
|
||||
var body: some View {
|
||||
TabView(selection: $reiter) {
|
||||
Tab(value: Reiter.start) {
|
||||
TVHomeView(deepLinkTarget: $deepLinkTarget)
|
||||
} label: {
|
||||
Text("sidebar.home")
|
||||
}
|
||||
|
||||
ForEach(session.libraries, id: \.id) { mediathek in
|
||||
Tab(value: Reiter.mediathek(mediathek.id)) {
|
||||
// Jeder Reiter bekommt seinen eigenen Stapel. Ein
|
||||
// gemeinsamer hiesse, dass ein Wechsel des Reiters die
|
||||
// Detailseite des vorigen mitnimmt.
|
||||
NavigationStack {
|
||||
TVLibraryView(libraryID: mediathek.id)
|
||||
}
|
||||
} label: {
|
||||
Text(mediathek.title)
|
||||
}
|
||||
}
|
||||
|
||||
// **`role: .search` und nicht ein gewöhnlicher Reiter.** tvOS
|
||||
// setzt ihn dadurch dorthin, wo er in jeder anderen App auch
|
||||
// steht, und gibt ihm die Lupe. Die Stelle bestimmt also Apple,
|
||||
// nicht diese Datei.
|
||||
Tab(value: Reiter.suche, role: .search) {
|
||||
TVSearchView()
|
||||
}
|
||||
}
|
||||
.onChange(of: deepLinkTarget) { _, neu in
|
||||
if neu != nil { reiter = .start }
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user