FROMDEV

How to Check Internet Connection in macOS Using Swift

Fromdev Publisher
Swift Network Reachability: Check macOS Internet Access

Checking for Active Internet Connection in macOS: A Developer’s Guide

In modern macOS applications, maintaining seamless user experiences requires handling internet connectivity gracefully. Whether it’s syncing data, fetching remote content, or enabling cloud features, checking for an active internet connection is essential. However, dealing with network variability on desktop systems—especially with Ethernet, Wi-Fi, and VPNs—introduces complexity.

This guide is tailored for macOS developers who want to reliably detect and monitor internet connectivity using modern Swift techniques and Objective-C alternatives. We’ll explore how to use the Network framework, verify actual internet access, and handle diverse network scenarios with best practices.

Understanding Network Connectivity in macOS

Types of Connections

macOS supports multiple network interfaces, including:

Each type may behave differently in terms of latency, reliability, and accessibility, making robust detection crucial.

Network Reachability vs. Internet Access

Network reachability refers to the ability to connect to a network, but not necessarily the internet. A device could be connected to a local network with no actual internet access. Thus, developers must distinguish between:

Using Network Framework for Reachability (macOS 10.14+)

Apple’s Network framework is the modern approach for checking network status in macOS and iOS.

Setting Up NWPathMonitor in Swift

import Network

let monitor = NWPathMonitor()
let queue = DispatchQueue(label: "NetworkMonitor")

monitor.pathUpdateHandler = { path in
    if path.status == .satisfied {
        print("Internet connection is available.")
    } else {
        print("No internet connection.")
    }

    print("Interface Type: \(path.availableInterfaces.map { $0.type })")
}

monitor.start(queue: queue)

Handling NWPath.Status

Checking Interface Types

if path.usesInterfaceType(.wifi) {
    print("Connected via Wi-Fi")
} else if path.usesInterfaceType(.wiredEthernet) {
    print("Connected via Ethernet")
}

Monitoring Changes

NWPathMonitor continuously watches for changes, making it ideal for long-running apps and background tasks. Always start and stop it appropriately to conserve resources.

Checking for Actual Internet Access

Network reachability isn’t enough. To confirm real connectivity, make a lightweight request to a reliable endpoint.

Swift + URLSession Example

func checkInternetAccess(completion: @escaping (Bool) -> Void) {
    guard let url = URL(string: "https://www.apple.com/library/test/success.html") else {
        completion(false)
        return
    }

    var request = URLRequest(url: url)
    request.timeoutInterval = 5.0

    URLSession.shared.dataTask(with: request) { _, response, error in
        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
            completion(true)
        } else {
            completion(false)
        }
    }.resume()
}

Best Practices

Handling Different Network Scenarios

No Internet Connection

Use NWPath.Status.unsatisfied or failed URLSession response to detect and notify users.

Limited or Slow Connections

Monitor request durations and fallback gracefully:

request.timeoutInterval = 3 // Adjust based on app needs

Network Changes

Use NWPathMonitor to listen and react in real-time:

monitor.pathUpdateHandler = { path in
    // Respond to connectivity changes
}

VPN Detection

Detect VPN via interface type:

if path.usesInterfaceType(.other) {
    print("Possibly connected via VPN")
}

For exact VPN detection, consider examining routing tables or using third-party APIs.

User Experience Considerations

Clear Feedback

Provide meaningful messages:

"No internet connection. Please check your network settings."

Avoid vague errors like “Request failed.”

Background Tasks

Handle suspensions and resume network checks appropriately in AppDelegate lifecycle events.

Best Practices for Network Monitoring

Error Handling and Debugging

Common Errors

Debugging Tips

Objective-C Compatibility

For macOS apps using Objective-C or targeting older systems, use the System Configuration framework:

#import <SystemConfiguration/SystemConfiguration.h>

- (BOOL)isConnectedToNetwork {
    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, "apple.com");
    SCNetworkReachabilityFlags flags;
    BOOL success = SCNetworkReachabilityGetFlags(reachability, &flags);
    CFRelease(reachability);

    return success && (flags & kSCNetworkReachabilityFlagsReachable) &&
           !(flags & kSCNetworkReachabilityFlagsConnectionRequired);
}

Note: This does not confirm internet access—only that a network is reachable.

Conclusion

Checking for an active internet connection in macOS is more than verifying reachability—it’s about confirming true connectivity in real-time. By leveraging the modern Network framework alongside lightweight connectivity tests, you can deliver resilient, user-friendly macOS apps that handle connectivity changes smoothly.

Start implementing NWPathMonitor, use smart URLSession checks, and ensure graceful handling of all network states. For more details, consult the official Apple Network framework documentation and stay updated with best practices.

Exit mobile version