@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.0

package/android/src/main/kotlin/com/margelo/nitro/nitromap/providers/google/MarkerTagData.kt

@@ -0,0 +1,19 @@
+package com.margelo.nitro.nitromap.providers.google
+
+/**
+ * Type-safe marker tag data. Replaces loose `Any?` tag union
+ * (String | ClusterUserData | "__user_location__") with exhaustive
+ * sealed class for compile-time safety.
+ *
+ * Set on `Marker.tag` and matched with `when` in GoogleMapDelegate.
+ */
+sealed class MarkerTagData {
+    /** Regular user-added marker with its ID. */
+    data class Regular(val markerId: String) : MarkerTagData()
+
+    /** Cluster icon representing multiple markers. */
+    data class Cluster(val markerIds: List<String>, val count: Int) : MarkerTagData()
+
+    /** Custom user location marker. */
+    data object UserLocation : MarkerTagData()
+}

package/ios/Location/NitroLocationManager.swift

@@ -0,0 +1,116 @@
+import CoreLocation
+import Foundation
+
+/// Provider-agnostic location manager that wraps CLLocationManager.
+/// Lives at the NitroMap facade level, not tied to any specific map SDK.
+/// Provides location updates + compass heading for custom user location markers.
+class NitroLocationManager: NSObject, CLLocationManagerDelegate {
+
+  // MARK: - Properties
+
+  private let locationManager = CLLocationManager()
+  private var isRunning = false
+
+  var onLocationUpdate: ((_ location: CLLocation, _ heading: CLHeading?) -> Void)?
+
+  /// Called when location services fail
+  var onLocationError: ((_ code: String, _ message: String) -> Void)?
+
+  /// Latest heading (kept for marker rotation)
+  private(set) var latestHeading: CLHeading?
+  /// Latest location
+  private(set) var latestLocation: CLLocation?
+
+  // MARK: - Init
+
+  override init() {
+    super.init()
+    locationManager.delegate = self
+    locationManager.desiredAccuracy = kCLLocationAccuracyBest
+    locationManager.distanceFilter = 1 // Update every 1 meter
+    locationManager.headingFilter = 1 // Update every 1 degree
+  }
+
+  // MARK: - Public API
+
+  func startUpdating() {
+    guard !isRunning else { return }
+    isRunning = true
+
+    // Request permission if not yet determined
+    let status = locationManager.authorizationStatus
+    if status == .notDetermined {
+      locationManager.requestWhenInUseAuthorization()
+    }
+
+    locationManager.startUpdatingLocation()
+    locationManager.startUpdatingHeading()
+  }
+
+  func stopUpdating() {
+    guard isRunning else { return }
+    isRunning = false
+    locationManager.stopUpdatingLocation()
+    locationManager.stopUpdatingHeading()
+    latestLocation = nil
+    latestHeading = nil
+  }
+
+  // MARK: - CLLocationManagerDelegate
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didUpdateLocations locations: [CLLocation]
+  ) {
+    guard let location = locations.last else { return }
+    latestLocation = location
+    onLocationUpdate?(location, latestHeading)
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didUpdateHeading newHeading: CLHeading
+  ) {
+    latestHeading = newHeading
+    // Fire update with latest location + new heading
+    if let location = latestLocation {
+      onLocationUpdate?(location, newHeading)
+    }
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didChangeAuthorization status: CLAuthorizationStatus
+  ) {
+    // If permission just granted, start updating
+    if isRunning && (status == .authorizedWhenInUse || status == .authorizedAlways) {
+      locationManager.startUpdatingLocation()
+      locationManager.startUpdatingHeading()
+    }
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didFailWithError error: Error
+  ) {
+    let code: String
+    if let clError = error as? CLError {
+      switch clError.code {
+      case .denied:
+        code = "LOCATION_PERMISSION_DENIED"
+      case .locationUnknown:
+        code = "LOCATION_UNKNOWN"
+      case .network:
+        code = "LOCATION_NETWORK_ERROR"
+      default:
+        code = "LOCATION_ERROR"
+      }
+    } else {
+      code = "LOCATION_ERROR"
+    }
+    onLocationError?(code, error.localizedDescription)
+    #if DEBUG
+    NSLog("[NitroLocationManager] Error: %@", error.localizedDescription)
+    #endif
+  }
+}

package/ios/MarkerRenderer/MarkerIconFactory.swift

@@ -33,8 +33,6 @@ final class MarkerIconCache {
   }
 
   @objc private func handleMemoryWarning() {
-    // Clear half the cache on memory warning instead of all
-    // This keeps frequently used icons while freeing memory
     #if DEBUG
     print("[MarkerIconCache] Memory warning received, clearing caches")
     #endif
@@ -255,7 +253,7 @@ class MarkerIconFactory {
 
         // Post notification for markers to refresh their icons
         NotificationCenter.default.post(
-          name: Notification.Name("MarkerIconLoaded"),
+          name: GoogleMapProvider.markerIconLoadedNotification,
           object: nil,
           userInfo: ["cacheKey": cacheKey, "icon": finalIcon]
         )

package/ios/MarkerRenderer/PriceMarkerRenderer.swift

@@ -33,16 +33,20 @@ class PriceMarkerRenderer {
         )
       }
       
+      let bg = PriceMarkerRenderer.variantToUIColor(config.backgroundColor) ?? .white
+      let text = PriceMarkerRenderer.variantToUIColor(config.textColor)
+        ?? UIColor(red: 51/255, green: 51/255, blue: 51/255, alpha: 1)
+
       return Style(
         price: config.price,
         currency: config.currency,
         selected: config.selected,
-        backgroundColor: PriceMarkerRenderer.variantToUIColor(config.backgroundColor) ?? .white,
-        selectedBackgroundColor: PriceMarkerRenderer.variantToUIColor(config.selectedBackgroundColor)
-          ?? UIColor(red: 255/255, green: 59/255, blue: 48/255, alpha: 1),
-        textColor: PriceMarkerRenderer.variantToUIColor(config.textColor)
-          ?? UIColor(red: 51/255, green: 51/255, blue: 51/255, alpha: 1),
-        selectedTextColor: PriceMarkerRenderer.variantToUIColor(config.selectedTextColor) ?? .white,
+        backgroundColor: bg,
+        // Fall back to normal colors when consumer doesn't provide selection colors.
+        // This way selectMarker() only shows the info window without changing the icon.
+        selectedBackgroundColor: PriceMarkerRenderer.variantToUIColor(config.selectedBackgroundColor) ?? bg,
+        textColor: text,
+        selectedTextColor: PriceMarkerRenderer.variantToUIColor(config.selectedTextColor) ?? text,
         fontSize: CGFloat(config.fontSize ?? 10),
         paddingHorizontal: CGFloat(config.paddingHorizontal ?? 8),
         paddingVertical: CGFloat(config.paddingVertical ?? 6),

package/ios/NitroMap.swift

@@ -1,8 +1,9 @@
 import Foundation
 import NitroModules
 import UIKit
+import CoreLocation
 
-/// HybridNitroMap - Google Maps powered map view.
+/// HybridNitroMap - Provider-agnostic map view facade.
 ///
 /// Threading contract:
 /// - All UI/SDK operations are dispatched to main thread HERE.
@@ -23,11 +24,11 @@ class HybridNitroMap: HybridNitroMapSpec {
   /// The provider is created lazily on first `afterUpdate()` or first
   /// imperative method call. This avoids premature init before the view
   /// has valid bounds.
-  private var _provider: GoogleMapProvider?
+  private var _provider: MapProviderProtocol?
 
   /// Returns the provider, initializing it if needed.
   /// Must be called from the main thread.
-  private var mapProvider: GoogleMapProvider {
+  private var mapProvider: MapProviderProtocol {
     if _provider == nil {
       initializeProvider()
     }
@@ -35,7 +36,7 @@ class HybridNitroMap: HybridNitroMapSpec {
   }
 
   private func initializeProvider() {
-    let provider = GoogleMapProvider()
+    let provider = MapProviderFactory.create(for: self.provider ?? .google)
     provider.setup()
 
     let providerView = provider.mapView
@@ -47,18 +48,34 @@ class HybridNitroMap: HybridNitroMapSpec {
     applyCurrentSettings(to: provider)
   }
 
-  private func applyCurrentSettings(to provider: GoogleMapProvider) {
-    provider.initialRegion = initialRegion
+  /// Returns `nil` when the region is the JS sentinel (negative deltas).
+  private func filterSentinel(_ r: Region?) -> Region? {
+    guard let r = r, r.latitudeDelta >= 0, r.longitudeDelta >= 0 else { return nil }
+    return r
+  }
+
+  private func applyCurrentSettings(to provider: MapProviderProtocol) {
+    provider.initialRegion = filterSentinel(initialRegion)
+    provider.region = filterSentinel(region)
     provider.showsUserLocation = showsUserLocation
     provider.zoomEnabled = zoomEnabled
     provider.scrollEnabled = scrollEnabled
     provider.rotateEnabled = rotateEnabled
     provider.pitchEnabled = pitchEnabled
     provider.mapType = mapType
-    provider.showsMyLocationButton = showsMyLocationButton
     provider.clusterConfig = clusterConfig
     provider.customMapStyle = customMapStyle
     provider.darkMode = darkMode
+    provider.mapPadding = mapPadding
+    provider.showsTraffic = showsTraffic
+    provider.showsBuildings = showsBuildings
+    provider.showsCompass = showsCompass
+    provider.minZoom = minZoom
+    provider.maxZoom = maxZoom
+    provider.userTrackingMode = userTrackingMode
+    provider.userLocationImage = userLocationImage
+    provider.userLocationSize = userLocationSize
+    provider.userLocationAnchor = userLocationAnchor
 
     provider.onPress = onPress
     provider.onLongPress = onLongPress
@@ -71,6 +88,55 @@ class HybridNitroMap: HybridNitroMapSpec {
     provider.onMarkerDragEnd = onMarkerDragEnd
     provider.onClusterPress = onClusterPress
     provider.onError = onError
+    provider.onUserTrackingModeChange = onUserTrackingModeChange
+    provider.onMapIdle = onMapIdle
+    provider.onPolylinePress = onPolylinePress
+    provider.onPolygonPress = onPolygonPress
+    provider.onCirclePress = onCirclePress
+
+    // Start location manager if needed
+    if showsUserLocation == true {
+      startLocationManager()
+    }
+  }
+
+  // MARK: - Location Manager
+
+  private lazy var locationManager: NitroLocationManager = {
+    let mgr = NitroLocationManager()
+    mgr.onLocationUpdate = { [weak self] location, heading in
+      self?.handleLocationUpdate(location, heading: heading)
+    }
+    mgr.onLocationError = { [weak self] code, message in
+      self?.onUserLocationError?(MapError(code: code, message: message))
+    }
+    return mgr
+  }()
+
+  private func startLocationManager() {
+    locationManager.startUpdating()
+  }
+
+  private func stopLocationManager() {
+    locationManager.stopUpdating()
+  }
+
+  private func handleLocationUpdate(_ location: CLLocation, heading: CLHeading?) {
+    // Forward to provider for marker/camera management
+    _provider?.updateUserLocation(location, heading: heading)
+
+    // Fire JS callback
+    let headingValue = heading?.trueHeading ?? (location.course >= 0 ? location.course : -1)
+    let event = UserLocationChangeEvent(
+      coordinate: Coordinate(
+        latitude: location.coordinate.latitude,
+        longitude: location.coordinate.longitude
+      ),
+      accuracy: location.horizontalAccuracy,
+      heading: headingValue,
+      speed: location.speed >= 0 ? location.speed : -1
+    )
+    onUserLocationChange?(event)
   }
 
   var view: UIView { return containerView }
@@ -88,11 +154,27 @@ class HybridNitroMap: HybridNitroMapSpec {
   // are pushed in bulk via applyCurrentSettings when provider inits).
 
   var initialRegion: Region? {
-    didSet { _provider?.initialRegion = initialRegion }
+    didSet {
+      _provider?.initialRegion = filterSentinel(initialRegion)
+    }
+  }
+
+  var region: Region? {
+    didSet {
+      // Sentinel → nil (cleared); real value → forwarded as-is
+      _provider?.region = filterSentinel(region)
+    }
   }
 
   var showsUserLocation: Bool? {
-    didSet { _provider?.showsUserLocation = showsUserLocation }
+    didSet {
+      _provider?.showsUserLocation = showsUserLocation
+      if showsUserLocation == true {
+        startLocationManager()
+      } else {
+        stopLocationManager()
+      }
+    }
   }
 
   var zoomEnabled: Bool? {
@@ -115,10 +197,6 @@ class HybridNitroMap: HybridNitroMapSpec {
     didSet { _provider?.mapType = mapType }
   }
 
-  var showsMyLocationButton: Bool? {
-    didSet { _provider?.showsMyLocationButton = showsMyLocationButton }
-  }
-
   var clusterConfig: ClusterConfig? {
     didSet { _provider?.clusterConfig = clusterConfig }
   }
@@ -131,6 +209,46 @@ class HybridNitroMap: HybridNitroMapSpec {
     didSet { _provider?.darkMode = darkMode }
   }
 
+  var mapPadding: EdgePadding = EdgePadding(top: 0, right: 0, bottom: 0, left: 0) {
+    didSet { _provider?.mapPadding = mapPadding }
+  }
+
+  var showsTraffic: Bool? {
+    didSet { _provider?.showsTraffic = showsTraffic }
+  }
+
+  var showsBuildings: Bool? {
+    didSet { _provider?.showsBuildings = showsBuildings }
+  }
+
+  var showsCompass: Bool? {
+    didSet { _provider?.showsCompass = showsCompass }
+  }
+
+  var minZoom: Double = 1 {
+    didSet { _provider?.minZoom = minZoom }
+  }
+
+  var maxZoom: Double = 22 {
+    didSet { _provider?.maxZoom = maxZoom }
+  }
+
+  var userTrackingMode: UserTrackingMode? {
+    didSet { _provider?.userTrackingMode = userTrackingMode }
+  }
+
+  var userLocationImage: String = "" {
+    didSet { _provider?.userLocationImage = userLocationImage }
+  }
+
+  var userLocationSize: Double = 40 {
+    didSet { _provider?.userLocationSize = userLocationSize }
+  }
+
+  var userLocationAnchor: Point? {
+    didSet { _provider?.userLocationAnchor = userLocationAnchor }
+  }
+
   // MARK: - Callbacks
 
   var onPress: ((MapPressEvent) -> Void)? {
@@ -177,6 +295,30 @@ class HybridNitroMap: HybridNitroMapSpec {
     didSet { _provider?.onError = onError }
   }
 
+  var onUserLocationChange: ((_ event: UserLocationChangeEvent) -> Void)?
+
+  var onUserTrackingModeChange: ((_ mode: UserTrackingMode) -> Void)? {
+    didSet { _provider?.onUserTrackingModeChange = onUserTrackingModeChange }
+  }
+
+  var onMapIdle: (() -> Void)? {
+    didSet { _provider?.onMapIdle = onMapIdle }
+  }
+
+  var onPolylinePress: ((_ id: String) -> Void)? {
+    didSet { _provider?.onPolylinePress = onPolylinePress }
+  }
+
+  var onPolygonPress: ((_ id: String) -> Void)? {
+    didSet { _provider?.onPolygonPress = onPolygonPress }
+  }
+
+  var onCirclePress: ((_ id: String) -> Void)? {
+    didSet { _provider?.onCirclePress = onCirclePress }
+  }
+
+  var onUserLocationError: ((_ error: MapError) -> Void)?
+
   // MARK: - Initialization
 
   override init() {
@@ -216,6 +358,20 @@ class HybridNitroMap: HybridNitroMapSpec {
     }
   }
 
+  func fitToSuppliedMarkers(
+    markerIds: [String],
+    edgePadding: EdgePadding?,
+    animated: Bool?
+  ) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.fitToSuppliedMarkers(
+        markerIds,
+        edgePadding: edgePadding,
+        animated: animated
+      )
+    }
+  }
+
   func animateCamera(camera: Camera, duration: Double?) throws {
     DispatchQueue.main.async { [weak self] in
       self?.mapProvider.animateCamera(camera, duration: duration)
@@ -252,6 +408,32 @@ class HybridNitroMap: HybridNitroMapSpec {
     return .resolved(withResult: boundaries)
   }
 
+  func centerOnUserLocation() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?._provider?.centerOnUserLocation()
+    }
+  }
+
+  func pointForCoordinate(coordinate: Coordinate) throws -> Point {
+    if Thread.isMainThread {
+      return mapProvider.pointForCoordinate(coordinate)
+    } else {
+      return DispatchQueue.main.sync {
+        return self.mapProvider.pointForCoordinate(coordinate)
+      }
+    }
+  }
+
+  func coordinateForPoint(point: Point) throws -> Coordinate {
+    if Thread.isMainThread {
+      return mapProvider.coordinateForPoint(point)
+    } else {
+      return DispatchQueue.main.sync {
+        return self.mapProvider.coordinateForPoint(point)
+      }
+    }
+  }
+
   // MARK: - Marker Methods
 
   func addMarker(marker: MarkerData) throws {
@@ -290,6 +472,12 @@ class HybridNitroMap: HybridNitroMapSpec {
     }
   }
 
+  func deselectMarker() {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.deselectMarker()
+    }
+  }
+
   // MARK: - Clustering
 
   func setClusteringEnabled(enabled: Bool) throws {
@@ -329,4 +517,82 @@ class HybridNitroMap: HybridNitroMapSpec {
   func getCurrentRegion() -> Region {
     return mapProvider.getCurrentRegion()
   }
+
+  // MARK: - Polyline Methods
+
+  func addPolyline(polyline: PolylineData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.addPolyline(polyline)
+    }
+  }
+
+  func updatePolyline(polyline: PolylineData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.updatePolyline(polyline)
+    }
+  }
+
+  func removePolyline(id: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.removePolyline(id)
+    }
+  }
+
+  func clearPolylines() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.clearPolylines()
+    }
+  }
+
+  // MARK: - Polygon Methods
+
+  func addPolygon(polygon: PolygonData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.addPolygon(polygon)
+    }
+  }
+
+  func updatePolygon(polygon: PolygonData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.updatePolygon(polygon)
+    }
+  }
+
+  func removePolygon(id: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.removePolygon(id)
+    }
+  }
+
+  func clearPolygons() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.clearPolygons()
+    }
+  }
+
+  // MARK: - Circle Methods
+
+  func addCircle(circle: CircleData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.addCircle(circle)
+    }
+  }
+
+  func updateCircle(circle: CircleData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.updateCircle(circle)
+    }
+  }
+
+  func removeCircle(id: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.removeCircle(id)
+    }
+  }
+
+  func clearCircles() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.clearCircles()
+    }
+  }
 }

package/ios/NitroMapConfig/NitroMapConfig.swift

@@ -0,0 +1,45 @@
+import Foundation
+import GoogleMaps
+import NitroModules
+
+class HybridNitroMapConfig: HybridNitroMapConfigSpec {
+
+  // Static flag to track initialization across all instances
+  private static var isInitialized = false
+
+  func NitroMapInitialize(apiKey: String, provider: MapProvider) {
+    // Use static flag to prevent duplicate initialization
+    guard !HybridNitroMapConfig.isInitialized else {
+      #if DEBUG
+      print("[NitroMap] Already initialized, skipping...")
+      #endif
+      return
+    }
+
+    switch provider {
+    case .google:
+      // Set initialized BEFORE async dispatch to prevent race conditions
+      HybridNitroMapConfig.isInitialized = true
+      DispatchQueue.main.async {
+        GMSServices.provideAPIKey(apiKey)
+        #if DEBUG
+        print("[NitroMap] Google Maps initialized")
+        #endif
+      }
+    case .apple:
+      // Apple Maps uses MapKit (built-in) — no SDK initialization needed
+      HybridNitroMapConfig.isInitialized = true
+      #if DEBUG
+      print("[NitroMap] Apple Maps ready (no SDK init needed)")
+      #endif
+    case .yandex:
+      #if DEBUG
+      print("[NitroMap] Yandex Maps is not yet implemented")
+      #endif
+    }
+  }
+
+  func IsNitroMapInitialized() -> Bool {
+    return HybridNitroMapConfig.isInitialized
+  }
+}