@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLLocationModule.swift

@@ -0,0 +1,272 @@
+import Foundation
+import MapboxMaps
+
+@objc(RCTMGLLocation)
+class RCTMGLLocation: NSObject {
+  var location : CLLocation = CLLocation(latitude: 0.0, longitude: 0.0)
+  
+  var heading : CLHeading? = nil
+
+  func toJSON() -> [String:Any] {
+    return [
+      "coords": [
+        "longitude": location.coordinate.longitude,
+        "latitude": location.coordinate.latitude,
+        "altitude": location.altitude,
+        "accuracy": location.horizontalAccuracy,
+        "heading": heading?.trueHeading ?? 0.0,
+        "course": location.course,
+        "speed": location.speed,
+      ],
+      "timestamp": location.timestamp.timeIntervalSince1970
+    ]
+  }
+}
+
+typealias RCTMGLLocationBlock = (RCTMGLLocation?) -> Void
+
+let RCT_MAPBOX_USER_LOCATION_UPDATE = "MapboxUserLocationUpdate";
+
+
+protocol RCTMGLLocationManagerDelegate {
+  func locationManager(_ locationManager: RCTMGLLocationManager, didUpdateLocation: RCTMGLLocation)
+}
+
+class RCTMGLLocationManager : LocationProviderDelegate {
+  var provider: LocationProvider
+  
+  var lastKnownLocation : CLLocation?
+  var lastKnownHeading : CLHeading?
+  
+  var delegate: RCTMGLLocationManagerDelegate?
+  var locationProviderDelage: LocationProviderDelegate?
+  
+  var listeners: [RCTMGLLocationBlock] = []
+  
+  init() {
+    provider = AppleLocationProvider()
+    provider.setDelegate(self)
+  }
+  
+  func setDistanceFilter(_ distanceFilter: CLLocationDistance) {
+    provider.locationProviderOptions.distanceFilter = distanceFilter
+  }
+  
+  func start() {
+    provider.requestAlwaysAuthorization()
+    provider.requestWhenInUseAuthorization()
+    provider.setDelegate(self)
+    provider.startUpdatingHeading()
+    provider.startUpdatingLocation()
+  }
+  
+  func _convertToMapboxLocation(_ location: CLLocation?) -> RCTMGLLocation {
+    guard let location = location else {
+      return RCTMGLLocation()
+    }
+
+    let userLocation = RCTMGLLocation()
+    userLocation.location = location;
+    userLocation.heading = lastKnownHeading
+    return userLocation;
+  }
+  
+  func _updateDelegate() {
+    if delegate == nil {
+      return;
+    }
+
+    let userLocation = _convertToMapboxLocation(lastKnownLocation)
+
+    for listener in listeners {
+      listener(userLocation)
+    }
+    delegate?.locationManager(self, didUpdateLocation: userLocation)
+  }
+  
+    // MARK: - LocationProviderDelegate
+  
+  func locationProvider(_ provider: LocationProvider, didUpdateLocations locations: [CLLocation]) {
+    lastKnownLocation = locations.last
+    self._updateDelegate()
+    
+    locationProviderDelage?.locationProvider(provider, didUpdateLocations: locations)
+  }
+  
+  func locationProvider(_ provider: LocationProvider, didUpdateHeading newHeading: CLHeading) {
+    lastKnownHeading = newHeading
+    self._updateDelegate()
+    
+    locationProviderDelage?.locationProvider(provider, didUpdateHeading: newHeading)
+  }
+  
+  func locationProvider(_ provider: LocationProvider, didFailWithError error: Error) {
+    locationProviderDelage?.locationProvider(provider, didFailWithError: error)
+  }
+  
+  func locationProviderDidChangeAuthorization(_ provider: LocationProvider) {
+    locationProviderDelage?.locationProviderDidChangeAuthorization(provider)
+  }
+}
+
+extension RCTMGLLocationManager: LocationProvider {
+  var locationProviderOptions: LocationOptions {
+    get {
+      provider.locationProviderOptions
+    }
+    set(newValue) {
+      provider.locationProviderOptions = newValue
+    }
+  }
+  
+  var authorizationStatus: CLAuthorizationStatus {
+    get {
+      provider.authorizationStatus
+    }
+  }
+  
+  var accuracyAuthorization: CLAccuracyAuthorization {
+    get {
+      provider.accuracyAuthorization
+    }
+  }
+  
+  var heading: CLHeading? {
+    get {
+      provider.heading
+    }
+  }
+  
+  func setDelegate(_ delegate: LocationProviderDelegate) {
+    provider.setDelegate(self)
+    locationProviderDelage = delegate
+  }
+  
+  func requestAlwaysAuthorization() {
+    provider.requestAlwaysAuthorization()
+  }
+  
+  func requestWhenInUseAuthorization() {
+    provider.requestWhenInUseAuthorization()
+  }
+  
+  func requestTemporaryFullAccuracyAuthorization(withPurposeKey purposeKey: String) {
+    if #available(iOS 14.0, *) {
+      provider.requestTemporaryFullAccuracyAuthorization(withPurposeKey: purposeKey)
+    } else {
+      // Fallback on earlier versions
+    }
+  }
+  
+  func startUpdatingLocation() {
+    provider.startUpdatingLocation()
+  }
+  
+  func stopUpdatingLocation() {
+    provider.stopUpdatingLocation()
+  }
+  
+  var headingOrientation: CLDeviceOrientation {
+    get {
+      return provider.headingOrientation
+    }
+    set(newValue) {
+      provider.headingOrientation = newValue
+    }
+  }
+  
+  func startUpdatingHeading() {
+    provider.startUpdatingHeading()
+  }
+  
+  func stopUpdatingHeading() {
+    provider.stopUpdatingHeading()
+  }
+  
+  func dismissHeadingCalibrationDisplay() {
+    provider.dismissHeadingCalibrationDisplay()
+  }
+}
+
+
+@objc(RCTMGLLocationModule)
+class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
+
+  static var shared : RCTMGLLocationModule? = nil
+  
+  var locationManager : RCTMGLLocationManager
+  var hasListener = false
+  
+  var locationProvider : LocationProvider {
+    get {
+      return locationManager
+    }
+  }
+  
+  override init() {
+    locationManager = RCTMGLLocationManager()
+    super.init()
+    locationManager.delegate = self
+    RCTMGLLocationModule.shared = self
+  }
+  
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  @objc
+  override func constantsToExport() -> [AnyHashable: Any]! {
+    return [
+      "foo": "bar"
+    ];
+  }
+
+  @objc override func supportedEvents() -> [String]
+  {
+    return [RCT_MAPBOX_USER_LOCATION_UPDATE];
+  }
+  
+  @objc func start(_ minDisplacement: CLLocationDistance) {
+    locationManager.start()
+    locationManager.setDistanceFilter(minDisplacement)
+  }
+  
+  @objc func stop() {
+    print("TODO implement RCTMGLLocationModule.stop!")
+  }
+  
+  @objc func getLastKnownLocation() -> RCTMGLLocation? {
+    return RCTMGLLocation()
+  }
+  
+  @objc func setMinDisplacement(_ minDisplacement: CLLocationDistance) {
+    locationManager.setDistanceFilter(minDisplacement)
+  }
+  
+  @objc
+  override func startObserving() {
+    super.startObserving()
+    hasListener = true
+  }
+  
+  @objc
+  override func stopObserving() {
+    super.stopObserving()
+    hasListener = false
+  }
+  
+  
+  func locationManager(_ locationManager: RCTMGLLocationManager, didUpdateLocation location: RCTMGLLocation) {
+    guard hasListener else {
+      return
+    }
+    
+    guard let _ = bridge else {
+      return
+    }
+   
+    self.sendEvent(withName: RCT_MAPBOX_USER_LOCATION_UPDATE, body: location.toJSON())
+  }
+
+}

package/ios/RCTMGL-v10/RCTMGLLogging.m

@@ -0,0 +1,8 @@
+#import "React/RCTBridgeModule.h"
+
+@interface RCT_EXTERN_MODULE(RCTMGLLogging, NSObject)
+
+RCT_EXTERN_METHOD(setLogLevel: (nonnull NSString*)logLevel)
+
+@end
+

package/ios/RCTMGL-v10/RCTMGLLogging.swift

@@ -0,0 +1,133 @@
+import Foundation
+import MapboxMaps
+
+enum RCTMGLError: Error, LocalizedError {
+  case parseError(String)
+  case failed(String)
+  case paramError(String)
+
+  var errorDescription: String? {
+    return String(describing: self)
+  }
+}
+
+class Logger {
+  enum LogLevel : String, Comparable {
+    static func < (lhs: Logger.LogLevel, rhs: Logger.LogLevel) -> Bool {
+      return lhs.intValue < rhs.intValue
+    }
+    
+    case verbose = "verbose"
+    case debug = "debug"
+    case info = "info"
+    case warn = "warn"
+    case error = "error"
+  
+    var intValue : Int {
+      let values : [LogLevel:Int] = [
+        .verbose: 0,
+        .debug: 1,
+        .info: 2,
+        .warn: 3,
+        .error: 4
+      ]
+      guard let result = values[self] else {
+        fatalError("Unepxected level \(self)")
+      }
+      return result
+    }
+    
+    var stringValue : String {
+      return rawValue
+    }
+  }
+  
+  static let sharedInstance = Logger()
+  
+  var level: LogLevel = .info
+  var handler : (LogLevel, String) -> Void = { (level, message) in
+    fatalError("Handler not yet installed")
+  }
+  
+  func log(level: LogLevel, message: String) {
+    print("LOG \(level) \(message)")
+    if self.level <= level {
+      handler(level, message)
+    }
+  }
+  
+  static func log(level: LogLevel, message: String) {
+    sharedInstance.log(level: level, message: message)
+  }
+  
+  static func log(level: LogLevel, message: String, error: Error) {
+    sharedInstance.log(level: level, message: "\(message) - error: \(error.localizedDescription) \(error)")
+  }
+}
+
+func logged<T>(_ msg: String, info: (() -> String)? = nil, level: Logger.LogLevel = .error, rejecter: RCTPromiseRejectBlock? = nil, fn : () throws -> T) -> T? {
+  do {
+    return try fn()
+  } catch {
+    Logger.log(level:level, message: "\(msg) \(info?() ?? "") \(error.localizedDescription)")
+    rejecter?(msg, "\(info?() ?? "") \(error.localizedDescription)", error)
+    return nil
+  }
+}
+
+func logged<T>(_ msg: String, info: (() -> String)? = nil, errorResult: (Error) -> T, level: Logger.LogLevel = .error, fn : () throws -> T) -> T {
+  do {
+    return try fn()
+  } catch {
+    Logger.log(level:level, message: "\(msg) \(info?() ?? "") \(error.localizedDescription)")
+    return errorResult(error)
+  }
+}
+
+@objc(RCTMGLLogging)
+class RCTMGLLogging: RCTEventEmitter {
+  static var shared : RCTMGLLogging? = nil
+  
+  enum ErrorType {
+      case argumentError
+  }
+
+  @objc
+  func setLogLevel(_ logLevel: String) {
+    guard let logLevel = Logger.LogLevel(rawValue: logLevel) else {
+      fatalError("Unexpected \(logLevel)")
+    }
+    Logger.sharedInstance.level = logLevel
+  }
+  
+  override init() {
+    super.init()
+    if let _ = RCTMGLLogging.shared {
+      // seems to happen on reload in debug versions
+      // fatalError("More than one instance of RCTMGLLogging is created \(previous)")
+    }
+    RCTMGLLogging.shared = self
+    installHandler()
+  }
+
+  func installHandler() {
+    Logger.sharedInstance.handler = { (level, msg) in
+      let body = [
+        "level": level.stringValue,
+        "message": msg
+      ]
+      self.sendEvent(withName: "LogEvent", body: body)
+    }
+  }
+  
+  @objc
+  static override func requiresMainQueueSetup() -> Bool {
+      return true
+  }
+  
+  @objc
+  override func supportedEvents() -> [String]
+  {
+      return ["LogEvent"];
+  }
+}