Phase 1: Anmeldung, Bibliothek, Detailseiten, Hybrid-Player
Die Datenschicht: - plex.tv-Anmeldung über das PIN-Verfahren, Token im Schlüsselbund - Serversuche und Verbindungsauswahl nach Rang (lokal vor direkt vor Vermittlung), mit Abgleich der Server-Kennung gegen veraltete plex.direct-Adressen - PlexServer als einzige Stelle, an der die App Endpunkte kennt: Mediatheken, Hubs, seitenweises Blättern mit Filtern, Metadaten, Staffeln/Folgen, Suche Die Oberfläche: - Startseite mit Aufmacher und den Reihen vom Server - Mediathek als Raster oder Liste, mit Filter- und Sortierblatt - Detailseiten für Filme, Folgen, Serien und Staffeln inkl. Besetzung, Fassungsauswahl und aufklappbaren technischen Angaben - Suche mit gemerkten Anfragen - Vollbildplayer mit eigenem Chrome Der Player: - AVPlayerEngine und VLCPlayerEngine hinter einem gemeinsamen Protokoll - VLCKit liegt in einem eigenen Package (FlixyVLC), damit `swift test` in FlixyKit nicht das 920-MB-Binärpaket mitzieht Am echten plex.tv geprüft: der Anmeldecode kommt an. Dabei fiel auf, dass `strong=true` einen dreißigstelligen Code liefert, der sich bei plex.tv/link nicht eintippen lässt — jetzt der kurze. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Guido
Claude Opus 5
@@ -0,0 +1,241 @@
|
||||
import AVFoundation
|
||||
import Foundation
|
||||
import FlixyPlayback
|
||||
import UIKit
|
||||
@preconcurrency import VLCKit
|
||||
|
||||
/// Wiedergabe über VLCKit.
|
||||
///
|
||||
/// Der Weg für alles, was der Systemplayer nicht öffnet: Matroska-Container,
|
||||
/// DTS- und TrueHD-Ton, ältere Codecs. Langsamer beim Starten und stromhungriger,
|
||||
/// dafür spielt er praktisch jede Datei ohne Zutun des Servers.
|
||||
///
|
||||
/// `@preconcurrency import`, weil VLCKit als Objective-C-Bibliothek nichts über
|
||||
/// Nebenläufigkeit aussagt. Die ganze Klasse liegt deshalb auf dem Hauptakteur —
|
||||
/// VLCKit erwartet seine Rückrufe ohnehin dort.
|
||||
@MainActor
|
||||
public final class VLCPlayerEngine: NSObject, VideoPlayerEngine {
|
||||
/// Die Fläche, in die VLC zeichnet. Die Ansicht hängt sie in ihren
|
||||
/// Hierarchiebaum.
|
||||
public let videoView = UIView()
|
||||
|
||||
private let player = VLCMediaPlayer()
|
||||
|
||||
public private(set) var state: PlaybackState = .idle {
|
||||
didSet {
|
||||
guard state != oldValue else { return }
|
||||
continuation?.yield(.stateChanged(state))
|
||||
}
|
||||
}
|
||||
|
||||
public private(set) var duration: Duration?
|
||||
public private(set) var audioTracks: [MediaTrack] = []
|
||||
public private(set) var subtitleTracks: [MediaTrack] = []
|
||||
|
||||
public var currentTime: Duration {
|
||||
.milliseconds(Int(player.time.intValue))
|
||||
}
|
||||
|
||||
/// VLCKit 4 bringt ein eigenes Bild-in-Bild-Protokoll mit
|
||||
/// (`VLCPictureInPictureMediaControlling`). Angebunden ist es noch nicht —
|
||||
/// solange steht hier `false`, damit kein Knopf erscheint, der nichts tut.
|
||||
/// Nachzuholen in Phase 2, zusammen mit der Steuerung im Sperrbildschirm.
|
||||
public let supportsPictureInPicture = false
|
||||
|
||||
public private(set) lazy var events: AsyncStream<PlaybackEvent> = {
|
||||
AsyncStream { continuation in
|
||||
self.continuation = continuation
|
||||
}
|
||||
}()
|
||||
|
||||
private var continuation: AsyncStream<PlaybackEvent>.Continuation?
|
||||
private var pendingStartTime: Duration = .zero
|
||||
|
||||
public override init() {
|
||||
super.init()
|
||||
videoView.backgroundColor = .black
|
||||
player.delegate = self
|
||||
player.drawable = videoView
|
||||
AudioSessionBridge.activate()
|
||||
}
|
||||
|
||||
public func load(_ source: PlaybackSource) async throws(PlaybackFailure) {
|
||||
state = .loading
|
||||
pendingStartTime = source.startTime
|
||||
|
||||
let media = VLCMedia(url: source.url)
|
||||
player.media = media
|
||||
|
||||
// VLC kennt Länge und Spuren erst, wenn es die Datei geöffnet hat.
|
||||
// Beides kommt später über den Delegaten — hier gibt es nichts zu
|
||||
// warten, und ein `await` würde nur den Bildaufbau verzögern.
|
||||
player.play()
|
||||
}
|
||||
|
||||
public func play() {
|
||||
player.play()
|
||||
}
|
||||
|
||||
public func pause() {
|
||||
// `pause()` ist bei VLC ein Umschalter. Ohne diese Prüfung würde ein
|
||||
// Aufruf im pausierten Zustand die Wiedergabe wieder starten.
|
||||
if player.isPlaying { player.pause() }
|
||||
}
|
||||
|
||||
public func seek(to time: Duration) async {
|
||||
player.time = VLCTime(int: time.vlcMilliseconds)
|
||||
continuation?.yield(.timeChanged(time))
|
||||
}
|
||||
|
||||
public func setRate(_ rate: Double) {
|
||||
player.rate = Float(rate)
|
||||
}
|
||||
|
||||
public func selectAudioTrack(_ track: MediaTrack?) {
|
||||
select(track, from: player.audioTracks)
|
||||
}
|
||||
|
||||
public func selectSubtitleTrack(_ track: MediaTrack?) {
|
||||
select(track, from: player.textTracks)
|
||||
}
|
||||
|
||||
public func teardown() {
|
||||
player.stop()
|
||||
player.delegate = nil
|
||||
player.drawable = nil
|
||||
continuation?.finish()
|
||||
continuation = nil
|
||||
state = .idle
|
||||
AudioSessionBridge.deactivate()
|
||||
}
|
||||
|
||||
// MARK: - Spuren
|
||||
|
||||
private func select(_ track: MediaTrack?, from tracks: [VLCMediaPlayer.Track]) {
|
||||
guard let track, let identifier = track.engineTrackID else {
|
||||
// Abschalten: alle Spuren dieser Art abwählen. Bei Untertiteln der
|
||||
// Normalfall.
|
||||
tracks.forEach { $0.isSelected = false }
|
||||
return
|
||||
}
|
||||
// `isSelectedExclusively` wählt diese Spur und wählt die übrigen
|
||||
// desselben Typs ab. Einzeln zu setzen ließe zwei Tonspuren gleichzeitig
|
||||
// laufen.
|
||||
tracks.first { $0.trackId == identifier }?.isSelectedExclusively = true
|
||||
}
|
||||
|
||||
private func refreshTracks() {
|
||||
audioTracks = player.audioTracks.map { $0.mediaTrack(kind: .audio) }
|
||||
subtitleTracks = player.textTracks.map { $0.mediaTrack(kind: .subtitle) }
|
||||
continuation?.yield(.tracksResolved(audio: audioTracks, subtitle: subtitleTracks))
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - VLCMediaPlayerDelegate
|
||||
|
||||
/// VLCKit stellt seine Rückrufe standardmäßig über die Hauptwarteschlange zu
|
||||
/// (siehe `VLCEventsConfiguration`). Deshalb `assumeIsolated` statt eines
|
||||
/// `Task`: ein nachgelagerter Task würde die Reihenfolge der Zustandswechsel
|
||||
/// durcheinanderbringen — „spielt" könnte nach „gestoppt" ankommen.
|
||||
extension VLCPlayerEngine: VLCMediaPlayerDelegate {
|
||||
public nonisolated func mediaPlayerStateChanged(_ newState: VLCMediaPlayerState) {
|
||||
MainActor.assumeIsolated {
|
||||
switch newState {
|
||||
case .opening:
|
||||
state = .loading
|
||||
case .playing:
|
||||
state = .playing
|
||||
applyPendingStartTime()
|
||||
refreshTracks()
|
||||
case .paused:
|
||||
state = .paused
|
||||
case .stopped, .stopping:
|
||||
// VLC meldet das Ende einer Datei als „gestoppt". Ob das
|
||||
// Ansehen abgeschlossen ist oder jemand abgebrochen hat,
|
||||
// unterscheidet nur die Position.
|
||||
state = isNearEnd ? .ended : .idle
|
||||
if isNearEnd { continuation?.yield(.reachedEnd) }
|
||||
case .error:
|
||||
state = .failed(PlaybackFailure(kind: .formatUnsupported))
|
||||
case .nothingSpecial:
|
||||
break
|
||||
@unknown default:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public nonisolated func mediaPlayerTimeChanged(_ aNotification: Notification) {
|
||||
MainActor.assumeIsolated {
|
||||
continuation?.yield(.timeChanged(currentTime))
|
||||
}
|
||||
}
|
||||
|
||||
public nonisolated func mediaPlayerLengthChanged(_ length: Int64) {
|
||||
MainActor.assumeIsolated {
|
||||
guard length > 0 else { return }
|
||||
let value = Duration.milliseconds(length)
|
||||
duration = value
|
||||
continuation?.yield(.durationResolved(value))
|
||||
}
|
||||
}
|
||||
|
||||
/// Beim Fortsetzen: VLC nimmt eine Position erst an, wenn die Wiedergabe
|
||||
/// tatsächlich läuft. Vorher gesetzt, wird sie kommentarlos verworfen.
|
||||
private func applyPendingStartTime() {
|
||||
guard pendingStartTime > .zero else { return }
|
||||
player.time = VLCTime(int: pendingStartTime.vlcMilliseconds)
|
||||
pendingStartTime = .zero
|
||||
}
|
||||
|
||||
private var isNearEnd: Bool {
|
||||
// Ein Rest von unter zwei Sekunden zählt als durchgesehen — VLC
|
||||
// stoppt selten exakt am Dateiende.
|
||||
guard let duration else { return false }
|
||||
return currentTime + .seconds(2) >= duration
|
||||
}
|
||||
}
|
||||
|
||||
extension Duration {
|
||||
/// Millisekunden als `Int32`, wie VLCTime sie erwartet.
|
||||
///
|
||||
/// Abgeschnitten statt umgewandelt: `Int32(...)` stürzt bei Überlauf ab,
|
||||
/// und die Grenze liegt bei rund 24 Tagen Laufzeit. Das wird keine Datei
|
||||
/// erreichen — aber ein Absturz an dieser Stelle wäre besonders schwer zu
|
||||
/// erklären.
|
||||
var vlcMilliseconds: Int32 {
|
||||
let milliseconds = components.seconds * 1000
|
||||
return Int32(clamping: milliseconds)
|
||||
}
|
||||
}
|
||||
|
||||
extension VLCMediaPlayer.Track {
|
||||
fileprivate func mediaTrack(kind: MediaTrack.Kind) -> MediaTrack {
|
||||
MediaTrack(
|
||||
id: "vlc-\(trackId)",
|
||||
kind: kind,
|
||||
displayName: trackName.isEmpty ? trackId : trackName,
|
||||
engineIdentifier: nil
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension MediaTrack {
|
||||
/// VLC führt seine Spuren unter Zeichenketten, nicht unter Zahlen —
|
||||
/// deshalb steckt die Kennung im `id`-Feld statt in `engineIdentifier`.
|
||||
fileprivate var engineTrackID: String? {
|
||||
id.hasPrefix("vlc-") ? String(id.dropFirst(4)) : nil
|
||||
}
|
||||
}
|
||||
|
||||
/// Die Tonsitzung, damit der Ton auch bei umgelegtem Stummschalter läuft.
|
||||
enum AudioSessionBridge {
|
||||
static func activate() {
|
||||
try? AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
|
||||
try? AVAudioSession.sharedInstance().setActive(true)
|
||||
}
|
||||
|
||||
static func deactivate() {
|
||||
try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user