@maplibre/maplibre-react-native 8.6.0-beta.0

package/ios/RCTMGL/CameraMode.h

@@ -0,0 +1,18 @@
+//
+//  CameraMode.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface CameraMode : NSObject
+
+extern int const RCT_MAPBOX_CAMERA_MODE_FLIGHT;
+extern int const RCT_MAPBOX_CAMERA_MODE_EASE;
+extern int const RCT_MAPBOX_CAMERA_MODE_LINEAR;
+extern int const RCT_MAPBOX_CAMERA_MODE_NONE;
+
+@end

package/ios/RCTMGL/CameraMode.m

@@ -0,0 +1,18 @@
+//
+//  CameraMode.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "CameraMode.h"
+
+@implementation CameraMode
+
+int const RCT_MAPBOX_CAMERA_MODE_FLIGHT = 1;
+int const RCT_MAPBOX_CAMERA_MODE_EASE = 2;
+int const RCT_MAPBOX_CAMERA_MODE_LINEAR = 3;
+int const RCT_MAPBOX_CAMERA_MODE_NONE = 4;
+
+@end

package/ios/RCTMGL/CameraStop.h

@@ -0,0 +1,26 @@
+//
+//  CameraStop.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/5/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+@import Mapbox;
+#import "RCTMGLCamera.h"
+
+@interface CameraStop : NSObject
+
+@property (nonatomic, strong) NSNumber *pitch;
+@property (nonatomic, strong) NSNumber *heading;
+@property (nonatomic, strong) NSNumber *zoom;
+@property (nonatomic, strong) NSNumber *mode;
+@property (nonatomic, assign) NSTimeInterval duration;
+
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property (nonatomic, assign) MGLCoordinateBounds bounds;
+@property (nonatomic, assign) UIEdgeInsets padding;
+
++ (CameraStop*)fromDictionary:(NSDictionary*)args;
+
+@end

package/ios/RCTMGL/CameraStop.m

@@ -0,0 +1,83 @@
+//
+//  CameraStop.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/5/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "CameraStop.h"
+#import "CameraMode.h"
+#import "RCTMGLUtils.h"
+#import "RCTMGLCamera.h"
+
+@implementation CameraStop
+
+- (void)setMode:(NSNumber *)mode
+{
+    int modeInt = [mode intValue];
+    
+    if (modeInt == RCT_MAPBOX_CAMERA_MODE_FLIGHT) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else if (modeInt == RCT_MAPBOX_CAMERA_MODE_NONE) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else if (modeInt == RCT_MAPBOX_CAMERA_MODE_LINEAR) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else {
+        _mode = [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_EASE];
+    }
+}
+
+-(id)init {
+     if (self = [super init])  {
+         self.coordinate = kCLLocationCoordinate2DInvalid;
+         self.bounds = MGLCoordinateBoundsMake(kCLLocationCoordinate2DInvalid, kCLLocationCoordinate2DInvalid);
+     }
+     return self;
+}
+
+
++ (CameraStop*)fromDictionary:(NSDictionary *)args
+{
+    CameraStop *stop = [[CameraStop alloc] init];
+    
+    if (args[@"pitch"]) {
+        stop.pitch = args[@"pitch"];
+    }
+    
+    if (args[@"heading"]) {
+        stop.heading = args[@"heading"];
+    }
+
+    if (args[@"centerCoordinate"]) {
+        stop.coordinate = [RCTMGLUtils fromFeature:args[@"centerCoordinate"]];
+    }
+    
+    if (args[@"zoom"]) {
+        stop.zoom = args[@"zoom"];
+    }
+    
+    if (args[@"mode"]) {
+        stop.mode = args[@"mode"];
+    }
+    
+    if (args[@"bounds"]) {
+        stop.bounds = [RCTMGLUtils fromFeatureCollection:args[@"bounds"]];
+    }
+    
+    CGFloat paddingTop = args[@"paddingTop"] ? [args[@"paddingTop"] floatValue] : 0.0;
+    CGFloat paddingRight = args[@"paddingRight"] ? [args[@"paddingRight"] floatValue] : 0.0;
+    CGFloat paddingBottom = args[@"paddingBottom"] ? [args[@"paddingBottom"] floatValue] : 0.0;
+    CGFloat paddingLeft = args[@"paddingLeft"] ? [args[@"paddingLeft"] floatValue] : 0.0;
+    stop.padding = UIEdgeInsetsMake(paddingTop, paddingLeft, paddingBottom, paddingRight);
+    
+    NSTimeInterval duration = 2.0;
+    if (args[@"duration"]) {
+        duration = [RCTMGLUtils fromMS:args[@"duration"]];
+    }
+    stop.duration = duration;
+    
+    return stop;
+}
+
+@end

package/ios/RCTMGL/CameraUpdateItem.h

@@ -0,0 +1,18 @@
+//
+//  CameraUpdateItem.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "CameraStop.h"
+#import "RCTMGLMapView.h"
+
+@interface CameraUpdateItem : NSObject
+
+@property (nonatomic, strong) CameraStop* _Nonnull cameraStop;
+
+- (void)execute:(RCTMGLMapView* _Nonnull)mapView withCompletionHandler:(nullable void (^)(void))completionHandler;
+
+@end

package/ios/RCTMGL/CameraUpdateItem.m

@@ -0,0 +1,178 @@
+//
+//  CameraUpdateItem.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "CameraUpdateItem.h"
+#import "CameraMode.h"
+
+
+@interface MGLMapView(FlyToWithPadding)
+- (void)_flyToCamera:(MGLMapCamera *)camera edgePadding:(UIEdgeInsets)insets withDuration:(NSTimeInterval)duration peakAltitude:(CLLocationDistance)peakAltitude completionHandler:(nullable void (^)(void))completion;
+@end
+
+@interface RCTMGLCameraWithPadding : MGLMapCamera
+
+@property (nonatomic) MGLMapCamera* _Nonnull camera;
+@property (nonatomic) UIEdgeInsets boundsPadding;
+
+@end
+
+@implementation RCTMGLCameraWithPadding
+
+@end
+
+@implementation CameraUpdateItem
+
+- (void)execute:(RCTMGLMapView *)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];
+    }
+}
+
+- (void)_flyToCamera:(RCTMGLMapView*)mapView withCompletionHandler:(void (^)(void))completionHandler
+{
+    RCTMGLCameraWithPadding *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];
+    }
+}
+
+- (void)_moveCamera:(RCTMGLMapView*)mapView animated:(BOOL)animated ease:(BOOL)ease withCompletionHandler:(void (^)(void))completionHandler
+{
+        RCTMGLCameraWithPadding *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];
+}
+
+- (RCTMGLCameraWithPadding*)_makeCamera:(RCTMGLMapView*)mapView
+{
+    MGLMapCamera *nextCamera = [mapView.camera copy];
+
+    UIEdgeInsets padding = [self _clippedPadding:_cameraStop.padding forView:mapView];
+    if (padding.top <= 0 && padding.bottom <= 0) {
+      // 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 _isCoordValid:_cameraStop.coordinate]) {
+        MGLCoordinateBounds boundsFromCoord = { .sw =  _cameraStop.coordinate, .ne =  _cameraStop.coordinate };
+        MGLMapCamera *boundsCamera = [mapView
+            camera:nextCamera
+            fittingCoordinateBounds:boundsFromCoord
+            edgePadding: padding];
+        nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+    } else if ([self _areBoundsValid:_cameraStop.bounds]) {
+        MGLMapCamera *boundsCamera = [mapView
+            camera:nextCamera
+            fittingCoordinateBounds:_cameraStop.bounds
+            edgePadding: padding];
+        nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+        nextCamera.altitude = boundsCamera.altitude;
+        hasSetAltitude = true;
+    }
+  
+    if (_cameraStop.pitch != nil) {
+      nextCamera.pitch = [_cameraStop.pitch floatValue];
+    }
+    
+    if (_cameraStop.heading != nil) {
+      nextCamera.heading = [_cameraStop.heading floatValue];
+    }
+    
+    if (_cameraStop.zoom != nil && hasSetAltitude == false) {
+      nextCamera.altitude = [mapView
+           altitudeFromZoom:[_cameraStop.zoom doubleValue]
+           atLatitude:nextCamera.centerCoordinate.latitude
+           atPitch:nextCamera.pitch];
+    }
+  
+    RCTMGLCameraWithPadding* cameraWithPadding = [[RCTMGLCameraWithPadding alloc] init];
+    cameraWithPadding.camera = nextCamera;
+    cameraWithPadding.boundsPadding = padding;
+    return cameraWithPadding;
+}
+
+- (UIEdgeInsets)_clippedPadding:(UIEdgeInsets)padding forView:(RCTMGLMapView*)mapView
+{
+    UIEdgeInsets result = padding;
+    if ((padding.top + padding.bottom) >= mapView.frame.size.height) {
+        double totalPadding = padding.top + padding.bottom;
+        double extra = totalPadding - mapView.frame.size.height + 1.0;
+        result.top -= (padding.top * extra) / totalPadding;
+        result.bottom -= (padding.bottom * extra) / totalPadding;
+    }
+    if ((padding.left + padding.right) >= mapView.frame.size.width) {
+        double totalPadding = padding.left + padding.right;
+        double extra = totalPadding - mapView.frame.size.width + 1.0;
+        result.left -= (padding.left * extra) / totalPadding;
+        result.right -= (padding.right * extra) / totalPadding;
+    }
+    return result;
+}
+
+- (BOOL)_areBoundsValid:(MGLCoordinateBounds)bounds {
+    BOOL isValid = CLLocationCoordinate2DIsValid(bounds.ne) && CLLocationCoordinate2DIsValid(bounds.sw);
+    
+    if (!isValid) {
+        return NO;
+    }
+    
+    CLLocationCoordinate2D ne = bounds.ne;
+    CLLocationCoordinate2D sw = bounds.sw;
+    return [self _isCoordValid:ne] && [self _isCoordValid:sw];
+}
+
+- (BOOL)_isCoordValid:(CLLocationCoordinate2D)coord
+{
+    BOOL isValid = CLLocationCoordinate2DIsValid(coord);
+    
+    if (!isValid) {
+        return NO;
+    }
+    
+    return YES;
+}
+
+- (BOOL)_hasCenterCoordAndZoom
+{
+    BOOL isValid = CLLocationCoordinate2DIsValid(_cameraStop.coordinate) && _cameraStop.zoom != nil;
+    
+    if (!isValid) {
+        return NO;
+    }
+    
+    return [self _isCoordValid:_cameraStop.coordinate];
+}
+
+@end

package/ios/RCTMGL/CameraUpdateQueue.h

@@ -0,0 +1,21 @@
+//
+//  CameraUpdateQueue.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "CameraStop.h"
+#import "CameraUpdateItem.h"
+#import "RCTMGLMapView.h"
+
+@interface CameraUpdateQueue : NSObject
+
+- (void)enqueue:(CameraStop* _Nonnull)cameraUpdateItem;
+- (CameraStop* _Nonnull)dequeue;
+- (void)flush;
+- (BOOL)isEmpty;
+- (void)execute:(RCTMGLMapView* _Nonnull)mapView;
+
+@end

package/ios/RCTMGL/CameraUpdateQueue.m

@@ -0,0 +1,74 @@
+//
+//  CameraUpdateQueue.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 9/6/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#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:(RCTMGLMapView*)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 RCTMGLMapView *weakMap = mapView;
+    
+    [item execute:mapView withCompletionHandler:^{ [weakSelf execute:weakMap]; }];
+}
+
+@end

package/ios/RCTMGL/FilterParser.h

@@ -0,0 +1,14 @@
+//
+//  FilterParser.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 10/3/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+#import <Foundation/Foundation.h>
+
+@interface FilterParser : NSObject
+
++ (NSPredicate*)parse:(NSArray *)filter;
+
+@end

package/ios/RCTMGL/FilterParser.m

@@ -0,0 +1,22 @@
+//
+//  FilterParser.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 10/3/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "FilterParser.h"
+#import <Mapbox/Mapbox.h>
+
+@implementation FilterParser
+
++ (NSPredicate*)parse:(NSArray *)filterList
+{
+    if (filterList == nil || filterList.count < 1) {
+        return nil;
+    }
+    return [NSPredicate predicateWithMGLJSONObject:filterList];
+}
+
+@end

package/ios/RCTMGL/MGLCustomHeaders.h

@@ -0,0 +1,20 @@
+//
+//  MGLCustomHeaders.h
+//  RCTMGL
+//
+
+#import <Foundation/Foundation.h>
+
+@interface NSMutableURLRequest (CustomHeaders)
+@end
+
+@interface MGLCustomHeaders : 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/RCTMGL/MGLCustomHeaders.m

@@ -0,0 +1,98 @@
+//
+//  MGLCustomHeaders.h
+//  RCTMGL
+//
+
+#import <objc/runtime.h>
+
+#import "MGLCustomHeaders.h"
+#import <Mapbox/Mapbox.h>
+#import <Mapbox/MGLNetworkConfiguration.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:@"Mapbox"] == NO) {
+            return [NSMutableURLRequest __swizzle_requestWithURL:url];
+        }
+
+        NSMutableURLRequest *req = [NSMutableURLRequest __swizzle_requestWithURL:url];
+        NSDictionary<NSString*, NSString*> *currentHeaders = [[[MGLCustomHeaders 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 MGLCustomHeaders {
+    NSMutableDictionary<NSString*, NSString*> *_currentHeaders;
+    BOOL areHeadersAdded;
+}
+
++ (id)sharedInstance
+{
+    static MGLCustomHeaders *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 [MGLCustomHeaders _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];
+    [[[MGLNetworkConfiguration sharedManager] sessionConfiguration] setHTTPAdditionalHeaders:_currentHeaders];
+}
+
+- (void)removeHeader:(NSString *)header {
+    if(!areHeadersAdded) {
+        return;
+    }
+
+    [_currentHeaders removeObjectForKey:header];
+}
+
+@end

package/ios/RCTMGL/MGLFaux3DUserLocationAnnotationView.h

@@ -0,0 +1,23 @@
+//
+//  MGLFaux3DUserLocationAnnotationView.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 12/20/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+@import Mapbox;
+
+extern const CGFloat MGLUserLocationAnnotationDotSize;
+extern const CGFloat MGLUserLocationAnnotationHaloSize;
+
+extern const CGFloat MGLUserLocationAnnotationPuckSize;
+extern const CGFloat MGLUserLocationAnnotationArrowSize;
+
+// Threshold in radians between heading indicator rotation updates.
+extern const CGFloat MGLUserLocationHeadingUpdateThreshold;
+
+@interface MGLFaux3DUserLocationAnnotationView : MGLUserLocationAnnotationView
+
+@end