Swift Academy · Leçon

Tâches et actualisation en arrière-plan

Planifiez le travail en arrière-plan avec BGTaskScheduler.

Leçon 3 sur 413 étapes

Tâches et actualisation en arrière-plan est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Pourquoi les tâches en arrière-plan existent

iOS suspend agressivement les apps pour économiser la batterie. Pour effectuer un travail utile en arrière-plan — actualiser un flux ou traiter un téléchargement — vous le planifiez avec BGTaskScheduler. Le système décide quand l’exécuter, en équilibrant vos besoins avec la consommation d’énergie et les habitudes d’utilisation.

import BackgroundTasks
// You request work; the system schedules it later
// at an opportune moment (charging, on Wi-Fi, etc.)

Deux types de tâches

Il en existe deux types : BGAppRefreshTask pour les mises à jour courtes et fréquentes (quelques secondes), et BGProcessingTask pour les opérations plus longues et plus lourdes (quelques minutes), comme la maintenance d’une base de données, avec la possibilité d’exiger une alimentation externe ou une connexion réseau.

import BackgroundTasks
// BGAppRefreshTask  -> quick content refresh
// BGProcessingTask  -> long maintenance, can require
//                      external power / network

Déclaration des identifiants

Chaque tâche nécessite un identifiant unique que vous devez inscrire dans Info.plist, sous BGTaskSchedulerPermittedIdentifiers. Sans cette déclaration, l’inscription échoue. Utilisez des chaînes au format DNS inversé.

// Info.plist:
// BGTaskSchedulerPermittedIdentifiers = [
//   "com.example.app.refresh",
//   "com.example.app.cleanup"
// ]
let ids = "declare every identifier in Info.plist"
_ = ids

Enregistrer un gestionnaire

Au lancement, enregistrez un gestionnaire pour chaque identifiant avec BGTaskScheduler.shared.register. Cela doit se produire avant la fin du lancement de l’app. Le gestionnaire est exécuté lorsque le système décide ensuite de lancer la tâche.

import BackgroundTasks
func registerTasks() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: "com.example.app.refresh",
        using: nil) { task in
        handleRefresh(task as! BGAppRefreshTask)
    }
}

Envoyer une requête

L’inscription ne fait que configurer le gestionnaire. Pour demander réellement une exécution, construisez un BGAppRefreshTaskRequest, définissez la date de début la plus proche et envoyez-la avec submit. Le système considère cette date comme une indication, et non comme une garantie.

import BackgroundTasks
func scheduleRefresh() {
    let request = BGAppRefreshTaskRequest(
        identifier: "com.example.app.refresh")
    request.earliestBeginDate = Date(
        timeIntervalSinceNow: 15 * 60)
    try? BGTaskScheduler.shared.submit(request)
}

Toujours reprogrammer

Une requête envoyée ne s’exécute qu’une seule fois au maximum. Pour continuer les actualisations, votre gestionnaire doit envoyer la prochaine requête avant de se terminer. Reprogrammez-la d’abord, puis effectuez le travail, afin qu’un plantage en cours d’opération n’interrompe pas le cycle.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh() // queue the next run first
    // ... then perform this run's work
}

Signaler la fin

Vous devez appeler task.setTaskCompleted(success:) une fois le travail terminé. Oublier cet appel gaspille votre budget d’exécution en arrière-plan et peut réduire la priorité des tâches futures. Indiquez si l’opération a réussi afin que le système puisse adapter la planification.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    Task {
        let ok = await fetchLatest()
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Respecter le gestionnaire d’expiration

Le système peut récupérer du temps avant l’échéance. Définissez task.expirationHandler pour annuler le travail en cours et effectuer le nettoyage nécessaire, afin de quitter proprement si l’exécution est interrompue. Considérez-le comme une alarme de délai.

import BackgroundTasks
func handle(_ task: BGAppRefreshTask) {
    let work = Task { await fetchLatest() }
    task.expirationHandler = {
        work.cancel() // stop before the OS suspends us
    }
}
func fetchLatest() async -> Bool { true }

Traiter des tâches avec des exigences

Pour les opérations lourdes, BGProcessingTaskRequest vous permet de définir requiresNetworkConnectivity et requiresExternalPower. Le système attend que ces conditions soient réunies, de sorte que les tâches longues puissent s’exécuter pendant que l’appareil se recharge durant la nuit, connecté au Wi-Fi.

import BackgroundTasks
func scheduleCleanup() {
    let req = BGProcessingTaskRequest(
        identifier: "com.example.app.cleanup")
    req.requiresExternalPower = true
    req.requiresNetworkConnectivity = false
    try? BGTaskScheduler.shared.submit(req)
}

Tester dans le débogueur

Vous n’aurez pas à attendre des heures que le système planifie la tâche. Mettez l’exécution en pause dans le débogueur et lancez une commande LLDB pour forcer le démarrage immédiat d’une tâche enregistrée, afin de vérifier le gestionnaire de bout en bout.

// In LLDB while paused:
// e -l objc -- (void)[[BGTaskScheduler sharedScheduler]
//   _simulateLaunchForTaskWithIdentifier:
//   @"com.example.app.refresh"]
let test = "force-launch task via LLDB"
_ = test

Un cycle complet d’actualisation

Pour tout assembler : enregistrez la tâche au lancement, envoyez la requête en arrière-plan et, dans le gestionnaire, reprogrammez l’exécution, protégez-la avec un gestionnaire d’expiration, effectuez le travail asynchrone et signalez la fin.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    let work = Task { await fetchLatest() }
    task.expirationHandler = { work.cancel() }
    Task {
        let ok = await work.value
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Vérification rapide

Rappelez-vous le cycle de vie d’une tâche d’actualisation récurrente.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris à planifier des tâches en arrière-plan :

BGAppRefreshTask pour les actualisations courtes, et BGProcessingTask pour la maintenance longue avec des exigences d’alimentation ou de réseau.
Déclarez les identifiants dans Info.plist, enregistrez les gestionnaires au lancement avec register, puis envoyez les requêtes avec submit et une earliestBeginDate.
Reprogrammez la prochaine exécution dans le gestionnaire, définissez un expirationHandler et appelez toujours setTaskCompleted.
Forcez le lancement des tâches avec LLDB pour les tester.

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 « Tâches et actualisation en arrière-plan » est-elle gratuite ?

Oui — le texte complet de « Tâches et actualisation en arrière-plan » 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 « Tâches et actualisation en arrière-plan » ?

Planifiez le travail en arrière-plan avec BGTaskScheduler. 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 3 sur 4.

Combien de temps prend la leçon « Tâches et actualisation en arrière-plan » ?

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

S’inscrire aux notifications push
Gérer les charges utiles des notifications
Tâches et actualisation en arrière-plan
Actions et catégories de notifications

← Retour à Swift Academy