WidgetKit — qu'est-ce que c'est, framework de widgets et SwiftUI

Qu'est-ce que WidgetKit et comment fonctionne-t-il ?

WidgetKit est un framework Apple pour créer des widgets qui affichent du contenu sur les écrans système des appareils Apple. Un widget est une représentation miniature de votre application que l'utilisateur place sur l'écran d'accueil en mode jiggle. Contrairement aux complications watchOS qui existaient avant WidgetKit, le nouveau framework a unifié la création de widgets pour toutes les plateformes Apple via une API unique basée sur SwiftUI.

Le principe de fonctionnement de WidgetKit est basé sur TimelineProvider — un objet qui crée un tableau ordonné de TimelineEntry, où chaque entrée contient un Snapshot (un état spécifique du widget à un moment donné). Le système affiche les entrées séquentiellement, mettant à jour le widget lors du passage à l'entrée suivante sur la timeline. Entre les entrées, WidgetKit n'appelle pas le code de l'application — le temps CPU est consommé uniquement lors de la création d'une nouvelle Timeline.

Selon la session WWDC 2024 « WidgetKit : What’s new », l'utilisateur iOS moyen a 8–12 widgets sur son écran d'accueil, les catégories les plus populaires étant la météo, l'heure, le calendrier, le fitness et la finance. WidgetKit consomme moins de 1% de charge de batterie par jour en utilisation typique grâce à des mises à jour planifiées plutôt qu'en temps réel.

Ce qui distingue WidgetKit des anciennes Today Extensions

Avant iOS 14, les widgets existaient uniquement sous forme de Today View — un panneau accessible en balayant vers la gauche depuis le premier écran. Les Today Extensions avaient des limitations sérieuses : elles n'étaient disponibles que sur l'écran « Aujourd'hui », nécessitaient d'ouvrir l'application pour mettre à jour le contenu et avaient un support de tailles limité. WidgetKit a complètement remplacé les Today Extensions, offrant des widgets sur l'écran d'accueil, l'écran de verrouillage (iOS 16+) et le bureau du Mac.

• Widgets sur l'écran d'accueil, pas seulement dans Today View
• Mise à jour autonome via TimelineProvider, sans ouvrir l'application
• Trois tailles prédéfinies au lieu d'une
• Smart Rotate et Smart Stack — rotation automatique des widgets par le système
• API unifiée en SwiftUI pour toutes les plateformes Apple

Architecture de WidgetKit : TimelineProvider et Entry

L'architecture de WidgetKit repose sur trois protocoles clés : TimelineProvider, TimelineEntry et Widget. TimelineEntry est un modèle de données représentant l'état du widget à un moment spécifique. TimelineProvider crée un tableau de ces entrées (Timeline), en spécifiant la date d'activation pour chacune. Widget est le point d'entrée qui connecte le fournisseur à la vue SwiftUI.

La méthode Timeline getTimeline est appelée par le système lors du premier ajout du widget, puis périodiquement — généralement toutes les 1–6 heures selon le type de fournisseur. Une Timeline peut contenir des entrées pour des heures ou des jours à l'avance, permettant au widget de fonctionner sans appeler le code de l'application entre les mises à jour. Si une mise à jour urgente est nécessaire (par exemple, changement de taux de change), l'application peut appeler WidgetCenter.shared.reloadAllTimelines() de manière forcée.

TimelineProvider de base

struct SimpleEntry: TimelineEntry {
    let date: Date
    let value: Double
}

struct Provider: TimelineProvider {
    typealias Entry = SimpleEntry
    
    func placeholder(in context: Context) -> Entry {
        Entry(date: Date(), value: 0)
    }
    
    func getSnapshot(
        in context: Context,
        completion: @escaping (Entry) -> Void
    ) {
        Entry(date: Date(), value: 42.5)
    }
    
    func getTimeline(
        in context: Context,
        completion: @escaping (Timeline<Entry>, Error?) -> Void
    ) {
        let entry = Entry(date: Date(), value: fetchLatestValue())
        let nextUpdate = Calendar.current
            .date(byAdding: .hour, value: 1, to: Date())!
        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
        completion(timeline, nil)
    }
}

Widget Family : small, medium, large

WidgetKit prend en charge trois tailles de widgets, chacune avec des proportions fixes. Small (170×170 pt sur iPhone) affiche des informations compactes — une valeur unique, une icône ou un texte court. Medium (364×170 pt) est deux fois plus large que small et convient pour afficher des paires de valeurs ou des mini-graphiques. Large (364×382 pt) occupe près de la moitié de l'écran verticalement et permet d'afficher des tableaux, des listes ou des données développées.

Le développeur doit prendre en charge au moins deux tailles — Apple recommande small + medium. Le widget Large n'est nécessaire que si l'application a suffisamment de contenu pour remplir ce volume. Chaque taille obtient sa propre vue SwiftUI, que WidgetKit rend sur l'écran système. Il est important que WidgetKit ne prend pas en charge les tailles personnalisées — seulement trois tailles fixes, garantissant l'uniformité de l'interface.

Configuration des tailles via WidgetConfiguration

struct WeatherWidget: Widget {
    let kind: String = "WeatherWidget"
    
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            WeatherWidgetView(entry: entry)
        }
        .configurationDisplayName("Weather")
        .description("Current temperature and forecast")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

Types de configuration des widgets : Static et Intent

WidgetKit propose deux types de configuration — StaticConfiguration et IntentConfiguration. StaticConfiguration convient aux widgets qui affichent le même contenu pour tous les utilisateurs : taux de change, météo, calendrier. IntentConfiguration permet à l'utilisateur de personnaliser le widget lors de son ajout via le système d'intents Siri — par exemple, sélectionner une ville spécifique pour la météo ou un ticker spécifique pour le cours des actions.

IntentConfiguration utilise INWidgetIntent — une sous-classe d'INIntent de SiriKit. Lorsque l'utilisateur ajoute un widget et sélectionne des paramètres (ex. : ville), le système sauvegarde cet intent et le transmet à TimelineProvider à chaque mise à jour. Le fournisseur reçoit l'intent dans la méthode getTimeline et utilise ses paramètres pour former le contenu. IntentConfiguration est l'approche préférée pour les widgets personnalisés car il s'intègre avec Siri et Shortcuts.

IntentConfiguration avec sélection de paramètres

struct WeatherWidgetEntryView: View {
    var entry: WeatherEntry
    
    var body: some View {
        VStack(alignment: .leading) {
            Text(entry.cityName)
                .font(.caption)
                .foregroundColor(.secondary)
            Text("\(entry.temperature)°C")
                .font(.largeTitle)
        }
    }
}

struct WeatherWidget: Widget {
    var body: some WidgetConfiguration {
        IntentConfiguration(
            kind: "WeatherWidget",
            intent: WeatherConfigIntent.self,
            provider: WeatherTimelineProvider()
        ) { entry in
            WeatherWidgetEntryView(entry: entry)
        }
    }
}

Création d'un widget en SwiftUI : exemple étape par étape

La création d'un widget commence par l'ajout d'un Widget Extension Target dans Xcode : File → New → Target → Widget Extension. Xcode génère automatiquement une structure avec TimelineEntry, TimelineProvider et WidgetConfiguration. Le développeur n'a plus qu'à implémenter la vue SwiftUI pour afficher les données et configurer le fournisseur pour un calendrier de mise à jour correct.

Voici un exemple complet d'un widget simple pour afficher le prix actuel du Bitcoin : Provider charge le taux via URLSession et crée une Timeline avec des mises à jour toutes les heures. WidgetSwiftUIView affiche le taux en grande police et l'heure de la dernière mise à jour en petite police.

struct BTCPriceEntry: TimelineEntry {
    let date: Date
    let price: Double
    let change24h: Double
}

struct BTCWidgetEntryView: View {
    var entry: BTCPriceEntry
    
    var body: some View {
        VStack {
            Text("BTC/USD").font(.caption)
            Text("$\(entry.price, specifier: "%.0f")")
                .font(.title2).fontWeight(.bold)
            Text(entry.change24h > 0 ? "+" : "")
        }
    }
}

Widgets d'écran de verrouillage iOS 16+

Avec iOS 16, WidgetKit a étendu la prise en charge à l'écran de verrouillage — l'écran de verrouillage de l'iPhone. Les widgets d'écran de verrouillage sont de deux types : inline (une seule ligne de texte sous l'horloge) et rectangular (une zone rectangulaire). Contrairement aux widgets de l'écran d'accueil, les widgets d'écran de verrouillage sont mis à jour plus fréquemment — le déclencheur système permet des mises à jour toutes les 15–30 minutes pour afficher des informations actuelles sans déverrouiller le téléphone.

Les widgets d'écran de verrouillage nécessitent une configuration séparée via WidgetConfiguration avec accessoryFamilies : accessoryCircular, accessoryRectangular, accessoryInline. Ces familles ont des limitations strictes de taille et de contenu — elles ne supportent pas les images, les animations ou les polices personnalisées. Apple recommande d'utiliser uniquement des informations textuelles et les icônes système SF Symbols pour les widgets d'écran de verrouillage.

• accessoryCircular — widget circulaire compact pour la zone sous l'horloge
• accessoryRectangular — widget rectangulaire pour la zone au-dessus de l'horloge
• accessoryInline — texte d'une ligne sous l'heure, taille minimale
• Limitations : texte uniquement, SF Symbols, dégradés ; pas d'images ni de vidéo

Bonnes pratiques et limitations de WidgetKit

Lors du développement de widgets, il est important de prendre en compte les limitations de WidgetKit. Les widgets sont des vues en lecture seule : ils ne gèrent pas les événements tactiles (sauf un tap qui ouvre l'application). Les widgets ne supportent pas l'animation, la vidéo, la saisie au clavier, le défilement ou les éléments interactifs. Chaque widget est un instantané statique de données à un moment donné, et tenter d'ajouter de l'interactivité entraînera le rejet de l'application sur l'App Store.

Les bonnes pratiques incluent l'utilisation de Widget Center pour les mises à jour forcées, la mise en cache des données au niveau de TimelineProvider pour une réponse rapide et l'utilisation de placeholders pour l'état initial. Il est également important de prendre en charge plusieurs tailles — les utilisateurs s'attendent à ce que le widget soit disponible à la fois en variante small et medium. Évitez rigoureusement d'afficher des données inexactes ou obsolètes — les utilisateurs se souviennent longtemps des informations incorrectes provenant des widgets.

Tableau des limitations de WidgetKit