How to monitor network in SwiftUI
Tags: swiftui, network
Published: 2024-04-11 08:39:02

---
title: How to monitor network in SwiftUI
published: true
date: 2024-03-17 20:01:53 UTC
tags: SwiftUI,Network
canonical_url: https://wesleydegroot.nl/blog/Monitor-network-in-SwiftUI
---

Network monitoring is crucial for maintaining robust and reliable applications.  
In this blog post, we’ll explore how to implement network monitoring in Swift using Apple’s native Network framework.  
By leveraging this framework, you can efficiently track network connectivity, detect changes, and respond accordingly.

## What is `NWPathMonitor`?

NWPathMonitor is a class that monitors changes to network connectivity.  
It provides information about the current network path, such as the status of the network connection and the available interfaces.

## Writing the monitor

```swift
import SwiftUI
import Network

final class NetworkMonitor: ObservableObject {
    // This will be used to track the network connectivity
    @Published
    var isConnected = true

    // This will be used to track if the network is expensive (e.g. cellular data)
    @Published
    var isExpensive = false

    @Published
    var networkType: NWInterface.InterfaceType? = .other

    // This will be used to track the network path (e.g. Wi-Fi, cellular data, etc.)
    @Published
    var nwPath: NWPath?

    // Create an instance of NWPathMonitor
    let monitor = NWPathMonitor()

    init() {
        // Set the pathUpdateHandler
        monitor.pathUpdateHandler = { [weak self] path in

            // Check if the device is connected to the internet
            self?.isConnected = path.status == .satisfied

            // Check if the network is expensive (e.g. cellular data)
            self?.isExpensive = path.isExpensive

            // Check which interface we are currently using
            self?.networkType = path.availableInterfaces.first?.type

            // Update the network path
            self?.nwPath = path
        }

        // Create a queue for the monitor
        let queue = DispatchQueue(label: "Monitor")

        // Start monitoring
        monitor.start(queue: queue)
    }

    deinit {
        // Stop monitoring
        monitor.cancel()
    }
}
```

## Use the monitor

```swift
import SwiftUI

struct ContentView: View {
    @ObservedObject
    private var network = NetworkMonitor()

    var body: some View {
        VStack {
            Text("Hello!")
            Text("The network status is \(network.isConnected ? "Connected" : "Disconnected")")
            Text("You are using a \"\(network.isExpensive ? "Expensive" : "Normal")\" internet connection")

            HStack(spacing: 0) {
                Text("You are using \"")
                switch (network.networkType) {
                case .cellular:
                    Text("Celluar")
                case .wifi:
                    Text("Wifi")
                case .loopback:
                    Text("Loopback")
                case .other:
                    Text("Other")
                case .wiredEthernet:
                    Text("Wired")
                default:
                    Text("Unknown")
                }
                Text("\" to connect to the internet")
            }
        }.task {
            print(network.nwPath)
        }
    }
}
```

Download the [Swift Playground here](https://wesleydegroot.nl/resources/Monitor-network-in-SwiftUI.swiftpm.zip)

## Conclusion

Network monitoring is crucial for maintaining robust and reliable applications.  
In this blog post, we explored how to implement network monitoring in Swift using Apple’s native Network framework.  
By leveraging this framework, you can efficiently track network connectivity, detect changes, and respond accordingly.

Resources:  
[https://developer.apple.com/documentation/network](https://developer.apple.com/documentation/network)