Ein Download riss ab, galt als fertig — und setzte nie fort
Dein Bericht: bei rund 3 GB abgebrochen, beim Fortsetzen wieder bei null,
und später „plötzlich bei 60 Prozent fertig". Beide Hälften standen so im
Code.
**Fertig war sie nicht, sie war halb.**
if expected > 0, Double(written) < Double(expected) * 0.5 { verwerfen }
Alles über der Hälfte galt als vollständig. Diese Regel war nie für diesen
Fall gedacht, sondern für die **hochgerechnete** Größe der Transcoder-Stufen
(Bitrate × Dauer) — dort ist Abweichung normal. Beim Original nennt der
Server die Dateigröße in den Metadaten, und da ist jedes fehlende Byte ein
Abriss.
Das unterscheidet jetzt `expectedIsExact`, gesetzt beim Planen und
mitgeführt am Eintrag. Dazu merkt sich der Koordinator, für welche Titel der
Server eine `Content-Length` geschickt hat — auch das ist eine Zusage.
**„Fortsetzen" war eine Zusage, die der Code nicht halten konnte.**
`NSURLSessionDownloadTaskResumeData` kam im ganzen Projekt nicht vor; den
Wiederaufnahme-Datensatz gab es nur beim Pausieren von Hand. Nach einem
Netzfehler war er weg, und der Knopf daneben hieß trotzdem „Fortsetzen".
Jetzt wird er aus dem Fehler gerettet, und wo es ihn nicht gibt, heißt der
Knopf „Erneut versuchen".
**Und es merkte niemand, wenn das WLAN zurückkam.** `RootView` reicht das
jetzt weiter — nur für Einträge mit Wiederaufnahme-Datensatz, damit ein 404
sich nicht im Kreis versucht.
**Rate und Restzeit** stehen in der Zeile: „12 MB / 20 MB · 3,4 MB/s ·
gleich fertig". `DownloadRate` ist ein reiner Wertetyp mit Uhr von außen —
geglättet, weil rohe Differenzen um ein Vielfaches springen, und ohne Zahl,
solange nichts gemessen ist. Neun Tests.
**Zwei Dinge, die erst die Messung gezeigt hat** — und die beide nicht in
der App liegen:
Erstens: reißt eine Übertragung ab, **die eine `Content-Length` angekündigt
hatte**, wiederholt die Hintergrundsitzung von iOS sie selbst — stumm, ohne
den Delegaten zu fragen, und **jedes Mal ab Byte null**. Gemessen: sieben
Anläufe, jeder die vollen 12 MB. Das ist genau dein „fing wieder bei null
an", und dagegen hilft kein Wiederaufnahme-Datensatz.
Zweitens: ein Fortsetzen braucht eine Prüfmarke vom Server. Ohne `ETag`
oder `Last-Modified` kann iOS sein `If-Range` nicht stellen und lädt alles
noch einmal — gemessen, 20 MB zweimal. Mit Marke kam die zweite Anfrage als
`Range: bytes=5636096-` und holte nur den Rest.
Die Attrappe kann das jetzt alles nachstellen: eine beliebig große Datei,
die auf Wunsch mittendrin abreißt, mit oder ohne angekündigte Länge, und
gedrosselt. Ohne sie ist nichts davon beweisbar — und genau daran ist der
Fehler vorbeigekommen.
Im Simulator gegen die Attrappe: 12 von 20 MB → „Fehlgeschlagen:
Übertragung unvollständig", nicht Haken. Vollständig → Haken. iOS und tvOS
bauen, 489 Tests grün.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
c37087fd34
commit
e86c0a6e95
@@ -0,0 +1,102 @@
|
||||
import Foundation
|
||||
|
||||
/// Wie schnell ein Download gerade läuft — und wie lange er noch braucht.
|
||||
///
|
||||
/// **Ein Wertetyp mit Uhr von außen.** Die Rückmeldungen der Übertragung
|
||||
/// kommen mehrmals je Sekunde; was daraus eine Zahl macht, ist reine Rechnung
|
||||
/// und gehört nicht in den Koordinator. Die Zeitpunkte kommen als Argument
|
||||
/// herein, damit sich eine Übertragung ohne echte Uhr nachstellen lässt — eine
|
||||
/// Rate, die man nur im Betrieb beurteilen kann, ist keine prüfbare Zahl.
|
||||
///
|
||||
/// **Warum geglättet.** Zwischen zwei Rückmeldungen schwankt die rohe
|
||||
/// Differenz um ein Vielfaches: ein Puffer läuft voll, der Funk hat ein Loch,
|
||||
/// das System hält die Hintergrundsitzung kurz an. Ungeglättet stünde dort
|
||||
/// eine Zahl, die zehnmal je Sekunde springt — und eine springende Zahl ist
|
||||
/// keine Auskunft, sondern Unruhe.
|
||||
public struct DownloadRate: Sendable, Equatable {
|
||||
/// Wie stark ein neuer Messwert gegenüber dem bisherigen zählt.
|
||||
///
|
||||
/// Ein Drittel: schnell genug, dass ein echter Einbruch binnen weniger
|
||||
/// Sekunden ankommt, träge genug, dass einzelne Ausreißer untergehen.
|
||||
private static let weight = 1.0 / 3.0
|
||||
|
||||
/// Kürzere Abstände werden nicht gemessen.
|
||||
///
|
||||
/// Über fünfzig Millisekunden gerechnet entscheidet der Zufall, wann das
|
||||
/// System den Puffer leert — nicht die Leitung.
|
||||
static let minimumInterval: Duration = .milliseconds(500)
|
||||
|
||||
/// Ab dieser Lücke beginnt die Messung von vorn.
|
||||
///
|
||||
/// So lange ohne eine einzige Rückmeldung heißt nicht „langsam", sondern
|
||||
/// „stand still": die App war angehalten, das Gerät gesperrt, das Netz
|
||||
/// weg. Diese Pause in die Rate einzurechnen ergäbe eine Zahl nahe null
|
||||
/// und eine Restzeit von Stunden.
|
||||
static let maximumInterval: Duration = .seconds(10)
|
||||
|
||||
/// Ein Messpunkt: wie viel war wann da.
|
||||
///
|
||||
/// Als Typ und nicht als Tupel — ein Tupel kann `Equatable` nicht erben,
|
||||
/// und ohne das wäre der ganze Wertetyp nicht vergleichbar.
|
||||
private struct Anchor: Equatable {
|
||||
var bytes: Int64
|
||||
var at: ContinuousClock.Instant
|
||||
}
|
||||
|
||||
/// Der letzte Messpunkt, gegen den gerechnet wird.
|
||||
private var anchor: Anchor?
|
||||
private var smoothed: Double?
|
||||
|
||||
public init() {}
|
||||
|
||||
/// Bytes je Sekunde — `nil`, solange nichts gemessen wurde.
|
||||
///
|
||||
/// **Nicht null.** Null wäre eine Auskunft („es geht nichts durch"), und
|
||||
/// die stimmt in der ersten halben Sekunde nie.
|
||||
public var bytesPerSecond: Double? { smoothed }
|
||||
|
||||
/// Nimmt den Stand der Übertragung entgegen.
|
||||
public mutating func record(bytes: Int64, at now: ContinuousClock.Instant) {
|
||||
guard let anchor else {
|
||||
self.anchor = Anchor(bytes: bytes, at: now)
|
||||
return
|
||||
}
|
||||
|
||||
let elapsed = now - anchor.at
|
||||
guard elapsed >= Self.minimumInterval else { return }
|
||||
defer { self.anchor = Anchor(bytes: bytes, at: now) }
|
||||
|
||||
// Rückwärts heißt: eine neue Aufgabe fängt von vorn an. Dann ist jede
|
||||
// bisherige Messung ungültig — und eine negative Rate wäre Unsinn.
|
||||
guard bytes >= anchor.bytes, elapsed <= Self.maximumInterval else {
|
||||
smoothed = nil
|
||||
return
|
||||
}
|
||||
|
||||
let seconds = elapsed.inSeconds
|
||||
guard seconds > 0 else { return }
|
||||
|
||||
let gemessen = Double(bytes - anchor.bytes) / seconds
|
||||
smoothed = smoothed.map { $0 + (gemessen - $0) * Self.weight } ?? gemessen
|
||||
}
|
||||
|
||||
/// Wie lange es bei dieser Rate noch dauert.
|
||||
///
|
||||
/// `nil`, solange keine Rate feststeht oder die Gesamtgröße unbekannt ist.
|
||||
/// Eine Restzeit ohne Rate wäre geraten, und geraten sieht man ihr nicht
|
||||
/// an.
|
||||
public func remaining(received: Int64, total: Int64) -> Duration? {
|
||||
guard let smoothed, smoothed > 0, total > received else { return nil }
|
||||
return .seconds(Double(total - received) / smoothed)
|
||||
}
|
||||
}
|
||||
|
||||
extension Duration {
|
||||
/// Die Dauer als Sekunden.
|
||||
///
|
||||
/// `components` liefert ganze Sekunden und Attosekunden getrennt; für eine
|
||||
/// Division braucht es beides in einer Zahl.
|
||||
var inSeconds: Double {
|
||||
Double(components.seconds) + Double(components.attoseconds) / 1e18
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,8 @@ public struct DownloadPlan: Sendable {
|
||||
public var episodeIndex: Int?
|
||||
public var durationMilliseconds: Int?
|
||||
public var expectedBytes: Int64
|
||||
/// Ob `expectedBytes` die genaue Größe ist — siehe `DownloadItem`.
|
||||
public var expectedIsExact: Bool
|
||||
public var offlineMedia: OfflineMedia?
|
||||
|
||||
public init(
|
||||
@@ -30,6 +32,7 @@ public struct DownloadPlan: Sendable {
|
||||
episodeIndex: Int? = nil,
|
||||
durationMilliseconds: Int? = nil,
|
||||
expectedBytes: Int64 = 0,
|
||||
expectedIsExact: Bool = false,
|
||||
offlineMedia: OfflineMedia? = nil
|
||||
) {
|
||||
self.ratingKey = ratingKey
|
||||
@@ -43,6 +46,7 @@ public struct DownloadPlan: Sendable {
|
||||
self.episodeIndex = episodeIndex
|
||||
self.durationMilliseconds = durationMilliseconds
|
||||
self.expectedBytes = expectedBytes
|
||||
self.expectedIsExact = expectedIsExact
|
||||
self.offlineMedia = offlineMedia
|
||||
}
|
||||
}
|
||||
@@ -80,6 +84,28 @@ public final class DownloadCoordinator {
|
||||
/// Wie viel die Downloads insgesamt belegen.
|
||||
public private(set) var usedBytes: Int64 = 0
|
||||
|
||||
/// Das gemessene Tempo je laufender Übertragung.
|
||||
///
|
||||
/// **Im Arbeitsspeicher, nicht in der Datenbank** — aus demselben Grund,
|
||||
/// aus dem `handleProgress` kein `save()` ruft: die Messpunkte kommen
|
||||
/// mehrmals je Sekunde, und jedes Schreiben wäre eine Plattenoperation.
|
||||
/// Über einen Neustart hinweg wäre eine alte Rate ohnehin wertlos.
|
||||
private var rates: [String: DownloadRate] = [:]
|
||||
|
||||
/// Für welche Titel der Server die Größe **angekündigt** hat.
|
||||
///
|
||||
/// Der Unterschied entscheidet, wann eine Datei als abgerissen gilt. Bei
|
||||
/// einer angekündigten Größe ist jedes fehlende Byte ein Abriss; bei einer
|
||||
/// hochgerechneten (Transcoder: Bitrate × Dauer) wäre dieselbe Strenge
|
||||
/// falsch, denn die Schätzung weicht von Haus aus ab.
|
||||
///
|
||||
/// Woran man es erkennt: `URLSession` meldet die erwartete Größe nur, wenn
|
||||
/// die Antwort eine `Content-Length` trägt — sonst kommt −1.
|
||||
///
|
||||
/// Ebenfalls im Arbeitsspeicher: nach einem Neustart wird die Übertragung
|
||||
/// neu eingereiht, und dann meldet sich der Server wieder.
|
||||
private var announcedSizes: Set<String> = []
|
||||
|
||||
/// Nur über WLAN übertragen.
|
||||
public var isWiFiOnly: Bool {
|
||||
didSet { defaults.set(isWiFiOnly, forKey: Key.wifiOnly) }
|
||||
@@ -279,7 +305,8 @@ public final class DownloadCoordinator {
|
||||
seasonIndex: plan.seasonIndex,
|
||||
episodeIndex: plan.episodeIndex,
|
||||
durationMilliseconds: plan.durationMilliseconds,
|
||||
offlineMediaData: plan.offlineMedia.flatMap { try? JSONEncoder().encode($0) }
|
||||
offlineMediaData: plan.offlineMedia.flatMap { try? JSONEncoder().encode($0) },
|
||||
expectedIsExact: plan.expectedIsExact
|
||||
)
|
||||
context.insert(item)
|
||||
save()
|
||||
@@ -343,6 +370,7 @@ public final class DownloadCoordinator {
|
||||
task.cancel { continuation.resume(returning: $0) }
|
||||
}
|
||||
item.resumeData = data
|
||||
forgetTransfer(item.ratingKey)
|
||||
item.state = .paused
|
||||
save()
|
||||
await startNextIfPossible()
|
||||
@@ -364,6 +392,7 @@ public final class DownloadCoordinator {
|
||||
|
||||
/// Entfernt Eintrag und Datei.
|
||||
public func remove(_ item: DownloadItem) {
|
||||
forgetTransfer(item.ratingKey)
|
||||
fileStore.remove(fileName: item.localFileName)
|
||||
fileStore.remove(fileName: item.artworkFileName)
|
||||
context.delete(item)
|
||||
@@ -462,13 +491,40 @@ public final class DownloadCoordinator {
|
||||
func handleProgress(ratingKey: String, received: Int64, expected: Int64) {
|
||||
guard let item = items.first(where: { $0.ratingKey == ratingKey }) else { return }
|
||||
item.receivedBytes = received
|
||||
if expected > 0 { item.totalBytes = expected }
|
||||
if expected > 0 {
|
||||
item.totalBytes = expected
|
||||
// Hier und nur hier ist belegt, dass die Größe vom Server kommt
|
||||
// und nicht hochgerechnet ist. Siehe `announcedSizes`.
|
||||
announcedSizes.insert(ratingKey)
|
||||
}
|
||||
|
||||
var rate = rates[ratingKey] ?? DownloadRate()
|
||||
rate.record(bytes: received, at: .now)
|
||||
rates[ratingKey] = rate
|
||||
|
||||
updateActivity()
|
||||
// Bewusst ohne `save()`: der Fortschritt kommt mehrmals je Sekunde, und
|
||||
// jedes Schreiben wäre eine Plattenoperation. Für die Anzeige reicht
|
||||
// die Beobachtung; gespeichert wird bei Zustandswechseln.
|
||||
}
|
||||
|
||||
/// Das gemessene Tempo einer laufenden Übertragung.
|
||||
///
|
||||
/// `nil`, solange noch nichts gemessen wurde — und das ist eine ehrlichere
|
||||
/// Antwort als „0 MB/s".
|
||||
public func rate(forRatingKey key: String) -> DownloadRate? {
|
||||
rates[key]
|
||||
}
|
||||
|
||||
/// Vergisst, was nur zu einer laufenden Übertragung gehört.
|
||||
///
|
||||
/// Beim nächsten Anlauf wird neu gemessen: eine Rate von vorhin gälte
|
||||
/// sonst für eine Leitung, die es inzwischen nicht mehr gibt.
|
||||
private func forgetTransfer(_ ratingKey: String) {
|
||||
rates[ratingKey] = nil
|
||||
announcedSizes.remove(ratingKey)
|
||||
}
|
||||
|
||||
func handleCompletion(ratingKey: String, temporaryFile: URL) {
|
||||
guard let item = items.first(where: { $0.ratingKey == ratingKey }),
|
||||
let sourceURL = URL(string: item.sourceURLString)
|
||||
@@ -483,13 +539,19 @@ public final class DownloadCoordinator {
|
||||
// Fehler verdeckt: kamen nur ein paar Kilobyte an, wurden sie als
|
||||
// empfangen *und* als erwartet notiert — und die Anzeige stand auf
|
||||
// hundert Prozent.
|
||||
if let problem = Self.implausibility(written: written, expected: item.totalBytes) {
|
||||
let problem = Self.implausibility(
|
||||
written: written,
|
||||
expected: item.totalBytes,
|
||||
announced: item.expectedIsExact || announcedSizes.contains(ratingKey)
|
||||
)
|
||||
if let problem {
|
||||
fileStore.remove(fileName: name)
|
||||
fail(item, message: problem)
|
||||
Task { await startNextIfPossible() }
|
||||
return
|
||||
}
|
||||
|
||||
forgetTransfer(ratingKey)
|
||||
item.localFileName = name
|
||||
item.receivedBytes = written
|
||||
if item.totalBytes <= 0 { item.totalBytes = written }
|
||||
@@ -508,10 +570,22 @@ public final class DownloadCoordinator {
|
||||
/// Prüft, ob die fertige Datei plausibel ist.
|
||||
///
|
||||
/// Gibt eine Begründung zurück, wenn nicht. Zwei Fälle fallen darunter:
|
||||
/// eine winzige Datei (fast immer eine Fehlerseite) und eine, die deutlich
|
||||
/// unter der angekündigten Größe liegt (abgebrochene Übertragung, die als
|
||||
/// eine winzige Datei (fast immer eine Fehlerseite) und eine, die unter
|
||||
/// der erwarteten Größe liegt (abgebrochene Übertragung, die als
|
||||
/// erfolgreich gemeldet wurde).
|
||||
static func implausibility(written: Int64, expected: Int64) -> String? {
|
||||
///
|
||||
/// **`announced` entscheidet, wie streng gemessen wird** — und daran hing
|
||||
/// ein Fehler, der Dateien kaputt machte und als Erfolg verbuchte. Hier
|
||||
/// stand früher für jede Größe dieselbe Regel: unter der Hälfte ist es ein
|
||||
/// Abriss, darüber in Ordnung. Eine bei sechzig Prozent abgerissene Datei
|
||||
/// kam damit durch, bekam einen Haken — und brach beim Abspielen
|
||||
/// mittendrin ab.
|
||||
///
|
||||
/// Die Hälfte-Regel war nie für diesen Fall gedacht, sondern für die
|
||||
/// **hochgerechnete** Größe der Transcoder-Stufen (Bitrate × Dauer). Dort
|
||||
/// ist Abweichung normal. Hat der Server die Größe dagegen angekündigt,
|
||||
/// ist jedes fehlende Byte ein Abriss, und zwar genau einer.
|
||||
static func implausibility(written: Int64, expected: Int64, announced: Bool) -> String? {
|
||||
// Unter hundert Kilobyte ist keine Videodatei. Dieser Wert liegt
|
||||
// bewusst niedrig: eine sehr kurze Folge kann klein sein, eine
|
||||
// HTML-Fehlerseite ist es immer.
|
||||
@@ -521,9 +595,10 @@ public final class DownloadCoordinator {
|
||||
bundle: .module
|
||||
)
|
||||
}
|
||||
// Zehn Prozent Abweichung nach unten sind noch erklärbar — der
|
||||
// Transcoder kennt die Endgröße vorab nicht genau. Die Hälfte nicht.
|
||||
if expected > 0, Double(written) < Double(expected) * 0.5 {
|
||||
// Angekündigt: auf das Byte genau. Hochgerechnet: die Hälfte, denn der
|
||||
// Transcoder kennt die Endgröße vorab nicht.
|
||||
let untergrenze = announced ? Double(expected) : Double(expected) * 0.5
|
||||
if expected > 0, Double(written) < untergrenze {
|
||||
return String(
|
||||
localized: "downloads.failed.truncated \(written.formatted(.byteCount(style: .file))) \(expected.formatted(.byteCount(style: .file)))",
|
||||
bundle: .module
|
||||
@@ -549,11 +624,49 @@ public final class DownloadCoordinator {
|
||||
return
|
||||
}
|
||||
|
||||
// **Den Wiederaufnahme-Datensatz retten.**
|
||||
//
|
||||
// Hier lag der zweite Teil des Fehlers. Es gab ihn nur beim Pausieren
|
||||
// von Hand (`pause(_:)`); nach einem Netzabbruch war er weg, und
|
||||
// „Fortsetzen" lud eine vierzig Gigabyte große Datei wieder ab Byte
|
||||
// null — während der Knopf daneben „Fortsetzen" hieß. Eine
|
||||
// Beschriftung, die der Code nicht halten konnte.
|
||||
//
|
||||
// iOS legt den Datensatz dem Fehler bei, wenn die Übertragung
|
||||
// unterbrochen wurde und fortsetzbar ist. Fehlt er, war es keine
|
||||
// Unterbrechung, sondern eine Ablehnung — und `resumeInterrupted()`
|
||||
// unterscheidet die beiden genau daran.
|
||||
item.resumeData = (error as NSError)
|
||||
.userInfo[NSURLSessionDownloadTaskResumeData] as? Data
|
||||
|
||||
fail(item, message: error.localizedDescription)
|
||||
Task { await startNextIfPossible() }
|
||||
}
|
||||
|
||||
/// Nimmt wieder auf, was nur das Netz unterbrochen hat.
|
||||
///
|
||||
/// **Weil niemand sonst merkt, dass das WLAN zurück ist.** Ein
|
||||
/// gescheiterter Download lag bisher, bis man ihn von Hand antippte — auch
|
||||
/// dann, wenn die Verbindung seit einer Stunde wieder stand.
|
||||
///
|
||||
/// Nur Einträge mit Wiederaufnahme-Datensatz: den gibt es bei einer
|
||||
/// unterbrochenen Übertragung, nicht bei einer abgelehnten. Ein Titel, den
|
||||
/// der Server mit „nicht gefunden" beantwortet, versucht sich damit nicht
|
||||
/// im Kreis.
|
||||
public func resumeInterrupted() async {
|
||||
let unterbrochen = items.filter { $0.state == .failed && $0.resumeData != nil }
|
||||
guard !unterbrochen.isEmpty else { return }
|
||||
|
||||
for item in unterbrochen {
|
||||
item.state = .queued
|
||||
item.failureMessage = nil
|
||||
}
|
||||
save()
|
||||
await startNextIfPossible()
|
||||
}
|
||||
|
||||
private func fail(_ item: DownloadItem, message: String) {
|
||||
forgetTransfer(item.ratingKey)
|
||||
item.state = .failed
|
||||
item.failureMessage = message
|
||||
save()
|
||||
|
||||
@@ -29,6 +29,17 @@ public final class DownloadItem {
|
||||
|
||||
public var totalBytes: Int64
|
||||
public var receivedBytes: Int64
|
||||
/// Ob `totalBytes` die **genaue** Größe ist oder eine Schätzung.
|
||||
///
|
||||
/// **Daran hängt, wann eine Datei als abgerissen gilt.** Beim Original
|
||||
/// nennt der Server die Dateigröße in den Metadaten — da ist jedes
|
||||
/// fehlende Byte ein Abriss. Bei den umgerechneten Stufen rechnet die App
|
||||
/// die Größe aus Bitrate und Dauer hoch, und die weicht von Haus aus ab;
|
||||
/// dort wäre dieselbe Strenge falsch.
|
||||
///
|
||||
/// Ohne diese Unterscheidung galt für beides die Hälfte-Regel — und eine
|
||||
/// bei sechzig Prozent abgerissene Datei bekam einen Haken.
|
||||
public var expectedIsExact: Bool = false
|
||||
|
||||
/// Dateiname im Download-Ordner. Nicht der volle Pfad: der Container der
|
||||
/// App bekommt bei jedem Systemupdate eine neue Kennung, ein gespeicherter
|
||||
@@ -69,7 +80,8 @@ public final class DownloadItem {
|
||||
seasonIndex: Int? = nil,
|
||||
episodeIndex: Int? = nil,
|
||||
durationMilliseconds: Int? = nil,
|
||||
offlineMediaData: Data? = nil
|
||||
offlineMediaData: Data? = nil,
|
||||
expectedIsExact: Bool = false
|
||||
) {
|
||||
self.ratingKey = ratingKey
|
||||
self.title = title
|
||||
@@ -85,6 +97,7 @@ public final class DownloadItem {
|
||||
self.episodeIndex = episodeIndex
|
||||
self.durationMilliseconds = durationMilliseconds
|
||||
self.offlineMediaData = offlineMediaData
|
||||
self.expectedIsExact = expectedIsExact
|
||||
self.addedAt = Date()
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user