fix: prevent crash on simultaneous min/max zoom changes and support zoom during navigation

Author: jokerttu

android/src/main/java/com/google/android/react/navsdk/MapViewController.java

@@ -15,15 +15,18 @@
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
+import android.util.Log;
 import androidx.core.util.Supplier;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.google.android.gms.maps.CameraUpdateFactory;
 import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.GoogleMap.CameraPerspective;
 import com.google.android.gms.maps.model.BitmapDescriptor;
 import com.google.android.gms.maps.model.BitmapDescriptorFactory;
 import com.google.android.gms.maps.model.CameraPosition;
 import com.google.android.gms.maps.model.Circle;
 import com.google.android.gms.maps.model.CircleOptions;
+import com.google.android.gms.maps.model.FollowMyLocationOptions;
 import com.google.android.gms.maps.model.GroundOverlay;
 import com.google.android.gms.maps.model.GroundOverlayOptions;
 import com.google.android.gms.maps.model.LatLng;
@@ -42,6 +45,7 @@
 import java.util.Map;
 
 public class MapViewController implements INavigationViewControllerProperties {
+  private static final String TAG = "MapViewController";
   private GoogleMap mGoogleMap;
   private Supplier<Activity> activitySupplier;
   private INavigationViewCallback mNavigationViewCallback;
@@ -883,23 +887,35 @@ public void setMinZoomLevel(float minZoomLevel) {
       return;
     }
 
-    // Get the effective max zoom for comparison
-    float maxZoom =
+    minZoomLevelPreference = minZoomLevel;
+
+    // Reset both preferences first so the new min/max pair is always applied
+    // atomically. Without this, Fabric can deliver minZoomLevel and maxZoomLevel
+    // prop updates in any order, causing a transient state where min > max.
+    mGoogleMap.resetMinMaxZoomPreference();
+
+    float effectiveMin = (minZoomLevel < 0.0f) ? mGoogleMap.getMinZoomLevel() : minZoomLevel;
+    float effectiveMax =
         (maxZoomLevelPreference != null && maxZoomLevelPreference >= 0.0f)
             ? maxZoomLevelPreference
             : mGoogleMap.getMaxZoomLevel();
 
-    // Validate that min is not greater than max (unless using -1 sentinel)
-    if (minZoomLevel >= 0.0f && minZoomLevel > maxZoom) {
-      throw new IllegalArgumentException(
-          "Minimum zoom level cannot be greater than maximum zoom level");
+    if (effectiveMin > effectiveMax) {
+      Log.w(
+          TAG,
+          "minZoomLevel ("
+              + effectiveMin
+              + ") is greater than maxZoomLevel ("
+              + effectiveMax
+              + "). Ignoring zoom level constraints.");
+      return;
     }
 
-    minZoomLevelPreference = minZoomLevel;
-
-    // Use map's current minZoomLevel if -1 is provided
-    float effectiveMin = (minZoomLevel < 0.0f) ? mGoogleMap.getMinZoomLevel() : minZoomLevel;
     mGoogleMap.setMinZoomPreference(effectiveMin);
+
+    if (maxZoomLevelPreference != null) {
+      mGoogleMap.setMaxZoomPreference(effectiveMax);
+    }
   }
 
   @Override
@@ -908,23 +924,35 @@ public void setMaxZoomLevel(float maxZoomLevel) {
       return;
     }
 
-    // Get the effective min zoom for comparison
-    float minZoom =
+    maxZoomLevelPreference = maxZoomLevel;
+
+    // Reset both preferences first so the new min/max pair is always applied
+    // atomically. Without this, Fabric can deliver minZoomLevel and maxZoomLevel
+    // prop updates in any order, causing a transient state where min > max.
+    mGoogleMap.resetMinMaxZoomPreference();
+
+    float effectiveMax = (maxZoomLevel < 0.0f) ? mGoogleMap.getMaxZoomLevel() : maxZoomLevel;
+    float effectiveMin =
         (minZoomLevelPreference != null && minZoomLevelPreference >= 0.0f)
             ? minZoomLevelPreference
             : mGoogleMap.getMinZoomLevel();
 
-    // Validate that max is not less than min (unless using -1 sentinel)
-    if (maxZoomLevel >= 0.0f && maxZoomLevel < minZoom) {
-      throw new IllegalArgumentException(
-          "Maximum zoom level cannot be less than minimum zoom level");
+    if (effectiveMin > effectiveMax) {
+      Log.w(
+          TAG,
+          "minZoomLevel ("
+              + effectiveMin
+              + ") is greater than maxZoomLevel ("
+              + effectiveMax
+              + "). Ignoring zoom level constraints.");
+      return;
     }
 
-    maxZoomLevelPreference = maxZoomLevel;
-
-    // Use map's current maxZoomLevel if -1 is provided
-    float effectiveMax = (maxZoomLevel < 0.0f) ? mGoogleMap.getMaxZoomLevel() : maxZoomLevel;
     mGoogleMap.setMaxZoomPreference(effectiveMax);
+
+    if (minZoomLevelPreference != null) {
+      mGoogleMap.setMinZoomPreference(effectiveMin);
+    }
   }
 
   public void setZoomGesturesEnabled(boolean enabled) {
@@ -1005,16 +1033,27 @@ public void resetMinMaxZoomLevel() {
       return;
     }
 
+    minZoomLevelPreference = null;
+    maxZoomLevelPreference = null;
     mGoogleMap.resetMinMaxZoomPreference();
   }
 
   @SuppressLint("MissingPermission")
-  public void setFollowingPerspective(int jsValue) {
+  public void setFollowingPerspective(int jsValue, float zoomLevel) {
     if (mGoogleMap == null) {
       return;
     }
 
-    mGoogleMap.followMyLocation(EnumTranslationUtil.getCameraPerspectiveFromJsValue(jsValue));
+    @CameraPerspective
+    int perspective = EnumTranslationUtil.getCameraPerspectiveFromJsValue(jsValue);
+
+    if (zoomLevel >= 0.0f) {
+      FollowMyLocationOptions options =
+          FollowMyLocationOptions.builder().setZoomLevel(zoomLevel).build();
+      mGoogleMap.followMyLocation(perspective, options);
+    } else {
+      mGoogleMap.followMyLocation(perspective);
+    }
   }
 
   public void setPadding(int top, int left, int bottom, int right) {

android/src/main/java/com/google/android/react/navsdk/NavAutoModule.java

@@ -393,14 +393,15 @@ public void setMyLocationEnabled(boolean enabled) {
   }
 
   @Override
-  public void setFollowingPerspective(double perspective) {
+  public void setFollowingPerspective(double perspective, double zoomLevel) {
     int jsValue = (int) perspective;
+    float zoom = (float) zoomLevel;
     UiThreadUtil.runOnUiThread(
         () -> {
           if (mMapViewController == null) {
             return;
           }
-          mMapViewController.setFollowingPerspective(jsValue);
+          mMapViewController.setFollowingPerspective(jsValue, zoom);
         });
   }
 

android/src/main/java/com/google/android/react/navsdk/NavViewModule.java

@@ -405,7 +405,8 @@ public void setNavigationUIEnabled(String nativeID, boolean enabled, final Promi
   }
 
   @Override
-  public void setFollowingPerspective(String nativeID, double perspective, final Promise promise) {
+  public void setFollowingPerspective(
+      String nativeID, double perspective, double zoomLevel, final Promise promise) {
     UiThreadUtil.runOnUiThread(
         () -> {
           IMapViewFragment fragment = mNavViewManager.getFragmentByNativeId(nativeID);
@@ -415,7 +416,9 @@ public void setFollowingPerspective(String nativeID, double perspective, final P
           }
 
           if (fragment instanceof INavViewFragment) {
-            fragment.getMapController().setFollowingPerspective((int) perspective);
+            fragment
+                .getMapController()
+                .setFollowingPerspective((int) perspective, (float) zoomLevel);
             promise.resolve(null);
           } else {
             promise.reject(JsErrors.NOT_NAV_VIEW_ERROR_CODE, JsErrors.NOT_NAV_VIEW_ERROR_MESSAGE);

example/e2e/map.test.js

@@ -89,4 +89,11 @@ describe('Map view tests', () => {
     await expectNoErrors();
     await expectSuccess();
   });
+
+  it('MT10 - test min and max zoom level constraints', async () => {
+    await selectTestByName('testMinMaxZoomLevels');
+    await waitForTestToFinish();
+    await expectNoErrors();
+    await expectSuccess();
+  });
 });

example/src/screens/IntegrationTestsScreen.tsx

@@ -55,6 +55,7 @@ import {
   testStartGuidanceWithoutDestinations,
   testRouteTokenOptionsValidation,
   testMapStyle,
+  testMinMaxZoomLevels,
   NO_ERRORS_DETECTED_LABEL,
 } from './integration_tests/integration_test';
 
@@ -127,6 +128,12 @@ const IntegrationTestsScreen = () => {
     boolean | undefined
   >(undefined);
   const [mapStyle, setMapStyle] = useState<string | undefined>(undefined);
+  const [minZoomLevel, setMinZoomLevel] = useState<number | undefined>(
+    undefined
+  );
+  const [maxZoomLevel, setMaxZoomLevel] = useState<number | undefined>(
+    undefined
+  );
 
   const onMapReady = useCallback(async () => {
     try {
@@ -236,6 +243,8 @@ const IntegrationTestsScreen = () => {
       setZoomControlsEnabled,
       setMapToolbarEnabled,
       setMapStyle,
+      setMinZoomLevel,
+      setMaxZoomLevel,
     };
   };
 
@@ -305,6 +314,9 @@ const IntegrationTestsScreen = () => {
       case 'testMapStyle':
         await testMapStyle(getTestTools());
         break;
+      case 'testMinMaxZoomLevels':
+        await testMinMaxZoomLevels(getTestTools());
+        break;
       default:
         resetTestState();
         break;
@@ -347,6 +359,8 @@ const IntegrationTestsScreen = () => {
           zoomControlsEnabled={zoomControlsEnabled}
           mapToolbarEnabled={mapToolbarEnabled}
           mapStyle={mapStyle}
+          minZoomLevel={minZoomLevel}
+          maxZoomLevel={maxZoomLevel}
         />
       </View>
       <View style={{ flex: 4 }}>
@@ -518,6 +532,13 @@ const IntegrationTestsScreen = () => {
           }}
           testID="testMapStyle"
         />
+        <ExampleAppButton
+          title="testMinMaxZoomLevels"
+          onPress={() => {
+            runTest('testMinMaxZoomLevels');
+          }}
+          testID="testMinMaxZoomLevels"
+        />
       </OverlayModal>
     </View>
   );

example/src/screens/integration_tests/integration_test.ts

@@ -64,6 +64,8 @@ interface TestTools {
   setZoomControlsEnabled: (enabled: boolean | undefined) => void;
   setMapToolbarEnabled: (enabled: boolean | undefined) => void;
   setMapStyle: (style: string | undefined) => void;
+  setMinZoomLevel: (level: number | undefined) => void;
+  setMaxZoomLevel: (level: number | undefined) => void;
 }
 
 const NAVIGATOR_NOT_READY_ERROR_CODE = 'NO_NAVIGATOR_ERROR_CODE';
@@ -1667,3 +1669,106 @@ export const testMapStyle = async (testTools: TestTools) => {
     failTest(`Failed to set mapStyle: ${error}`);
   }
 };
+
+export const testMinMaxZoomLevels = async (testTools: TestTools) => {
+  const {
+    mapViewController,
+    passTest,
+    failTest,
+    expectFalseError,
+    setMinZoomLevel,
+    setMaxZoomLevel,
+  } = testTools;
+
+  if (!mapViewController) {
+    return failTest('mapViewController was expected to exist');
+  }
+
+  try {
+    // Test 1: Set valid min and max zoom levels (min < max)
+    setMinZoomLevel(5);
+    setMaxZoomLevel(15);
+    await delay(200);
+
+    // Verify camera zoom is constrained - move to zoom below min
+    mapViewController.moveCamera({
+      target: { lat: 37.7749, lng: -122.4194 },
+      bearing: 0,
+      tilt: 0,
+      zoom: 3,
+    });
+    await delay(200);
+
+    const posAfterMinClamp = await mapViewController.getCameraPosition();
+    if ((posAfterMinClamp.zoom ?? 0) < 5) {
+      return expectFalseError(
+        `zoom (${posAfterMinClamp.zoom}) should be >= minZoomLevel (5)`
+      );
+    }
+
+    // Move to zoom above max
+    mapViewController.moveCamera({
+      target: { lat: 37.7749, lng: -122.4194 },
+      bearing: 0,
+      tilt: 0,
+      zoom: 20,
+    });
+    await delay(200);
+
+    const posAfterMaxClamp = await mapViewController.getCameraPosition();
+    if ((posAfterMaxClamp.zoom ?? 0) > 15) {
+      return expectFalseError(
+        `zoom (${posAfterMaxClamp.zoom}) should be <= maxZoomLevel (15)`
+      );
+    }
+
+    // Test 2: Set zoom within range - should work normally
+    mapViewController.moveCamera({
+      target: { lat: 37.7749, lng: -122.4194 },
+      bearing: 0,
+      tilt: 0,
+      zoom: 10,
+    });
+    await delay(200);
+
+    const posInRange = await mapViewController.getCameraPosition();
+    if (posInRange.zoom !== 10) {
+      return expectFalseError(
+        `zoom (${posInRange.zoom}) should be 10 when within range`
+      );
+    }
+
+    // Test 3: Reset zoom levels
+    setMinZoomLevel(undefined);
+    setMaxZoomLevel(undefined);
+    await delay(200);
+
+    // Test 4: Invalid case - min > max (should not crash, constraints ignored)
+    setMinZoomLevel(15);
+    setMaxZoomLevel(5);
+    await delay(200);
+
+    // Verify app did not crash - camera operations should still work
+    mapViewController.moveCamera({
+      target: { lat: 37.7749, lng: -122.4194 },
+      bearing: 0,
+      tilt: 0,
+      zoom: 10,
+    });
+    await delay(200);
+
+    const posAfterInvalid = await mapViewController.getCameraPosition();
+    if (!posAfterInvalid) {
+      return failTest('getCameraPosition failed after invalid min/max zoom');
+    }
+
+    // Clean up - reset to defaults
+    setMinZoomLevel(undefined);
+    setMaxZoomLevel(undefined);
+    await delay(200);
+
+    passTest();
+  } catch (error) {
+    failTest(`testMinMaxZoomLevels failed: ${error}`);
+  }
+};

ios/react-native-navigation-sdk/NavAutoModule.mm

@@ -548,10 +548,11 @@ - (void)setNightMode:(NSInteger)nightMode {
   });
 }
 
-- (void)setFollowingPerspective:(NSInteger)perspective {
+- (void)setFollowingPerspective:(NSInteger)perspective zoomLevel:(double)zoomLevel {
   dispatch_async(dispatch_get_main_queue(), ^{
     if (self->_viewController) {
-      [self->_viewController setFollowingPerspective:[NSNumber numberWithInteger:perspective]];
+      [self->_viewController setFollowingPerspective:[NSNumber numberWithInteger:perspective]
+                                           zoomLevel:(float)zoomLevel];
     }
   });
 }