Scarriffle/Flaro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Live-TV: die Senderliste wird gesucht, nicht geraten — und Serien richtig beschriftet

Browse Source 
Vier geratene Adressen, vier 404. Statt ein fünftes Mal zu raten, klopft
die App jetzt in einem Durchgang und gleichzeitig ein Dutzend Adressen ab:
was /media/providers an Endpunkten angibt, welche Unterverzeichnisse
Programmanbieter und Empfänger in ihrer eigenen Antwort führen, die
bekannten Formen anderer Serverfassungen, die Senderliste des Tuners
selbst — und zuletzt das Programmraster.

Dabei zwei Fehlerquellen mitbehoben, die jede einzeln wie „keine Sender"
ausgesehen hätten: der Sendername steht je nach Tunertyp in title, name,
channelTitle oder callSign, und eine Antwort mit dreißig namenlosen
Einträgen sieht aus wie eine Senderliste, ist aber keine.

Bleibt es leer, steht jetzt jede abgeklopfte Adresse mit ihrer Antwort in
der Ansicht. Das beantwortet „liegt es am Server oder an der App" ohne
eine weitere Runde Rückfragen.

Dazu drei Sachen bei Serien:
- Groß steht, worum es geht — bei einer Folge ihr Titel, bei einer
  Staffel der Name der Serie. „Staffel 10" als Überschrift sagte nicht,
  welche Serie gemeint ist.
- Die Einordnung steht darunter: Serienname bei Folgen, Staffelnummer bei
  Staffeln.
- Von der Folge führt ein Weg zur Staffel und zur Serie. Wer über
  „Weiterschauen" bei einer Folge landete, saß dort bisher fest.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
2026-09-12 12:21:29 +02:00
co-authored by Claude Opus 5
parent 591cba73a7
commit 7e36f37506
11 changed files with 565 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Flixy/Resources/Localizable.xcstrings
+61
View File
@@ -442,6 +442,38 @@
}
}
},
"detail.toSeason": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Zur Staffel"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Go to season"
}
}
}
},
"detail.toSeries": {
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Zur Serie"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Go to series"
}
}
}
},
"detail.unwatchedCount %lld": {
"extractionState": "stale",
"localizations": {
@@ -1760,8 +1792,13 @@
}
}
},
"liveTV.channelCount %@": {
"comment": "A label displaying the number of channels. The argument is the number of channels.",
"isCommentAutoGenerated": true
},
"liveTV.channelCount %lld": {
"comment": "Platzhalter: Anzahl Sender",
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1778,6 +1815,7 @@
}
},
"liveTV.gap": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1794,6 +1832,7 @@
}
},
"liveTV.mode": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1810,6 +1849,7 @@
}
},
"liveTV.mode.guide": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1826,6 +1866,7 @@
}
},
"liveTV.mode.now": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1941,6 +1982,7 @@
}
},
"liveTV.now": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1957,6 +1999,7 @@
}
},
"liveTV.runningNow": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -1990,6 +2033,7 @@
}
},
"liveTV.tune": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
@@ -2579,6 +2623,23 @@
}
}
},
"season.short %lld": {
"comment": "Platzhalter: Staffelnummer",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Staffel %lld"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Season %lld"
}
}
}
},
"serverPicker.owned": {
"extractionState": "stale",
"localizations": {
Flixy/Session/PlaybackCoordinator.swift
+13 -4
View File
@@ -60,15 +60,24 @@ extension PlexItem {
}
/// Die Beschriftung unter einer Kachel.
///
/// Sie ordnet ein, was darüber steht: zu einer Folge gehört die Serie, zu
/// einer Staffel ihre Nummer. Die Reihenfolge ist Absicht — wird der
/// Platz eng, bleibt der Serienname stehen und die Folgennummer fällt weg.
var cardSubtitle: String? {
switch kind {
case .episode:
var code: String?
if let season = parentIndex, let episode = index {
return String(localized: "episode.short \(season) \(episode)")
code = String(localized: "episode.short \(season) \(episode)")
}
return grandparentTitle
case .movie:
return year.map(String.init)
guard let series = grandparentTitle else { return code }
return code.map { "\(series) · \($0)" } ?? series
case .season:
// Ohne die Serie darüber wäre „Staffel 10" beliebig — deshalb
// steht die Nummer hier und der Serienname als Titel.
if let index { return String(localized: "season.short \(index)") }
return parentTitle == nil ? nil : title
default:
return year.map(String.init)
}
Flixy/Views/Detail/ParentLinks.swift
+90
View File
@@ -0,0 +1,90 @@
import SwiftUI
import FlixyDesign
import PlexKit
/// Der Weg nach oben: von der Folge zur Staffel, von der Staffel zur Serie.
///
/// Bisher gab es ihn nicht. Wer über „Weiterschauen" oder „Zuletzt
/// hinzugefügt" bei einer einzelnen Folge landete, saß dort fest — die
/// übrigen Folgen derselben Staffel waren nur über den Umweg Bibliothek →
/// Serie → Staffel erreichbar. Genau dieser Umweg ist der Grund, dass die
/// Zeile existiert.
struct ParentLinks: View {
let item: PlexItem
var body: some View {
if !destinations.isEmpty {
ScrollView(.horizontal) {
HStack(spacing: FlixySpacing.snug) {
ForEach(destinations, id: \.route.ratingKey) { destination in
NavigationLink(value: destination.route) {
Label {
Text(destination.route.title)
.lineLimit(1)
} icon: {
Image(systemName: destination.symbol)
}
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextPrimary)
.padding(.horizontal, FlixySpacing.regular)
.padding(.vertical, FlixySpacing.snug)
.background(Color.flixyElevated, in: .capsule)
}
.buttonStyle(.plain)
}
}
.padding(.horizontal, FlixySpacing.screenMargin)
}
.scrollIndicators(.hidden)
}
}
private struct Destination {
let route: MediaRoute
let symbol: String
}
/// Die Stationen über diesem Eintrag.
///
/// Bei einer Folge zwei — Staffel und Serie; bei einer Staffel eine.
/// Plex führt beide Kennungen am Eintrag mit, deshalb braucht es dafür
/// keine zusätzliche Abfrage.
private var destinations: [Destination] {
switch item.kind {
case .episode:
var stops: [Destination] = []
if let season = item.parentRatingKey {
let title = item.parentIndex.map { String(localized: "season.short \($0)") }
?? item.parentTitle
?? String(localized: "detail.toSeason")
stops.append(Destination(
route: MediaRoute(ratingKey: season, title: title),
symbol: "rectangle.stack"
))
}
if let show = item.grandparentRatingKey {
stops.append(Destination(
route: MediaRoute(
ratingKey: show,
title: item.grandparentTitle ?? String(localized: "detail.toSeries")
),
symbol: "tv"
))
}
return stops
case .season:
guard let show = item.parentRatingKey else { return [] }
return [Destination(
route: MediaRoute(
ratingKey: show,
title: item.parentTitle ?? String(localized: "detail.toSeries")
),
symbol: "tv"
)]
default:
return []
}
}
}
Flixy/Views/Detail/PlayableDetailView.swift
+9 -2
View File
@@ -19,6 +19,8 @@ struct PlayableDetailView: View {
VStack(alignment: .leading, spacing: FlixySpacing.section) {
header
ParentLinks(item: item)
if item.hasMultipleVersions {
VersionPicker(media: item.media, selection: $selectedVersion)
.padding(.horizontal, FlixySpacing.screenMargin)
@@ -104,8 +106,13 @@ struct PlayableDetailView: View {
private var metadataLine: String? {
var pieces: [String] = []
if item.kind == .episode, let season = item.parentIndex, let episode = item.index {
pieces.append(String(localized: "episode.short \(season) \(episode)"))
if item.kind == .episode {
// Der Folgentitel steht jetzt groß darüber; ohne die Serie hier
// wüsste man auf dieser Seite nicht, wozu die Folge gehört.
if let series = item.grandparentTitle { pieces.append(series) }
if let season = item.parentIndex, let episode = item.index {
pieces.append(String(localized: "episode.short \(season) \(episode)"))
}
}
if let year = item.year { pieces.append(String(year)) }
if let duration = item.duration { pieces.append(Duration.milliseconds(duration).runtimeLabel) }
Flixy/Views/Detail/SeriesDetailView.swift
+8 -1
View File
@@ -17,6 +17,8 @@ struct SeriesDetailView: View {
VStack(alignment: .leading, spacing: FlixySpacing.section) {
header
ParentLinks(item: item)
if let summary = item.summary, !summary.isEmpty {
Text(summary)
.font(.flixyBody)
@@ -38,7 +40,7 @@ struct SeriesDetailView: View {
private var header: some View {
HeroBanner(
title: item.title,
title: item.rowTitle,
metadata: metadataLine,
summary: nil,
artworkURL: session.server?.artworkURL(
@@ -87,6 +89,11 @@ struct SeriesDetailView: View {
private var metadataLine: String? {
var pieces: [String] = []
// Bei einer Staffel steht oben der Serienname — welche Staffel es
// ist, muss deshalb hierher.
if item.kind == .season, let number = item.index {
pieces.append(String(localized: "season.short \(number)"))
}
if let year = item.year { pieces.append(String(year)) }
if let leafCount = item.leafCount {
pieces.append(String(localized: "detail.episodeCount \(leafCount)"))
Flixy/Views/Home/MediaRow.swift
+12 -4
View File
@@ -79,11 +79,19 @@ struct MediaRow: View {
extension PlexItem {
/// Der Titel auf einer Kachel in einer Reihe.
///
/// Bei Folgen der Serientitel: in „Weiterschauen" stehen Folgen
/// verschiedener Serien nebeneinander, und der Folgentitel allein sagt
/// nicht, worum es geht.
/// Groß steht, worum es geht: bei einer Folge ihr eigener Titel, bei
/// einer Staffel der Name der Serie. Die Einordnung — Serie, Staffel —
/// gehört darunter. „Staffel 10" allein als Überschrift sagt nichts
/// darüber, welche Serie gemeint ist.
var rowTitle: String {
kind == .episode ? (grandparentTitle ?? title) : title
switch kind {
case .episode: title
// Die Serie steht je nach Antwort mal unter `parentTitle`, mal unter
// `grandparentTitle`. Fehlt beides, bleibt „Staffel 2" — besser als
// gar keine Beschriftung.
case .season: parentTitle ?? grandparentTitle ?? title
default: title
}
}
/// Welches Bild auf die Querformat-Kachel gehört.
Flixy/Views/LiveTV/LiveTVView.swift
+52 -12
View File
@@ -14,6 +14,8 @@ struct LiveTVView: View {
@State private var channels: [PlexChannel] = []
/// Woher die Senderliste kam — steht in der leeren Ansicht.
@State private var channelSource: String?
/// Jede abgeklopfte Adresse mit ihrer Antwort.
@State private var trace: [ChannelProbe] = []
@State private var programs: [String: [PlexProgram]] = [:]
@State private var isTuning: String?
/// Raster oder Senderliste.
@@ -55,19 +57,12 @@ struct LiveTVView: View {
ContentUnavailableView {
Label("liveTV.noChannels.title", systemImage: "tv")
} description: {
VStack(spacing: FlixySpacing.snug) {
Text("liveTV.noChannels.description")
if let channelSource {
// Ohne diese Angabe ist „keine Sender" eine
// Sackgasse: es sagt nicht, ob der Server nichts
// hergibt oder ob die App am falschen Ort sucht.
Text(channelSource)
.font(.system(.caption2, design: .monospaced))
.foregroundStyle(Color.flixyTextMuted)
}
}
Text("liveTV.noChannels.description")
} actions: {
Button("action.retry") { Task { await load() } }
VStack(spacing: FlixySpacing.regular) {
Button("action.retry") { Task { await load() } }
searchTrace
}
}
case .available:
@@ -102,6 +97,50 @@ struct LiveTVView: View {
.refreshable { await load() }
}
/// Wo überall gesucht wurde, und was dort stand.
///
/// Unbequem, aber nützlich: die Live-TV-Schnittstelle von Plex hat keine
/// Beschreibung, und „keine Sender" allein ist eine Sackgasse. Hier steht
/// jede abgeklopfte Adresse mit ihrer Antwort — das beantwortet die Frage
/// „liegt es am Server oder an der App" ohne eine weitere Runde.
@ViewBuilder
private var searchTrace: some View {
if !trace.isEmpty {
VStack(alignment: .leading, spacing: FlixySpacing.snug) {
if let channelSource {
Text(channelSource)
.font(.flixyCaption)
.foregroundStyle(Color.flixyTextSecondary)
}
ScrollView {
VStack(alignment: .leading, spacing: 3) {
ForEach(trace) { probe in
Text("\(probe.path) → \(probe.result)")
.font(.system(size: 10, design: .monospaced))
.foregroundStyle(Color.flixyTextMuted)
.lineLimit(2)
.textSelection(.enabled)
}
}
.frame(maxWidth: .infinity, alignment: .leading)
}
.frame(maxHeight: 200)
Button {
UIPasteboard.general.string = trace
.map { "\($0.path) → \($0.result)" }
.joined(separator: "\n")
} label: {
Label("diagnostics.copy", systemImage: "doc.on.doc")
.font(.flixyCaption)
}
.buttonStyle(.bordered)
}
.padding(.horizontal, FlixySpacing.screenMargin)
}
}
private var channelList: some View {
ScrollView {
LazyVStack(spacing: 0) {
@@ -138,6 +177,7 @@ struct LiveTVView: View {
channels = guide.channels
programs = guide.programs
channelSource = guide.source
trace = guide.trace
}
private func tune(_ channel: PlexChannel) async {
Packages/FlixyKit/Sources/PlexKit/Endpoints/PlexServer+LiveTV.swift
+211 -88
View File
@@ -31,110 +31,193 @@ extension PlexServer {
}
}
/// Die eingeschalteten Sender eines Empfängers, mit Namen und Logos.
/// Die Sender eines Empfängers — gefunden, nicht geraten.
///
/// Zwei Quellen, die zusammengeführt werden müssen — das war der
/// eigentliche Stolperstein:
/// Die Live-TV-Schnittstelle von Plex hat keine Beschreibung, und die
/// Adresse der Senderliste unterscheidet sich zwischen Serverfassungen,
/// Tunertypen und Programmanbietern. Drei Versuche, sie zu erraten,
/// endeten auf einem echten Server alle mit 404.
///
/// - Der Empfänger kennt nur die **Zuordnung**: welche Sender einer
/// Senderliste eingeschaltet sind, als nackte Schlüssel. Bei einer
/// Swisscom-Liste sind das 28 von 521. Namen stehen dort keine.
/// - Die **Namen, Nummern und Logos** stehen beim Programmanbieter, unter
/// der Senderliste.
/// Deshalb wird sie jetzt gesucht statt geraten, in einem Durchgang und
/// gleichzeitig:
///
/// Zweimal habe ich vorher die Zuordnung für die Senderliste gehalten.
/// Beim ersten Mal blieb sie leer, beim zweiten hätten alle Sender „—"
/// geheißen und dieselbe Kennung getragen.
/// 1. Der Server sagt unter `/media/providers` selbst, welche Endpunkte
/// er anbietet.
/// 2. Der Programmanbieter und der Empfänger führen Unterverzeichnisse,
/// deren Adressen in ihrer eigenen Antwort stehen.
/// 3. Dazu die bekannten Formen, die andere Server verwenden.
/// 4. Und zuletzt das Programmraster, in dem jeder Eintrag seinen Sender
/// mitträgt.
///
/// Was dabei herauskam, steht in `trace` — jede Adresse mit ihrer
/// Antwort. Schlägt alles fehl, ist damit ohne Rückfrage zu sehen, was
/// der Server tatsächlich geantwortet hat.
public func channels(inDVR dvr: PlexDVR) async -> ChannelLookup {
let enabled = dvr.enabledChannelKeys
var identifier = dvr.epgIdentifier
if identifier == nil {
identifier = await electronicProgramGuideIdentifier()
}
if identifier == nil { identifier = await electronicProgramGuideIdentifier() }
guard let epgIdentifier = identifier else {
return ChannelLookup(channels: [], source: .noLineup)
return ChannelLookup(channels: [], source: .noLineup, trace: [])
}
let advertised = await providerFeatures(for: epgIdentifier)
let paths = await candidatePaths(dvr: dvr, epgIdentifier: epgIdentifier)
var found: [Int: [PlexChannel]] = [:]
var trace: [Int: ChannelProbe] = [:]
var lastFailure: String?
for path in Self.channelPaths(
dvr: dvr,
epgIdentifier: epgIdentifier,
advertised: advertised
) {
do {
let container = try await client.send(
PlexRequest(path: path, timeout: .seconds(30)),
as: PlexMediaContainer<PlexChannel>.self
)
guard !container.content.isEmpty else { continue }
// Ohne Zuordnung alles zeigen: besser die vollständige Liste
// als gar keine, wenn der Empfänger keine Auswahl meldet.
let channels = enabled.isEmpty
? container.content
: container.content.filter { $0.matches(anyOf: enabled) }
if channels.isEmpty {
return ChannelLookup(
channels: [],
source: .lineupWithoutMatches(
available: container.content.count,
enabled: enabled.count
)
)
// Gleichzeitig, nicht nacheinander: ein Dutzend Adressen einzeln
// abzuklopfen dauert bei einem Server, der schweigt statt abzulehnen,
// eine Minute. Der Actor gibt an jedem `await` frei, deshalb laufen
// die Abfragen wirklich nebeneinander.
await withTaskGroup(of: (Int, [PlexChannel], ChannelProbe).self) { group in
for (index, path) in paths.enumerated() {
group.addTask {
let outcome = await self.probe(path: path)
return (index, outcome.channels, outcome.probe)
}
return ChannelLookup(
channels: channels,
source: .lineup(available: container.content.count, path: path)
)
} catch {
lastFailure = "\(path): \(error)"
}
for await (index, channels, probe) in group {
found[index] = channels
trace[index] = probe
}
}
return ChannelLookup(channels: [], source: .failed(lastFailure ?? "kein Weg lieferte Sender"))
let ordered = paths.indices.compactMap { trace[$0] }
let enabled = dvr.enabledChannelKeys
// Die Reihenfolge der Kandidaten ist die Rangfolge: was der Server
// selbst angibt, zählt mehr als eine bekannte Form.
for index in paths.indices {
guard let channels = found[index], !channels.isEmpty else { continue }
// Ohne Zuordnung alles zeigen, und auch dann, wenn keiner passt:
// eine vollständige Liste ist besser als eine leere Ansicht, und
// die Schlüssel der Zuordnung weichen je nach Anbieter ab.
let matching = enabled.isEmpty ? channels : channels.filter { $0.matches(anyOf: enabled) }
let result = matching.isEmpty ? channels : matching
return ChannelLookup(
channels: result,
source: .lineup(available: channels.count, path: paths[index]),
trace: ordered
)
}
return ChannelLookup(channels: [], source: .failed("keine der \(paths.count) Adressen lieferte Sender"), trace: ordered)
}
/// Die Adressen, unter denen die Senderliste stehen könnte.
///
/// Mehrere, weil dieser Teil der Plex-API keine Beschreibung hat und sich
/// die Form zwischen Serverfassungen unterscheidet. Sie werden der Reihe
/// nach probiert; welche gegriffen hat, steht in der Diagnose — damit aus
/// dem Durchprobieren beim nächsten Mal Wissen wird.
///
/// Entscheidend ist `pathIdentifier`: die Kennung der Senderliste kommt
/// als vollständige Adresse mit Schema und Anhang. Roh eingesetzt ergibt
/// jeder dieser Pfade 404.
static func channelPaths(
dvr: PlexDVR,
epgIdentifier: String,
advertised: [PlexProviderFeature] = []
) -> [String] {
/// Eine Adresse abklopfen: was steht dort, und sind es Sender?
private func probe(path: String) async -> (channels: [PlexChannel], probe: ChannelProbe) {
let data: Data
do {
data = try await client.send(PlexRequest(path: path, timeout: .seconds(12)))
} catch {
return ([], ChannelProbe(path: path, result: Self.shortDescription(of: error)))
}
let channels = (try? PlexResponse.decode(PlexMediaContainer<PlexChannel>.self, from: data))?.content ?? []
// Namenlose zählen nicht: eine Liste aus dreißig Strichen sieht aus
// wie eine Senderliste, ist aber keine — dieser Fehler ist hier schon
// einmal passiert.
let named = channels.filter(\.hasName)
return (
named,
ChannelProbe(
path: path,
result: named.isEmpty ? Self.containerSummary(data) : "\(named.count) Sender"
)
)
}
/// Alle Adressen, an denen die Senderliste stehen könnte — erfragt und bekannt.
private func candidatePaths(dvr: PlexDVR, epgIdentifier: String) async -> [String] {
var paths: [String] = []
// Zuerst, was der Server selbst angibt. Die Namen der Fähigkeiten sind
// nicht dokumentiert, deshalb alles, was nach Sendern klingt.
for feature in advertised where ["channels", "lineups", "livetv", "grid"].contains(feature.type) {
// 1. Was der Server selbst angibt.
for feature in await providerFeatures(for: epgIdentifier)
where ["channels", "lineups", "livetv", "grid", "tuner"].contains(feature.type) {
if let key = feature.key { paths.append(key) }
}
// Danach die geratenen Formen. Sie haben bei einem Server mit
// Swisscom-Liste alle 404 ergeben — sie stehen hier nur noch, weil
// andere Serverfassungen sie kennen könnten.
if let lineup = dvr.lineups.first {
paths.append("/\(epgIdentifier)/lineups/\(lineup.pathIdentifier)/channels")
// 2. Was Anbieter und Empfänger an Unterverzeichnissen führen.
for root in ["/\(epgIdentifier)", "/livetv/dvrs/\(dvr.key)"] {
for entry in await directories(at: root) {
guard let key = entry.key else { continue }
let haystack = (key + " " + (entry.title ?? "")).lowercased()
guard ["channel", "sender", "lineup", "grid", "guide"].contains(where: haystack.contains)
else { continue }
paths.append(key.hasPrefix("/") ? key : "\(root)/\(key)")
}
}
paths.append("/\(epgIdentifier)/channels")
paths.append("/livetv/dvrs/\(dvr.key)/channels")
// Doppelte entfernen, Reihenfolge behalten.
// 3. Die bekannten Formen.
paths.append(contentsOf: Self.knownPaths(dvr: dvr, epgIdentifier: epgIdentifier))
var seen = Set<String>()
return paths.filter { seen.insert($0).inserted }
}
/// Die Adressen, die andere Serverfassungen verwenden.
///
/// Entscheidend ist `pathIdentifier`: die Kennung der Senderliste kommt
/// als vollständige Adresse mit Schema und Anhang. Roh eingesetzt ergibt
/// jeder dieser Pfade 404 — das war der erste Fehlschlag von vieren.
static func knownPaths(dvr: PlexDVR, epgIdentifier: String) -> [String] {
var paths = ["/livetv/dvrs/\(dvr.key)/channels"]
if let lineup = dvr.lineups.first {
paths.append("/\(epgIdentifier)/lineups/\(lineup.pathIdentifier)/channels")
paths.append("/livetv/dvrs/\(dvr.key)/lineups/\(lineup.pathIdentifier)/channels")
}
paths.append("/\(epgIdentifier)/channels")
paths.append("/\(epgIdentifier)/lineups")
// Der Empfänger selbst führt bei Netzwerk-Tunern seine eigene
// Senderliste — die vom Gerät gefundenen Sender, mit Namen.
for device in dvr.devices {
for key in [device.key, device.deviceIdentifier].compactMap({ $0 }) {
let base = key.hasPrefix("/") ? key : "/media/grabbers/devices/\(key)"
paths.append("\(base)/channels")
paths.append("/livetv/dvrs/\(dvr.key)/devices/\(key)/channels")
}
}
var seen = Set<String>()
return paths.filter { seen.insert($0).inserted }
}
/// Die Unterverzeichnisse an einer Adresse.
private func directories(at path: String) async -> [PlexNavigationEntry] {
let container = try? await client.send(
PlexRequest(path: path, timeout: .seconds(12)),
as: PlexMediaContainer<PlexNavigationEntry>.self
)
return container?.content ?? []
}
/// Welche Sammlungen eine Antwort enthält, mit Anzahl.
///
/// Beantwortet die Frage, die nach einem Fehlschlag als Nächstes kommt:
/// war dort etwas, und unter welchem Namen?
static func containerSummary(_ data: Data) -> String {
guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
let container = object["MediaContainer"] as? [String: Any]
else { return "keine Plex-Antwort (\(data.count) Bytes)" }
let collections = container
.compactMap { key, value -> String? in
guard let array = value as? [Any] else { return nil }
return "\(key): \(array.count)"
}
.sorted()
return collections.isEmpty ? "leer" : collections.joined(separator: ", ")
}
static func shortDescription(of error: any Error) -> String {
if let plex = error as? PlexError { return String(describing: plex) }
return (error as? URLError).map { "URLError \($0.errorCode)" } ?? "Fehler"
}
/// Was der Programmanbieter an Fähigkeiten angibt.
public func providerFeatures(for identifier: String) async -> [PlexProviderFeature] {
guard let container = try? await client.send(
@@ -210,7 +293,12 @@ extension PlexServer {
var identifier = dvr.epgIdentifier
if identifier == nil { identifier = await electronicProgramGuideIdentifier() }
guard let epgIdentifier = identifier else {
return LiveTVGuide(channels: lookup.channels, programs: [:], source: lookup.description)
return LiveTVGuide(
channels: lookup.channels,
programs: [:],
source: lookup.description,
trace: lookup.trace
)
}
let now = Date()
@@ -227,7 +315,12 @@ extension PlexServer {
}
if !lookup.channels.isEmpty {
return LiveTVGuide(channels: lookup.channels, programs: programs, source: lookup.description)
return LiveTVGuide(
channels: lookup.channels,
programs: programs,
source: lookup.description,
trace: lookup.trace
)
}
// Aus dem Raster: jeden Sender einmal, in der Reihenfolge, in der das
@@ -247,7 +340,13 @@ extension PlexServer {
programs: programs,
source: channels.isEmpty
? "Raster: keine Sender (\(lookup.description))"
: "Raster: \(channels.count) von \(fromGrid.count) Sendern"
: "Raster: \(channels.count) von \(fromGrid.count) Sendern",
trace: lookup.trace + [ChannelProbe(
path: "/\(epgIdentifier)/grid",
result: fromGrid.isEmpty
? "\(entries.count) Sendungen, kein Sender benannt"
: "\(fromGrid.count) Sender"
)]
)
}
@@ -307,12 +406,7 @@ extension PlexServer {
as: PlexMediaContainer<PlexDVR>.self
).content.first,
let epgIdentifier = dvr.epgIdentifier {
let advertised = await providerFeatures(for: epgIdentifier)
for path in Self.channelPaths(
dvr: dvr,
epgIdentifier: epgIdentifier,
advertised: advertised
) {
for path in await candidatePaths(dvr: dvr, epgIdentifier: epgIdentifier) {
report.append("\n=== \(path) ===")
report.append(await structure(ofPath: path))
}
@@ -387,6 +481,24 @@ extension PlexServer {
}
}
/// Eine abgeklopfte Adresse und was sie geantwortet hat.
public struct ChannelProbe: Sendable, Equatable, Identifiable {
public let path: String
/// „28 Sender", „notFound", „Channel: 0" — kurz genug für eine Zeile.
public let result: String
public var id: String { path }
}
/// Ein Verzeichniseintrag, wie ihn Plex in Wurzelantworten führt.
///
/// Nur Adresse und Beschriftung: mehr braucht es nicht, um zu erkennen, wo
/// die Sender stehen, und mehr steht dort oft auch nicht.
struct PlexNavigationEntry: Decodable {
let key: String?
let title: String?
}
/// Woher die Senderliste kam.
public struct ChannelLookup: Sendable {
public enum Source: Sendable, Equatable {
@@ -402,9 +514,18 @@ public struct ChannelLookup: Sendable {
public let channels: [PlexChannel]
public let source: Source
public init(channels: [PlexChannel], source: Source) {
/// Jede abgeklopfte Adresse mit ihrer Antwort.
///
/// Steht in der Ansicht, wenn nichts gefunden wurde. Der Grund ist
/// unbequem, aber nützlich: bei einer Schnittstelle ohne Beschreibung ist
/// „keine Sender" allein eine Sackgasse, und jede Runde Rückfragen
/// kostet Tage.
public let trace: [ChannelProbe]
public init(channels: [PlexChannel], source: Source, trace: [ChannelProbe] = []) {
self.channels = channels
self.source = source
self.trace = trace
}
/// Kurzbeschreibung für die Diagnose.
@@ -488,4 +609,6 @@ public struct LiveTVGuide: Sendable {
public let programs: [String: [PlexProgram]]
/// Woher die Sender kamen — steht in der leeren Ansicht und in der Diagnose.
public let source: String
/// Jede abgeklopfte Adresse mit ihrer Antwort, falls nichts gefunden wurde.
public let trace: [ChannelProbe]
}
Packages/FlixyKit/Sources/PlexKit/Models/PlexLiveTV.swift
+43 -4
View File
@@ -135,13 +135,15 @@ public struct PlexTunerDevice: Sendable, Equatable, Decodable, Identifiable {
public let key: String?
public let uuid: String?
public let title: String?
/// Die Gerätekennung — unter ihr führt der Server die gefundenen Sender.
public let deviceIdentifier: String?
/// Welche Sender der Senderliste hier eingeschaltet sind.
public let channelMappings: [PlexChannelMapping]
public var id: String { uuid ?? key ?? title ?? "tuner" }
private enum CodingKeys: String, CodingKey {
case key, uuid, title
case key, uuid, title, deviceId, deviceIdentifier
case channelMapping = "ChannelMapping"
}
@@ -150,6 +152,9 @@ public struct PlexTunerDevice: Sendable, Equatable, Decodable, Identifiable {
self.key = try? values.decodeIfPresent(String.self, forKey: .key)
self.uuid = try values.decodeIfPresent(String.self, forKey: .uuid)
self.title = try values.decodeIfPresent(String.self, forKey: .title)
self.deviceIdentifier = (try? values.decodeIfPresent(String.self, forKey: .deviceId))
?? (try? values.decodeIfPresent(String.self, forKey: .deviceIdentifier))
?? nil
self.channelMappings = try values
.decodeIfPresent([PlexChannelMapping].self, forKey: .channelMapping) ?? []
}
@@ -158,11 +163,13 @@ public struct PlexTunerDevice: Sendable, Equatable, Decodable, Identifiable {
key: String? = nil,
uuid: String? = nil,
title: String? = nil,
deviceIdentifier: String? = nil,
channelMappings: [PlexChannelMapping] = []
) {
self.key = key
self.uuid = uuid
self.title = title
self.deviceIdentifier = deviceIdentifier
self.channelMappings = channelMappings
}
}
@@ -236,16 +243,32 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
public let key: String?
public let id: String
/// Ob dieser Sender einen Namen trägt.
///
/// Eine Liste aus dreißig Strichen sieht aus wie eine Senderliste, ist
/// aber keine — dieser Irrtum hat hier schon einmal eine falsche Quelle
/// als die richtige durchgehen lassen.
public var hasName: Bool { title != Self.placeholder }
static let placeholder = "—"
private enum CodingKeys: String, CodingKey {
case channelIdentifier, title, thumb, key
case identifier = "id"
case uuid
case uuid, name, callSign, vcn, number, channelTitle, channelCallSign
}
public init(from decoder: any Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
self.title = try values.decodeIfPresent(String.self, forKey: .title) ?? "—"
self.channelIdentifier = try values.decodeIfPresent(String.self, forKey: .channelIdentifier)
// Vier Schreibweisen für denselben Namen, je nach Tunertyp und
// Anbieter. Nur `title` zu lesen hieße, die halbe Senderliste als
// namenlos zu verwerfen.
self.title = [CodingKeys.title, .name, .channelTitle, .callSign, .channelCallSign]
.lazy
.compactMap { try? values.decodeIfPresent(String.self, forKey: $0) }
.first { !$0.isEmpty } ?? Self.placeholder
self.channelIdentifier = Self.text(in: values, forKeys: [.channelIdentifier, .vcn, .number])
self.thumb = try values.decodeIfPresent(String.self, forKey: .thumb)
self.key = try values.decodeIfPresent(String.self, forKey: .key)
@@ -283,6 +306,22 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
return keys.contains { $0.split(separator: "/").last.map(String.init) == id }
}
/// Ein Wert, der als Zahl oder als Zeichenkette kommen kann.
private static func text(
in values: KeyedDecodingContainer<CodingKeys>,
forKeys keys: [CodingKeys]
) -> String? {
for key in keys {
if let text = try? values.decodeIfPresent(String.self, forKey: key), !text.isEmpty {
return text
}
if let number = try? values.decodeIfPresent(Int.self, forKey: key) {
return String(number)
}
}
return nil
}
public init(id: String, title: String, channelIdentifier: String? = nil, thumb: String? = nil, key: String? = nil) {
self.id = id
self.title = title
Packages/FlixyKit/Tests/PlexKitTests/ClearLogoTests.swift
+9 -9
View File
@@ -197,23 +197,23 @@ struct ChannelPathTests {
)
@Test("Die Kennung der Senderliste wird ausgepackt, nicht roh eingesetzt")
func usesBareIdentifier() {
func usesBareIdentifier() throws {
// Der Fehler, der 404 ergab: die volle Adresse mit Schema, Anhang und
// Prozentzeichen landete unverändert im Pfad.
let paths = PlexServer.channelPaths(dvr: dvr, epgIdentifier: "epg:2")
let first = paths[0]
let paths = PlexServer.knownPaths(dvr: dvr, epgIdentifier: "epg:2")
let lineupPath = try #require(paths.first { $0.contains("/lineups/") })
#expect(first == "/epg:2/lineups/6228f7f2364e02fa5ec8e51c/channels")
#expect(!first.contains("lineup://"))
#expect(!first.contains("#"))
#expect(!first.contains("%"))
#expect(lineupPath == "/epg:2/lineups/6228f7f2364e02fa5ec8e51c/channels")
#expect(!lineupPath.contains("lineup://"))
#expect(!lineupPath.contains("#"))
#expect(!lineupPath.contains("%"))
}
@Test("Es gibt Rückfalllinien")
func offersFallbacks() {
// Die Form unterscheidet sich zwischen Serverfassungen, und dieser
// Teil der API hat keine Beschreibung.
let paths = PlexServer.channelPaths(dvr: dvr, epgIdentifier: "epg:2")
let paths = PlexServer.knownPaths(dvr: dvr, epgIdentifier: "epg:2")
#expect(paths.count >= 2)
#expect(paths.contains("/livetv/dvrs/1/channels"))
}
@@ -221,7 +221,7 @@ struct ChannelPathTests {
@Test("Ohne Senderliste bleiben die übrigen Wege")
func withoutLineup() {
let bare = PlexDVR(key: "7")
let paths = PlexServer.channelPaths(dvr: bare, epgIdentifier: "epg:2")
let paths = PlexServer.knownPaths(dvr: bare, epgIdentifier: "epg:2")
#expect(!paths.isEmpty)
#expect(paths.allSatisfy { !$0.contains("lineups//") })
}
Packages/FlixyKit/Tests/PlexKitTests/LiveTVGuideTests.swift
+57
View File
@@ -91,6 +91,63 @@ struct LiveTVGuideTests {
#expect(guide.channels.isEmpty)
}
@Test("Die Senderliste des Empfängers wird gefunden, ohne dass sie geraten wird")
func sweepsUntilSomethingAnswers() async throws {
// Der Fall, der viermal danebenging: die Senderliste steht weder beim
// Programmanbieter noch unter dem Empfänger, sondern beim Gerät — und
// sie schreibt den Namen in `name` statt in `title`.
let device = """
{"MediaContainer":{"size":2,"Channel":[
{"name":"SRF 1 HD","vcn":1,"key":"/livetv/channels/11","enabled":"1"},
{"name":"SRF zwei HD","vcn":2,"key":"/livetv/channels/12","enabled":"1"}
]}}
"""
let server = server(routes: ["/media/grabbers/devices/tuner-7/channels": device])
let withTuner = PlexDVR(
key: "2",
devices: [PlexTunerDevice(key: "tuner-7")],
epgIdentifier: "tv.plex.providers.epg.cloud:2"
)
let lookup = await server.channels(inDVR: withTuner)
#expect(lookup.channels.map(\.title) == ["SRF 1 HD", "SRF zwei HD"])
#expect(lookup.channels.first?.channelIdentifier == "1")
}
@Test("Jede abgeklopfte Adresse steht mit ihrer Antwort in der Spur")
func recordsWhatEveryPathAnswered() async throws {
// Ohne diese Spur ist „keine Sender" eine Sackgasse: sie sagt nicht,
// ob der Server nichts hergibt oder die App am falschen Ort sucht.
let server = server(routes: [:])
let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
let lookup = await server.channels(inDVR: withTuner)
#expect(lookup.channels.isEmpty)
#expect(lookup.trace.count >= 3)
#expect(lookup.trace.allSatisfy { !$0.result.isEmpty })
#expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" })
}
@Test("Eine Liste aus Strichen zählt nicht als Senderliste")
func rejectsNamelessChannels() async throws {
// Genau das ist einmal durchgegangen: dreißig Einträge ohne Namen
// sahen aus wie eine Senderliste und verdrängten die richtige Quelle.
let nameless = """
{"MediaContainer":{"size":2,"Channel":[
{"channelKey":"a","enabled":"1"},{"channelKey":"b","enabled":"1"}
]}}
"""
let server = server(routes: ["/livetv/dvrs/2/channels": nameless])
let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
let lookup = await server.channels(inDVR: withTuner)
#expect(lookup.channels.isEmpty)
#expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" && $0.result.contains("Channel: 2") })
}
@Test("Die Einschaltadresse reist mit dem Sender mit")
func keepsTuneKey() async throws {
let server = server(routes: [