@lugg/maps 0.2.0-alpha.22 → 0.2.0-alpha.24

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

@@ -1,6 +1,5 @@
 package com.luggmaps.core
 
-import android.animation.TimeInterpolator
 import android.animation.ValueAnimator
 import android.graphics.Color
 import android.location.Location
@@ -14,6 +13,10 @@ import kotlin.math.floor
 import kotlin.math.min
 
 class PolylineAnimator {
+  companion object {
+    private const val MAX_ANIMATION_SPANS = 16
+  }
+
   var polyline: Polyline? = null
   var coordinates: List<LatLng> = emptyList()
     set(value) {
@@ -59,17 +62,12 @@ class PolylineAnimator {
     startAnimation()
   }
 
-  private fun getInterpolator(): TimeInterpolator =
+  private fun applyEasing(t: Float): Float =
     when (animatedOptions.easing) {
-      "easeIn" -> TimeInterpolator { t -> t * t }
-
-      "easeOut" -> TimeInterpolator { t -> t * (2 - t) }
-
-      "easeInOut" -> TimeInterpolator { t ->
-        if (t < 0.5f) 2 * t * t else -1 + (4 - 2 * t) * t
-      }
-
-      else -> LinearInterpolator()
+      "easeIn" -> t * t
+      "easeOut" -> t * (2 - t)
+      "easeInOut" -> if (t < 0.5f) 2 * t * t else -1 + (4 - 2 * t) * t
+      else -> t
     }
 
   fun update() {
@@ -93,13 +91,13 @@ class PolylineAnimator {
     computeCumulativeDistances()
 
     val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
-    val endValue = if (trailLength < 1f) 1f else 2.15f
+    val maxProgress = if (trailLength < 1f) 1f else 2.15f
 
-    animator = ValueAnimator.ofFloat(0f, endValue).apply {
-      duration = animatedOptions.duration
+    animator = ValueAnimator.ofFloat(0f, maxProgress).apply {
+      duration = (animatedOptions.duration * maxProgress).toLong()
       startDelay = animatedOptions.delay
       repeatCount = ValueAnimator.INFINITE
-      interpolator = getInterpolator()
+      interpolator = LinearInterpolator()
       addUpdateListener { animation ->
         animationProgress = animation.animatedValue as Float
         updateAnimatedPolyline()
@@ -191,7 +189,9 @@ class PolylineAnimator {
     }
 
     val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
-    val progress = min(animationProgress, if (trailLength < 1f) 1f else 2f)
+    val maxProgress = if (trailLength < 1f) 1f else 2f
+    val rawProgress = min(animationProgress, maxProgress)
+    val progress = applyEasing(rawProgress / maxProgress) * maxProgress
 
     val headDist: Float
     val tailDist: Float
@@ -209,8 +209,8 @@ class PolylineAnimator {
     }
 
     if (headDist <= tailDist) {
-      poly.setSpans(emptyList())
       poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
       return
     }
 
@@ -219,7 +219,6 @@ class PolylineAnimator {
     val endIndex = indexForDistance(headDist)
 
     reusablePoints.clear()
-    reusableSpans.clear()
 
     reusablePoints.add(coordinateAtDistance(tailDist))
 
@@ -233,16 +232,23 @@ class PolylineAnimator {
       reusablePoints.add(endCoord)
     }
 
-    val pointCount = reusablePoints.size
-    for (i in 0 until (pointCount - 1)) {
-      val segMidDist = tailDist + visibleLength * (i + 0.5f) / (pointCount - 1)
-      val gradientPos = (segMidDist - tailDist) / visibleLength
-      val color = colorAtGradientPosition(gradientPos)
-      reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
-    }
+    if (reusablePoints.size < 2) return
 
     poly.points = reusablePoints
-    if (reusableSpans.isNotEmpty()) {
+
+    if (strokeColors.size <= 1) {
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+    } else {
+      val segmentCount = reusablePoints.size - 1
+      val spanCount = min(segmentCount, MAX_ANIMATION_SPANS)
+      val segmentsPerSpan = segmentCount.toDouble() / spanCount
+
+      reusableSpans.clear()
+      for (i in 0 until spanCount) {
+        val gradientPos = (i + 0.5f) / spanCount
+        val color = colorAtGradientPosition(gradientPos)
+        reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan))
+      }
       poly.setSpans(reusableSpans)
     }
   }

package/ios/LuggMapView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface LuggMapView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggMapView.mm

@@ -0,0 +1,285 @@
+#import "LuggMapView.h"
+#import "LuggMapWrapperView.h"
+#import "LuggMarkerView.h"
+#import "LuggPolylineView.h"
+#import "core/AppleMapProvider.h"
+#import "core/GoogleMapProvider.h"
+#import "core/MapProviderDelegate.h"
+#import "events/CameraIdleEvent.h"
+#import "events/CameraMoveEvent.h"
+#import "events/ReadyEvent.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 LuggMapView () <RCTLuggMapViewViewProtocol, MapProviderDelegate>
+@end
+
+@implementation LuggMapView {
+  id<MapProvider> _provider;
+  LuggMapWrapperView *_mapWrapperView;
+  LuggMapViewProvider _providerType;
+  NSString *_mapId;
+  BOOL _initialized;
+  // Cached props to apply after content creation
+  BOOL _zoomEnabled;
+  BOOL _scrollEnabled;
+  BOOL _rotateEnabled;
+  BOOL _pitchEnabled;
+  BOOL _userLocationEnabled;
+  NSString *_theme;
+  double _minZoom;
+  double _maxZoom;
+  UIEdgeInsets _padding;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<LuggMapViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const LuggMapViewProps>();
+    _props = defaultProps;
+
+    _initialized = NO;
+    _mapId = @"";
+    _providerType = LuggMapViewProvider::Google;
+    _zoomEnabled = YES;
+    _scrollEnabled = YES;
+    _rotateEnabled = YES;
+    _pitchEnabled = YES;
+    _userLocationEnabled = NO;
+    _theme = @"system";
+    _padding = UIEdgeInsetsZero;
+  }
+  return self;
+}
+
+#pragma mark - View Lifecycle
+
+- (void)mountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  [super mountChildComponentView:childComponentView index:index];
+
+  if ([childComponentView isKindOfClass:[LuggMapWrapperView class]]) {
+    _mapWrapperView = (LuggMapWrapperView *)childComponentView;
+  } else if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
+    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
+    if (_provider) {
+      [_provider addMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider addPolylineView:polylineView];
+    }
+  }
+}
+
+- (void)unmountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
+    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
+    if (_provider) {
+      [_provider removeMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider removePolylineView:polylineView];
+    }
+  }
+
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  if (self.window) {
+    if (!_provider && _mapWrapperView) {
+      [self initializeProvider];
+    }
+    [_provider resumeAnimations];
+  } else {
+    [_provider pauseAnimations];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_provider destroy];
+  _provider = nil;
+  _mapWrapperView = nil;
+  _initialized = NO;
+}
+
+#pragma mark - Provider Initialization
+
+- (void)initializeProvider {
+  if (_provider || !_mapWrapperView)
+    return;
+
+  const auto &viewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+
+  if (_providerType == LuggMapViewProvider::Apple) {
+    _provider = [[AppleMapProvider alloc] init];
+  } else {
+    GoogleMapProvider *google = [[GoogleMapProvider alloc] init];
+    google.mapId = _mapId;
+    _provider = google;
+  }
+
+  _provider.delegate = self;
+
+  // Apply cached props before initialization
+  [self applyProps];
+
+  CLLocationCoordinate2D coordinate =
+      CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
+                                 viewProps.initialCoordinate.longitude);
+
+  [_provider initializeMapInView:_mapWrapperView
+               initialCoordinate:coordinate
+                     initialZoom:viewProps.initialZoom];
+
+  [_provider setPadding:_padding oldPadding:UIEdgeInsetsZero];
+
+  _initialized = YES;
+
+  // Flush any children that were mounted before content was created
+  for (UIView *subview in self.subviews) {
+    if ([subview isKindOfClass:[LuggMarkerView class]]) {
+      [_provider addMarkerView:(LuggMarkerView *)subview];
+    } else if ([subview isKindOfClass:[LuggPolylineView class]]) {
+      [_provider addPolylineView:(LuggPolylineView *)subview];
+    }
+  }
+}
+
+#pragma mark - MapProviderDelegate
+
+- (void)mapProviderDidReady {
+  ReadyEvent::emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraMoveEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraIdleEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+#pragma mark - Property Setters
+
+- (void)applyProps {
+  [_provider setZoomEnabled:_zoomEnabled];
+  [_provider setScrollEnabled:_scrollEnabled];
+  [_provider setRotateEnabled:_rotateEnabled];
+  [_provider setPitchEnabled:_pitchEnabled];
+  [_provider setUserLocationEnabled:_userLocationEnabled];
+  [_provider setTheme:_theme];
+  [_provider setMinZoom:_minZoom];
+  [_provider setMaxZoom:_maxZoom];
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(oldProps);
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(props);
+
+  _providerType = newViewProps.provider;
+
+  NSString *newMapId =
+      [NSString stringWithUTF8String:newViewProps.mapId.c_str()];
+  if (newMapId.length > 0) {
+    _mapId = newMapId;
+  }
+
+  // Cache props
+  _zoomEnabled = newViewProps.zoomEnabled;
+  _scrollEnabled = newViewProps.scrollEnabled;
+  _rotateEnabled = newViewProps.rotateEnabled;
+  _pitchEnabled = newViewProps.pitchEnabled;
+  _userLocationEnabled = newViewProps.userLocationEnabled;
+  _minZoom = newViewProps.minZoom;
+  _maxZoom = newViewProps.maxZoom;
+
+  if (newViewProps.theme == LuggMapViewTheme::Dark) {
+    _theme = @"dark";
+  } else if (newViewProps.theme == LuggMapViewTheme::Light) {
+    _theme = @"light";
+  } else {
+    _theme = @"system";
+  }
+
+  UIEdgeInsets oldPadding = _padding;
+  _padding =
+      UIEdgeInsetsMake(newViewProps.padding.top, newViewProps.padding.left,
+                       newViewProps.padding.bottom, newViewProps.padding.right);
+
+  if (_provider) {
+    [self applyProps];
+    [_provider setPadding:_padding oldPadding:oldPadding];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - Commands
+
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration {
+  [_provider moveCamera:latitude
+              longitude:longitude
+                   zoom:zoom
+               duration:duration];
+}
+
+- (void)fitCoordinates:(NSArray *)coordinates
+            paddingTop:(double)paddingTop
+           paddingLeft:(double)paddingLeft
+         paddingBottom:(double)paddingBottom
+          paddingRight:(double)paddingRight
+              duration:(double)duration {
+  [_provider fitCoordinates:coordinates
+                 paddingTop:paddingTop
+                paddingLeft:paddingLeft
+              paddingBottom:paddingBottom
+               paddingRight:paddingRight
+                   duration:duration];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTLuggMapViewHandleCommand(self, commandName, args);
+}
+
+Class<RCTComponentViewProtocol> LuggMapViewCls(void) {
+  return LuggMapView.class;
+}
+
+@end

package/ios/core/AppleMapProvider.h

@@ -0,0 +1,15 @@
+#import "MapProviderDelegate.h"
+#import <MapKit/MapKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface LuggAppleMapViewContent : MKMapView
+@end
+
+@interface AppleMapProvider : NSObject <MapProvider, MKMapViewDelegate>
+
+@property(nonatomic, readonly, nullable) MKMapView *mapView;
+
+@end
+
+NS_ASSUME_NONNULL_END