@maplibre/maplibre-react-native 11.0.0-alpha.2 → 11.0.0-alpha.20

package/ios/components/camera/CameraStop.m

@@ -0,0 +1,75 @@
+#import "CameraStop.h"
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+#import "MLRNUtils.h"
+
+@implementation CameraStop
+
+- (void)setEasing:(NSNumber *)easing {
+  NSInteger value = easing ? easing.integerValue : (NSInteger)MLRNCameraEasingNone;
+  switch (value) {
+    case MLRNCameraEasingNone:
+    case MLRNCameraEasingLinear:
+    case MLRNCameraEasingEase:
+    case MLRNCameraEasingFly:
+      _easing = @(value);
+      break;
+    default:
+      _easing = @(MLRNCameraEasingNone);
+      break;
+  }
+}
+
+- (id)init {
+  if (self = [super init]) {
+    self.center = kCLLocationCoordinate2DInvalid;
+    self.bounds =
+        MLNCoordinateBoundsMake(kCLLocationCoordinate2DInvalid, kCLLocationCoordinate2DInvalid);
+  }
+
+  return self;
+}
+
++ (CameraStop *)fromDictionary:(NSDictionary *)args {
+  CameraStop *stop = [[CameraStop alloc] init];
+
+  if (args[@"longitude"] && args[@"latitude"]) {
+    stop.center = [MLRNUtils fromLongitude:args[@"longitude"] latitude:args[@"latitude"]];
+  }
+
+  if (args[@"zoom"]) {
+    stop.zoom = args[@"zoom"];
+  }
+
+  if (args[@"bearing"]) {
+    stop.bearing = args[@"bearing"];
+  }
+
+  if (args[@"pitch"]) {
+    stop.pitch = args[@"pitch"];
+  }
+
+  if (args[@"bounds"]) {
+    stop.bounds = [MLRNUtils fromReactBounds:args[@"bounds"]];
+  }
+
+  NSDictionary *padding = args[@"padding"];
+  stop.padding =
+      padding ? UIEdgeInsetsMake([padding[@"top"] floatValue], [padding[@"left"] floatValue],
+                                 [padding[@"bottom"] floatValue], [padding[@"right"] floatValue])
+              : UIEdgeInsetsZero;
+
+  NSTimeInterval duration = 0;
+  if (args[@"duration"]) {
+    duration = [MLRNUtils fromMS:args[@"duration"]];
+  }
+  stop.duration = duration;
+
+  if (args[@"easing"]) {
+    stop.easing = @([args[@"easing"] integerValue]);
+  }
+
+  return stop;
+}
+
+@end

package/ios/components/camera/CameraUpdateItem.m

@@ -0,0 +1,167 @@
+#import "CameraUpdateItem.h"
+#import "CameraEasing.h"
+
+@interface MLRNCameraWithPadding : MLNMapCamera
+
+@property (nonatomic) MLNMapCamera *_Nonnull camera;
+@property (nonatomic) UIEdgeInsets boundsPadding;
+
+@end
+
+@implementation MLRNCameraWithPadding
+
+@end
+
+@implementation CameraUpdateItem
+
+- (void)execute:(MLRNMapView *)mapView withCompletionHandler:(void (^)(void))completionHandler {
+  NSInteger easing = [_cameraStop.easing integerValue];
+
+  switch (easing) {
+    case MLRNCameraEasingLinear:
+      [self _moveCamera:mapView animated:YES ease:NO withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingEase:
+      [self _moveCamera:mapView animated:YES ease:YES withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingFly:
+      [self _flyToCamera:mapView withCompletionHandler:completionHandler];
+      break;
+    case MLRNCameraEasingNone:
+    default:
+      [self _moveCamera:mapView animated:NO ease:NO withCompletionHandler:completionHandler];
+      break;
+  }
+}
+
+- (void)_flyToCamera:(MLRNMapView *)mapView
+    withCompletionHandler:(void (^)(void))completionHandler {
+  MLRNCameraWithPadding *nextCamera = [self _makeCamera:mapView];
+
+  [mapView flyToCamera:nextCamera.camera
+            edgePadding:nextCamera.boundsPadding
+           withDuration:_cameraStop.duration
+      completionHandler:completionHandler];
+}
+
+- (void)_moveCamera:(MLRNMapView *)mapView
+                 animated:(BOOL)animated
+                     ease:(BOOL)ease
+    withCompletionHandler:(void (^)(void))completionHandler {
+  MLRNCameraWithPadding *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];
+}
+
+- (MLRNCameraWithPadding *)_makeCamera:(MLRNMapView *)mapView {
+  MLNMapCamera *nextCamera = [mapView.camera copy];
+
+  UIEdgeInsets padding = [self _clippedPadding:_cameraStop.padding forView:mapView];
+  if (padding.top <= 0 && padding.bottom <= 0) {
+    // TODO: Report Bug
+    // 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 _isCenterValid:_cameraStop.center]) {
+    MLNCoordinateBounds boundsFromCoord = {.sw = _cameraStop.center, .ne = _cameraStop.center};
+    MLNMapCamera *boundsCamera = [mapView camera:nextCamera
+                         fittingCoordinateBounds:boundsFromCoord
+                                     edgePadding:padding];
+    nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+  } else if ([self _areBoundsValid:_cameraStop.bounds]) {
+    MLNMapCamera *boundsCamera = [mapView camera:nextCamera
+                         fittingCoordinateBounds:_cameraStop.bounds
+                                     edgePadding:padding];
+    nextCamera.centerCoordinate = boundsCamera.centerCoordinate;
+    nextCamera.altitude = boundsCamera.altitude;
+    hasSetAltitude = true;
+  }
+
+  if (_cameraStop.bearing != nil) {
+    nextCamera.heading = [_cameraStop.bearing floatValue];
+  }
+
+  if (_cameraStop.zoom != nil && hasSetAltitude == false) {
+    nextCamera.altitude = [mapView altitudeFromZoom:[_cameraStop.zoom doubleValue]
+                                         atLatitude:nextCamera.centerCoordinate.latitude
+                                            atPitch:nextCamera.pitch];
+  }
+
+  if (_cameraStop.pitch != nil) {
+    nextCamera.pitch = [_cameraStop.pitch floatValue];
+  }
+
+  MLRNCameraWithPadding *cameraWithPadding = [[MLRNCameraWithPadding alloc] init];
+  cameraWithPadding.camera = nextCamera;
+  cameraWithPadding.boundsPadding = padding;
+
+  return cameraWithPadding;
+}
+
+- (UIEdgeInsets)_clippedPadding:(UIEdgeInsets)padding forView:(MLRNMapView *)mapView {
+  UIEdgeInsets result = padding;
+
+  double width = mapView.frame.size.width;
+  double height = mapView.frame.size.height;
+
+  if ((padding.top + padding.bottom) >= height) {
+    double totalPadding = padding.top + padding.bottom;
+    double extra = totalPadding - height + 1.0;
+    result.top -= (padding.top * extra) / totalPadding;
+    result.bottom -= (padding.bottom * extra) / totalPadding;
+  }
+
+  if ((padding.left + padding.right) >= width) {
+    double totalPadding = padding.left + padding.right;
+    double extra = totalPadding - width + 1.0;
+    result.left -= (padding.left * extra) / totalPadding;
+    result.right -= (padding.right * extra) / totalPadding;
+  }
+
+  return result;
+}
+
+- (BOOL)_areBoundsValid:(MLNCoordinateBounds)bounds {
+  if ([self _isLatitudeValid:bounds.ne.latitude] && [self _isLatitudeValid:bounds.sw.latitude]) {
+    return YES;
+  }
+
+  return NO;
+}
+
+- (BOOL)_isLatitudeValid:(CLLocationDegrees)latitude {
+  return latitude >= -90 && latitude <= 90;
+}
+
+- (BOOL)_isCenterValid:(CLLocationCoordinate2D)coord {
+  BOOL isValid = CLLocationCoordinate2DIsValid(coord);
+
+  if (!isValid) {
+    return NO;
+  }
+
+  return YES;
+}
+
+- (BOOL)_hasCenterAndZoom {
+  BOOL isValid = CLLocationCoordinate2DIsValid(_cameraStop.center) && _cameraStop.zoom != nil;
+
+  if (!isValid) {
+    return NO;
+  }
+
+  return [self _isCenterValid:_cameraStop.center];
+}
+
+@end

package/ios/components/camera/MLRNCamera.h

@@ -0,0 +1,26 @@
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+#import "MLRNMapView.h"
+
+@class MLRNMapView;
+
+@interface MLRNCamera : UIView <MLRNMapViewCamera>
+
+@property (nonatomic, strong) MLRNMapView *map;
+
+@property (nonatomic, strong) NSDictionary<NSString *, id> *stop;
+
+@property (nonatomic, strong) NSDictionary<NSString *, id> *initialViewState;
+
+@property (nonatomic, copy) NSNumber *minZoom;
+@property (nonatomic, copy) NSNumber *maxZoom;
+@property (nonatomic, copy) NSArray<NSNumber *> *maxBounds;
+
+@property (nonatomic, copy) NSString *trackUserLocation;
+
+@property (nonatomic, copy) RCTDirectEventBlock onTrackUserLocationChange;
+
+- (void)handleImperativeStop:(NSDictionary<NSString *, id> *)stop;
+- (void)updateCamera;
+
+@end

package/ios/components/camera/MLRNCamera.m

@@ -0,0 +1,195 @@
+#import "MLRNCamera.h"
+#import "CameraEasing.h"
+#import "CameraStop.h"
+#import "CameraUpdateQueue.h"
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNLocation.h"
+#import "MLRNLocationManager.h"
+#import "MLRNUtils.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)setMap:(MLRNMapView *)map {
+  if (_map != nil) {
+    _map.reactCamera = nil;
+  }
+  _map = map;
+  _map.reactCamera = self;
+
+  // [self _setInitialCamera];
+  [self _updateMinMaxZoom];
+  [self _updateMaxBounds];
+  // [self updateCamera];
+}
+
+- (void)setStop:(NSDictionary<NSString *, id> *)stop {
+  _stop = stop;
+}
+
+- (void)setMinZoom:(NSNumber *)minZoom {
+  _minZoom = minZoom;
+
+  [self _updateMinMaxZoom];
+}
+
+- (void)setMaxZoom:(NSNumber *)maxZoom {
+  _maxZoom = maxZoom;
+
+  [self _updateMinMaxZoom];
+}
+
+- (void)setMaxBounds:(NSArray<NSNumber *> *)maxBounds {
+  _maxBounds = maxBounds;
+
+  [self _updateMaxBounds];
+}
+
+- (void)setTrackUserLocation:(NSString *)trackUserLocation {
+  _trackUserLocation = trackUserLocation;
+}
+
+- (void)handleImperativeStop:(NSDictionary<NSString *, id> *)stop {
+  if (_map != nil) {
+    [cameraUpdateQueue enqueue:[CameraStop fromDictionary:stop]];
+    [cameraUpdateQueue execute:_map];
+  }
+}
+
+- (void)updateCamera {
+  if (_map != nil) {
+    if ([self _userTrackingMode] == MLNUserTrackingModeNone) {
+      [self _updateCameraFromStop];
+    } else {
+      [self _updateCameraFromTrackUserLocation];
+    }
+  }
+}
+
+- (void)_updateCameraFromStop {
+  if (_map.userTrackingMode != MLNUserTrackingModeNone) {
+    _map.userTrackingMode = MLNUserTrackingModeNone;
+  }
+
+  if (_stop != nil) {
+    [cameraUpdateQueue enqueue:[CameraStop fromDictionary:_stop]];
+    [cameraUpdateQueue execute:_map];
+  }
+}
+
+- (void)_updateCameraFromTrackUserLocation {
+  MLNMapCamera *camera = _map.camera;
+
+  if (_stop != nil) {
+    if (_stop[@"zoom"] != nil) {
+      camera.altitude = [_map altitudeFromZoom:[_stop[@"zoom"] floatValue]];
+    }
+
+    if ([self _userTrackingMode] != MLNUserTrackingModeFollowWithCourse &&
+        [self _userTrackingMode] != MLNUserTrackingModeFollowWithHeading) {
+      if (_stop[@"bearing"] != nil) {
+        camera.heading = [_stop[@"bearing"] floatValue];
+      }
+    }
+
+    if (_stop[@"pitch"] != nil) {
+      camera.pitch = [_stop[@"pitch"] floatValue];
+    }
+  }
+
+  [_map setCamera:camera animated:NO];
+
+  if (_map.userTrackingMode != [self _userTrackingMode]) {
+    _map.userTrackingMode = [self _userTrackingMode];
+  }
+}
+
+- (void)_setInitialCamera {
+  if (!_initialViewState) {
+    return;
+  }
+
+  CameraStop *stop = [CameraStop fromDictionary:_initialViewState];
+  stop.duration = 0;
+  stop.easing = @(MLRNCameraEasingNone);
+  CameraUpdateItem *item = [[CameraUpdateItem alloc] init];
+  item.cameraStop = stop;
+  [item execute:_map
+      withCompletionHandler:^{
+      }];
+}
+
+- (void)_updateMinMaxZoom {
+  if (_map != nil) {
+    if (_maxZoom) {
+      _map.maximumZoomLevel = [_maxZoom doubleValue];
+    }
+    if (_minZoom) {
+      _map.minimumZoomLevel = [_minZoom doubleValue];
+    }
+  }
+}
+
+- (void)_updateMaxBounds {
+  if (_map != nil) {
+    if (_maxBounds) {
+      _map.maxBounds = [MLRNUtils fromReactBounds:_maxBounds];
+    }
+  }
+}
+
+- (MLNUserTrackingMode)_userTrackingMode {
+  if ([_trackUserLocation isEqualToString:@"default"]) {
+    return MLNUserTrackingModeFollow;
+  } else if ([_trackUserLocation isEqualToString:@"heading"]) {
+    return MLNUserTrackingModeFollowWithHeading;
+  } else if ([_trackUserLocation isEqualToString:@"course"]) {
+    return MLNUserTrackingModeFollowWithCourse;
+  } else {
+    return MLNUserTrackingModeNone;
+  }
+}
+
+- (id)_trackingModeToString:(MLNUserTrackingMode)mode {
+  switch (mode) {
+    case MLNUserTrackingModeFollow:
+      return @"default";
+    case MLNUserTrackingModeFollowWithHeading:
+      return @"heading";
+    case MLNUserTrackingModeFollowWithCourse:
+      return @"course";
+    case MLNUserTrackingModeNone:
+      return [NSNull null];
+  }
+}
+
+- (void)initialLayout {
+  [self _setInitialCamera];
+  [self updateCamera];
+}
+
+- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated {
+  NSDictionary *payload = @{
+    @"trackUserLocation" : [self _trackingModeToString:mode],
+  };
+
+  self.onTrackUserLocationChange(payload);
+}
+
+@end

package/ios/components/camera/MLRNCameraComponentView.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNCameraComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/components/camera/MLRNCameraComponentView.mm

@@ -0,0 +1,196 @@
+#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) {
+      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.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