react-native-maps 1.24.11 → 1.24.12

package/android/src/main/java/com/rnmaps/maps/MapView.java

@@ -24,8 +24,6 @@ import android.widget.RelativeLayout;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.content.PermissionChecker;
-import androidx.core.view.GestureDetectorCompat;
-import androidx.core.view.MotionEventCompat;
 
 import com.facebook.react.common.MapBuilder;
 
@@ -144,7 +142,7 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
     private final Map<GroundOverlay, MapOverlay> overlayMap = new HashMap<>();
     private final Map<TileOverlay, MapHeatmap> heatmapMap = new HashMap<>();
     private final Map<TileOverlay, MapGradientPolyline> gradientPolylineMap = new HashMap<>();
-    private final GestureDetectorCompat gestureDetector;
+    private final GestureDetector gestureDetector;
     private boolean paused = false;
     private boolean destroyed = false;
     private final ThemedReactContext context;
@@ -259,7 +257,7 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
         fusedLocationSource = new FusedLocationSource(context);
 
         gestureDetector =
-                new GestureDetectorCompat(context, new GestureDetector.SimpleOnGestureListener() {
+                new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
 
                     @Override
                     public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
@@ -1512,7 +1510,7 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
             tapLocation = map.getProjection().fromScreenLocation(new Point(X, Y));
         }
 
-        int action = MotionEventCompat.getActionMasked(ev);
+        int action = ev.getActionMasked();
 
         switch (action) {
             case (MotionEvent.ACTION_DOWN):

package/package.json

@@ -5,7 +5,7 @@
   "main": "src/index.ts",
   "author": "Leland Richardson <leland.m.richardson@gmail.com>",
   "homepage": "https://github.com/react-native-maps/react-native-maps#readme",
-  "version": "1.24.11",
+  "version": "1.24.12",
   "license": "MIT",
   "scripts": {
     "lint": "eslint . --max-warnings 0",

package/src/createFabricMap.tsx

@@ -10,9 +10,15 @@ import type {
 import NativeAirMapsModule, {
   type MapBoundaries,
 } from './specs/NativeAirMapsModule';
-import type {MapFabricNativeProps} from './specs/NativeComponentMapView';
-
-export type FabricMapViewProps = MapFabricNativeProps;
+import FabricMapView, {
+  Commands as FabricCommands,
+  type MapFabricNativeProps,
+} from './specs/NativeComponentMapView';
+import GoogleMapView, {
+  Commands as GoogleCommands,
+  type MapFabricNativeProps as GoogleMapFabricNativeProps,
+} from './specs/NativeComponentGoogleMapView';
+export type MapViewProps = MapFabricNativeProps | GoogleMapFabricNativeProps;
 
 export interface FabricMapHandle {
   getCamera: () => Promise<Camera>;
@@ -42,231 +48,208 @@ export interface FabricMapHandle {
   setIndoorActiveLevelIndex: (activeLevelIndex: number) => void;
 }
 
-// Helper to safely get a node handle for supported types
-function getNodeHandle(ref: unknown): null | number {
-  if (
-    ref === null ||
-    typeof ref === 'number' ||
-    (typeof ref === 'object' && ref !== null && '_reactInternals' in ref)
-  ) {
-    // @ts-expect-error: safe for findNodeHandle
-    return findNodeHandle(ref);
-  }
-  return null;
-}
-
-const createFabricMap = (ViewComponent: React.ComponentType, Commands: any) => {
-  return forwardRef<FabricMapHandle | null, FabricMapViewProps>(
-    (props, ref) => {
-      const fabricRef = useRef<React.ComponentRef<typeof ViewComponent>>(null);
+const createFabricMap = (
+  ViewComponent: typeof GoogleMapView | typeof FabricMapView,
+  Commands: typeof FabricCommands | typeof GoogleCommands,
+) => {
+  return forwardRef<FabricMapHandle | null, MapViewProps>((props, ref) => {
+    const fabricRef =
+      useRef<React.ElementRef<typeof GoogleMapView | typeof FabricMapView>>(
+        null,
+      );
+    const node = findNodeHandle(fabricRef.current) ?? -1;
 
-      useImperativeHandle(ref, () => ({
-        async getMarkersFrames(onlyVisible: boolean) {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getMarkersFrames(
-              getNodeHandle(fabricRef.current) ?? -1,
-              onlyVisible,
-            );
-          } else {
-            throw new Error(
-              'getMarkersFrames is only supported on iOS with Fabric.',
-            );
-          }
-        },
-        async getCoordinateForPoint(point: Point) {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getCoordinateForPoint(
-              getNodeHandle(fabricRef.current) ?? -1,
-              point,
-            );
-          } else {
-            throw new Error(
-              'getCoordinateForPoint is only supported on iOS with Fabric.',
-            );
-          }
-        },
-        async getPointForCoordinate(coordinate: LatLng) {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getPointForCoordinate(
-              getNodeHandle(fabricRef.current) ?? -1,
-              coordinate,
-            );
-          } else {
-            throw new Error(
-              'getPointForCoordinate is not supported on this platform.',
-            );
-          }
-        },
-        async getAddressFromCoordinates(coordinate: LatLng) {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getAddressFromCoordinates(
-              getNodeHandle(fabricRef.current) ?? -1,
-              coordinate,
-            );
-          } else {
-            throw new Error(
-              'getAddressFromCoordinates is not supported on this platform',
-            );
+    useImperativeHandle(ref, () => ({
+      async getMarkersFrames(onlyVisible: boolean) {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getMarkersFrames(node, onlyVisible);
+        } else {
+          throw new Error(
+            'getMarkersFrames is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      async getCoordinateForPoint(point: Point) {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getCoordinateForPoint(node, point);
+        } else {
+          throw new Error(
+            'getCoordinateForPoint is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      async getPointForCoordinate(coordinate: LatLng) {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getPointForCoordinate(node, coordinate);
+        } else {
+          throw new Error(
+            'getPointForCoordinate is not supported on this platform.',
+          );
+        }
+      },
+      async getAddressFromCoordinates(coordinate: LatLng) {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getAddressFromCoordinates(
+            node,
+            coordinate,
+          );
+        } else {
+          throw new Error(
+            'getAddressFromCoordinates is not supported on this platform',
+          );
+        }
+      },
+      async takeSnapshot(config: SnapshotOptions) {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.takeSnapshot(node, JSON.stringify(config));
+        } else {
+          throw new Error('takeSnapshot is only supported on iOS with Fabric.');
+        }
+      },
+      async getCamera() {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getCamera(node);
+        } else {
+          throw new Error('getCamera is only supported on iOS with Fabric.');
+        }
+      },
+      async getMapBoundaries() {
+        if (fabricRef.current) {
+          return NativeAirMapsModule.getMapBoundaries(node);
+        } else {
+          throw new Error(
+            'getMapBoundaries is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      animateToRegion(region: Region, duration: number) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).animateToRegion(
+              fabricRef.current,
+              JSON.stringify(region),
+              duration,
+            );
+          } catch (error) {
+            throw new Error('Failed to animateToRegion');
           }
-        },
-        async takeSnapshot(config: SnapshotOptions) {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.takeSnapshot(
-              getNodeHandle(fabricRef.current) ?? -1,
-              JSON.stringify(config),
-            );
-          } else {
-            throw new Error(
-              'takeSnapshot is only supported on iOS with Fabric.',
-            );
-          }
-        },
-        async getCamera() {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getCamera(
-              getNodeHandle(fabricRef.current) ?? -1,
-            );
-          } else {
-            throw new Error('getCamera is only supported on iOS with Fabric.');
-          }
-        },
-        async getMapBoundaries() {
-          if (fabricRef.current) {
-            return NativeAirMapsModule.getMapBoundaries(
-              getNodeHandle(fabricRef.current) ?? -1,
-            );
-          } else {
-            throw new Error(
-              'getMapBoundaries is only supported on iOS with Fabric.',
-            );
+        } else {
+          throw new Error(
+            'animateToRegion is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      fitToElements(edgePadding: EdgePadding, animated: boolean) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).fitToElements(
+              fabricRef.current,
+              JSON.stringify(edgePadding),
+              animated,
+            );
+          } catch (error) {
+            throw new Error('Failed to fitToElements');
           }
-        },
-        animateToRegion(region: Region, duration: number) {
-          if (fabricRef.current) {
-            try {
-              Commands.animateToRegion(
-                fabricRef.current,
-                JSON.stringify(region),
-                duration,
-              );
-            } catch (error) {
-              throw new Error('Failed to animateToRegion');
-            }
-          } else {
-            throw new Error(
-              'animateToRegion is only supported on iOS with Fabric.',
-            );
-          }
-        },
-        fitToElements(edgePadding: EdgePadding, animated: boolean) {
-          if (fabricRef.current) {
-            try {
-              Commands.fitToElements(
-                fabricRef.current,
-                JSON.stringify(edgePadding),
-                animated,
-              );
-            } catch (error) {
-              throw new Error('Failed to fitToElements');
-            }
-          } else {
-            throw new Error(
-              'fitToElements is only supported on iOS with Fabric.',
-            );
+        } else {
+          throw new Error(
+            'fitToElements is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      fitToSuppliedMarkers(
+        markers: string[],
+        edgePadding: EdgePadding,
+        animated: boolean,
+      ) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).fitToSuppliedMarkers(
+              fabricRef.current,
+              JSON.stringify(markers),
+              JSON.stringify(edgePadding),
+              animated,
+            );
+          } catch (error) {
+            throw new Error('Failed to fitToSuppliedMarkers');
           }
-        },
-        fitToSuppliedMarkers(
-          markers: string[],
-          edgePadding: EdgePadding,
-          animated: boolean,
-        ) {
-          if (fabricRef.current) {
-            try {
-              Commands.fitToSuppliedMarkers(
-                fabricRef.current,
-                JSON.stringify(markers),
-                JSON.stringify(edgePadding),
-                animated,
-              );
-            } catch (error) {
-              throw new Error('Failed to fitToSuppliedMarkers');
-            }
-          } else {
-            throw new Error(
-              'fitToSuppliedMarkers is only supported on iOS with Fabric.',
-            );
+        } else {
+          throw new Error(
+            'fitToSuppliedMarkers is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      animateCamera(camera: Partial<Camera>, duration: number) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).animateCamera(
+              fabricRef.current,
+              JSON.stringify(camera),
+              duration,
+            );
+          } catch (error) {
+            throw new Error('Failed to animateCamera');
           }
-        },
-        animateCamera(camera: Partial<Camera>, duration: number) {
-          if (fabricRef.current) {
-            try {
-              Commands.animateCamera(
-                fabricRef.current,
-                JSON.stringify(camera),
-                duration,
-              );
-            } catch (error) {
-              throw new Error('Failed to animateCamera');
-            }
-          } else {
-            throw new Error(
-              'animateCamera is only supported on iOS with Fabric.',
-            );
-          }
-        },
-        fitToCoordinates(
-          coordinates: LatLng[],
-          edgePadding: EdgePadding,
-          animated: boolean,
-        ) {
-          if (fabricRef.current) {
-            try {
-              Commands.fitToCoordinates(
-                fabricRef.current,
-                JSON.stringify(coordinates),
-                JSON.stringify(edgePadding),
-                animated,
-              );
-            } catch (error) {
-              throw new Error('Failed to fitToCoordinates');
-            }
-          } else {
-            throw new Error(
-              'fitToCoordinates is only supported on iOS with Fabric.',
-            );
+        } else {
+          throw new Error(
+            'animateCamera is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      fitToCoordinates(
+        coordinates: LatLng[],
+        edgePadding: EdgePadding,
+        animated: boolean,
+      ) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).fitToCoordinates(
+              fabricRef.current,
+              JSON.stringify(coordinates),
+              JSON.stringify(edgePadding),
+              animated,
+            );
+          } catch (error) {
+            throw new Error('Failed to fitToCoordinates');
           }
-        },
-        setIndoorActiveLevelIndex(activeLevelIndex: number) {
-          if (fabricRef.current) {
-            try {
-              Commands.setIndoorActiveLevelIndex(
-                fabricRef.current,
-                activeLevelIndex,
-              );
-            } catch (error) {
-              console.error('Failed to set camera:', error);
-            }
-          } else {
-            console.warn('setIndoorActiveLevelIndex is not supported.');
+        } else {
+          throw new Error(
+            'fitToCoordinates is only supported on iOS with Fabric.',
+          );
+        }
+      },
+      setIndoorActiveLevelIndex(activeLevelIndex: number) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).setIndoorActiveLevelIndex(
+              fabricRef.current,
+              activeLevelIndex,
+            );
+          } catch (error) {
+            console.error('Failed to set camera:', error);
           }
-        },
-        setCamera(camera: Partial<Camera>) {
-          if (fabricRef.current) {
-            try {
-              Commands.setCamera(fabricRef.current, JSON.stringify(camera));
-            } catch (error) {
-              console.error('Failed to set camera:', error);
-            }
-          } else {
-            console.warn('setCamera is not supported');
+        } else {
+          console.warn('setIndoorActiveLevelIndex is not supported.');
+        }
+      },
+      setCamera(camera: Partial<Camera>) {
+        if (fabricRef.current) {
+          try {
+            (Commands as any).setCamera(
+              fabricRef.current,
+              JSON.stringify(camera),
+            );
+          } catch (error) {
+            console.error('Failed to set camera:', error);
           }
-        },
-      }));
+        } else {
+          console.warn('setCamera is not supported');
+        }
+      },
+    }));
 
-      // @ts-ignore
-      return <ViewComponent {...props} ref={fabricRef} />;
-    },
-  );
+    // @ts-ignore
+    return <ViewComponent {...props} ref={fabricRef} />;
+  });
 };
 
 export default createFabricMap;

package/src/specs/NativeComponentGoogleMapView.ts

@@ -11,6 +11,7 @@ import type {
   DirectEventHandler,
   BubblingEventHandler,
 } from 'react-native/Libraries/Types/CodegenTypes';
+import GoogleMapView from './NativeComponentGoogleMapView';
 
 export type EdgePadding = Readonly<{
   top: Double; // Non-nullable Double for top
@@ -860,45 +861,45 @@ export interface MapFabricNativeProps extends ViewProps {
   zoomTapEnabled?: WithDefault<boolean, true>;
 }
 
-export interface NativeCommands {
+interface NativeCommands {
   animateToRegion: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     regionJSON: string,
     duration: Int32,
   ) => void;
 
   setCamera: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     cameraJSON: string,
   ) => void;
 
   animateCamera: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     cameraJSON: string,
     duration: Int32,
   ) => void;
 
   fitToElements: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
 
   fitToSuppliedMarkers: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     markersJSON: string,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
 
   fitToCoordinates: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     coordinatesJSON: string,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
   setIndoorActiveLevelIndex: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof GoogleMapView>,
     activeLevelIndex: Int32,
   ) => void;
 }

package/src/specs/NativeComponentMapView.ts

@@ -11,6 +11,7 @@ import type {
   DirectEventHandler,
   BubblingEventHandler,
 } from 'react-native/Libraries/Types/CodegenTypes';
+import FabricMapView from './NativeComponentMapView';
 
 export type EdgePadding = Readonly<{
   top: Double; // Non-nullable Double for top
@@ -1039,46 +1040,46 @@ export interface MapFabricNativeProps extends ViewProps {
   cameraZoomRange?: CameraZoomRange;
 }
 
-export interface NativeCommands {
+interface NativeCommands {
   animateToRegion: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     regionJSON: string,
     duration: Int32,
   ) => void;
 
   setCamera: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     cameraJSON: string,
   ) => void;
 
   animateCamera: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     cameraJSON: string,
     duration: Int32,
   ) => void;
 
   fitToElements: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
 
   fitToSuppliedMarkers: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     markersJSON: string,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
 
   fitToCoordinates: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     coordinatesJSON: string,
     edgePaddingJSON: string,
     animated: boolean,
   ) => void;
 
   setIndoorActiveLevelIndex: (
-    viewRef: React.ElementRef<React.ComponentType>,
+    viewRef: React.ElementRef<typeof FabricMapView>,
     activeLevelIndex: Int32,
   ) => void;
 }