@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

package/ios/RNMBX/RNMBXImageQueue.swift

@@ -0,0 +1,149 @@
+class RNMBXImageQueueOperation : Operation {
+  enum State : Equatable {
+    case Initial
+    case Executing
+    case Finished
+    case CancelDoNotExecute
+    case None
+    case All
+  }
+  
+  weak var bridge: RCTBridge? = nil
+  var completionHandler: ((Error?, UIImage?) -> Void)?
+  var cancellationBlock: RCTImageLoaderCancellationBlock?
+  var urlRequest : URLRequest! = nil
+  var scale:Double! = 1.0
+  
+  var state: State = .Initial
+  
+  func syncronized<T>(_ body: () throws -> T) rethrows ->  T {
+    objc_sync_enter(self)
+    defer { objc_sync_exit(self) }
+    return try body()
+  }
+  
+  func setState(state newState: State, only: State, except: State) -> State {
+    var prevState : State = .None;
+    self.willChangeValue(forKey: "isExecuting")
+    self.willChangeValue(forKey: "isFinished")
+    self.willChangeValue(forKey: "isCancelled")
+
+    syncronized {
+      var allowed = true
+      prevState = self.state
+      if !(only == State.All || prevState == only) {
+          allowed = false;
+      }
+      if (prevState == except) {
+          allowed = false;
+      }
+      if (allowed) {
+          self.state = newState;
+      }
+    }
+    
+    self.didChangeValue(forKey: "isExecuting")
+    self.didChangeValue(forKey: "isFinished")
+    self.didChangeValue(forKey: "isCancelled")
+    return prevState;
+  }
+  
+  func setState(state newState: State, except: State) -> State {
+    setState(state: newState, only: .All, except: except)
+  }
+  
+  func setState(state newState: State, only: State) -> State {
+    setState(state: newState, only: only, except: .None)
+  }
+  
+  func callCancellationBlock() {
+    if let cancellationBlock = cancellationBlock {
+      cancellationBlock()
+    }
+  }
+  
+  override func start() {
+    weak var weakSelf : RNMBXImageQueueOperation! = self
+    
+    DispatchQueue.global(qos: .default).async {
+      if let weakSelf = weakSelf {
+        let loader : RCTImageLoaderProtocol = weakSelf.bridge!.module(forName: "ImageLoader", lazilyLoadIfNecessary: true) as! RCTImageLoaderProtocol
+        
+        let cancellationBlock = loader.loadImage(with: weakSelf.urlRequest, size: .zero, scale: CGFloat(weakSelf.scale), clipped: true, resizeMode: .stretch, progressBlock: { _,_  in }, partialLoad: { _ in }) { error, image in
+          if let completionHandler = weakSelf.completionHandler {
+            completionHandler(error, image)
+          }
+          _ = weakSelf.setState(state:.Finished, except:.Finished)
+        }
+        
+        if true /*let weakSelf = weakSelf */ {
+          weakSelf.cancellationBlock = cancellationBlock
+          if (weakSelf.setState(state:.Executing, only:.Initial) == .CancelDoNotExecute) {
+            weakSelf.callCancellationBlock()
+          }
+        }
+      }
+    }
+  }
+  
+  override func cancel() {
+    if self.setState(state: .CancelDoNotExecute, except:.Finished) == .Executing {
+      self.callCancellationBlock()
+    }
+  }
+  
+  override var isExecuting: Bool {
+    get {
+      return syncronized {
+        return self.state == .Executing
+      }
+    }
+  }
+
+  override var isFinished: Bool {
+    get {
+      return syncronized {
+        return self.state == .Finished || self.state == .CancelDoNotExecute
+      }
+    }
+  }
+  
+  override var isCancelled: Bool {
+    get {
+      return syncronized {
+        return self.state == .CancelDoNotExecute
+      }
+    }
+  }
+}
+
+class RNMBXImageQueue {
+   static let sharedInstance: RNMBXImageQueue = {
+        let instance = RNMBXImageQueue()
+        // setup code
+        return instance
+    }()
+  
+  var imageQueue : OperationQueue = {
+    let result = OperationQueue()
+    result.name = "comp.mapbox.RNMBX.DownloadImageQueue"
+    return result
+  }()
+  
+  public func addImage(_ url: String, scale: Double?, bridge: RCTBridge, handler: @escaping (Error?, UIImage?) -> Void) {
+    addImage(urlRequest: RCTConvert.nsurlRequest(url), scale: scale, bridge: bridge, handler: handler)
+  }
+  
+  public func addImage(_ json : [String:Any], scale: Double?, bridge: RCTBridge, handler: @escaping (Error?, UIImage?) -> Void) {
+    addImage(urlRequest: RCTConvert.nsurlRequest(json), scale: scale, bridge: bridge, handler: handler)
+  }
+  
+  public func addImage(urlRequest: URLRequest, scale: Double?, bridge: RCTBridge, handler: @escaping (Error?, UIImage?) -> Void) {
+    let operation = RNMBXImageQueueOperation()
+    operation.bridge = bridge
+    operation.urlRequest = urlRequest
+    operation.completionHandler = handler
+    operation.scale = scale
+    imageQueue.addOperation(operation)
+  }
+}

package/ios/RNMBX/RNMBXImageSource.swift

@@ -0,0 +1,65 @@
+import MapboxMaps
+
+@objc
+class RNMBXImageSource : RNMBXSource {
+  
+  @objc var url: String? = nil {
+    didSet {
+      if var source = source as? ImageSource {
+        source.url = url
+        self.doUpdate { (style) in
+          try! style.setSourceProperty(for: id, property: "url", value: url)
+        }
+      }
+    }
+  }
+  
+  @objc var coordinates: [[NSNumber]]? = nil {
+    didSet {
+      if var source = source as? ImageSource {
+        if let coordinates = coordinates {
+          source.coordinates = coordinates.map { $0.map { $0.doubleValue }}
+        } else {
+          source.coordinates = nil
+        }
+        self.doUpdate { (style) in
+          try! style.setSourceProperty(for: id, property: "coordinates", value: source.coordinates)
+        }
+      }
+    }
+  }
+  
+  override func sourceType() -> Source.Type {
+    return ImageSource.self
+  }
+
+  override func makeSource() -> Source
+  {
+    #if RNMBX_11
+    var result = ImageSource(id: self.id)
+    #else
+    var result = ImageSource()
+    #endif
+    if let url = url {
+      result.url = url
+    }
+    
+    if let coordinates = coordinates {
+      result.coordinates = coordinates.map { $0.map { $0.doubleValue }}
+    }
+    
+    return result
+  }
+  
+  func doUpdate(_ update:(Style) -> Void) {
+    guard let map = self.map,
+          let _ = self.source,
+          map.mapboxMap.style.sourceExists(withId: id) else {
+      return
+    }
+    
+    let style = map.mapboxMap.style
+    update(style)
+  }
+  
+}

package/ios/RNMBX/RNMBXImageSourceManager.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RNMBXImageSourceManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(existing, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(coordinates, NSArray)
+
+@end

package/ios/RNMBX/RNMBXImageSourceManager.swift

@@ -0,0 +1,11 @@
+@objc(RNMBXImageSourceManager)
+class RNMBXImageSourceManager: RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  @objc override func view() -> UIView {
+    return RNMBXImageSource()
+  }
+}

package/ios/RNMBX/RNMBXImages.swift

@@ -0,0 +1,288 @@
+import MapboxMaps
+
+protocol RNMBXImageSetter : AnyObject {
+  func addImage(name: String, image: UIImage, sdf: Bool?, stretchX: [[NSNumber]], stretchY: [[NSNumber]], content: [NSNumber]?, log: String) -> Bool
+}
+
+func hasImage(style: Style, name: String) -> Bool {
+  #if RNMBX_11
+  return style.imageExists(withId: name)
+  #else
+  return (style.styleManager.getStyleImage(forImageId: name) != nil)
+  #endif
+}
+
+#if RNMBX_11
+typealias StyleImageMissingPayload = StyleImageMissing
+#endif
+
+class RNMBXImages : UIView, RNMBXMapComponent {
+  
+  weak var bridge : RCTBridge! = nil
+  
+  weak var style: Style? = nil
+
+  @objc
+  var onImageMissing: RCTBubblingEventBlock? = nil
+  
+  @objc
+  var images : [String:Any] = [:] {
+    didSet {
+      updateImages(images: images, oldImages: oldValue)
+    }
+  }
+    
+  var loadedImages : Set<String> = []
+  
+  var imageViews: [RNMBXImage] = []
+
+  @objc
+  var nativeImages: [Any] = [] {
+    didSet {
+      nativeImageInfos = nativeImages.compactMap { decodeImage($0) }
+    }
+  }
+
+  typealias NativeImageInfo = (name:String, sdf: Bool, stretchX:[(from:Float, to:Float)], stretchY:[(from:Float, to:Float)], content: (left:Float,top:Float,right:Float,bottom:Float)? );
+  var nativeImageInfos: [NativeImageInfo] = []
+  
+  @objc open override func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    if let image = subview as? RNMBXImage {
+      imageViews.insert(image, at: atIndex)
+    } else {
+      Logger.log(level:.warn, message: "RNMBXImages children can only be RNMBXImage, got \(optional: subview)")
+    }
+    super.insertReactSubview(subview, at: atIndex)
+  }
+  
+  @objc open override func removeReactSubview(_ subview: UIView!) {
+    if let image = subview as? RNMBXImage {
+      imageViews.removeAll { $0 == image }
+      image.images = nil
+    }
+    super.removeReactSubview(subview)
+  }
+  
+  // MARK: - RNMBXMapComponent
+
+  func waitForStyleLoad() -> Bool {
+    return false
+  }
+  
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    self.style = style
+    map.images.append(self)
+    
+    self.addNativeImages(style: style, nativeImages: nativeImageInfos)
+    self.addImages(style: style, images: images, oldImages: [:])
+    self.addImageViews(style: style, imageViews: imageViews)
+  }
+  
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    self.style = nil
+    // v10todo
+    return true
+  }
+  
+  func sameImage(oldValue: Any?, newValue: Any?) -> Bool {
+    if let oldS = oldValue as? String, let newS = newValue as? String {
+      return oldS == newS
+    } else {
+      return false
+    }
+  }
+
+  func updateImages(images: [String:Any], oldImages: [String:Any]) {
+    if let style = self.style {
+      addImages(style: style, images: images, oldImages: oldImages)
+    }
+  }
+
+  func addImages(style: Style, images: [String: Any], oldImages: [String:Any]) {
+    var missingImages : [String:Any] = [:]
+    
+    // Add image placeholder for images that are not yet available in the style. This way
+    // we can load the images asynchronously and add the ShapeSource to the map without delay.
+    // The same is required when this ShapeSource is updated with new/added images and the
+    // data references them. In which case addMissingImageToStyle will take care of loading
+    // them in a similar way.
+    //
+    // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+    
+    for name in images.keys {
+      let newImage = oldImages[name] == nil
+      if oldImages[name] == nil || loadedImages.contains(name) || !sameImage(oldValue: oldImages[name], newValue: images[name]) {
+        let addPlaceholder = oldImages[name] == nil
+        if !sameImage(oldValue: oldImages[name], newValue: images[name]) {
+          missingImages[name] = images[name]
+        } else {
+          if !hasImage(style: style, name: name) {
+            logged("RNMBXImages.addImagePlaceholder") {
+              try? style.addImage(placeholderImage, id: name, stretchX: [], stretchY: [])
+              missingImages[name] = images[name]
+            }
+          }
+        }
+      }
+    }
+    
+    if missingImages.count > 0 {
+      RNMBXUtils.fetchImages(bridge, style: style, objects: missingImages, forceUpdate: true, loaded: { name in self.loadedImages.insert(name) } ,callback: { })
+    }
+  }
+  
+  private func addImageViews(style: Style, imageViews: [RNMBXImage]) {
+    imageViews.forEach { imageView in
+      imageView.images = self
+    }
+  }
+  
+  public func addMissingImageToStyle(style: Style, imageName: String) -> Bool {
+    if let nativeImage = nativeImageInfos.first(where: { $0.name == imageName }) {
+      addNativeImages(style: style, nativeImages: [nativeImage])
+      return true
+    }
+    
+    if let image = images[imageName] {
+      addImages(style: style, images: [imageName: image], oldImages: [:])
+      return true
+    }
+    return false
+  }
+  
+  public func sendImageMissingEvent(imageName: String, payload: StyleImageMissingPayload) {
+    let payload = ["imageKey":imageName]
+    let event = RNMBXEvent(type: .imageMissing, payload: payload)
+    if let onImageMissing = onImageMissing {
+      onImageMissing(event.toJSON())
+    }
+  }
+  
+  static func convert(stretch: [[NSNumber]], scale: CGFloat = 1.0) -> [(from: Float, to: Float)] {
+    return stretch.map{ pair in
+      return (from: pair[0].floatValue * Float(scale), to: pair[1].floatValue * Float(scale))
+    }
+  }
+  
+  static func convert(stretch: [(from: Float, to: Float)], scale: CGFloat = 1.0) -> [ImageStretches] {
+    return stretch.map { v in ImageStretches(first: v.from * Float(scale), second: v.to * Float(scale)) }
+  }
+  
+  static func convert(stretch: [[NSNumber]], scale: CGFloat = 1.0) -> [ImageStretches] {
+    return convert(stretch: convert(stretch: stretch, scale: scale))
+  }
+  
+  static func convert(stretch: [[NSNumber]], scale: Float = 1.0) -> [ImageStretches] {
+    return convert(stretch: stretch, scale: CGFloat(scale))
+  }
+
+
+  static func convert(content: (left:Float, top:Float, right:Float, bottom:Float)?, scale: CGFloat) -> ImageContent? {
+    guard let content = content else {
+      return nil
+    }
+    
+    return ImageContent(left:content.left*Float(scale), top:content.top*Float(scale), right:content.right*Float(scale), bottom:content.bottom*Float(scale))
+  }
+
+  static func convert(content: [NSNumber]?, scale: CGFloat = 1.0) -> (left:Float,top:Float,right:Float,bottom:Float)? {
+    guard let content = content else {
+      return nil
+    }
+    guard content.count == 4 else {
+      Logger.log(level: .error, message: "Image content should have 4 elements got \(content)")
+      return nil
+    }
+    return (
+      left: content[0].floatValue*Float(scale),
+      top: content[1].floatValue*Float(scale),
+      right: content[2].floatValue*Float(scale),
+      bottom: content[3].floatValue*Float(scale)
+    )
+  }
+  
+  static func convert(content: [NSNumber]?, scale: CGFloat = 1.0) -> ImageContent? {
+    return convert(content: convert(content: content, scale: scale), scale: 1.0)
+  }
+  
+  func decodeImage(_ imageNameOrInfo: Any) -> NativeImageInfo? {
+    if let imageName = imageNameOrInfo as? String {
+      return (name: imageName, sdf: false, stretchX:[],stretchY:[],content:nil)
+    } else if let imageInfo = imageNameOrInfo as? [String:Any] {
+      guard let name = imageInfo["name"] as? String else {
+        Logger.log(level: .warn, message: "NativeImage: \(imageInfo) has no name key")
+        return nil
+      }
+      var sdf = false
+      var stretchX : [(from:Float, to:Float)] = []
+      var stretchY : [(from:Float, to:Float)] = []
+      if let sdfV = imageInfo["sdf"] as? NSNumber {
+        sdf = sdfV.boolValue
+      }
+      
+      if let stretchXV = imageInfo["stretchX"] as? [[NSNumber]] {
+        stretchX = RNMBXImages.convert(stretch: stretchXV)
+      }
+      
+      if let stretchYV = imageInfo["stretchY"] as? [[NSNumber]] {
+        stretchY = RNMBXImages.convert(stretch: stretchYV)
+      }
+      
+      var content : (left:Float, top:Float, right:Float, bottom:Float)? = nil
+      if let contentV = imageInfo["content"] as? [NSNumber] {
+        content = RNMBXImages.convert(content: contentV)
+      }
+      
+      return (name: name, sdf: sdf, stretchX: stretchX, stretchY: stretchY, content: content)
+    } else {
+      Logger.log(level: .warn, message: "RNMBXImage.nativeImage, unexpected image: \(imageNameOrInfo)")
+      return nil
+    }
+  }
+  
+  func addNativeImages(style: Style, nativeImages: [NativeImageInfo]) {
+    for imageInfo in nativeImages {
+      let imageName = imageInfo.name
+      if !hasImage(style: style, name: imageInfo.name) {
+        if let image = UIImage(named: imageName) {
+          logged("RNMBXImage.addNativeImage: \(imageName)") {
+            try style.addImage(image, id: imageName, sdf: imageInfo.sdf,
+                               stretchX: RNMBXImages.convert(stretch: imageInfo.stretchX, scale: image.scale),
+                               stretchY: RNMBXImages.convert(stretch: imageInfo.stretchY, scale: image.scale),
+                               content: RNMBXImages.convert(content: imageInfo.content, scale: image.scale)
+            )
+          }
+        } else {
+          Logger.log(level:.error, message: "Cannot find nativeImage named \(imageName)")
+        }
+      }
+    }
+  }
+  
+  lazy var placeholderImage : UIImage = {
+    UIGraphicsBeginImageContextWithOptions(CGSize(width: 1, height: 1), false, 0.0)
+    let result = UIGraphicsGetImageFromCurrentImageContext()!
+    UIGraphicsEndImageContext()
+    return result
+  }()
+}
+
+extension RNMBXImages : RNMBXImageSetter {
+  func addImage(name: String, image: UIImage, sdf: Bool?, stretchX: [[NSNumber]], stretchY: [[NSNumber]], content: [NSNumber]?, log: String) -> Bool
+  {
+     return logged("\(log).addImage") {
+       if let style = style {
+         try style.addImage(image,
+                            id:name,
+                            sdf: sdf ?? false,
+                            stretchX: RNMBXImages.convert(stretch: stretchX, scale: image.scale),
+                            stretchY: RNMBXImages.convert(stretch: stretchY, scale: image.scale),
+                            content: RNMBXImages.convert(content: content, scale: image.scale)
+         )
+         return true
+       } else {
+         return false
+       }
+     } ?? false
+ }
+}

package/ios/RNMBX/RNMBXImagesManager.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RNMBXImagesManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(images, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(nativeImages, NSArray)
+RCT_REMAP_VIEW_PROPERTY(onImageMissing, onImageMissing, RCTBubblingEventBlock)
+
+@end

package/ios/RNMBX/RNMBXImagesManager.swift

@@ -0,0 +1,14 @@
+
+@objc(RNMBXImagesManager)
+class RNMBXImagesManager : RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  override func view() -> UIView! {
+    let layer = RNMBXImages()
+    layer.bridge = self.bridge
+    return layer
+  }
+}

package/ios/RNMBX/RNMBXInteractiveElement.swift

@@ -0,0 +1,64 @@
+import MapboxMaps
+
+@objc
+class RNMBXInteractiveElement : UIView, RNMBXMapComponent {
+  weak var map : RNMBXMapView? = nil
+
+  static let hitboxDefault = 44.0
+
+  @objc var draggable: Bool = false
+  
+  @objc var hasPressListener: Bool = false
+  
+  @objc var hitbox : [String:NSNumber] = [
+    "width": NSNumber(value: hitboxDefault),
+    "height": NSNumber(value: hitboxDefault)
+  ]
+  
+  @objc var id: String! = nil {
+    willSet {
+      if id != nil && newValue != id {
+        Logger.log(level:.warn, message: "Changing id from: \(optional: id) to \(optional: newValue), changing of id is supported")
+        if let map = map { removeFromMap(map, reason: .ComponentChange) }
+      }
+    }
+    didSet {
+      if oldValue != nil && oldValue != id {
+        if let map = map { addToMap(map, style: map.mapboxMap.style) }
+      }
+    }
+  }
+  
+  @objc var onDragStart: RCTBubblingEventBlock? = nil
+  
+  @objc var onPress: RCTBubblingEventBlock? = nil
+  
+  func getLayerIDs() -> [String] {
+    return []
+  }
+
+  func isDraggable() -> Bool {
+    return draggable
+  }
+  
+  func isTouchable() -> Bool {
+    return hasPressListener
+  }
+  
+  // MARK: - RNMBXMapComponent
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    if (self.id == nil) {
+      Logger.log(level: .error, message: "id is required on \(self) but not specified")
+    }
+    self.map = map
+  }
+
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    self.map = nil
+    return true
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+}