Background Fetch : qu'est-ce que c'est, principe de fonctionnement et configuration des mises à jour

Qu'est-ce que Background Fetch dans iOS ?

Background Fetch est une API iOS qui permet à l'application de recevoir périodiquement des données actualisées en arrière-plan. Introduite pour la première fois dans iOS 7 avec le mécanisme Background App Refresh. L'objectif principal est que le contenu soit à jour au moment où l'utilisateur ouvre l'application, sans avoir à attendre le chargement.

Différence avec les notifications push

Les notifications push sont initiées par le serveur — celui-ci envoie un signal à l'appareil, et le système décide s'il faut réveiller l'application. Background Fetch est initié par iOS lui-même en fonction des modèles d'utilisation de l'appareil. Push est plus adapté aux messages urgents, tandis que Fetch est destiné aux mises à jour planifiées de contenu (actualités, fil d'actualités des réseaux sociaux).

Place dans l'écosystème des tâches d'arrière-plan

Background Fetch est l'un des plusieurs mécanismes d'exécution en arrière-plan dans iOS. BGAppRefreshTask (iOS 13+) effectue la même tâche mais avec une planification plus flexible. Background Modes (audio, localisation) sont pour les opérations continues. Silent Push sont des mises à jour initiées par le serveur. Fetch reste pertinent pour les projets prenant en charge iOS 12 et inférieur.

• Background Fetch — périodique, initié par le système, iOS 7+.
• BGAppRefreshTask — périodique, initié par le système, iOS 13+.
• BGProcessingTask — tâches longues, iOS 13+.
• Silent Push — initié par le serveur, iOS 7+.

Comment fonctionne Background Fetch : architecture et cycle de vie

iOS utilise un algorithme d'apprentissage automatique pour déterminer le moment optimal pour réveiller l'application. Le système analyse quand l'utilisateur ouvre habituellement l'application, combien de temps il l'utilise et à quelle fréquence il revient. Sur la base de ces données, iOS calcule les fenêtres pour Background Fetch.

Processus d'exécution de la tâche

Lorsque le système décide de réveiller l'application, il appelle la méthode application(_:performFetchWithCompletionHandler:) dans AppDelegate. L'application doit charger une quantité minimale de nouvelles données et appeler le completion handler avec l'un des trois statuts : .newData (données chargées), .noData (pas de nouvelles données) ou .failed (erreur). Le statut affecte la fréquence des futurs réveils.

Impact du completion handler sur la fréquence des appels

Le statut .newData indique au système que la mise à jour a été utile — iOS peut augmenter la fréquence des réveils. .noData indique qu'il n'y a pas de données — la fréquence reste la même ou diminue. .failed signale un problème — le système réduit la fréquence pour économiser la batterie. L'accent doit être mis sur un statut honnête, et non sur le forçage de .newData.

Configuration de Background Fetch dans un projet Xcode

Pour activer Background Fetch, deux étapes sont nécessaires : activer la capability dans Xcode et définir l'intervalle minimum dans le code. La capability se trouve dans Target — Signing & Capabilities — Background Modes — cocher la case Background Fetch. Sans cette étape, le système ne réveillera pas l'application.

Définition de l'intervalle minimum

La méthode UIApplication.shared.setMinimumBackgroundFetchInterval définit le temps minimum en secondes entre les appels Fetch. La valeur UIApplication.backgroundFetchIntervalMinimum (environ 15 minutes) indique au système de réveiller l'application aussi souvent que possible de manière économe en énergie. Définir l'intervalle dans application(_:didFinishLaunchingWithOptions:) est une pratique standard.

func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey : Any]?
)-> Bool {
    UIApplication.shared.setMinimumBackgroundFetchInterval(
        UIApplication.backgroundFetchIntervalMinimum
    )
    return true
}

Info.plist et capability

Lors de l'activation de Background Fetch dans Xcode, celui-ci met automatiquement à jour Info.plist — ajoute la clé UIBackgroundModes avec la valeur fetch. C'est une étape obligatoire : sans elle, l'application ne recevra pas l'appel performFetchWithCompletionHandler. Vous pouvez vérifier via P list Source ou Build Settings.

Exemples de code Background Fetch en Swift

Voyons une implémentation complète de Background Fetch pour une application d'actualités. L'implémentation inclut le chargement des données, la mise en cache et l'appel du completion handler. Le code s'exécute dans AppDelegate — le seul endroit où le système appelle fetch.

func application(
    _ application: UIApplication,
    performFetchWithCompletionHandler handler: @escaping (UIBackgroundFetchResult) -> Void
) {
    let url = URL(string: "https://api.example.com/latest")!

    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data, error == nil else {
            handler(.failed)
            return
        }

        do {
            let articles = try JSONDecoder().decode([Article].self, from: data)
            cacheArticles(articles)
            handler(articles.isEmpty ? .noData : .newData)
        } catch {
            handler(.failed)
        }
    }.resume()
}

Mise en cache des données chargées

Après avoir chargé les données via Background Fetch, il faut les sauvegarder dans le stockage local — CoreData, UserDefaults ou File Manager. Lors de l'ouverture de l'application, les données doivent déjà être disponibles. Utilisez CoreData avec un contexte d'arrière-plan pour une écriture thread-safe. Après la sauvegarde, mettez à jour l'interface utilisateur sur le thread principal.

func cacheArticles(_ articles: [Article]) {
    let container = NSPersistentContainer(name: "AppModel")
    container.performBackgroundTask { context in
        articles.forEach { article in
            let entity = ArticleEntity(context: context)
            entity.id = Int64(article.id)
            entity.title = article.title
            entity.body = article.body
        }
        try? context.save()
    }
}

Tester Background Fetch

Pour les tests, utilisez le Simulateur — sélectionnez Debug — Simulate Background Fetch dans Xcode. Sur un appareil physique, vous devez attendre que le système décide d'effectuer un fetch. Pour accélérer, vous pouvez définir l'intervalle minimum à 1 minute, mais le système peut l'ignorer lorsque la batterie est faible.

Limitations et pièges

Background Fetch a plusieurs limitations importantes à prendre en compte lors de la conception de l'architecture de l'application. La principale est que le système contrôle entièrement la fréquence des appels et que le développeur ne peut pas la garantir. Même avec un intervalle minimum défini, le système peut ne pas appeler fetch pendant des heures.

Limite de temps d'exécution

Le système alloue un temps limité à l'application pour exécuter la tâche — généralement jusqu'à 30 secondes. Si l'application n'appelle pas le completion handler dans ce délai, le système termine le processus de force et réduit la fréquence des futurs réveils. Toutes les requêtes réseau doivent être compactes — pas plus de 1-2 par appel.

Dépendance à la batterie

iOS tient compte du niveau de batterie lors de la planification de Background Fetch. Lorsque la charge est inférieure à 20 %, la fréquence des réveils diminue. Lorsque le Mode faible consommation est activé, le système peut désactiver complètement les mises à jour en arrière-plan pour toutes les applications. L'utilisateur peut également désactiver Background App Refresh pour une application spécifique dans les réglages.

Limitations réseau

URLSession lancée depuis Background Fetch fonctionne en mode standard — sans support des sessions d'arrière-plan. Pour les téléchargements volumineux, utilisez URLSession avec configuration d'arrière-plan. Le système continuera le téléchargement même après la fin du fetch, mais la progression ne sera pas suivie jusqu'au prochain réveil.

Migration de Background Fetch vers BGTaskScheduler

À partir d'iOS 13, Apple recommande BGTaskScheduler comme remplacement de Background Fetch. BGTaskScheduler offre une planification plus flexible, deux types de tâches (refresh et processing) et un enregistrement des tâches avec identifiants. La migration comprend plusieurs étapes et est recommandée pour tous les nouveaux projets.

Migration étape par étape

La première étape consiste à définir les identifiants de tâches dans Info.plist via la clé BGTaskSchedulerPermittedIdentifiers. La deuxième est d'enregistrer les tâches dans AppDelegate via BGTaskScheduler.shared.register. La troisième est de remplacer l'appel performFetchWithCompletionHandler par le handler passé à register. La quatrième est d'appeler submit pour planifier la tâche.

// Avant (Background Fetch)
UIApplication.shared.setMinimumBackgroundFetchInterval(
    UIApplication.backgroundFetchIntervalMinimum
)

// Après la migration (BGTaskScheduler)
BGTaskScheduler.shared.register(
    forTaskWithIdentifier: "com.example.refresh",
    using: nil
) { task in
    self.handleAppRefresh(task: task as! BGAppRefreshTask)
}

let request = BGAppRefreshTaskRequest(
    identifier: "com.example.refresh"
)
request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
try? BGTaskScheduler.shared.submit(request)

Avantages de BGTaskScheduler

BGTaskScheduler offre plus de contrôle : BGProcessingTask pour les opérations longues (jusqu'à 10 minutes), des conditions d'exécution via requiresNetworkConnectivity et requiresExternalPower, et un expiration handler pour une terminaison en douceur. Le système analyse également l'utilisation de l'application, mais le développeur peut définir des exigences plus précises.

Quand conserver Background Fetch

Si l'application prend en charge iOS 12 et inférieur, Background Fetch reste la seule option pour les mises à jour périodiques. BGTaskScheduler n'est disponible qu'à partir d'iOS 13+. Dans ce cas, utilisez un wrapper : vérifiez la disponibilité via if #available(iOS 13, *) et appelez l'API appropriée.