MediaKit: die Grundschicht, auf der Plex und Jellyfin dasselbe meinen

Erster Schritt zu Jellyfin, und er besteht vor allem aus Wegnehmen.

`PlaybackDecider` nahm bisher Plex-Modelle entgegen und las daraus sechs
Felder. Das band die Entscheidung an einen bestimmten Server, obwohl an
der Frage „kann iOS das öffnen?" nichts serverspezifisch ist. Jetzt nimmt
er ein `MediaProfile` — Container, Codecs, Bitrate, ob die Datei
untersucht ist.

Wie ernst die Kopplung war, zeigte der Player selbst: für die
Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen — eine
Media mit Kennung 0, ein Part mit dem Dateinamen als Schlüssel,
zusammengesetzte Spurlisten —, nur damit die Signatur passte. Für eine
Datei, die längst auf dem Gerät lag und mit Plex nichts mehr zu tun
hatte. Dieser Hack ist weg.

Neu ist das Target `MediaKit`: Typen und Rechnungen, die für jeden Server
gelten, ohne eine einzige Abhängigkeit. Darin `MediaProfile` und die
`Duration`-Brücke, die bisher in PlexKit stand — „weil es die unterste
Schicht ist". Das stimmte, solange es nur einen Server gab.

Damit kennen Wiedergabe und Downloads Plex nicht mehr. Zwei der
Abhängigkeiten waren ohnehin tot; die dritte trug nur diese Brücke.

Die wichtigste Testtabelle des Projekts ist mitgewandert und dabei
kürzer geworden: dort steht jetzt, worauf es ankommt, statt vollständiger
Modelle mit Kennungen und Dateipfaden, von denen niemand etwas las.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy/Views/Detail/TechnicalDetails.swift

@@ -15,7 +15,7 @@ struct TechnicalDetails: View {
     @Binding var isExpanded: Bool
 
     private var decision: PlaybackDecision {
-        PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+        PlaybackDecider().decide(profile: media.profile(part: part), policy: .directPlayOnly)
     }
 
     var body: some View {

Flixy/Views/Player/PlayerModel.swift

@@ -1,5 +1,6 @@
 import AVKit
 import Foundation
+import MediaKit
 import Observation
 import FlixyDownloads
 import FlixyPlayback
@@ -184,7 +185,7 @@ final class PlayerModel {
         currentMedia = media
         currentPart = part
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(profile: media.profile(part: part), policy: policy)
         self.decision = decision
 
         guard let source = await source(for: decision, item: item, media: media, part: part, server: server) else {
@@ -232,7 +233,10 @@ final class PlayerModel {
         phase = .preparing
 
         let newPolicy = newQuality.policy(basedOn: policy)
-        let newDecision = PlaybackDecider().decide(media: media, part: part, policy: newPolicy)
+        let newDecision = PlaybackDecider().decide(
+            profile: media.profile(part: part),
+            policy: newPolicy
+        )
         decision = newDecision
 
         guard let source = await source(
@@ -299,19 +303,19 @@ final class PlayerModel {
         let offline = downloads.offlineMedia(forRatingKey: request.ratingKey)
 
         let decision = PlaybackDecider().decide(
-            media: PlexMedia(
-                id: 0,
+            // Früher standen hier **erfundene** Plex-Modelle: eine Media mit
+            // Kennung 0, ein Part mit dem Dateinamen als Schlüssel und
+            // zusammengebaute Spuren — alles nur, damit die Signatur passte,
+            // für eine Datei, die längst auf dem Gerät lag. Genau daran war zu
+            // sehen, dass die Entscheidung nie etwas mit Plex zu tun hatte.
+            profile: MediaProfile(
                 container: offline?.container,
                 videoCodec: offline?.videoCodec,
                 audioCodec: offline?.audioCodec,
-                videoResolution: offline?.videoResolution,
-                bitrate: offline?.bitrate
-            ),
-            part: PlexPart(
-                id: 0,
-                key: url.lastPathComponent,
-                container: offline?.container,
-                streams: offline.map(localStreams) ?? []
+                bitrate: offline?.bitrate,
+                // Was heruntergeladen wurde, ist untersucht. Ohne diese Zusage
+                // ginge jede Offline-Datei vorsichtshalber an VLC.
+                hasKnownStreams: offline?.videoCodec != nil
             ),
             // Lokal gibt es nichts umzurechnen und keine Bandbreitengrenze.
             policy: .directPlayOnly
@@ -325,19 +329,6 @@ final class PlayerModel {
         )
     }
 
-    /// Baut künstliche Spuren aus dem Offline-Abzug.
-    ///
-    /// Der `PlaybackDecider` erwartet Spuren, um überhaupt zu entscheiden —
-    /// eine leere Liste hieße „noch nicht analysiert" und schickte jede
-    /// heruntergeladene Datei vorsichtshalber an VLC.
-    private func localStreams(from offline: OfflineMedia) -> [PlexStream] {
-        var streams = [PlexStream(id: 1, streamType: 1, codec: offline.videoCodec)]
-        if let audioCodec = offline.audioCodec {
-            streams.append(PlexStream(id: 2, streamType: 2, codec: audioCodec, selected: true))
-        }
-        return streams
-    }
-
     private func load(_ source: PlaybackSource, decision: PlaybackDecision) async {
         diagnostics.record(decision: decision, source: source.url)