[Backport release/v0.19] [MAPSIOS-2100] Restore map panning on ViewAnnotations (#10338)

Backport e1ef22e3502b82bb6f386dda4666a5971f91ccf4 from #10186.

Co-authored-by: Patrick Leonard <pjleonard37@users.noreply.github.com>
GitOrigin-RevId: 2717ac3246ccdd0be1a3da6d7ffc34d205205da5

Author: 2 people

CHANGELOG.md

@@ -4,6 +4,12 @@ Mapbox welcomes participation and contributions from everyone.
 
 ## main
 
+### Features ✨ and improvements 🏁
+* Add animation to experimental `Marker` with two animation triggers: `appear` and `disappear`. Each trigger accepts `MarkerAnimationEffect` including `wiggle` (pendulum rotation), `scale`, `fadeIn`, and `fadeOut`. Effects can be customized with parameters (e.g., `scale(from: 0.5, to: 1.5)`, `fade(from: 0.5, to: 1.0)`) and combined for rich animations. See `MarkersExample` for usage.
+
+### Bug fixes 🐞
+* Fix map panning not working on ViewAnnotations
+
 ## 11.19.0-rc.1 - 12 February, 2026
 
 ## 11.19.0-rc.1

Sources/MapboxMaps/Foundation/ViewAnnotationsContainer.swift

@@ -1,6 +1,9 @@
 import UIKit
 
-final class ViewAnnotationsContainer: UIView {
+/// Views conforming to this protocol allow map gestures to pass through them.
+protocol AllowsMapGestures {}
+
+final class ViewAnnotationsContainer: UIView, AllowsMapGestures {
     var subviewDebugFrames: Bool = false {
         didSet {
             if subviewDebugFrames != oldValue {

Sources/MapboxMaps/Gestures/GestureHandlers/DoubleTapToZoomInGestureHandler.swift

@@ -45,8 +45,7 @@ extension DoubleTapToZoomInGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments)
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 }

Sources/MapboxMaps/Gestures/GestureHandlers/PanGestureHandler.swift

@@ -192,9 +192,8 @@ extension PanGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments).
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 }
 

Sources/MapboxMaps/Gestures/GestureHandlers/PinchGestureHandler.swift

@@ -97,9 +97,8 @@ extension PinchGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments)
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 
     func gestureRecognizer(

Sources/MapboxMaps/Gestures/GestureHandlers/QuickZoomGestureHandler.swift

@@ -55,8 +55,7 @@ extension QuickZoomGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments)
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 }

Sources/MapboxMaps/Gestures/GestureHandlers/RotateGestureHandler.swift

@@ -105,8 +105,7 @@ extension RotateGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments)
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 }

Sources/MapboxMaps/Gestures/GestureHandlers/SingleTapGestureHandler.swift

@@ -44,8 +44,7 @@ extension SingleTapGestureHandler: UIGestureRecognizerDelegate {
         _ gestureRecognizer: UIGestureRecognizer,
         shouldReceive touch: UITouch
     ) -> Bool {
-        /// Only handle touches that targeting the map, but any of its subviews (including view annotations and ornaments)
         assert(self.gestureRecognizer == gestureRecognizer)
-        return gestureRecognizer.attachedToSameView(as: touch)
+        return gestureRecognizer.shouldAllowMapGesture(for: touch)
     }
 }

Sources/MapboxMaps/Gestures/GestureHandlers/UIGestureRecognizer+Extensions.swift

@@ -1,17 +1,57 @@
 import UIKit
 
-/// Can be used to distinguish between recognizers attached to the SwiftUI hosting view and recognizers added tp underlying UIKit view
-/// SwiftUI API's add recognizers to the hosting view
 extension UIGestureRecognizer {
+    // MARK: - SwiftUI Compatibility
+
+    /// Checks if two gesture recognizers are attached to the same view.
+    /// Used to distinguish between recognizers attached to the SwiftUI hosting view
+    /// and recognizers added to the underlying UIKit view.
     func attachedToSameView(as other: UIGestureRecognizer) -> Bool {
        view === other.view
     }
-}
 
-/// Can be used to decide whether the recognizer should receive the touch.
-/// In case where the recognizer is known to be attached to some view we may ignore any touches that is going to be delievered to unrelated view.
-extension UIGestureRecognizer {
+    /// Checks if a touch is directly on the same view as the gesture recognizer.
+    /// Returns true only if `touch.view === gestureRecognizer.view`.
     func attachedToSameView(as touch: UITouch) -> Bool {
         view === touch.view
     }
+
+    // MARK: - Map Gesture Filtering
+
+    /// Determines whether a map gesture should be allowed for the given touch.
+    ///
+    /// This method walks up the view hierarchy from the touch location to determine if the gesture
+    /// should be recognized. Map gestures are allowed when:
+    /// - The touch is directly on the map view, OR
+    /// - The touch is on a view that conforms to `AllowsMapGestures` (e.g., `ViewAnnotationsContainer`)
+    ///
+    /// Map gestures are blocked when:
+    /// - The touch is on UI controls/ornaments (compass, scale bar, indoor selector, etc.)
+    /// - The touch is outside the map view hierarchy
+    ///
+    /// - Parameter touch: The touch to evaluate
+    /// - Returns: `true` if the map gesture should be recognized, `false` otherwise
+    func shouldAllowMapGesture(for touch: UITouch) -> Bool {
+        guard let gestureView = view, let touchView = touch.view else {
+            return false
+        }
+
+        // Allow touches directly on the map view itself
+        if touchView === gestureView {
+            return true
+        }
+
+        // Walk up the view hierarchy to find a view that allows map gestures
+        // Stop before reaching the gesture view (to block direct children like ornaments)
+        var currentView: UIView? = touchView
+        while let view = currentView, view !== gestureView {
+            if view is AllowsMapGestures {
+                return true
+            }
+            currentView = view.superview
+        }
+
+        // Touch is on a direct child (ornament) or outside hierarchy - reject
+        return false
+    }
 }

Tests/MapboxMapsTests/Gestures/GestureHandlers/PanGestureHandlerTests.swift

@@ -489,4 +489,114 @@ final class PanGestureHandlerTests: XCTestCase {
 
         panGestureHandler.assertNotRecognizedSimultaneously(gestureRecognizer, with: interruptingRecognizers)
     }
+
+    // MARK: - shouldReceive touch tests
+
+    func testShouldReceiveTouchOnMapView() {
+        // Given: A touch directly on the map view
+        let touch = MockUITouch(view: view)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should accept the touch
+        XCTAssertTrue(shouldReceive, "Gesture should receive touches directly on the map view")
+    }
+
+    func testShouldReceiveTouchOnViewAnnotation() {
+        // Given: A ViewAnnotationsContainer (conforms to AllowsMapGestures)
+        let viewAnnotationsContainer = ViewAnnotationsContainer()
+        view.addSubview(viewAnnotationsContainer)
+
+        // And: A view annotation inside the container
+        let annotationView = UIView()
+        viewAnnotationsContainer.addSubview(annotationView)
+
+        // And: A touch on the annotation view
+        let touch = MockUITouch(view: annotationView)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should accept the touch (this would have failed before the fix)
+        XCTAssertTrue(shouldReceive, "Gesture should receive touches on view annotations to allow map panning")
+    }
+
+    func testShouldReceiveTouchOnViewAnnotationsContainer() {
+        // Given: A ViewAnnotationsContainer
+        let viewAnnotationsContainer = ViewAnnotationsContainer()
+        view.addSubview(viewAnnotationsContainer)
+
+        // And: A touch directly on the container
+        let touch = MockUITouch(view: viewAnnotationsContainer)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should accept the touch
+        XCTAssertTrue(shouldReceive, "Gesture should receive touches on ViewAnnotationsContainer")
+    }
+
+    func testShouldNotReceiveTouchOnOrnament() {
+        // Given: A regular UIView representing an ornament (does not conform to AllowsMapGestures)
+        let ornamentView = UIView()
+        view.addSubview(ornamentView)
+
+        // And: A touch on the ornament
+        let touch = MockUITouch(view: ornamentView)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should reject the touch to allow ornament to handle it
+        XCTAssertFalse(shouldReceive, "Gesture should not receive touches on ornaments/UI controls")
+    }
+
+    func testShouldNotReceiveTouchOutsideMapView() {
+        // Given: A view outside the map view hierarchy
+        let externalView = UIView()
+
+        // And: A touch on the external view
+        let touch = MockUITouch(view: externalView)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should reject the touch
+        XCTAssertFalse(shouldReceive, "Gesture should not receive touches outside the map view hierarchy")
+    }
+
+    func testShouldReceiveTouchOnNestedViewAnnotation() {
+        // Given: A ViewAnnotationsContainer
+        let viewAnnotationsContainer = ViewAnnotationsContainer()
+        view.addSubview(viewAnnotationsContainer)
+
+        // And: A nested view hierarchy inside a view annotation
+        let annotationView = UIView()
+        viewAnnotationsContainer.addSubview(annotationView)
+        let button = UIButton()
+        annotationView.addSubview(button)
+        let label = UILabel()
+        button.addSubview(label)
+
+        // And: A touch on a deeply nested view
+        let touch = MockUITouch(view: label)
+
+        // When: Checking if gesture should receive the touch
+        let shouldReceive = panGestureHandler.gestureRecognizer(gestureRecognizer, shouldReceive: touch)
+
+        // Then: Should accept the touch (walks up hierarchy to find AllowsMapGestures)
+        XCTAssertTrue(shouldReceive, "Gesture should receive touches on nested views within view annotations")
+    }
+}
+
+// MARK: - MockUITouch
+
+private final class MockUITouch: UITouch {
+    override var view: UIView? { _view }
+    private let _view: UIView
+
+    init(view: UIView) {
+        self._view = view
+    }
 }