@maplibre/maplibre-react-native 10.4.0 → 11.0.0-alpha.10

package/ios/components/camera/MLRNCameraComponentView.mm

@@ -0,0 +1,192 @@
+#import "MLRNCameraComponentView.h"
+
+#import <react/renderer/components/MapLibreReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/Props.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <React/RCTConversions.h>
+#import "MLRNCamera.h"
+
+using namespace facebook::react;
+
+// MARK: - MLRNCameraComponentView
+
+@interface MLRNCameraComponentView () <RCTMLRNCameraViewProtocol>
+
+@end
+
+@implementation MLRNCameraComponentView {
+  MLRNCamera *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNCameraProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNCamera alloc] init];
+
+  // Capture weak self reference to prevent retain cycle
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setOnTrackUserLocationChange:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      facebook::react::MLRNCameraEventEmitter::OnTrackUserLocationChange eventStruct{
+          [event[@"trackUserLocation"] UTF8String],
+      };
+      std::dynamic_pointer_cast<const facebook::react::MLRNCameraEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onTrackUserLocationChange(eventStruct);
+    }
+  }];
+
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNCameraProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNCameraProps const>(props);
+
+  if (oldViewProps.minZoom != newViewProps.minZoom) {
+    [_view setMinZoom:@(newViewProps.minZoom)];
+  }
+
+  if (oldViewProps.maxZoom != newViewProps.maxZoom) {
+    [_view setMaxZoom:@(newViewProps.maxZoom)];
+  }
+
+  if (oldViewProps.maxBounds != newViewProps.maxBounds) {
+    if (newViewProps.maxBounds.size() == 4) {
+      NSMutableArray<NSNumber *> *maxBoundsArray =
+          [NSMutableArray arrayWithCapacity:newViewProps.maxBounds.size()];
+      for (double value : newViewProps.maxBounds) {
+        [maxBoundsArray addObject:@(value)];
+      }
+
+      [_view setMaxBounds:maxBoundsArray];
+    } else {
+      [_view setMaxBounds:nil];
+    }
+  }
+
+  if (_view.initialViewState == nil) {
+    NSMutableDictionary *initialViewState = [NSMutableDictionary dictionary];
+
+    if (newViewProps.initialViewState.longitude != -360 &&
+        newViewProps.initialViewState.latitude != -360) {
+      initialViewState[@"longitude"] = @(newViewProps.initialViewState.longitude);
+      initialViewState[@"latitude"] = @(newViewProps.initialViewState.latitude);
+    } else if (newViewProps.initialViewState.bounds.size() == 4) {
+      initialViewState[@"bounds"] = @[
+        @(newViewProps.initialViewState.bounds[0]), @(newViewProps.initialViewState.bounds[1]),
+        @(newViewProps.initialViewState.bounds[2]), @(newViewProps.initialViewState.bounds[3])
+      ];
+    }
+
+    initialViewState[@"padding"] = @{
+      @"top" : @(newViewProps.initialViewState.padding.top),
+      @"right" : @(newViewProps.initialViewState.padding.right),
+      @"bottom" : @(newViewProps.initialViewState.padding.bottom),
+      @"left" : @(newViewProps.initialViewState.padding.left)
+    };
+
+    if (newViewProps.initialViewState.zoom != -1) {
+      initialViewState[@"zoom"] = @(newViewProps.initialViewState.zoom);
+    }
+    if (newViewProps.initialViewState.bearing != -1) {
+      initialViewState[@"bearing"] = @(newViewProps.initialViewState.bearing);
+    }
+    if (newViewProps.initialViewState.pitch != -1) {
+      initialViewState[@"pitch"] = @(newViewProps.initialViewState.pitch);
+    }
+
+    [_view setInitialViewState:initialViewState];
+  }
+
+  BOOL updateCamera = NO;
+
+  if (oldViewProps.stop.longitude != newViewProps.stop.longitude ||
+      oldViewProps.stop.latitude != newViewProps.stop.latitude ||
+
+      oldViewProps.stop.bounds != newViewProps.stop.bounds ||
+      oldViewProps.stop.padding.top != newViewProps.stop.padding.top ||
+      oldViewProps.stop.padding.right != newViewProps.stop.padding.right ||
+      oldViewProps.stop.padding.bottom != newViewProps.stop.padding.bottom ||
+      oldViewProps.stop.padding.left != newViewProps.stop.padding.left ||
+
+      oldViewProps.stop.zoom != newViewProps.stop.zoom ||
+      oldViewProps.stop.bearing != newViewProps.stop.bearing ||
+      oldViewProps.stop.pitch != newViewProps.stop.pitch ||
+
+      oldViewProps.stop.duration != newViewProps.stop.duration ||
+      oldViewProps.stop.easing != newViewProps.stop.easing) {
+    NSMutableDictionary *stop = [NSMutableDictionary dictionary];
+
+    if (newViewProps.stop.longitude != -360 && newViewProps.stop.latitude != -360) {
+      stop[@"longitude"] = @(newViewProps.stop.longitude);
+      stop[@"latitude"] = @(newViewProps.stop.latitude);
+    } else if (newViewProps.stop.bounds.size() == 4) {
+      stop[@"bounds"] = @[
+        @(newViewProps.stop.bounds[0]), @(newViewProps.stop.bounds[1]),
+        @(newViewProps.stop.bounds[2]), @(newViewProps.stop.bounds[3])
+      ];
+    }
+
+    stop[@"padding"] = @{
+      @"top" : @(newViewProps.stop.padding.top),
+      @"right" : @(newViewProps.stop.padding.right),
+      @"bottom" : @(newViewProps.stop.padding.bottom),
+      @"left" : @(newViewProps.stop.padding.left)
+    };
+
+    if (newViewProps.stop.zoom != -1) {
+      stop[@"zoom"] = @(newViewProps.stop.zoom);
+    }
+    if (newViewProps.stop.bearing != -1) {
+      stop[@"bearing"] = @(newViewProps.stop.bearing);
+    }
+    if (newViewProps.stop.pitch != -1) {
+      stop[@"pitch"] = @(newViewProps.stop.pitch);
+    }
+
+    if (newViewProps.stop.duration != -1) {
+      stop[@"duration"] = @(newViewProps.stop.duration);
+    }
+    stop[@"easing"] = @((NSInteger)newViewProps.stop.easing);
+
+    [_view setStop:stop];
+    updateCamera = YES;
+  }
+
+  if (oldViewProps.trackUserLocation != newViewProps.trackUserLocation) {
+    [_view setTrackUserLocation:[NSString stringWithUTF8String:facebook::react::toString(
+                                                                   newViewProps.trackUserLocation)
+                                                                   .c_str()]];
+    updateCamera = YES;
+  }
+
+  if (updateCamera) {
+    [_view updateCamera];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNCameraComponentDescriptor>();
+}
+
+@end

package/ios/components/camera/MLRNCameraManager.h

@@ -0,0 +1,11 @@
+#import "MLRNCamera.h"
+#import "ViewManager.h"
+
+@interface MLRNCameraManager : ViewManager
+
++ (void)handleImperativeStop:(MLRNCamera *)view
+                        stop:(NSDictionary<NSString *, id> *)stop
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject;
+
+@end

package/ios/components/camera/MLRNCameraManager.m

@@ -0,0 +1,20 @@
+#import "MLRNCameraManager.h"
+#import "MLRNCamera.h"
+
+@implementation MLRNCameraManager
+
+- (UIView *)view {
+  return [[MLRNCamera alloc] init];
+}
+
+// MARK: - React View Methods
+
++ (void)handleImperativeStop:(MLRNCamera *)view
+                        stop:(NSDictionary<NSString *, id> *)stop
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  [view handleImperativeStop:stop];
+  resolve(nil);
+}
+
+@end

package/ios/components/camera/MLRNCameraModule.h

@@ -0,0 +1,4 @@
+#import <MapLibreReactNativeSpec/MapLibreReactNativeSpec.h>
+
+@interface MLRNCameraModule : NSObject <NativeCameraModuleSpec>
+@end

package/ios/components/camera/MLRNCameraModule.mm

@@ -0,0 +1,111 @@
+#import "MLRNCameraModule.h"
+
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+#import "MLRNCameraComponentView.h"
+#import "MLRNCameraManager.h"
+
+@implementation MLRNCameraModule
+
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
++ (NSString *)moduleName {
+  return @"MLRNCameraModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeCameraModuleSpecJSI>(params);
+}
+
+- (void)withCamera:(NSInteger)reactTag
+             block:(void (^)(MLRNCamera *))block
+            reject:(RCTPromiseRejectBlock)reject
+        methodName:(NSString *)methodName {
+  [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+    UIView *view =
+        [self.viewRegistry_DEPRECATED viewForReactTag:[NSNumber numberWithInteger:reactTag]];
+
+    if ([view isKindOfClass:[MLRNCameraComponentView class]]) {
+      MLRNCameraComponentView *componentView = (MLRNCameraComponentView *)view;
+
+      if ([componentView.contentView isKindOfClass:[MLRNCamera class]]) {
+        MLRNCamera *camera = (MLRNCamera *)componentView.contentView;
+
+        block(camera);
+        return;
+      }
+    }
+
+    reject(methodName,
+           [NSString stringWithFormat:@"Invalid `reactTag` %@, could not find MLRNCamera",
+                                      [NSNumber numberWithInteger:reactTag]],
+           nil);
+  }];
+}
+
+- (void)setStop:(NSInteger)reactTag
+           stop:(JS::NativeCameraModule::NativeCameraStop &)stop
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary<NSString *, id> *stopDict = [NSMutableDictionary dictionary];
+
+  if (stop.longitude().has_value() && stop.latitude().has_value()) {
+    stopDict[@"longitude"] = @(stop.longitude().value());
+    stopDict[@"latitude"] = @(stop.latitude().value());
+  } else if (stop.bounds().has_value() && stop.bounds().value().size() == 4) {
+    NSArray<NSNumber *> *bounds = @[
+      @(stop.bounds().value()[0]), @(stop.bounds().value()[1]), @(stop.bounds().value()[2]),
+      @(stop.bounds().value()[3])
+    ];
+    stopDict[@"bounds"] = bounds;
+  }
+
+  if (stop.padding().has_value()) {
+    auto padding = stop.padding().value();
+    stopDict[@"padding"] = @{
+      @"top" : padding.top().has_value() ? @(padding.top().value()) : @0,
+      @"right" : padding.right().has_value() ? @(padding.right().value()) : @0,
+      @"bottom" : padding.bottom().has_value() ? @(padding.bottom().value()) : @0,
+      @"left" : padding.left().has_value() ? @(padding.left().value()) : @0
+    };
+  }
+  if (stop.zoom().has_value()) {
+    stopDict[@"zoom"] = @(stop.zoom().value());
+  }
+  if (stop.bearing().has_value()) {
+    stopDict[@"bearing"] = @(stop.bearing().value());
+  }
+  if (stop.pitch().has_value()) {
+    stopDict[@"pitch"] = @(stop.pitch().value());
+  }
+
+  if (stop.duration().has_value()) {
+    stopDict[@"duration"] = @(stop.duration().value());
+  }
+  if (stop.easing()) {
+    NSString *easing = stop.easing();
+
+    if ([easing isEqualToString:@"none"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingLinear);
+    } else if ([easing isEqualToString:@"linear"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingLinear);
+    } else if ([easing isEqualToString:@"ease"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingEase);
+    } else if ([easing isEqualToString:@"fly"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingFly);
+    }
+  }
+
+  [self withCamera:reactTag
+             block:^(MLRNCamera *view) {
+               [MLRNCameraManager handleImperativeStop:view
+                                                  stop:[stopDict copy]
+                                               resolve:resolve
+                                                reject:reject];
+             }
+            reject:reject
+        methodName:@"setStop"];
+}
+
+@end

package/ios/components/images/MLRNImages.h

@@ -0,0 +1,24 @@
+#import <React/RCTBridge.h>
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+
+#import <MapLibre/MapLibre.h>
+
+@class MLRNMapView;
+
+@interface MLRNImages : UIView
+
+@property (nonatomic, weak) RCTBridge *bridge;
+
+@property (nonatomic, strong) MLRNMapView *map;
+
+@property (nonatomic, strong) NSDictionary<NSString *, NSString *> *images;
+@property (nonatomic, strong) NSArray<NSString *> *nativeImages;
+
+@property (nonatomic, copy) RCTBubblingEventBlock onImageMissing;
+@property (nonatomic, assign) BOOL hasOnImageMissing;
+
+- (BOOL)addMissingImageToStyle:(NSString *)imageName;
+- (void)sendImageMissingEvent:(NSString *)imageName;
+
+@end

package/ios/components/images/MLRNImages.m

@@ -0,0 +1,124 @@
+#import "MLRNImages.h"
+#import <React/UIView+React.h>
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNMapView.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNImages : UIView
+
+static UIImage *_placeHolderImage;
+
+- (void)addToMap {
+  if (self.map.style == nil) {
+    return;
+  }
+  [self _addNativeImages:_nativeImages];
+  [self _addRemoteImages:_images];
+}
+
+- (void)removeFromMap {
+  if (self.map.style == nil) {
+    return;
+  }
+
+  [self _removeImages];
+}
+
+- (void)_removeImages {
+  if ([self _hasImages]) {
+    NSArray<NSString *> *imageNames = _images.allKeys;
+
+    for (NSString *imageName in imageNames) {
+      [self.map.style removeImageForName:imageName];
+    }
+  }
+
+  if ([self _hasNativeImages]) {
+    for (NSString *imageName in _nativeImages) {
+      [self.map.style removeImageForName:imageName];
+    }
+  }
+}
+
+- (BOOL)addMissingImageToStyle:(NSString *)imageName {
+  if (_nativeImages && [_nativeImages containsObject:imageName]) {
+    [self _addNativeImages:@[ imageName ]];
+    return true;
+  }
+
+  NSString *remoteImage = _images != nil ? [_images objectForKey:imageName] : nil;
+  if (remoteImage) {
+    [self _addRemoteImages:@{imageName : remoteImage}];
+    return true;
+  }
+  return false;
+}
+
+- (void)sendImageMissingEvent:(NSString *)imageName {
+  NSDictionary *payload = @{@"imageKey" : imageName};
+  MLRNEvent *event = [MLRNEvent makeEvent:RCT_MLRN_MISSING_IMAGE withPayload:payload];
+  if (_onImageMissing) {
+    _onImageMissing([event toJSON]);
+  }
+}
+
+- (void)_addNativeImages:(NSArray<NSString *> *)nativeImages {
+  if (!nativeImages) return;
+
+  for (NSString *imageName in nativeImages) {
+    // only add native images if they are not in the style yet (similar to [MLRNUtils fetchImages:
+    // style:])
+    if (![self.map.style imageForName:imageName]) {
+      UIImage *image = [UIImage imageNamed:imageName];
+      [self.map.style setImage:image forName:imageName];
+    }
+  }
+}
+
+- (void)_addRemoteImages:(NSDictionary<NSString *, NSString *> *)remoteImages {
+  if (!remoteImages) return;
+  NSDictionary<NSString *, NSString *> *missingImages = [NSMutableDictionary new];
+
+  // Add image placeholder for images that are not yet available in the style. This way
+  // we can load the images asynchronously and add the ShapeSource to the map without delay.
+  // The same is required when this ShapeSource is updated with new/added images and the
+  // data references them. In which case addMissingImageToStyle will take care of loading
+  // them in a similar way.
+  //
+  // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+  for (NSString *imageName in remoteImages.allKeys) {
+    if (![self.map.style imageForName:imageName]) {
+      [self.map.style setImage:[MLRNImages placeholderImage] forName:imageName];
+      [missingImages setValue:_images[imageName] forKey:imageName];
+    }
+  }
+
+  if (missingImages.count > 0) {
+    // forceUpdate to ensure the placeholder images are updated
+    [MLRNUtils fetchImages:_bridge
+                     style:self.map.style
+                   objects:_images
+               forceUpdate:true
+                  callback:^{
+                  }];
+  }
+}
+
+- (BOOL)_hasImages {
+  return _images != nil && _images.count > 0;
+}
+
+- (BOOL)_hasNativeImages {
+  return _nativeImages != nil && _nativeImages.count > 0;
+}
+
++ (UIImage *)placeholderImage {
+  if (_placeHolderImage) return _placeHolderImage;
+  UIGraphicsBeginImageContextWithOptions(CGSizeMake(1, 1), NO, 0.0);
+  _placeHolderImage = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+  return _placeHolderImage;
+}
+
+@end

package/ios/components/layers/MLRNLayer.h

@@ -0,0 +1,42 @@
+#import <React/RCTBridge.h>
+#import <UIKit/UIKit.h>
+
+@class MLRNMapView;
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNLayer<T> : UIView
+
+@property (nonatomic, weak, nullable) RCTBridge *bridge;
+
+@property (nonatomic, strong, nullable) MLNStyleLayer *styleLayer;
+@property (nonatomic, strong, nullable) MLNStyle *style;
+@property (nonatomic, weak, nullable) MLRNMapView *map;
+@property (nonatomic, strong, nullable) NSDictionary *reactStyle;
+@property (nonatomic, strong, nullable) NSArray *filter;
+
+@property (nonatomic, copy, nullable) NSString *id;
+@property (nonatomic, copy, nullable) NSString *sourceID;
+
+@property (nonatomic, copy, nullable) NSString *aboveLayerID;
+@property (nonatomic, copy, nullable) NSString *belowLayerID;
+@property (nonatomic, copy, nullable) NSNumber *layerIndex;
+
+@property (nonatomic, copy, nullable) NSNumber *maxZoomLevel;
+@property (nonatomic, copy, nullable) NSNumber *minZoomLevel;
+
+- (void)addToMap:(nonnull MLRNMapView *)map style:(nonnull MLNStyle *)style;
+- (void)addedToMap;
+- (void)removeFromMap:(nonnull MLNStyle *)style;
+- (nullable T)makeLayer:(nonnull MLNStyle *)style;
+- (void)addStyles;
+- (void)insertAbove:(nonnull NSString *)layer;
+- (void)insertBelow:(nonnull NSString *)layer;
+- (void)insertAtIndex:(NSUInteger)index;
+- (void)setZoomBounds;
+
+- (BOOL)isAddedToMap;
+
+- (nullable MLNSource *)layerWithSourceIDInStyle:(nonnull MLNStyle *)style;
+
+@end