From 12bfc9e5304164124b92a45268ed3240906b696f Mon Sep 17 00:00:00 2001 From: Scarriffle Date: Tue, 29 Sep 2026 19:55:02 +0200 Subject: [PATCH] =?UTF-8?q?Abspielen=20am=20Fernseher=20=E2=80=94=20mit=20?= =?UTF-8?q?Apples=20Player=20und=20unseren=20Spuren?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Schritt sieben. Wiedergabe, Spurwahl, Titelzeile, „Intro überspringen". **Die schwierige Stelle war die Spurwahl.** Unsere Ton- und Untertitelwahl geht als `audioStreamIndex` an Jellyfin und verlangt bei einem Transcode einen **neuen Stream**. Apples eingebauter Spurwähler zeigt dagegen die Auswahlgruppen des **laufenden** Streams — beim Transcode genau eine. Er ist die richtige Oberfläche für die falsche Liste. Unsere Menüs sitzen deshalb über `transportBarCustomMenuItems` daneben; `customInfoViewControllers` wäre falsch, denn die Tonspur ist ein Bedienelement der Wiedergabe und kein Begleitmaterial. **Der Neuaufbau wird angesagt, nicht erklärt.** Jeder Eintrag, der Sekunden mit schwarzem Bild kostet, trägt das als Untertitel — vorher, nicht hinterher. Wer drückt, sieht den Haken sofort wandern, weil das Menü sich schliesst und darin kein Platz für einen Kreisel ist. Das schwarze Bild deckt eine Überlagerung in `contentOverlayView` zu, die hinter den Bedienelementen liegt und keinen Fokus nimmt — `customOverlayViewController` täte beides nicht und machte die Fernbedienung währenddessen tot. Und solange umgebaut wird, sind alle Einträge gesperrt: sonst räumt `restart()` eine Engine ab, die eine andere gerade baut. **Die Regel dahinter ist jetzt prüfbar.** „Wann kostet ein Spurwechsel einen Neuaufbau" lag bisher mitten im Vollzug von `selectAudioStream` und liess sich nur an einem echten Server mit mehreren Tonspuren auslösen. Als `TrackMenu` steht sie neben den übrigen Entscheidungsregeln, mit sieben Tests — darunter der Fall, auf den der Kommentar dort seit jeher hinweist: stimmt die Spurzahl nicht überein, ist die Zuordnung über die Reihenfolge falsch, und es muss neu aufgebaut werden. **Zwei stille Fehler nebenbei.** Die Tonsitzung stand hinter `#if os(iOS)` und wäre auf tvOS nie gesetzt worden — verfügbar ist sie dort seit 9.0, man hätte es nur daran gemerkt, dass sich die Wiedergabe gegen anderen Ton nicht durchsetzt. Und `PlayerModel.downloads` ist jetzt optional statt eines leeren Koordinators: ein leerer bräuchte einen `ModelContainer`, und der ist das Einzige, wofür diese App SwiftData benutzt. **Belegt statt vermutet.** Im Simulator lief die Wiedergabe gegen die Attrappe, und die Titelzeile zeigte „Unbekannt". Statt an AVKit zu drehen, hat ein Protokolleintrag die Frage beantwortet: `externalMetadata` wird gesetzt, der Wert stimmt, und „Unbekannt" ist wörtlich das, was die Attrappe für unbekannte Kennungen liefert. Geblieben ist davon nur die Erkenntnis, dass die Beschriftung auf das Item warten muss — beim Austausch des Players gibt es noch keines. Co-Authored-By: Claude Opus 5 --- .gitignore | 4 + Flixy.xcworkspace/README.md | 19 ++ Flixy.xcworkspace/contents.xcworkspacedata | 4 + Flixy/Resources/Localizable.xcstrings | 35 ++- Flixy/Views/Player/PlayerModel.swift | 40 +++- Flixy/Views/Player/VideoSurface.swift | 6 +- FlixyTV/Views/Library/TVLibraryView.swift | 11 +- .../Views/Player/TVPlayerCoordinator.swift | 199 ++++++++++++++++++ FlixyTV/Views/Player/TVPlayerHost.swift | 79 +++++++ FlixyTV/Views/Player/TVPlayerScreen.swift | 70 ++++++ FlixyTV/Views/Player/TVTrackMenuBuilder.swift | 85 ++++++++ FlixyTV/Views/TVRootView.swift | 15 ++ .../FlixyPlayback/Decision/TrackMenu.swift | 99 +++++++++ .../FlixyPlayback/Engine/AVPlayerEngine.swift | 12 +- .../FlixyPlaybackTests/TrackMenuTests.swift | 115 ++++++++++ Packages/FlixyVLC/Package.resolved | 2 +- project.yml | 27 ++- 17 files changed, 799 insertions(+), 23 deletions(-) create mode 100644 Flixy.xcworkspace/README.md create mode 100644 Flixy.xcworkspace/contents.xcworkspacedata create mode 100644 FlixyTV/Views/Player/TVPlayerCoordinator.swift create mode 100644 FlixyTV/Views/Player/TVPlayerHost.swift create mode 100644 FlixyTV/Views/Player/TVPlayerScreen.swift create mode 100644 FlixyTV/Views/Player/TVTrackMenuBuilder.swift create mode 100644 Packages/FlixyKit/Sources/FlixyPlayback/Decision/TrackMenu.swift create mode 100644 Packages/FlixyKit/Tests/FlixyPlaybackTests/TrackMenuTests.swift diff --git a/.gitignore b/.gitignore index 6f82855..456abb2 100644 --- a/.gitignore +++ b/.gitignore @@ -8,4 +8,8 @@ xcuserdata/ # Von XcodeGen aus project.yml erzeugt — nicht eingecheckt, damit es keine # Konflikte in der pbxproj gibt. Nach dem Klonen: xcodegen generate +# +# Flixy.xcworkspace daneben ist dagegen von Hand geschrieben und gehört dazu: +# er verweist nur auf das Projekt und überlebt jedes Neuerzeugen. Warum das +# nötig ist, steht in Flixy.xcworkspace/README.md. Flixy.xcodeproj/ diff --git a/Flixy.xcworkspace/README.md b/Flixy.xcworkspace/README.md new file mode 100644 index 0000000..fe3028d --- /dev/null +++ b/Flixy.xcworkspace/README.md @@ -0,0 +1,19 @@ +# Diesen Arbeitsbereich öffnen, nicht das Projekt + +`Flixy.xcodeproj` wird von XcodeGen aus `project.yml` erzeugt — und dabei +**ersetzt**, nicht bearbeitet: jede Datei darin bekommt einen neuen Inode, +auch die, deren Inhalt gleich bleibt. Hat Xcode den Arbeitsbereich **im** +Projekt offen (`Flixy.xcodeproj/project.xcworkspace`), meldet es danach + +> The workspace file … has disappeared. Do you want to re-save the container, +> or close it? + +und zwar nach jedem einzelnen Lauf. + +Dieser Arbeitsbereich liegt **daneben** statt darin. Er verweist nur auf das +Projekt und wird von XcodeGen nie angefasst — Xcode lädt das Projekt danach +still nach, ohne zu fragen. + +**Falls der Dialog doch einmal kommt: „Close", nie „Re-save".** Re-save +schreibt Xcodes Kopie aus dem Arbeitsspeicher über das frisch erzeugte +Projekt; alle Änderungen aus `project.yml` wären damit wieder weg. diff --git a/Flixy.xcworkspace/contents.xcworkspacedata b/Flixy.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..ae372ab --- /dev/null +++ b/Flixy.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,4 @@ + + + + diff --git a/Flixy/Resources/Localizable.xcstrings b/Flixy/Resources/Localizable.xcstrings index 6df1172..cd41544 100644 --- a/Flixy/Resources/Localizable.xcstrings +++ b/Flixy/Resources/Localizable.xcstrings @@ -1975,7 +1975,6 @@ } }, "home.empty.title": { - "extractionState": "stale", "localizations": { "de": { "stringUnit": { @@ -3841,6 +3840,40 @@ } } }, + "player.rebuilding": { + "extractionState": "manual", + "localizations": { + "de": { + "stringUnit": { + "state": "translated", + "value": "Stream wird neu aufgebaut …" + } + }, + "en": { + "stringUnit": { + "state": "translated", + "value": "Rebuilding stream …" + } + } + } + }, + "player.rebuilds": { + "extractionState": "manual", + "localizations": { + "de": { + "stringUnit": { + "state": "translated", + "value": "Stream wird neu aufgebaut" + } + }, + "en": { + "stringUnit": { + "state": "translated", + "value": "Stream will be rebuilt" + } + } + } + }, "player.relayWarning": { "comment": "Warnung im Player, wenn die Verbindung über die Plex-Vermittlung läuft", "extractionState": "stale", diff --git a/Flixy/Views/Player/PlayerModel.swift b/Flixy/Views/Player/PlayerModel.swift index 941a540..a15eeb6 100644 --- a/Flixy/Views/Player/PlayerModel.swift +++ b/Flixy/Views/Player/PlayerModel.swift @@ -4,7 +4,9 @@ import MediaKit import Observation import FlixyDownloads import FlixyPlayback -#if canImport(FlixyVLC) +// Siehe `PlaybackSettings`: `!os(tvOS)` muss dazu, sonst bricht der +// Abhängigkeits-Sucher an VLCKit ab, das für dieses Ziel gar nicht gebaut wird. +#if canImport(FlixyVLC) && !os(tvOS) import FlixyVLC #endif import PlexKit @@ -154,6 +156,17 @@ final class PlayerModel { /// bei jedem Wechsel eine neue `AVPlayerLayer`, und das Bild setzte neu an. let surface = PlayerLayerView() + /// Der Systemplayer der laufenden Engine — oder nichts, solange keine läuft. + /// + /// **AVFoundation, nicht UIKit.** Das Modell weiss weiterhin nicht, wer + /// das Bild zeichnet: auf dem Telefon hängt die gehaltene `AVPlayerLayer` + /// daran, auf dem Fernseher ein `AVPlayerViewController`. Beide holen sich + /// hier dasselbe ab. + /// + /// `nil` bei VLC — kein Sonderfall, sondern dieselbe Auskunft, die + /// `VideoSurface` heute schon auswertet. + var systemPlayer: AVPlayer? { (engine as? AVPlayerEngine)?.player } + /// Wie das Bild in die Fläche gelegt wird. /// /// **Im Modell und nicht in der Ansicht**, aus demselben Grund wie die @@ -201,7 +214,14 @@ final class PlayerModel { /// gibt, steht hier kein Plex-Server mehr, sondern wer auch immer /// Live-TV kann. private let liveTV: (any LiveTVBackend)? - private let downloads: DownloadCoordinator + /// Der Bestand auf der Platte — auf dem Fernseher gibt es keinen. + /// + /// **Optional und nicht ein leerer Koordinator.** Ein leerer bräuchte + /// einen `ModelContainer`, und der ist das Einzige, wofür diese App + /// SwiftData überhaupt benutzt; auf tvOS bliebe damit beides weg. Ein + /// Protokoll mit Null-Objekt wäre die dritte Möglichkeit und die + /// schlechteste: ein Typ mehr, um drei `if let` zu vermeiden. + private let downloads: DownloadCoordinator? private let diagnostics: PlaybackDiagnostics private let policy: PlaybackPolicy private let settings: PlaybackSettings @@ -454,7 +474,7 @@ final class PlayerModel { request: PlaybackRequest, backend: (any MediaBackend)?, liveTV: (any LiveTVBackend)?, - downloads: DownloadCoordinator, + downloads: DownloadCoordinator? = nil, diagnostics: PlaybackDiagnostics, policy: PlaybackPolicy, settings: PlaybackSettings, @@ -491,7 +511,7 @@ final class PlayerModel { // Die lokale Datei hat immer Vorrang. Sie ist schneller, kostet kein // Datenvolumen und funktioniert auch dann, wenn der Server gerade // nicht erreichbar ist — der eigentliche Sinn des Herunterladens. - if let localURL = downloads.localURL(forRatingKey: request.ratingKey) { + if let downloads, let localURL = downloads.localURL(forRatingKey: request.ratingKey) { await startLocal(url: localURL) return } @@ -713,7 +733,7 @@ final class PlayerModel { } private func startLocal(url: URL) async { - let offline = downloads.offlineMedia(forRatingKey: request.ratingKey) + let offline = downloads?.offlineMedia(forRatingKey: request.ratingKey) ?? nil let decision = PlaybackDecider().decide( // Früher standen hier **erfundene** Plex-Modelle: eine Media mit @@ -1746,7 +1766,7 @@ final class PlayerModel { } private func makeEngine(for decision: PlaybackDecision) -> any VideoPlayerEngine { - #if canImport(FlixyVLC) + #if canImport(FlixyVLC) && !os(tvOS) switch decision.engine { case .vlc: VLCPlayerEngine() // Auch der Transcode-Weg endet beim Systemplayer: er liefert HLS, und @@ -1842,9 +1862,11 @@ final class PlayerModel { // Grundlage fürs automatische Löschen nach dem Ansehen — // und der Auslöser fürs Nachladen: der Vorrat ist jetzt // um eine Folge kleiner. - downloads.markWatched(ratingKey: request.ratingKey) - Task { [backend, downloads] in - await DownloadRefiller(backend: backend, coordinator: downloads).refill() + if let downloads { + downloads.markWatched(ratingKey: request.ratingKey) + Task { [backend, downloads] in + await DownloadRefiller(backend: backend, coordinator: downloads).refill() + } } case .tracksResolved(let audio, let subtitle): audioTracks = audio diff --git a/Flixy/Views/Player/VideoSurface.swift b/Flixy/Views/Player/VideoSurface.swift index 97e5098..a6107ba 100644 --- a/Flixy/Views/Player/VideoSurface.swift +++ b/Flixy/Views/Player/VideoSurface.swift @@ -6,7 +6,9 @@ import UIKit #else import AppKit #endif -#if canImport(FlixyVLC) +// Siehe `PlaybackSettings`: `!os(tvOS)` muss dazu, sonst bricht der +// Abhängigkeits-Sucher an VLCKit ab, das für dieses Ziel gar nicht gebaut wird. +#if canImport(FlixyVLC) && !os(tvOS) import FlixyVLC #endif @@ -59,7 +61,7 @@ struct VideoSurface: View { var bottomInset: CGFloat = 0 var body: some View { - #if canImport(FlixyVLC) + #if canImport(FlixyVLC) && !os(tvOS) if let vlcEngine = engine as? VLCPlayerEngine { SurfaceContainer(view: vlcEngine.videoView, isActive: isActive, bottomInset: bottomInset) } else if engine is AVPlayerEngine { diff --git a/FlixyTV/Views/Library/TVLibraryView.swift b/FlixyTV/Views/Library/TVLibraryView.swift index 654bea8..f30385c 100644 --- a/FlixyTV/Views/Library/TVLibraryView.swift +++ b/FlixyTV/Views/Library/TVLibraryView.swift @@ -13,6 +13,8 @@ struct TVLibraryView: View { let libraryID: String @Environment(FlixySession.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? @@ -78,10 +80,17 @@ struct TVLibraryView: View { ), progress: item.watchProgress ) { - // In Fassung eins führt die Karte zur Detailseite. + // **Ü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 diff --git a/FlixyTV/Views/Player/TVPlayerCoordinator.swift b/FlixyTV/Views/Player/TVPlayerCoordinator.swift new file mode 100644 index 0000000..77a611f --- /dev/null +++ b/FlixyTV/Views/Player/TVPlayerCoordinator.swift @@ -0,0 +1,199 @@ +import AVKit +import UIKit +import FlixyPlayback +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 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? + + init(onDismiss: @escaping () -> Void) { + 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 + + // **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, + 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 } + } +} diff --git a/FlixyTV/Views/Player/TVPlayerHost.swift b/FlixyTV/Views/Player/TVPlayerHost.swift new file mode 100644 index 0000000..22b86cb --- /dev/null +++ b/FlixyTV/Views/Player/TVPlayerHost.swift @@ -0,0 +1,79 @@ +import AVKit +import SwiftUI +import FlixyPlayback +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 + 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(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? + + /// `@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, offLabel: String) { + 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") + } + } +} diff --git a/FlixyTV/Views/Player/TVPlayerScreen.swift b/FlixyTV/Views/Player/TVPlayerScreen.swift new file mode 100644 index 0000000..6c874cc --- /dev/null +++ b/FlixyTV/Views/Player/TVPlayerScreen.swift @@ -0,0 +1,70 @@ +import SwiftUI +import FlixyDesign +import FlixyPlayback +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(FlixySession.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, offLabel: String(localized: "player.subtitlesOff")), + onDismiss: { playback.close() } + ) + .ignoresSafeArea() + } else { + ProgressView() + } + } + .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() } } + } +} diff --git a/FlixyTV/Views/Player/TVTrackMenuBuilder.swift b/FlixyTV/Views/Player/TVTrackMenuBuilder.swift new file mode 100644 index 0000000..513a2e5 --- /dev/null +++ b/FlixyTV/Views/Player/TVTrackMenuBuilder.swift @@ -0,0 +1,85 @@ +import AVKit +import UIKit +import FlixyPlayback + +/// 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 { + static func items( + for aufnahme: TVPlayerSnapshot, + onAudio: @escaping (Int?) -> Void, + onSubtitle: @escaping (Int?) -> Void + ) -> [UIMenuElement] { + var menüs: [UIMenuElement] = [] + if aufnahme.audio.count > 1 { + menüs.append(menü( + titel: String(localized: "player.audioTracks"), + symbol: "waveform", + einträge: aufnahme.audio, + gesperrt: aufnahme.isRebuilding, + aktion: onAudio + )) + } + if aufnahme.subtitles.count > 1 { + menüs.append(menü( + titel: String(localized: "player.subtitleTracks"), + symbol: "captions.bubble", + einträge: aufnahme.subtitles, + gesperrt: aufnahme.isRebuilding, + aktion: onSubtitle + )) + } + return menüs + } + + private static func menü( + titel: String, + symbol: String, + einträge: [TrackMenu.Entry], + gesperrt: Bool, + aktion: @escaping (Int?) -> Void + ) -> UIMenu { + UIMenu( + title: titel, + image: UIImage(systemName: symbol), + options: [.singleSelection], + children: einträge.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) + } + } + ) + } + + /// „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() }] + } +} diff --git a/FlixyTV/Views/TVRootView.swift b/FlixyTV/Views/TVRootView.swift index 25ac5e8..700abb9 100644 --- a/FlixyTV/Views/TVRootView.swift +++ b/FlixyTV/Views/TVRootView.swift @@ -11,6 +11,7 @@ import FlixyDesign /// in derselben Datei. struct TVRootView: View { @Environment(FlixySession.self) private var session + @Environment(PlaybackCoordinator.self) private var playback var body: some View { ZStack { @@ -38,6 +39,20 @@ struct TVRootView: View { } } .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) + } } private func verbinden(mit name: String) -> some View { diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/TrackMenu.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/TrackMenu.swift new file mode 100644 index 0000000..68a9382 --- /dev/null +++ b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/TrackMenu.swift @@ -0,0 +1,99 @@ +import Foundation +import MediaKit + +/// Was in einem Spurenmenü steht — und was ein Umschalten kostet. +/// +/// **Warum es diesen Typ gibt.** Auf dem Fernseher sitzt die Spurwahl in +/// Apples Transportleiste, und die nimmt `UIMenu`-Einträge entgegen. Die +/// Abbildung von Spuren auf Einträge hat mit UIKit aber nichts zu tun: sie +/// beantwortet, welche Spuren zur Wahl stehen, welche gerade gilt, und — das +/// ist der Teil, der sonst nirgends steht — **ob das Umschalten Sekunden mit +/// schwarzem Bild kostet**. +/// +/// Diese Regel lag bisher nur mitten im Vollzug von +/// `PlayerModel.selectAudioStream` und war damit weder ablesbar noch prüfbar: +/// auslösen lässt sie sich nur an einem echten Server mit einer Datei, die +/// mehrere Tonspuren hat. Hier steht sie als Auskunft — und die Oberfläche +/// kann sie **vorher** anzeigen, statt den Nutzer hinterher vor ein schwarzes +/// Bild zu setzen. +/// +/// Liegt neben `AudioTrackChooser` und `DowngradeRule`, weil es dasselbe ist: +/// eine Regel über die Wiedergabe, ohne Oberfläche und ohne Netz. +public enum TrackMenu { + public struct Entry: Equatable, Sendable, Identifiable { + /// Der Index der Spur beim Server. `nil` heisst „Aus". + public let id: Int? + public let title: String + public let isSelected: Bool + /// Ob das Umschalten den Stream neu aufbaut. + public let rebuilds: Bool + + public init(id: Int?, title: String, isSelected: Bool, rebuilds: Bool) { + self.id = id + self.title = title + self.isSelected = isSelected + self.rebuilds = rebuilds + } + } + + /// Die Tonspuren **der Datei**, nicht die des Players. + /// + /// Rechnet der Server um, kennt der Player genau eine Spur — die, für die + /// er sich entschieden hat. Zur Wahl steht, was in der Datei liegt. + /// + /// - Parameter playerTrackCount: Wie viele Tonspuren der Player meldet. + /// Weicht die Zahl ab, stimmt die Zuordnung über die Reihenfolge nicht, + /// und es muss neu aufgebaut werden — lieber eine Unterbrechung als die + /// falsche Sprache. + public static func audio( + from streams: [MediaStream], + selected: MediaStream?, + isDirectPlay: Bool, + playerTrackCount: Int + ) -> [Entry] { + let billig = isDirectPlay && playerTrackCount == streams.count + return streams.enumerated().map { stelle, stream in + Entry( + id: stream.index ?? stelle, + title: stream.name, + isSelected: stream == selected, + rebuilds: !billig + ) + } + } + + /// Die Untertitelspuren, mit „Aus" an erster Stelle. + /// + /// - Parameter offLabel: Wie „Aus" in der Sprache des Nutzers heisst. + /// Als Argument, weil dieses Paket keinen Textkatalog der App kennt. + /// - Parameter playerTrackLanguages: Die Sprachkürzel der Spuren, die der + /// Player wirklich hat. Nur was sich darin abbilden lässt, schaltet ohne + /// Neuaufbau um — sonst stünde der falsche Untertitel im Bild, und das + /// ist schlimmer als eine kurze Unterbrechung. + public static func subtitles( + from streams: [MediaStream], + selected: MediaStream?, + isDirectPlay: Bool, + playerTrackLanguages: [String?] = [], + offLabel: String + ) -> [Entry] { + // „Aus" kostet nie einen Neuaufbau: abschalten kann der Player immer, + // auch eine Spur, die er nie hatte. + var einträge = [ + Entry(id: nil, title: offLabel, isSelected: selected == nil, rebuilds: false) + ] + + einträge += streams.enumerated().map { stelle, stream in + let abbildbar = isDirectPlay && playerTrackLanguages.contains { + LanguageCode.matches(stream.languageCode, $0) + } + return Entry( + id: stream.index ?? stelle, + title: stream.name, + isSelected: stream == selected, + rebuilds: !abbildbar + ) + } + return einträge + } +} diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift index c836328..cc12c01 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift +++ b/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift @@ -586,12 +586,18 @@ public final class AVPlayerEngine: VideoPlayerEngine { /// Die Tonsitzung des Systems. /// -/// Nur auf iOS vorhanden. Gekapselt statt an drei Stellen mit `#if` versehen — +/// Auf iOS **und tvOS**. Gekapselt statt an drei Stellen mit `#if` versehen — /// macOS steht in diesem Paket ohnehin nur, damit die Logik-Tests ohne /// Simulator laufen. +/// +/// **tvOS stand hier lange nicht**, und das war ein stiller Fehler: die +/// Kategorie wäre dort verfügbar (`AVAudioSessionCategoryPlayback` ist +/// `tvos(9.0)`), wurde aber nie gesetzt. Man hätte es nicht am Übersetzer +/// gemerkt, sondern erst daran, dass sich die Wiedergabe gegen anderen Ton +/// nicht durchsetzt. enum AudioSession { static func activate() { - #if os(iOS) + #if os(iOS) || os(tvOS) // Ohne diese Kategorie schweigt die Wiedergabe, sobald der // Stummschalter am Gerät umgelegt ist — und Bild-in-Bild gäbe es gar // nicht. @@ -601,7 +607,7 @@ enum AudioSession { } static func deactivate() { - #if os(iOS) + #if os(iOS) || os(tvOS) // `notifyOthersOnDeactivation` lässt die Musik-App wieder anlaufen, // die vor dem Film gespielt hat. try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation) diff --git a/Packages/FlixyKit/Tests/FlixyPlaybackTests/TrackMenuTests.swift b/Packages/FlixyKit/Tests/FlixyPlaybackTests/TrackMenuTests.swift new file mode 100644 index 0000000..b96e363 --- /dev/null +++ b/Packages/FlixyKit/Tests/FlixyPlaybackTests/TrackMenuTests.swift @@ -0,0 +1,115 @@ +import Testing +import MediaKit +@testable import FlixyPlayback + +@Suite("Was im Spurenmenü steht") +struct TrackMenuTests { + + private func spur( + _ id: String, + kind: MediaStream.Kind = .audio, + sprache: String? = "Deutsch", + code: String? = "deu", + name: String? = nil, + codec: String? = "AC3" + ) -> MediaStream { + MediaStream( + id: id, kind: kind, codec: codec, language: sprache, languageCode: code, + displayTitle: name, channels: nil, isSelected: false, isForced: false, + title: nil, isDefault: false, isHearingImpaired: false, isOriginal: false + ) + } + + // MARK: - Wann es einen Neuaufbau kostet + + /// **Der Fall, der bisher nirgends stand.** Rechnet der Server um, liegt + /// im Stream genau eine Tonspur — jede andere Wahl verlangt eine neue + /// Bestellung und damit Sekunden mit schwarzem Bild. + @Test("Beim Umrechnen kostet jede Wahl einen Neuaufbau") + func transcodeAlwaysRebuilds() { + let einträge = TrackMenu.audio( + from: [spur("1"), spur("2")], + selected: nil, isDirectPlay: false, playerTrackCount: 1 + ) + #expect(einträge.allSatisfy { $0.rebuilds }) + } + + @Test("Unverändert gespielt und gleiche Anzahl: kein Neuaufbau") + func directPlayMatchingCountIsCheap() { + let einträge = TrackMenu.audio( + from: [spur("1"), spur("2")], + selected: nil, isDirectPlay: true, playerTrackCount: 2 + ) + #expect(einträge.allSatisfy { !$0.rebuilds }) + } + + /// **Die Regel aus `PlayerModel`, zum ersten Mal prüfbar.** Die Zuordnung + /// geht über die Reihenfolge; stimmt die Anzahl nicht, ist die Annahme + /// falsch, und es wäre die falsche Sprache statt einer Unterbrechung. + /// Auslösen liess sich das bisher nur an einem echten Server. + @Test("Abweichende Anzahl heißt Neuaufbau, auch unverändert gespielt") + func directPlayMismatchRebuilds() { + let einträge = TrackMenu.audio( + from: [spur("1"), spur("2"), spur("3")], + selected: nil, isDirectPlay: true, playerTrackCount: 2 + ) + #expect(einträge.allSatisfy { $0.rebuilds }) + } + + // MARK: - Untertitel + + @Test("„Aus“ steht vorn und kostet nie einen Neuaufbau") + func offComesFirstAndIsFree() { + let einträge = TrackMenu.subtitles( + from: [spur("1", kind: .subtitle)], + selected: nil, isDirectPlay: false, offLabel: "Aus" + ) + #expect(einträge.first?.id == nil) + #expect(einträge.first?.title == "Aus") + #expect(einträge.first?.isSelected == true) + #expect(einträge.first?.rebuilds == false) + } + + /// Nur was der Player wirklich hat, lässt sich ohne Neuaufbau schalten. + @Test("Eine Untertitelspur, die der Player nicht hat, kostet einen Neuaufbau") + func unmappableSubtitleRebuilds() { + let deutsch = spur("1", kind: .subtitle, sprache: "Deutsch", code: "deu") + let englisch = spur("2", kind: .subtitle, sprache: "English", code: "eng") + let einträge = TrackMenu.subtitles( + from: [deutsch, englisch], + selected: nil, isDirectPlay: true, + playerTrackLanguages: ["de"], offLabel: "Aus" + ) + // „deu" und „de" sind dieselbe Sprache — das entscheidet LanguageCode. + #expect(einträge[1].rebuilds == false) + #expect(einträge[2].rebuilds == true) + } + + // MARK: - Beschriftung + + @Test("Der Name des Servers gewinnt, sonst Sprache und Codec") + func fallsBackToLanguageAndCodec() { + let mitNamen = spur("1", name: "Deutsch (AC3 5.1)") + let ohneNamen = spur("2", sprache: "English", codec: "eac3") + let einträge = TrackMenu.audio( + from: [mitNamen, ohneNamen], + selected: mitNamen, isDirectPlay: true, playerTrackCount: 2 + ) + #expect(einträge[0].title == "Deutsch (AC3 5.1)") + #expect(einträge[1].title == "English · EAC3") + #expect(einträge[0].isSelected) + #expect(!einträge[1].isSelected) + } + + /// Ohne alles bleibt ein Strich — besser als eine leere Zeile, bei der + /// niemand weiss, ob sie anklickbar ist. + @Test("Ohne Sprache und Codec bleibt ein Strich") + func namelessStreamStillHasALabel() { + let leer = spur("7", sprache: nil, code: nil, codec: nil) + let einträge = TrackMenu.audio( + from: [leer], selected: nil, isDirectPlay: true, playerTrackCount: 1 + ) + #expect(einträge[0].title == "—") + #expect(einträge[0].id == 7) + } +} diff --git a/Packages/FlixyVLC/Package.resolved b/Packages/FlixyVLC/Package.resolved index c362a13..613e4ba 100644 --- a/Packages/FlixyVLC/Package.resolved +++ b/Packages/FlixyVLC/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "b573b58f837dec84b5981e792f7548e0bb126412c181987af9b265133a652e02", + "originHash" : "8b778ccd4dce9d26be9db57d4587b19c4a4366fcdaf8b6017e1df36fa1eddb4f", "pins" : [ { "identity" : "vlckit", diff --git a/project.yml b/project.yml index a09d1b7..0cc7f17 100644 --- a/project.yml +++ b/project.yml @@ -175,16 +175,26 @@ targets: excludes: # Ein Fernseher dreht sich nicht. - "OrientationLock.swift" - # Downloads gibt es hier nicht. - - "DownloadService.swift" - - "DownloadRefiller.swift" - # Kommt mit dem Player in Schritt sieben. Solange es ihn nicht gibt, - # hätte die Anmeldung beim System nichts anzumelden. - - "NowPlaying.swift" + # Heruntergeladen wird auf dem Fernseher nichts. + # + # `DownloadRefiller.swift` und `DownloadService.swift` kommen + # trotzdem mit: `PlayerModel` nennt den Nachfüller in einem Zweig, + # der auf tvOS nie läuft (`downloads` ist dort `nil`), und der + # Nachfüller wiederum den Dienst. Sie auszuschliessen hiesse, eine + # Plattformfrage mitten in zweitausend Zeilen Wiedergabelogik zu + # tragen — teurer als zwei Dateien mitzuübersetzen, die niemand + # aufruft. Beide sind reine Übersetzer ohne UIKit. # Reines Modell trotz des Ordnernamens: LoadState, ErrorText und # MediaRoute liegen zusammen in einer Datei. - path: Flixy/Views/LoadState.swift type: file + # Der Player. **Ohne PlayerView** — die zeichnet auf iOS das Bild und + # alle Bedienelemente selbst; auf dem Fernseher macht das Apples + # AVPlayerViewController. Das Modell darunter ist dasselbe. + - path: Flixy/Views/Player/PlayerModel.swift + type: file + - path: Flixy/Views/Player/VideoSurface.swift + type: file - path: Flixy/Branding.swift type: file # Die Texte. Dieselben Schlüssel, dieselben Übersetzungen. @@ -206,6 +216,11 @@ targets: product: FlixyDesign - package: FlixyKit product: FlixyPlayback + # Nur damit `PlayerModel` den Typ nennen darf. Angelegt wird nie einer: + # FlixyTVApp reicht `nil` durch, und damit gibt es auf tvOS auch keinen + # ModelContainer und kein SwiftData. + - package: FlixyKit + product: FlixyDownloads settings: base: PRODUCT_BUNDLE_IDENTIFIER: com.scarriffleservices.flixy.tv