@rnmapbox/maps 10.1.0-beta.9 → 10.1.0-rc.0

package/ios/RNMBX/RNMBXViewport.swift

@@ -0,0 +1,349 @@
+@_spi(Experimental) import MapboxMaps
+
+#if RNMBX_11
+#else
+typealias ViewportManager = Viewport
+#endif
+
+@objc(RNMBXViewport)
+open class RNMBXViewport : UIView, RNMBXMapComponent, ViewportStatusObserver {
+  var mapView: MapView? = nil
+    
+  // MARK: React properties
+  @objc
+  public var onStatusChanged: RCTBubblingEventBlock? = nil
+  
+  @objc
+  public var hasStatusChanged: Bool = false {
+    didSet {
+      if let mapView = mapView {
+        applyHasStatusChanged(mapView: mapView)
+      }
+    }
+  }
+  
+  func applyHasStatusChanged(mapView: MapView) {
+    if (hasStatusChanged) {
+      mapView.viewport.addStatusObserver(self)
+    } else {
+      mapView.viewport.removeStatusObserver(self)
+    }
+  }
+  
+  public func viewportStatusDidChange(from fromStatus: ViewportStatus,
+                               to toStatus: ViewportStatus,
+                               reason: ViewportStatusChangeReason)
+  {
+    onStatusChanged?([
+      "type": "statuschanged",
+      "payload": [
+        "from": statusToMap(fromStatus),
+        "to": statusToMap(toStatus),
+        "reason": reasonToString(reason)
+      ]])
+  }
+  
+  @objc
+  public var transitionsToIdleUponUserInteraction: NSNumber? = nil {
+    didSet {
+      if let mapView = mapView {
+        apply(mapView: mapView)
+      }
+    }
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    true
+  }
+
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    mapView = map.mapView
+    applyHasStatusChanged(mapView: mapView!)
+    apply(mapView: map.mapView)
+  }
+
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    if (hasStatusChanged) {
+      map.mapView.viewport.removeStatusObserver(self)
+    }
+    self.mapView = nil
+    return true
+  }
+
+  func apply(mapView: MapView) {
+    if let value = transitionsToIdleUponUserInteraction {
+      var origOptions = mapView.viewport.options
+      origOptions.transitionsToIdleUponUserInteraction = value.boolValue
+      mapView.viewport.options = origOptions
+    }
+  }
+  
+  func reasonToString(_ reason: ViewportStatusChangeReason) -> String {
+    switch (reason) {
+    case .idleRequested:
+      return "IdleRequested"
+    case .transitionFailed:
+      return "TransitionFailed"
+    case .transitionStarted:
+      return "TransitionStarted"
+    case .transitionSucceeded:
+      return "TransitionSucceeded"
+    case .userInteraction:
+      return "UserInteraction"
+    default:
+      return "Unknown:\(reason)"
+    }
+  }
+
+  func stateToMap(_ state: ViewportState) -> [String: Any] {
+    if let state = state as? FollowPuckViewportState {
+      return ["kind": "followPuck"]
+    } else if let state = state as? OverviewViewportState {
+      return ["kind": "overview"]
+    } else {
+      return ["kind": "custom", "impl": "\(type(of: state))"]
+    }
+  }
+  
+  func transitionToMap(_ transition: ViewportTransition) -> [String:Any] {
+    if let transition = transition as? DefaultViewportTransition {
+      return ["kind": "default", "maxDurationMs": transition.options.maxDuration * 1000.0] as [String:Any]
+    } else if let transition = transition as? ImmediateViewportTransition {
+      return ["kind": "immediate"]
+    } else {
+      return ["kind": "unknown", "impl": "\(type(of: transition))"]
+    }
+  }
+  
+  func statusToMap(_ status: ViewportStatus) -> [String: Any] {
+    switch (status) {
+    case .idle:
+      return ["kind": "idle"]
+    case .state(let state):
+      return ["kind": "state",
+       "state": stateToMap(state)
+      ] as [String : Any]
+    case .transition(let transition, let toState):
+      return ["kind": "transition",
+       "transition": transitionToMap(transition),
+       "toState": stateToMap(toState)
+      ] as [String:Any]
+    }
+  }
+  
+  func getState() -> [String:Any] {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.getState")
+      return [:]
+    }
+    return statusToMap(mapView.viewport.status)
+  }
+  
+  func idle() {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.idle")
+      return
+    }
+    mapView.viewport.idle()
+  }
+  
+  func toState(_ viewport: ViewportManager?,_ state: [String:Any]) -> ViewportState? {
+    guard let viewport = viewport else {
+      Logger.log(level:.error, message: "no viewport")
+      return nil
+    }
+    guard let kind = state["kind"] as? String else {
+      Logger.log(level:.error, message: "no kind found in state")
+      return nil
+    }
+    
+    switch (kind) {
+    case "followPuck":
+      return viewport.makeFollowPuckViewportState(options:
+        parseFollowViewportOptions(state)
+      )
+    case "overview":
+      if let options = parseOverviewViewportOptions(state) {
+        return viewport.makeOverviewViewportState(options: options)
+      } else {
+        Logger.log(level:.error, message: "Cannot parse overview options")
+        return nil
+      }
+    default:
+      Logger.log(level:.error, message: "unexpected state kind: \(kind)")
+      return nil
+    }
+  }
+  
+  func parseFollowViewportOptions(_ state: [String:Any]) -> FollowPuckViewportStateOptions {
+    var result = FollowPuckViewportStateOptions()
+    if let options = state["options"] as? [String:Any] {
+      if let zoom = options["zoom"] as? String, (zoom == "keep") {
+        result.zoom = nil
+      } else if let zoom = options["zoom"] as? Double {
+        result.zoom = zoom
+      } else if options["zoom"] != nil {
+        Logger.log(level: .error, message: "parseFollowViewportOptions expected zoom to be number or 'keep', but was \(options["zoom"])")
+      }
+      
+      if let pitch = options["pitch"] as? String, (pitch == "keep") {
+        result.pitch = nil
+      } else if let pitch = options["pitch"] as? Double {
+        result.pitch = pitch
+      } else if options["pitch"] != nil{
+        Logger.log(level: .error, message: "parseFollowViewportOptions expected pitch to be number or 'keep', but was \(options["pitch"])")
+      }
+      
+      if let bearing = options["bearing"] as? String {
+        switch (bearing) {
+        case "keep":
+          result.bearing = nil
+        case "course":
+          result.bearing = .course
+        case "heading":
+          result.bearing = .heading
+        default:
+          Logger.log(level: .error, message: "bearing expected to be a number or 'keep' or 'course' or 'heading', but was \(options["bearing"])")
+        }
+      } else if let bearing = options["bearing"] as? NSNumber {
+        result.bearing = .constant(bearing.doubleValue)
+      } else if options["bearing"] != nil {
+        Logger.log(level: .error, message: "bearing expected to be a number or 'keep' or 'course' or 'heading', but was \(options["bearing"])")
+      }
+      
+      if let padding = options["padding"] as? String, (padding == "keep") {
+        result.padding = nil
+      } else if let padding = options["padding"] as? [String: NSNumber] {
+        result.padding = toPadding(padding)
+      } else if (options["padding"] != nil) {
+        Logger.log(level: .error, message: "padding expected to be an object or 'keep' or but was \(options["bearing"])")
+      }
+    }
+    
+    return result
+  }
+  
+  func parseOverviewViewportOptions(_ state: [String:Any]) -> OverviewViewportStateOptions? {
+    guard let options = state["options"] as? [String:Any] else {
+      return nil
+    }
+    guard let geometry = options["geometry"], let geometry = toGeometry(geometry) else {
+      return nil
+    }
+
+    var result = OverviewViewportStateOptions(geometry: geometry)
+
+    if let padding = options["padding"] as? [String: NSNumber] {
+      result.padding = toPadding(padding)
+    } else if (options["padding"] != nil) {
+      Logger.log(level: .error, message: "padding expected to be an object or nil or but was \(options["padding"])")
+    }
+
+    if options["bearing"] == nil {
+      result.bearing = (CLLocationDirection?)(nil)
+    } else if let bearing = options["bearing"] as? NSNumber {
+      result.bearing = bearing.doubleValue
+    } else if options["bearing"] != nil {
+      Logger.log(level: .error, message: "bearing expected to be a number or nil but was \(options["bearing"])")
+    }
+
+    if options["pitch"] == nil {
+      result.pitch = (CGFloat?)(nil)
+    } else if let pitch = options["pitch"] as? Double {
+      result.pitch = pitch
+    } else if options["pitch"] != nil{
+      Logger.log(level: .error, message: "parseOverviewViewportOptions expected pitch to be number or nil, but was \(options["pitch"])")
+    }
+
+    if let animationDuration = options["animationDuration"] as? Double {
+      result.animationDuration = animationDuration
+    } else if let animationDuration = options["animationDuration"] as? NSNumber {
+      result.animationDuration = animationDuration.doubleValue
+    } else if options["animationDuration"] != nil {
+      Logger.log(level: .error, message: "parseOverviewViewportOptions expected animationDuration to be a number or nil but was \(options["animationDuration"])")
+    }
+
+    return result
+  }
+  
+  func toGeometry(_ geometry: Any) -> GeometryConvertible? {
+    return logged("toGeometry") {
+      let jsonData = try JSONSerialization.data(withJSONObject: geometry)
+      let geometry = try JSONDecoder().decode(Geometry.self, from: jsonData)
+      return geometry
+    }
+  }
+  
+  func toTransition(_ from: [String: Any], _ viewport: ViewportManager?) -> ViewportTransition? {
+    guard let viewport = viewport else {
+      Logger.log(level:.error, message: "no viewport")
+      return nil
+    }
+    guard let kind = from["kind"] as? String else {
+      Logger.log(level:.error, message: "no kind found in state")
+      return nil
+    }
+    
+    switch (kind) {
+    case "immediate":
+      return viewport.makeImmediateViewportTransition()
+    case "default":
+      var options = DefaultViewportTransitionOptions()
+      if let maxDurationMs = from["maxDurationMs"] as? NSNumber {
+        options.maxDuration = maxDurationMs.doubleValue/1000.0
+      }
+      return viewport.makeDefaultViewportTransition(
+        options: options
+      )
+        
+    default:
+      Logger.log(level:.error, message: "unexpected transition kind: \(kind)")
+      return nil
+    }
+  }
+  
+  func transitionTo(
+    state: [String: Any],
+    transition: [String: Any],
+    resolve: @escaping (NSNumber) -> Void
+  ) {
+    guard let mapView = mapView else {
+      Logger.log(level:.error, message: "mapView is null in RNMBXViewport.transitionTo")
+      return
+    }
+    guard let state = toState(mapView.viewport, state) else {
+      Logger.log(level:.error, message: "unable to parse toState in RNMBXViewport.transitionTo")
+      return
+    }
+    guard let transition = toTransition(transition, mapView.viewport) else {
+      Logger.log(level:.error, message: "unable to parse transition in RNMBXViewport.transitionTo")
+      return
+    }
+    mapView.viewport.transition(to: state, transition: transition) { completed in
+      resolve(NSNumber(booleanLiteral: completed))
+    }
+  }
+}
+
+
+func toPadding(_ value: [String: NSNumber]) -> UIEdgeInsets {
+  var result = UIEdgeInsets()
+  
+  if let top = value["top"] as? NSNumber {
+    result.top = top.CGFloat
+  }
+  
+  if let bottom = value["bottom"] as? NSNumber {
+    result.bottom = bottom.CGFloat
+  }
+  
+  if let left = value["left"] as? NSNumber {
+    result.left = left.CGFloat
+  }
+  
+  if let right = value["right"] as? NSNumber {
+    result.right = right.CGFloat
+  }
+  
+  return result
+}

package/ios/RNMBX/RNMBXViewportComponentView.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+@interface RNMBXViewportComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXViewportComponentView.mm

@@ -0,0 +1,119 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMBXViewportComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+
+#import "rnmapbox_maps-Swift.pre.h"
+
+#import "RCTFollyConvert.h"
+
+
+// TODO: use generated RNMBXViewportEventEmitter, but need 0.73+ for dynamic support
+class RNMBXViewportEventEmitter : public facebook::react::ViewEventEmitter {
+ public:
+  using facebook::react::ViewEventEmitter::ViewEventEmitter;
+
+  struct OnStatusChanged {
+    std::string type;
+    folly::dynamic payload;
+  };
+  void onStatusChanged(OnStatusChanged $event) const {
+    dispatchEvent("statusChanged", [$event=std::move($event)](facebook::jsi::Runtime &runtime) {
+      auto $payload = facebook::jsi::Object(runtime);
+      $payload.setProperty(runtime, "type", $event.type);
+      $payload.setProperty(runtime, "payload", facebook::jsi::valueFromDynamic(runtime, $event.payload));
+      return $payload;
+    });
+  }
+};
+
+using namespace facebook::react;
+
+NSNumber* convertDynamicToOptional_boolean(const folly::dynamic &dyn, NSString* propertyName) {
+  switch (dyn.type()) {
+    case folly::dynamic::NULLT:
+      return NULL;
+    case folly::dynamic::BOOL:
+      return [NSNumber numberWithBool:dyn.getBool()];
+    default:
+      std::stringstream ss;
+      ss << dyn;
+      [RNMBXLogger error:[NSString stringWithFormat:@"Property %@ expected to be a boolean or nil but was: $d",
+                          propertyName,
+                          ss.str().c_str()
+                         ]];
+  }
+}
+
+@implementation RNMBXViewportComponentView {
+    RNMBXViewport *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNMBXViewportProps>();
+    _props = defaultProps;
+    _view = [[RNMBXViewport alloc] init];
+    [self prepareView];
+    
+    self.contentView = _view;
+  }
+  
+  return self;
+}
+
+- (void)prepareView
+{
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setOnStatusChanged:^(NSDictionary* event) {
+    __typeof__(self) strongSelf = weakSelf;
+    
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      auto type = std::string([[event objectForKey:@"type"] UTF8String]);
+      auto payload = convertIdToFollyDynamic([event objectForKey:@"payload"]);
+      ::RNMBXViewportEventEmitter::OnStatusChanged event = {type, payload};
+      std::reinterpret_pointer_cast<const ::RNMBXViewportEventEmitter>(strongSelf->_eventEmitter)->onStatusChanged(event);
+    }
+  }];
+}
+
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNMBXViewportComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = static_cast<const RNMBXViewportProps &>(*oldProps);
+  const auto &newViewProps = static_cast<const RNMBXViewportProps &>(*props);
+
+  if (!oldProps.get() || oldViewProps.transitionsToIdleUponUserInteraction != newViewProps.transitionsToIdleUponUserInteraction) {
+    _view.transitionsToIdleUponUserInteraction = convertDynamicToOptional_boolean(newViewProps.transitionsToIdleUponUserInteraction, @"transitionsToIdleUponUserInteraction");
+  }
+  if (!oldProps.get() ||
+      oldViewProps.hasStatusChanged !=
+      newViewProps.hasStatusChanged) {
+    _view.hasStatusChanged = newViewProps.hasStatusChanged;
+  }
+  [super updateProps:props oldProps:oldProps];
+}
+@end
+
+Class<RCTComponentViewProtocol> RNMBXViewportCls(void)
+{
+  return RNMBXViewportComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXViewportManager.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXViewport, RNMBXViewportManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(transitionsToIdleUponUserInteraction, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(hasStatusChanged, BOOL)
+
+RCT_EXPORT_VIEW_PROPERTY(onStatusChanged, RCTBubblingEventBlock)
+
+@end

package/ios/RNMBX/RNMBXViewportManager.swift

@@ -0,0 +1,38 @@
+@objc(RNMBXViewportManager)
+public class RNMBXViewportManager : RCTViewManager {
+  @objc
+  public override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  public override func view() -> UIView! {
+    let layer = RNMBXViewport()
+    return layer
+  }
+  
+  @objc public static func getState(
+      _ view: RNMBXViewport,
+      resolve: @escaping RCTPromiseResolveBlock,
+      reject: @escaping RCTPromiseRejectBlock) {
+        resolve(view.getState())
+  }
+  
+  @objc public static func idle(
+    _ view: RNMBXViewport,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock) {
+      resolve(view.idle())
+    }
+      
+  @objc public static func transitionTo(
+    _ view: RNMBXViewport,
+    state: [String: Any],
+    transition: [String: Any],
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    view.transitionTo(state: state, transition: transition) { finished in
+      resolve(finished)
+    }
+  }
+}

package/ios/RNMBX/RNMBXViewportModule.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "rnmapbox_maps_specs.h"
+#else
+#import <React/RCTBridge.h>
+#endif
+
+@interface RNMBXViewportModule : NSObject
+#ifdef RCT_NEW_ARCH_ENABLED
+<NativeRNMBXViewportModuleSpec>
+#else
+<RCTBridgeModule>
+#endif
+
+@end
+

package/ios/RNMBX/RNMBXViewportModule.mm

@@ -0,0 +1,87 @@
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import "RNMBXViewportModule.h"
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNMBXViewportComponentView.h"
+#endif // RCT_NEW_ARCH_ENABLED
+
+#import "rnmapbox_maps-Swift.pre.h"
+
+@implementation RNMBXViewportModule
+
+RCT_EXPORT_MODULE();
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+#endif // RCT_NEW_ARCH_ENABLED
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+  // It seems that due to how UIBlocks work with uiManager, we need to call the methods there
+  // for the blocks to be dispatched before the batch is completed
+  return RCTGetUIManagerQueue();
+}
+
+// Thanks to this guard, we won't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeRNMBXViewportModuleSpecJSI>(params);
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (void)withViewport:(nonnull NSNumber*)viewRef block:(void (^)(RNMBXViewport *))block reject:(RCTPromiseRejectBlock)reject methodName:(NSString *)methodName
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+    [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+    RNMBXViewportComponentView *componentView = [self.viewRegistry_DEPRECATED viewForReactTag:viewRef];
+        RNMBXViewport *view = componentView.contentView;
+        
+#else
+    [self.bridge.uiManager
+     addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        RNMBXViewport *view = [uiManager viewForReactTag:viewRef];
+#endif // RCT_NEW_ARCH_ENABLED
+        if (view != nil) {
+           block(view);
+        } else {
+            reject(methodName, [NSString stringWithFormat:@"Unknown reactTag: %@", viewRef], nil);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(getState:(nonnull NSNumber *)viewRef
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject)
+{
+    [self withViewport:viewRef block:^(RNMBXViewport *view) {
+        [RNMBXViewportManager getState:view resolve:resolve reject:reject];
+    } reject:reject methodName:@"getState"];
+}
+     
+RCT_EXPORT_METHOD(idle:(nonnull NSNumber *)viewRef
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject)
+{
+   [self withViewport:viewRef block:^(RNMBXViewport *view) {
+       [RNMBXViewportManager idle:view resolve:resolve reject:reject];
+   } reject:reject methodName:@"idle"];
+}
+
+RCT_EXPORT_METHOD(transitionTo:(nonnull NSNumber *)viewRef
+                  state: (NSDictionary*)state
+                  transition: (NSDictionary*) transition
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  [self withViewport:viewRef block:^(RNMBXViewport *view) {
+      [RNMBXViewportManager transitionTo:view state:state transition:transition
+        resolve:resolve reject:reject];
+  } reject:reject methodName:@"idle"];
+}
+
+@end