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

Live-TV: die Sender stehen im Programmraster, nicht in einer Senderliste

Browse Source 
Drei geratene Adressen für die Senderliste antworteten auf einem echten
Server alle mit 404. Statt ein viertes Mal zu raten, liest die App jetzt
zwei Dinge: was /media/providers an Endpunkten angibt, und das
Programmraster selbst — die Weboberfläche von Plex zeichnet ihren Guide
daraus, und jeder Rastereintrag trägt Sendername, Nummer, Logo und
Einschaltweg mit sich.

Damit kommen Sender und Programm aus einer Abfrage, und ihre Kennungen
passen zueinander. Getrennt geholt taten sie das nicht: das Programm
landete in keiner Zeile.

Dazu die Ansicht, für die das alles da ist — ein Programmraster mit
stehender Senderspalte, mitlaufender Zeitachse und einer Jetzt-Linie.
Antippen öffnet die Sendung; läuft sie gerade, schaltet ein Knopf um.

Die Geometrie steht in GuideLayout und ist geprüft: in einer View wäre
sie unsichtbar falsch. Die Trennlinien gehören in die Zeile statt
zwischen die Zeilen — Divider ist auf 3x-Schirmen keinen ganzen Punkt
hoch, und der Bruchteil summiert sich, bis die angetippte Zeile zum
Nachbarsender gehört.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
2026-09-12 12:03:11 +02:00
co-authored by Claude Opus 5
parent 9f9eec1b7f
commit 591cba73a7
9 changed files with 3462 additions and 2409 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Packages/FlixyKit/Sources/PlexKit/Endpoints/PlexServer+LiveTV.swift
+190 -14
View File
@@ -56,8 +56,14 @@ extension PlexServer {
return ChannelLookup(channels: [], source: .noLineup)
}
let advertised = await providerFeatures(for: epgIdentifier)
var lastFailure: String?
for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
for path in Self.channelPaths(
dvr: dvr,
epgIdentifier: epgIdentifier,
advertised: advertised
) {
do {
let container = try await client.send(
PlexRequest(path: path, timeout: .seconds(30)),
@@ -102,14 +108,41 @@ extension PlexServer {
/// 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] {
static func channelPaths(
dvr: PlexDVR,
epgIdentifier: String,
advertised: [PlexProviderFeature] = []
) -> [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) {
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")
}
paths.append("/\(epgIdentifier)/channels")
paths.append("/livetv/dvrs/\(dvr.key)/channels")
return paths
// Doppelte entfernen, Reihenfolge behalten.
var seen = Set<String>()
return paths.filter { seen.insert($0).inserted }
}
/// Was der Programmanbieter an Fähigkeiten angibt.
public func providerFeatures(for identifier: String) async -> [PlexProviderFeature] {
guard let container = try? await client.send(
PlexRequest(path: "/media/providers"),
as: PlexMediaContainer<PlexMediaProvider>.self
) else { return [] }
return container.content.first { $0.identifier == identifier }?.features ?? []
}
/// Die Kennung des Programmanbieters.
@@ -126,7 +159,7 @@ extension PlexServer {
return container.content.first { $0.identifier.contains("epg") }?.identifier
}
/// Das Programmraster für einen Zeitraum.
/// Das Programmraster für einen Zeitraum, mit Sendern.
///
/// Bewusst über einen Zeitraum statt „alles": ein Tag über hundert Sender
/// sind mehrere tausend Sendungen, und mehr als die nächsten Stunden
@@ -135,7 +168,7 @@ extension PlexServer {
providerIdentifier: String,
from start: Date,
to end: Date
) async throws(PlexError) -> [PlexProgram] {
) async throws(PlexError) -> [PlexGuideEntry] {
let container = try await client.send(
PlexRequest(
path: "/\(providerIdentifier)/grid",
@@ -151,14 +184,73 @@ extension PlexServer {
)
return container.content.compactMap { entry in
// Die Senderzuordnung steckt im Medien-Block. Fehlt sie, lässt
// sich die Sendung keiner Spalte zuordnen — dann ist sie für ein
// Raster wertlos.
let channelID = entry.media?.first?.parts.first?.key
return entry.program(channelID: channelID)
// Sender und Sendung stammen aus demselben Eintrag — deshalb
// passen die Kennungen zueinander. Getrennt geholt taten sie das
// nicht, und das Programm landete in keiner Spalte.
let channel = entry.channel
guard let program = entry.program(channelID: channel?.id) else { return nil }
return PlexGuideEntry(channel: channel, program: program)
}
}
/// Senderliste und Programm in einem Zug.
///
/// Der Weg über die Senderliste des Anbieters ist der erste Versuch; wo
/// er greift, sind Logos und Nummern vollständiger. Wo er nicht greift —
/// und bei einem Server mit Swisscom-Liste tut er das nicht, alle
/// bekannten Adressen antworten mit 404 — tragen die Rastereinträge die
/// Sender selbst. Die Weboberfläche von Plex zeichnet ihren Guide genau
/// daraus.
public func liveTVGuide(
dvr: PlexDVR,
hours: Int = 6
) async -> LiveTVGuide {
let lookup = await channels(inDVR: dvr)
var identifier = dvr.epgIdentifier
if identifier == nil { identifier = await electronicProgramGuideIdentifier() }
guard let epgIdentifier = identifier else {
return LiveTVGuide(channels: lookup.channels, programs: [:], source: lookup.description)
}
let now = Date()
let entries = (try? await guide(
providerIdentifier: epgIdentifier,
from: now.addingTimeInterval(-3_600),
to: now.addingTimeInterval(TimeInterval(hours) * 3_600)
)) ?? []
let programs = Dictionary(grouping: entries.compactMap { entry in
entry.program.channelID.map { (key: $0, program: entry.program) }
}, by: \.key).mapValues { pairs in
pairs.map(\.program).sorted { $0.startsAt < $1.startsAt }
}
if !lookup.channels.isEmpty {
return LiveTVGuide(channels: lookup.channels, programs: programs, source: lookup.description)
}
// Aus dem Raster: jeden Sender einmal, in der Reihenfolge, in der das
// Raster ihn nennt. Plex sortiert dort bereits nach Sendernummer.
var seen = Set<String>()
let fromGrid = entries.compactMap(\.channel).filter { seen.insert($0.id).inserted }
let enabled = dvr.enabledChannelKeys
let filtered = enabled.isEmpty ? fromGrid : fromGrid.filter { $0.matches(anyOf: enabled) }
// Passt keiner zur Zuordnung, ist die ganze Liste besser als keine:
// die Zuordnung zu erzwingen hieße, bei abweichenden Schlüsseln alles
// wegzuwerfen, was der Server gerade geliefert hat.
let channels = filtered.isEmpty ? fromGrid : filtered
return LiveTVGuide(
channels: channels,
programs: programs,
source: channels.isEmpty
? "Raster: keine Sender (\(lookup.description))"
: "Raster: \(channels.count) von \(fromGrid.count) Sendern"
)
}
/// Schaltet einen Sender ein.
///
/// Live-TV kommt immer als umgerechneter Strom: der Tuner liefert einen
@@ -202,6 +294,11 @@ extension PlexServer {
var report = ["=== /livetv/dvrs ==="]
report.append(await structure(ofPath: "/livetv/dvrs"))
// Was der Server an Endpunkten angibt. Nach drei geratenen Adressen
// mit 404 ist das die Stelle, an der die Antwort stehen muss.
report.append("\n=== /media/providers ===")
report.append(await structure(ofPath: "/media/providers"))
// Und die Senderliste beim Anbieter — dort stehen die Namen. Ohne sie
// im selben Abzug bliebe nach einem Fehlschlag wieder eine Runde
// Raten übrig.
@@ -210,10 +307,29 @@ extension PlexServer {
as: PlexMediaContainer<PlexDVR>.self
).content.first,
let epgIdentifier = dvr.epgIdentifier {
for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
let advertised = await providerFeatures(for: epgIdentifier)
for path in Self.channelPaths(
dvr: dvr,
epgIdentifier: epgIdentifier,
advertised: advertised
) {
report.append("\n=== \(path) ===")
report.append(await structure(ofPath: path))
}
// Und das Raster: wenn keine Senderliste antwortet, muss die
// Antwort hier stehen — die Weboberfläche zeichnet ihren Guide
// daraus.
let now = Int(Date().timeIntervalSince1970)
let gridPath = "/\(epgIdentifier)/grid"
report.append("\n=== \(gridPath) ===")
report.append(await structure(
ofPath: gridPath,
query: [
URLQueryItem(name: "type", value: "1"),
URLQueryItem(name: "beginsAt>", value: String(now - 3_600)),
URLQueryItem(name: "endsAt<", value: String(now + 3_600)),
]
))
} else {
report.append("\n=== Senderliste ===\nKeine Kennung des Programmanbieters am Empfänger")
}
@@ -221,10 +337,10 @@ extension PlexServer {
return report.joined(separator: "\n")
}
private func structure(ofPath path: String) async -> String {
private func structure(ofPath path: String, query: [URLQueryItem] = []) async -> String {
let data: Data
do {
data = try await client.send(PlexRequest(path: path, timeout: .seconds(30)))
data = try await client.send(PlexRequest(path: path, query: query, timeout: .seconds(30)))
} catch {
return "Abfrage gescheitert: \(error)"
}
@@ -245,7 +361,8 @@ extension PlexServer {
case let dictionary as [String: Any]:
return dictionary.keys.sorted().flatMap { key -> [String] in
let child = dictionary[key]!
if ["title", "channelIdentifier", "lineupTitle"].contains(key),
if ["title", "channelIdentifier", "lineupTitle", "type", "key", "identifier",
"channelTitle", "channelCallSign", "channelVcn"].contains(key),
let text = child as? String {
return ["\(padding)\(key): \(text)"]
}
@@ -310,6 +427,65 @@ public struct PlexMediaProvider: Sendable, Equatable, Decodable, Identifiable {
public let identifier: String
public let title: String?
public let types: String?
/// Was dieser Anbieter kann, und unter welcher Adresse.
///
/// Der Grund, warum hier überhaupt etwas steht: Plex sagt selbst, welche
/// Endpunkte es anbietet. Drei Versuche, die Adresse der Senderliste zu
/// erraten, endeten in 404 — sie hier abzulesen ist kein Ratespiel mehr.
public let features: [PlexProviderFeature]
public var id: String { identifier }
private enum CodingKeys: String, CodingKey {
case identifier, title, types
case features = "Feature"
}
public init(from decoder: any Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
self.identifier = try values.decode(String.self, forKey: .identifier)
self.title = try values.decodeIfPresent(String.self, forKey: .title)
self.types = try values.decodeIfPresent(String.self, forKey: .types)
self.features = try values.decodeIfPresent([PlexProviderFeature].self, forKey: .features) ?? []
}
public init(identifier: String, title: String? = nil, types: String? = nil, features: [PlexProviderFeature] = []) {
self.identifier = identifier
self.title = title
self.types = types
self.features = features
}
/// Die Adresse für eine Fähigkeit, falls der Anbieter sie anbietet.
public func key(forFeature type: String) -> String? {
features.first { $0.type == type }?.key
}
}
/// Eine Fähigkeit eines Anbieters, mit der Adresse dahinter.
public struct PlexProviderFeature: Sendable, Equatable, Decodable, Identifiable {
public let type: String
public let key: String?
public var id: String { key ?? type }
public init(type: String, key: String? = nil) {
self.type = type
self.key = key
}
}
/// Ein Rastereintrag: eine Sendung und der Sender, auf dem sie läuft.
public struct PlexGuideEntry: Sendable {
public let channel: PlexChannel?
public let program: PlexProgram
}
/// Senderliste und Programm, so wie die Live-TV-Ansicht sie braucht.
public struct LiveTVGuide: Sendable {
public let channels: [PlexChannel]
/// Sendungen je Sender, nach Anfangszeit sortiert.
public let programs: [String: [PlexProgram]]
/// Woher die Sender kamen — steht in der leeren Ansicht und in der Diagnose.
public let source: String
}