NWPathMonitor: ano ito, pagsubaybay sa network at paggawa sa iOS

Ano ang NWPathMonitor?

NWPathMonitor — ay isang klase mula sa Network framework, ipinakilala ng Apple sa iOS 12 at macOS 10.14 Mojave. Nagbibigay ito ng modernong API para sa pagsubaybay sa mga pagbabago sa network path ng device — ang kombinasyon ng mga network interface kung saan dumadaan ang trapiko ng aplikasyon.

Bago ang iOS 12, para sa pagsubaybay sa network ay ginamit ang library na Reachability, na binuo sa C-framework na SystemConfiguration. Ang NWPathMonitor ay isang native na Swift alternatibo na may mas mayamang API, suporta para sa mga modernong uri ng koneksyon (VPN, multipath, LTE, 5G) at built-in na trabaho sa GCD.

Ang pangunahing pagkakaiba sa pagitan ng NWPathMonitor at Reachability — ang NWPath object ay nagbibigay hindi lamang ng binary status “magagamit/hindi magagamit”, kundi isang kumpletong larawan ng landas: mga interface na ginamit, ang kanilang prayoridad, gastos, status ng roaming, at posibilidad ng proxy at VPN. Ang developer ay nakakatanggap ng komprehensibong impormasyon para sa paggawa ng desisyon tungkol sa mga network request.

Kasaysayan ng paglitaw ng Network framework

Ang Network framework ay lumitaw bilang isang modernong kapalit para sa mababang antas ng C-API — CFStream at BSD Sockets. Nagbibigay ito ng pinag-isang interface para sa komunikasyon sa network sa lahat ng platform ng Apple, kabilang ang watchOS at tvOS. Ang NWPathMonitor ay bahagi ng framework na ito kasama ang NWConnection, NWListener, at NWBrowser.

Ang Network framework ay isinulat sa Swift at gumagamit ng GCD para sa asynchronous na pagproseso. Ito ay nangangahulugan na ang mga callback ng NWPathMonitor ay isinasakatuparan sa tinukoy na dispatch queue, na nagsasama sa umiiral na multi-threading architecture ng aplikasyon nang walang manu-manong pamamahala ng thread.

Paano gamitin ang NWPathMonitor sa aplikasyon

Ang paggamit ng NWPathMonitor ay nagsisimula sa paglikha ng isang instance ng klase at pag-configure ng handler na pathUpdateHandler. Pagkatapos ay tinatawag ang metodo start na may pagtukoy sa dispatch queue kung saan isasakatuparan ang closure. Ang paghinto ng pagsubaybay ay ginagawa sa pamamagitan ng metodo cancel, na nagpapalaya rin ng mga resources.

import Network

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

    func startMonitoring() {
        monitor.pathUpdateHandler = { path in
            if path.status == .satisfied {
                print("Available ang network")
            } else {
                print("Hindi available ang network")
            }
        }
        monitor.start(on: queue)
    }

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

Paggawa sa uri ng interface

Ang NWPathMonitor ay maaaring i-configure upang subaybayan lamang ang isang partikular na uri ng interface. Para dito ginagamit ang initializer na NWPathMonitor(requiredInterfaceType:) na may parameter na NWInterface.InterfaceType — .wifi, .cellular, .wiredEthernet o .loopback. Kung hindi tinukoy ang uri, ang pagsubaybay ay gagawin para sa lahat ng interface.

Praktikal na halimbawa: ang isang streaming application ay maaaring subaybayan lamang ang Wi-Fi at balaan ang user tungkol sa paglipat sa mobile data. Ang pagsusuri ng isConstrained at isExpensive sa NWPath ay nagbibigay-daan upang matukoy kung ang kasalukuyang koneksyon ay binabayaran o limitado sa bilis.

Ikot ng buhay ng pagsubaybay

Ang pagsubaybay ay dapat simulan sa pagsisimula ng aplikasyon o sa paglabas sa foreground at itigil sa pagpasok sa background. Inirerekomenda na lumikha ng isang instance ng NWPathMonitor para sa buong aplikasyon (singleton) at gamitin ito mula sa iba't ibang modyul sa pamamagitan ng protocol o service layer.

Mga Property at Kakayahan ng NWPath

NWPath — ang object na ipinapasa sa pathUpdateHandler, na naglalarawan ng kasalukuyang estado ng network path. Naglalaman ito ng limang pangunahing property na sumasaklaw sa karamihan ng mga senaryo ng pagsubaybay sa network. NWPath.Status — isang enumeration na may tatlong estado: satisfied (magagamit), unsatisfied (hindi magagamit) at requiresConnection (nangangailangan ng koneksyon).

Pagsusuri ng mga gastos at limitasyon

Ang property na isExpensive — isang kritikal na mahalagang flag para sa mga aplikasyon na nagtatrabaho sa malalaking volume ng data. Kung ang isExpensive = true, ang aplikasyon ay dapat magbaba ng kalidad ng streaming, ipagpaliban ang pag-download ng mga update, o balaan ang user. Ang isConstrained ay nagpapahiwatig na ang Low Data Mode ay naka-on.

Para sa pagsusuri ng pagkakaroon ng internet (hindi lamang network) ay ginagamit ang metodo usesInterfaceType. Kung ang device ay konektado sa Wi-Fi na walang internet — ang NWPath ay maaaring magpakita ng satisfied, ngunit ang aktwal na access ay wala. Sa ganitong mga kaso, kinakailangan ang karagdagang validation sa pamamagitan ng NWConnection.

Mga Halimbawa ng Implementasyon ng NWPathMonitor

Tingnan natin ang isang advanced na implementasyon ng NWPathMonitor na may paghawak ng mga gastos, uri ng interface, at pag-notify sa ViewModel sa pamamagitan ng publisher. Sa halimbawa, ginagamit ang Combine framework para sa reaktibong pag-update ng UI kapag nagbabago ang estado ng network.

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

Paghawak ng pagkawala ng network na may naantalang aksyon

Sa pagkawala ng koneksyon, maaaring kailanganin hindi lamang abisuhan ang UI, kundi pati na rin magsagawa ng mga naantalang aksyon — halimbawa, i-save ang draft ng request para sa susunod na pagpapadala. Ipatupad ang isang pila ng mga naantalang request na nag-iipon ng mga operasyon sa status na unsatisfied at nagpapadala ng mga ito kapag bumalik ang satisfied.

Para sa gawaing ito, ang pattern na ReachabilityManager na may delegate ay perpekto: ang NWPathMonitor ay nag-aabiso sa manager, ang manager ay nag-a-update ng pila at UI. Kapag ang status ay nagbago sa satisfied, ang pila ay awtomatikong nagiging walang laman, at ang UI ay tumatanggap ng indikasyon ng pagpapanumbalik ng koneksyon.

NWPathMonitor vs Reachability

Bago ang paglitaw ng NWPathMonitor, ang karaniwang solusyon para sa pagsubaybay sa network sa iOS ay ang Reachability library mula sa Apple (halimbawa mula sa dokumentasyon), na binuo sa SystemConfiguration. Ang mga pangunahing pagkakaiba: Ang Reachability ay gumagana sa pamamagitan ng SCNetworkReachability sa C, hindi sumusuporta sa mga modernong uri ng network, at nagbibigay lamang ng binary na tugon tungkol sa pagkakaroon.

Nilulutas ng NWPathMonitor ang mga limitasyong ito: ito ay isinulat sa Swift, sumusuporta sa VPN, multipath, 5G at LTE, nagbibigay ng detalyadong impormasyon tungkol sa bawat interface, at gumagana nang asynchronous sa pamamagitan ng GCD. Ang Reachability ay ginagamit pa rin sa mga proyektong may minimal na suporta para sa iOS 11 at mas mababa.

Kailan gagamitin ang Reachability

Kung ang iyong aplikasyon ay sumusuporta sa iOS 11 at mas mababa, ang Reachability ay nananatiling tanging opsyon. Para sa mga proyektong iOS 12+ inirerekomenda na agad gamitin ang NWPathMonitor — ito ay mas mahusay na nagsasama sa modernong Swift code, Combine, at SwiftUI.

Ang migrasyon mula sa Reachability patungo sa NWPathMonitor ay simple: palitan lamang ang mga tawag sa SCNetworkReachability ng NWPathMonitor, pinapanatili ang parehong lohika ng pagproseso. Ang layer ng abstraction (protocol na NetworkMonitorProtocol) ay magpapahintulot sa paglipat sa pagitan ng mga implementasyon nang hindi binabago ang business logic ng aplikasyon.