0Pricing
Swift Academy · Lektion

Timeline-Provider und Snapshots

Stellen Sie Widget-Inhalte im zeitlichen Verlauf bereit.

Timeline-Provider und Snapshots ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Aufgabe des Providers

Ein Widget aktualisiert sich nicht fortlaufend selbst. Stattdessen übergibt ein TimelineProvider WidgetKit einen Zeitplan mit vorab gerenderten Einträgen, die das System jeweils zum richtigen Zeitpunkt anzeigt. Der Provider beantwortet drei Fragen: Platzhalter, Snapshot und Timeline.

import WidgetKit
// TimelineProvider supplies:
//   placeholder(in:) -> instant skeleton
//   getSnapshot(in:)  -> one entry for previews
//   getTimeline(in:)  -> future entries + refresh policy

Dem TimelineProvider entsprechen

Ein Provider entspricht mit einem zugehörigen Entry-Typ dem TimelineProvider-Protokoll. Sie implementieren die drei Methoden; jede davon stellt Ihnen einen Context bereit, der die Widget-Familie und angibt, ob es sich um eine Vorschau handelt.

import WidgetKit
struct WeatherProvider: TimelineProvider {
    typealias Entry = WeatherEntry
    func placeholder(in context: Context) -> WeatherEntry {
        WeatherEntry(date: Date(),
            temperature: 20, condition: "Sunny")
    }
    // getSnapshot and getTimeline follow
}

Der Platzhalter

placeholder(in:) muss sofort repräsentative Beispieldaten zurückgeben. Das System zeigt diese Daten als unkenntlich gemachtes Skelett an, während das echte Widget geladen wird, sowie in der Widget-Galerie. Führen Sie hier niemals Netzwerk- oder Festplattenzugriffe durch.

import WidgetKit
func placeholder(in context: Context) -> WeatherEntry {
    // Synchronous, fake data, no I/O
    WeatherEntry(date: Date(),
        temperature: 0, condition: "--")
}

Der Snapshot

getSnapshot stellt für vorübergehende Situationen wie die Vorschau in der Widget-Galerie einen einzelnen Eintrag bereit. Die Methode sollte schnell zurückkehren. Wenn context.isPreview den Wert true hat, verwenden Sie Beispieldaten statt eines langsamen Abrufs, damit die Galerie sofort reagiert.

import WidgetKit
func getSnapshot(
    in context: Context,
    completion: @escaping (WeatherEntry) -> Void) {
    if context.isPreview {
        completion(WeatherEntry(date: Date(),
            temperature: 22, condition: "Clear"))
    } else {
        completion(currentEntry())
    }
}

Die Timeline

getTimeline bildet das Herzstück: Sie erstellen ein Array zukünftiger Einträge und bündeln es in einer Timeline mit einer Aktualisierungsrichtlinie. Das System rendert jeden Eintrag zu seinem Zeitpunkt und fragt anschließend gemäß dieser Richtlinie nach einer neuen Timeline.

import WidgetKit
func getTimeline(
    in context: Context,
    completion: @escaping (Timeline<WeatherEntry>) -> Void) {
    let entries = buildEntries()
    let timeline = Timeline(
        entries: entries, policy: .atEnd)
    completion(timeline)
}

Aktualisierungsrichtlinien

Die Richtlinie zum Neuladen steuert, wann WidgetKit die nächste Timeline anfordert: .atEnd nach dem Zeitpunkt des letzten Eintrags, .after(date) zu einem bestimmten Zeitpunkt oder .never, bis Sie manuell neu laden. Das System legt hierfür Budgets fest. Erwarten Sie daher keine Aktualisierungen im Sekundentakt.

import WidgetKit
// .atEnd            -> reload after final entry
// .after(someDate)  -> reload at a chosen time
// .never            -> only on manual reloadTimelines
let policy = TimelineReloadPolicy.atEnd
_ = policy

Zukünftige Einträge erstellen

Ein gängiges Muster besteht darin, die nächsten Stunden vorab zu berechnen, damit das Widget aktualisiert werden kann, ohne Ihren Code jedes Mal aufzuwecken. Erzeugen Sie in bestimmten Abständen Einträge von jetzt an bis in die Zukunft, die jeweils die Daten für ihren Zeitpunkt enthalten.

import WidgetKit
import Foundation
func hourlyEntries() -> [WeatherEntry] {
    var entries: [WeatherEntry] = []
    let now = Date()
    for hour in 0..<6 {
        let date = Calendar.current.date(
            byAdding: .hour, value: hour, to: now)!
        entries.append(WeatherEntry(date: date,
            temperature: 18 + hour, condition: "Sunny"))
    }
    return entries
}

Asynchrone Daten in der Timeline

Wenn Sie Daten aus dem Netzwerk abrufen müssen, tun Sie dies vor dem Aufruf von completion. Verpacken Sie die asynchrone Arbeit in eine Task und schließen Sie den Vorgang erst ab, sobald die Daten eingetroffen sind. Halten Sie den Vorgang kurz – Provider haben nur ein knappes Zeitbudget.

import WidgetKit
func getTimeline(
    in context: Context,
    completion: @escaping (Timeline<WeatherEntry>) -> Void) {
    Task {
        let entry = await fetchForecast()
        let timeline = Timeline(
            entries: [entry], policy: .after(
                Date().addingTimeInterval(3600)))
        completion(timeline)
    }
}
func fetchForecast() async -> WeatherEntry {
    WeatherEntry(date: Date(),
        temperature: 21, condition: "Cloudy")
}

Relevanz und Budget

WidgetKit begrenzt die Anzahl der Aktualisierungen pro Tag, um den Akku zu schonen. Häufige Aktualisierungen können Sie nicht erzwingen. Stellen Sie mehrere Einträge pro Timeline bereit und wählen Sie eine angemessene Zeit zum Neuladen. Verwenden Sie reloadTimelines aus der App nur bei wesentlichen Datenänderungen.

import WidgetKit
// The system, not you, decides exact refresh timing.
// Strategy: pre-bake multiple entries + a sensible policy
// + app-driven reloads on real changes.
let budget = "refreshes are budgeted by the OS"
_ = budget

Provider für konfigurierbare Widgets

Verwenden Sie für ein Widget mit AppIntentConfiguration stattdessen AppIntentTimelineProvider. Seine Methoden erhalten den vom Benutzer konfigurierten Intent, sodass Sie Daten für die ausgewählte Option abrufen können, etwa für die ausgewählte Stadt oder das ausgewählte Konto.

import WidgetKit
// AppIntentTimelineProvider adds the configuration:
//   func timeline(for configuration: MyIntent,
//                 in context: Context)
//       async -> Timeline<Entry>
let configurable = "intent-aware provider"
_ = configurable

Den Provider zusammensetzen

Ein vollständiger Provider bietet einen sofort verfügbaren Platzhalter, einen schnellen Snapshot, der Vorschauen berücksichtigt, sowie eine Timeline mit vorab erstellten Einträgen und einer passenden Aktualisierungsrichtlinie. So bleibt das Widget innerhalb des Systembudgets aktuell.

import WidgetKit
// 1. placeholder -> instant dummy
// 2. getSnapshot -> sample when isPreview, else current
// 3. getTimeline -> [entries] + .atEnd or .after
let summary = "three methods, one current widget"
_ = summary

Schnelltest

Rufen Sie sich die Einschränkung für die Platzhalter-Methode ins Gedächtnis.

Zusammenfassung

Sie haben Timeline-Provider kennengelernt:

  • placeholder gibt sofort Beispieldaten zurück; getSnapshot gibt einen Eintrag zurück (bei isPreview einen Beispiel-Eintrag); getTimeline gibt zukünftige Einträge zusammen mit einer Richtlinie zurück.
  • Die Richtlinien zum Neuladen sind .atEnd, .after(date) oder .never; das Betriebssystem legt ein Budget für tatsächliche Aktualisierungen fest.
  • Erstellen Sie mehrere Einträge vorab und führen Sie asynchrone Abrufe vor dem Abschluss durch.
  • Konfigurierbare Widgets verwenden AppIntentTimelineProvider.

Häufig gestellte Fragen

Ist die Lektion „Timeline-Provider und Snapshots“ kostenlos?

Ja — der vollständige Text von „Timeline-Provider und Snapshots“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Timeline-Provider und Snapshots“?

Stellen Sie Widget-Inhalte im zeitlichen Verlauf bereit. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Timeline-Provider und Snapshots“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Ein WidgetKit-Widget erstellen
  2. Timeline-Provider und Snapshots
  3. Überblick über App Extensions
  4. App Intents und Shortcuts
← Zurück zu Swift Academy