react-native-maps 1.21.0-alpha.82 → 1.21.0-alpha.84

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

@@ -2,8 +2,37 @@ package com.rnmaps.maps;
 
 import android.content.Context;
 import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.drawable.Animatable;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
 
+import androidx.annotation.Nullable;
+
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.BaseDataSubscriber;
+import com.facebook.datasource.DataSource;
+import com.facebook.datasource.DataSubscriber;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.drawee.controller.BaseControllerListener;
+import com.facebook.drawee.controller.ControllerListener;
+import com.facebook.drawee.drawable.ScalingUtils;
+import com.facebook.drawee.generic.GenericDraweeHierarchy;
+import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder;
+import com.facebook.drawee.view.DraweeHolder;
+import com.facebook.imagepipeline.core.ImagePipeline;
+import com.facebook.imagepipeline.image.CloseableBitmap;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.image.CloseableStaticBitmap;
+import com.facebook.imagepipeline.image.ImageInfo;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
 import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.common.MapBuilder;
+import com.google.android.gms.common.images.ImageManager;
 import com.google.android.gms.maps.model.BitmapDescriptor;
 import com.google.android.gms.maps.model.BitmapDescriptorFactory;
 import com.google.android.gms.maps.model.GroundOverlay;
@@ -11,156 +40,265 @@ import com.google.android.gms.maps.model.GroundOverlayOptions;
 import com.google.android.gms.maps.model.LatLng;
 import com.google.android.gms.maps.model.LatLngBounds;
 import com.google.maps.android.collections.GroundOverlayManager;
+import com.rnmaps.fabric.event.OnPressEvent;
+
+import java.util.Map;
+import java.util.concurrent.Executors;
 
 public class MapOverlay extends MapFeature implements ImageReadable {
 
-  private GroundOverlayOptions groundOverlayOptions;
-  private GroundOverlay groundOverlay;
-  private LatLngBounds bounds;
-  private float bearing;
-  private BitmapDescriptor iconBitmapDescriptor;
-  private boolean tappable;
-  private float zIndex;
-  private float transparency;
-
-  private final ImageReader mImageReader;
-  private GroundOverlayManager.Collection groundOverlayCollection;
-
-  public MapOverlay(Context context) {
-    super(context);
-    this.mImageReader = new ImageReader(context, getResources(), this);
-  }
-
-  public void setBounds(ReadableArray bounds) {
-    LatLng sw = new LatLng(bounds.getArray(0).getDouble(0), bounds.getArray(0).getDouble(1));
-    LatLng ne = new LatLng(bounds.getArray(1).getDouble(0), bounds.getArray(1).getDouble(1));
-    this.bounds = new LatLngBounds(sw, ne);
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setPositionFromBounds(this.bounds);
-    }
-  }
-
-  public void setBearing(float bearing){
-    this.bearing = bearing;
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setBearing(bearing);
-    }
-  }
-
-  public void setZIndex(float zIndex) {
-    this.zIndex = zIndex;
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setZIndex(zIndex);
-    }
-  }
-
-  public void setTransparency(float transparency) {
-      this.transparency = transparency;
-      if (groundOverlay != null) {
-          groundOverlay.setTransparency(transparency);
-      }
-  }
-
-  public void setImage(String uri) {
-    this.mImageReader.setImage(uri);
-  }
-
-  public void setTappable(boolean tapabble) {
-    this.tappable = tapabble;
-    if (groundOverlay != null) {
-      groundOverlay.setClickable(tappable);
-    }
-  }
-
-
-  public GroundOverlayOptions getGroundOverlayOptions() {
-    if (this.groundOverlayOptions == null) {
-      this.groundOverlayOptions = createGroundOverlayOptions();
-    }
-    return this.groundOverlayOptions;
-  }
-
-  private GroundOverlayOptions createGroundOverlayOptions() {
-    if (this.groundOverlayOptions != null) {
-      return this.groundOverlayOptions;
-    }
-    GroundOverlayOptions options = new GroundOverlayOptions();
-    if (this.iconBitmapDescriptor != null) {
-      options.image(iconBitmapDescriptor);
-    } else {
-      // add stub image to be able to instantiate the overlay
-      // and store a reference to it in MapView
-      options.image(BitmapDescriptorFactory.defaultMarker());
-      // hide overlay until real image gets added
-      options.visible(false);
-    }
-    options.positionFromBounds(bounds);
-    options.zIndex(zIndex);
-    options.bearing(bearing);
-    options.transparency(transparency);
-    return options;
-  }
-
-  @Override
-  public Object getFeature() {
-    return groundOverlay;
-  }
-
-  @Override
-  public void addToMap(Object collection) {
-    GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
-    GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
-    if (groundOverlayOptions != null) {
-      groundOverlay = groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
-      groundOverlay.setClickable(this.tappable);
-    } else {
-      this.groundOverlayCollection = groundOverlayCollection;
-    }
-  }
-
-  @Override
-  public void removeFromMap(Object collection) {
-    if (groundOverlay != null) {
-      GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
-      groundOverlayCollection.remove(groundOverlay);
-      groundOverlay = null;
-      groundOverlayOptions = null;
-    }
-    groundOverlayCollection = null;
-  }
-
-  @Override
-  public void setIconBitmap(Bitmap bitmap) {
-  }
-
-  @Override
-  public void setIconBitmapDescriptor(
-      BitmapDescriptor iconBitmapDescriptor) {
-    this.iconBitmapDescriptor = iconBitmapDescriptor;
-  }
-
-  @Override
-  public void update() {
-    this.groundOverlay = getGroundOverlay();
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setVisible(true);
-      this.groundOverlay.setImage(this.iconBitmapDescriptor);
-      this.groundOverlay.setTransparency(this.transparency);
-      this.groundOverlay.setClickable(this.tappable);
-    }
-  }
-
-  private GroundOverlay getGroundOverlay() {
-    if (this.groundOverlay != null) {
-      return this.groundOverlay;
-    }
-    if (this.groundOverlayCollection == null) {
-      return null;
-    }
-    GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
-    if (groundOverlayOptions != null) {
-      return this.groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
-    }
-    return null;
-  }
+
+    private String imageUri;
+
+    private GroundOverlayOptions groundOverlayOptions;
+    private GroundOverlay groundOverlay;
+    private LatLngBounds bounds;
+    private float bearing;
+    private BitmapDescriptor bitmapDescriptor;
+    private boolean tappable;
+    private float zIndex;
+    private float transparency;
+
+    private DataSource<CloseableReference<CloseableImage>> dataSource;
+
+    private GroundOverlayManager.Collection groundOverlayCollection;
+
+    private ImageManager.OnImageLoadedListener imageLoadedListener;
+
+
+    public MapOverlay(Context context) {
+        super(context);
+        transparency = 1;
+    }
+
+    private GenericDraweeHierarchy createDraweeHierarchy() {
+        return new GenericDraweeHierarchyBuilder(getResources())
+                .setActualImageScaleType(ScalingUtils.ScaleType.FIT_CENTER)
+                .setFadeDuration(0)
+                .build();
+    }
+
+
+    // seems like apple users north west, south east
+    // google uses north east, south west
+    private static LatLngBounds fixBoundsIfNecessary(ReadableArray bounds) {
+        double lat1 = bounds.getArray(0).getDouble(0);
+        double lon1 = bounds.getArray(0).getDouble(1);
+        double lat2 = bounds.getArray(1).getDouble(0);
+        double lon2 = bounds.getArray(1).getDouble(1);
+
+// Ensure lat1/lon1 is the SW corner and lat2/lon2 is the NE corner
+        double southLat = Math.min(lat1, lat2);
+        double northLat = Math.max(lat1, lat2);
+        double westLon = Math.min(lon1, lon2);
+        double eastLon = Math.max(lon1, lon2);
+
+// Create corrected LatLngs
+        LatLng sw = new LatLng(southLat, westLon);
+        LatLng ne = new LatLng(northLat, eastLon);
+        return new LatLngBounds(sw, ne);
+    }
+
+    public void setBounds(ReadableArray bounds) {
+
+        this.bounds = fixBoundsIfNecessary(bounds);
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setPositionFromBounds(this.bounds);
+        }
+    }
+
+    public void setBearing(float bearing) {
+        this.bearing = bearing;
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setBearing(bearing);
+        }
+    }
+
+    public void setZIndex(float zIndex) {
+        this.zIndex = zIndex;
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setZIndex(zIndex);
+        }
+    }
+
+    public void setTransparency(float transparency) {
+        this.transparency = transparency;
+        if (groundOverlay != null) {
+            groundOverlay.setTransparency(transparency);
+        }
+    }
+
+
+    public void setImage(String uri) {
+        boolean shouldLoadImage = true;
+
+        this.imageUri = uri;
+        if (!shouldLoadImage) {
+            return;
+        }
+
+        if (uri == null) {
+            bitmapDescriptor = null;
+        } else if (uri.startsWith("http://") || uri.startsWith("https://") ||
+                uri.startsWith("file://") || uri.startsWith("asset://") || uri.startsWith("data:")) {
+
+            ImageRequest imageRequest = ImageRequestBuilder
+                    .newBuilderWithSource(Uri.parse(uri))
+                    .build();
+
+            ImagePipeline imagePipeline = Fresco.getImagePipeline();
+            dataSource = imagePipeline.fetchDecodedImage(imageRequest, this);
+
+            DataSubscriber<CloseableReference<CloseableImage>> subscriber = new BaseDataSubscriber<CloseableReference<CloseableImage>>() {
+                @Override
+                protected void onNewResultImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
+                    if (!dataSource.isFinished()) {
+                        return;
+                    }
+
+                    CloseableReference<CloseableImage> imageReference = dataSource.getResult();
+                    if (imageReference != null) {
+                        try {
+                            CloseableImage closeableImage = imageReference.get();
+                            if (closeableImage instanceof CloseableBitmap) {
+                                Bitmap bitmap = ((CloseableBitmap) closeableImage).getUnderlyingBitmap();
+                                if (bitmap != null) {
+                                    bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(bitmap);
+                                }
+                            }
+                        } finally {
+                            CloseableReference.closeSafely(imageReference);
+                        }
+                        new Handler(Looper.getMainLooper()).post(() -> update());
+                    }
+                }
+
+                @Override
+                protected void onFailureImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
+                    // Handle failure
+                }
+            };
+
+            dataSource.subscribe(subscriber, Executors.newSingleThreadExecutor());
+
+        } else {
+            bitmapDescriptor = getBitmapDescriptorByName(uri);
+        }
+    }
+
+
+    private BitmapDescriptor getBitmapDescriptorByName(String name) {
+        return BitmapDescriptorFactory.fromResource(getDrawableResourceByName(name));
+    }
+
+    private int getDrawableResourceByName(String name) {
+        return getResources().getIdentifier(
+                name,
+                "drawable",
+                getContext().getPackageName());
+    }
+
+    public void setTappable(boolean tapabble) {
+        this.tappable = tapabble;
+        if (groundOverlay != null) {
+            groundOverlay.setClickable(tappable);
+        }
+    }
+
+    public static Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+        builder.put(OnPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPressEvent.EVENT_NAME));
+        return builder.build();
+    }
+
+    public GroundOverlayOptions getGroundOverlayOptions() {
+        if (this.groundOverlayOptions == null) {
+            this.groundOverlayOptions = createGroundOverlayOptions();
+        }
+        return this.groundOverlayOptions;
+    }
+
+    private GroundOverlayOptions createGroundOverlayOptions() {
+        if (this.groundOverlayOptions != null) {
+            return this.groundOverlayOptions;
+        }
+        GroundOverlayOptions options = new GroundOverlayOptions();
+        if (this.bitmapDescriptor != null) {
+            options.image(bitmapDescriptor);
+        } else {
+            // add stub image to be able to instantiate the overlay
+            // and store a reference to it in MapView
+            options.image(BitmapDescriptorFactory.defaultMarker());
+            // hide overlay until real image gets added
+            options.visible(false);
+        }
+        options.positionFromBounds(bounds);
+        options.zIndex(zIndex);
+        options.bearing(bearing);
+//        options.transparency(transparency);
+        return options;
+    }
+
+    @Override
+    public Object getFeature() {
+        return groundOverlay;
+    }
+
+    @Override
+    public void addToMap(Object collection) {
+        GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
+        GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
+        if (groundOverlayOptions != null) {
+            groundOverlay = groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
+            groundOverlay.setClickable(this.tappable);
+        } else {
+            this.groundOverlayCollection = groundOverlayCollection;
+        }
+    }
+
+    @Override
+    public void removeFromMap(Object collection) {
+        if (groundOverlay != null) {
+            GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
+            groundOverlayCollection.remove(groundOverlay);
+            groundOverlay = null;
+            groundOverlayOptions = null;
+        }
+        groundOverlayCollection = null;
+    }
+
+    @Override
+    public void setIconBitmap(Bitmap bitmap) {
+    }
+
+    @Override
+    public void setBitmapDescriptor(
+            BitmapDescriptor bitmapDescriptor) {
+        this.bitmapDescriptor = bitmapDescriptor;
+    }
+
+    @Override
+    public void update() {
+        this.groundOverlay = getGroundOverlay();
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setVisible(true);
+            this.groundOverlay.setImage(this.bitmapDescriptor);
+  //          this.groundOverlay.setTransparency(this.transparency);
+            this.groundOverlay.setClickable(this.tappable);
+        }
+    }
+
+    private GroundOverlay getGroundOverlay() {
+        if (this.groundOverlay != null) {
+            return this.groundOverlay;
+        }
+        if (this.groundOverlayCollection == null) {
+            return null;
+        }
+        GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
+        if (groundOverlayOptions != null) {
+            return this.groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
+        }
+        return null;
+    }
 }

package/ios/generated/RNMapsSpecs/ComponentDescriptors.cpp

@@ -22,6 +22,7 @@ registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMapViewComponentDe
 registry->add(concreteComponentDescriptorProvider<RNMapsGooglePolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMapViewComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMarkerComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsOverlayComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsPolylineComponentDescriptor>());
 }
 

package/ios/generated/RNMapsSpecs/ComponentDescriptors.h

@@ -22,6 +22,7 @@ using RNMapsGoogleMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMap
 using RNMapsGooglePolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsGooglePolygonShadowNode>;
 using RNMapsMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsMapViewShadowNode>;
 using RNMapsMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsMarkerShadowNode>;
+using RNMapsOverlayComponentDescriptor = ConcreteComponentDescriptor<RNMapsOverlayShadowNode>;
 using RNMapsPolylineComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolylineShadowNode>;
 
 void RNMapsSpecs_registerComponentDescriptorsFromCodegen(

package/ios/generated/RNMapsSpecs/EventEmitters.cpp

@@ -938,6 +938,28 @@ $payload.setProperty(runtime, "id", $event.id);
 }
 
 
+void RNMapsOverlayEventEmitter::onPress(OnPress $event) const {
+  dispatchEvent("press", [$event=std::move($event)](jsi::Runtime &runtime) {
+    auto $payload = jsi::Object(runtime);
+    $payload.setProperty(runtime, "action", $event.action);
+$payload.setProperty(runtime, "id", $event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", $event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", $event.coordinate.longitude);
+  $payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", $event.position.x);
+  position.setProperty(runtime, "y", $event.position.y);
+  $payload.setProperty(runtime, "position", position);
+}
+    return $payload;
+  });
+}
+
+
 void RNMapsPolylineEventEmitter::onPress(OnPress $event) const {
   dispatchEvent("press", [$event=std::move($event)](jsi::Runtime &runtime) {
     auto $payload = jsi::Object(runtime);

package/ios/generated/RNMapsSpecs/EventEmitters.h

@@ -806,6 +806,28 @@ class RNMapsMarkerEventEmitter : public ViewEventEmitter {
 
   void onSelect(OnSelect value) const;
 };
+class RNMapsOverlayEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+  void onPress(OnPress value) const;
+};
 class RNMapsPolylineEventEmitter : public ViewEventEmitter {
  public:
   using ViewEventEmitter::ViewEventEmitter;

package/ios/generated/RNMapsSpecs/Props.cpp

@@ -163,6 +163,17 @@ RNMapsMarkerProps::RNMapsMarkerProps(
     subtitleVisibility(convertRawProp(context, rawProps, "subtitleVisibility", sourceProps.subtitleVisibility, {RNMapsMarkerSubtitleVisibility::Adaptive})),
     useLegacyPinView(convertRawProp(context, rawProps, "useLegacyPinView", sourceProps.useLegacyPinView, {false}))
       {}
+RNMapsOverlayProps::RNMapsOverlayProps(
+    const PropsParserContext &context,
+    const RNMapsOverlayProps &sourceProps,
+    const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
+
+    bearing(convertRawProp(context, rawProps, "bearing", sourceProps.bearing, {0.0})),
+    bounds(convertRawProp(context, rawProps, "bounds", sourceProps.bounds, {})),
+    image(convertRawProp(context, rawProps, "image", sourceProps.image, {})),
+    opacity(convertRawProp(context, rawProps, "opacity", sourceProps.opacity, {1.0})),
+    tappable(convertRawProp(context, rawProps, "tappable", sourceProps.tappable, {false}))
+      {}
 RNMapsPolylineProps::RNMapsPolylineProps(
     const PropsParserContext &context,
     const RNMapsPolylineProps &sourceProps,

package/ios/generated/RNMapsSpecs/Props.h

@@ -1092,6 +1092,51 @@ class RNMapsMarkerProps final : public ViewProps {
   bool useLegacyPinView{false};
 };
 
+struct RNMapsOverlayBoundsStruct {
+  double latitude{0.0};
+  double longitude{0.0};
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, RNMapsOverlayBoundsStruct &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto tmp_latitude = map.find("latitude");
+  if (tmp_latitude != map.end()) {
+    fromRawValue(context, tmp_latitude->second, result.latitude);
+  }
+  auto tmp_longitude = map.find("longitude");
+  if (tmp_longitude != map.end()) {
+    fromRawValue(context, tmp_longitude->second, result.longitude);
+  }
+}
+
+static inline std::string toString(const RNMapsOverlayBoundsStruct &value) {
+  return "[Object RNMapsOverlayBoundsStruct]";
+}
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<RNMapsOverlayBoundsStruct> &result) {
+  auto items = (std::vector<RawValue>)value;
+  for (const auto &item : items) {
+    RNMapsOverlayBoundsStruct newItem;
+    fromRawValue(context, item, newItem);
+    result.emplace_back(newItem);
+  }
+}
+
+class RNMapsOverlayProps final : public ViewProps {
+ public:
+  RNMapsOverlayProps() = default;
+  RNMapsOverlayProps(const PropsParserContext& context, const RNMapsOverlayProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+
+  Float bearing{0.0};
+  std::vector<RNMapsOverlayBoundsStruct> bounds{};
+  ImageSource image{};
+  Float opacity{1.0};
+  bool tappable{false};
+};
+
 enum class RNMapsPolylineLineCap { Butt, Round, Square };
 
 static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, RNMapsPolylineLineCap &result) {

package/ios/generated/RNMapsSpecs/RCTComponentViewHelpers.h

@@ -592,6 +592,10 @@ if ([commandName isEqualToString:@"redraw"]) {
 #endif
 }
 
+@protocol RCTRNMapsOverlayViewProtocol <NSObject>
+
+@end
+
 @protocol RCTRNMapsPolylineViewProtocol <NSObject>
 
 @end

package/ios/generated/RNMapsSpecs/ShadowNodes.cpp

@@ -18,6 +18,7 @@ extern const char RNMapsGoogleMapViewComponentName[] = "RNMapsGoogleMapView";
 extern const char RNMapsGooglePolygonComponentName[] = "RNMapsGooglePolygon";
 extern const char RNMapsMapViewComponentName[] = "RNMapsMapView";
 extern const char RNMapsMarkerComponentName[] = "RNMapsMarker";
+extern const char RNMapsOverlayComponentName[] = "RNMapsOverlay";
 extern const char RNMapsPolylineComponentName[] = "RNMapsPolyline";
 
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/ShadowNodes.h

@@ -84,6 +84,17 @@ using RNMapsMarkerShadowNode = ConcreteViewShadowNode<
     RNMapsMarkerEventEmitter,
     RNMapsMarkerState>;
 
+JSI_EXPORT extern const char RNMapsOverlayComponentName[];
+
+/*
+ * `ShadowNode` for <RNMapsOverlay> component.
+ */
+using RNMapsOverlayShadowNode = ConcreteViewShadowNode<
+    RNMapsOverlayComponentName,
+    RNMapsOverlayProps,
+    RNMapsOverlayEventEmitter,
+    RNMapsOverlayState>;
+
 JSI_EXPORT extern const char RNMapsPolylineComponentName[];
 
 /*

package/ios/generated/RNMapsSpecs/States.h

@@ -86,6 +86,18 @@ public:
 #endif
 };
 
+class RNMapsOverlayState {
+public:
+  RNMapsOverlayState() = default;
+
+#ifdef ANDROID
+  RNMapsOverlayState(RNMapsOverlayState const &previousState, folly::dynamic data){};
+  folly::dynamic getDynamic() const {
+    return {};
+  };
+#endif
+};
+
 class RNMapsPolylineState {
 public:
   RNMapsPolylineState() = default;