@maplibre/maplibre-react-native 11.0.0-alpha.7 → 11.0.0-alpha.9

package/ios/{CameraStop.h → components/camera/CameraStop.h}

@@ -1,18 +1,22 @@
-@import MapLibre;
+#import <MapLibre/MapLibre.h>
+
+#import "CameraEasing.h"
 #import "MLRNCamera.h"
 
 @interface CameraStop : NSObject
 
-@property (nonatomic, strong) NSNumber *pitch;
-@property (nonatomic, strong) NSNumber *heading;
+@property (nonatomic, assign) CLLocationCoordinate2D center;
+
 @property (nonatomic, strong) NSNumber *zoom;
-@property (nonatomic, strong) NSNumber *mode;
-@property (nonatomic, assign) NSTimeInterval duration;
+@property (nonatomic, strong) NSNumber *bearing;
+@property (nonatomic, strong) NSNumber *pitch;
 
-@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
 @property (nonatomic, assign) MLNCoordinateBounds bounds;
 @property (nonatomic, assign) UIEdgeInsets padding;
 
+@property (nonatomic, assign) NSTimeInterval duration;
+@property (nonatomic, strong) NSNumber *easing;
+
 + (CameraStop *)fromDictionary:(NSDictionary *)args;
 
 @end

package/ios/components/camera/CameraStop.m

@@ -0,0 +1,75 @@
+#import "CameraStop.h"
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+#import "MLRNUtils.h"
+
+@implementation CameraStop
+
+- (void)setEasing:(NSNumber *)easing {
+  NSInteger value = easing ? easing.integerValue : (NSInteger)MLRNCameraEasingNone;
+  switch (value) {
+    case MLRNCameraEasingNone:
+    case MLRNCameraEasingLinear:
+    case MLRNCameraEasingEase:
+    case MLRNCameraEasingFly:
+      _easing = @(value);
+      break;
+    default:
+      _easing = @(MLRNCameraEasingNone);
+      break;
+  }
+}
+
+- (id)init {
+  if (self = [super init]) {
+    self.center = kCLLocationCoordinate2DInvalid;
+    self.bounds =
+        MLNCoordinateBoundsMake(kCLLocationCoordinate2DInvalid, kCLLocationCoordinate2DInvalid);
+  }
+
+  return self;
+}
+
++ (CameraStop *)fromDictionary:(NSDictionary *)args {
+  CameraStop *stop = [[CameraStop alloc] init];
+
+  if (args[@"longitude"] && args[@"latitude"]) {
+    stop.center = [MLRNUtils fromLongitude:args[@"longitude"] latitude:args[@"latitude"]];
+  }
+
+  if (args[@"zoom"]) {
+    stop.zoom = args[@"zoom"];
+  }
+
+  if (args[@"bearing"]) {
+    stop.bearing = args[@"bearing"];
+  }
+
+  if (args[@"pitch"]) {
+    stop.pitch = args[@"pitch"];
+  }
+
+  if (args[@"bounds"]) {
+    stop.bounds = [MLRNUtils fromReactBounds:args[@"bounds"]];
+  }
+
+  NSDictionary *padding = args[@"padding"];
+  stop.padding =
+      padding ? UIEdgeInsetsMake([padding[@"top"] floatValue], [padding[@"left"] floatValue],
+                                 [padding[@"bottom"] floatValue], [padding[@"right"] floatValue])
+              : UIEdgeInsetsZero;
+
+  NSTimeInterval duration = 0;
+  if (args[@"duration"]) {
+    duration = [MLRNUtils fromMS:args[@"duration"]];
+  }
+  stop.duration = duration;
+
+  if (args[@"easing"]) {
+    stop.easing = @([args[@"easing"] integerValue]);
+  }
+
+  return stop;
+}
+
+@end

package/ios/{CameraUpdateItem.m → components/camera/CameraUpdateItem.m}

@@ -1,13 +1,5 @@
 #import "CameraUpdateItem.h"
-#import "CameraMode.h"
-
-@interface MLNMapView (FlyToWithPadding)
-- (void)_flyToCamera:(MLNMapCamera *)camera
-          edgePadding:(UIEdgeInsets)insets
-         withDuration:(NSTimeInterval)duration
-         peakAltitude:(CLLocationDistance)peakAltitude
-    completionHandler:(nullable void (^)(void))completion;
-@end
+#import "CameraEasing.h"
 
 @interface MLRNCameraWithPadding : MLNMapCamera
 
@@ -23,14 +15,22 @@
 @implementation CameraUpdateItem
 
 - (void)execute:(MLRNMapView *)mapView withCompletionHandler:(void (^)(void))completionHandler {
-  if (_cameraStop.mode == [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_FLIGHT]) {
-    [self _flyToCamera:mapView withCompletionHandler:completionHandler];
-  } else if (_cameraStop.mode == [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_EASE]) {
-    [self _moveCamera:mapView animated:YES ease:YES withCompletionHandler:completionHandler];
-  } else if (_cameraStop.mode == [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_LINEAR]) {
-    [self _moveCamera:mapView animated:YES ease:NO withCompletionHandler:completionHandler];
-  } else {
-    [self _moveCamera:mapView animated:NO ease:NO withCompletionHandler:completionHandler];
+  NSInteger easing = [_cameraStop.easing integerValue];
+
+  switch (easing) {
+    case MLRNCameraEasingLinear:
+      [self _moveCamera:mapView animated:YES ease:NO withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingEase:
+      [self _moveCamera:mapView animated:YES ease:YES withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingFly:
+      [self _flyToCamera:mapView withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingNone:
+    default:
+      [self _moveCamera:mapView animated:NO ease:NO withCompletionHandler:completionHandler];
+      break;
   }
 }
 
@@ -38,18 +38,10 @@
     withCompletionHandler:(void (^)(void))completionHandler {
   MLRNCameraWithPadding *nextCamera = [self _makeCamera:mapView];
 
-  if ([mapView respondsToSelector:@selector
-               (_flyToCamera:edgePadding:withDuration:peakAltitude:completionHandler:)]) {
-    [mapView _flyToCamera:nextCamera.camera
-              edgePadding:nextCamera.boundsPadding
-             withDuration:_cameraStop.duration
-             peakAltitude:-1
-        completionHandler:completionHandler];
-  } else {
-    [mapView flyToCamera:nextCamera.camera
-             withDuration:_cameraStop.duration
-        completionHandler:completionHandler];
-  }
+  [mapView flyToCamera:nextCamera.camera
+            edgePadding:nextCamera.boundsPadding
+           withDuration:_cameraStop.duration
+      completionHandler:completionHandler];
 }
 
 - (void)_moveCamera:(MLRNMapView *)mapView
@@ -72,6 +64,7 @@
 
   UIEdgeInsets padding = [self _clippedPadding:_cameraStop.padding forView:mapView];
   if (padding.top <= 0 && padding.bottom <= 0) {
+    // TODO: Report Bug
     // If all padding properties are 0 in the update, and the bounds and centerCoordinate do not
     // change, the padding doesn't change either. This seems to be a bug in the iOS SDK.
     padding.top = 1.0;
@@ -80,9 +73,8 @@
 
   bool hasSetAltitude = false;
 
-  if ([self _isCoordValid:_cameraStop.coordinate]) {
-    MLNCoordinateBounds boundsFromCoord = {.sw = _cameraStop.coordinate,
-                                           .ne = _cameraStop.coordinate};
+  if ([self _isCenterValid:_cameraStop.center]) {
+    MLNCoordinateBounds boundsFromCoord = {.sw = _cameraStop.center, .ne = _cameraStop.center};
     MLNMapCamera *boundsCamera = [mapView camera:nextCamera
                          fittingCoordinateBounds:boundsFromCoord
                                      edgePadding:padding];
@@ -96,12 +88,8 @@
     hasSetAltitude = true;
   }
 
-  if (_cameraStop.pitch != nil) {
-    nextCamera.pitch = [_cameraStop.pitch floatValue];
-  }
-
-  if (_cameraStop.heading != nil) {
-    nextCamera.heading = [_cameraStop.heading floatValue];
+  if (_cameraStop.bearing != nil) {
+    nextCamera.heading = [_cameraStop.bearing floatValue];
   }
 
   if (_cameraStop.zoom != nil && hasSetAltitude == false) {
@@ -110,26 +98,37 @@
                                             atPitch:nextCamera.pitch];
   }
 
+  if (_cameraStop.pitch != nil) {
+    nextCamera.pitch = [_cameraStop.pitch floatValue];
+  }
+
   MLRNCameraWithPadding *cameraWithPadding = [[MLRNCameraWithPadding alloc] init];
   cameraWithPadding.camera = nextCamera;
   cameraWithPadding.boundsPadding = padding;
+
   return cameraWithPadding;
 }
 
 - (UIEdgeInsets)_clippedPadding:(UIEdgeInsets)padding forView:(MLRNMapView *)mapView {
   UIEdgeInsets result = padding;
-  if ((padding.top + padding.bottom) >= mapView.frame.size.height) {
+
+  double width = mapView.frame.size.width;
+  double height = mapView.frame.size.height;
+
+  if ((padding.top + padding.bottom) >= height) {
     double totalPadding = padding.top + padding.bottom;
-    double extra = totalPadding - mapView.frame.size.height + 1.0;
+    double extra = totalPadding - height + 1.0;
     result.top -= (padding.top * extra) / totalPadding;
     result.bottom -= (padding.bottom * extra) / totalPadding;
   }
-  if ((padding.left + padding.right) >= mapView.frame.size.width) {
+
+  if ((padding.left + padding.right) >= width) {
     double totalPadding = padding.left + padding.right;
-    double extra = totalPadding - mapView.frame.size.width + 1.0;
+    double extra = totalPadding - width + 1.0;
     result.left -= (padding.left * extra) / totalPadding;
     result.right -= (padding.right * extra) / totalPadding;
   }
+
   return result;
 }
 
@@ -145,7 +144,7 @@
   return latitude >= -90 && latitude <= 90;
 }
 
-- (BOOL)_isCoordValid:(CLLocationCoordinate2D)coord {
+- (BOOL)_isCenterValid:(CLLocationCoordinate2D)coord {
   BOOL isValid = CLLocationCoordinate2DIsValid(coord);
 
   if (!isValid) {
@@ -155,14 +154,14 @@
   return YES;
 }
 
-- (BOOL)_hasCenterCoordAndZoom {
-  BOOL isValid = CLLocationCoordinate2DIsValid(_cameraStop.coordinate) && _cameraStop.zoom != nil;
+- (BOOL)_hasCenterAndZoom {
+  BOOL isValid = CLLocationCoordinate2DIsValid(_cameraStop.center) && _cameraStop.zoom != nil;
 
   if (!isValid) {
     return NO;
   }
 
-  return [self _isCoordValid:_cameraStop.coordinate];
+  return [self _isCenterValid:_cameraStop.center];
 }
 
 @end

package/ios/components/camera/MLRNCamera.h

@@ -0,0 +1,26 @@
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+#import "MLRNMapView.h"
+
+@class MLRNMapView;
+
+@interface MLRNCamera : UIView <MLRNMapViewCamera>
+
+@property (nonatomic, strong) MLRNMapView *map;
+
+@property (nonatomic, strong) NSDictionary<NSString *, id> *stop;
+
+@property (nonatomic, strong) NSDictionary<NSString *, id> *initialViewState;
+
+@property (nonatomic, copy) NSNumber *minZoom;
+@property (nonatomic, copy) NSNumber *maxZoom;
+@property (nonatomic, copy) NSArray<NSNumber *> *maxBounds;
+
+@property (nonatomic, copy) NSString *trackUserLocation;
+
+@property (nonatomic, copy) RCTDirectEventBlock onTrackUserLocationChange;
+
+- (void)handleImperativeStop:(NSDictionary<NSString *, id> *)stop;
+- (void)updateCamera;
+
+@end

package/ios/components/camera/MLRNCamera.m

@@ -0,0 +1,195 @@
+#import "MLRNCamera.h"
+#import "CameraEasing.h"
+#import "CameraStop.h"
+#import "CameraUpdateQueue.h"
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNLocation.h"
+#import "MLRNLocationManager.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNCamera {
+  CameraUpdateQueue *cameraUpdateQueue;
+  MLRNCamera *followCamera;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    cameraUpdateQueue = [[CameraUpdateQueue alloc] init];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  if (_map) {
+    _map.reactCamera = nil;
+  }
+}
+
+- (void)setMap:(MLRNMapView *)map {
+  if (_map != nil) {
+    _map.reactCamera = nil;
+  }
+  _map = map;
+  _map.reactCamera = self;
+
+  // [self _setInitialCamera];
+  [self _updateMinMaxZoom];
+  [self _updateMaxBounds];
+  // [self updateCamera];
+}
+
+- (void)setStop:(NSDictionary<NSString *, id> *)stop {
+  _stop = stop;
+}
+
+- (void)setMinZoom:(NSNumber *)minZoom {
+  _minZoom = minZoom;
+
+  [self _updateMinMaxZoom];
+}
+
+- (void)setMaxZoom:(NSNumber *)maxZoom {
+  _maxZoom = maxZoom;
+
+  [self _updateMinMaxZoom];
+}
+
+- (void)setMaxBounds:(NSArray<NSNumber *> *)maxBounds {
+  _maxBounds = maxBounds;
+
+  [self _updateMaxBounds];
+}
+
+- (void)setTrackUserLocation:(NSString *)trackUserLocation {
+  _trackUserLocation = trackUserLocation;
+}
+
+- (void)handleImperativeStop:(NSDictionary<NSString *, id> *)stop {
+  if (_map != nil) {
+    [cameraUpdateQueue enqueue:[CameraStop fromDictionary:stop]];
+    [cameraUpdateQueue execute:_map];
+  }
+}
+
+- (void)updateCamera {
+  if (_map != nil) {
+    if ([self _userTrackingMode] == MLNUserTrackingModeNone) {
+      [self _updateCameraFromStop];
+    } else {
+      [self _updateCameraFromTrackUserLocation];
+    }
+  }
+}
+
+- (void)_updateCameraFromStop {
+  if (_map.userTrackingMode != MLNUserTrackingModeNone) {
+    _map.userTrackingMode = MLNUserTrackingModeNone;
+  }
+
+  if (_stop != nil) {
+    [cameraUpdateQueue enqueue:[CameraStop fromDictionary:_stop]];
+    [cameraUpdateQueue execute:_map];
+  }
+}
+
+- (void)_updateCameraFromTrackUserLocation {
+  MLNMapCamera *camera = _map.camera;
+
+  if (_stop != nil) {
+    if (_stop[@"zoom"] != nil) {
+      camera.altitude = [_map altitudeFromZoom:[_stop[@"zoom"] floatValue]];
+    }
+
+    if ([self _userTrackingMode] != MLNUserTrackingModeFollowWithCourse &&
+        [self _userTrackingMode] != MLNUserTrackingModeFollowWithHeading) {
+      if (_stop[@"bearing"] != nil) {
+        camera.heading = [_stop[@"bearing"] floatValue];
+      }
+    }
+
+    if (_stop[@"pitch"] != nil) {
+      camera.pitch = [_stop[@"pitch"] floatValue];
+    }
+  }
+
+  [_map setCamera:camera animated:NO];
+
+  if (_map.userTrackingMode != [self _userTrackingMode]) {
+    _map.userTrackingMode = [self _userTrackingMode];
+  }
+}
+
+- (void)_setInitialCamera {
+  if (!_initialViewState) {
+    return;
+  }
+
+  CameraStop *stop = [CameraStop fromDictionary:_initialViewState];
+  stop.duration = 0;
+  stop.easing = @(MLRNCameraEasingNone);
+  CameraUpdateItem *item = [[CameraUpdateItem alloc] init];
+  item.cameraStop = stop;
+  [item execute:_map
+      withCompletionHandler:^{
+      }];
+}
+
+- (void)_updateMinMaxZoom {
+  if (_map != nil) {
+    if (_maxZoom) {
+      _map.maximumZoomLevel = [_maxZoom doubleValue];
+    }
+    if (_minZoom) {
+      _map.minimumZoomLevel = [_minZoom doubleValue];
+    }
+  }
+}
+
+- (void)_updateMaxBounds {
+  if (_map != nil) {
+    if (_maxBounds) {
+      _map.maxBounds = [MLRNUtils fromReactBounds:_maxBounds];
+    }
+  }
+}
+
+- (MLNUserTrackingMode)_userTrackingMode {
+  if ([_trackUserLocation isEqualToString:@"default"]) {
+    return MLNUserTrackingModeFollow;
+  } else if ([_trackUserLocation isEqualToString:@"heading"]) {
+    return MLNUserTrackingModeFollowWithHeading;
+  } else if ([_trackUserLocation isEqualToString:@"course"]) {
+    return MLNUserTrackingModeFollowWithCourse;
+  } else {
+    return MLNUserTrackingModeNone;
+  }
+}
+
+- (id)_trackingModeToString:(MLNUserTrackingMode)mode {
+  switch (mode) {
+    case MLNUserTrackingModeFollow:
+      return @"default";
+    case MLNUserTrackingModeFollowWithHeading:
+      return @"heading";
+    case MLNUserTrackingModeFollowWithCourse:
+      return @"course";
+    case MLNUserTrackingModeNone:
+      return [NSNull null];
+  }
+}
+
+- (void)initialLayout {
+  [self _setInitialCamera];
+  [self updateCamera];
+}
+
+- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated {
+  NSDictionary *payload = @{
+    @"trackUserLocation" : [self _trackingModeToString:mode],
+  };
+
+  self.onTrackUserLocationChange(payload);
+}
+
+@end

package/ios/components/camera/MLRNCameraComponentView.h

@@ -0,0 +1,18 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+#ifndef MLRNCameraComponentView_h
+#define MLRNCameraComponentView_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNCameraComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif