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

Live-TV: die Lineup-Kennung ist eine Adresse, keine Kennung

Browse Source 
Der zweite Abzug zeigt den Pfad, der 404 ergab:

    /tv.plex.providers.epg.cloud:2/lineups/
      lineup://tv.plex.providers.epg.cloud/6228f7f2364e02fa5ec8e51c
      #Swisscom%20Blue%20TV%20%28Deutschschweiz%29%20%28521%20channels%29
      /channels

`Lineup.id` heißt zwar Kennung, ist aber eine vollständige Adresse: mit
Schema, Doppelschrägstrich, Prozentzeichen und einem Anhang hinter der
Raute. Die habe ich roh in den Pfad gespleißt.

Gebraucht wird der nackte Teil in der Mitte —
`6228f7f2364e02fa5ec8e51c`. `PlexLineup.pathIdentifier` packt ihn aus,
vier Tests halten die Fälle fest.

Da die Pfadform zwischen Serverfassungen schwankt und dieser Teil der
API keine Beschreibung hat, werden drei Adressen der Reihe nach
probiert. Welche gegriffen hat, steht in der Diagnose — damit aus dem
Durchprobieren beim nächsten Mal Wissen wird. Der Strukturabzug deckt
jetzt alle drei ab.

173 Tests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Guido
2026-09-12 10:55:14 +02:00
co-authored by Claude Opus 5
parent 90d5d96485
commit 9f9eec1b7f
3 changed files with 154 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Packages/FlixyKit/Sources/PlexKit/Endpoints/PlexServer+LiveTV.swift
+62 -35
View File
@@ -48,41 +48,68 @@ extension PlexServer {
public func channels(inDVR dvr: PlexDVR) async -> ChannelLookup {
let enabled = dvr.enabledChannelKeys
// `??` mit einem asynchronen Aufruf rechts geht nicht — die
// Kurzschlussauswertung ist nicht nebenläufigkeitsfähig.
var identifier = dvr.epgIdentifier
if identifier == nil {
identifier = await electronicProgramGuideIdentifier()
}
guard let epgIdentifier = identifier, let lineup = dvr.lineups.first else {
guard let epgIdentifier = identifier else {
return ChannelLookup(channels: [], source: .noLineup)
}
do {
let container = try await client.send(
PlexRequest(
path: "/\(epgIdentifier)/lineups/\(lineup.id)/channels",
timeout: .seconds(30)
),
as: PlexMediaContainer<PlexChannel>.self
)
var lastFailure: String?
for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
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) }
// 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) }
return ChannelLookup(
channels: channels,
source: channels.isEmpty
? .lineupWithoutMatches(available: container.content.count, enabled: enabled.count)
: .lineup(available: container.content.count)
)
} catch {
return ChannelLookup(channels: [], source: .failed(String(describing: error)))
if channels.isEmpty {
return ChannelLookup(
channels: [],
source: .lineupWithoutMatches(
available: container.content.count,
enabled: enabled.count
)
)
}
return ChannelLookup(
channels: channels,
source: .lineup(available: container.content.count, path: path)
)
} catch {
lastFailure = "\(path): \(error)"
}
}
return ChannelLookup(channels: [], source: .failed(lastFailure ?? "kein Weg lieferte Sender"))
}
/// 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) -> [String] {
var paths: [String] = []
if let lineup = dvr.lineups.first {
paths.append("/\(epgIdentifier)/lineups/\(lineup.pathIdentifier)/channels")
}
paths.append("/\(epgIdentifier)/channels")
paths.append("/livetv/dvrs/\(dvr.key)/channels")
return paths
}
/// Die Kennung des Programmanbieters.
@@ -182,13 +209,13 @@ extension PlexServer {
PlexRequest(path: "/livetv/dvrs", timeout: .seconds(10)),
as: PlexMediaContainer<PlexDVR>.self
).content.first,
let epgIdentifier = dvr.epgIdentifier,
let lineup = dvr.lineups.first {
let path = "/\(epgIdentifier)/lineups/\(lineup.id)/channels"
report.append("\n=== \(path) ===")
report.append(await structure(ofPath: path))
let epgIdentifier = dvr.epgIdentifier {
for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
report.append("\n=== \(path) ===")
report.append(await structure(ofPath: path))
}
} else {
report.append("\n=== Senderliste ===\nKeine Kennung oder Senderliste am Empfänger")
report.append("\n=== Senderliste ===\nKeine Kennung des Programmanbieters am Empfänger")
}
return report.joined(separator: "\n")
@@ -246,8 +273,8 @@ extension PlexServer {
/// Woher die Senderliste kam.
public struct ChannelLookup: Sendable {
public enum Source: Sendable, Equatable {
/// Aus der Senderliste des Programmanbieters.
case lineup(available: Int)
/// Aus der Senderliste des Programmanbieters, über diesen Pfad.
case lineup(available: Int, path: String)
/// Die Senderliste kam an, aber keiner passte zur Zuordnung.
case lineupWithoutMatches(available: Int, enabled: Int)
/// Am Empfänger hängt keine Senderliste oder kein Programmanbieter.
@@ -266,8 +293,8 @@ public struct ChannelLookup: Sendable {
/// Kurzbeschreibung für die Diagnose.
public var description: String {
switch source {
case .lineup(let available):
"\(channels.count) von \(available) Sendern eingeschaltet"
case .lineup(let available, let path):
"\(channels.count) von \(available) Sendern · \(path)"
case .lineupWithoutMatches(let available, let enabled):
"Senderliste hat \(available) Sender, \(enabled) sind zugeordnet — keiner passte zusammen"
case .noLineup:
Packages/FlixyKit/Sources/PlexKit/Models/PlexLiveTV.swift
+19
View File
@@ -82,9 +82,28 @@ public struct PlexDVR: Sendable, Equatable, Decodable, Identifiable {
/// Eine Senderliste des Anbieters — bei Kabel oder IPTV oft mehrere hundert.
public struct PlexLineup: Sendable, Equatable, Decodable, Identifiable {
/// Die Kennung, wie Plex sie liefert.
///
/// Trotz des Namens keine Kennung, sondern eine vollständige Adresse:
///
/// lineup://tv.plex.providers.epg.cloud/6228f7f2364e02fa5ec8e51c#Swisscom%20Blue%20TV
///
/// Mit Schema, Doppelschrägstrich, Prozentzeichen und einem Anhang hinter
/// der Raute. Roh in einen Pfad gesetzt ergibt das zwangsläufig 404 —
/// genau daran scheiterte die Senderabfrage.
public let id: String
public let title: String?
/// Der nackte Teil in der Mitte, als Pfadabschnitt verwendbar.
///
/// Aus der Adresse oben wird `6228f7f2364e02fa5ec8e51c`.
public var pathIdentifier: String {
// Der Anhang hinter der Raute ist der Anzeigename und gehört nicht in
// die Adresse.
let withoutFragment = id.split(separator: "#", maxSplits: 1).first.map(String.init) ?? id
return withoutFragment.split(separator: "/").last.map(String.init) ?? withoutFragment
}
public init(id: String, title: String? = nil) {
self.id = id
self.title = title