Reachability: vad är det, bibliotek för kontroll av nätverkstillgänglighet

Vad är Reachability?

Reachability — är ett exempelbibliotek från Apple som visar användningen av ramverket SystemConfiguration för nätverksövervakning. Källkoden publicerades i Apple Developer Documentation som ett exempel, men gemenskapen antog det som ett standardverktyg för anslutningskontroll i iOS-projekt.

Biblioteket fungerar baserat på SCNetworkReachability — en C-funktion från SystemConfiguration som utvärderar nåbarheten av en fjärrvärd eller IP-adress. När du skapar Reachability anger du antingen ett värdnamn (t.ex. google.com) eller en IP-adress, och biblioteket kontrollerar asynkront om denna värd är tillgänglig via enhetens aktuella nätverksgränssnitt.

Populariteten hos Reachability beror på dess enkelhet: skapa en instans, prenumerera på aviseringar via NotificationCenter och lyssna på kReachabilityChangedNotification. Som svar får applikationen status: NotReachable, ReachableViaWiFi eller ReachableViaWWAN (mobildata).

Bibliotekets historia och status

Reachability första gången i iPhone OS 2 (2008) tillsammans med ramverket SystemConfiguration. Under tio år var det det enda inbyggda sättet att övervaka nätverk i iOS. Med lanseringen av iOS 12 och ramverket Network rekommenderar Apple NWPathMonitor som ersättning, men Reachability stöds fortfarande.

Många tredjepartsomslag — AFNetworking, Alamofire, AshleyDodd/Reachability.swift — använder den interna mekanismen SCNetworkReachability. Dessa bibliotek lägger till ett bekvämt Swift/Objective-C-gränssnitt, statusmemoization och trådsäkra återanrop, samtidigt som de behåller samma SystemConfiguration-bas.

Hur fungerar Reachability under huven

Huvudmekanismen i Reachability — funktionen SCNetworkReachabilityCreateWithName, som skapar ett spårningsobjekt för den angivna värden. Därefter anropas SCNetworkReachabilityGetFlags — en synkron kontroll som returnerar en bitmask SCNetworkReachabilityFlags med aktuell nätverksstatus.

För asynkron övervakning används SCNetworkReachabilitySetCallback, som registrerar en C-återanropsfunktion. Återanropet körs på den aktuella RunLoop när värdens nåbarhetsstatus ändras. Reachability slår in detta C-återanrop i en Objective-C-metod och skickar en avisering 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
    }
}

Flaggor för nätverksnåbarhet

SCNetworkReachabilityFlags — en bitmask som kodar nätverksstatus. Flaggan kSCNetworkReachabilityFlagsReachable indikerar att värden är nåbar. kSCNetworkReachabilityFlagsConnectionRequired — för anslutning krävs upprättande av kommunikation. Kombinationen av flaggor avgör om applikationen kan skicka data.

Ytterligare flaggor: kSCNetworkReachabilityFlagsIsWWAN — anslutning via mobilnät (iOS), kSCNetworkReachabilityFlagsInterventionRequired — kräver användarintervention (t.ex. för VPN). Reachability tar hänsyn till dessa flaggor för att bestämma gränssnittstyp.

Exempel på användning av Reachability

Standardmönstret för användning av Reachability i en iOS-app inkluderar att skapa en instans, prenumerera på aviseringar och reagera på statusändringar. Exemplet nedan visar integration med NotificationCenter för att uppdatera gränssnittet vid nätverksändringar.

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("Ansluten via Wi-Fi")
            case .cellular:
                print("Ansluten via mobilnät")
            case .unavailable:
                print("Ingen anslutning")
            }
        }
    }
}

Nätverkskontroll före begäran

Innan du utför en HTTP-begäran kan du synkront kontrollera nätverkstillgängligheten: reachability.connection != .unavailable. Detta garanterar inte framgång för begäran (servern kan vara otillgänglig), men förhindrar dömda begäran och förbättrar användarupplevelsen — appen visar ingen spinner i offlineläge.

För mer exakt kontroll, kombinera Reachability med URLSession-timeouter. Om Reachability visar reachable men begäran inte utförs inom timeouten — ligger problemet troligen på serversidan eller en captive portal. I så fall kan du visa ett meddelande för användaren om att servern är otillgänglig.

Anslutningstyper i Reachability

Reachability särskiljer tre huvudanslutningstillstånd: Wi-Fi, mobildata (WWAN) och otillgänglighet. WWAN omfattar alla typer av mobil kommunikation — 2G, 3G, 4G/LTE, 5G. Biblioteket ger inga detaljer inom WWAN, därför krävs CoreTelephony för att särskilja 4G och 5G.

Begränsningar för Reachability per nätverkstyp

Reachability särskiljer inte Ethernet, VPN-tunnlar eller multipath-anslutningar — alla icke-WWAN-gränssnitt klassificeras som Wi-Fi. Denna begränsning är kopplad till arkitekturen i SystemConfiguration, som inte ger detaljerad information om nätverksgränssnitt utanför grundklassificeringen.

För att bestämma den specifika typen av mobil kommunikation (4G vs 5G) krävs CTTelephonyNetworkInfo från CoreTelephony. Att kombinera Reachability med CoreTelephony låter applikationen välja innehållskvalitet: vid 5G — 4K-strömning, vid 4G/LTE — HD, vid 3G — SD eller endast ljud.

Migrering från Reachability till NWPathMonitor

Apple rekommenderar att ersätta Reachability med NWPathMonitor i alla nya projekt, från och med iOS 12. Huvudorsaken är att NWPathMonitor är en del av det moderna ramverket Network, skrivet i Swift, stödjer Combine och ger detaljerad information om nätverksvägen utan att använda C-kompatibilitet.

Migreringsprocessen innefattar att ersätta SCNetworkReachability med NWPathMonitor, övergång från NotificationCenter till pathUpdateHandler-closure eller Combine-publisher. Algoritmen och logiken för bearbetning av nätverksstatus förblir desamma — endast övervaknings-API:et ändras.

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

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

// Modern implementering med 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()
    }
}

Rekommendationer för migrering

För projekt med grundläggande stöd för iOS 12+, ersätt Reachability helt med NWPathMonitor. För projekt som stödjer iOS 11, använd villkorlig kompilering #available(iOS 12, *) med NWPathMonitor och Reachability som fallback. Detta möjliggör gradvis migrering utan att förlora stöd för äldre enheter.

Den största fördelen med migrering är detaljrikedomen i nätverksvägen. NWPathMonitor rapporterar inte bara ”tillgänglig/ej tillgänglig”, utan även typen av varje gränssnitt, dess kostnader, prioritet, stöd för proxy och VPN. Detta ger utvecklaren mer data för att anpassa applikationens beteende till aktuella nätverksförhållanden.