react-native-google-maps-plus 1.0.2 → 1.1.0-dev.1

package/ios/RNGoogleMapsPlusView.swift

@@ -8,90 +8,118 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
   private let permissionHandler: PermissionHandler
   private let locationHandler: LocationHandler
 
+  private let markerBuilder = MapMarkerBuilder()
+  private let polylineBuilder = MapPolylineBuilder()
+  private let polygonBuilder = MapPolygonBuilder()
+  private let circleBuilder = MapCircleBuilder()
+
   private let impl: GoogleMapsViewImpl
 
   var view: UIView {
     return impl
   }
 
-  private var currentCustomMapStyle: String = ""
-  private let markerOptions = MapMarkerOptions()
-  private let polylineOptions = MapPolylineOptions()
-  private let polygonOptions = MapPolygonOptions()
-
   override init() {
     self.permissionHandler = PermissionHandler()
     self.locationHandler = LocationHandler()
     self.impl = GoogleMapsViewImpl(
       locationHandler: locationHandler,
-      markerOptions: markerOptions
+      markerBuilder: markerBuilder
     )
   }
 
+  /*
+   /// TODO: prepareForRecycle
+   override func prepareForRecycle() {
+   impl.clearAll()
+   }
+   */
+
   @MainActor
-  var buildingEnabled: Bool {
-    get { impl.buildingEnabled }
-    set { impl.buildingEnabled = newValue }
+  var initialProps: RNInitialProps? {
+    didSet {
+      impl.initMapView(
+        mapId: initialProps?.mapId,
+        liteMode: initialProps?.liteMode,
+        camera: initialProps?.camera?.toGMSCameraPosition(current: nil)
+      )
+    }
   }
 
   @MainActor
-  var trafficEnabled: Bool {
-    get { impl.trafficEnabled }
-    set { impl.trafficEnabled = newValue }
+  var uiSettings: RNMapUiSettings? {
+    didSet { impl.uiSettings = uiSettings }
   }
 
   @MainActor
-  var customMapStyle: String {
-    get { currentCustomMapStyle }
-    set {
-      currentCustomMapStyle = newValue
-      impl.customMapStyle = try? GMSMapStyle(jsonString: newValue)
-    }
+  var myLocationEnabled: Bool? {
+    didSet { impl.myLocationEnabled = myLocationEnabled }
   }
 
   @MainActor
-  var initialCamera: RNCamera {
-    get { mapCameraPositionToCamera(impl.initialCamera) }
-    set { impl.initialCamera = mapCameraToGMSCamera(newValue) }
+  var buildingEnabled: Bool? {
+    didSet { impl.buildingEnabled = buildingEnabled }
   }
 
   @MainActor
-  var userInterfaceStyle: RNUserInterfaceStyle {
-    get { mapUIUserInterfaceStyletoUserInterfaceStyle(impl.userInterfaceStyle) }
-    set {
-      impl.userInterfaceStyle = mapUserInterfaceStyleToUIUserInterfaceStyle(
-        newValue
-      )
+  var trafficEnabled: Bool? {
+    didSet { impl.trafficEnabled = trafficEnabled }
+  }
+
+  @MainActor
+  var indoorEnabled: Bool? {
+    didSet { impl.indoorEnabled = indoorEnabled }
+  }
+
+  @MainActor
+  var customMapStyle: String? {
+    didSet {
+      if let value = customMapStyle {
+        impl.customMapStyle = try? GMSMapStyle(jsonString: value)
+      }
     }
   }
 
   @MainActor
-  var minZoomLevel: Double {
-    get { impl.minZoomLevel }
-    set { impl.minZoomLevel = newValue }
+  var userInterfaceStyle: RNUserInterfaceStyle? {
+    didSet {
+      impl.userInterfaceStyle = userInterfaceStyle?.toUIUserInterfaceStyle
+    }
+  }
+
+  @MainActor
+  var minZoomLevel: Double? {
+    didSet { impl.minZoomLevel = minZoomLevel }
+  }
+
+  @MainActor
+  var maxZoomLevel: Double? {
+    didSet { impl.maxZoomLevel = maxZoomLevel }
   }
 
   @MainActor
-  var maxZoomLevel: Double {
-    get { impl.maxZoomLevel }
-    set { impl.maxZoomLevel = newValue }
+  var mapPadding: RNMapPadding? {
+    didSet { impl.mapPadding = mapPadding }
   }
 
   @MainActor
-  var mapPadding: RNMapPadding {
-    get { impl.mapPadding }
-    set { impl.mapPadding = newValue }
+  var mapType: RNMapType? {
+    didSet {
+      impl.mapType = mapType.map {
+        GMSMapViewType(rawValue: UInt($0.rawValue)) ?? .normal
+      }
+    }
   }
 
   @MainActor
-  var markers: [RNMarker] = [] {
+  var markers: [RNMarker]? {
     didSet {
       let prevById = Dictionary(
-        oldValue.map { ($0.id, $0) },
+        (oldValue ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
       let nextById = Dictionary(
-        markers.map { ($0.id, $0) },
+        (markers ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
 
@@ -100,20 +128,20 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
 
         removed.forEach {
           impl.removeMarker(id: $0)
-          markerOptions.cancelIconTask($0)
+          markerBuilder.cancelIconTask($0)
         }
 
         for (id, next) in nextById {
           if let prev = prevById[id] {
             if !prev.markerEquals(next) {
               impl.updateMarker(id: id) { m in
-                self.markerOptions.updateMarker(prev, next, m)
+                self.markerBuilder.updateMarker(prev, next, m)
               }
             }
           } else {
-            markerOptions.buildIconAsync(next.id, next) { icon in
+            markerBuilder.buildIconAsync(next.id, next) { icon in
               guard let icon else { return }
-              let marker = self.markerOptions.build(next, icon: icon)
+              let marker = self.markerBuilder.build(next, icon: icon)
               self.impl.addMarker(id: id, marker: marker)
             }
           }
@@ -123,14 +151,14 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
   }
 
   @MainActor
-  var polylines: [RNPolyline] = [] {
+  var polylines: [RNPolyline]? {
     didSet {
       let prevById = Dictionary(
-        oldValue.map { ($0.id, $0) },
+        (oldValue ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
       let nextById = Dictionary(
-        polylines.map { ($0.id, $0) },
+        (polylines ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
 
@@ -140,29 +168,29 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
       for (id, next) in nextById {
         if let prev = prevById[id] {
           if !prev.polylineEquals(next) {
-            impl.updatePolyline(id: id) { gms in
-              prev.updatePolyline(next, gms)
+            impl.updatePolyline(id: id) { pl in
+              prev.updatePolyline(next, pl)
             }
-          } else {
-            impl.addPolyline(
-              id: id,
-              polyline: polylineOptions.buildPolyline(next)
-            )
           }
+        } else {
+          impl.addPolyline(
+            id: id,
+            polyline: polylineBuilder.buildPolyline(next)
+          )
         }
       }
     }
   }
 
   @MainActor
-  var polygons: [RNPolygon] = [] {
+  var polygons: [RNPolygon]? {
     didSet {
       let prevById = Dictionary(
-        oldValue.map { ($0.id, $0) },
+        (oldValue ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
       let nextById = Dictionary(
-        polygons.map { ($0.id, $0) },
+        (polygons ?? []).map { ($0.id, $0) },
         uniquingKeysWith: { _, new in new }
       )
 
@@ -177,73 +205,109 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
             }
           }
         } else {
-          impl.addPolygon(id: id, polygon: polygonOptions.buildPolygon(next))
+          impl.addPolygon(id: id, polygon: polygonBuilder.buildPolygon(next))
         }
       }
     }
   }
 
-  func setCamera(camera: RNCamera, animated: Bool?, durationMS: Double?) {
-    onMain {
-      self.impl.setCamera(
-        camera: camera,
-        animated: animated ?? true,
-        durationMS: durationMS ?? 3000
+  @MainActor
+  var circles: [RNCircle]? {
+    didSet {
+      let prevById = Dictionary(
+        (oldValue ?? []).map { ($0.id, $0) },
+        uniquingKeysWith: { _, new in new }
       )
+      let nextById = Dictionary(
+        (circles ?? []).map { ($0.id, $0) },
+        uniquingKeysWith: { _, new in new }
+      )
+
+      let removed = Set(prevById.keys).subtracting(nextById.keys)
+      removed.forEach { impl.removeCircle(id: $0) }
+
+      for (id, next) in nextById {
+        if let prev = prevById[id] {
+          if !prev.circleEquals(next) {
+            impl.updateCircle(id: id) { circle in
+              prev.updateCircle(next, circle)
+            }
+          }
+        } else {
+          impl.addCircle(id: id, circle: circleBuilder.buildCircle(next))
+        }
+      }
     }
   }
 
-  func setCameraToCoordinates(
-    coordinates: [RNLatLng],
-    padding: RNMapPadding?,
-    animated: Bool?,
-    durationMS: Double?
-  ) {
-    onMain {
-      self.impl.setCameraToCoordinates(
-        coordinates: coordinates,
-        padding: padding ?? RNMapPadding(0, 0, 0, 0),
-        animated: animated ?? true,
-        durationMS: durationMS ?? 3000
-      )
+  @MainActor var locationConfig: RNLocationConfig? {
+    didSet {
+      impl.locationConfig = locationConfig
     }
   }
 
   var onMapError: ((RNMapErrorCode) -> Void)? {
-    get { impl.onMapError }
-    set { impl.onMapError = newValue }
+    didSet { impl.onMapError = onMapError }
   }
   var onMapReady: ((Bool) -> Void)? {
-    get { impl.onMapReady }
-    set { impl.onMapReady = newValue }
+    didSet { impl.onMapReady = onMapReady }
   }
   var onLocationUpdate: ((RNLocation) -> Void)? {
-    get { impl.onLocationUpdate }
-    set { impl.onLocationUpdate = newValue }
+    didSet { impl.onLocationUpdate = onLocationUpdate }
   }
   var onLocationError: ((_ error: RNLocationErrorCode) -> Void)? {
-    get { impl.onLocationError }
-    set { impl.onLocationError = newValue }
+    didSet { impl.onLocationError = onLocationError }
   }
   var onMapPress: ((RNLatLng) -> Void)? {
-    get { impl.onMapPress }
-    set { impl.onMapPress = newValue }
+    didSet { impl.onMapPress = onMapPress }
   }
   var onMarkerPress: ((String) -> Void)? {
-    get { impl.onMarkerPress }
-    set { impl.onMarkerPress = newValue }
+    didSet { impl.onMarkerPress = onMarkerPress }
+  }
+  var onPolylinePress: ((String) -> Void)? {
+    didSet { impl.onPolylinePress = onPolylinePress }
+  }
+  var onPolygonPress: ((String) -> Void)? {
+    didSet { impl.onPolygonPress = onPolygonPress }
+  }
+  var onCirclePress: ((String) -> Void)? {
+    didSet { impl.onCirclePress = onCirclePress }
   }
   var onCameraChangeStart: ((RNRegion, RNCamera, Bool) -> Void)? {
-    get { impl.onCameraChangeStart }
-    set { impl.onCameraChangeStart = newValue }
+    didSet { impl.onCameraChangeStart = onCameraChangeStart }
   }
   var onCameraChange: ((RNRegion, RNCamera, Bool) -> Void)? {
-    get { impl.onCameraChange }
-    set { impl.onCameraChange = newValue }
+    didSet { impl.onCameraChange = onCameraChange }
   }
   var onCameraChangeComplete: ((RNRegion, RNCamera, Bool) -> Void)? {
-    get { impl.onCameraChangeComplete }
-    set { impl.onCameraChangeComplete = newValue }
+    didSet { impl.onCameraChangeComplete = onCameraChangeComplete }
+  }
+
+  func setCamera(camera: RNCamera, animated: Bool?, durationMS: Double?) {
+    let cam = camera.toGMSCameraPosition(current: impl.currentCamera)
+    onMain {
+      self.impl.setCamera(
+        camera: cam,
+        animated: animated ?? true,
+        durationMS: durationMS ?? 3000
+      )
+    }
+  }
+
+  func setCameraToCoordinates(
+    coordinates: [RNLatLng],
+    padding: RNMapPadding?,
+    animated: Bool?,
+    durationMS: Double?
+  ) {
+    onMain {
+      self.impl.setCameraToCoordinates(
+        coordinates: coordinates,
+        padding: padding ?? RNMapPadding(0, 0, 0, 0),
+        animated: animated ?? true,
+        durationMS: durationMS ?? 3000
+      )
+    }
   }
 
   func showLocationDialog() {
@@ -255,7 +319,7 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
   }
 
   func requestLocationPermission()
-    -> NitroModules.Promise<RNLocationPermissionResult> {
+  -> NitroModules.Promise<RNLocationPermissionResult> {
     return permissionHandler.requestLocationPermission()
   }
 
@@ -263,79 +327,6 @@ final class RNGoogleMapsPlusView: HybridRNGoogleMapsPlusViewSpec {
     /// not supported
     return true
   }
-
-  private func mapCameraToGMSCamera(_ c: RNCamera) -> GMSCameraPosition {
-    let current = impl.currentCamera
-    let center = CLLocationCoordinate2D(
-      latitude: c.center?.latitude ?? current.target.latitude,
-      longitude: c.center?.longitude ?? current.target.longitude
-    )
-    let z = Float(c.zoom ?? Double(current.zoom))
-    let b = c.bearing ?? current.bearing
-    let t = c.tilt ?? current.viewingAngle
-
-    return GMSCameraPosition.camera(
-      withTarget: center,
-      zoom: z,
-      bearing: b,
-      viewingAngle: t
-    )
-  }
-
-  private func mapCameraPositionToCamera(_ cp: GMSCameraPosition)
-    -> RNCamera {
-    return RNCamera(
-      center: RNLatLng(
-        latitude: cp.target.latitude,
-        longitude: cp.target.longitude
-      ),
-      zoom: Double(cp.zoom),
-      bearing: cp.bearing,
-      tilt: cp.viewingAngle
-    )
-  }
-
-  func mapUserInterfaceStyleToUIUserInterfaceStyle(
-    _ style: RNUserInterfaceStyle
-  )
-    -> UIUserInterfaceStyle {
-    switch style {
-    case .light: return .light
-    case .dark: return .dark
-    case .default: return .unspecified
-    }
-  }
-
-  func mapUIUserInterfaceStyletoUserInterfaceStyle(
-    _ uiStyle: UIUserInterfaceStyle
-  ) -> RNUserInterfaceStyle {
-    switch uiStyle {
-    case .light: return .light
-    case .dark: return .dark
-    case .unspecified: return .default
-    @unknown default: return .default
-    }
-  }
-}
-
-extension UIUserInterfaceStyle {
-  init?(fromString string: String) {
-    switch string.lowercased() {
-    case "light": self = .light
-    case "dark": self = .dark
-    case "default": self = .unspecified
-    default: return nil
-    }
-  }
-
-  var stringValue: String {
-    switch self {
-    case .light: return "light"
-    case .dark: return "dark"
-    case .unspecified: return "default"
-    @unknown default: return "default"
-    }
-  }
 }
 
 @inline(__always)

package/ios/extensions/RNCamera+Extension.swift

@@ -0,0 +1,22 @@
+import CoreLocation
+import GoogleMaps
+
+extension RNCamera {
+  func toGMSCameraPosition(current: GMSCameraPosition?) -> GMSCameraPosition {
+    let center = CLLocationCoordinate2D(
+      latitude: center?.latitude ?? current?.target.latitude ?? 0,
+      longitude: center?.longitude ?? current?.target.longitude ?? 0
+    )
+
+    let zoom = Float(zoom ?? Double(current?.zoom ?? 0))
+    let bearing = bearing ?? current?.bearing ?? 0
+    let tilt = tilt ?? current?.viewingAngle ?? 0
+
+    return GMSCameraPosition.camera(
+      withTarget: center,
+      zoom: zoom,
+      bearing: bearing,
+      viewingAngle: tilt
+    )
+  }
+}

package/ios/extensions/RNCircle+Extension.swift

@@ -0,0 +1,24 @@
+import GoogleMaps
+
+extension RNCircle {
+  func updateCircle(_ next: RNCircle, _ c: GMSCircle) {
+    c.position = CLLocationCoordinate2D(
+      latitude: next.center.latitude,
+      longitude: next.center.longitude
+    )
+    if let r = next.radius { c.radius = r }
+    if let fc = next.fillColor?.toUIColor() { c.fillColor = fc }
+    if let sc = next.strokeColor?.toUIColor() { c.strokeColor = sc }
+    if let sw = next.strokeWidth { c.strokeWidth = CGFloat(sw) }
+    if let pr = next.pressable { c.isTappable = pr }
+    if let zi = next.zIndex { c.zIndex = Int32(zi) }
+  }
+
+  func circleEquals(_ b: RNCircle) -> Bool {
+    zIndex == b.zIndex && pressable == b.pressable
+      && center.latitude == b.center.latitude
+      && center.longitude == b.center.longitude && radius == b.radius
+      && strokeWidth == b.strokeWidth && strokeColor == b.strokeColor
+      && fillColor == b.fillColor
+  }
+}

package/ios/extensions/RNIOSLocationAccuracy+Extensions.swift

@@ -0,0 +1,19 @@
+import CoreLocation
+
+extension RNIOSLocationAccuracy {
+  var toCLLocationAccuracy: CLLocationAccuracy {
+    switch self {
+    case .accuracyBest:
+      return kCLLocationAccuracyBest
+
+    case .accuracyNearestTenMeter:
+      return kCLLocationAccuracyNearestTenMeters
+
+    case .accuracyNearestHundredMeter:
+      return kCLLocationAccuracyHundredMeters
+
+    case .accuracyKilometer:
+      return kCLLocationAccuracyKilometer
+    }
+  }
+}

package/ios/extensions/RNMarker+Extension.swift

@@ -0,0 +1,24 @@
+import GoogleMaps
+
+extension RNMarker {
+  func markerEquals(_ b: RNMarker) -> Bool {
+    id == b.id && zIndex == b.zIndex
+      && coordinate.latitude == b.coordinate.latitude
+      && coordinate.longitude == b.coordinate.longitude
+      && anchor?.x == b.anchor?.x && anchor?.y == b.anchor?.y
+      && markerStyleEquals(b)
+  }
+
+  func markerStyleEquals(_ b: RNMarker) -> Bool {
+    width == b.width && height == b.height
+      && iconSvg == b.iconSvg
+  }
+
+  func styleHash() -> NSString {
+    var hasher = Hasher()
+    hasher.combine(width)
+    hasher.combine(height)
+    hasher.combine(iconSvg)
+    return String(hasher.finalize()) as NSString
+  }
+}

package/ios/{MapPolygon.swift → extensions/RNPolygon+Extension.swift.swift}

@@ -1,23 +1,5 @@
 import GoogleMaps
 
-class MapPolygonOptions {
-
-  func buildPolygon(_ p: RNPolygon) -> GMSPolygon {
-    let path = GMSMutablePath()
-    p.coordinates.forEach {
-      path.add(
-        CLLocationCoordinate2D(latitude: $0.latitude, longitude: $0.longitude)
-      )
-    }
-    let pg = GMSPolygon(path: path)
-    if let fc = p.fillColor?.toUIColor() { pg.fillColor = fc }
-    if let sc = p.strokeColor?.toUIColor() { pg.strokeColor = sc }
-    if let sw = p.strokeWidth { pg.strokeWidth = CGFloat(sw) }
-    pg.zIndex = Int32(p.zIndex)
-    return pg
-  }
-}
-
 extension RNPolygon {
   func updatePolygon(_ next: RNPolygon, _ pg: GMSPolygon) {
     let path = GMSMutablePath()
@@ -34,15 +16,17 @@ extension RNPolygon {
     if let fc = next.fillColor?.toUIColor() { pg.fillColor = fc }
     if let sc = next.strokeColor?.toUIColor() { pg.strokeColor = sc }
     if let sw = next.strokeWidth { pg.strokeWidth = CGFloat(sw) }
-    pg.zIndex = Int32(next.zIndex)
+    if let pr = next.pressable { pg.isTappable = pr }
+    if let zi = next.zIndex { pg.zIndex = Int32(zi) }
   }
 
   func polygonEquals(_ b: RNPolygon) -> Bool {
     guard zIndex == b.zIndex,
-      strokeWidth == b.strokeWidth,
-      fillColor == b.fillColor,
-      strokeColor == b.strokeColor,
-      coordinates.count == b.coordinates.count
+          pressable == b.pressable,
+          strokeWidth == b.strokeWidth,
+          fillColor == b.fillColor,
+          strokeColor == b.strokeColor,
+          coordinates.count == b.coordinates.count
     else { return false }
     for i in 0..<coordinates.count {
       if coordinates[i].latitude != b.coordinates[i].latitude

package/ios/extensions/RNPolyline+Extension.swift.swift

@@ -0,0 +1,62 @@
+import GoogleMaps
+
+extension RNPolyline {
+  func updatePolyline(_ next: RNPolyline, _ pl: GMSPolyline) {
+    let path = GMSMutablePath()
+    next.coordinates.forEach {
+      path.add(
+        CLLocationCoordinate2D(
+          latitude: $0.latitude,
+          longitude: $0.longitude
+        )
+      )
+    }
+    pl.path = path
+    if let w = next.width { pl.strokeWidth = CGFloat(w) }
+    if let cap = next.lineCap {
+      pl.spans = nil
+      /// gms.lineCap = mapLineCap(cap)
+    }
+    if let join = next.lineJoin {
+      /// gms.strokeJoin = mapLineJoin(join)
+    }
+    if let c = next.color?.toUIColor() {
+      pl.strokeColor = c
+    }
+    if let pr = next.pressable { pl.isTappable = pr }
+    if let zi = next.zIndex { pl.zIndex = Int32(zi) }
+  }
+
+  func polylineEquals(_ b: RNPolyline) -> Bool {
+    guard zIndex == b.zIndex,
+          (width ?? 0) == (b.width ?? 0),
+          lineCap == b.lineCap,
+          lineJoin == b.lineJoin,
+          color == b.color,
+          coordinates.count == b.coordinates.count
+    else { return false }
+    for i in 0..<coordinates.count {
+      if coordinates[i].latitude != b.coordinates[i].latitude
+        || coordinates[i].longitude != b.coordinates[i].longitude {
+        return false
+      }
+    }
+    return true
+  }
+
+  private func mapLineCap(_ t: RNLineCapType) -> CGLineCap {
+    switch t {
+    case .round: return .round
+    case .square: return .square
+    default: return .butt
+    }
+  }
+
+  private func mapLineJoin(_ t: RNLineJoinType) -> CGLineJoin {
+    switch t {
+    case .round: return .round
+    case .bevel: return .bevel
+    default: return .miter
+    }
+  }
+}

package/ios/extensions/RNUserInterface+Extension.swift

@@ -0,0 +1,16 @@
+import UIKit
+
+extension RNUserInterfaceStyle {
+  var toUIUserInterfaceStyle: UIUserInterfaceStyle {
+    switch self {
+    case .light:
+      return .light
+    case .dark:
+      return .dark
+    case .default:
+      return .unspecified
+    @unknown default:
+      return .unspecified
+    }
+  }
+}