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

package/ios/GoogleMapViewImpl.swift

@@ -5,65 +5,34 @@ import UIKit
 final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
 
   private let locationHandler: LocationHandler
-  private let markerOptions: MapMarkerOptions
-  private var mapView: GMSMapView!
+  private let markerBuilder: MapMarkerBuilder
+  private var mapView: GMSMapView?
+  private var initialized = false
   private var mapReady = false
 
-  private var pendingBuildingEnabled: Bool = false
-  private var pendingTrafficEnabled: Bool = false
-  private var pendingCustomMapStyle: GMSMapStyle?
-  private var pendingInitialCamera: GMSCameraPosition =
-    GMSCameraPosition.camera(withLatitude: 0, longitude: 0, zoom: 0)
-  private var pendingUserInterfaceStyle = UIUserInterfaceStyle.unspecified
-  private var pendingMinZoomLevel: Double = 0.0
-  private var pendingMaxZoomLevel: Double = 21.0
-  private var pendingMapPadding: RNMapPadding = .init(
-    top: 0,
-    left: 0,
-    bottom: 0,
-    right: 0
-  )
-
-  private var pendingPolygons: [(id: String, polygon: GMSPolygon)] = []
-  private var pendingPolylines: [(id: String, polyline: GMSPolyline)] = []
   private var pendingMarkers: [(id: String, marker: GMSMarker)] = []
+  private var pendingPolylines: [(id: String, polyline: GMSPolyline)] = []
+  private var pendingPolygons: [(id: String, polygon: GMSPolygon)] = []
+  private var pendingCircles: [(id: String, circle: GMSCircle)] = []
 
-  private var polygonsById: [String: GMSPolygon] = [:]
-  private var polylinesById: [String: GMSPolyline] = [:]
   private var markersById: [String: GMSMarker] = [:]
+  private var polylinesById: [String: GMSPolyline] = [:]
+  private var polygonsById: [String: GMSPolygon] = [:]
+  private var circlesById: [String: GMSCircle] = [:]
 
   private var cameraMoveReasonIsGesture: Bool = false
   private var lastSubmittedCameraPosition: GMSCameraPosition?
   private var lastSubmittedLocation: CLLocation?
 
-  var onMapError: ((RNMapErrorCode) -> Void)?
-  var onMapReady: ((Bool) -> Void)?
-  var onLocationUpdate: ((RNLocation) -> Void)?
-  var onLocationError: ((_ error: RNLocationErrorCode) -> Void)?
-  var onMapPress: ((RNLatLng) -> Void)?
-  var onMarkerPress: ((String) -> Void)?
-  var onCameraChangeStart: ((RNRegion, RNCamera, Bool) -> Void)?
-  var onCameraChange: ((RNRegion, RNCamera, Bool) -> Void)?
-  var onCameraChangeComplete: ((RNRegion, RNCamera, Bool) -> Void)?
-
   init(
     frame: CGRect = .zero,
     locationHandler: LocationHandler,
-    markerOptions: MapMarkerOptions
+    markerBuilder: MapMarkerBuilder
   ) {
     self.locationHandler = locationHandler
-    self.markerOptions = markerOptions
+    self.markerBuilder = markerBuilder
     super.init(frame: frame)
     setupAppLifecycleObservers()
-    setupMap()
-
-    /// wait 1 second if alle setter called
-    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
-      self?.initLocationCallbacks()
-      self?.applyPending()
-      self?.onMapReady?(true)
-      self?.mapReady = true
-    }
   }
 
   private func setupAppLifecycleObservers() {
@@ -86,14 +55,31 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
   }
 
   @MainActor
-  private func setupMap() {
+  func initMapView(mapId: String?, liteMode: Bool?, camera: GMSCameraPosition?) {
+    if initialized { return }
+    initialized = true
     let options = GMSMapViewOptions()
     options.frame = bounds
+    if let mapId = mapId {
+      options.mapID = GMSMapID(identifier: mapId)
+    }
+    if let liteMode = liteMode {
+      /// not supported
+    }
+    if let camera = camera {
+      options.camera = camera
+    }
     mapView = GMSMapView.init(options: options)
-    mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-    mapView.paddingAdjustmentBehavior = .never
-    mapView.delegate = self
-    addSubview(mapView)
+    mapView?.delegate = self
+    mapView?.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    mapView?.paddingAdjustmentBehavior = .never
+    if let mapView = mapView {
+      addSubview(mapView)
+    }
+    initLocationCallbacks()
+    applyPending()
+    onMapReady?(true)
+    mapReady = true
   }
 
   private func initLocationCallbacks() {
@@ -102,7 +88,7 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
       if self.lastSubmittedLocation?.coordinate.latitude
         != loc.coordinate.latitude
         || self.lastSubmittedLocation?.coordinate.longitude
-          != loc.coordinate.longitude {
+        != loc.coordinate.longitude {
         self.onLocationUpdate?(
           RNLocation(
             RNLatLng(
@@ -123,21 +109,92 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
 
   @MainActor
   private func applyPending() {
-    mapView.padding = UIEdgeInsets(
-      top: pendingMapPadding.top,
-      left: pendingMapPadding.left,
-      bottom: pendingMapPadding.bottom,
-      right: pendingMapPadding.right
-    )
 
-    mapView.mapStyle = pendingCustomMapStyle
-    mapView.isBuildingsEnabled = pendingBuildingEnabled
-    mapView.isTrafficEnabled = pendingTrafficEnabled
-    mapView.overrideUserInterfaceStyle = pendingUserInterfaceStyle
-    mapView.setMinZoom(
-      Float(pendingMinZoomLevel),
-      maxZoom: Float(pendingMaxZoomLevel)
-    )
+    if let padding = mapPadding {
+      mapView?.padding = UIEdgeInsets(
+        top: padding.top,
+        left: padding.left,
+        bottom: padding.bottom,
+        right: padding.right
+      )
+    }
+
+    if let uiSettings = uiSettings {
+      if let allGesturesEnabled = uiSettings.allGesturesEnabled {
+        mapView?.settings.setAllGesturesEnabled(allGesturesEnabled)
+      }
+      if let compassEnabled = uiSettings.compassEnabled {
+        mapView?.settings.compassButton = compassEnabled
+      }
+      if let indoorLevelPickerEnabled = uiSettings.indoorLevelPickerEnabled {
+        mapView?.settings.indoorPicker = indoorLevelPickerEnabled
+      }
+      if let mapToolbarEnabled = uiSettings.mapToolbarEnabled {
+        /// not supported
+      }
+      if let myLocationButtonEnabled = uiSettings.myLocationButtonEnabled {
+        mapView?.settings.myLocationButton = myLocationButtonEnabled
+      }
+      if let rotateEnabled = uiSettings.rotateEnabled {
+        mapView?.settings.rotateGestures = rotateEnabled
+      }
+      if let scrollEnabled = uiSettings.scrollEnabled {
+        mapView?.settings.scrollGestures = scrollEnabled
+      }
+      if let scrollDuringRotateOrZoomEnabled = uiSettings
+        .scrollDuringRotateOrZoomEnabled {
+        mapView?.settings.allowScrollGesturesDuringRotateOrZoom =
+          scrollDuringRotateOrZoomEnabled
+      }
+      if let tiltEnabled = uiSettings.tiltEnabled {
+        mapView?.settings.tiltGestures = tiltEnabled
+      }
+      if let zoomControlsEnabled = uiSettings.zoomControlsEnabled {
+        /// not supported
+      }
+      if let zoomGesturesEnabled = uiSettings.zoomGesturesEnabled {
+        mapView?.settings.zoomGestures = zoomGesturesEnabled
+      }
+    }
+
+    if let myLocation = myLocationEnabled {
+      mapView?.isMyLocationEnabled = myLocation
+    }
+
+    if let buildings = buildingEnabled {
+      mapView?.isBuildingsEnabled = buildings
+    }
+
+    if let traffic = trafficEnabled {
+      mapView?.isTrafficEnabled = traffic
+    }
+
+    if let indoor = indoorEnabled {
+      mapView?.isIndoorEnabled = indoor
+    }
+
+    if let style = customMapStyle {
+      mapView?.mapStyle = style
+    }
+
+    if let mapType = mapType {
+      mapView?.mapType = mapType
+    }
+
+    if let uiStyle = userInterfaceStyle {
+      mapView?.overrideUserInterfaceStyle = uiStyle
+    }
+
+    if let minZoom = minZoomLevel, let maxZoom = maxZoomLevel {
+      mapView?.setMinZoom(Float(minZoom), maxZoom: Float(maxZoom))
+    }
+
+    if let locationConfig = locationConfig {
+      locationHandler.desiredAccuracy =
+        locationConfig.ios?.desiredAccuracy?.toCLLocationAccuracy
+      locationHandler.distanceFilterMeters =
+        locationConfig.ios?.distanceFilterMeters
+    }
 
     if !pendingMarkers.isEmpty {
       pendingMarkers.forEach {
@@ -157,119 +214,209 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
       }
       pendingPolygons.removeAll()
     }
+    if !pendingCircles.isEmpty {
+      pendingCircles.forEach {
+        addCircleInternal(id: $0.id, circle: $0.circle)
+      }
+      pendingCircles.removeAll()
+    }
   }
 
-  var currentCamera: GMSCameraPosition {
-    mapView.camera
+  var currentCamera: GMSCameraPosition? {
+    mapView?.camera
   }
 
   @MainActor
-  var buildingEnabled: Bool {
-    get { mapView.isBuildingsEnabled }
-    set {
-      pendingBuildingEnabled = newValue
-      mapView.isBuildingsEnabled = newValue
+  var uiSettings: RNMapUiSettings? {
+    didSet {
+      guard let mapView = mapView else { return }
+      let settings = mapView.settings
+
+      if let v = uiSettings {
+        if let allGesturesEnabled = v.allGesturesEnabled {
+          settings.setAllGesturesEnabled(allGesturesEnabled)
+        }
+        if let compassEnabled = v.compassEnabled {
+          settings.compassButton = compassEnabled
+        }
+        if let indoorLevelPickerEnabled = v.indoorLevelPickerEnabled {
+          settings.indoorPicker = indoorLevelPickerEnabled
+        }
+        if let mapToolbarEnabled = v.mapToolbarEnabled {
+          /// not supported
+        }
+        if let myLocationButtonEnabled = v.myLocationButtonEnabled {
+          settings.myLocationButton = myLocationButtonEnabled
+        }
+        if let rotateEnabled = v.rotateEnabled {
+          settings.rotateGestures = rotateEnabled
+        }
+        if let scrollEnabled = v.scrollEnabled {
+          settings.scrollGestures = scrollEnabled
+        }
+        if let scrollDuringRotateOrZoomEnabled = v
+          .scrollDuringRotateOrZoomEnabled {
+          settings.allowScrollGesturesDuringRotateOrZoom =
+            scrollDuringRotateOrZoomEnabled
+        }
+        if let tiltEnabled = v.tiltEnabled {
+          settings.tiltGestures = tiltEnabled
+        }
+        if let zoomControlsEnabled = v.zoomControlsEnabled {
+          /// not supported
+        }
+        if let zoomGesturesEnabled = v.zoomGesturesEnabled {
+          settings.zoomGestures = zoomGesturesEnabled
+        }
+      } else {
+        settings.setAllGesturesEnabled(true)
+        settings.compassButton = false
+        settings.indoorPicker = false
+        settings.myLocationButton = false
+        settings.rotateGestures = true
+        settings.scrollGestures = true
+        settings.allowScrollGesturesDuringRotateOrZoom = true
+        settings.tiltGestures = true
+        settings.zoomGestures = false
+      }
     }
   }
 
   @MainActor
-  var trafficEnabled: Bool {
-    get { mapView.isTrafficEnabled }
-    set {
-      pendingTrafficEnabled = newValue
-      mapView.isTrafficEnabled = newValue
+  var myLocationEnabled: Bool? {
+    didSet {
+      if let value = myLocationEnabled {
+        mapView?.isMyLocationEnabled = value
+      } else {
+        mapView?.isMyLocationEnabled = false
+      }
     }
   }
 
   @MainActor
-  var customMapStyle: GMSMapStyle? {
-    get { pendingCustomMapStyle }
-    set {
-      pendingCustomMapStyle = newValue
-      mapView.mapStyle = newValue
+  var buildingEnabled: Bool? {
+    didSet {
+      if let value = buildingEnabled {
+        mapView?.isBuildingsEnabled = value
+      } else {
+        mapView?.isBuildingsEnabled = false
+      }
     }
   }
 
   @MainActor
-  var initialCamera: GMSCameraPosition {
-    get { pendingInitialCamera }
-    set {
-      pendingInitialCamera = newValue
-      if mapView != nil && !mapReady {
-        mapView.camera = newValue
+  var trafficEnabled: Bool? {
+    didSet {
+      if let value = trafficEnabled {
+        mapView?.isTrafficEnabled = value
+      } else {
+        mapView?.isTrafficEnabled = false
       }
     }
   }
 
   @MainActor
-  var userInterfaceStyle: UIUserInterfaceStyle {
-    get { pendingUserInterfaceStyle }
-    set {
-      pendingUserInterfaceStyle = newValue
-      mapView.overrideUserInterfaceStyle = newValue
+  var indoorEnabled: Bool? {
+    didSet {
+      if let value = indoorEnabled {
+        mapView?.isIndoorEnabled = value
+      } else {
+        mapView?.isIndoorEnabled = false
+      }
     }
   }
 
   @MainActor
-  var minZoomLevel: Double {
-    get { pendingMinZoomLevel }
-    set {
-      pendingMinZoomLevel = newValue
-      mapView.setMinZoom(Float(newValue), maxZoom: Float(pendingMaxZoomLevel))
+  var customMapStyle: GMSMapStyle? {
+    didSet {
+      if let style = customMapStyle {
+        mapView?.mapStyle = style
+      }
     }
   }
 
   @MainActor
-  var maxZoomLevel: Double {
-    get { pendingMaxZoomLevel }
-    set {
-      pendingMaxZoomLevel = newValue
-      mapView.setMinZoom(Float(pendingMinZoomLevel), maxZoom: Float(newValue))
+  var userInterfaceStyle: UIUserInterfaceStyle? {
+    didSet {
+      if let style = userInterfaceStyle {
+        mapView?.overrideUserInterfaceStyle = style
+      }
     }
   }
 
   @MainActor
-  var mapPadding: RNMapPadding {
-    get { pendingMapPadding }
-    set {
-      pendingMapPadding = newValue
-      mapView.padding = UIEdgeInsets(
-        top: newValue.top,
-        left: newValue.left,
-        bottom: newValue.bottom,
-        right: newValue.right
-      )
+  var minZoomLevel: Double? {
+    didSet {
+      if let min = minZoomLevel, let max = maxZoomLevel {
+        mapView?.setMinZoom(Float(min), maxZoom: Float(max))
+      }
     }
   }
 
-  func setCamera(camera: RNCamera, animated: Bool, durationMS: Double) {
-    let current = mapView.camera
+  @MainActor
+  var maxZoomLevel: Double? {
+    didSet {
+      if let max = maxZoomLevel, let min = minZoomLevel {
+        mapView?.setMinZoom(Float(min), maxZoom: Float(max))
+      }
+    }
+  }
+
+  @MainActor
+  var mapPadding: RNMapPadding? {
+    didSet {
+      if let padding = mapPadding {
+        mapView?.padding = UIEdgeInsets(
+          top: padding.top,
+          left: padding.left,
+          bottom: padding.bottom,
+          right: padding.right
+        )
+      } else {
+        mapView?.padding = .zero
+      }
+    }
+  }
 
-    let zoom = Float(camera.zoom ?? Double(current.zoom))
-    let bearing = camera.bearing ?? current.bearing
-    let viewingAngle = camera.bearing ?? current.viewingAngle
+  @MainActor var mapType: GMSMapViewType? {
+    didSet {
+      mapView?.mapType = mapType ?? .normal
+    }
+  }
 
-    let target = CLLocationCoordinate2D(
-      latitude: camera.center?.latitude ?? mapView.camera.target.latitude,
-      longitude: camera.center?.longitude ?? mapView.camera.target.longitude
-    )
+  @MainActor var locationConfig: RNLocationConfig? {
+    didSet {
+      locationHandler.desiredAccuracy =
+        locationConfig?.ios?.desiredAccuracy?.toCLLocationAccuracy
+      locationHandler.distanceFilterMeters =
+        locationConfig?.ios?.distanceFilterMeters
+    }
+  }
 
-    let cam = GMSCameraPosition.camera(
-      withTarget: target,
-      zoom: zoom,
-      bearing: bearing,
-      viewingAngle: viewingAngle
-    )
+  var onMapError: ((RNMapErrorCode) -> Void)?
+  var onMapReady: ((Bool) -> Void)?
+  var onLocationUpdate: ((RNLocation) -> Void)?
+  var onLocationError: ((_ error: RNLocationErrorCode) -> Void)?
+  var onMapPress: ((RNLatLng) -> Void)?
+  var onMarkerPress: ((String) -> Void)?
+  var onPolylinePress: ((String) -> Void)?
+  var onPolygonPress: ((String) -> Void)?
+  var onCirclePress: ((String) -> Void)?
+  var onCameraChangeStart: ((RNRegion, RNCamera, Bool) -> Void)?
+  var onCameraChange: ((RNRegion, RNCamera, Bool) -> Void)?
+  var onCameraChangeComplete: ((RNRegion, RNCamera, Bool) -> Void)?
+
+  func setCamera(camera: GMSCameraPosition, animated: Bool, durationMS: Double) {
     if animated {
       withCATransaction(
         disableActions: false,
         duration: durationMS / 1000.0
       ) {
-        mapView.animate(to: cam)
+        mapView?.animate(to: camera)
       }
     } else {
-      let update = GMSCameraUpdate.setCamera(cam)
-      mapView.moveCamera(update)
+      let update = GMSCameraUpdate.setCamera(camera)
+      mapView?.moveCamera(update)
     }
   }
 
@@ -315,10 +462,10 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
         disableActions: false,
         duration: durationMS / 1000.0
       ) {
-        mapView.animate(with: update)
+        mapView?.animate(with: update)
       }
     } else {
-      mapView.moveCamera(update)
+      mapView?.moveCamera(update)
     }
   }
 
@@ -427,19 +574,50 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
     pendingPolygons.removeAll()
   }
 
-  func clearAll() {
-    markerOptions.cancelAllIconTasks()
+  @MainActor
+  func addCircle(id: String, circle: GMSCircle) {
+    if mapView == nil {
+      pendingCircles.append((id, circle))
+      return
+    }
+    if let old = circlesById.removeValue(forKey: id) { old.map = nil }
+    addCircleInternal(id: id, circle: circle)
+  }
+
+  @MainActor
+  private func addCircleInternal(id: String, circle: GMSCircle) {
+    circle.map = mapView
+    circle.userData = id
+    circlesById[id] = circle
+  }
+
+  @MainActor
+  func updateCircle(id: String, block: @escaping (GMSCircle) -> Void) {
+    guard let circle = circlesById[id] else { return }
+    block(circle)
+  }
+
+  @MainActor
+  func removeCircle(id: String) {
+    if let circle = circlesById.removeValue(forKey: id) { circle.map = nil }
+  }
+
+  @MainActor
+  func clearCircles() {
+    circlesById.values.forEach { $0.map = nil }
+    circlesById.removeAll()
+    pendingCircles.removeAll()
+  }
+
+  func deinitInternal() {
+    markerBuilder.cancelAllIconTasks()
     clearMarkers()
     clearPolylines()
     clearPolygons()
+    clearCircles()
     locationHandler.stop()
-    clearMap()
-  }
-
-  @MainActor
-  func clearMap() {
-    mapView.clear()
-    mapView.delegate = nil
+    mapView?.clear()
+    mapView?.delegate = nil
     mapView = nil
   }
 
@@ -457,7 +635,7 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
     super.didMoveToWindow()
     if window != nil {
       if mapView != nil && mapReady {
-       onMapReady?(true)
+        onMapReady?(true)
       }
       locationHandler.start()
     } else {
@@ -467,7 +645,7 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
 
   deinit {
     NotificationCenter.default.removeObserver(self)
-    clearAll()
+    deinitInternal()
   }
 
   func mapView(_ mapView: GMSMapView, willMove gesture: Bool) {
@@ -504,11 +682,11 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
 
   func mapView(_ mapView: GMSMapView, didChange position: GMSCameraPosition) {
     if let last = lastSubmittedCameraPosition,
-      last.target.latitude == position.target.latitude,
-      last.target.longitude == position.target.longitude,
-      last.zoom == position.zoom,
-      last.bearing == position.bearing,
-      last.viewingAngle == position.viewingAngle {
+       last.target.latitude == position.target.latitude,
+       last.target.longitude == position.target.longitude,
+       last.zoom == position.zoom,
+       last.bearing == position.bearing,
+       last.viewingAngle == position.viewingAngle {
       return
     }
     let visibleRegion = mapView.projection.visibleRegion()
@@ -576,10 +754,11 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
     didTapAt coordinate: CLLocationCoordinate2D
   ) {
     onMapPress?(
-    RNLatLng(
-      latitude: coordinate.latitude,
-      longitude: coordinate.longitude
-    ))
+      RNLatLng(
+        latitude: coordinate.latitude,
+        longitude: coordinate.longitude
+      )
+    )
   }
 
   func mapView(_ mapView: GMSMapView, didTap marker: GMSMarker) -> Bool {
@@ -587,4 +766,23 @@ final class GoogleMapsViewImpl: UIView, GMSMapViewDelegate {
     onMarkerPress?(id)
     return true
   }
+
+  func mapView(_ mapView: GMSMapView, didTap overlay: GMSOverlay) {
+    switch overlay {
+    case let circle as GMSCircle:
+      let id = (circle.userData as? String) ?? "unknown"
+      onCirclePress?(id)
+
+    case let polygon as GMSPolygon:
+      let id = (polygon.userData as? String) ?? "unknown"
+      onPolygonPress?(id)
+
+    case let polyline as GMSPolyline:
+      let id = (polyline.userData as? String) ?? "unknown"
+      onPolylinePress?(id)
+
+    default:
+      break
+    }
+  }
 }