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,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() }]
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user