ScarriffleandClaude Opus 5
f296d7ae1a
Deine Frage war die richtige. Eine native Mac-App sah an zwei Dutzend Stellen
anders aus, weil AppKit dieselben Dinge anders misst: Schriftgrößen,
Spaltenbreiten, Formularstil. Jede davon habe ich heute einzeln nachgezogen —
und wäre bei der nächsten Ansicht wieder von vorn angefangen.
Mac Catalyst nimmt die iPad-Oberfläche unverändert. Nicht nachgebaut, sondern
dieselbe: gleiche Schrift, gleiche Leiste, gleiche Abstände, und zwar auch in
allem, was noch kommt.
**Ich habe „MKV geht dann nie" gesagt. Das war falsch.** Ohne VLC spielen sie
nicht *unverändert* — der Server rechnet sie um, und das kann er längst. Nur
war die App darauf nicht vorbereitet: die Entscheidung hätte weiterhin VLC
gewählt, den es dort nicht gibt, und das Bild wäre schwarz geblieben.
`PlaybackSettings.hasFallbackEngine` fragt jetzt, ob es den zweiten Spieler auf
dieser Plattform überhaupt gibt. Wo nicht, übernimmt der Server. Das kostet ihn
Rechenzeit und sieht man nicht.
Unverändert abspielen kommt später zurück — dafür braucht es einen Decoder mit
einem Catalyst-Teil. VLCKits Binärpaket hat keinen:
ios-arm64 ios-simulator macos-arm64_x86_64 tvos watchos xros
Drei Stellen mussten Catalyst ausdrücklich ausnehmen: dort gilt `os(iOS)`, aber
ActivityKit gibt es nicht — die Typen sind da und jeder Aufruf ist als nicht
verfügbar markiert. Das ist die Art Falle, die erst der Compiler findet.
Die Anpassungen von vorhin bleiben stehen, obwohl Catalyst sie nicht braucht:
FlixyDesign baut für macOS mit, und `swift test` läuft dort. Sie kosten nichts
und halten den Weg zu einer nativen Mac-App offen, falls VLC ihn eines Tages
nötig macht.
263 Tests grün, iOS baut unverändert.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
80 lines
3.2 KiB
Swift
80 lines
3.2 KiB
Swift
import Foundation
|
|
|
|
// Catalyst ausdrücklich ausgenommen: dort gilt `os(iOS)`, aber ActivityKit
|
|
// gibt es nicht — die Typen sind zwar da und jeder Aufruf ist als nicht
|
|
// verfügbar markiert.
|
|
#if os(iOS) && !targetEnvironment(macCatalyst)
|
|
// `@preconcurrency`, weil `Activity` und `ActivityContent` keine
|
|
// Sendable-Zusage tragen. Beide bleiben hier ohnehin auf dem Hauptakteur —
|
|
// die Klasse ist darauf festgelegt, und ActivityKit erwartet seine Aufrufe
|
|
// von dort. Ohne diese Zeile lehnt Swift 6 jeden Aufruf ab.
|
|
@preconcurrency import ActivityKit
|
|
|
|
/// Zeigt den Download-Fortschritt im Sperrbildschirm.
|
|
///
|
|
/// Getrennt vom Koordinator, weil Live Activities eine Reihe eigener Fallen
|
|
/// haben — sie können vom Nutzer abgeschaltet sein, ihre Zahl ist begrenzt,
|
|
/// und eine nicht beendete Activity bleibt stundenlang stehen. Der Koordinator
|
|
/// meldet nur „das läuft gerade"; was daraus wird, entscheidet sich hier.
|
|
@MainActor
|
|
public final class DownloadActivityPresenter {
|
|
private var activity: Activity<DownloadActivityAttributes>?
|
|
/// Wann zuletzt aktualisiert wurde.
|
|
///
|
|
/// ActivityKit drosselt häufige Aktualisierungen und verwirft sie
|
|
/// irgendwann kommentarlos. Der Fortschritt kommt mehrmals je Sekunde —
|
|
/// ungebremst weitergereicht bliebe die Anzeige irgendwann stehen.
|
|
private var lastUpdate = Date.distantPast
|
|
private let minimumInterval: TimeInterval = 1.5
|
|
|
|
public init() {}
|
|
|
|
/// Bringt die Anzeige auf den neuesten Stand.
|
|
///
|
|
/// `nil` beendet sie — das ist der Fall, wenn nichts mehr läuft.
|
|
/// `async`, nicht `Task { … }` im Inneren: `Activity` und
|
|
/// `ActivityContent` sind nicht `Sendable`, und eine Aufgabe würde sie über
|
|
/// die Isolationsgrenze schicken. So bleibt alles auf dem Hauptakteur.
|
|
public func update(with state: DownloadActivityAttributes.ContentState?) async {
|
|
guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
|
|
|
|
guard let state else {
|
|
await end()
|
|
return
|
|
}
|
|
|
|
if let activity {
|
|
guard Date().timeIntervalSince(lastUpdate) >= minimumInterval else { return }
|
|
lastUpdate = Date()
|
|
await activity.update(ActivityContent(state: state, staleDate: nil))
|
|
} else {
|
|
start(with: state)
|
|
}
|
|
}
|
|
|
|
private func start(with state: DownloadActivityAttributes.ContentState) {
|
|
do {
|
|
activity = try Activity.request(
|
|
attributes: DownloadActivityAttributes(),
|
|
content: ActivityContent(state: state, staleDate: nil)
|
|
)
|
|
lastUpdate = Date()
|
|
} catch {
|
|
// Scheitert meist, weil die Höchstzahl gleichzeitiger Activities
|
|
// erreicht ist. Kein Grund, den Download anzuhalten — die Anzeige
|
|
// ist Beiwerk.
|
|
activity = nil
|
|
}
|
|
}
|
|
|
|
/// Beendet die Anzeige.
|
|
public func end() async {
|
|
guard let activity else { return }
|
|
self.activity = nil
|
|
// `.immediate`: eine Download-Anzeige, die nach dem letzten Byte noch
|
|
// eine Viertelstunde im Sperrbildschirm klebt, ist Müll.
|
|
await activity.end(nil, dismissalPolicy: .immediate)
|
|
}
|
|
}
|
|
#endif
|