Swift Academy · Lektion

Tidslinjeleverantörer och ögonblicksbilder

Tillhandahåll widgetinnehåll över tid.

Lektion 2 av 413 steg

Tidslinjeleverantörer och ögonblicksbilder är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Providerns uppgift

En widget uppdateras aldrig kontinuerligt av sig själv. I stället överlämnar en TimelineProvider ett schema med förrenderade poster till WidgetKit, och systemet visar varje post vid rätt tidpunkt. Providern besvarar tre frågor: platshållare, ögonblicksbild och tidslinje.

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

Implementera TimelineProvider

En provider implementerar TimelineProvider-protokollet med en associerad Entry-typ. Du implementerar de tre metoderna; var och en ger Dig en Context som beskriver familjen och om det är en förhandsvisning.

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
}

Platshållaren

placeholder(in:) måste returnera representativa exempeldata omedelbart. Systemet visar den som en maskerad skelettvy medan den riktiga widgeten läses in och i widgetgalleriet. Utför aldrig nätverks- eller diskåtkomst här.

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

Snapshoten

getSnapshot tillhandahåller en enda post för tillfälliga situationer, till exempel förhandsvisningen i widgetgalleriet. Den bör returneras snabbt. När context.isPreview är true ska Du använda exempeldata i stället för en långsam hämtning, så att galleriet känns omedelbart.

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())
    }
}

Tidslinjen

getTimeline är kärnan: Du bygger en array med framtida poster och paketerar den med en uppdateringspolicy i en Timeline. Systemet renderar varje post vid dess tidpunkt och ber sedan om en ny tidslinje enligt policyn.

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

Uppdateringspolicyer

Uppdateringspolicyn styr när WidgetKit begär nästa tidslinje: .atEnd efter den sista postens tidpunkt, .after(date) vid en specifik tidpunkt eller .never tills Du uppdaterar manuellt. Systemet begränsar dessa uppdateringar, så förvänta Dig inte uppdateringar sekund för sekund.

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

Skapa framtida poster

En vanlig metod är att förberäkna de närmaste timmarna så att widgeten uppdateras utan att väcka koden varje gång. Generera poster med intervall från nu och framåt, där varje post innehåller de data som gäller vid den tidpunkten.

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
}

Asynkrona data i tidslinjen

Om Du måste hämta data från nätverket gör Du det innan completion anropas. Omslut det asynkrona arbetet i en Task och anropa completion först när data har kommit. Håll det snabbt – providrar har en snäv tidsbudget.

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")
}

Relevans och budget

WidgetKit begränsar hur ofta det uppdateras per dag för att spara batteri. Du kan inte tvinga fram täta uppdateringar. Tillhandahåll flera poster per tidslinje och välj en rimlig tidpunkt för nästa uppdatering. Använd reloadTimelines från appen endast vid meningsfulla dataändringar.

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 konfigurerbara widgetar

För en widget med AppIntentConfiguration använder Du i stället AppIntentTimelineProvider. Metoderna tar emot användarens konfigurerade intent, så att Du kan hämta data för det valda alternativet (den valda staden, det valda kontot och så vidare).

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

Sätt ihop providern

En komplett provider ger en omedelbar platshållare, en snabb ögonblicksbild som tar hänsyn till förhandsvisning och en tidslinje med färdigskapade poster samt en lämplig uppdateringspolicy – så att widgeten hålls aktuell inom systemets budget.

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

Snabb kontroll

Kom ihåg begränsningen för platshållarmetoden.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig om tidslinjeproviders:

placeholder returnerar omedelbara exempeldata, getSnapshot returnerar en post (exempeldata när isPreview är true) och getTimeline returnerar framtida poster samt en policy.
Uppdateringspolicyerna är .atEnd, .after(date) eller .never; operativsystemet begränsar de faktiska uppdateringarna.
Förbered flera poster i förväg och utför asynkrona hämtningar innan Du slutför.
Konfigurerbara widgetar använder AppIntentTimelineProvider.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Tidslinjeleverantörer och ögonblicksbilder” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Tidslinjeleverantörer och ögonblicksbilder”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Tidslinjeleverantörer och ögonblicksbilder”?

Tillhandahåll widgetinnehåll över tid. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Tidslinjeleverantörer och ögonblicksbilder”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Bygga en WidgetKit-widget
Tidslinjeleverantörer och ögonblicksbilder
Översikt över apputökningar
App Intents och Shortcuts

← Tillbaka till Swift Academy