NWPathMonitor: vad är det, nätverksspårning och arbete i iOS

Vad är NWPathMonitor?

NWPathMonitor — är en klass från Network-ramverket, introducerad av Apple i iOS 12 och macOS 10.14 Mojave. Den tillhandahåller ett modernt API för att spåra ändringar i enhetens nätverksväg — kombinationen av nätverksgränssnitt som applikationens trafik passerar genom.

Före iOS 12 användes biblioteket Reachability för nätverksövervakning, byggt på C-ramverket SystemConfiguration. NWPathMonitor är ett inbyggt Swift-alternativ med ett rikare API, stöd för moderna anslutningstyper (VPN, multipath, LTE, 5G) och inbyggd integration med GCD.

Den viktigaste skillnaden mellan NWPathMonitor och Reachability — NWPath-objektet ger inte bara en binär status ”tillgänglig/inte tillgänglig”, utan en fullständig bild av vägen: använda gränssnitt, deras prioritet, kostnader, roamingstatus och möjligheten till proxy och VPN. Utvecklaren får uttömmande information för att fatta beslut om nätverksförfrågningar.

Historik om Network-ramverkets uppkomst

Network-ramverket uppstod som en modern ersättning för lågnivå-C-API:er — CFStream och BSD Sockets. Det tillhandahåller ett enhetligt gränssnitt för nätverkskommunikation på alla Apple-plattformar, inklusive watchOS och tvOS. NWPathMonitor är en del av detta ramverk tillsammans med NWConnection, NWListener och NWBrowser.

Network-ramverket är skrivet i Swift och använder GCD för asynkron bearbetning. Detta innebär att NWPathMonitor-callbacks utförs på den angivna dispatch queue, vilket integreras med applikationens befintliga flertrådsarkitektur utan manuell trådhantering.

Hur man använder NWPathMonitor i applikationen

Användning av NWPathMonitor börjar med att skapa en instans av klassen och konfigurera pathUpdateHandler. Sedan anropas metoden start med angivelse av den dispatch queue där closure ska utföras. Stopp av övervakning görs med metoden cancel, som också frigör resurser.

import Network

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

    func startMonitoring() {
        monitor.pathUpdateHandler = { path in
            if path.status == .satisfied {
                print("Nätverk tillgängligt")
            } else {
                print("Nätverk inte tillgängligt")
            }
        }
        monitor.start(on: queue)
    }

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

Arbete med gränssnittstyp

NWPathMonitor kan konfigureras för att endast spåra en specifik gränssnittstyp. För detta används initialiseraren NWPathMonitor(requiredInterfaceType:) med parametern NWInterface.InterfaceType — .wifi, .cellular, .wiredEthernet eller .loopback. Om typen inte anges utförs övervakning för alla gränssnitt.

Praktiskt exempel: en streamingapp kan endast övervaka Wi-Fi och varna användaren vid övergång till mobildata. Kontroll av isConstrained och isExpensive i NWPath gör det möjligt att avgöra om den aktuella anslutningen är avgiftsbelagd eller hastighetsbegränsad.

Övervakningens livscykel

Övervakning bör startas när applikationen startar eller vid övergång till förgrunden och stoppas vid övergång till bakgrunden. Det rekommenderas att skapa en instans av NWPathMonitor för hela applikationen (singleton) och använda den från olika moduler via ett protokoll eller tjänstlager.

NWPaths egenskaper och möjligheter

NWPath — objektet som skickas till pathUpdateHandler, som beskriver den aktuella statusen för nätverksvägen. Det innehåller fem viktiga egenskaper som täcker de flesta nätverksövervakningsscenarier. NWPath.Status — en uppräkning med tre tillstånd: satisfied (tillgänglig), unsatisfied (inte tillgänglig) och requiresConnection (kräver anslutning).

Kontroll av kostnader och begränsningar

Egenskapen isExpensive — en kritisk viktig flagga för applikationer som arbetar med stora datamängder. Om isExpensive = true bör applikationen minska streamingkvaliteten, skjuta upp nedladdning av uppdateringar eller varna användaren. isConstrained indikerar att Low Data Mode är aktiverat.

För att kontrollera internettillgänglighet (inte bara nätverk) används metoden usesInterfaceType. Om enheten är ansluten till Wi-Fi utan internet — kan NWPath visa satisfied, men faktisk åtkomst saknas. I sådana fall krävs ytterligare validering via NWConnection.

Exempel på NWPathMonitor-implementering

Låt oss titta på en avancerad NWPathMonitor-implementering med hantering av kostnader, gränssnittstyper och avisering av ViewModel via en publisher. I exemplet används Combine-ramverket för reaktiv uppdatering av UI när nätverksstatusen ändras.

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
    }
}

Hantering av nätverksförlust med fördröjd åtgärd

Vid förlust av anslutning kan det krävas inte bara att meddela UI, utan också att utföra fördröjda åtgärder — till exempel spara ett utkast till förfrågan för senare skickande. Implementera en kö för fördröjda förfrågningar som samlar operationer vid status unsatisfied och skickar dem när satisfied återställs.

För denna uppgift är mönstret ReachabilityManager med delegat idealiskt: NWPathMonitor meddelar hanteraren, hanteraren uppdaterar kön och UI. När status ändras till satisfied töms kön automatiskt och UI får en indikation på återställd anslutning.

NWPathMonitor vs Reachability

Innan NWPathMonitor kom var standardlösningen för nätverksövervakning i iOS Apples Reachability-bibliotek (exempel från dokumentationen), byggt på SystemConfiguration. De viktigaste skillnaderna: Reachability fungerar via SCNetworkReachability i C, stöder inte moderna nätverkstyper och ger endast ett binärt svar om tillgänglighet.

NWPathMonitor löser dessa begränsningar: det är skrivet i Swift, stöder VPN, multipath, 5G och LTE, tillhandahåller detaljerad information om varje gränssnitt och fungerar asynkront via GCD. Reachability används fortfarande i projekt med minimalt stöd för iOS 11 och lägre.

När ska Reachability användas

Om din applikation stöder iOS 11 och lägre, förblir Reachability det enda alternativet. För iOS 12+ projekt rekommenderas att omedelbart använda NWPathMonitor — det integreras bättre med modern Swift-kod, Combine och SwiftUI.

Migrering från Reachability till NWPathMonitor är enkel: ersätt bara SCNetworkReachability-anropen med NWPathMonitor, med bibehållen samma bearbetningslogik. Abstraktionslagret (protokollet NetworkMonitorProtocol) gör det möjligt att växla mellan implementeringar utan att ändra applikationens affärslogik.