@mapvina-com/mapvina-react-native 1.0.0

package/ios/components/layer/MLRNLayer.m

@@ -0,0 +1,348 @@
+#import "MLRNLayer.h"
+#import "FilterParser.h"
+#import "MLRNMapView.h"
+#import "MLRNSource.h"
+#import "MLRNStyle.h"
+#import "MLRNStyleValue.h"
+#import "MLRNUtils.h"
+
+#import <React/RCTLog.h>
+
+@implementation MLRNLayer
+
+// MARK: - Property setters with live update support
+
+- (void)setMinZoomLevel:(NSNumber *)minZoomLevel {
+  _minZoomLevel = minZoomLevel;
+
+  if (_styleLayer != nil) {
+    _styleLayer.minimumZoomLevel = [_minZoomLevel doubleValue];
+  }
+}
+
+- (void)setMaxZoomLevel:(NSNumber *)maxZoomLevel {
+  _maxZoomLevel = maxZoomLevel;
+
+  if (_styleLayer != nil) {
+    _styleLayer.maximumZoomLevel = [_maxZoomLevel doubleValue];
+  }
+}
+
+- (void)setAboveLayerID:(NSString *)aboveLayerID {
+  if (_aboveLayerID != nil && _aboveLayerID == aboveLayerID) {
+    return;
+  }
+
+  _aboveLayerID = aboveLayerID;
+  if (_styleLayer != nil) {
+    [self removeFromMap:_style];
+    [self insertAbove:aboveLayerID];
+  }
+}
+
+- (void)setBelowLayerID:(NSString *)belowLayerID {
+  if (_belowLayerID != nil && _belowLayerID == belowLayerID) {
+    return;
+  }
+
+  _belowLayerID = belowLayerID;
+  if (_styleLayer != nil) {
+    [self removeFromMap:_style];
+    [self insertBelow:_belowLayerID];
+  }
+}
+
+- (void)setLayerIndex:(NSNumber *)layerIndex {
+  if (_layerIndex != nil && _layerIndex == layerIndex) {
+    return;
+  }
+
+  _layerIndex = layerIndex;
+  if (_styleLayer != nil) {
+    [self removeFromMap:_style];
+    [self insertAtIndex:_layerIndex.unsignedIntegerValue];
+  }
+}
+
+- (void)setMap:(MLRNMapView *)map {
+  if (map == nil) {
+    [self removeFromMap:_map.style];
+    _map = nil;
+  } else {
+    _map = map;
+    [self addToMap:map style:map.style];
+  }
+}
+
+- (void)setReactStyle:(NSDictionary *)reactStyle {
+  _reactStyle = reactStyle;
+
+  if (_styleLayer != nil) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self addStyles];
+    });
+  }
+}
+
+- (void)setSourceLayerID:(NSString *)sourceLayerID {
+  _sourceLayerID = sourceLayerID;
+
+  if (_styleLayer != nil && [_styleLayer isKindOfClass:[MLNVectorStyleLayer class]]) {
+    ((MLNVectorStyleLayer *)_styleLayer).sourceLayerIdentifier = _sourceLayerID;
+  }
+}
+
+- (void)setFilter:(NSArray *)filter {
+  _filter = filter;
+
+  if (_styleLayer != nil && [_styleLayer isKindOfClass:[MLNVectorStyleLayer class]]) {
+    NSPredicate *predicate = [self buildFilters];
+    [self updateFilter:predicate];
+  }
+}
+
+// MARK: - Filter support
+
+- (NSPredicate *)buildFilters {
+  return _filter ? [FilterParser parse:_filter] : nil;
+}
+
+- (void)updateFilter:(NSPredicate *)predicate {
+  @try {
+    ((MLNVectorStyleLayer *)_styleLayer).predicate = predicate;
+  } @catch (NSException *exception) {
+    RCTLogError(@"Invalid predicate: %@ on layer %@ - %@ reason: %@", predicate, self,
+                exception.name, exception.reason);
+  }
+}
+
+// MARK: - Map lifecycle
+
+- (void)addToMap:(MLRNMapView *)map style:(MLNStyle *)style {
+  if (style == nil) {
+    return;
+  }
+  _map = map;
+  _style = style;
+  if (_id == nil) {
+    RCTLogError(@"Cannot add a layer without id to the map: %@", self);
+    return;
+  }
+  MLNStyleLayer *existingLayer = [style layerWithIdentifier:_id];
+  if (existingLayer != nil) {
+    _styleLayer = existingLayer;
+  } else {
+    _styleLayer = [self makeLayer:style];
+    if (_styleLayer == nil) {
+      RCTLogError(@"Failed to make layer: %@", _id);
+      return;
+    }
+    [self insertLayer:map];
+  }
+
+  [self addStyles];
+  [self addedToMap];
+}
+
+- (nullable MLNSource *)layerWithSourceIDInStyle:(nonnull MLNStyle *)style {
+  MLNSource *result = [style sourceWithIdentifier:self.sourceID];
+  if (result == NULL) {
+    RCTLogError(@"Cannot find source with id: %@ referenced by layer:%@", self.sourceID, _id);
+  }
+  return result;
+}
+
+- (void)removeFromMap:(MLNStyle *)style {
+  if (_styleLayer != nil) {
+    [style removeLayer:_styleLayer];
+  }
+  _style = nil;
+}
+
+- (BOOL)isAddedToMap {
+  return (_style != nil);
+}
+
+// MARK: - Layer factory (type-based dispatch)
+
+- (nullable MLNStyleLayer *)makeLayer:(MLNStyle *)style {
+  if (_layerType == MLRNLayerTypeBackground) {
+    return [[MLNBackgroundStyleLayer alloc] initWithIdentifier:_id];
+  }
+
+  MLNSource *source = [self layerWithSourceIDInStyle:style];
+  if (source == nil) {
+    return nil;
+  }
+
+  MLNStyleLayer *layer = nil;
+
+  switch (_layerType) {
+    case MLRNLayerTypeCircle:
+      layer = [[MLNCircleStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeColorRelief:
+      layer = [[MLNColorReliefStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeFill:
+      layer = [[MLNFillStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeFillExtrusion:
+      layer = [[MLNFillExtrusionStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeHeatmap:
+      layer = [[MLNHeatmapStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeHillshade:
+      layer = [[MLNHillshadeStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeLine:
+      layer = [[MLNLineStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeRaster:
+      layer = [[MLNRasterStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    case MLRNLayerTypeSymbol:
+      layer = [[MLNSymbolStyleLayer alloc] initWithIdentifier:_id source:source];
+      break;
+    default:
+      RCTLogError(@"Unknown layer type: %ld", (long)_layerType);
+      return nil;
+  }
+
+  // Set sourceLayerIdentifier for vector layers
+  if (_sourceLayerID != nil && [layer isKindOfClass:[MLNVectorStyleLayer class]]) {
+    ((MLNVectorStyleLayer *)layer).sourceLayerIdentifier = _sourceLayerID;
+  }
+
+  return layer;
+}
+
+// MARK: - Style application (type-based dispatch)
+
+- (void)addStyles {
+  MLRNStyle *style = [[MLRNStyle alloc] initWithMLNStyle:self.style];
+
+  BOOL (^isValid)(void) = ^{
+    return [self isAddedToMap];
+  };
+
+  if ([_styleLayer isKindOfClass:[MLNBackgroundStyleLayer class]]) {
+    [style backgroundLayer:(MLNBackgroundStyleLayer *)_styleLayer
+            withReactStyle:_reactStyle
+                   isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNCircleStyleLayer class]]) {
+    [style circleLayer:(MLNCircleStyleLayer *)_styleLayer
+        withReactStyle:_reactStyle
+               isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNColorReliefStyleLayer class]]) {
+    [style colorReliefLayer:(MLNColorReliefStyleLayer *)_styleLayer
+             withReactStyle:_reactStyle
+                    isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNFillStyleLayer class]]) {
+    [style fillLayer:(MLNFillStyleLayer *)_styleLayer withReactStyle:_reactStyle isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNFillExtrusionStyleLayer class]]) {
+    [style fillExtrusionLayer:(MLNFillExtrusionStyleLayer *)_styleLayer
+               withReactStyle:_reactStyle
+                      isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNHeatmapStyleLayer class]]) {
+    [style heatmapLayer:(MLNHeatmapStyleLayer *)_styleLayer
+         withReactStyle:_reactStyle
+                isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNHillshadeStyleLayer class]]) {
+    [style hillshadeLayer:(MLNHillshadeStyleLayer *)_styleLayer
+           withReactStyle:_reactStyle
+                  isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNLineStyleLayer class]]) {
+    [style lineLayer:(MLNLineStyleLayer *)_styleLayer withReactStyle:_reactStyle isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNRasterStyleLayer class]]) {
+    [style rasterLayer:(MLNRasterStyleLayer *)_styleLayer
+        withReactStyle:_reactStyle
+               isValid:isValid];
+  } else if ([_styleLayer isKindOfClass:[MLNSymbolStyleLayer class]]) {
+    [style symbolLayer:(MLNSymbolStyleLayer *)_styleLayer
+        withReactStyle:_reactStyle
+               isValid:isValid];
+  }
+}
+
+- (void)addedToMap {
+  NSPredicate *filter = [self buildFilters];
+  if (filter != nil && [_styleLayer isKindOfClass:[MLNVectorStyleLayer class]]) {
+    [self updateFilter:filter];
+  }
+}
+
+// MARK: - Layer insertion
+
+- (void)insertLayer:(MLRNMapView *)map {
+  if ([_style layerWithIdentifier:_id] != nil) {
+    return;  // prevent layer from being added twice
+  }
+
+  if (_aboveLayerID != nil) {
+    [self insertAbove:_aboveLayerID];
+  } else if (_belowLayerID != nil) {
+    [self insertBelow:_belowLayerID];
+  } else if (_layerIndex != nil) {
+    [self insertAtIndex:_layerIndex.unsignedIntegerValue];
+  } else {
+    [_style addLayer:_styleLayer];
+    [_map layerAdded:_styleLayer];
+  }
+
+  [self setZoomBounds];
+}
+
+- (void)setZoomBounds {
+  if (_maxZoomLevel != nil) {
+    _styleLayer.maximumZoomLevel = [_maxZoomLevel doubleValue];
+  }
+
+  if (_minZoomLevel != nil) {
+    _styleLayer.minimumZoomLevel = [_minZoomLevel doubleValue];
+  }
+}
+
+- (void)insertAbove:(NSString *)aboveLayerIDs {
+  [_map waitForLayerWithId:aboveLayerIDs
+                      then:^void(MLNStyleLayer *layer) {
+                        if (![self _hasInitialized]) {
+                          return;
+                        }
+                        [self->_style insertLayer:self->_styleLayer aboveLayer:layer];
+                        [self->_map layerAdded:self->_styleLayer];
+                      }];
+}
+
+- (void)insertBelow:(NSString *)belowLayerID {
+  [_map waitForLayerWithId:belowLayerID
+                      then:^void(MLNStyleLayer *layer) {
+                        if (![self _hasInitialized]) {
+                          return;
+                        }
+
+                        [self->_style insertLayer:self->_styleLayer belowLayer:layer];
+                        [self->_map layerAdded:self->_styleLayer];
+                      }];
+}
+
+- (void)insertAtIndex:(NSUInteger)index {
+  if (![self _hasInitialized]) {
+    return;
+  }
+  NSArray *layers = _style.layers;
+  if (index >= layers.count) {
+    RCTLogWarn(@"Layer index is greater than number of layers on map. Layer inserted at end of "
+               @"layer stack.");
+    index = layers.count - 1;
+  }
+  [_style insertLayer:self->_styleLayer atIndex:index];
+  [_map layerAdded:self->_styleLayer];
+}
+
+- (BOOL)_hasInitialized {
+  return _style != nil && _styleLayer != nil;
+}
+
+@end

package/ios/components/layer/MLRNLayerComponentView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+
+@class MLRNLayer;
+
+@interface MLRNLayerComponentView : RCTViewComponentView
+
+@property (nonatomic, readonly) MLRNLayer *mlrnLayer;
+
+@end

package/ios/components/layer/MLRNLayerComponentView.mm

@@ -0,0 +1,136 @@
+#import "MLRNLayerComponentView.h"
+
+#import <react/renderer/components/MapVinaReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/Props.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <MapVina/MapVina.h>
+#import <React/RCTConversions.h>
+#import "MLRNLayer.h"
+#import "MLRNPropConvert.h"
+
+using namespace facebook::react;
+
+static MLRNLayerType MLRNLayerTypeFromCppEnum(MLRNLayerLayerType layerType) {
+  switch (layerType) {
+    case MLRNLayerLayerType::Background:
+      return MLRNLayerTypeBackground;
+    case MLRNLayerLayerType::Circle:
+      return MLRNLayerTypeCircle;
+    case MLRNLayerLayerType::ColorRelief:
+      return MLRNLayerTypeColorRelief;
+    case MLRNLayerLayerType::Fill:
+      return MLRNLayerTypeFill;
+    case MLRNLayerLayerType::FillExtrusion:
+      return MLRNLayerTypeFillExtrusion;
+    case MLRNLayerLayerType::Heatmap:
+      return MLRNLayerTypeHeatmap;
+    case MLRNLayerLayerType::Hillshade:
+      return MLRNLayerTypeHillshade;
+    case MLRNLayerLayerType::Line:
+      return MLRNLayerTypeLine;
+    case MLRNLayerLayerType::Raster:
+      return MLRNLayerTypeRaster;
+    case MLRNLayerLayerType::Symbol:
+      return MLRNLayerTypeSymbol;
+  }
+}
+
+// MARK: - MLRNLayerComponentView
+
+@interface MLRNLayerComponentView () <RCTMLRNLayerViewProtocol>
+
+@end
+
+@implementation MLRNLayerComponentView {
+  MLRNLayer *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  static const auto defaultProps = std::make_shared<const MLRNLayerProps>();
+  _props = defaultProps;
+
+  _view = [[MLRNLayer alloc] init];
+  self.contentView = _view;
+}
+
+- (MLRNLayer *)mlrnLayer {
+  return _view;
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self prepareView];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNLayerComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<const MLRNLayerProps>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<const MLRNLayerProps>(props);
+
+  if (oldViewProps.id != newViewProps.id) {
+    _view.id = RCTNSStringFromString(newViewProps.id);
+  }
+
+  if (oldViewProps.layerType != newViewProps.layerType) {
+    _view.layerType = MLRNLayerTypeFromCppEnum(newViewProps.layerType);
+  }
+
+  if (oldViewProps.source != newViewProps.source) {
+    _view.sourceID = RCTNSStringFromStringNilIfEmpty(newViewProps.source);
+  }
+
+  if (oldViewProps.sourceLayer != newViewProps.sourceLayer) {
+    _view.sourceLayerID = RCTNSStringFromStringNilIfEmpty(newViewProps.sourceLayer);
+  }
+
+  if (oldViewProps.afterId != newViewProps.afterId) {
+    _view.aboveLayerID = RCTNSStringFromStringNilIfEmpty(newViewProps.afterId);
+  }
+
+  if (oldViewProps.beforeId != newViewProps.beforeId) {
+    _view.belowLayerID = RCTNSStringFromStringNilIfEmpty(newViewProps.beforeId);
+  }
+
+  if (oldViewProps.layerIndex != newViewProps.layerIndex) {
+    _view.layerIndex = @(newViewProps.layerIndex);
+  }
+
+  if (oldViewProps.minzoom != newViewProps.minzoom) {
+    _view.minZoomLevel = @(newViewProps.minzoom);
+  }
+
+  if (oldViewProps.maxzoom != newViewProps.maxzoom) {
+    _view.maxZoomLevel = @(newViewProps.maxzoom);
+  }
+
+  if (oldViewProps.filter != newViewProps.filter) {
+    _view.filter = MLRN_DYNAMIC_TO_ARRAY(newViewProps.filter);
+  }
+
+  if (oldViewProps.reactStyle != newViewProps.reactStyle) {
+    _view.reactStyle = MLRN_DYNAMIC_TO_DICT(newViewProps.reactStyle);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+Class<RCTComponentViewProtocol> MLRNLayerCls(void) { return MLRNLayerComponentView.class; }
+
+@end