diff --git a/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCamera.java b/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCamera.java
index 2e6e95d81..a10a66ce7 100644
--- a/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCamera.java
+++ b/android/src/main/java/org/maplibre/reactnative/components/camera/MLRNCamera.java
@@ -2,6 +2,7 @@
 
 import android.content.Context;
 import android.location.Location;
+import android.util.Log;
 
 import org.maplibre.android.camera.CameraPosition;
 import org.maplibre.android.camera.CameraUpdate;
@@ -11,13 +12,9 @@
 import org.maplibre.android.geometry.VisibleRegion;
 import org.maplibre.android.location.OnCameraTrackingChangedListener;
 import org.maplibre.android.location.modes.CameraMode;
-import org.maplibre.android.location.modes.RenderMode;
 import org.maplibre.android.maps.MapLibreMap;
 import org.maplibre.android.maps.Style;
-import org.maplibre.android.location.LocationComponent;
-import org.maplibre.android.location.LocationComponentOptions;
-import org.maplibre.android.location.LocationComponentActivationOptions;
-// import org.maplibre.android.plugins.locationlayer.LocationLayerPlugin;
+
 import org.maplibre.reactnative.components.AbstractMapFeature;
 import org.maplibre.reactnative.components.location.LocationComponentManager;
 import org.maplibre.reactnative.components.mapview.MLRNMapView;
@@ -31,8 +28,6 @@
 import org.maplibre.reactnative.location.UserTrackingState;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
-import org.maplibre.reactnative.R;
-
 import org.maplibre.reactnative.events.constants.EventTypes;
 
 import com.facebook.react.bridge.WritableMap;
@@ -87,12 +82,12 @@ public class MLRNCamera extends AbstractMapFeature {
     private LocationManager.OnUserLocationChange mLocationChangeListener = new LocationManager.OnUserLocationChange() {
         @Override
         public void onLocationChange(Location nextLocation) {
-        if (getMapboxMap() == null || mLocationComponentManager == null || !mLocationComponentManager.hasLocationComponent() || (!mFollowUserLocation)) {
-            return;
-        }
+            if (getMapboxMap() == null || mLocationComponentManager == null || !mLocationComponentManager.hasLocationComponent() || (!mFollowUserLocation)) {
+                return;
+            }
 
-        mUserLocation.setCurrentLocation(nextLocation);
-        sendUserLocationUpdateEvent(nextLocation);
+            mUserLocation.setCurrentLocation(nextLocation);
+            sendUserLocationUpdateEvent(nextLocation);
         }
     };
 
@@ -236,12 +231,7 @@ private CameraPosition getUserLocationUpdateCameraPosition(double zoomLevel) {
             }
         }
 
-        return new CameraPosition.Builder()
-                .target(center)
-                .bearing(getDirectionForUserLocationUpdate())
-                .tilt(mPitch)
-                .zoom(zoomLevel)
-                .build();
+        return new CameraPosition.Builder().target(center).bearing(getDirectionForUserLocationUpdate()).tilt(mPitch).zoom(zoomLevel).build();
     }
 
     private double getDirectionForUserLocationUpdate() {
@@ -260,7 +250,7 @@ private double getDirectionForUserLocationUpdate() {
     }
 
     private void sendUserLocationUpdateEvent(Location location) {
-        if(location == null){
+        if (location == null) {
             return;
         }
         IEvent event = new MapChangeEvent(this, EventTypes.USER_LOCATION_UPDATED, makeLocationChangePayload(location));
@@ -376,37 +366,38 @@ private void updateLocationLayer(@NonNull Style style) {
         }
 
         mLocationComponentManager.update(style);
-
-        if (mFollowUserLocation) {
-            mLocationComponentManager.setCameraMode(UserTrackingMode.getCameraMode(mUserTrackingMode));
-        }
         mLocationComponentManager.setFollowUserLocation(mFollowUserLocation);
 
         if (mFollowUserLocation) {
             mLocationComponentManager.setCameraMode(UserTrackingMode.getCameraMode(mUserTrackingMode));
             mLocationComponentManager.addOnCameraTrackingChangedListener(new OnCameraTrackingChangedListener() {
-                    @Override public void onCameraTrackingChanged(int currentMode) {
-                        int userTrackingMode = UserTrackingMode.NONE;
-                        switch (currentMode) {
-                            case CameraMode.NONE:
-                                userTrackingMode = UserTrackingMode.NONE;
-                                break;
-                            case CameraMode.TRACKING:
-                                userTrackingMode = UserTrackingMode.FOLLOW;
-                                break;
-                            case CameraMode.TRACKING_COMPASS:
-                                userTrackingMode = UserTrackingMode.FollowWithHeading;
-                                break;
-                            case CameraMode.TRACKING_GPS:
-                                userTrackingMode = UserTrackingMode.FollowWithCourse;
-                                break;
-                            default:
-                                userTrackingMode = UserTrackingMode.NONE;
-                        }
-                        updateUserTrackingMode(userTrackingMode);
-                    }
-                    @Override public void onCameraTrackingDismissed() {
+                @Override
+                public void onCameraTrackingChanged(int currentMode) {
+                    int userTrackingMode;
+
+                    switch (currentMode) {
+                        case CameraMode.NONE:
+                            userTrackingMode = UserTrackingMode.NONE;
+                            break;
+                        case CameraMode.TRACKING:
+                            userTrackingMode = UserTrackingMode.FOLLOW;
+                            break;
+                        case CameraMode.TRACKING_COMPASS:
+                            userTrackingMode = UserTrackingMode.FollowWithHeading;
+                            break;
+                        case CameraMode.TRACKING_GPS:
+                            userTrackingMode = UserTrackingMode.FollowWithCourse;
+                            break;
+                        default:
+                            userTrackingMode = UserTrackingMode.NONE;
                     }
+
+                    updateUserTrackingMode(userTrackingMode);
+                }
+
+                @Override
+                public void onCameraTrackingDismissed() {
+                }
             });
         } else {
             mLocationComponentManager.setCameraMode(CameraMode.NONE);
@@ -429,10 +420,7 @@ public void setZoomLevel(double zoomLevel) {
     }
 
     private CameraPosition buildCamera(CameraPosition previousPosition, boolean shouldUpdateTarget) {
-        CameraPosition.Builder builder = new CameraPosition.Builder(previousPosition)
-                .bearing(mHeading)
-                .tilt(mPitch)
-                .zoom(mZoomLevel);
+        CameraPosition.Builder builder = new CameraPosition.Builder(previousPosition).bearing(mHeading).tilt(mPitch).zoom(mZoomLevel);
 
         if (shouldUpdateTarget) {
             builder.target(GeoJSONUtils.toLatLng(mCenterCoordinate));
@@ -507,6 +495,7 @@ MapLibreMap getMapboxMap() {
     /**
      * Create a payload of the location data per the web api geolocation spec
      * https://dev.w3.org/geo/api/spec-source.html#position
+     *
      * @return
      */
     private WritableMap makeLocationChangePayload(Location location) {
diff --git a/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.java b/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.java
index e7562d898..67b5a8850 100644
--- a/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.java
+++ b/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.java
@@ -46,6 +46,8 @@ public LocationComponentManager(MLRNMapView mlrnMapView, Context context) {
 
     private boolean mShowingUserLocation = false;
 
+    private OnCameraTrackingChangedListener mOnCameraTrackingChangedListener = null;
+
     public void showUserLocation(boolean showUserLocation) {
         mShowUserLocation = showUserLocation;
         stateChanged();
@@ -68,16 +70,21 @@ public void setRenderMode(@RenderMode.Mode int renderMode) {
     }
 
     public void setPreferredFramesPerSecond(int preferredFramesPerSecond) {
-       if(mLocationComponent == null || preferredFramesPerSecond <= 0) {
+        if (mLocationComponent == null || preferredFramesPerSecond <= 0) {
             return;
-       }
+        }
 
         mLocationComponent.setMaxAnimationFps(preferredFramesPerSecond);
     }
 
-
     public void addOnCameraTrackingChangedListener(OnCameraTrackingChangedListener onCameraTrackingChangedListener) {
-        mLocationComponent.addOnCameraTrackingChangedListener(onCameraTrackingChangedListener);
+        if (mOnCameraTrackingChangedListener != null) {
+            mLocationComponent.removeOnCameraTrackingChangedListener(mOnCameraTrackingChangedListener);
+        }
+
+        mOnCameraTrackingChangedListener = onCameraTrackingChangedListener;
+
+        mLocationComponent.addOnCameraTrackingChangedListener(mOnCameraTrackingChangedListener);
     }
 
     @SuppressLint("MissingPermission")
@@ -111,7 +118,7 @@ public void update(@NonNull Style style) {
     public void update(boolean displayUserLocation, @NonNull Style style) {
         Integer tintColor = mMapView.getTintColor();
 
-        if (mLocationComponent == null || tintColor != null ) {
+        if (mLocationComponent == null || tintColor != null) {
             mLocationComponent = mMap.getLocationComponent();
 
             LocationComponentActivationOptions locationComponentActivationOptions = LocationComponentActivationOptions
@@ -148,10 +155,10 @@ LocationComponentOptions options(boolean displayUserLocation) {
                     .accuracyAlpha(0.0f);
         } else if (tintColor != null) {
             builder = builder
-                .enableStaleState(false)
-                .bearingTintColor(tintColor)
-                .foregroundTintColor(tintColor)
-                .accuracyColor(tintColor);
+                    .enableStaleState(false)
+                    .bearingTintColor(tintColor)
+                    .foregroundTintColor(tintColor)
+                    .accuracyColor(tintColor);
         }
         return builder.build();
     }
diff --git a/ios/MLRN/MLRNCamera.m b/ios/MLRN/MLRNCamera.m
index 2a6f99922..e5862b5f3 100644
--- a/ios/MLRN/MLRNCamera.m
+++ b/ios/MLRN/MLRNCamera.m
@@ -179,11 +179,6 @@ - (void)_updateCameraFromTrackingMode
         return;
     }
     
-    if (_map.userTrackingMode != [self _userTrackingMode]) {
-        _map.showsUserLocation = [self _userTrackingMode] != MLNUserTrackingModeNone;
-        _map.userTrackingMode = [self _userTrackingMode];
-    }
-    
     MLNMapCamera *camera = _map.camera;
     if (_followPitch != nil && [_followPitch floatValue] >= 0.0) {
         camera.pitch = [_followPitch floatValue];
@@ -202,8 +197,12 @@ - (void)_updateCameraFromTrackingMode
     if (_followZoomLevel != nil && [_followZoomLevel doubleValue] >= 0.0) {
         camera.altitude = [_map altitudeFromZoom:[_followZoomLevel doubleValue]];
     }
-    
-    [_map setCamera:camera animated:YES];
+
+    [_map setCamera:camera animated:NO];
+
+    if (_map.userTrackingMode != [self _userTrackingMode]) {
+      [_map setUserTrackingMode:[self _userTrackingMode] animated:NO completionHandler:nil];
+    }
 }
 
 - (NSUInteger)_userTrackingMode
diff --git a/packages/examples/src/Examples.tsx b/packages/examples/src/Examples.tsx
index 69594fcee..b32111f53 100644
--- a/packages/examples/src/Examples.tsx
+++ b/packages/examples/src/Examples.tsx
@@ -117,6 +117,10 @@ const Examples = new ExampleGroup(
         "Follow User Location Render Mode",
         MapLibreExamples.FollowUserLocationRenderMode,
       ),
+      new ExampleItem(
+        "User Location for Navigation",
+        MapLibreExamples.UserLocationForNavigation,
+      ),
       new ExampleItem(
         "User Location Updates",
         MapLibreExamples.UserLocationUpdate,
diff --git a/packages/examples/src/examples/UserLocation/UserLocationForNavigation.tsx b/packages/examples/src/examples/UserLocation/UserLocationForNavigation.tsx
new file mode 100755
index 000000000..54b95de07
--- /dev/null
+++ b/packages/examples/src/examples/UserLocation/UserLocationForNavigation.tsx
@@ -0,0 +1,78 @@
+import {
+  Camera,
+  MapView,
+  SymbolLayer,
+  UserLocation,
+  UserLocationRenderMode,
+  UserTrackingMode,
+} from "@maplibre/maplibre-react-native";
+import { useState } from "react";
+import { Button } from "react-native";
+
+import maplibreIcon from "../../assets/images/maplibre.png";
+import { OSM_RASTER_STYLE } from "../../constants/OSM_RASTER_STYLE";
+import { sheet } from "../../styles/sheet";
+
+export function UserLocationForNavigation() {
+  const [navigationActive, setNavigationActive] = useState(false);
+
+  return (
+    <>
+      <Button
+        title={`Navigation is ${navigationActive ? "active" : "inactive"}`}
+        onPress={() => setNavigationActive((prevState) => !prevState)}
+      />
+
+      <MapView
+        style={sheet.matchParent}
+        mapStyle={OSM_RASTER_STYLE}
+        contentInset={navigationActive ? [200, 0, 0, 0] : undefined}
+        pitchEnabled={navigationActive}
+      >
+        {navigationActive ? (
+          <UserLocation
+            renderMode={
+              navigationActive
+                ? UserLocationRenderMode.Normal
+                : UserLocationRenderMode.Native
+            }
+            showsUserHeadingIndicator
+          >
+            <SymbolLayer
+              id="navigation-icon"
+              style={{
+                iconImage: maplibreIcon,
+                iconPitchAlignment: "map",
+                iconAllowOverlap: true,
+              }}
+            />
+          </UserLocation>
+        ) : null}
+
+        <Camera
+          followUserLocation={navigationActive}
+          followUserMode={
+            navigationActive
+              ? UserTrackingMode.FollowWithHeading
+              : UserTrackingMode.Follow
+          }
+          followZoomLevel={19}
+          followPitch={60}
+          pitch={0}
+          onUserTrackingModeChange={(event) => {
+            console.log("js userTrackingModeChange");
+            console.log("js", event.type);
+            console.log("js", JSON.stringify(event.nativeEvent));
+
+            if (
+              navigationActive &&
+              !event.nativeEvent.payload.followUserLocation
+            ) {
+              setNavigationActive(false);
+            }
+          }}
+        />
+      </MapView>
+    </>
+  );
+}
diff --git a/packages/examples/src/examples/index.ts b/packages/examples/src/examples/index.ts
index 50f79a0df..749e12b1a 100644
--- a/packages/examples/src/examples/index.ts
+++ b/packages/examples/src/examples/index.ts
@@ -50,6 +50,7 @@ export { ShapeSourceIcon } from "./SymbolCircleLayer/ShapeSourceIcon";
 // USERLOCATION
 export { FollowUserLocationRenderMode } from "./UserLocation/FollowUserLocationRenderMode";
 export { FollowUserLocationAlignment } from "./UserLocation/FollowUserLocationAlignment";
+export { UserLocationForNavigation } from "./UserLocation/UserLocationForNavigation";
 export { SetAndroidPreferredFramesPerSecond } from "./UserLocation/SetAndroidPreferredFramesPerSecond";
 export { UserLocationDisplacement } from "./UserLocation/UserLocationDisplacement";
 export { UserLocationUpdate } from "./UserLocation/UserLocationUpdate";
diff --git a/src/__tests__/components/Camera.test.tsx b/src/__tests__/components/Camera.test.tsx
index 2ddba61df..cce9df938 100644
--- a/src/__tests__/components/Camera.test.tsx
+++ b/src/__tests__/components/Camera.test.tsx
@@ -70,16 +70,7 @@ describe("Camera", () => {
       expect(getByTestId("Camera").props).toStrictEqual({
         children: undefined,
         testID: "Camera",
-        stop: {},
         defaultStop: undefined,
-        maxBounds: undefined,
-        followUserLocation: undefined,
-        followUserMode: undefined,
-        followPitch: undefined,
-        followHeading: undefined,
-        followZoomLevel: undefined,
-        maxZoomLevel: undefined,
-        minZoomLevel: undefined,
         onUserTrackingModeChange: undefined,
       });
     });
@@ -100,8 +91,9 @@ describe("Camera", () => {
     });
 
     describe("buildNativeStop", () => {
-      const configWithoutBounds = {
+      const configWithoutBounds: CameraProps = {
         animationDuration: 2000,
+        animationMode: "flyTo",
         pitch: 45,
         heading: 110,
         zoomLevel: 9,
@@ -123,78 +115,89 @@ describe("Camera", () => {
       };
 
       test('returns correct "stopConfig" without bounds', () => {
-        const { rerender, getByTestId } = renderCamera(configWithoutBounds);
-        expect(getByTestId("Camera").props.stop).toStrictEqual({
-          duration: 2000,
-          heading: 110,
-          pitch: 45,
-          zoom: 9,
+        const { rerender, setNativePropsSpy } =
+          renderCamera(configWithoutBounds);
+        expect(setNativePropsSpy).toHaveBeenLastCalledWith({
+          stop: {
+            duration: 2000,
+            mode: "Flight",
+            heading: 110,
+            pitch: 45,
+            zoom: 9,
+          },
         });
 
         rerender({
           ...configWithoutBounds,
           centerCoordinate: [0, 0],
         });
-        expect(getByTestId("Camera").props.stop).toStrictEqual({
-          centerCoordinate:
-            '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
-          duration: 2000,
-          heading: 110,
-          pitch: 45,
-          zoom: 9,
+        expect(setNativePropsSpy).toHaveBeenLastCalledWith({
+          stop: {
+            centerCoordinate:
+              '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
+            duration: 2000,
+            mode: "Flight",
+            heading: 110,
+            pitch: 45,
+            zoom: 9,
+          },
         });
       });
 
       test('returns correct "stopConfig" with bounds', () => {
-        const { getByTestId, rerender } = renderCamera(configWithBounds);
+        const { rerender, setNativePropsSpy } = renderCamera(configWithBounds);
 
-        expect(getByTestId("Camera").props.stop).toStrictEqual({
-          bounds: BOUNDS_STRING,
-          paddingBottom: 8,
-          paddingLeft: 10,
-          paddingRight: 5,
-          paddingTop: 3,
-          duration: 500,
-          heading: 100,
-          mode: "Ease",
-          pitch: 45,
-          zoom: 11,
+        expect(setNativePropsSpy).toHaveBeenLastCalledWith({
+          stop: {
+            bounds: BOUNDS_STRING,
+            paddingBottom: 8,
+            paddingLeft: 10,
+            paddingRight: 5,
+            paddingTop: 3,
+            duration: 500,
+            heading: 100,
+            mode: "Ease",
+            pitch: 45,
+            zoom: 11,
+          },
         });
 
         rerender({
-          ...configWithBounds,
+          ...configWithoutBounds,
           centerCoordinate: [0, 0],
         });
-
-        expect(getByTestId("Camera").props.stop).toStrictEqual({
-          bounds: BOUNDS_STRING,
-          paddingBottom: 8,
-          paddingLeft: 10,
-          paddingRight: 5,
-          paddingTop: 3,
-          centerCoordinate:
-            '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
-          duration: 500,
-          heading: 100,
-          mode: "Ease",
-          pitch: 45,
-          zoom: 11,
+        expect(setNativePropsSpy).toHaveBeenLastCalledWith({
+          stop: {
+            centerCoordinate:
+              '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
+            duration: 2000,
+            mode: "Flight",
+            heading: 110,
+            pitch: 45,
+            zoom: 9,
+          },
         });
       });
     });
 
     describe("maxBounds", () => {
       test("are undefined when missing", () => {
-        const { rerender, getByTestId } = renderCamera();
-        expect(getByTestId("Camera").props.maxBounds).toStrictEqual(undefined);
+        const { rerender, setNativePropsSpy } = renderCamera();
+        expect(setNativePropsSpy).toHaveBeenCalledWith({
+          maxBounds: undefined,
+        });
 
         // @ts-expect-error
         rerender({ maxBounds: { ne: [1, 1] } });
-        expect(getByTestId("Camera").props.maxBounds).toStrictEqual(undefined);
+        expect(setNativePropsSpy).toHaveBeenCalledWith({
+          maxBounds: undefined,
+        });
 
         // @ts-expect-error
         renderCamera({ maxBounds: { sw: [0, 0] } });
-        expect(getByTestId("Camera").props.maxBounds).toStrictEqual(undefined);
+        expect(setNativePropsSpy).toHaveBeenCalledWith({
+          maxBounds: undefined,
+        });
       });
 
       test('returns maxBounds when "maxBounds" property is set', () => {
@@ -203,84 +206,126 @@ describe("Camera", () => {
           sw: [0, 0],
         };
 
-        const { getByTestId } = renderCamera({ maxBounds });
-        expect(getByTestId("Camera").props.maxBounds).toStrictEqual(
-          BOUNDS_STRING,
-        );
+        const { setNativePropsSpy } = renderCamera({ maxBounds });
+        expect(setNativePropsSpy).toHaveBeenCalledWith({
+          maxBounds: BOUNDS_STRING,
+        });
       });
     });
   });
 
   describe("updates", () => {
     test('updates when "followUserLocation" changes', () => {
-      const { getByTestId, rerender } = renderCamera({
+      const { rerender, setNativePropsSpy } = renderCamera({
         followUserLocation: false,
       });
 
-      expect(getByTestId("Camera").props.followUserLocation).toEqual(false);
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        followUserLocation: false,
+      });
 
       rerender({ followUserLocation: true });
 
-      expect(getByTestId("Camera").props.followUserLocation).toEqual(true);
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        followUserLocation: true,
+      });
     });
 
     test("updates when maxBounds change", () => {
-      const { rerender, getByTestId } = renderCamera();
-      expect(getByTestId("Camera").props.maxBounds).toEqual(undefined);
+      const { rerender, setNativePropsSpy } = renderCamera();
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        maxBounds: undefined,
+      });
 
-      rerender({
-        maxBounds: BOUNDS,
+      rerender({ maxBounds: BOUNDS });
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        maxBounds: BOUNDS_STRING,
       });
-      expect(getByTestId("Camera").props.maxBounds).toEqual(BOUNDS_STRING);
     });
 
     test("updates when minZoomLevel changes", () => {
-      const { rerender, getByTestId } = renderCamera();
-      expect(getByTestId("Camera").props.minZoomLevel).toEqual(undefined);
+      const { rerender, setNativePropsSpy } = renderCamera();
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        minZoomLevel: undefined,
+      });
 
       rerender({ minZoomLevel: 5 });
-      expect(getByTestId("Camera").props.minZoomLevel).toEqual(5);
+      expect(setNativePropsSpy).toHaveBeenCalledWith({ minZoomLevel: 5 });
     });
 
     test("updates when maxZoomLevel changes", () => {
-      const { rerender, getByTestId } = renderCamera();
-      expect(getByTestId("Camera").props.maxZoomLevel).toEqual(undefined);
+      const { rerender, setNativePropsSpy } = renderCamera();
+
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        maxZoomLevel: undefined,
+      });
 
       rerender({ maxZoomLevel: 5 });
-      expect(getByTestId("Camera").props.maxZoomLevel).toEqual(5);
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        maxZoomLevel: 5,
+      });
     });
 
     test("updates when follow user props change", () => {
-      const { rerender, getByTestId } = renderCamera({
+      const { rerender, setNativePropsSpy } = renderCamera({
+        followUserLocation: true,
+      });
+
+      expect(setNativePropsSpy).toHaveBeenLastCalledWith({
         followUserLocation: true,
+        followUserMode: undefined,
+        followHeading: undefined,
+        followPitch: undefined,
+        followZoomLevel: undefined,
       });
 
       rerender({
         followUserLocation: true,
         followUserMode: UserTrackingMode.Follow,
       });
-      expect(getByTestId("Camera").props.followUserMode).toEqual("normal");
-      expect(getByTestId("Camera").props.followHeading).toEqual(undefined);
-      expect(getByTestId("Camera").props.followPitch).toEqual(undefined);
-      expect(getByTestId("Camera").props.followZoomLevel).toEqual(undefined);
+
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        followUserMode: UserTrackingMode.Follow,
+        followHeading: undefined,
+        followPitch: undefined,
+        followZoomLevel: undefined,
+      });
 
       rerender({
-        followUserLocation: false,
         followUserMode: UserTrackingMode.FollowWithHeading,
       });
-      expect(getByTestId("Camera").props.followUserMode).toEqual("compass");
-      expect(getByTestId("Camera").props.followHeading).toEqual(undefined);
-      expect(getByTestId("Camera").props.followPitch).toEqual(undefined);
-      expect(getByTestId("Camera").props.followZoomLevel).toEqual(undefined);
+
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        followUserMode: undefined,
+        followHeading: undefined,
+        followPitch: undefined,
+        followZoomLevel: undefined,
+      });
+
+      rerender({
+        followUserLocation: true,
+        followUserMode: UserTrackingMode.FollowWithHeading,
+      });
+
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        followUserMode: UserTrackingMode.FollowWithHeading,
+        followHeading: undefined,
+        followPitch: undefined,
+        followZoomLevel: undefined,
+      });
     });
 
     test("updates when CameraStop changes", () => {
-      const { rerender, getByTestId } = renderCamera();
-      expect(getByTestId("Camera").props.stop).toEqual({});
+      const { rerender, setNativePropsSpy } = renderCamera();
+      expect(setNativePropsSpy).toHaveBeenCalledWith({ stop: {} });
+
       rerender({ centerCoordinate: [0, 0] });
-      expect(getByTestId("Camera").props.stop).toEqual({
-        centerCoordinate:
-          '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
+
+      expect(setNativePropsSpy).toHaveBeenCalledWith({
+        stop: {
+          centerCoordinate:
+            '{"type":"Feature","properties":{},"geometry":{"type":"Point","coordinates":[0,0]}}',
+        },
       });
     });
   });
diff --git a/src/components/Camera.tsx b/src/components/Camera.tsx
index 0521dce3e..b1b06ac9f 100644
--- a/src/components/Camera.tsx
+++ b/src/components/Camera.tsx
@@ -1,6 +1,13 @@
 import { point } from "@turf/helpers";
-import { forwardRef, memo, useImperativeHandle, useMemo } from "react";
-import { requireNativeComponent, type ViewProps } from "react-native";
+import {
+  forwardRef,
+  memo,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useState,
+} from "react";
+import { Platform, requireNativeComponent, type ViewProps } from "react-native";
 
 import { CameraModes } from "../MLRNModule";
 import { useNativeRef } from "../hooks/useNativeRef";
@@ -47,54 +54,62 @@ function makeNativeCameraStop(stop?: CameraStop): NativeCameraStop | undefined {
     return undefined;
   }
 
-  const nativeStop: NativeCameraStop = {};
+  const newNativeStop: NativeCameraStop = {};
 
   if (stop.animationDuration !== undefined) {
-    nativeStop.duration = stop.animationDuration;
+    newNativeStop.duration = stop.animationDuration;
   }
   if (stop.animationMode !== undefined) {
-    nativeStop.mode = getNativeCameraMode(stop.animationMode);
+    newNativeStop.mode = getNativeCameraMode(stop.animationMode);
   }
   if (stop.centerCoordinate) {
-    nativeStop.centerCoordinate = JSON.stringify(point(stop.centerCoordinate));
+    newNativeStop.centerCoordinate = JSON.stringify(
+      point(stop.centerCoordinate),
+    );
   }
   if (stop.heading !== undefined) {
-    nativeStop.heading = stop.heading;
+    newNativeStop.heading = stop.heading;
   }
   if (stop.pitch !== undefined) {
-    nativeStop.pitch = stop.pitch;
+    newNativeStop.pitch = stop.pitch;
   }
   if (stop.zoomLevel !== undefined) {
-    nativeStop.zoom = stop.zoomLevel;
+    newNativeStop.zoom = stop.zoomLevel;
   }
 
   if (stop.bounds && stop.bounds.ne && stop.bounds.sw) {
     const { ne, sw } = stop.bounds;
-    nativeStop.bounds = makeNativeBounds(ne, sw);
+    newNativeStop.bounds = makeNativeBounds(ne, sw);
   }
 
   const paddingTop = stop.padding?.paddingTop ?? stop.bounds?.paddingTop;
   if (paddingTop !== undefined) {
-    nativeStop.paddingTop = paddingTop;
+    newNativeStop.paddingTop = paddingTop;
   }
 
   const paddingRight = stop.padding?.paddingRight ?? stop.bounds?.paddingRight;
   if (paddingRight !== undefined) {
-    nativeStop.paddingRight = paddingRight;
+    newNativeStop.paddingRight = paddingRight;
   }
 
   const paddingBottom =
     stop.padding?.paddingBottom ?? stop.bounds?.paddingBottom;
   if (paddingBottom !== undefined) {
-    nativeStop.paddingBottom = paddingBottom;
+    newNativeStop.paddingBottom = paddingBottom;
   }
 
   const paddingLeft = stop.padding?.paddingLeft ?? stop.bounds?.paddingLeft;
   if (paddingLeft !== undefined) {
-    nativeStop.paddingLeft = paddingLeft;
+    newNativeStop.paddingLeft = paddingLeft;
   }
 
-  return nativeStop;
+  if (newNativeStop.centerCoordinate && newNativeStop.bounds) {
+    throw new Error(
+      "Create a camera stop with bounds and centerCoordinate – this is not possible.",
+    );
+  }
+
+  return newNativeStop;
 }
 
 export interface CameraRef {
@@ -269,44 +284,11 @@ export const Camera = memo(
       }: CameraProps,
       ref,
     ) => {
-      const nativeCamera = useNativeRef<NativeCameraProps>();
-
-      const nativeStop = useMemo(() => {
-        return makeNativeCameraStop({
-          animationDuration,
-          animationMode,
-          bounds,
-          centerCoordinate,
-          heading,
-          padding,
-          pitch,
-          zoomLevel,
-        });
-      }, [
-        animationDuration,
-        animationMode,
-        bounds,
-        centerCoordinate,
-        heading,
-        padding,
-        pitch,
-        zoomLevel,
-      ]);
-
-      const nativeDefaultStop = useMemo(() => {
-        return makeNativeCameraStop(defaultSettings);
-      }, [defaultSettings]);
-
-      const nativeMaxBounds = useMemo(() => {
-        if (!maxBounds?.ne || !maxBounds?.sw) {
-          return undefined;
-        }
-        return makeNativeBounds(maxBounds.ne, maxBounds.sw);
-      }, [maxBounds]);
+      const nativeCameraRef = useNativeRef<NativeCameraProps>();
 
       const setCamera = (config: CameraStop | CameraStops = {}): void => {
         if ("stops" in config) {
-          nativeCamera.current?.setNativeProps({
+          nativeCameraRef.current?.setNativeProps({
             stop: {
               stops: config.stops
                 .map((stopItem) => makeNativeCameraStop(stopItem))
@@ -314,10 +296,10 @@ export const Camera = memo(
             },
           });
         } else {
-          const nativeStop = makeNativeCameraStop(config);
+          const stop = makeNativeCameraStop(config);
 
-          if (nativeStop) {
-            nativeCamera.current?.setNativeProps({ stop: nativeStop });
+          if (stop) {
+            nativeCameraRef.current?.setNativeProps({ stop });
           }
         }
       };
@@ -465,20 +447,116 @@ export const Camera = memo(
         }),
       );
 
+      const followProps = useMemo(() => {
+        return {
+          followUserMode,
+          followPitch: followPitch ?? pitch,
+          followHeading: followHeading ?? heading,
+          followZoomLevel: followZoomLevel ?? zoomLevel,
+        };
+      }, [
+        followUserMode,
+        followPitch,
+        pitch,
+        followHeading,
+        heading,
+        followZoomLevel,
+        zoomLevel,
+      ]);
+
+      useEffect(() => {
+        if (followUserLocation) {
+          if (Platform.OS === "android") {
+            nativeCameraRef.current?.setNativeProps({
+              ...followProps,
+              followUserLocation,
+            });
+          } else {
+            nativeCameraRef.current?.setNativeProps({
+              ...followProps,
+            });
+            nativeCameraRef.current?.setNativeProps({
+              followUserLocation,
+            });
+          }
+        } else {
+          nativeCameraRef.current?.setNativeProps({
+            followUserLocation,
+          });
+        }
+      }, [followUserLocation, followProps]);
+
+      const nativeMaxBounds = useMemo(() => {
+        if (!maxBounds?.ne || !maxBounds?.sw) {
+          return undefined;
+        }
+
+        return makeNativeBounds(maxBounds.ne, maxBounds.sw);
+      }, [maxBounds]);
+
+      useEffect(() => {
+        if (!followUserLocation) {
+          nativeCameraRef.current?.setNativeProps({
+            maxBounds: nativeMaxBounds,
+          });
+        }
+      }, [followUserLocation, nativeMaxBounds]);
+
+      useEffect(() => {
+        if (!followUserLocation) {
+          nativeCameraRef.current?.setNativeProps({
+            minZoomLevel,
+          });
+        }
+      }, [followUserLocation, minZoomLevel]);
+
+      useEffect(() => {
+        if (!followUserLocation) {
+          nativeCameraRef.current?.setNativeProps({
+            maxZoomLevel,
+          });
+        }
+      }, [followUserLocation, maxZoomLevel]);
+
+      const nativeStop = useMemo(() => {
+        return makeNativeCameraStop({
+          animationDuration,
+          animationMode,
+          bounds,
+          centerCoordinate,
+          heading,
+          padding,
+          pitch,
+          zoomLevel,
+        });
+      }, [
+        animationDuration,
+        animationMode,
+        bounds,
+        centerCoordinate,
+        heading,
+        padding,
+        pitch,
+        zoomLevel,
+      ]);
+
+      useEffect(() => {
+        if (!followUserLocation) {
+          nativeCameraRef.current?.setNativeProps({
+            stop: nativeStop,
+          });
+        }
+      }, [followUserLocation, nativeStop]);
+
+      const [nativeDefaultStop] = useState(
+        makeNativeCameraStop(defaultSettings),
+      );
+
       return (
         <MLRNCamera
           testID="Camera"
-          ref={nativeCamera}
-          stop={nativeStop}
+          ref={nativeCameraRef}
           defaultStop={nativeDefaultStop}
-          maxBounds={nativeMaxBounds}
-          followUserLocation={followUserLocation}
-          followHeading={followHeading}
-          followPitch={followPitch}
-          followUserMode={followUserMode}
-          followZoomLevel={followZoomLevel}
-          maxZoomLevel={maxZoomLevel}
-          minZoomLevel={minZoomLevel}
           onUserTrackingModeChange={onUserTrackingModeChange}
         />
       );