NWPathMonitor : ce que c’est, surveillance réseau et travail dans iOS

Qu’est-ce que NWPathMonitor ?

NWPathMonitor est une classe du framework Network introduite par Apple dans iOS 12 et macOS 10.14 Mojave. Elle fournit une API moderne pour suivre les changements dans le chemin réseau de l’appareil — la combinaison d’interfaces réseau à travers lesquelles le trafic de l’application transite.

Avant iOS 12, la bibliothèque Reachability construite sur le framework SystemConfiguration en C était utilisée pour la surveillance réseau. NWPathMonitor est une alternative native en Swift avec une API plus riche, une prise en charge des types de connexion modernes (VPN, multipath, LTE, 5G) et une intégration intégrée avec GCD.

La différence clé entre NWPathMonitor et Reachability — l’objet NWPath fournit non seulement un statut binaire « disponible/indisponible », mais une image complète du chemin : interfaces utilisées, leur priorité, coûts, statut d’itinérance et capacités proxy et VPN. Le développeur obtient des informations complètes pour prendre des décisions sur les requêtes réseau.

Historique du framework Network

Le framework Network est apparu comme un remplacement moderne des API C de bas niveau — CFStream et BSD Sockets. Il fournit une interface unifiée pour la communication réseau sur toutes les plateformes Apple, y compris watchOS et tvOS. NWPathMonitor fait partie de ce framework aux côtés de NWConnection, NWListener et NWBrowser.

Le framework Network est écrit en Swift et utilise GCD pour le traitement asynchrone. Cela signifie que les callbacks de NWPathMonitor s’exécutent sur la dispatch queue spécifiée, s’intégrant à l’architecture de multithreading existante de l’application sans gestion manuelle des threads.

Comment utiliser NWPathMonitor dans une application

L’utilisation de NWPathMonitor commence par la création d’une instance de classe et la configuration du callback pathUpdateHandler. Ensuite, la méthode start est appelée avec une dispatch queue où la closure s’exécutera. La surveillance est arrêtée par la méthode cancel, qui libère également les ressources.

import Network

class NetworkMonitor {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue("monitor")

    func startMonitoring() {
        monitor.pathUpdateHandler = { path in
            if path.status == .satisfied {
                print("Réseau disponible")
            } else {
                print("Réseau indisponible")
            }
        }
        monitor.start(on: queue)
    }

    func stopMonitoring() {
        monitor.cancel()
    }
}

Travail avec le type d’interface

NWPathMonitor peut être configuré pour surveiller uniquement un type d’interface spécifique. Utilisez l’initialiseur NWPathMonitor(requiredInterfaceType:) avec le paramètre NWInterface.InterfaceType — .wifi, .cellular, .wiredEthernet ou .loopback. Si aucun type n’est spécifié, la surveillance couvre toutes les interfaces.

Exemple pratique : une application de streaming peut surveiller uniquement le Wi-Fi et avertir l’utilisateur du passage aux données cellulaires. Vérifier isConstrained et isExpensive dans NWPath permet de déterminer si la connexion actuelle est facturée ou limitée en vitesse.

Cycle de vie de la surveillance

La surveillance doit démarrer au lancement de l’application ou lors du passage au premier plan, et s’arrêter lors du passage en arrière-plan. Il est recommandé de créer une seule instance de NWPathMonitor pour toute l’application (singleton) et de l’utiliser depuis différents modules via un protocole ou une couche de service.

Propriétés et capacités de NWPath

NWPath est un objet transmis à pathUpdateHandler qui décrit l’état actuel du chemin réseau. Il contient cinq propriétés clés couvrant la plupart des scénarios de surveillance réseau. NWPath.Status — une énumération avec trois états : satisfied (disponible), unsatisfied (indisponible) et requiresConnection (nécessite une connexion).

Vérification des coûts et restrictions

La propriété isExpensive est un indicateur critique pour les applications traitant de grands volumes de données. Si isExpensive = true, l’application doit réduire la qualité du streaming, reporter les téléchargements de mises à jour ou avertir l’utilisateur. isConstrained indique que le Low Data Mode est activé.

Pour vérifier la disponibilité Internet (pas seulement le réseau), utilisez la méthode usesInterfaceType. Si l’appareil est connecté au Wi-Fi sans Internet — NWPath peut afficher satisfied, mais l’accès réel est absent. Dans ces cas, une validation supplémentaire via NWConnection est nécessaire.

Exemples d’implémentation de NWPathMonitor

Examinons une implémentation avancée de NWPathMonitor avec gestion des coûts, types d’interface et notification ViewModel via un publisher. L’exemple utilise le framework Combine pour les mises à jour réactives de l’interface utilisateur lors des changements d’état du réseau.

import Network
import Combine

final class NetworkManager: ObservableObject {
    static let shared = NetworkManager()
    @Published private(set) var isConnected = true
    @Published private(set) var isExpensive = false

    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue("NetworkMonitor")

    private init() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
                self?.isExpensive = path.isExpensive
            }
        }
        monitor.start(on: queue)
    }

    func checkInterface() -> NWInterface.InterfaceType {
        let path = monitor.currentPath
        if path.usesInterfaceType(.wifi) { return .wifi }
        if path.usesInterfaceType(.cellular) { return .cellular }
        return .other
    }
}

Gestion de la perte de réseau avec action différée

Lorsque la connexion est perdue, il peut être nécessaire non seulement d’informer l’interface utilisateur, mais aussi d’effectuer des actions différées — par exemple, enregistrer un brouillon de requête pour un envoi ultérieur. Implémentez une file d’attente de requêtes différées qui accumule les opérations pendant le statut unsatisfied et les envoie lorsque satisfied est rétabli.

Le modèle ReachabilityManager avec délégation est idéal pour cette tâche : NWPathMonitor notifie le gestionnaire, le gestionnaire met à jour la file d’attente et l’interface utilisateur. Lorsque le statut passe à satisfied, la file d’attente se vide automatiquement et l’interface utilisateur reçoit une indication de restauration de la connexion.

NWPathMonitor vs Reachability

Avant NWPathMonitor, la solution standard pour la surveillance réseau dans iOS était la bibliothèque Reachability d’Apple (exemple de la documentation), construite sur SystemConfiguration. Les principales différences : Reachability fonctionne via SCNetworkReachability en C, ne prend pas en charge les types de réseau modernes et fournit seulement une réponse binaire de disponibilité.

NWPathMonitor résout ces limitations : il est écrit en Swift, prend en charge VPN, multipath, 5G et LTE, fournit des informations détaillées sur chaque interface et fonctionne de manière asynchrone via GCD. Reachability est toujours utilisé dans les projets prenant en charge iOS 11 et inférieur.

Quand utiliser Reachability

Si votre application prend en charge iOS 11 et inférieur, Reachability reste la seule option. Pour les projets iOS 12+, il est recommandé d’utiliser directement NWPathMonitor — il s’intègre mieux avec le code Swift moderne, Combine et SwiftUI.

La migration de Reachability vers NWPathMonitor est simple : il suffit de remplacer les appels SCNetworkReachability par NWPathMonitor, en conservant la même logique de traitement. Une couche d’abstraction (NetworkMonitorProtocol) permettra de basculer entre les implémentations sans modifier la logique métier de l’application.