Reachability : qu’est-ce que c’est, bibliothèque de vérification de disponibilité réseau

Qu’est-ce que Reachability ?

Reachability est une bibliothèque d’exemple d’Apple démontrant l’utilisation du framework SystemConfiguration pour la surveillance réseau. Le code source a été publié dans la Documentation Apple Developer comme exemple, mais la communauté l’a adopté comme outil standard de vérification de connectivité dans les projets iOS.

La bibliothèque est basée sur SCNetworkReachability — une fonction C de SystemConfiguration qui évalue l’accessibilité d’un hôte distant ou d’une adresse IP. Lors de la création de Reachability, on spécifie un nom d’hôte (par exemple google.com) ou une adresse IP, et la bibliothèque vérifie de façon asynchrone si cet hôte est accessible via les interfaces réseau actuelles de l’appareil.

La popularité de Reachability tient à sa simplicité : il suffit de créer une instance, de s’abonner aux notifications via NotificationCenter et d’écouter kReachabilityChangedNotification. En réponse, l’application reçoit un statut : NotReachable, ReachableViaWiFi ou ReachableViaWWAN (données cellulaires).

Histoire et statut de la bibliothèque

Reachability est apparue pour la première fois dans iPhone OS 2 (2008) avec le framework SystemConfiguration. Pendant une décennie, elle a été le seul moyen natif de surveiller l’état du réseau sous iOS. Avec la sortie d’iOS 12 et du framework Network, Apple recommande NWPathMonitor comme remplacement, mais Reachability est toujours prise en charge.

De nombreux wrappers tiers — AFNetworking, Alamofire, AshleyDodd/Reachability.swift — utilisent le mécanisme interne de SCNetworkReachability. Ces bibliothèques ajoutent une interface pratique en Swift/Objective-C, la mémoisation du statut et des callbacks thread-safe, tout en conservant la même base SystemConfiguration.

Comment Reachability fonctionne en interne

Le mécanisme principal de Reachability est la fonction SCNetworkReachabilityCreateWithName, qui crée un objet de suivi pour l’hôte spécifié. Ensuite, SCNetworkReachabilityGetFlags est appelée — une vérification synchrone qui renvoie un masque de bits SCNetworkReachabilityFlags avec l’état actuel du réseau.

Pour la surveillance asynchrone, SCNetworkReachabilitySetCallback est utilisé, enregistrant une fonction de rappel C. Le rappel s’exécute sur le RunLoop actuel lorsque l’état d’accessibilité de l’hôte change. Reachability encapsule ce rappel C dans une méthode Objective-C et envoie une notification via NotificationCenter.

import SystemConfiguration

class Reachability {
    private var reachabilityRef: SCNetworkReachability?

    init?(hostname: String) {
        reachabilityRef = SCNetworkReachabilityCreateWithName(
            nil, hostname
        )
    }

    func checkReachability() -> Bool {
        var flags = SCNetworkReachabilityFlags()
        SCNetworkReachabilityGetFlags(
            reachabilityRef!, &flags
        )
        return isReachable(with: flags)
    }

    private func isReachable(with flags: SCNetworkReachabilityFlags) -> Bool {
        let reachable = flags.contains(.reachable)
        let connectionRequired = flags.contains(.connectionRequired)
        return reachable && !connectionRequired
    }
}

Indicateurs d’accessibilité réseau

SCNetworkReachabilityFlags est un masque de bits qui code l’état du réseau. L’indicateur kSCNetworkReachabilityFlagsReachable signale que l’hôte est accessible. kSCNetworkReachabilityFlagsConnectionRequired — une connexion doit être établie. La combinaison des indicateurs détermine si l’application peut envoyer des données.

Indicateurs supplémentaires : kSCNetworkReachabilityFlagsIsWWAN — connexion via le réseau cellulaire (iOS), kSCNetworkReachabilityFlagsInterventionRequired — intervention de l’utilisateur nécessaire (par exemple pour VPN). Reachability prend en compte ces indicateurs pour déterminer le type d’interface.

Exemples d’utilisation de Reachability

Le modèle standard d’utilisation de Reachability dans une application iOS comprend la création d’une instance, l’abonnement aux notifications et la réaction aux changements de statut. L’exemple ci-dessous montre l’intégration avec NotificationCenter pour mettre à jour l’interface utilisateur lors d’un changement de réseau.

import Reachability
import UIKit

class ViewController: UIViewController {
    var reachability: Reachability?

    override func viewDidLoad() {
        super.viewDidLoad()
        reachability = Reachability(hostname: "google.com")
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(reachabilityChanged),
            name: .reachabilityChanged,
            object: nil
        )
        reachability?.startNotifier()
    }

    @objc func reachabilityChanged(notification: Notification) {
        if let reachability = notification.object as? Reachability {
            switch reachability.connection {
            case .wifi:
                print("Connecté via Wi-Fi")
            case .cellular:
                print("Connecté via cellulaire")
            case .unavailable:
                print("Aucune connexion")
            }
        }
    }
}

Vérification du réseau avant une requête

Avant d’exécuter une requête HTTP, on peut vérifier la disponibilité du réseau de façon synchrone : reachability.connection != .unavailable. Cela ne garantit pas le succès de la requête (le serveur peut être indisponible), mais évite les requêtes vouées à l’échec et améliore l’UX — l’application n’affiche pas de spinner en mode hors ligne.

Pour une vérification plus précise, combinez Reachability avec les délais d’attente d’URLSession. Si Reachability indique accessible mais que la requête échoue dans le délai imparti — il y a probablement un problème côté serveur ou un portail captif. Dans ce cas, on peut afficher à l’utilisateur un message d’indisponibilité du serveur.

Types de connexion dans Reachability

Reachability distingue trois états de connexion principaux : Wi-Fi, données cellulaires (WWAN) et indisponible. WWAN inclut tous les types de connexion cellulaire — 2G, 3G, 4G/LTE, 5G. La bibliothèque ne fournit pas de granularité au sein de WWAN, donc pour distinguer la 4G de la 5G, CoreTelephony est nécessaire.

Limitations de Reachability par type de réseau

Reachability ne distingue pas Ethernet, les tunnels VPN ou les connexions multipath — toutes les interfaces non-WWAN sont classées comme Wi-Fi. Cette limitation découle de l’architecture SystemConfiguration, qui ne fournit pas d’informations détaillées sur les interfaces réseau au-delà de la classification de base.

Pour déterminer le type spécifique de connexion cellulaire (4G vs 5G), CTTelephonyNetworkInfo de CoreTelephony est requis. La combinaison de Reachability avec CoreTelephony permet à l’application de sélectionner la qualité du contenu : en 5G — streaming en 4K, en 4G/LTE — HD, en 3G — SD ou audio uniquement.

Migration de Reachability vers NWPathMonitor

Apple recommande de remplacer Reachability par NWPathMonitor dans tous les nouveaux projets à partir d’iOS 12. La raison principale est que NWPathMonitor fait partie du framework Network moderne, est écrit en Swift, prend en charge Combine et fournit des informations détaillées sur le chemin réseau sans utiliser de compatibilité C.

Le processus de migration comprend le remplacement de SCNetworkReachability par NWPathMonitor, le passage de NotificationCenter à une closure pathUpdateHandler ou un publisher Combine. L’algorithme et la logique de gestion du statut réseau restent les mêmes — seule l’API de surveillance change.

protocol NetworkMonitorProtocol {
    var isReachable: Bool { get }
    var connectionType: ConnectionType { get }
    func startMonitoring()
    func stopMonitoring()
}

enum ConnectionType {
    case wifi, cellular, ethernet, unavailable
}

// Implémentation moderne utilisant NWPathMonitor
class ModernNetworkMonitor: NetworkMonitorProtocol {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue("Network")
    private var currentPath: NWPath?

    var isReachable: Bool {
        currentPath?.status == .satisfied
    }

    func startMonitoring() {
        monitor.pathUpdateHandler = { [weak self] path in
            self?.currentPath = path
        }
        monitor.start(on: queue)
    }

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

Recommandations de migration

Pour les projets ciblant iOS 12+, remplacez entièrement Reachability par NWPathMonitor. Pour les projets prenant en charge iOS 11, utilisez la compilation conditionnelle #available(iOS 12, *) avec NWPathMonitor et Reachability comme solution de repli. Cela permet une migration progressive sans perdre la prise en charge des anciens appareils.

Le principal avantage de la migration est la granularité du chemin réseau. NWPathMonitor signale non seulement « accessible/inaccessible » mais aussi le type de chaque interface, leurs coûts, priorité, support proxy et VPN. Cela donne au développeur plus de données pour adapter le comportement de l’application aux conditions réseau actuelles.