Fix crash in Camera API methods with invalid coordinates (#8617)

Fixes crash in camera API methods when given invalid coordinates (NaN or
infinity values). These camera methods now catch exceptions and return
empty `CameraOptions` instead of crashing the app.

GitOrigin-RevId: eadf53dcf2536f639805df0e0d7c42042df198dc

Author: pjleonard37

CHANGELOG.md

@@ -4,6 +4,9 @@ Mapbox welcomes participation and contributions from everyone.
 
 ## main
 
+### Bug fixes 🐞
+* Fixed crash in camera API methods when given invalid coordinates (NaN or infinity values). Methods now return empty `CameraOptions` instead of crashing.
+
 ## 11.18.0-beta.1 - 17 December, 2025
 
 ### Breaking changes ⚠️

Sources/MapboxMaps/Foundation/MapboxMap.swift

@@ -539,7 +539,8 @@ public final class MapboxMap: StyleManager {
     ///   - pitch: The new pitch to be used by the camera, in degrees (0°, 85°) with 0° being a top-down view.
     ///   - maxZoom: The maximum zoom level to allow when the camera would transition to the specified bounds.
     ///   - offset: The center of the given bounds relative to the map's center, measured in points.
-    /// - Returns: A `CameraOptions` that fits the provided constraints
+    /// - Returns: A `CameraOptions` that fits the provided constraints. Returns an empty CameraOptions if the
+    ///     calculation fails (e.g., when coordinates are invalid).
     /// - Important:
     ///  The equivalent of the following deprecated call, where `point1` and `point2` are the most southwestern and northeastern points:
     ///  ```swift
@@ -578,14 +579,21 @@ public final class MapboxMap: StyleManager {
                        pitch: Double?,
                        maxZoom: Double?,
                        offset: CGPoint?) -> CameraOptions {
-        return CameraOptions.Marshaller.toSwift(
-            __map.cameraForCoordinateBounds(
-                for: coordinateBounds,
-                padding: padding?.toMBXEdgeInsetsValue(),
-                bearing: bearing?.NSNumber,
-                pitch: pitch?.NSNumber,
-                maxZoom: maxZoom?.NSNumber,
-                offset: offset?.screenCoordinate))
+        do {
+            let coreOptions = try NSExceptionHandler.try {
+                __map.cameraForCoordinateBounds(
+                    for: coordinateBounds,
+                    padding: padding?.toMBXEdgeInsetsValue(),
+                    bearing: bearing?.NSNumber,
+                    pitch: pitch?.NSNumber,
+                    maxZoom: maxZoom?.NSNumber,
+                    offset: offset?.screenCoordinate)
+            }
+            return CameraOptions.Marshaller.toSwift(coreOptions)
+        } catch {
+            Log.error("camera(for coordinateBounds:) failed with error: \(error). Returning empty CameraOptions.")
+            return CameraOptions()
+        }
     }
 
     /// Calculates a `CameraOptions` to fit a list of coordinates.
@@ -599,7 +607,8 @@ public final class MapboxMap: StyleManager {
     ///              If you want to apply padding to the map use `camera` parameter on ``camera(for:camera:coordinatesPadding:maxZoom:offset:)``
     ///   - bearing: The new bearing to be used by the camera, in degrees (0°, 360°) clockwise from true north.
     ///   - pitch: The new pitch to be used by the camera, in degrees (0°, 85°) with 0° being a top-down view.
-    /// - Returns: A `CameraOptions` that fits the provided constraints
+    /// - Returns: A `CameraOptions` that fits the provided constraints. Returns an empty CameraOptions if the
+    ///     calculation fails (e.g., when coordinates are invalid).
     /// - Important:
     ///  The equivalent of the following deprecated call:
     ///  ```swift
@@ -635,12 +644,19 @@ public final class MapboxMap: StyleManager {
                        padding: UIEdgeInsets?,
                        bearing: Double?,
                        pitch: Double?) -> CameraOptions {
-        return CameraOptions.Marshaller.toSwift(
-            __map.cameraForCoordinates(
-                for: coordinates.map { Coordinate2D(value: $0) },
-                padding: padding?.toMBXEdgeInsetsValue(),
-                bearing: bearing?.NSNumber,
-                pitch: pitch?.NSNumber))
+        do {
+            let coreOptions = try NSExceptionHandler.try {
+                __map.cameraForCoordinates(
+                    for: coordinates.map { Coordinate2D(value: $0) },
+                    padding: padding?.toMBXEdgeInsetsValue(),
+                    bearing: bearing?.NSNumber,
+                    pitch: pitch?.NSNumber)
+            }
+            return CameraOptions.Marshaller.toSwift(coreOptions)
+        } catch {
+            Log.error("camera(for coordinates:) failed with error: \(error). Returning empty CameraOptions.")
+            return CameraOptions()
+        }
     }
 
     /// Calculates a `CameraOptions` to fit a list of coordinates into a sub-rect of the map.
@@ -716,7 +732,8 @@ public final class MapboxMap: StyleManager {
     ///   - padding: The new padding to be used by the camera.
     ///   - bearing: The new bearing to be used by the camera.
     ///   - pitch: The new pitch to be used by the camera.
-    /// - Returns: A `CameraOptions` that fits the provided constraints
+    /// - Returns: A `CameraOptions` that fits the provided constraints. Returns an empty CameraOptions if the
+    ///     calculation fails (e.g., when coordinates are invalid).
     ///
     /// - Important:
     ///  The equivalent of the following deprecated call:
@@ -749,12 +766,19 @@ public final class MapboxMap: StyleManager {
                        padding: UIEdgeInsets,
                        bearing: CGFloat?,
                        pitch: CGFloat?) -> CameraOptions {
-        return CameraOptions.Marshaller.toSwift(
-            __map.cameraForGeometry(
-                for: MapboxCommon.Geometry(geometry),
-                padding: padding.toMBXEdgeInsetsValue(),
-                bearing: bearing?.NSNumber,
-                pitch: pitch?.NSNumber))
+        do {
+            let coreOptions = try NSExceptionHandler.try {
+                __map.cameraForGeometry(
+                    for: MapboxCommon.Geometry(geometry),
+                    padding: padding.toMBXEdgeInsetsValue(),
+                    bearing: bearing?.NSNumber,
+                    pitch: pitch?.NSNumber)
+            }
+            return CameraOptions.Marshaller.toSwift(coreOptions)
+        } catch {
+            Log.error("camera(for geometry:) failed with error: \(error). Returning empty CameraOptions.")
+            return CameraOptions()
+        }
     }
 
     // MARK: - CameraOptions to CoordinateBounds
@@ -962,10 +986,19 @@ public final class MapboxMap: StyleManager {
     ///   - to: The point to which the map is dragged.
     ///
     /// - Returns:
-    ///     The camera options object showing end point.
+    ///     The camera options object showing end point. Returns an empty CameraOptions if the
+    ///     drag calculation fails (e.g., when coordinates are invalid). An empty CameraOptions
+    ///     passed to `setCamera` acts as a no-op, leaving the camera unchanged.
     public func dragCameraOptions(from: CGPoint, to: CGPoint) -> CameraOptions {
-        let options = __map.cameraForDrag(forStart: from.screenCoordinate, end: to.screenCoordinate)
-        return CameraOptions.Marshaller.toSwift(options)
+        do {
+            let coreOptions = try NSExceptionHandler.try {
+                __map.cameraForDrag(forStart: from.screenCoordinate, end: to.screenCoordinate)
+            }
+            return CameraOptions.Marshaller.toSwift(coreOptions)
+        } catch {
+            Log.error("dragCameraOptions failed with error: \(error). Returning empty CameraOptions.")
+            return CameraOptions()
+        }
     }
 
     /// :nodoc:

Tests/MapboxMapsTests/Foundation/MapboxMapTests.swift

@@ -539,4 +539,108 @@ final class MapboxMapTests: XCTestCase {
         XCTAssertEqual(mapboxMap.viewAnnotationAvoidLayers, layers)
         XCTAssertEqual(mapboxMap.__testingMap.getViewAnnotationAvoidLayers(), layers)
     }
+
+    // MARK: - Exception Handling Tests
+
+    func testDragCameraOptionsWithNaNCoordinates() {
+        // This test verifies that dragCameraOptions catches exceptions from the native layer
+        // when given invalid coordinates (NaN) and returns empty CameraOptions instead of crashing.
+
+        let fromPoint = CGPoint(x: 0, y: 0)
+        let toPoint = CGPoint(x: Double.nan, y: Double.nan)
+
+        let cameraOptions = mapboxMap.dragCameraOptions(from: fromPoint, to: toPoint)
+
+        // Should not crash and should return empty CameraOptions (all properties nil)
+        XCTAssertNotNil(cameraOptions, "dragCameraOptions should not crash with NaN coordinates")
+        XCTAssertNil(cameraOptions.center, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.zoom, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.bearing, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.pitch, "CameraOptions should be empty after exception")
+    }
+
+    func testDragCameraOptionsWithInfiniteCoordinates() {
+        // This test verifies that dragCameraOptions catches exceptions from the native layer
+        // when given invalid coordinates (infinity) and returns empty CameraOptions instead of crashing.
+
+        let fromPoint = CGPoint(x: 0, y: 0)
+        let toPoint = CGPoint(x: Double.infinity, y: Double.infinity)
+
+        let cameraOptions = mapboxMap.dragCameraOptions(from: fromPoint, to: toPoint)
+
+        // Should not crash and should return empty CameraOptions (all properties nil)
+        XCTAssertNotNil(cameraOptions, "dragCameraOptions should not crash with infinite coordinates")
+        XCTAssertNil(cameraOptions.center, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.zoom, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.bearing, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.pitch, "CameraOptions should be empty after exception")
+    }
+
+    func testCameraForCoordinateBoundsWithNaNCoordinates() {
+        // Test camera(for coordinateBounds:...) with invalid bounds containing NaN
+        // Note: The native method handles this gracefully with its own try/catch,
+        // but we wrap it with NSExceptionHandler.try for additional safety.
+
+        let invalidBounds = CoordinateBounds(
+            southwest: CLLocationCoordinate2D(latitude: Double.nan, longitude: Double.nan),
+            northeast: CLLocationCoordinate2D(latitude: Double.nan, longitude: Double.nan)
+        )
+
+        let cameraOptions = mapboxMap.camera(
+            for: invalidBounds,
+            padding: nil,
+            bearing: nil,
+            pitch: nil,
+            maxZoom: nil,
+            offset: nil
+        )
+
+        // Should not crash and should return empty CameraOptions
+        XCTAssertNotNil(cameraOptions)
+        XCTAssertNil(cameraOptions.center, "CameraOptions should be empty when given invalid bounds")
+        XCTAssertNil(cameraOptions.zoom, "CameraOptions should be empty when given invalid bounds")
+    }
+
+    func testCameraForCoordinatesWithNaNCoordinates() {
+        // Test camera(for coordinates:...) with array containing only invalid NaN/infinity coordinates
+        // Note: The native method handles this gracefully with its own try/catch,
+        // but we wrap it with NSExceptionHandler.try for additional safety.
+
+        let invalidCoordinates = [
+            CLLocationCoordinate2D(latitude: Double.nan, longitude: Double.nan),
+            CLLocationCoordinate2D(latitude: Double.infinity, longitude: Double.infinity)
+        ]
+
+        let cameraOptions = mapboxMap.camera(
+            for: invalidCoordinates,
+            padding: nil,
+            bearing: nil,
+            pitch: nil
+        )
+
+        // Should not crash and should return empty CameraOptions
+        XCTAssertNotNil(cameraOptions)
+        XCTAssertNil(cameraOptions.center, "CameraOptions should be empty when given invalid coordinates")
+        XCTAssertNil(cameraOptions.zoom, "CameraOptions should be empty when given invalid coordinates")
+    }
+
+    func testCameraForGeometryWithNaNCoordinates() {
+        // Test camera(for geometry:...) with geometry containing NaN coordinates
+        // This method can throw exceptions from the native layer, similar to dragCameraOptions.
+
+        let invalidPoint = Point(CLLocationCoordinate2D(latitude: Double.nan, longitude: Double.nan))
+        let geometry = Geometry.point(invalidPoint)
+
+        let cameraOptions = mapboxMap.camera(
+            for: geometry,
+            padding: UIEdgeInsets(top: 10, left: 10, bottom: 10, right: 10),
+            bearing: nil,
+            pitch: nil
+        )
+
+        // Should not crash and should return empty CameraOptions
+        XCTAssertNotNil(cameraOptions)
+        XCTAssertNil(cameraOptions.center, "CameraOptions should be empty after exception")
+        XCTAssertNil(cameraOptions.zoom, "CameraOptions should be empty after exception")
+    }
 }