@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.2

package/ios/MLRN/MLRNCamera.m

@@ -0,0 +1,250 @@
+#import "MLRNCamera.h"
+#import "CameraStop.h"
+#import "CameraUpdateQueue.h"
+#import "MLRNLocation.h"
+#import "MLRNUtils.h"
+#import "MLRNLocationManager.h"
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "CameraMode.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)setMaxZoomLevel:(NSNumber *)maxZoomLevel {
+    _maxZoomLevel = maxZoomLevel;
+    [self _updateMinMaxZoomLevel];
+}
+
+- (void)setMinZoomLevel:(NSNumber *)minZoomLevel {
+    _minZoomLevel = minZoomLevel;
+    [self _updateMinMaxZoomLevel];
+}
+
+- (void)setMaxBounds:(NSString *)maxBounds {
+    _maxBounds = maxBounds;
+    [self _updateMaxBounds];
+}
+
+- (void)setDefaultStop:(NSDictionary<NSString *,id> *)stop
+{
+    _defaultStop = stop;
+}
+
+- (void)setStop:(NSDictionary<NSString *,id> *)stop
+{
+    _stop = stop;
+    
+    [self _updateCamera];
+}
+
+- (void)setMap:(MLRNMapView *)map
+{
+    if (_map != nil) {
+        _map.reactCamera = nil;
+    }
+    _map = map;
+    _map.reactCamera = self;
+
+    [self _setInitialCamera];
+    [self _updateMinMaxZoomLevel];
+    [self _updateMaxBounds];
+    [self _updateCamera];
+}
+
+- (void)setFollowUserLocation:(BOOL)followUserLocation
+{
+    _followUserLocation = followUserLocation;
+    [self _updateCameraFromTrackingMode];
+}
+
+- (void)setFollowUserMode:(NSString *)followUserMode
+{
+    _followUserMode = followUserMode;
+    [self _updateCameraFromTrackingMode];
+}
+
+- (void)setFollowPitch:(NSNumber *)followPitch
+{
+    _followPitch = followPitch;
+    [self _updateCameraFromTrackingMode];
+}
+
+- (void)setFollowZoomLevel:(NSNumber *)followZoomLevel
+{
+    _followZoomLevel = followZoomLevel;
+    [self _updateCameraFromTrackingMode];
+}
+
+- (void)setFollowHeading:(NSNumber *)followHeading
+{
+    _followHeading = followHeading;
+    [self _updateCameraFromTrackingMode];
+}
+
+- (void)_updateCameraFromJavascript
+{
+    if (_stop == nil) {
+        return;
+    }
+    
+    if (_followUserLocation) {
+        return;
+    }
+    
+    if (_map != nil && _map.userTrackingMode != MLNUserTrackingModeNone) {
+        _map.userTrackingMode = MLNUserTrackingModeNone;
+    }
+    if (_stop[@"stops"]) {
+        NSArray* stops = _stop[@"stops"];
+        for (NSDictionary* stop in stops) {
+            [cameraUpdateQueue enqueue:[CameraStop fromDictionary:stop]];
+        }
+    } else {
+        [cameraUpdateQueue enqueue:[CameraStop fromDictionary:_stop]];
+    }
+    [cameraUpdateQueue execute:_map];
+}
+
+- (void)_setInitialCamera
+{
+    if (! _defaultStop) {
+        return;
+    }
+
+    CameraStop* stop = [CameraStop fromDictionary:_defaultStop];
+    stop.duration = 0;
+    stop.mode = [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_NONE];
+    CameraUpdateItem *item = [[CameraUpdateItem alloc] init];
+    item.cameraStop = stop;
+    [item execute:_map withCompletionHandler:^{ }];
+}
+
+- (void)_updateCamera
+{
+    if (_map != nil) {
+        if (_followUserLocation) {
+            [self _updateCameraFromTrackingMode];
+        } else {
+            [self _updateCameraFromJavascript];
+        }
+    }
+}
+
+- (void)_updateMinMaxZoomLevel
+{
+    if (_map != nil) {
+        if (_maxZoomLevel) {
+            _map.maximumZoomLevel = [_maxZoomLevel doubleValue];
+        }
+        if (_minZoomLevel) {
+            _map.minimumZoomLevel = [_minZoomLevel doubleValue];
+        }
+    }
+}
+
+- (void)_updateMaxBounds
+{
+    if (_map != nil) {
+        if (_maxBounds) {
+            _map.maxBounds = [MLRNUtils fromFeatureCollection:_maxBounds];
+        }
+    }
+}
+
+- (void)_updateCameraFromTrackingMode
+{
+    if (_map == nil) {
+          return;
+    }
+    if (!_followUserLocation) {
+        _map.userTrackingMode = MLNUserTrackingModeNone;
+        return;
+    }
+    
+    if (_map.userTrackingMode != [self _userTrackingMode]) {
+        _map.showsUserLocation = [self _userTrackingMode] != MLNUserTrackingModeNone;
+        _map.userTrackingMode = [self _userTrackingMode];
+    }
+    
+    MLNMapCamera *camera = _map.camera;
+    if (_followPitch != nil && [_followPitch floatValue] >= 0.0) {
+        camera.pitch = [_followPitch floatValue];
+    } else if (_stop != nil && _stop[@"pitch"] != nil) {
+        camera.pitch = [_stop[@"pitch"] floatValue];
+    }
+    
+    if ([self _userTrackingMode] != MLNUserTrackingModeFollowWithCourse && [self _userTrackingMode] != MLNUserTrackingModeFollowWithHeading) {
+        if (_followHeading != nil && [_followHeading floatValue] >= 0.0) {
+            camera.heading = [_followHeading floatValue];
+        } else if (_stop != nil && _stop[@"heading"] != nil) {
+            camera.heading = [_stop[@"heading"] floatValue];
+        }
+    }
+    
+    if (_followZoomLevel != nil && [_followZoomLevel doubleValue] >= 0.0) {
+        camera.altitude = [_map altitudeFromZoom:[_followZoomLevel doubleValue]];
+    }
+    
+    [_map setCamera:camera animated:YES];
+}
+
+- (NSUInteger)_userTrackingMode
+{
+    if ([_followUserMode isEqualToString:@"compass"]) {
+        return MLNUserTrackingModeFollowWithHeading;
+    } else if ([_followUserMode isEqualToString:@"course"]) {
+        return MLNUserTrackingModeFollowWithCourse;
+    } else if (_followUserLocation) {
+        return MLNUserTrackingModeFollow;
+    } else {
+        return MLNUserTrackingModeNone;
+    }
+}
+
+- (id)_trackingModeToString:(MLNUserTrackingMode) mode {
+    switch (mode) {
+        case MLNUserTrackingModeFollowWithHeading:
+            return @"compass";
+        case MLNUserTrackingModeFollowWithCourse:
+            return @"course";
+        case MLNUserTrackingModeFollow:
+            return @"normal";
+        case MLNUserTrackingModeNone:
+            return [NSNull null];
+    }
+}
+
+- (void)initialLayout
+{
+    [self _setInitialCamera];
+    [self _updateCamera];
+}
+
+- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated
+{
+    NSDictionary *payload = @{ @"followUserMode": [self _trackingModeToString: mode], @"followUserLocation": @((BOOL)(mode != MLNUserTrackingModeNone)) };
+    MLRNEvent *event = [MLRNEvent makeEvent:RCT_MAPBOX_USER_TRACKING_MODE_CHANGE withPayload:payload];
+    if (_onUserTrackingModeChange) {
+        _onUserTrackingModeChange([event toJSON]);
+    }
+}
+
+@end

package/ios/MLRN/MLRNCameraManager.h

@@ -0,0 +1,5 @@
+#import "ViewManager.h"
+
+@interface MLRNCameraManager : ViewManager
+
+@end

package/ios/MLRN/MLRNCameraManager.m

@@ -0,0 +1,41 @@
+#import "MLRNCameraManager.h"
+#import "MLRNCamera.h"
+
+@implementation MLRNCameraManager
+
+RCT_EXPORT_MODULE(MLRNCamera)
+
+#pragma - View Properties
+
+RCT_EXPORT_VIEW_PROPERTY(stop, NSDictionary)
+
+RCT_EXPORT_VIEW_PROPERTY(followUserLocation, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(followUserMode, NSString)
+RCT_EXPORT_VIEW_PROPERTY(followZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(followPitch, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(followHeading, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(alignment, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(maxBounds, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(onUserTrackingModeChange, RCTBubblingEventBlock)
+
+RCT_EXPORT_VIEW_PROPERTY(defaultStop, NSDictionary)
+
+#pragma Methods
+
+- (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (UIView *)view
+{
+    return [[MLRNCamera alloc] init];
+}
+
+@end

package/ios/MLRN/MLRNCircleLayer.h

@@ -0,0 +1,5 @@
+#import "MLRNVectorLayer.h"
+
+@interface MLRNCircleLayer : MLRNVectorLayer
+
+@end

package/ios/MLRN/MLRNCircleLayer.m

@@ -0,0 +1,26 @@
+#import "MLRNCircleLayer.h"
+#import "MLRNStyle.h"
+
+#import <React/RCTLog.h>
+
+@implementation MLRNCircleLayer
+
+- (MLNCircleStyleLayer*)makeLayer:(MLNStyle*)style
+{
+    MLNSource *source = [self layerWithSourceIDInStyle:style];
+    if (source == nil) { return nil; }
+    MLNCircleStyleLayer *layer = [[MLNCircleStyleLayer alloc] initWithIdentifier:self.id source:source];
+    layer.sourceLayerIdentifier = self.sourceLayerID;
+    return layer;
+}
+
+- (void)addStyles
+{
+    MLRNStyle *style = [[MLRNStyle alloc] initWithMLNStyle:self.style];
+    style.bridge = self.bridge;
+    [style circleLayer:(MLNCircleStyleLayer*)self.styleLayer withReactStyle:self.reactStyle isValid:^{
+        return [self isAddedToMap];
+    }];
+}
+
+@end

package/ios/MLRN/MLRNCircleLayerManager.h

@@ -0,0 +1,5 @@
+#import "ViewManager.h"
+
+@interface MLRNCircleLayerManager : ViewManager
+
+@end

package/ios/MLRN/MLRNCircleLayerManager.m

@@ -0,0 +1,31 @@
+#import "MLRNCircleLayerManager.h"
+#import "MLRNCircleLayer.h"
+
+@implementation MLRNCircleLayerManager
+
+RCT_EXPORT_MODULE()
+
+// circle layer props
+RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString);
+
+// standard layer props
+RCT_EXPORT_VIEW_PROPERTY(id, NSString);
+RCT_EXPORT_VIEW_PROPERTY(sourceID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(filter, NSArray);
+
+RCT_EXPORT_VIEW_PROPERTY(aboveLayerID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(belowLayerID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(layerIndex, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(reactStyle, NSDictionary);
+
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber);
+
+- (UIView*)view
+{
+    MLRNCircleLayer *layer = [MLRNCircleLayer new];
+    layer.bridge = self.bridge;
+    return layer;
+}
+
+@end

package/ios/MLRN/MLRNCustomHeaders.h

@@ -0,0 +1,20 @@
+//
+//  MLRNCustomHeaders.h
+//  MLRN
+//
+
+#import <Foundation/Foundation.h>
+
+@interface NSMutableURLRequest (CustomHeaders)
+@end
+
+@interface MLRNCustomHeaders : NSObject
+
+@property (nonatomic, strong) NSMutableDictionary<NSString*, NSString*> *currentHeaders;
+
++ (id)sharedInstance;
+- (void)initHeaders;
+- (void)addHeader:(NSString*)value forHeaderName:(NSString *)header;
+- (void)removeHeader:(NSString *)header;
+
+@end

package/ios/MLRN/MLRNCustomHeaders.m

@@ -0,0 +1,98 @@
+//
+//  MLRNCustomHeaders.h
+//  MLRN
+//
+
+#import <objc/runtime.h>
+
+#import "MLRNCustomHeaders.h"
+#import <MapLibre/MapLibre.h>
+#import <MapLibre/MLNNetworkConfiguration.h>
+
+@implementation NSMutableURLRequest (CustomHeaders)
+
+    +(NSMutableURLRequest*) __swizzle_requestWithURL:(NSURL*)url {
+        if([url.scheme isEqualToString:@"ws"]) {
+            return [NSMutableURLRequest __swizzle_requestWithURL:url];
+        }
+
+        NSArray<NSString*>* stack = [NSThread callStackSymbols];
+        if ([stack count] < 2) {
+            return [NSMutableURLRequest __swizzle_requestWithURL:url];
+        }
+
+        if ([stack[1] containsString:@"MapLibre"] == NO) {
+            return [NSMutableURLRequest __swizzle_requestWithURL:url];
+        }
+
+        NSMutableURLRequest *req = [NSMutableURLRequest __swizzle_requestWithURL:url];
+        NSDictionary<NSString*, NSString*> *currentHeaders = [[[MLRNCustomHeaders sharedInstance] currentHeaders] copy];
+        if(currentHeaders != nil && [currentHeaders count]>0) {
+            for (NSString* headerName in currentHeaders) {
+                id headerValue = currentHeaders[headerName];
+                [req setValue:headerValue forHTTPHeaderField:headerName];
+            }
+        }
+        return req;
+    }
+
+@end
+
+@implementation MLRNCustomHeaders {
+    NSMutableDictionary<NSString*, NSString*> *_currentHeaders;
+    BOOL areHeadersAdded;
+}
+
++ (id)sharedInstance
+{
+    static MLRNCustomHeaders *customHeaders;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ customHeaders = [[self alloc] init]; });
+    return customHeaders;
+}
+
+// This replaces the [NSMutableURLRequest requestWithURL:] with custom implementation which
+// adds runtime headers copied from [MLRNCustomHeaders _currentHeaders]
+-(void)initHeaders
+{
+    if (!areHeadersAdded) {
+        areHeadersAdded = YES;
+        NSLog(@"Replace method [NSMutableURLRequest requestWithURL]");
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            Class targetClass = [NSMutableURLRequest class];
+            Method oldMethod = class_getClassMethod(targetClass, @selector(requestWithURL:));
+            Method newMethod = class_getClassMethod(targetClass, @selector(__swizzle_requestWithURL:));
+            method_exchangeImplementations(oldMethod, newMethod);
+        });
+    }
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _currentHeaders = [[NSMutableDictionary alloc] init];
+        areHeadersAdded = NO;
+    }
+    return self;
+}
+
+- (void)addHeader:(NSString *)value forHeaderName:(NSString *)headerName {
+
+    if(!areHeadersAdded) {
+        areHeadersAdded = YES;
+    }
+
+    [_currentHeaders setObject:value forKey:headerName];
+    [[[MLNNetworkConfiguration sharedManager] sessionConfiguration] setHTTPAdditionalHeaders:_currentHeaders];
+}
+
+- (void)removeHeader:(NSString *)header {
+    if(!areHeadersAdded) {
+        return;
+    }
+
+    [_currentHeaders removeObjectForKey:header];
+}
+
+@end

package/ios/MLRN/MLRNEvent.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import "MLRNEventProtocol.h"
+
+@interface MLRNEvent : NSObject<MLRNEventProtocol>
+
+@property (nonatomic, copy) NSString *type;
+@property (nonatomic, strong) NSDictionary *payload;
+@property (nonatomic, readonly) NSTimeInterval timestamp;
+
++ (MLRNEvent*)makeEvent:(NSString*)eventType;
++ (MLRNEvent*)makeEvent:(NSString*)eventType withPayload:(NSDictionary*)payload;
+
+@end

package/ios/MLRN/MLRNEvent.m

@@ -0,0 +1,39 @@
+#import "MLRNEvent.h"
+
+@implementation MLRNEvent
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _timestamp = [[NSDate date] timeIntervalSince1970];
+    }
+    return self;
+}
+
+- (NSDictionary*)payload
+{
+    if (_payload == nil) {
+        return @{};
+    }
+    return _payload;
+}
+
+- (NSDictionary*)toJSON
+{
+    return @{ @"type": self.type, @"payload": self.payload };
+}
+
++ (MLRNEvent*)makeEvent:(NSString*)type
+{
+    return [MLRNEvent makeEvent:type withPayload:@{}];
+}
+
++ (MLRNEvent*)makeEvent:(NSString*)type withPayload:(NSDictionary*)payload
+{
+    MLRNEvent *event = [[MLRNEvent alloc] init];
+    event.type = type;
+    event.payload = payload;
+    return event;
+}
+
+@end

package/ios/MLRN/MLRNEventProtocol.h

@@ -0,0 +1,8 @@
+@protocol MLRNEventProtocol <NSObject>
+
+@property (nonatomic, copy) NSString *type;
+@property (nonatomic, strong) NSDictionary *payload;
+
+- (NSDictionary*)toJSON;
+
+@end

package/ios/MLRN/MLRNEventTypes.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+
+@interface MLRNEventTypes : NSObject
+
+extern NSString *const RCT_MAPBOX_EVENT_TAP;
+extern NSString *const RCT_MAPBOX_EVENT_LONGPRESS;
+
+extern NSString *const RCT_MAPBOX_USER_LOCATION_UPDATE;
+extern NSString *const RCT_MAPBOX_USER_TRACKING_MODE_CHANGE;
+
+extern NSString *const RCT_MAPBOX_REGION_WILL_CHANGE_EVENT;
+extern NSString *const RCT_MAPBOX_REGION_IS_CHANGING;
+extern NSString *const RCT_MAPBOX_REGION_DID_CHANGE;
+
+extern NSString *const RCT_MAPBOX_WILL_START_LOADING_MAP;
+extern NSString *const RCT_MAPBOX_DID_FINISH_LOADING_MAP;
+extern NSString *const RCT_MAPBOX_DID_FAIL_LOADING_MAP;
+
+extern NSString *const RCT_MAPBOX_WILL_START_RENDERING_FRAME;
+extern NSString *const RCT_MAPBOX_DID_FINSIH_RENDERING_FRAME;
+extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_FRAME_FULLY;
+
+extern NSString *const RCT_MAPBOX_WILL_START_RENDERING_MAP;
+extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP;
+extern NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP_FULLY;
+
+extern NSString *const RCT_MAPBOX_DID_FINISH_LOADING_STYLE;
+
+extern NSString *const RCT_MAPBOX_ANNOTATION_TAP;
+
+extern NSString *const RCT_MAPBOX_OFFLINE_PROGRESS;
+extern NSString *const RCT_MAPBOX_OFFLINE_ERROR;
+extern NSString *const RCT_MAPBOX_OFFLINE_TILE_LIMIT;
+
+extern NSString *const RCT_MAPBOX_SHAPE_SOURCE_LAYER_PRESS;
+extern NSString *const RCT_MAPBOX_VECTOR_SOURCE_LAYER_PRESS;
+
+extern NSString *const RCT_MAPBOX_USER_LOCATION_UPDATE;
+
+extern NSString *const RCT_MAPBOX_IMAGES_MISSING_IMAGE;
+
+@end

package/ios/MLRN/MLRNEventTypes.m

@@ -0,0 +1,41 @@
+#import "MLRNEventTypes.h"
+
+@implementation MLRNEventTypes
+
+NSString *const RCT_MAPBOX_EVENT_TAP = @"press";
+NSString *const RCT_MAPBOX_EVENT_LONGPRESS = @"longpress";
+
+NSString *const RCT_MAPBOX_USER_TRACKING_MODE_CHANGE = @"usertrackingmodechange";
+
+NSString *const RCT_MAPBOX_REGION_WILL_CHANGE_EVENT = @"regionwillchange";
+NSString *const RCT_MAPBOX_REGION_IS_CHANGING = @"regionischanging";
+NSString *const RCT_MAPBOX_REGION_DID_CHANGE = @"regiondidchange";
+
+NSString *const RCT_MAPBOX_WILL_START_LOADING_MAP = @"willstartloadingmap";
+NSString *const RCT_MAPBOX_DID_FINISH_LOADING_MAP = @"didfinishloadingmap";
+NSString *const RCT_MAPBOX_DID_FAIL_LOADING_MAP = @"didfailoadingmap";
+
+NSString *const RCT_MAPBOX_WILL_START_RENDERING_FRAME = @"willstartrenderingframe";
+NSString *const RCT_MAPBOX_DID_FINSIH_RENDERING_FRAME = @"didfinishrenderingframe";
+NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_FRAME_FULLY = @"didfinishrenderingframefully";
+
+NSString *const RCT_MAPBOX_WILL_START_RENDERING_MAP = @"willstartrenderingmap";
+NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP = @"didfinishrenderingmap";
+NSString *const RCT_MAPBOX_DID_FINISH_RENDERING_MAP_FULLY = @"didfinishrenderingmapfully";
+
+NSString *const RCT_MAPBOX_DID_FINISH_LOADING_STYLE = @"didfinishloadingstyle";
+
+NSString *const RCT_MAPBOX_ANNOTATION_TAP = @"annotationtap";
+
+NSString *const RCT_MAPBOX_OFFLINE_PROGRESS = @"offlinestatus";
+NSString *const RCT_MAPBOX_OFFLINE_ERROR = @"offlineerror";
+NSString *const RCT_MAPBOX_OFFLINE_TILE_LIMIT = @"offlinetilelimit";
+
+NSString *const RCT_MAPBOX_SHAPE_SOURCE_LAYER_PRESS = @"shapesourcelayerpress";
+NSString *const RCT_MAPBOX_VECTOR_SOURCE_LAYER_PRESS = @"vectorsourcelayerpress";
+
+NSString *const RCT_MAPBOX_IMAGES_MISSING_IMAGE = @"imagesmissingimage";
+
+NSString *const RCT_MAPBOX_USER_LOCATION_UPDATE = @"MapboxUserLocationUpdate";
+
+@end

package/ios/MLRN/MLRNFillExtrusionLayer.h

@@ -0,0 +1,6 @@
+#import "MLRNVectorLayer.h"
+@import MapLibre;
+
+@interface MLRNFillExtrusionLayer : MLRNVectorLayer
+
+@end

package/ios/MLRN/MLRNFillExtrusionLayer.m

@@ -0,0 +1,24 @@
+#import "MLRNFillExtrusionLayer.h"
+#import "MLRNStyle.h"
+#import <React/RCTLog.h>
+
+@implementation MLRNFillExtrusionLayer
+
+- (MLNFillExtrusionStyleLayer*)makeLayer:(MLNStyle*)style
+{
+    MLNSource *source = [self layerWithSourceIDInStyle:style];
+    if (source == nil) { return nil; }
+    MLNFillExtrusionStyleLayer *layer = [[MLNFillExtrusionStyleLayer alloc] initWithIdentifier:self.id source:source];
+    layer.sourceLayerIdentifier = self.sourceLayerID;
+    return layer;
+}
+
+- (void)addStyles
+{
+    MLRNStyle *style = [[MLRNStyle alloc] initWithMLNStyle:self.style];
+    style.bridge = self.bridge;
+    [style fillExtrusionLayer:(MLNFillExtrusionStyleLayer*)self.styleLayer withReactStyle:self.reactStyle isValid:^{ return [self isAddedToMap];
+    }];
+}
+
+@end

package/ios/MLRN/MLRNFillExtrusionLayerManager.h

@@ -0,0 +1,5 @@
+#import "ViewManager.h"
+
+@interface MLRNFillExtrusionLayerManager : ViewManager
+
+@end