Swift Academy · Leçon

Fournisseurs de chronologie et instantanés

Fournissez le contenu du widget au fil du temps.

Leçon 2 sur 413 étapes

Fournisseurs de chronologie et instantanés est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Le rôle du fournisseur

Un widget ne se met jamais à jour en continu. À la place, un TimelineProvider remet à WidgetKit un calendrier d’entrées pré-rendues, puis le système affiche chacune d’elles au bon moment. Le fournisseur répond à trois questions : espace réservé, instantané et chronologie.

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

Adopter TimelineProvider

Un fournisseur adopte TimelineProvider avec un type Entry associé. Vous implémentez les trois méthodes ; chacune vous fournit un Context décrivant la famille et indiquant s’il s’agit d’un aperçu.

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
}

L’espace réservé

placeholder(in:) doit renvoyer instantanément des données fictives représentatives. Le système l’affiche sous la forme d’un squelette masqué pendant le chargement du widget réel et dans la galerie de widgets. N’effectuez ici aucune opération réseau ou sur disque.

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

L’instantané

getSnapshot fournit une seule entrée pour des situations temporaires, comme l’aperçu de la galerie de widgets. Il doit être renvoyé rapidement. Lorsque context.isPreview vaut true, utilisez des données d’exemple plutôt qu’une récupération lente afin que la galerie s’affiche instantanément.

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 chronologie

getTimeline est le cœur du fonctionnement : vous construisez un tableau d’entrées futures et les regroupez avec une stratégie d’actualisation dans une Timeline. Le système affiche chaque entrée à sa date, puis demande une nouvelle chronologie conformément à la stratégie.

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

Stratégies d’actualisation

La stratégie de rechargement contrôle le moment où WidgetKit demande la prochaine chronologie : .atEnd après la date de la dernière entrée, .after(date) à un moment précis, ou .never jusqu’à ce que vous effectuiez un rechargement manuel. Le système attribue un budget à ces actualisations ; n’attendez donc pas des mises à jour seconde par seconde.

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

Construire les entrées futures

Une approche courante consiste à précalculer les prochaines heures afin que le widget s’actualise sans réveiller votre code à chaque fois. Générez des entrées à intervalles réguliers à partir de maintenant vers le futur, chacune contenant les données correspondant à cet instant.

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
}

Données asynchrones dans la chronologie

Si vous devez récupérer des données sur le réseau, faites-le avant d’appeler la fonction de finalisation. Encapsulez le travail asynchrone dans une Task et n’indiquez la fin qu’une fois les données reçues. Restez rapide : les fournisseurs disposent d’un budget de temps très limité.

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

Pertinence et budget

WidgetKit limite le nombre d’actualisations quotidiennes afin de préserver la batterie. Vous ne pouvez pas imposer des mises à jour fréquentes. Fournissez plusieurs entrées par chronologie et choisissez un délai d’actualisation raisonnable ; utilisez reloadTimelines depuis l’application uniquement lorsque les données changent de manière significative.

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

Fournisseur pour widgets configurables

Pour un widget configuré avec AppIntentConfiguration, utilisez plutôt AppIntentTimelineProvider. Ses méthodes reçoivent l’intention configurée par l’utilisateur, ce qui vous permet de récupérer les données correspondant à l’option choisie (la ville, le compte, etc.).

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

Assembler le fournisseur

Un fournisseur complet fournit un espace réservé instantané, un aperçu rapide tenant compte du mode d’aperçu et une chronologie d’entrées précalculées avec une stratégie de rechargement adaptée — ainsi, le widget reste à jour dans les limites du budget du système.

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

Vérification rapide

Rappelez-vous la contrainte imposée à la méthode d’espace réservé.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez découvert les fournisseurs de chronologie :

placeholder renvoie instantanément des données fictives ; getSnapshot renvoie une entrée (des données d’exemple lorsque isPreview est actif) ; getTimeline renvoie des entrées futures accompagnées d’une stratégie.
Les stratégies de rechargement sont .atEnd, .after(date) ou .never ; le système détermine le budget des actualisations réelles.
Précalculez plusieurs entrées ; effectuez les récupérations asynchrones avant la finalisation.
Les widgets configurables utilisent AppIntentTimelineProvider.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Fournisseurs de chronologie et instantanés » est-elle gratuite ?

Oui — le texte complet de « Fournisseurs de chronologie et instantanés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fournisseurs de chronologie et instantanés » ?

Fournissez le contenu du widget au fil du temps. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Fournisseurs de chronologie et instantanés » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Créer un widget avec WidgetKit
Fournisseurs de chronologie et instantanés
Présentation des extensions d’app
App Intents et raccourcis

← Retour à Swift Academy