@mapvina-com/mapvina-react-native 1.0.0

package/ios/components/camera/MLRNCameraComponentView.mm

@@ -0,0 +1,201 @@
+#import "MLRNCameraComponentView.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 <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]) {
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self prepareView];
+}
+
+- (void)prepareView {
+  static const auto defaultProps = std::make_shared<const MLRNCameraProps>();
+
+  _props = defaultProps;
+
+  _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) {
+      NSString *trackUserLocation = event[@"trackUserLocation"];
+
+      facebook::react::MLRNCameraEventEmitter::OnTrackUserLocationChange eventStruct{
+          [trackUserLocation isKindOfClass:[NSString class]]
+              ? folly::dynamic([trackUserLocation UTF8String])
+              : folly::dynamic(nullptr),
+      };
+      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.center.size() == 2) {
+      initialViewState[@"center"] = @[
+        @(newViewProps.initialViewState.center[0]), @(newViewProps.initialViewState.center[1])
+      ];
+    } 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.center != newViewProps.stop.center ||
+
+      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.center.size() == 2) {
+      stop[@"center"] = @[ @(newViewProps.stop.center[0]), @(newViewProps.stop.center[1]) ];
+    } 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 <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+@interface MLRNCameraModule : NSObject <NativeCameraModuleSpec>
+@end

package/ios/components/camera/MLRNCameraModule.mm

@@ -0,0 +1,101 @@
+#import "MLRNCameraModule.h"
+
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+#import "MLRNCameraComponentView.h"
+#import "MLRNCameraManager.h"
+#import "MLRNViewModuleUtils.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 {
+  [MLRNViewModuleUtils withView:self.viewRegistry_DEPRECATED
+                       reactTag:reactTag
+             componentViewClass:[MLRNCameraComponentView class]
+               contentViewClass:[MLRNCamera class]
+                          block:^(UIView *view) {
+                            block((MLRNCamera *)view);
+                          }
+                         reject:reject
+                     methodName:methodName];
+}
+
+- (void)setStop:(NSInteger)reactTag
+           stop:(JS::NativeCameraModule::NativeCameraStop &)stop
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary<NSString *, id> *stopDict = [NSMutableDictionary dictionary];
+
+  if (stop.center().has_value() && stop.center().value().size() == 2) {
+    NSArray<NSNumber *> *center = @[ @(stop.center().value()[0]), @(stop.center().value()[1]) ];
+    stopDict[@"center"] = center;
+  } 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/MLRNImageLoader.h

@@ -0,0 +1,27 @@
+#import <MapVina/MapVina.h>
+#import <React/RCTImageLoaderProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Singleton that exposes the image loader obtained from the TurboModule registry.
+ */
+@interface MLRNImageLoader : NSObject
+
++ (instancetype)sharedInstance;
+
+@property (nonatomic, strong, nullable) id<RCTImageLoaderProtocol> imageLoader;
+
++ (void)fetchImage:(NSString *)url
+             scale:(double)scale
+               sdf:(BOOL)sdf
+          callback:(RCTImageLoaderCompletionBlock)callback;
+
++ (void)fetchImages:(MLNStyle *)style
+            objects:(NSDictionary<NSString *, id> *)objects
+        forceUpdate:(BOOL)forceUpdate
+           callback:(void (^)(void))callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/components/images/MLRNImageLoader.m

@@ -0,0 +1,85 @@
+#import "MLRNImageLoader.h"
+#import "MLRNImageQueue.h"
+
+#import <React/RCTLog.h>
+
+@implementation MLRNImageLoader
+
++ (instancetype)sharedInstance {
+  static MLRNImageLoader *_instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _instance = [[MLRNImageLoader alloc] init];
+  });
+  return _instance;
+}
+
++ (void)fetchImage:(NSString *)url
+             scale:(double)scale
+               sdf:(BOOL)sdf
+          callback:(RCTImageLoaderCompletionBlock)callback {
+  [MLRNImageQueue.sharedInstance addImage:url
+                                    scale:scale
+                                      sdf:sdf
+                              imageLoader:[MLRNImageLoader sharedInstance].imageLoader
+                        completionHandler:callback];
+}
+
++ (void)fetchImages:(MLNStyle *)style
+            objects:(NSDictionary<NSString *, id> *)objects
+        forceUpdate:(BOOL)forceUpdate
+           callback:(void (^)(void))callback {
+  if (objects == nil) {
+    callback();
+    return;
+  }
+
+  NSArray<NSString *> *imageNames = objects.allKeys;
+  if (imageNames.count == 0) {
+    callback();
+    return;
+  }
+
+  __block NSUInteger imagesLeftToLoad = imageNames.count;
+  __weak MLNStyle *weakStyle = style;
+
+  void (^imageLoadedBlock)(void) = ^{
+    imagesLeftToLoad--;
+
+    if (imagesLeftToLoad == 0) {
+      callback();
+    }
+  };
+
+  for (NSString *imageName in imageNames) {
+    UIImage *foundImage = forceUpdate ? nil : [style imageForName:imageName];
+
+    if (forceUpdate || foundImage == nil) {
+      NSDictionary *image = objects[imageName];
+      BOOL hasScale =
+          [image isKindOfClass:[NSDictionary class]] && ([image objectForKey:@"scale"] != nil);
+      BOOL hasSdf =
+          [image isKindOfClass:[NSDictionary class]] && ([image objectForKey:@"sdf"] != nil);
+      double scale = hasScale ? [[image objectForKey:@"scale"] doubleValue] : 1.0;
+      BOOL sdf = hasSdf ? [[image objectForKey:@"sdf"] boolValue] : NO;
+      [MLRNImageQueue.sharedInstance addImage:objects[imageName]
+                                        scale:scale
+                                          sdf:sdf
+                                  imageLoader:[MLRNImageLoader sharedInstance].imageLoader
+                            completionHandler:^(NSError *error, UIImage *img) {
+                              if (!img) {
+                                RCTLogWarn(@"Failed to fetch image: %@ error:%@", imageName, error);
+                              } else {
+                                dispatch_async(dispatch_get_main_queue(), ^{
+                                  [weakStyle setImage:img forName:imageName];
+                                  imageLoadedBlock();
+                                });
+                              }
+                            }];
+    } else {
+      imageLoadedBlock();
+    }
+  }
+}
+
+@end

package/ios/components/images/MLRNImageQueue.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTImageLoaderProtocol.h>
+
+@interface MLRNImageQueue : NSObject
+
++ (instancetype)sharedInstance;
+
+- (void)cancelAllOperations;
+- (void)addImage:(NSString *)imageURL
+                scale:(double)scale
+                  sdf:(Boolean)sdf
+          imageLoader:(id<RCTImageLoaderProtocol>)imageLoader
+    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 = @"io.github.mapvina.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
+          imageLoader:(id<RCTImageLoaderProtocol>)imageLoader
+    completionHandler:(RCTImageLoaderCompletionBlock)handler {
+  MLRNImageQueueOperation *operation = [[MLRNImageQueueOperation alloc] init];
+  operation.imageLoader = imageLoader;
+  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/RCTImageLoaderProtocol.h>
+
+@interface MLRNImageQueueOperation : NSBlockOperation
+
+@property (nonatomic, weak) id<RCTImageLoaderProtocol> imageLoader;
+@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,138 @@
+#import "MLRNImageQueueOperation.h"
+
+#import <React/RCTImageLoader.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.imageLoader loadImageWithURLRequest:weakSelf.urlRequest
+                                 size:CGSizeZero
+                                 scale:weakSelf.scale
+                                 clipped:YES
+                                 resizeMode:RCTResizeModeStretch
+                                 progressBlock:^(int64_t progress, int64_t total) {
+                                   // No-op
+                                 }
+                                 partialLoadBlock:^(UIImage *image) {
+                                   // No-op
+                                 }
+                                 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,26 @@
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+
+#import <MapVina/MapVina.h>
+
+@class MLRNMapView;
+
+@interface MLRNImages : UIView
+
+@property (nonatomic, strong) MLRNMapView *_Nullable map;
+@property (nonatomic, strong, nonnull) NSMutableArray<id<RCTComponent>> *reactSubviews;
+
+@property (nonatomic, strong, nonnull) NSDictionary *images;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onImageMissing;
+
+- (void)addToMap;
+- (void)removeFromMap;
+
+- (BOOL)addMissingImageToStyle:(NSString *_Nonnull)imageName;
+- (void)sendImageMissingEvent:(NSString *_Nonnull)imageName;
+
+- (void)insertReactSubview:(id<RCTComponent> _Nullable)subview atIndex:(NSInteger)atIndex;
+- (void)removeReactSubview:(id<RCTComponent> _Nullable)subview;
+
+@end