@lugg/maps 1.0.0-beta.3 → 1.0.0-beta.4

package/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt

@@ -14,13 +14,25 @@ import com.google.android.gms.maps.OnMapReadyCallback
 import com.google.android.gms.maps.model.AdvancedMarker
 import com.google.android.gms.maps.model.AdvancedMarkerOptions
 import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import com.google.android.gms.maps.model.Circle
+import com.google.android.gms.maps.model.CircleOptions
+import com.google.android.gms.maps.model.GroundOverlay
+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.android.gms.maps.model.MapColorScheme
 import com.google.android.gms.maps.model.Marker
 import com.google.android.gms.maps.model.Polygon
 import com.google.android.gms.maps.model.PolygonOptions
 import com.google.android.gms.maps.model.PolylineOptions
+import com.google.android.gms.maps.model.TileOverlay
+import com.google.android.gms.maps.model.TileOverlayOptions
+import com.google.android.gms.maps.model.UrlTileProvider
 import com.luggmaps.LuggCalloutView
+import com.luggmaps.LuggCircleView
+import com.luggmaps.LuggCircleViewDelegate
+import com.luggmaps.LuggGroundOverlayView
+import com.luggmaps.LuggGroundOverlayViewDelegate
 import com.luggmaps.LuggMapWrapperView
 import com.luggmaps.LuggMarkerView
 import com.luggmaps.LuggMarkerViewDelegate
@@ -28,6 +40,9 @@ import com.luggmaps.LuggPolygonView
 import com.luggmaps.LuggPolygonViewDelegate
 import com.luggmaps.LuggPolylineView
 import com.luggmaps.LuggPolylineViewDelegate
+import com.luggmaps.LuggTileOverlayView
+import com.luggmaps.LuggTileOverlayViewDelegate
+import java.net.URL
 
 class GoogleMapProvider(private val context: Context) :
   MapProvider,
@@ -35,12 +50,17 @@ class GoogleMapProvider(private val context: Context) :
   LuggMarkerViewDelegate,
   LuggPolylineViewDelegate,
   LuggPolygonViewDelegate,
+  LuggCircleViewDelegate,
+  LuggGroundOverlayViewDelegate,
+  LuggTileOverlayViewDelegate,
   GoogleMap.OnCameraMoveStartedListener,
   GoogleMap.OnCameraMoveListener,
   GoogleMap.OnCameraIdleListener,
   GoogleMap.OnMapClickListener,
   GoogleMap.OnMapLongClickListener,
   GoogleMap.OnPolygonClickListener,
+  GoogleMap.OnCircleClickListener,
+  GoogleMap.OnGroundOverlayClickListener,
   GoogleMap.OnMarkerClickListener,
   GoogleMap.OnMarkerDragListener,
   GoogleMap.InfoWindowAdapter {
@@ -58,8 +78,13 @@ class GoogleMapProvider(private val context: Context) :
   private val pendingMarkerViews = mutableSetOf<LuggMarkerView>()
   private val pendingPolylineViews = mutableSetOf<LuggPolylineView>()
   private val pendingPolygonViews = mutableSetOf<LuggPolygonView>()
+  private val pendingCircleViews = mutableSetOf<LuggCircleView>()
+  private val pendingGroundOverlayViews = mutableSetOf<LuggGroundOverlayView>()
+  private val pendingTileOverlayViews = mutableSetOf<LuggTileOverlayView>()
   private val polylineAnimators = mutableMapOf<LuggPolylineView, PolylineAnimator>()
   private val polygonToViewMap = mutableMapOf<Polygon, LuggPolygonView>()
+  private val circleToViewMap = mutableMapOf<Circle, LuggCircleView>()
+  private val groundOverlayToViewMap = mutableMapOf<GroundOverlay, LuggGroundOverlayView>()
   private val markerToViewMap = mutableMapOf<Marker, LuggMarkerView>()
   private val liveMarkerViews = mutableSetOf<LuggMarkerView>()
   private var activeNonBubbledMarker: Marker? = null
@@ -118,9 +143,14 @@ class GoogleMapProvider(private val context: Context) :
     pendingMarkerViews.clear()
     pendingPolylineViews.clear()
     pendingPolygonViews.clear()
+    pendingCircleViews.clear()
+    pendingGroundOverlayViews.clear()
+    pendingTileOverlayViews.clear()
     polylineAnimators.values.forEach { it.destroy() }
     polylineAnimators.clear()
     polygonToViewMap.clear()
+    circleToViewMap.clear()
+    groundOverlayToViewMap.clear()
     markerToViewMap.clear()
     wrapperView?.touchEventHandler = null
     wrapperView = null
@@ -130,6 +160,8 @@ class GoogleMapProvider(private val context: Context) :
     googleMap?.setOnMapClickListener(null)
     googleMap?.setOnMapLongClickListener(null)
     googleMap?.setOnPolygonClickListener(null)
+    googleMap?.setOnCircleClickListener(null)
+    googleMap?.setOnGroundOverlayClickListener(null)
     googleMap?.setOnMarkerClickListener(null)
     googleMap?.setOnMarkerDragListener(null)
     googleMap?.setInfoWindowAdapter(null)
@@ -154,6 +186,8 @@ class GoogleMapProvider(private val context: Context) :
     map.setOnMapClickListener(this)
     map.setOnMapLongClickListener(this)
     map.setOnPolygonClickListener(this)
+    map.setOnCircleClickListener(this)
+    map.setOnGroundOverlayClickListener(this)
     map.setOnMarkerClickListener(this)
     map.setOnMarkerDragListener(this)
     map.setInfoWindowAdapter(this)
@@ -172,6 +206,9 @@ class GoogleMapProvider(private val context: Context) :
     processPendingMarkers()
     processPendingPolylines()
     processPendingPolygons()
+    processPendingCircles()
+    processPendingGroundOverlays()
+    processPendingTileOverlays()
 
     delegate?.mapProviderDidReady()
   }
@@ -227,6 +264,22 @@ class GoogleMapProvider(private val context: Context) :
     }
   }
 
+  override fun onCircleClick(circle: Circle) {
+    val circleView = circleToViewMap[circle]
+    if (circleView?.tappable == true) {
+      circleView.emitPressEvent()
+    } else {
+      onMapClick(tapLocation ?: return)
+    }
+  }
+
+  override fun onGroundOverlayClick(groundOverlay: GroundOverlay) {
+    val view = groundOverlayToViewMap[groundOverlay]
+    if (view?.tappable == true) {
+      view.emitPressEvent()
+    }
+  }
+
   override fun onMarkerClick(marker: Marker): Boolean {
     dismissNonBubbledCallout()
 
@@ -487,6 +540,30 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region CircleViewDelegate
+
+  override fun circleViewDidUpdate(circleView: LuggCircleView) {
+    syncCircleView(circleView)
+  }
+
+  // endregion
+
+  // region GroundOverlayViewDelegate
+
+  override fun groundOverlayViewDidUpdate(groundOverlayView: LuggGroundOverlayView) {
+    syncGroundOverlayView(groundOverlayView)
+  }
+
+  // endregion
+
+  // region TileOverlayViewDelegate
+
+  override fun tileOverlayViewDidUpdate(tileOverlayView: LuggTileOverlayView) {
+    syncTileOverlayView(tileOverlayView)
+  }
+
+  // endregion
+
   // region Marker Management
 
   override fun addMarkerView(markerView: LuggMarkerView) {
@@ -753,6 +830,218 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region Circle Management
+
+  override fun addCircleView(circleView: LuggCircleView) {
+    circleView.delegate = this
+    syncCircleView(circleView)
+  }
+
+  override fun removeCircleView(circleView: LuggCircleView) {
+    circleView.circle?.let { circleToViewMap.remove(it) }
+    circleView.circle?.remove()
+    circleView.circle = null
+  }
+
+  private fun syncCircleView(circleView: LuggCircleView) {
+    if (googleMap == null) {
+      pendingCircleViews.add(circleView)
+      return
+    }
+
+    if (circleView.circle == null) {
+      addCircleViewToMap(circleView)
+      return
+    }
+
+    circleView.circle?.apply {
+      center = circleView.center
+      radius = circleView.radius
+      fillColor = circleView.fillColor
+      strokeColor = circleView.strokeColor
+      strokeWidth = circleView.strokeWidth.dpToPx()
+      zIndex = circleView.zIndex
+      isClickable = true
+    }
+  }
+
+  private fun processPendingCircles() {
+    if (googleMap == null) return
+    pendingCircleViews.forEach { addCircleViewToMap(it) }
+    pendingCircleViews.clear()
+  }
+
+  private fun addCircleViewToMap(circleView: LuggCircleView) {
+    val map = googleMap ?: return
+
+    val options = CircleOptions()
+      .center(circleView.center)
+      .radius(circleView.radius)
+      .fillColor(circleView.fillColor)
+      .strokeColor(circleView.strokeColor)
+      .strokeWidth(circleView.strokeWidth.dpToPx())
+      .zIndex(circleView.zIndex)
+      .clickable(true)
+
+    val circle = map.addCircle(options)
+    circleView.circle = circle
+    circleToViewMap[circle] = circleView
+  }
+
+  // endregion
+
+  // region Ground Overlay Management
+
+  override fun addGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    groundOverlayView.delegate = this
+    syncGroundOverlayView(groundOverlayView)
+  }
+
+  override fun removeGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    groundOverlayView.delegate = null
+    groundOverlayView.groundOverlay?.let { groundOverlayToViewMap.remove(it) }
+    groundOverlayView.groundOverlay?.remove()
+    groundOverlayView.groundOverlay = null
+  }
+
+  private fun syncGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    if (googleMap == null) {
+      pendingGroundOverlayViews.add(groundOverlayView)
+      return
+    }
+
+    val imageUri = groundOverlayView.imageUri
+    if (imageUri.isEmpty()) return
+
+    // Remove old overlay
+    groundOverlayView.groundOverlay?.let { groundOverlayToViewMap.remove(it) }
+    groundOverlayView.groundOverlay?.remove()
+    groundOverlayView.groundOverlay = null
+
+    // Load image async and add overlay
+    Thread {
+      try {
+        val connection = URL(imageUri).openConnection() as java.net.HttpURLConnection
+        connection.instanceFollowRedirects = true
+        connection.connect()
+        val bitmap = android.graphics.BitmapFactory.decodeStream(connection.inputStream)
+        connection.disconnect()
+        if (bitmap != null) {
+          mapView?.post {
+            addGroundOverlayToMap(groundOverlayView, bitmap)
+          }
+        }
+      } catch (_: Exception) {}
+    }.start()
+  }
+
+  private fun addGroundOverlayToMap(groundOverlayView: LuggGroundOverlayView, bitmap: android.graphics.Bitmap) {
+    val map = googleMap ?: return
+
+    val bounds = LatLngBounds(groundOverlayView.southwest, groundOverlayView.northeast)
+    val options = GroundOverlayOptions()
+      .image(BitmapDescriptorFactory.fromBitmap(bitmap))
+      .positionFromBounds(bounds)
+      .transparency(1f - groundOverlayView.overlayOpacity)
+      .bearing(groundOverlayView.bearing)
+      .zIndex(groundOverlayView.zIndex)
+      .clickable(groundOverlayView.tappable)
+
+    val overlay = map.addGroundOverlay(options)
+    if (overlay != null) {
+      groundOverlayView.groundOverlay = overlay
+      groundOverlayToViewMap[overlay] = groundOverlayView
+    }
+  }
+
+  private fun processPendingGroundOverlays() {
+    if (googleMap == null) return
+    pendingGroundOverlayViews.forEach { syncGroundOverlayView(it) }
+    pendingGroundOverlayViews.clear()
+  }
+
+  // endregion
+
+  // region Tile Overlay Management
+
+  override fun addTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    tileOverlayView.delegate = this
+    syncTileOverlayView(tileOverlayView)
+  }
+
+  override fun removeTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    tileOverlayView.delegate = null
+    tileOverlayView.tileOverlay?.remove()
+    tileOverlayView.tileOverlay = null
+  }
+
+  private fun syncTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    if (googleMap == null) {
+      pendingTileOverlayViews.add(tileOverlayView)
+      return
+    }
+
+    val urlTemplate = tileOverlayView.urlTemplate
+    if (urlTemplate.isEmpty()) return
+
+    // Remove old overlay
+    tileOverlayView.tileOverlay?.remove()
+    tileOverlayView.tileOverlay = null
+
+    val tileSize = tileOverlayView.tileSize
+    val hasBounds = tileOverlayView.hasBounds
+    val swLat = tileOverlayView.boundsSwLat
+    val swLng = tileOverlayView.boundsSwLng
+    val neLat = tileOverlayView.boundsNeLat
+    val neLng = tileOverlayView.boundsNeLng
+
+    val tileProvider = object : UrlTileProvider(tileSize, tileSize) {
+      override fun getTileUrl(x: Int, y: Int, zoom: Int): URL? {
+        if (hasBounds) {
+          val n = Math.pow(2.0, zoom.toDouble())
+          val tileSWLat = Math.toDegrees(Math.atan(Math.sinh(Math.PI * (1 - 2.0 * (y + 1) / n))))
+          val tileNELat = Math.toDegrees(Math.atan(Math.sinh(Math.PI * (1 - 2.0 * y / n))))
+          val tileSWLng = x / n * 360.0 - 180.0
+          val tileNELng = (x + 1) / n * 360.0 - 180.0
+
+          if (tileNELat < swLat ||
+            tileSWLat > neLat ||
+            tileNELng < swLng ||
+            tileSWLng > neLng
+          ) {
+            return null
+          }
+        }
+
+        val url = urlTemplate
+          .replace("{x}", x.toString())
+          .replace("{y}", y.toString())
+          .replace("{z}", zoom.toString())
+        return try {
+          URL(url)
+        } catch (_: Exception) {
+          null
+        }
+      }
+    }
+
+    val options = TileOverlayOptions()
+      .tileProvider(tileProvider)
+      .transparency(1f - tileOverlayView.overlayOpacity)
+      .zIndex(tileOverlayView.zIndex)
+
+    val overlay = googleMap?.addTileOverlay(options)
+    tileOverlayView.tileOverlay = overlay
+  }
+
+  private fun processPendingTileOverlays() {
+    if (googleMap == null) return
+    pendingTileOverlayViews.forEach { syncTileOverlayView(it) }
+    pendingTileOverlayViews.clear()
+  }
+
+  // endregion
+
   // region Lifecycle
 
   override fun pauseAnimations() {

package/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt

@@ -1,9 +1,12 @@
 package com.luggmaps.core
 
 import android.view.View
+import com.luggmaps.LuggCircleView
+import com.luggmaps.LuggGroundOverlayView
 import com.luggmaps.LuggMarkerView
 import com.luggmaps.LuggPolygonView
 import com.luggmaps.LuggPolylineView
+import com.luggmaps.LuggTileOverlayView
 
 data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
 
@@ -42,6 +45,12 @@ interface MapProvider {
   fun removePolylineView(polylineView: LuggPolylineView)
   fun addPolygonView(polygonView: LuggPolygonView)
   fun removePolygonView(polygonView: LuggPolygonView)
+  fun addCircleView(circleView: LuggCircleView)
+  fun removeCircleView(circleView: LuggCircleView)
+  fun addGroundOverlayView(groundOverlayView: LuggGroundOverlayView)
+  fun removeGroundOverlayView(groundOverlayView: LuggGroundOverlayView)
+  fun addTileOverlayView(tileOverlayView: LuggTileOverlayView)
+  fun removeTileOverlayView(tileOverlayView: LuggTileOverlayView)
 
   // Lifecycle
   fun pauseAnimations()

package/android/src/main/java/com/luggmaps/events/CirclePressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class CirclePressEvent(view: View) : Event<CirclePressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topCirclePress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/events/GroundOverlayPressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class GroundOverlayPressEvent(view: View) : Event<GroundOverlayPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topGroundOverlayPress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/events/TileOverlayPressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class TileOverlayPressEvent(view: View) : Event<TileOverlayPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topTileOverlayPress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/ios/LuggCircleView.h

@@ -0,0 +1,31 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggCircleView;
+
+@protocol LuggCircleViewDelegate <NSObject>
+@optional
+- (void)circleViewDidUpdate:(LuggCircleView *)circleView;
+@end
+
+@interface LuggCircleView : RCTViewComponentView
+
+@property(nonatomic, readonly) CLLocationCoordinate2D center;
+@property(nonatomic, readonly) CLLocationDistance radius;
+@property(nonatomic, readonly) UIColor *strokeColor;
+@property(nonatomic, readonly) UIColor *fillColor;
+@property(nonatomic, readonly) CGFloat strokeWidth;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggCircleViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *circle;
+@property(nonatomic, weak, nullable) NSObject *renderer;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggCircleView.mm

@@ -0,0 +1,133 @@
+#import "LuggCircleView.h"
+#import "events/CirclePressEvent.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+using namespace luggmaps::events;
+
+@interface LuggCircleView () <RCTLuggCircleViewViewProtocol>
+@end
+
+@implementation LuggCircleView {
+  CLLocationCoordinate2D _center;
+  CLLocationDistance _radius;
+  UIColor *_strokeColor;
+  UIColor *_fillColor;
+  CGFloat _strokeWidth;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggCircleViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggCircleViewProps>();
+    _props = defaultProps;
+
+    _center = CLLocationCoordinate2DMake(0, 0);
+    _radius = 0;
+    _strokeColor = [UIColor blackColor];
+    _fillColor = [UIColor colorWithRed:0 green:0 blue:0 alpha:0.3];
+    _strokeWidth = 1.0;
+
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggCircleViewProps const>(props);
+
+  _center = CLLocationCoordinate2DMake(newViewProps.center.latitude,
+                                       newViewProps.center.longitude);
+  _radius = newViewProps.radius;
+
+  if (newViewProps.strokeColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.strokeColor);
+    if (color) {
+      _strokeColor = color;
+    }
+  }
+
+  if (newViewProps.fillColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.fillColor);
+    if (color) {
+      _fillColor = color;
+    }
+  }
+
+  _strokeWidth = newViewProps.strokeWidth > 0 ? newViewProps.strokeWidth : 1.0;
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate respondsToSelector:@selector(circleViewDidUpdate:)]) {
+      [self.delegate circleViewDidUpdate:self];
+    }
+  }
+}
+
+- (CLLocationCoordinate2D)center {
+  return _center;
+}
+
+- (CLLocationDistance)radius {
+  return _radius;
+}
+
+- (UIColor *)strokeColor {
+  return _strokeColor;
+}
+
+- (UIColor *)fillColor {
+  return _fillColor;
+}
+
+- (CGFloat)strokeWidth {
+  return _strokeWidth;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  CirclePressEvent::emit<LuggCircleViewEventEmitter>(_eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.circle = nil;
+  self.renderer = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggCircleViewCls(void) {
+  return LuggCircleView.class;
+}
+
+@end

package/ios/LuggGroundOverlayView.h

@@ -0,0 +1,30 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggGroundOverlayView;
+
+@protocol LuggGroundOverlayViewDelegate <NSObject>
+@optional
+- (void)groundOverlayViewDidUpdate:(LuggGroundOverlayView *)groundOverlayView;
+@end
+
+@interface LuggGroundOverlayView : RCTViewComponentView
+
+@property(nonatomic, readonly) NSString *imageUri;
+@property(nonatomic, readonly) CLLocationCoordinate2D northeast;
+@property(nonatomic, readonly) CLLocationCoordinate2D southwest;
+@property(nonatomic, readonly) CGFloat opacity;
+@property(nonatomic, readonly) CGFloat bearing;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggGroundOverlayViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *overlay;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END