[common][ios] location regions monitoring (#7597)

Introduces a Location Regions Monitoring system to the iOS
location's component of Common SDK, enabling its client to monitor
geographical regions and receive notifications when a device enters or
exits specified areas.

- When the app is terminated and a region is entered/exited, the system will wake the app up and geofence will be restarted and resumes checking the location against its features.

cc @mapbox/core-sdk
cc @mapbox/maps-ios

---------

Co-authored-by: Changelog autocreator bot <[email protected]>
GitOrigin-RevId: c3851a16807837d4714c545f59dfb77db74e0431

Author: 2 people

Sources/Examples/SwiftUI Examples/GeofencingUserLocation.swift

@@ -5,43 +5,57 @@ import SwiftUI
 
 /// This is an Example for Experimental API that is subject to change.
 struct GeofencingUserLocation: View {
-    @State private var initialLocation: CLLocationCoordinate2D?
+    @State private var region: CircularRegion?
     @ObservedObject private var geofencing = Geofencing()
     private let initialLocationProvider = InitialLocationProvider()
 
     var body: some View {
         MapReader { proxy in
-            Map(initialViewport: .followPuck(zoom: 16)) {
+            Map(initialViewport: .followPuck(zoom: 13)) {
                 Puck2D(bearing: .heading)
-                if let initialLocation = initialLocation {
-                    GeofenceCircle(id: "circle", location: initialLocation, event: geofencing.lastEvent)
+                if let region {
+                    GeofenceCircle(id: "circle", region: region, event: geofencing.lastEvent)
                 }
             }
             .onMapLoaded { _ in startGeofencing(proxy.location) }
+            .ignoresSafeArea()
+            .overlay(alignment: .bottom) {
+                PermissionView()
+            }
         }
-        .ignoresSafeArea()
     }
 
     func startGeofencing(_ locationManager: LocationManager?) {
         geofencing.start {
             initialLocationProvider.start(locationManager: locationManager) { initialLocation in
-                var feature = Feature(geometry: .geofenceCircle(initialLocation))
+                let _region = CircularRegion(center: Point(initialLocation), radius: .random(in: 200...300))
+                var feature = Feature(geometry: _region.center)
                 feature.identifier = .string("geofence-source-circle")
-                feature = feature.properties([GeofencingPropertiesKeys.dwellTimeKey: 1])
-                    geofencing.add(feature: feature, onSuccess: { _initialLocation.wrappedValue = initialLocation })
+                feature = feature.properties([
+                    GeofencingPropertiesKeys.dwellTimeKey: 1,
+                    GeofencingPropertiesKeys.pointRadiusKey: .number(_region.radius)
+                ])
+                geofencing.add(feature: feature) {
+                    region = _region
+                }
             }
         }
     }
 }
 
+private struct CircularRegion {
+    let center: Turf.Point
+    let radius: CLLocationDistance
+}
+
 private struct GeofenceCircle: MapStyleContent {
     var id: String
-    var location: CLLocationCoordinate2D
+    var region: CircularRegion
     var event: GeofenceEvent?
 
     var body: some MapStyleContent {
         GeoJSONSource(id: "geofence-source-\(id)")
-            .data(.geofenceCircle(location))
+            .data(.geometry(Polygon(center: region.center.coordinates, radius: region.radius, vertices: 64).geometry))
 
         FillLayer(id: "geofence-layer-\(id)", source: "geofence-source-\(id)")
             .fillColor(color(for: event))
@@ -62,6 +76,30 @@ private struct GeofenceCircle: MapStyleContent {
     }
 }
 
+private struct PermissionView: View {
+    var body: some View {
+        HStack {
+            OvalButton(title: "Enable Pushes") {
+                Task {
+                    // Request notifications (alert, badge) once via async/await.
+                    do {
+                        let granted = try await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge])
+                        print("Notification permission request finished. Granted: \(granted)")
+                    } catch {
+                        print("Notification permission request failed with error: \(error)")
+                    }
+                }
+            }
+            #if !os(visionOS)
+            OvalButton(title: "Enable Location") {
+                CLLocationManager().requestAlwaysAuthorization()
+            }
+            #endif
+        }
+        .padding(30)
+    }
+}
+
 private final class InitialLocationProvider {
     private var cancellables = Set<AnyCancelable>()
 
@@ -138,15 +176,3 @@ private struct GeofenceEvent {
     var type: GeofenceEventType
     var feature: Turf.Feature
 }
-
-private extension GeoJSONSourceData {
-    static func geofenceCircle(_ center: LocationCoordinate2D) -> GeoJSONSourceData {
-        .geometry(.geofenceCircle(center))
-    }
-}
-
-private extension Turf.Geometry {
-    static func geofenceCircle(_ center: LocationCoordinate2D) -> Turf.Geometry {
-        .polygon(Polygon(center: center, radius: 30, vertices: 64))
-    }
-}