How to Implement Geofencing in SwiftUI

import SwiftUI
import CoreLocation
import UserNotifications

// MARK: - Observable Location Manager

@Observable
final class GeofenceManager: NSObject, CLLocationManagerDelegate {

    private let locationManager = CLLocationManager()

    var authorizationStatus: CLAuthorizationStatus = .notDetermined
    var monitoredRegions: [CLCircularRegion] = []
    var lastEvent: String = "None"

    override init() {
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
    }

    // MARK: - Authorization

    func requestPermission() {
        locationManager.requestAlwaysAuthorization()
    }

    // MARK: - Region Management

    func addFence(coordinate: CLLocationCoordinate2D,
                  radius: CLLocationDistance,
                  identifier: String) {
        guard CLLocationManager.isMonitoringAvailable(for: CLCircularRegion.self) else {
            lastEvent = "Monitoring unavailable on this device"
            return
        }
        guard locationManager.monitoredRegions.count < 20 else {
            lastEvent = "iOS limit: max 20 monitored regions"
            return
        }

        let region = CLCircularRegion(center: coordinate,
                                      radius: min(radius, locationManager.maximumRegionMonitoringDistance),
                                      identifier: identifier)
        region.notifyOnEntry = true
        region.notifyOnExit  = true

        locationManager.startMonitoring(for: region)
        monitoredRegions = locationManager.monitoredRegions
            .compactMap { $0 as? CLCircularRegion }
        lastEvent = "Started monitoring '\(identifier)'"
    }

    func removeFence(identifier: String) {
        locationManager.monitoredRegions
            .filter { $0.identifier == identifier }
            .forEach { locationManager.stopMonitoring(for: $0) }
        monitoredRegions = locationManager.monitoredRegions
            .compactMap { $0 as? CLCircularRegion }
        lastEvent = "Removed '\(identifier)'"
    }

    func checkCurrentState(for region: CLCircularRegion) {
        locationManager.requestState(for: region)
    }

    // MARK: - CLLocationManagerDelegate

    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
        authorizationStatus = manager.authorizationStatus
    }

    func locationManager(_ manager: CLLocationManager,
                         didEnterRegion region: CLRegion) {
        lastEvent = "Entered '\(region.identifier)' at \(Date.now.formatted(date: .omitted, time: .standard))"
        sendNotification(title: "Geofence Entry", body: "You entered \(region.identifier).")
    }

    func locationManager(_ manager: CLLocationManager,
                         didExitRegion region: CLRegion) {
        lastEvent = "Exited '\(region.identifier)' at \(Date.now.formatted(date: .omitted, time: .standard))"
        sendNotification(title: "Geofence Exit", body: "You left \(region.identifier).")
    }

    func locationManager(_ manager: CLLocationManager,
                         didDetermineState state: CLRegionState,
                         for region: CLRegion) {
        let stateString = switch state {
            case .inside:  "Inside"
            case .outside: "Outside"
            case .unknown: "Unknown"
            @unknown default: "Unknown"
        }
        lastEvent = "State for '\(region.identifier)': \(stateString)"
    }

    func locationManager(_ manager: CLLocationManager,
                         monitoringDidFailFor region: CLRegion?,
                         withError error: Error) {
        lastEvent = "Monitoring failed: \(error.localizedDescription)"
    }

    // MARK: - Local Notification helper

    private func sendNotification(title: String, body: String) {
        let content = UNMutableNotificationContent()
        content.title = title
        content.body  = body
        content.sound = .default
        let request = UNNotificationRequest(identifier: UUID().uuidString,
                                            content: content,
                                            trigger: nil)
        UNUserNotificationCenter.current().add(request)
    }
}

// MARK: - SwiftUI View

struct GeofencingView: View {
    @State private var manager = GeofenceManager()

    private let sfHQ = CLLocationCoordinate2D(latitude: 37.7749, longitude: -122.4194)
    private let appleHQ = CLLocationCoordinate2D(latitude: 37.3349, longitude: -122.0090)

    var body: some View {
        NavigationStack {
            List {
                Section("Authorization") {
                    HStack {
                        Label("Status", systemImage: "lock.shield")
                        Spacer()
                        Text(authStatusText)
                            .foregroundStyle(authStatusColor)
                            .font(.footnote)
                    }
                    if manager.authorizationStatus != .authorizedAlways {
                        Button("Request Always Authorization") {
                            manager.requestPermission()
                        }
                    }
                }

                Section("Last Event") {
                    Text(manager.lastEvent)
                        .font(.footnote.monospaced())
                        .foregroundStyle(.secondary)
                }

                Section("Quick-add Fences") {
                    Button("Add SF HQ (200 m)") {
                        manager.addFence(coordinate: sfHQ, radius: 200, identifier: "SF HQ")
                    }
                    Button("Add Apple Park (500 m)") {
                        manager.addFence(coordinate: appleHQ, radius: 500, identifier: "Apple Park")
                    }
                }

                Section("Monitored Regions (\(manager.monitoredRegions.count)/20)") {
                    if manager.monitoredRegions.isEmpty {
                        Text("No active fences").foregroundStyle(.secondary)
                    }
                    ForEach(manager.monitoredRegions, id: \.identifier) { region in
                        VStack(alignment: .leading, spacing: 2) {
                            Text(region.identifier).fontWeight(.medium)
                            Text("Radius: \(Int(region.radius)) m · \(region.center.latitude, format: .number.precision(.fractionLength(4))), \(region.center.longitude, format: .number.precision(.fractionLength(4)))")
                                .font(.caption)
                                .foregroundStyle(.secondary)
                        }
                        .swipeActions {
                            Button("Remove", role: .destructive) {
                                manager.removeFence(identifier: region.identifier)
                            }
                        }
                    }
                }
            }
            .navigationTitle("Geofencing")
        }
    }

    private var authStatusText: String {
        switch manager.authorizationStatus {
        case .authorizedAlways:      "Always"
        case .authorizedWhenInUse:   "When In Use"
        case .denied:                "Denied"
        case .restricted:            "Restricted"
        case .notDetermined:         "Not Determined"
        @unknown default:            "Unknown"
        }
    }

    private var authStatusColor: Color {
        manager.authorizationStatus == .authorizedAlways ? .green : .orange
    }
}

#Preview {
    GeofencingView()
}