@lugg/maps 1.0.0-beta.2 → 1.0.0-beta.20

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)
 
@@ -27,13 +30,19 @@ interface MapProvider {
   fun setScrollEnabled(enabled: Boolean)
   fun setRotateEnabled(enabled: Boolean)
   fun setPitchEnabled(enabled: Boolean)
+  fun setCompassEnabled(enabled: Boolean)
   fun setUserLocationEnabled(enabled: Boolean)
   fun setUserLocationButtonEnabled(enabled: Boolean)
+  fun setMapType(value: String)
   fun setTheme(value: String)
   fun setMinZoom(zoom: Double)
   fun setMaxZoom(zoom: Double)
   fun setEdgeInsets(edgeInsets: EdgeInsets)
   fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int)
+  fun setInsetAdjustment(value: String)
+  fun setPoiEnabled(enabled: Boolean)
+  fun setPoiFilterMode(mode: String)
+  fun setPoiFilterCategories(categories: List<String>)
 
   // Children
   fun addMarkerView(markerView: LuggMarkerView)
@@ -42,6 +51,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/core/PolylineAnimator.kt

@@ -15,18 +15,44 @@ import kotlin.math.min
 class PolylineAnimator {
   companion object {
     private const val MAX_ANIMATION_SPANS = 16
+    private const val MAX_GRADIENT_SPANS = 512
+
+    // Cap polyline updates to ~60fps; every update crosses Binder into the
+    // maps renderer, and 120Hz displays double that churn (CONSUMER-APP-44Y)
+    private const val MIN_UPDATE_INTERVAL_NANOS = 16_000_000L
   }
 
   var polyline: Polyline? = null
   var coordinates: List<LatLng> = emptyList()
     set(value) {
+      // Structural equality: Fabric delivers a new list instance on every
+      // commit, so identity checks never match and the full route would be
+      // re-parceled across Binder even when unchanged
+      if (field == value) return
       field = value
+      dirty = true
       if (animated && animator != null) {
         computeCumulativeDistances()
       }
     }
   var strokeColors: List<Int> = listOf(Color.BLACK)
+    set(value) {
+      if (field == value) return
+      field = value
+      dirty = true
+    }
   var strokeWidth: Float = 1f
+    set(value) {
+      if (field == value) return
+      field = value
+      polyline?.width = value
+    }
+  var zIndex: Float = 0f
+    set(value) {
+      if (field == value) return
+      field = value
+      polyline?.zIndex = value
+    }
   var animatedOptions: AnimatedOptions = AnimatedOptions()
     set(value) {
       if (field == value) return
@@ -50,8 +76,11 @@ class PolylineAnimator {
 
   private var animator: ValueAnimator? = null
   private var animationProgress: Float = 0f
+  private var lastUpdateNanos: Long = 0L
+  private var lastAppliedColor: Int? = null
   private var cumulativeDistances: FloatArray = floatArrayOf()
   private var totalLength: Float = 0f
+  private var dirty: Boolean = true
 
   // Reusable collections to avoid per-frame allocations
   private val reusablePoints = ArrayList<LatLng>()
@@ -72,16 +101,21 @@ class PolylineAnimator {
 
   fun update() {
     if (animated) return
+    if (!dirty) return
 
     val poly = polyline ?: return
     if (coordinates.size < 2) return
 
+    dirty = false
     poly.points = coordinates
 
     if (strokeColors.size > 1) {
-      poly.setSpans(createGradientSpans())
+      applyGradientSpans(poly)
+      lastAppliedColor = null
     } else {
-      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+      val color = strokeColors.firstOrNull() ?: Color.BLACK
+      poly.color = color
+      lastAppliedColor = color
     }
   }
 
@@ -100,6 +134,9 @@ class PolylineAnimator {
       interpolator = LinearInterpolator()
       addUpdateListener { animation ->
         animationProgress = animation.animatedValue as Float
+        val now = System.nanoTime()
+        if (now - lastUpdateNanos < MIN_UPDATE_INTERVAL_NANOS) return@addUpdateListener
+        lastUpdateNanos = now
         updateAnimatedPolyline()
       }
       start()
@@ -171,6 +208,7 @@ class PolylineAnimator {
   private fun stopAnimation() {
     animator?.cancel()
     animator = null
+    lastUpdateNanos = 0L
   }
 
   fun pause() {
@@ -209,8 +247,10 @@ class PolylineAnimator {
     }
 
     if (headDist <= tailDist) {
-      poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
+      val point = coordinates.firstOrNull() ?: LatLng(0.0, 0.0)
       poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+      lastAppliedColor = null
+      poly.points = listOf(point, point)
       return
     }
 
@@ -234,11 +274,13 @@ class PolylineAnimator {
 
     if (reusablePoints.size < 2) return
 
-    poly.points = ArrayList(reusablePoints)
-
-    if (strokeColors.size <= 1) {
+    if (strokeColors.size > 1) {
+      // Clear spans before setting points to prevent IndexOutOfBoundsException
+      // when the new points list is shorter than what existing spans reference
       poly.color = strokeColors.firstOrNull() ?: Color.BLACK
-    } else {
+      lastAppliedColor = null
+      poly.points = reusablePoints
+
       val segmentCount = reusablePoints.size - 1
       val spanCount = min(segmentCount, MAX_ANIMATION_SPANS)
       val segmentsPerSpan = segmentCount.toDouble() / spanCount
@@ -250,16 +292,28 @@ class PolylineAnimator {
         reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan))
       }
       poly.setSpans(reusableSpans)
+    } else {
+      val color = strokeColors.firstOrNull() ?: Color.BLACK
+      if (lastAppliedColor != color) {
+        poly.color = color
+        lastAppliedColor = color
+      }
+      poly.points = reusablePoints
     }
   }
 
-  private fun createGradientSpans(): List<StyleSpan> {
+  private fun applyGradientSpans(poly: Polyline) {
     val segmentCount = coordinates.size - 1
-    return (0 until segmentCount).map { i ->
-      val position = i.toFloat() / segmentCount
+    val spanCount = min(segmentCount, MAX_GRADIENT_SPANS)
+    val segmentsPerSpan = segmentCount.toDouble() / spanCount
+
+    reusableSpans.clear()
+    for (i in 0 until spanCount) {
+      val position = (i + 0.5f) / spanCount
       val color = colorAtGradientPosition(position)
-      StyleSpan(StrokeStyle.colorBuilder(color).build())
+      reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan))
     }
+    poly.setSpans(reusableSpans)
   }
 
   private fun colorAtGradientPosition(position: Float): Int {

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/android/src/main/java/com/luggmaps/extensions/ViewExtensions.kt

@@ -1,6 +1,7 @@
 package com.luggmaps.extensions
 
 import android.view.View
+import android.view.ViewGroup
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
@@ -12,3 +13,13 @@ fun View.dispatchEvent(event: Event<*>) {
   )
   eventDispatcher?.dispatchEvent(event)
 }
+
+fun View.findViewByTag(tag: String): View? {
+  if (this.tag?.toString() == tag) return this
+  if (this !is ViewGroup) return null
+  for (i in 0 until childCount) {
+    val found = getChildAt(i).findViewByTag(tag)
+    if (found != null) return found
+  }
+  return null
+}

package/ios/LuggCalloutView.h

@@ -13,7 +13,7 @@ NS_ASSUME_NONNULL_BEGIN
 @interface LuggCalloutView : RCTViewComponentView
 
 @property(nonatomic, readonly) BOOL bubbled;
-@property(nonatomic, readonly) CGPoint anchor;
+@property(nonatomic, readonly) CGPoint offset;
 @property(nonatomic, readonly) BOOL hasCustomContent;
 @property(nonatomic, readonly) UIView *contentView;
 @property(nonatomic, weak, nullable) id<LuggCalloutViewDelegate> delegate;

package/ios/LuggCalloutView.mm

@@ -43,7 +43,7 @@ using namespace facebook::react;
 @implementation LuggCalloutView {
   LuggCalloutContentView *_contentView;
   BOOL _bubbled;
-  CGPoint _anchor;
+  CGPoint _offset;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -58,7 +58,7 @@ using namespace facebook::react;
     _props = defaultProps;
 
     _bubbled = YES;
-    _anchor = CGPointMake(0.5, 1.0);
+    _offset = CGPointZero;
     _contentView = [[LuggCalloutContentView alloc] init];
     _contentView.backgroundColor = [UIColor clearColor];
 
@@ -74,29 +74,39 @@ using namespace facebook::react;
   const auto &newViewProps =
       *std::static_pointer_cast<LuggCalloutViewProps const>(props);
 
-  _bubbled = newViewProps.bubbled;
+  BOOL changed = NO;
+
+  if (_bubbled != newViewProps.bubbled) {
+    _bubbled = newViewProps.bubbled;
+    changed = YES;
+  }
 
   if (oldProps) {
     const auto &oldViewProps =
         *std::static_pointer_cast<LuggCalloutViewProps const>(oldProps);
-    if (newViewProps.anchor.x != oldViewProps.anchor.x ||
-        newViewProps.anchor.y != oldViewProps.anchor.y) {
-      _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
+    if (newViewProps.offset.x != oldViewProps.offset.x ||
+        newViewProps.offset.y != oldViewProps.offset.y) {
+      _offset = CGPointMake(newViewProps.offset.x, newViewProps.offset.y);
+      changed = YES;
     }
-  } else if (newViewProps.anchor.x != 0 || newViewProps.anchor.y != 0) {
-    _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
+  } else if (newViewProps.offset.x != 0 || newViewProps.offset.y != 0) {
+    _offset = CGPointMake(newViewProps.offset.x, newViewProps.offset.y);
+    changed = YES;
   }
 
   [super updateProps:props oldProps:oldProps];
-  [_delegate calloutViewDidUpdate:self];
+
+  if (changed) {
+    [_delegate calloutViewDidUpdate:self];
+  }
 }
 
 - (BOOL)bubbled {
   return _bubbled;
 }
 
-- (CGPoint)anchor {
-  return _anchor;
+- (CGPoint)offset {
+  return _offset;
 }
 
 - (void)mountChildComponentView:

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

package/ios/LuggGroundOverlayView.mm

@@ -0,0 +1,125 @@
+#import "LuggGroundOverlayView.h"
+#import "events/GroundOverlayPressEvent.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"
+
+using namespace facebook::react;
+using namespace luggmaps::events;
+
+@interface LuggGroundOverlayView () <RCTLuggGroundOverlayViewViewProtocol>
+@end
+
+@implementation LuggGroundOverlayView {
+  NSString *_imageUri;
+  CLLocationCoordinate2D _northeast;
+  CLLocationCoordinate2D _southwest;
+  CGFloat _opacity;
+  CGFloat _bearing;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggGroundOverlayViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggGroundOverlayViewProps>();
+    _props = defaultProps;
+
+    _imageUri = @"";
+    _northeast = CLLocationCoordinate2DMake(0, 0);
+    _southwest = CLLocationCoordinate2DMake(0, 0);
+    _opacity = 1.0;
+    _bearing = 0.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<LuggGroundOverlayViewProps const>(props);
+
+  _imageUri = [NSString stringWithUTF8String:newViewProps.image.c_str()];
+
+  _northeast =
+      CLLocationCoordinate2DMake(newViewProps.bounds.northeast.latitude,
+                                 newViewProps.bounds.northeast.longitude);
+  _southwest =
+      CLLocationCoordinate2DMake(newViewProps.bounds.southwest.latitude,
+                                 newViewProps.bounds.southwest.longitude);
+
+  _opacity = newViewProps.opacity;
+  _bearing = newViewProps.bearing;
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate
+            respondsToSelector:@selector(groundOverlayViewDidUpdate:)]) {
+      [self.delegate groundOverlayViewDidUpdate:self];
+    }
+  }
+}
+
+- (NSString *)imageUri {
+  return _imageUri;
+}
+
+- (CLLocationCoordinate2D)northeast {
+  return _northeast;
+}
+
+- (CLLocationCoordinate2D)southwest {
+  return _southwest;
+}
+
+- (CGFloat)opacity {
+  return _opacity;
+}
+
+- (CGFloat)bearing {
+  return _bearing;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  GroundOverlayPressEvent::emit<LuggGroundOverlayViewEventEmitter>(
+      _eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.overlay = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggGroundOverlayViewCls(void) {
+  return LuggGroundOverlayView.class;
+}
+
+@end