0Pricing
Swift Academy · Lezione

Provider e snapshot delle timeline

Fornisca i contenuti del widget nel tempo.

Provider e snapshot delle timeline è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Il compito del provider

Un widget non si aggiorna mai continuamente da solo. Piuttosto, un TimelineProvider consegna a WidgetKit una pianificazione di entry pre-renderizzate e il sistema visualizza ciascuna al momento giusto. Il provider risponde a tre domande: placeholder, snapshot e timeline.

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

Conformità a TimelineProvider

Un provider è conforme a TimelineProvider con un tipo Entry associato. Implementi i tre metodi; ciascuno le fornisce un Context che descrive la famiglia e indica se si tratta di un'anteprima.

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
}

Il placeholder

placeholder(in:) deve restituire dati fittizi rappresentativi istantaneamente. Il sistema lo mostra come una struttura scheletrica con contenuto oscurato mentre il widget reale viene caricato e nella galleria dei widget. Non esegua qui operazioni di rete o su disco.

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

Lo snapshot

getSnapshot fornisce una singola entry per situazioni transitorie come l'anteprima nella galleria dei widget. Dovrebbe restituirla rapidamente. Quando context.isPreview è true, utilizzi dati di esempio invece di un recupero lento, così la galleria risulta immediata.

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

La timeline

getTimeline è il cuore del sistema: costruisca un array di entry future e lo associ a una politica di aggiornamento in una Timeline. Il sistema esegue il rendering di ogni entry alla relativa data, poi richiede una nuova timeline secondo la politica.

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

Politiche di aggiornamento

La politica di ricaricamento controlla quando WidgetKit richiede la timeline successiva: .atEnd dopo la data dell'ultima entry, .after(date) a un'ora specifica oppure .never finché non esegue manualmente un aggiornamento. Il sistema gestisce queste operazioni entro un budget, quindi non si aspetti aggiornamenti secondo per secondo.

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

Creazione di entry future

Un approccio comune consiste nel precalcolare le ore successive, così il widget si aggiorna senza riattivare il codice ogni volta. Generi entry a intervalli da questo momento in poi, ognuna contenente i dati relativi a quel momento.

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
}

Dati asincroni nella timeline

Se deve recuperare dati dalla rete, lo faccia prima di chiamare completion. Racchiuda il lavoro asincrono in un Task e completi l'operazione solo quando arrivano i dati. Mantenga l'operazione rapida: i provider dispongono di un budget di tempo molto ristretto.

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

Rilevanza e budget

WidgetKit limita la frequenza degli aggiornamenti giornalieri per proteggere la batteria. Non può forzare aggiornamenti frequenti. Fornisca diverse entry per ogni timeline e scelga un momento ragionevole per il ricaricamento; utilizzi reloadTimelines dall'app solo quando i dati cambiano in modo significativo.

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 per widget configurabili

Per un widget con AppIntentConfiguration, utilizzi invece AppIntentTimelineProvider. I suoi metodi ricevono l'intent configurato dall'utente, così può recuperare i dati relativi all'opzione scelta (la città, l'account e così via).

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

Composizione del provider

Un provider completo offre un placeholder istantaneo, uno snapshot rapido che tiene conto dell'anteprima e una timeline di entry precostruite con un'appropriata politica di ricaricamento, così il widget rimane aggiornato entro il budget del sistema.

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

Verifica rapida

Ricordi il vincolo imposto al metodo placeholder.

Riepilogo

Ha imparato a usare i provider delle timeline:

  • placeholder restituisce dati fittizi istantaneamente; getSnapshot restituisce una entry (di esempio quando isPreview è attivo); getTimeline restituisce entry future insieme a una politica.
  • Le politiche di ricaricamento sono .atEnd, .after(date) o .never; il sistema operativo gestisce la frequenza effettiva degli aggiornamenti.
  • Precostruisca più entry ed esegua i recuperi asincroni prima di completare l'operazione.
  • I widget configurabili utilizzano AppIntentTimelineProvider.

Domande Frequenti

La lezione «Provider e snapshot delle timeline» è gratuita?

Sì — il testo completo di «Provider e snapshot delle timeline» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Provider e snapshot delle timeline»?

Fornisca i contenuti del widget nel tempo. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Provider e snapshot delle timeline»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Creazione di un widget WidgetKit
  2. Provider e snapshot delle timeline
  3. Panoramica delle estensioni delle app
  4. App Intents e Shortcuts
← Torna a Swift Academy