@maplibre/maplibre-react-native 11.0.0-alpha.1 → 11.0.0-alpha.11

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/MLRNImageQueue.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTImageLoader.h>
+
+@interface MLRNImageQueue : NSObject
+
++ (instancetype)sharedInstance;
+
+- (void)cancelAllOperations;
+- (void)addImage:(NSString *)imageURL
+                scale:(double)scale
+                  sdf:(Boolean)sdf
+               bridge:(RCTBridge *)bridge
+    completionHandler:(RCTImageLoaderCompletionBlock)handler;
+
+@end

package/ios/components/images/MLRNImageQueue.m

@@ -0,0 +1,48 @@
+#import "MLRNImageQueue.h"
+#import "MLRNImageQueueOperation.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNImageQueue {
+  NSOperationQueue *imageQueue;
+}
+
+- (id)init {
+  if (self = [super init]) {
+    imageQueue = [[NSOperationQueue alloc] init];
+    imageQueue.name = @"org.maplibre.reactnative.DownloadImageQueue";
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self cancelAllOperations];
+}
+
++ (instancetype)sharedInstance {
+  static MLRNImageQueue *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[MLRNImageQueue alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (void)cancelAllOperations {
+  [imageQueue cancelAllOperations];
+}
+
+- (void)addImage:(NSString *)imageURL
+                scale:(double)scale
+                  sdf:(Boolean)sdf
+               bridge:(RCTBridge *)bridge
+    completionHandler:(RCTImageLoaderCompletionBlock)handler {
+  MLRNImageQueueOperation *operation = [[MLRNImageQueueOperation alloc] init];
+  operation.bridge = bridge;
+  operation.urlRequest = [RCTConvert NSURLRequest:imageURL];
+  operation.sdf = sdf;
+  operation.completionHandler = handler;
+  operation.scale = scale;
+  [imageQueue addOperation:operation];
+}
+
+@end

package/ios/components/images/MLRNImageQueueOperation.h

@@ -0,0 +1,11 @@
+#import <React/RCTImageLoader.h>
+
+@interface MLRNImageQueueOperation : NSBlockOperation
+
+@property (nonatomic, weak) RCTBridge *bridge;
+@property (nonatomic, copy) RCTImageLoaderCompletionBlock completionHandler;
+@property (nonatomic, copy) NSURLRequest *urlRequest;
+@property (nonatomic) Boolean sdf;
+@property (nonatomic) double scale;
+
+@end

package/ios/components/images/MLRNImageQueueOperation.m

@@ -0,0 +1,133 @@
+#import "MLRNImageQueueOperation.h"
+
+typedef NS_ENUM(NSInteger, MLRNImageQueueOperationState) {
+  IOState_Initial,
+  IOState_CancelledDoNotExecute,
+  IOState_Executing,  // cancellationBlock is set
+  IOState_Finished,
+
+  /* Not sates, just selectors for only and except params */
+  IOState_Filter_None,
+  IOState_Filter_All,
+};
+
+@interface MLRNImageQueueOperation ()
+@property (nonatomic) MLRNImageQueueOperationState state;
+@end
+
+@implementation MLRNImageQueueOperation {
+  RCTImageLoaderCancellationBlock _cancellationBlock;
+  BOOL _cancelled;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _state = IOState_Initial;
+    _cancelled = false;
+  }
+  return self;
+}
+
+- (BOOL)isExecuting {
+  @synchronized(self) {
+    return self.state == IOState_Executing;
+  }
+}
+
+- (BOOL)isFinished {
+  @synchronized(self) {
+    return (self.state == IOState_Finished || self.state == IOState_CancelledDoNotExecute);
+  }
+}
+
+- (BOOL)isCancelled {
+  @synchronized(self) {
+    return self.state == IOState_CancelledDoNotExecute;
+  }
+}
+
+- (void)setCancellationBlock:(dispatch_block_t)block {
+  _cancellationBlock = block;
+}
+
+- (void)callCancellationBlock {
+  if (_cancellationBlock) {
+    _cancellationBlock();
+  }
+}
+
+- (MLRNImageQueueOperationState)setState:(MLRNImageQueueOperationState)newState
+                                    only:(MLRNImageQueueOperationState)only
+                                  except:(MLRNImageQueueOperationState)except {
+  MLRNImageQueueOperationState prevState = IOState_Filter_None;
+  [self willChangeValueForKey:@"isExecuting"];
+  [self willChangeValueForKey:@"isFinished"];
+  [self willChangeValueForKey:@"isCancelled"];
+
+  @synchronized(self) {
+    BOOL allowed = YES;
+    prevState = self.state;
+    if (!(only == IOState_Filter_All || prevState == only)) {
+      allowed = NO;
+    }
+    if (prevState == except) {
+      allowed = NO;
+    }
+    if (allowed) {
+      self.state = newState;
+    }
+  }
+  [self didChangeValueForKey:@"isExecuting"];
+  [self didChangeValueForKey:@"isFinished"];
+  [self didChangeValueForKey:@"isCancelled"];
+  return prevState;
+}
+
+- (MLRNImageQueueOperationState)setState:(MLRNImageQueueOperationState)newState
+                                    only:(MLRNImageQueueOperationState)only {
+  return [self setState:newState only:only except:IOState_Filter_None];
+}
+
+- (MLRNImageQueueOperationState)setState:(MLRNImageQueueOperationState)newState
+                                  except:(MLRNImageQueueOperationState)except {
+  return [self setState:newState only:IOState_Filter_All except:except];
+}
+
+- (void)start {
+  if (self.state == IOState_CancelledDoNotExecute) {
+    return;
+  }
+  __weak MLRNImageQueueOperation *weakSelf = self;
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [weakSelf setCancellationBlock:
+                  [[weakSelf.bridge moduleForName:@"ImageLoader" lazilyLoadIfNecessary:YES]
+                      loadImageWithURLRequest:weakSelf.urlRequest
+                                         size:CGSizeZero
+                                        scale:weakSelf.scale
+                                      clipped:YES
+                                   resizeMode:RCTResizeModeStretch
+                                progressBlock:nil
+                             partialLoadBlock:nil
+                              completionBlock:^void(NSError *error, UIImage *image) {
+                                if (image && weakSelf.sdf) {
+                                  image = [image
+                                      imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
+                                }
+                                weakSelf.completionHandler(error, image);
+                                [weakSelf setState:IOState_Finished except:IOState_Finished];
+                              }]];
+    if ([weakSelf setState:IOState_Executing
+                      only:IOState_Initial] == IOState_CancelledDoNotExecute) {
+      [weakSelf callCancellationBlock];
+    }
+  });
+}
+
+- (void)cancel {
+  if ([self setState:IOState_CancelledDoNotExecute except:IOState_Finished] == IOState_Executing) {
+    [self callCancellationBlock];
+  }
+}
+
+@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