@rnmapbox/maps 10.1.0 → 10.1.1

package/ios/RNMBX/RNMBXOfflineModuleLegacy.swift

@@ -0,0 +1,431 @@
+import Foundation
+import MapboxMaps
+
+@objc(RNMBXOfflineModuleLegacy)
+class RNMBXOfflineModuleLegacy: RCTEventEmitter {
+  final let CompleteRegionDownloadState = 2
+  
+  lazy var offlineRegionManager: OfflineRegionManager = {
+    #if RNMBX_11
+    return OfflineRegionManager()
+    #else
+    return OfflineRegionManager(resourceOptions: .init(accessToken: RNMBXModule.accessToken!))
+    #endif
+  }()
+
+  @objc
+  override
+  func supportedEvents() -> [String] {
+    return []
+  }
+
+  @objc
+  override
+  static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  private func makeRegionStatusPayload(name: String, status: OfflineRegionStatus) -> [String:Any?] {
+    let progressPercentage = status.requiredResourceCount > 0 ? Double(status.completedResourceCount) / Double(status.requiredResourceCount) : 0
+    let percentage = min(ceil(Double(progressPercentage) * 100.0), 100.0)
+    let isCompleted = percentage == 100.0
+    let state = isCompleted ? CompleteRegionDownloadState : status.downloadState.rawValue
+    let result: [String:Any?] = [
+        "state": state,
+        "name": name,
+        "percentage": percentage,
+        "completedResourceCount": status.completedResourceCount,
+        "completedResourceSize": status.completedResourceSize,
+        "completedTileSize": status.completedTileSize,
+        "completedTileCount": status.completedTileCount,
+        "requiredResourceCount": status.requiredResourceCount
+      ]
+
+      return result
+    }
+
+
+  func convertPointPairToBounds(_ bounds: Geometry) -> CoordinateBounds? {
+    guard case .geometryCollection(let gc) = bounds else {
+      return nil
+    }
+    let geometries = gc.geometries
+
+    guard geometries.count == 2 else {
+      return nil
+    }
+    guard case .point(let g0) = geometries[0] else {
+      return nil
+    }
+    guard case .point(let g1) = geometries[1] else {
+      return nil
+    }
+
+    let pt0 = CLLocationCoordinate2D(latitude: g0.coordinates.latitude, longitude: g0.coordinates.longitude)
+    let pt1 = CLLocationCoordinate2D(latitude: g1.coordinates.latitude, longitude: g1.coordinates.longitude)
+
+    return CoordinateBounds(southwest: pt0, northeast: pt1)
+  }
+
+func convertRegionToPack(region: OfflineRegion) -> [String: Any]? {
+    var metadataString: String?
+
+    guard let bb = region.getTilePyramidDefinition()?.bounds else { return [:] }
+
+    do {
+      let metadata = region.getMetadata()
+
+      metadataString = String(data: metadata, encoding: .utf8)
+
+      if (metadataString == nil) {
+        // Handle archived data from V9
+        metadataString = NSKeyedUnarchiver.unarchiveObject(with: metadata) as? String
+      }
+
+
+      let jsonBounds = [
+         [bb.east, bb.north],
+         [bb.west, bb.south]
+      ]
+
+      let pack: [String: Any] = [
+        "metadata": metadataString,
+        "bounds": jsonBounds
+      ]
+
+      return pack
+    } catch {
+      print("convertRegionToPack error: \(error)")
+      return nil
+    }
+  }
+
+  func createPackCallback(region: OfflineRegion,
+                          metadata: Data,
+                          resolver: @escaping RCTPromiseResolveBlock,
+                          rejecter: @escaping RCTPromiseRejectBlock) {
+
+    region.setOfflineRegionDownloadStateFor(.active)
+    region.setMetadata(metadata) { [weak self] result in
+      switch result {
+      case let .failure(error):
+        print("Error creating offline region: \(error)")
+        rejecter("createPack error:", error.localizedDescription, error)
+
+      case .success():
+        resolver(self?.convertRegionToPack(region: region))
+      }
+    }
+  }
+
+func getRegionByName(name: String, offlineRegions: [OfflineRegion]) -> OfflineRegion? {
+    for region in offlineRegions {
+      var metadata:[String: Any] = [:]
+
+      do {
+        let byteMetadata = region.getMetadata()
+
+       // Handle archived data from V9
+        let metadataString = NSKeyedUnarchiver.unarchiveObject(with: byteMetadata) as? String
+
+        if (metadataString != nil) {
+          let data = metadataString!.data(using: .utf8)
+          metadata = try JSONSerialization.jsonObject(with: data!, options: []) as! [String: Any]
+        } else {
+          metadata = try JSONSerialization.jsonObject(with: byteMetadata, options: []) as! [String:Any]
+        }
+
+        if (name == metadata["name"] as! String) {
+          return region
+        }
+      } catch {
+        print("getRegionByName error: \(error)")
+        return nil
+      }
+    }
+
+    return nil
+  }
+
+  // MARK: react methods
+  
+  @objc
+  func createPack(_ options: NSDictionary, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      do {
+        let metadataStr = options["metadata"] as! String
+        let styleURL = options["styleURL"] as! String
+
+        let boundsStr = options["bounds"] as! String
+        let boundsData = boundsStr.data(using: .utf8)
+        var boundsFC = try JSONDecoder().decode(FeatureCollection.self, from: boundsData!)
+
+        guard let bounds = self.convertPointPairToBounds(RNMBXFeatureUtils.fcToGeomtry(boundsFC)),
+              let metadataBytes = metadataStr.data(using: .utf8)
+        else {
+          rejecter("createPack error:", "No metadata or bounds set", nil)
+          return
+        }
+
+        let offlineRegionDef = OfflineRegionTilePyramidDefinition(
+          styleURL: styleURL,
+          bounds: bounds,
+          minZoom: options["minZoom"] as! Double,
+          maxZoom: options["maxZoom"] as! Double,
+          pixelRatio: Float(UIScreen.main.scale),
+          glyphsRasterizationMode: .ideographsRasterizedLocally)
+
+        self.offlineRegionManager.createOfflineRegion(for: offlineRegionDef) { [weak self] result in
+          switch result {
+          case let .failure(error):
+            print("Error creating offline region: \(error)")
+            rejecter("createPack", error.localizedDescription, error)
+
+          case let .success(region):
+            self?.createPackCallback(region: region,
+                                    metadata: metadataBytes,
+                                    resolver: resolver,
+                                    rejecter: rejecter)
+          }
+        }
+      } catch {
+        rejecter("createPack", error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc
+  func getPacks(_ resolve : @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          var payload = [[String: Any]]()
+
+          for region in regions {
+            if let pack = self.convertRegionToPack(region: region) {
+              payload.append(pack)
+            }
+          }
+
+          resolve(payload)
+        case .failure(let error):
+          rejecter("getPacks error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func deletePack(_ name: String,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          guard let region = self.getRegionByName(name: name, offlineRegions: regions) else {
+            resolver(nil);
+            print("deleteRegion - Unknown offline region");
+            return
+          }
+
+          region.setOfflineRegionDownloadStateFor(.inactive)
+          region.purge { result in
+            switch result {
+            case let .failure(error):
+              rejecter("deleteRegion error", error.localizedDescription, error)
+
+            case .success:
+              print("deleteRegion done");
+              resolver(nil);
+            }
+          }
+        case .failure(let error):
+          rejecter("deleteRegion error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func invalidatePack(_ name: String,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          guard let region = self.getRegionByName(name: name, offlineRegions: regions) else {
+            resolver(nil);
+            print("invalidatePack - Unknown offline region");
+            return
+          }
+
+          region.invalidate { result in
+            switch result {
+            case let .failure(error):
+              rejecter("invalidatePack error", error.localizedDescription, error)
+
+            case .success:
+              print("invalidatePack done");
+              resolver(nil);
+            }
+          }
+        case .failure(let error):
+          rejecter("invalidatePack error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func getPackStatus(_ name: String,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          guard let region = self.getRegionByName(name: name, offlineRegions: regions) else {
+            resolver(nil);
+            print("getPackStatus - Unknown offline region");
+            return
+          }
+
+          region.getStatus { result in
+            switch result {
+            case let .success(status):
+              print("getPackStatus done");
+              resolver(self.makeRegionStatusPayload(name: name, status: status));
+
+            case let .failure(error):
+              rejecter("getPackStatus error", error.localizedDescription, error)
+            }
+          }
+        case .failure(let error):
+          rejecter("getPackStatus error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func pausePackDownload(_ name: String,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          guard let region = self.getRegionByName(name: name, offlineRegions: regions) else {
+            resolver(nil);
+            print("pausePackDownload - Unknown offline region");
+            return
+          }
+
+          region.setOfflineRegionDownloadStateFor(.inactive)
+          resolver(nil);
+
+        case .failure(let error):
+          rejecter("pausePackDownload error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func resumePackDownload(_ name: String,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    DispatchQueue.main.async {
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          guard let region = self.getRegionByName(name: name, offlineRegions: regions) else {
+            resolver(nil);
+            print("resumePackDownload - Unknown offline region");
+            return
+          }
+
+          region.setOfflineRegionDownloadStateFor(.active)
+          resolver(nil);
+
+        case .failure(let error):
+          rejecter("resumePackDownload error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+  @objc
+  func resetDatabase(_ resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock)
+  {
+    print("resetDatabase started");
+    DispatchQueue.main.async {
+      var purgedCount = 0
+      self.offlineRegionManager.offlineRegions { result in
+        switch result {
+        case .success(let regions):
+          if (regions.count ==  0) {resolver(nil);}
+
+          for region in regions {
+            region.setOfflineRegionDownloadStateFor(.inactive)
+            region.purge { result in
+              switch result {
+              case let .failure(error):
+                rejecter("resetDatabase error", error.localizedDescription, error)
+
+              case .success:
+                print("pack purged");
+                purgedCount += 1
+                if purgedCount == regions.count {
+                  print("resetDatabase done: \(regions.count) where purged");
+                  resolver(nil);
+                }
+              }
+            }
+
+          }
+
+
+        case .failure(let error):
+          rejecter("resetDatabase error", error.localizedDescription, error)
+        }
+      }
+    }
+  }
+
+
+ @objc
+  func migrateOfflineCache(_ resolve : @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    let bundleIdentifier = Bundle.main.bundleIdentifier!
+
+    let srcPath = "\(NSHomeDirectory())/Library/Application Support/\(bundleIdentifier)/.mapbox/cache.db"
+    let srcURL = URL(fileURLWithPath: NSHomeDirectory()).appendingPathComponent("Library/Application Support/\(bundleIdentifier)/.mapbox/cache.db")
+    let destURL = URL(fileURLWithPath: NSHomeDirectory()).appendingPathComponent("Library/Application Support/.mapbox/map_data/map_data.db")
+
+    let fileManager = FileManager.default
+
+    if (!fileManager.fileExists(atPath: srcPath)) {
+      print("migrateOfflineCache: nothing to migrate")
+      resolve(false)
+      return
+    }
+
+    do {
+      try fileManager.createDirectory(at: destURL.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
+      try fileManager.moveItem(at: srcURL, to: destURL)
+      print("migrateOfflineCache done:")
+      resolve(true)
+    } catch {
+      reject("migrateOfflineCache error:", error.localizedDescription, error)
+    }
+  }
+}

package/ios/RNMBX/RNMBXPointAnnotation.swift

@@ -155,6 +155,39 @@ public class RNMBXPointAnnotation : RNMBXInteractiveElement {
     return image
   }
   
+  func makeEvent(isSelect: Bool, deselectAnnotationOnMapTap: Bool = false) -> RNMBXEvent {
+    let position = superview?.convert(layer.position, to: nil)
+    let location = map?.mapboxMap.coordinate(for: position!)
+    var geojson = Feature(geometry: .point(Point(location!)))
+    geojson.identifier = .string(id)
+    var properties : [String: JSONValue?] = [
+      "screenPointX": .number(Double(position!.x)),
+      "screenPointY": .number(Double(position!.y))
+    ]
+    if deselectAnnotationOnMapTap {
+      properties["deselectAnnotationOnMapTap"] = true
+    }
+    geojson.properties = properties
+    let event = RNMBXEvent(type:isSelect ? .annotationSelected : .annotationDeselected, payload: logged("doHandleTap") { try geojson.toJSON() })
+    return event
+  }
+  
+  func doSelect() {
+    let event = makeEvent(isSelect: true)
+    if let onSelected = onSelected {
+      onSelected(event.toJSON())
+    }
+    onSelect()
+  }
+  
+  func doDeselect(deselectAnnotationOnMapTap: Bool = false) {
+    let event = makeEvent(isSelect: false, deselectAnnotationOnMapTap: deselectAnnotationOnMapTap)
+    if let onDeselected = onDeselected {
+      onDeselected(event.toJSON())
+    }
+    onDeselect()
+  }
+  
   func onSelect() {
     if let callout = callout,
        let calloutImage = _createViewSnapshot(view: callout),
@@ -252,7 +285,7 @@ extension RNMBXPointAnnotation {
         && annotation.point.coordinates.isValid()
         && (logged("PointAnnotation: missing id attribute") { return id }) != nil,
         let pointAnnotationManager = map?.pointAnnotationManager {
-      pointAnnotationManager.add(annotation)
+      pointAnnotationManager.add(annotation, self)
       added = true
       return true
     }

package/ios/RNMBX/RNMBXPointAnnotationModule.mm

@@ -25,7 +25,7 @@ RCT_EXPORT_MODULE();
   return RCTGetUIManagerQueue();
 }
 
-- (void)withPointAnnotation:(NSNumber*)viewRef block:(void (^)(RNMBXPointAnnotation *))block reject:(RCTPromiseRejectBlock)reject methodName:(NSString *)methodName
+- (void)withPointAnnotation:(nonnull NSNumber*)viewRef block:(void (^)(RNMBXPointAnnotation *))block reject:(RCTPromiseRejectBlock)reject methodName:(NSString *)methodName
 {
 #ifdef RCT_NEW_ARCH_ENABLED
     [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
@@ -46,7 +46,7 @@ RCT_EXPORT_MODULE();
 }
 
 
-RCT_EXPORT_METHOD(refresh:(NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(refresh:(nonnull NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
     [self withPointAnnotation:viewRef block:^(RNMBXPointAnnotation *view) {
         [view refresh];

package/ios/RNMBX/RNMBXShapeSource.swift

@@ -23,14 +23,30 @@ public class RNMBXShapeSource : RNMBXSource {
     }
   }
 
+  var shapeAnimator: ShapeAnimator? = nil
+  var shapeObject: GeoJSONObject? = nil
+
   @objc public var shape : String? {
     didSet {
-      logged("RNMBXShapeSource.updateShape") {
-        let obj : GeoJSONObject = try parse(shape)
-
-        doUpdate { (style) in
-          logged("RNMBXShapeSource.setShape") {
-            try style.updateGeoJSONSource(withId: id, geoJSON: obj)
+      shapeAnimator?.unsubscribe(consumer: self)
+      shapeAnimator = nil
+
+      if let shape = shape, ShapeAnimatorManager.shared.isShapeAnimatorTag(shape: shape), let animatedShape = ShapeAnimatorManager.shared.get(shape: shape) {
+        if let shapeAnimator = ShapeAnimatorManager.shared.get(shape: shape) {
+          self.shapeAnimator = shapeAnimator
+          shapeAnimator.subscribe(consumer: self)
+          
+          shapeUpdated(shape: shapeAnimator.getShape())
+        }
+      } else {
+        logged("RNMBXShapeSource.updateShape") {
+          let obj : GeoJSONObject = try parse(shape)
+          shapeObject = obj
+          
+          doUpdate { (style) in
+            logged("RNMBXShapeSource.setShape") {
+              try style.updateGeoJSONSource(withId: id, geoJSON: obj)
+            }
           }
         }
       }
@@ -71,13 +87,10 @@ public class RNMBXShapeSource : RNMBXSource {
     var result =  GeoJSONSource()
     #endif
 
-    if let shape = shape {
-      do {
-        result.data = try parse(shape)
-      } catch {
-        Logger.log(level: .error, message: "Unable to read shape: \(shape) \(error) setting it to empty")
-        result.data = emptyShape()
-      }
+    if let shapeObject = shapeObject {
+      result.data = toGeoJSONSourceData(shapeObject)
+    } else {
+      result.data = emptyShape()
     }
 
     if let url = url {
@@ -144,12 +157,27 @@ public class RNMBXShapeSource : RNMBXSource {
       try! style.setSourceProperty(for: id, property: property, value: value)
     }
   }
+  
+  deinit {
+    shapeAnimator?.unsubscribe(consumer: self)
+  }
 }
 
 // MARK: - parseJSON(url)
 
 extension RNMBXShapeSource
 {
+  func toGeoJSONSourceData(_ shape: GeoJSONObject) -> GeoJSONSourceData {
+    switch shape {
+    case .geometry(let geometry):
+      return .geometry(geometry)
+    case .feature(let feature):
+      return .feature(feature)
+    case .featureCollection(let features):
+      return .featureCollection(features)
+    }
+  }
+
   func parseJSON(_ url: String?, completion: @escaping (Result<GeoJSONObject, Error>) -> Void) {
     guard let url = url else { return }
 
@@ -299,8 +327,6 @@ extension MapboxMap {
                                    completion: completion)
     return DummyCancellable()
   }
-  
-  
 }
 #endif
 #endif
@@ -387,3 +413,16 @@ extension RNMBXShapeSource
     }
   }
 }
+
+// MARK: shape animation
+
+extension RNMBXShapeSource: ShapeAnimationConsumer {
+  func shapeUpdated(shape: Turf.GeoJSONObject) {
+    shapeObject = shape
+    doUpdate { (style) in
+      logged("RCTMGLShapeSource.setShape") {
+        try style.updateGeoJSONSource(withId: id, geoJSON: shape)
+      }
+    }
+  }
+}