@mapvina-com/mapvina-react-native 1.0.0

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[@"center"]) {
+    stop.center = [MLRNUtils fromLongitude:args[@"center"][0] latitude:args[@"center"][1]];
+  }
+
+  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/components/camera/CameraUpdateItem.h

@@ -0,0 +1,11 @@
+#import "CameraStop.h"
+#import "MLRNMapView.h"
+
+@interface CameraUpdateItem : NSObject
+
+@property (nonatomic, strong) CameraStop* _Nonnull cameraStop;
+
+- (void)execute:(MLRNMapView* _Nonnull)mapView
+    withCompletionHandler:(nullable void (^)(void))completionHandler;
+
+@end

package/ios/components/camera/CameraUpdateItem.m

@@ -0,0 +1,167 @@
+#import "CameraUpdateItem.h"
+#import "CameraEasing.h"
+
+@interface MLRNCameraWithPadding : MLNMapCamera
+
+@property (nonatomic) MLNMapCamera *_Nonnull camera;
+@property (nonatomic) UIEdgeInsets boundsPadding;
+
+@end
+
+@implementation MLRNCameraWithPadding
+
+@end
+
+@implementation CameraUpdateItem
+
+- (void)execute:(MLRNMapView *)mapView withCompletionHandler:(void (^)(void))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;
+  }
+}
+
+- (void)_flyToCamera:(MLRNMapView *)mapView
+    withCompletionHandler:(void (^)(void))completionHandler {
+  MLRNCameraWithPadding *nextCamera = [self _makeCamera:mapView];
+
+  [mapView flyToCamera:nextCamera.camera
+            edgePadding:nextCamera.boundsPadding
+           withDuration:_cameraStop.duration
+      completionHandler:completionHandler];
+}
+
+- (void)_moveCamera:(MLRNMapView *)mapView
+                 animated:(BOOL)animated
+                     ease:(BOOL)ease
+    withCompletionHandler:(void (^)(void))completionHandler {
+  MLRNCameraWithPadding *nextCamera = [self _makeCamera:mapView];
+  NSString *easeFunctionName =
+      ease ? kCAMediaTimingFunctionEaseInEaseOut : kCAMediaTimingFunctionLinear;
+
+  [mapView setCamera:nextCamera.camera
+                 withDuration:animated ? _cameraStop.duration : 0
+      animationTimingFunction:[CAMediaTimingFunction functionWithName:easeFunctionName]
+                  edgePadding:nextCamera.boundsPadding
+            completionHandler:completionHandler];
+}
+
+- (MLRNCameraWithPadding *)_makeCamera:(MLRNMapView *)mapView {
+  MLNMapCamera *nextCamera = [mapView.camera copy];
+
+  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;
+    padding.bottom = 1.0;
+  }
+
+  bool hasSetAltitude = false;
+
+  if ([self _isCenterValid:_cameraStop.center]) {
+    MLNCoordinateBounds boundsFromCoord = {.sw = _cameraStop.center, .ne = _cameraStop.center};
+    MLNMapCamera *boundsCamera = [mapView camera:nextCamera
+                         fittingCoordinateBounds:boundsFromCoord
+                                     edgePadding:padding];
+    nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+  } else if ([self _areBoundsValid:_cameraStop.bounds]) {
+    MLNMapCamera *boundsCamera = [mapView camera:nextCamera
+                         fittingCoordinateBounds:_cameraStop.bounds
+                                     edgePadding:padding];
+    nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+    nextCamera.altitude = boundsCamera.altitude;
+    hasSetAltitude = true;
+  }
+
+  if (_cameraStop.bearing != nil) {
+    nextCamera.heading = [_cameraStop.bearing floatValue];
+  }
+
+  if (_cameraStop.zoom != nil && hasSetAltitude == false) {
+    nextCamera.altitude = [mapView altitudeFromZoom:[_cameraStop.zoom doubleValue]
+                                         atLatitude:nextCamera.centerCoordinate.latitude
+                                            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;
+
+  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 - height + 1.0;
+    result.top -= (padding.top * extra) / totalPadding;
+    result.bottom -= (padding.bottom * extra) / totalPadding;
+  }
+
+  if ((padding.left + padding.right) >= width) {
+    double totalPadding = padding.left + padding.right;
+    double extra = totalPadding - width + 1.0;
+    result.left -= (padding.left * extra) / totalPadding;
+    result.right -= (padding.right * extra) / totalPadding;
+  }
+
+  return result;
+}
+
+- (BOOL)_areBoundsValid:(MLNCoordinateBounds)bounds {
+  if ([self _isLatitudeValid:bounds.ne.latitude] && [self _isLatitudeValid:bounds.sw.latitude]) {
+    return YES;
+  }
+
+  return NO;
+}
+
+- (BOOL)_isLatitudeValid:(CLLocationDegrees)latitude {
+  return latitude >= -90 && latitude <= 90;
+}
+
+- (BOOL)_isCenterValid:(CLLocationCoordinate2D)coord {
+  BOOL isValid = CLLocationCoordinate2DIsValid(coord);
+
+  if (!isValid) {
+    return NO;
+  }
+
+  return YES;
+}
+
+- (BOOL)_hasCenterAndZoom {
+  BOOL isValid = CLLocationCoordinate2DIsValid(_cameraStop.center) && _cameraStop.zoom != nil;
+
+  if (!isValid) {
+    return NO;
+  }
+
+  return [self _isCenterValid:_cameraStop.center];
+}
+
+@end

package/ios/components/camera/CameraUpdateQueue.h

@@ -0,0 +1,13 @@
+#import "CameraStop.h"
+#import "CameraUpdateItem.h"
+#import "MLRNMapView.h"
+
+@interface CameraUpdateQueue : NSObject
+
+- (void)enqueue:(CameraStop* _Nonnull)cameraUpdateItem;
+- (CameraStop* _Nonnull)dequeue;
+- (void)flush;
+- (BOOL)isEmpty;
+- (void)execute:(MLRNMapView* _Nonnull)mapView;
+
+@end

package/ios/components/camera/CameraUpdateQueue.m

@@ -0,0 +1,62 @@
+#import "CameraUpdateQueue.h"
+
+@implementation CameraUpdateQueue {
+  NSMutableArray<CameraStop *> *queue;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    queue = [[NSMutableArray alloc] init];
+  }
+
+  return self;
+}
+
+- (void)enqueue:(CameraStop *)cameraUpdateItem {
+  [queue addObject:cameraUpdateItem];
+}
+
+- (CameraStop *)dequeue {
+  if ([self isEmpty]) {
+    return nil;
+  }
+  CameraStop *stop = queue.firstObject;
+  [queue removeObjectAtIndex:0];
+  return stop;
+}
+
+- (void)flush {
+  [queue removeAllObjects];
+}
+
+- (BOOL)isEmpty {
+  return queue.count == 0;
+}
+
+- (void)execute:(MLRNMapView *)mapView {
+  if (mapView == nil) {
+    return;
+  }
+
+  if ([self isEmpty]) {
+    return;
+  }
+
+  CameraStop *stop = [self dequeue];
+  if (stop == nil) {
+    return;
+  }
+
+  CameraUpdateItem *item = [[CameraUpdateItem alloc] init];
+  item.cameraStop = stop;
+
+  __weak CameraUpdateQueue *weakSelf = self;
+  __weak MLRNMapView *weakMap = mapView;
+
+  [item execute:mapView
+      withCompletionHandler:^{
+        [weakSelf execute:weakMap];
+      }];
+}
+
+@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,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNCameraComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END