react-native-google-maps-plus 0.1.0 → 1.0.0-dev.1

package/ios/LocationHandler.swift

@@ -0,0 +1,205 @@
+import CoreLocation
+import Foundation
+import UIKit
+
+final class LocationHandler: NSObject, CLLocationManagerDelegate {
+
+  private let manager = CLLocationManager()
+  private var priority: Int = Priority.highAccuracy.rawValue
+  private var interval: TimeInterval = 5.0
+  private var minUpdateInterval: TimeInterval = 5.0
+  private var distanceFilterMeters: CLLocationDistance = kCLDistanceFilterNone
+
+  var onUpdate: ((CLLocation) -> Void)?
+  var onError: ((_ error: RNLocationErrorCode) -> Void)?
+
+  private var lastEmit: Date?
+
+  override init() {
+    super.init()
+    manager.delegate = self
+    manager.pausesLocationUpdatesAutomatically = true
+    manager.activityType = .other
+    applyPriority()
+  }
+
+  func setPriority(_ priority: Int) {
+    self.priority = priority
+    applyPriority()
+  }
+
+  func setInterval(_ seconds: Int) {
+    self.interval = max(0, TimeInterval(seconds))
+  }
+
+  func setFastestInterval(_ seconds: Int) {
+    self.minUpdateInterval = max(0, TimeInterval(seconds))
+  }
+
+  func setDistanceFilter(_ meters: Double) {
+    self.distanceFilterMeters = meters >= 0 ? meters : kCLDistanceFilterNone
+    manager.distanceFilter = distanceFilterMeters
+  }
+
+  func showLocationDialog() {
+    DispatchQueue.main.async {
+      guard let vc = Self.topMostViewController() else { return }
+      let title =
+        Bundle.main.object(forInfoDictionaryKey: "LocationNotAvailableTitle")
+        as? String
+      let message =
+        Bundle.main.object(forInfoDictionaryKey: "LocationNotAvailableMessage")
+        as? String
+      let cancelButton =
+        Bundle.main.object(forInfoDictionaryKey: "CancelButton") as? String
+      let openLocationSettingsButton =
+        Bundle.main.object(forInfoDictionaryKey: "OpenLocationAlertButton")
+        as? String
+
+      let alert = UIAlertController(
+        title: title ?? "Location not available",
+        message: message ?? "Please check your location settings.",
+        preferredStyle: .alert
+      )
+      alert.addAction(
+        UIAlertAction(title: cancelButton ?? "Cancel", style: .cancel)
+      )
+      alert.addAction(
+        UIAlertAction(
+          title: openLocationSettingsButton ?? "Open settings",
+          style: .default
+        ) { _ in
+          self.openLocationSettings()
+        }
+      )
+      vc.present(alert, animated: true, completion: nil)
+    }
+  }
+
+  func start() {
+    stop()
+    startUpdates()
+  }
+
+  func stop() {
+    manager.stopUpdatingLocation()
+  }
+
+  func openLocationSettings() {
+    DispatchQueue.main.async {
+      let openSettings = {
+        if #available(iOS 18.3, *) {
+          guard
+            let url = URL(
+              string: UIApplication.openDefaultApplicationsSettingsURLString
+            )
+          else {
+            return
+          }
+          UIApplication.shared.open(url, options: [:], completionHandler: nil)
+        } else {
+          guard let url = URL(string: UIApplication.openSettingsURLString)
+          else {
+            return
+          }
+          UIApplication.shared.open(url, options: [:], completionHandler: nil)
+        }
+      }
+
+      openSettings()
+    }
+  }
+
+  private func applyPriority() {
+    guard let p = Priority(rawValue: priority) else {
+      manager.desiredAccuracy = kCLLocationAccuracyBest
+      return
+    }
+    switch p {
+    case .highAccuracy:
+      manager.desiredAccuracy = kCLLocationAccuracyBest
+    case .balanced:
+      manager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+    case .lowPower:
+      manager.desiredAccuracy = kCLLocationAccuracyHundredMeters
+    case .passive:
+      manager.desiredAccuracy = kCLLocationAccuracyKilometer
+    }
+  }
+
+  private func startUpdates() {
+    manager.distanceFilter = distanceFilterMeters
+    manager.startUpdatingLocation()
+  }
+
+  private func shouldEmit(now: Date) -> Bool {
+    if let last = lastEmit {
+      let delta = now.timeIntervalSince(last)
+      if delta < minUpdateInterval { return false }
+    }
+    return true
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didFailWithError error: Error
+  ) {
+    let code: RNLocationErrorCode
+
+    if let clError = error as? CLError {
+      switch clError.code {
+      case .denied:
+        code = RNLocationErrorCode.permissionDenied
+      case .locationUnknown, .network:
+        code = RNLocationErrorCode.positionUnavailable
+      default:
+        code = RNLocationErrorCode.internalError
+      }
+    } else {
+      code = RNLocationErrorCode.internalError
+    }
+    onError?(code)
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didUpdateLocations locations: [CLLocation]
+  ) {
+    guard let loc = locations.last else { return }
+    let now = Date()
+
+    if shouldEmit(now: now) {
+      lastEmit = now
+      onUpdate?(loc)
+    }
+  }
+
+  private static func topMostViewController() -> UIViewController? {
+    let scenes = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .filter { $0.activationState == .foregroundActive }
+
+    guard
+      let window = scenes.flatMap({ $0.windows }).first(where: {
+        $0.isKeyWindow
+      }),
+      var top = window.rootViewController
+    else { return nil }
+
+    while let presented = top.presentedViewController { top = presented }
+    return top
+  }
+
+}
+
+extension LocationHandler {
+  enum Priority: Int {
+    case highAccuracy = 100
+    /// Android: PRIORITY_BALANCED_POWER_ACCURACY
+    case balanced = 102
+    /// Android: PRIORITY_LOW_POWER
+    case lowPower = 104
+    /// Android: PRIORITY_PASSIVE
+    case passive = 105
+  }
+}

package/ios/MapCircle.swift

@@ -0,0 +1,43 @@
+import GoogleMaps
+
+class MapCircleOptions {
+
+  func buildCircle(_ c: RNCircle) -> GMSCircle {
+    let circle = GMSCircle()
+    circle.position = CLLocationCoordinate2D(
+      latitude: c.center.latitude,
+      longitude: c.center.longitude
+    )
+    if let r = c.radius { circle.radius = r }
+    if let fc = c.fillColor?.toUIColor() { circle.fillColor = fc }
+    if let sc = c.strokeColor?.toUIColor() { circle.strokeColor = sc }
+    if let sw = c.strokeWidth { circle.strokeWidth = CGFloat(sw) }
+    if let pr = c.pressable { circle.isTappable = pr }
+    if let zi = c.zIndex { circle.zIndex = Int32(zi) }
+
+    return circle
+  }
+}
+
+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/MapHelper.swift

@@ -0,0 +1,18 @@
+import QuartzCore
+
+@inline(__always)
+func withCATransaction(
+  disableActions: Bool = true,
+  duration: CFTimeInterval? = nil,
+  timingFunction: CAMediaTimingFunction? = nil,
+  completion: (() -> Void)? = nil,
+  _ body: () -> Void
+) {
+  CATransaction.begin()
+  if disableActions { CATransaction.setDisableActions(true) }
+  if let d = duration { CATransaction.setAnimationDuration(d) }
+  if let tf = timingFunction { CATransaction.setAnimationTimingFunction(tf) }
+  if let c = completion { CATransaction.setCompletionBlock(c) }
+  body()
+  CATransaction.commit()
+}

package/ios/MapMarker.swift

@@ -0,0 +1,200 @@
+import GoogleMaps
+import SVGKit
+import UIKit
+
+final class MapMarkerOptions {
+  private let iconCache = NSCache<NSString, UIImage>()
+  private var tasks: [String: Task<Void, Never>] = [:]
+  private let queue = DispatchQueue(
+    label: "map.marker.render",
+    qos: .userInitiated,
+    attributes: .concurrent
+  )
+
+  func build(_ m: RNMarker, icon: UIImage) -> GMSMarker {
+    let marker = GMSMarker(
+      position: CLLocationCoordinate2D(
+        latitude: m.coordinate.latitude,
+        longitude: m.coordinate.longitude
+      )
+    )
+    marker.userData = m.id
+    marker.tracksViewChanges = true
+    marker.icon = icon
+    marker.groundAnchor = CGPoint(
+      x: m.anchor?.x ?? 0.5,
+      y: m.anchor?.y ?? 0.5
+    )
+    if let zi = m.zIndex { marker.zIndex = Int32(zi) }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak marker] in
+      marker?.tracksViewChanges = false
+    }
+    return marker
+  }
+
+  @MainActor
+  func buildIconAsync(
+    _ id: String,
+    _ m: RNMarker,
+    onReady: @escaping (UIImage?) -> Void
+  ) {
+    tasks[id]?.cancel()
+
+    let key = m.styleHash()
+    if let cached = iconCache.object(forKey: key) {
+      onReady(cached)
+      return
+    }
+
+    let task = Task(priority: .userInitiated) { [weak self] in
+      guard let self else { return }
+      defer {
+        self.tasks.removeValue(forKey: id)
+      }
+
+      let img = await self.renderUIImage(m)
+      guard let img, !Task.isCancelled else {
+        return
+      }
+
+      self.iconCache.setObject(img, forKey: key)
+
+      await MainActor.run {
+        guard !Task.isCancelled else { return }
+        onReady(img)
+      }
+
+    }
+
+    tasks[id] = task
+  }
+
+  @MainActor
+  func updateMarker(_ prev: RNMarker, _ next: RNMarker, _ m: GMSMarker) {
+    m.position = CLLocationCoordinate2D(
+      latitude: next.coordinate.latitude,
+      longitude: next.coordinate.longitude
+    )
+
+    if let zi = next.zIndex { m.zIndex = Int32(zi) }
+
+    m.groundAnchor = CGPoint(
+      x: next.anchor?.x ?? 0.5,
+      y: next.anchor?.y ?? 0.5
+    )
+
+    if !prev.markerStyleEquals(next) {
+      buildIconAsync(next.id, next) { img in
+        guard let img else { return }
+        m.tracksViewChanges = true
+        m.icon = img
+        if prev.anchor?.x != next.anchor?.x || prev.anchor?.y != next.anchor?.y {
+          m.groundAnchor = CGPoint(
+            x: next.anchor?.x ?? 0.5,
+            y: next.anchor?.y ?? 0.5
+          )
+        }
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak m] in
+          m?.tracksViewChanges = false
+        }
+      }
+    }
+  }
+
+  func cancelIconTask(_ id: String) {
+    tasks[id]?.cancel()
+    tasks.removeValue(forKey: id)
+  }
+
+  func cancelAllIconTasks() {
+    let ids = Array(tasks.keys)
+    for id in ids {
+      tasks[id]?.cancel()
+    }
+    tasks.removeAll()
+    iconCache.removeAllObjects()
+  }
+
+  private func renderUIImage(_ m: RNMarker) async -> UIImage? {
+    await withTaskCancellationHandler(
+      operation: {
+        await withCheckedContinuation { cont in
+          queue.async {
+            if Task.isCancelled {
+              cont.resume(returning: nil)
+              return
+            }
+
+            let targetW = max(1, Int(CGFloat(m.width)))
+            let targetH = max(1, Int(CGFloat(m.height)))
+            let size = CGSize(width: targetW, height: targetH)
+
+            guard
+              let data = m.iconSvg.data(using: .utf8),
+              let svgImg = SVGKImage(data: data)
+            else {
+              cont.resume(returning: nil)
+              return
+            }
+
+            svgImg.size = size
+
+            if Task.isCancelled {
+              cont.resume(returning: nil)
+              return
+            }
+
+            guard let base = svgImg.uiImage else {
+              cont.resume(returning: nil)
+              return
+            }
+
+            let scale = UIScreen.main.scale
+            let img: UIImage
+            if let cg = base.cgImage {
+              img = UIImage(cgImage: cg, scale: scale, orientation: .up)
+            } else {
+              let fmt = UIGraphicsImageRendererFormat.default()
+              fmt.opaque = false
+              fmt.scale = scale
+              let renderer = UIGraphicsImageRenderer(size: size, format: fmt)
+              img = renderer.image { _ in
+                base.draw(in: CGRect(origin: .zero, size: size))
+              }
+            }
+
+            cont.resume(returning: img)
+          }
+        }
+
+      },
+      onCancel: {}
+    )
+  }
+
+}
+
+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

@@ -0,0 +1,58 @@
+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) }
+    if let pr = p.pressable { pg.isTappable = pr }
+    if let zi = p.zIndex { pg.zIndex = Int32(zi) }
+    return pg
+  }
+}
+
+extension RNPolygon {
+  func updatePolygon(_ next: RNPolygon, _ pg: GMSPolygon) {
+    let path = GMSMutablePath()
+    next.coordinates.forEach {
+      path.add(
+        CLLocationCoordinate2D(
+          latitude: $0.latitude,
+          longitude: $0.longitude
+        )
+      )
+    }
+    pg.path = path
+
+    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) }
+    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,
+          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
+        || coordinates[i].longitude != b.coordinates[i].longitude {
+        return false
+      }
+    }
+    return true
+  }
+}

package/ios/MapPolyline.swift

@@ -0,0 +1,85 @@
+import GoogleMaps
+
+class MapPolylineOptions {
+  func buildPolyline(_ p: RNPolyline) -> GMSPolyline {
+    let path = GMSMutablePath()
+    p.coordinates.forEach {
+      path.add(
+        CLLocationCoordinate2D(latitude: $0.latitude, longitude: $0.longitude)
+      )
+    }
+    let pl = GMSPolyline(path: path)
+    if let w = p.width { pl.strokeWidth = CGFloat(w) }
+    if let c = p.color?.toUIColor() { pl.strokeColor = c }
+    if let cap = p.lineCap {
+      /// pl.lineCap = mapLineCap(cap)
+    }
+    if let join = p.lineJoin {
+      /// pl.strokeJoin = mapLineJoin(join)
+    }
+    if let pr = p.pressable { pl.isTappable = pr }
+    if let zi = p.zIndex { pl.zIndex = Int32(zi) }
+    return pl
+  }
+}
+
+func mapLineCap(_ t: RNLineCapType?) -> CGLineCap {
+  switch t {
+  case .round: return .round
+  case .square: return .square
+  default: return .butt
+  }
+}
+
+func mapLineJoin(_ t: RNLineJoinType?) -> CGLineJoin {
+  switch t {
+  case .round: return .round
+  case .bevel: return .bevel
+  default: return .miter
+  }
+}
+
+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
+  }
+}

package/ios/PermissionHandler.swift

@@ -0,0 +1,73 @@
+import CoreLocation
+import Foundation
+import NitroModules
+import UIKit
+
+final class PermissionHandler: NSObject, CLLocationManagerDelegate {
+  private let manager = CLLocationManager()
+  private var pendingPromises:
+    [NitroModules.Promise<RNLocationPermissionResult>] = []
+
+  override init() {
+    super.init()
+    manager.delegate = self
+  }
+
+  func requestLocationPermission()
+  -> NitroModules.Promise<RNLocationPermissionResult> {
+    let promise = NitroModules.Promise<RNLocationPermissionResult>()
+
+    let status = manager.authorizationStatus
+    switch status {
+    case .authorizedAlways, .authorizedWhenInUse:
+      promise.resolve(
+        withResult: RNLocationPermissionResult(
+          android: nil,
+          ios: RNIOSPermissionResult.authorized
+        )
+      )
+      return promise
+    case .denied, .restricted:
+      promise.resolve(
+        withResult: RNLocationPermissionResult(
+          android: nil,
+          ios: RNIOSPermissionResult.denied
+        )
+      )
+      return promise
+    case .notDetermined:
+      break
+    @unknown default:
+      break
+    }
+
+    pendingPromises.append(promise)
+    manager.requestWhenInUseAuthorization()
+
+    return promise
+  }
+
+  func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+    guard !pendingPromises.isEmpty else { return }
+
+    let status: RNIOSPermissionResult
+    switch manager.authorizationStatus {
+    case .authorizedWhenInUse, .authorizedAlways:
+      status = RNIOSPermissionResult.authorized
+    case .denied, .restricted:
+      status = RNIOSPermissionResult.denied
+    case .notDetermined:
+      return
+    @unknown default:
+      status = RNIOSPermissionResult.denied
+    }
+
+    let promises = pendingPromises
+    pendingPromises.removeAll()
+    promises.forEach {
+      $0.resolve(
+        withResult: RNLocationPermissionResult(android: nil, ios: status)
+      )
+    }
+  }
+}

package/ios/RNGoogleMapsPlusModule.swift

@@ -0,0 +1,27 @@
+final class RNGoogleMapsPlusModule: HybridRNGoogleMapsPlusModuleSpec {
+  private let permissionHandler: PermissionHandler
+  private let locationHandler: LocationHandler
+
+  override init() {
+    self.permissionHandler = PermissionHandler()
+    self.locationHandler = LocationHandler()
+  }
+
+  func showLocationDialog() {
+    locationHandler.showLocationDialog()
+  }
+
+  func openLocationSettings() {
+    locationHandler.openLocationSettings()
+  }
+
+  func requestLocationPermission()
+  -> NitroModules.Promise<RNLocationPermissionResult> {
+    return permissionHandler.requestLocationPermission()
+  }
+
+  func isGooglePlayServicesAvailable() -> Bool {
+    /// not supported
+    return true
+  }
+}