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

package/ios/Providers/Google/GoogleMapProvider+Markers.swift

@@ -0,0 +1,270 @@
+import Foundation
+import GoogleMaps
+
+// MARK: - Marker Management (SRP: Marker CRUD and selection only)
+
+extension GoogleMapProvider {
+
+  // MARK: - Marker CRUD
+
+  func addMarker(_ marker: MarkerData) {
+    addMarkerSync(marker)
+    clusteringDirty = true
+  }
+
+  func addMarkers(_ markers: [MarkerData]) {
+    for marker in markers {
+      addMarkerSync(marker)
+    }
+    clusteringDirty = true
+    performClustering()
+  }
+
+  func addMarkerSync(_ markerData: MarkerData) {
+    removeMarkerSync(markerData.id)
+
+    // ALL markers go into the clustering engine so it knows their positions
+    // and sizes for overlap prevention
+    clusterableMarkerData[markerData.id] = markerData
+    clusteringManager.addMarker(markerData)
+
+    if !markerData.clusteringEnabled || !(clusterConfig?.enabled ?? true) {
+      // Non-clustered markers also get a direct GMSMarker on the map
+      let marker = GMSMarker()
+      configureGMSMarker(marker, from: markerData)
+      marker.map = gmsMapView
+      nonClusteredMarkers[markerData.id] = marker
+    }
+  }
+
+  func updateMarker(_ marker: MarkerData) {
+    updateMarkerInPlace(marker)
+  }
+
+  /// Update marker in-place without triggering full re-clustering
+  /// This prevents texture allocation exhaustion by reusing existing GMSMarker objects
+  private func updateMarkerInPlace(_ markerData: MarkerData) {
+    let id = markerData.id
+
+    // Update stored data
+    if let existing = clusterableMarkerData[id] {
+      clusterableMarkerData[id] = markerData
+
+      // Only re-index in the C++ engine if coordinate changed.
+      // Cosmetic updates (selection, clusteringEnabled, icon style) don't
+      // need a spatial re-index and must NOT set markersChanged_ = true,
+      // which would force a full hierarchy rebuild.
+      let coordChanged =
+        existing.coordinate.latitude != markerData.coordinate.latitude ||
+        existing.coordinate.longitude != markerData.coordinate.longitude
+      if coordChanged {
+        clusteringManager.removeMarker(id)
+        clusteringManager.addMarker(markerData)
+      }
+    }
+
+    // Update rendered marker in-place (no remove/re-add)
+    if let gmsMarker = renderedSingleMarkers[id] {
+      updateGMSMarkerProperties(gmsMarker, from: markerData)
+    } else if let gmsMarker = nonClusteredMarkers[id] {
+      updateGMSMarkerProperties(gmsMarker, from: markerData)
+    }
+    // If marker not in any dict, it will be created with new data when clustering runs
+  }
+
+  func removeMarker(_ id: String) {
+    removeMarkerSync(id)
+    clusteringDirty = true
+    performClustering()
+  }
+
+  func removeMarkerSync(_ id: String) {
+    clusteringManager.removeMarker(id)
+    clusterableMarkerData.removeValue(forKey: id)
+
+    if let marker = renderedSingleMarkers[id] {
+      marker.map = nil
+      renderedSingleMarkers.removeValue(forKey: id)
+    }
+
+    if let marker = nonClusteredMarkers[id] {
+      marker.map = nil
+      nonClusteredMarkers.removeValue(forKey: id)
+    }
+  }
+
+  func clearMarkers() {
+    clearMarkersSync()
+    clusteringDirty = true
+  }
+
+  func clearMarkersSync() {
+    clusteringManager.clearMarkers()
+    clusterableMarkerData.removeAll()
+    clearRenderedMarkersToPool()
+
+    for (_, marker) in nonClusteredMarkers {
+      marker.map = nil
+    }
+    nonClusteredMarkers.removeAll()
+  }
+
+  // MARK: - Marker Selection
+
+  func deselectCurrentMarker() {
+    guard let previousId = selectedMarkerId else { return }
+    selectedMarkerId = nil
+    gmsMapView.selectedMarker = nil
+
+    // Revert marker data to unselected state and update icon in-place
+    if let data = clusterableMarkerData[previousId],
+       let updatedData = selectionHandler.updateSelectionState(for: data, selected: false) {
+      clusterableMarkerData[previousId] = updatedData
+
+      // Update icon in-place on the existing GMSMarker
+      if let gmsMarker = renderedSingleMarkers[previousId] {
+        gmsMarker.icon = MarkerIconFactory.createIcon(for: updatedData)
+        gmsMarker.zIndex = Int32(updatedData.zIndex ?? 0)
+      } else if let gmsMarker = nonClusteredMarkers[previousId] {
+        gmsMarker.icon = MarkerIconFactory.createIcon(for: updatedData)
+        gmsMarker.zIndex = Int32(updatedData.zIndex ?? 0)
+      }
+
+      // Add marker back into clustering engine
+      clusteringManager.addMarker(updatedData)
+    }
+  }
+
+  func deselectMarker() {
+    deselectCurrentMarker()
+  }
+
+  func selectMarker(_ id: String) {
+    // Deselect previous marker
+    if let previousId = selectedMarkerId, previousId != id {
+      deselectCurrentMarker()
+    }
+
+    selectedMarkerId = id
+
+    // Remove marker FROM clustering engine — it should not participate
+    // in clustering while selected. This prevents clustering from
+    // destroying the GMSMarker object and dismissing the info window.
+    clusteringManager.removeMarker(id)
+
+    // Update marker data to selected state (without touching clustering engine)
+    if let data = clusterableMarkerData[id],
+       let updatedData = selectionHandler.updateSelectionState(for: data, selected: true) {
+      clusterableMarkerData[id] = updatedData
+      // Regenerate icon on existing GMSMarker
+      if let gmsMarker = renderedSingleMarkers[id] {
+        gmsMarker.icon = MarkerIconFactory.createIcon(for: updatedData)
+      } else if let gmsMarker = nonClusteredMarkers[id] {
+        gmsMarker.icon = MarkerIconFactory.createIcon(for: updatedData)
+      }
+    }
+
+    // Find or create the GMSMarker and select it
+    var markerPosition: CLLocationCoordinate2D?
+
+    if let marker = renderedSingleMarkers[id] {
+      marker.zIndex = Int32.max
+      gmsMapView.selectedMarker = marker
+      markerPosition = marker.position
+    } else if let marker = nonClusteredMarkers[id] {
+      marker.zIndex = Int32.max
+      gmsMapView.selectedMarker = marker
+      markerPosition = marker.position
+    } else if let markerData = clusterableMarkerData[id] {
+      // Marker was inside a cluster — create a single marker for it
+      let marker = GMSMarker()
+      configureGMSMarker(marker, from: markerData)
+      marker.zIndex = Int32.max
+      marker.map = gmsMapView
+      renderedSingleMarkers[id] = marker
+      gmsMapView.selectedMarker = marker
+      markerPosition = marker.position
+    }
+
+    // No explicit re-clustering needed — the camera animation below
+    // triggers idleAt → performClustering() naturally.
+
+    // Animate camera to marker position
+    if let position = markerPosition {
+      let camera = GMSCameraPosition.camera(
+        withLatitude: position.latitude,
+        longitude: position.longitude,
+        zoom: gmsMapView.camera.zoom
+      )
+      CATransaction.begin()
+      CATransaction.setAnimationDuration(0.3)
+      gmsMapView.animate(to: camera)
+      CATransaction.commit()
+    }
+  }
+
+  // MARK: - GMSMarker Configuration Helpers
+
+  /// Configure a GMSMarker with marker data (for initial setup)
+  func configureGMSMarker(_ gmsMarker: GMSMarker, from markerData: MarkerData) {
+    gmsMarker.position = CLLocationCoordinate2D(
+      latitude: markerData.coordinate.latitude,
+      longitude: markerData.coordinate.longitude
+    )
+    gmsMarker.title = markerData.title
+    gmsMarker.snippet = markerData.description
+    gmsMarker.isDraggable = markerData.draggable
+    gmsMarker.opacity = Float(markerData.opacity)
+    gmsMarker.rotation = markerData.rotation
+    gmsMarker.zIndex = Int32(markerData.zIndex)
+    gmsMarker.groundAnchor = CGPoint(
+      x: markerData.anchor.x,
+      y: markerData.anchor.y
+    )
+    gmsMarker.userData = markerData.id
+    gmsMarker.icon = MarkerIconFactory.createIcon(for: markerData)
+
+    // Accessibility — GMSMarker manages its own isAccessibilityElement
+    // internally; forcing it to true throws an ObjC exception in some
+    // SDK versions. Setting accessibilityLabel alone is sufficient.
+    gmsMarker.accessibilityLabel = markerData.accessibilityLabel ?? markerData.title
+
+    switch markerData.animation {
+    case .appear:
+      gmsMarker.appearAnimation = .pop
+    case .none:
+      gmsMarker.appearAnimation = .none
+    }
+  }
+
+  /// Update GMSMarker properties in-place without creating a new marker object
+  func updateGMSMarkerProperties(_ gmsMarker: GMSMarker, from markerData: MarkerData) {
+    gmsMarker.position = CLLocationCoordinate2D(
+      latitude: markerData.coordinate.latitude,
+      longitude: markerData.coordinate.longitude
+    )
+    gmsMarker.title = markerData.title
+    gmsMarker.snippet = markerData.description
+    gmsMarker.isDraggable = markerData.draggable
+    gmsMarker.opacity = Float(markerData.opacity)
+    gmsMarker.rotation = markerData.rotation
+    gmsMarker.zIndex = Int32(markerData.zIndex)
+    gmsMarker.groundAnchor = CGPoint(
+      x: markerData.anchor.x,
+      y: markerData.anchor.y
+    )
+
+    // Accessibility
+    gmsMarker.accessibilityLabel = markerData.accessibilityLabel ?? markerData.title
+
+    // Only regenerate icon if needed - cache will handle deduplication
+    if let newIcon = MarkerIconFactory.createIcon(for: markerData) {
+      gmsMarker.icon = newIcon
+    }
+  }
+
+  /// Apply the platform's native appear animation to a cluster marker.
+  func applyClusterAnimation(_ marker: GMSMarker) {
+    marker.appearAnimation = .pop
+  }
+}

package/ios/Providers/Google/GoogleMapProvider+Overlays.swift

@@ -0,0 +1,245 @@
+import Foundation
+import GoogleMaps
+
+// MARK: - Overlay Management (SRP: Polyline, Polygon, Circle only)
+
+extension GoogleMapProvider {
+
+  // MARK: - Polyline Management
+
+  func addPolyline(_ polyline: PolylineData) {
+    // Remove existing polyline with same ID
+    if let existing = polylines[polyline.id] {
+      existing.map = nil
+      polylines.removeValue(forKey: polyline.id)
+    }
+
+    let path = GMSMutablePath()
+    for coord in polyline.coordinates {
+      path.add(CLLocationCoordinate2D(
+        latitude: coord.latitude,
+        longitude: coord.longitude
+      ))
+    }
+
+    let gmsPolyline = GMSPolyline(path: path)
+    gmsPolyline.strokeWidth = CGFloat(polyline.strokeWidth)
+    gmsPolyline.geodesic = polyline.geodesic
+    gmsPolyline.zIndex = Int32(polyline.zIndex)
+
+    let color = polyline.strokeColor.toUIColor()
+
+    if polyline.dashed {
+      applyDashSpans(to: gmsPolyline, color: color)
+      dashedPolylineData[polyline.id] = polyline
+    } else {
+      gmsPolyline.strokeColor = color
+      dashedPolylineData.removeValue(forKey: polyline.id)
+    }
+
+    gmsPolyline.isTappable = polyline.tappable
+    var userData: [String: String] = [GoogleMapDelegate.overlayTypeKey: GoogleMapDelegate.overlayTypePolyline, GoogleMapDelegate.overlayIdKey: polyline.id]
+    if let label = polyline.accessibilityLabel { userData["accessibilityLabel"] = label }
+    gmsPolyline.userData = userData
+    gmsPolyline.map = gmsMapView
+    polylines[polyline.id] = gmsPolyline
+  }
+
+  /// Apply dash spans using screen-pixel sizing.
+  /// Projects path coordinates to screen points, measures actual screen length,
+  /// then creates dashes targeting ~20pt solid / ~10pt gap.
+  /// Always starts and ends with a solid span. Bounded to max 100 cycles.
+  private func applyDashSpans(to gmsPolyline: GMSPolyline, color: UIColor) {
+    guard let path = gmsPolyline.path, path.count() >= 2 else { return }
+    let solidStyle = GMSStrokeStyle.solidColor(color)
+    let clearStyle = GMSStrokeStyle.solidColor(.clear)
+    let pointCount = Int(path.count())
+    let totalSegments: Double = Double(pointCount - 1)
+
+    // --- Step 1: Calculate screen length per segment ---
+    var segmentScreenLengths: [Double] = []
+    segmentScreenLengths.reserveCapacity(pointCount - 1)
+    var totalScreenLength: Double = 0
+
+    for i in 0..<(pointCount - 1) {
+      let p1 = gmsMapView.projection.point(for: path.coordinate(at: UInt(i)))
+      let p2 = gmsMapView.projection.point(for: path.coordinate(at: UInt(i + 1)))
+      let dx = Double(p2.x - p1.x)
+      let dy = Double(p2.y - p1.y)
+      let len = sqrt(dx * dx + dy * dy)
+      segmentScreenLengths.append(len)
+      totalScreenLength += len
+    }
+
+    guard totalScreenLength > 0 else {
+      gmsPolyline.spans = [GMSStyleSpan(style: solidStyle)]
+      return
+    }
+
+    // --- Step 2: Calculate dash/gap count from screen length ---
+    let dashPt: Double = 20.0   // solid dash size in screen points
+    let gapPt: Double = 10.0    // gap size in screen points
+    let cyclePt: Double = dashPt + gapPt
+
+    // How many full dash cycles fit? Always at least 1 dash.
+    var dashCount = max(Int(totalScreenLength / cyclePt), 1)
+    dashCount = min(dashCount, 100)  // cap for performance
+
+    // --- Step 3: Build spans as segment fractions proportional to screen size ---
+    // Pattern: solid, gap, solid, gap, ..., solid  (2N-1 slots)
+    // Each solid = dashPt screen points, each gap = gapPt screen points
+    // Total pattern screen length = dashCount * dashPt + (dashCount - 1) * gapPt
+    let patternScreenLength = Double(dashCount) * dashPt + Double(dashCount - 1) * gapPt
+
+    // Convert screen points to segment fractions
+    let dashSegments = (dashPt / patternScreenLength) * totalSegments
+    let gapSegments = (gapPt / patternScreenLength) * totalSegments
+
+    var spans: [GMSStyleSpan] = []
+    spans.reserveCapacity(dashCount * 2 - 1)
+
+    for i in 0..<(dashCount * 2 - 1) {
+      if i % 2 == 0 {
+        spans.append(GMSStyleSpan(style: solidStyle, segments: dashSegments))
+      } else {
+        spans.append(GMSStyleSpan(style: clearStyle, segments: gapSegments))
+      }
+    }
+    gmsPolyline.spans = spans
+  }
+
+  /// Recalculate dash spans for all dashed polylines at current zoom.
+  /// Called from camera idle delegate.
+  func refreshDashedPolylines() {
+    for (id, data) in dashedPolylineData {
+      guard let gmsPolyline = polylines[id] else { continue }
+      let color = data.strokeColor.toUIColor()
+      applyDashSpans(to: gmsPolyline, color: color)
+    }
+  }
+
+  func updatePolyline(_ polyline: PolylineData) {
+    // Remove and re-add — GMSPolyline properties like path are not
+    // efficiently updatable in-place.
+    addPolyline(polyline)
+  }
+
+  func removePolyline(_ id: String) {
+    if let existing = polylines[id] {
+      existing.map = nil
+      polylines.removeValue(forKey: id)
+    }
+    dashedPolylineData.removeValue(forKey: id)
+  }
+
+  func clearPolylines() {
+    for (_, polyline) in polylines {
+      polyline.map = nil
+    }
+    polylines.removeAll()
+    dashedPolylineData.removeAll()
+  }
+
+  // MARK: - Polygon Management
+
+  func addPolygon(_ polygon: PolygonData) {
+    // Remove existing polygon with same ID
+    if let existing = polygons[polygon.id] {
+      existing.map = nil
+    }
+
+    let path = GMSMutablePath()
+    for coord in polygon.coordinates {
+      path.add(CLLocationCoordinate2D(latitude: coord.latitude, longitude: coord.longitude))
+    }
+
+    let gmsPolygon = GMSPolygon(path: path)
+
+    gmsPolygon.fillColor = polygon.fillColor.toUIColor()
+    gmsPolygon.strokeColor = polygon.strokeColor.toUIColor()
+
+    gmsPolygon.strokeWidth = CGFloat(polygon.strokeWidth)
+    gmsPolygon.zIndex = Int32(polygon.zIndex)
+
+    // Add holes
+    if !polygon.holes.isEmpty {
+      var holePaths: [GMSPath] = []
+      for ring in polygon.holes {
+        let holePath = GMSMutablePath()
+        for coord in ring.coordinates {
+          holePath.add(CLLocationCoordinate2D(latitude: coord.latitude, longitude: coord.longitude))
+        }
+        holePaths.append(holePath)
+      }
+      gmsPolygon.holes = holePaths
+    }
+
+    gmsPolygon.isTappable = polygon.tappable
+    var polygonUserData: [String: String] = [GoogleMapDelegate.overlayTypeKey: GoogleMapDelegate.overlayTypePolygon, GoogleMapDelegate.overlayIdKey: polygon.id]
+    if let label = polygon.accessibilityLabel { polygonUserData["accessibilityLabel"] = label }
+    gmsPolygon.userData = polygonUserData
+    gmsPolygon.map = gmsMapView
+    polygons[polygon.id] = gmsPolygon
+  }
+
+  func updatePolygon(_ polygon: PolygonData) {
+    // Remove and re-add
+    addPolygon(polygon)
+  }
+
+  func removePolygon(_ id: String) {
+    if let existing = polygons[id] {
+      existing.map = nil
+      polygons.removeValue(forKey: id)
+    }
+  }
+
+  func clearPolygons() {
+    for (_, polygon) in polygons {
+      polygon.map = nil
+    }
+    polygons.removeAll()
+  }
+
+  // MARK: - Circle Management
+
+  func addCircle(_ circle: CircleData) {
+    // Remove existing circle with same ID
+    if let existing = circles[circle.id] {
+      existing.map = nil
+    }
+
+    let center = CLLocationCoordinate2D(latitude: circle.center.latitude, longitude: circle.center.longitude)
+    let gmsCircle = GMSCircle(position: center, radius: circle.radius)
+
+    gmsCircle.fillColor = circle.fillColor.toUIColor()
+    gmsCircle.strokeColor = circle.strokeColor.toUIColor()
+
+    gmsCircle.strokeWidth = CGFloat(circle.strokeWidth)
+    gmsCircle.zIndex = Int32(circle.zIndex)
+    gmsCircle.isTappable = circle.tappable
+    var circleUserData: [String: String] = [GoogleMapDelegate.overlayTypeKey: GoogleMapDelegate.overlayTypeCircle, GoogleMapDelegate.overlayIdKey: circle.id]
+    if let label = circle.accessibilityLabel { circleUserData["accessibilityLabel"] = label }
+    gmsCircle.userData = circleUserData
+    gmsCircle.map = gmsMapView
+    circles[circle.id] = gmsCircle
+  }
+
+  func updateCircle(_ circle: CircleData) {
+    addCircle(circle)
+  }
+
+  func removeCircle(_ id: String) {
+    if let existing = circles[id] {
+      existing.map = nil
+      circles.removeValue(forKey: id)
+    }
+  }
+
+  func clearCircles() {
+    for (_, circle) in circles {
+      circle.map = nil
+    }
+    circles.removeAll()
+  }
+}

package/ios/Providers/Google/GoogleMapProvider+UserLocation.swift

@@ -0,0 +1,180 @@
+import Foundation
+import GoogleMaps
+import UIKit
+import CoreLocation
+
+// MARK: - User Location
+
+extension GoogleMapProvider {
+
+  /// Called by facade when CLLocationManager fires a location/heading update.
+  /// Updates custom marker position + rotation and handles camera following.
+  func updateUserLocation(_ location: CLLocation, heading: CLHeading?) {
+    // Store latest location for my-location button
+    lastKnownUserLocation = location
+
+    let marker = customUserLocationMarker
+
+    // Compute rotation from heading
+    let rotation: CLLocationDirection? = {
+      if let heading = heading, heading.trueHeading >= 0 {
+        return heading.trueHeading
+      } else if location.course >= 0 {
+        return location.course
+      }
+      return nil
+    }()
+
+    // Determine if camera should follow
+    let shouldFollow = userTrackingMode != nil && userTrackingMode != .none
+
+    if shouldFollow {
+      // Synchronize marker position + camera in one animation transaction.
+      // Without this, marker.position jumps instantly while camera animates,
+      // causing a visual "teleport forward, then back" artifact.
+      CATransaction.begin()
+      CATransaction.setAnimationDuration(0.3)
+
+      // Update marker within the same animation
+      if let marker = marker {
+        marker.position = location.coordinate
+        if let rotation = rotation {
+          marker.rotation = rotation
+        }
+      }
+
+      // Camera follows — animate in the same transaction
+      let target = location.coordinate
+      switch userTrackingMode! {
+      case .follow:
+        let camera = GMSCameraPosition.camera(
+          withTarget: target,
+          zoom: gmsMapView.camera.zoom
+        )
+        gmsMapView.animate(to: camera)
+      case .followwithheading:
+        let bearing: CLLocationDirection = {
+          if let heading = heading, heading.trueHeading >= 0 {
+            return heading.trueHeading
+          } else if location.course >= 0 {
+            return location.course
+          }
+          return gmsMapView.camera.bearing
+        }()
+        let camera = GMSCameraPosition.camera(
+          withTarget: target,
+          zoom: gmsMapView.camera.zoom,
+          bearing: bearing,
+          viewingAngle: gmsMapView.camera.viewingAngle
+        )
+        gmsMapView.animate(to: camera)
+      case .none:
+        break
+      }
+
+      CATransaction.commit()
+    } else {
+      // No camera follow — just update marker position instantly
+      if let marker = marker {
+        marker.position = location.coordinate
+        if let rotation = rotation {
+          marker.rotation = rotation
+        }
+      }
+    }
+  }
+
+  // MARK: - Custom User Location Marker
+
+  func setupCustomUserLocationMarker() {
+    // Remove old custom marker
+    customUserLocationMarker?.map = nil
+    customUserLocationMarker = nil
+
+    guard !userLocationImage.isEmpty else {
+      // No custom image — re-enable default blue dot
+      cachedUserLocationImageUrl = ""
+      userLocationImageData = nil
+      gmsMapView.isMyLocationEnabled = showsUserLocation ?? false
+      return
+    }
+
+    // Disable native blue dot — CLLocationManager handles tracking independently
+    gmsMapView.isMyLocationEnabled = false
+
+    // Create custom marker
+    let marker = GMSMarker()
+    marker.groundAnchor = CGPoint(
+      x: userLocationAnchor?.x ?? 0.5,
+      y: userLocationAnchor?.y ?? 0.5
+    )
+    marker.isFlat = true
+    marker.zIndex = Int32.max // Always on top
+
+    // Reuse cached image if URL is the same (only size changed, or marker recreated)
+    if let cachedImage = userLocationImageData, cachedUserLocationImageUrl == userLocationImage {
+      let size = CGFloat(userLocationSize)
+      let resized = resizeImage(cachedImage, to: CGSize(width: size, height: size))
+      marker.icon = resized
+    }
+
+    marker.map = gmsMapView
+    customUserLocationMarker = marker
+
+    // Restore position from last known location
+    if let location = lastKnownUserLocation {
+      marker.position = location.coordinate
+    }
+
+    // Skip download if same URL and we already have cached data
+    if cachedUserLocationImageUrl == userLocationImage && userLocationImageData != nil {
+      return
+    }
+
+    // Load image
+    let size = CGFloat(userLocationSize)
+    if userLocationImage.hasPrefix("http://") || userLocationImage.hasPrefix("https://") {
+      // Remote image
+      let imageUrl = userLocationImage
+      cachedUserLocationImageUrl = imageUrl
+      DispatchQueue.global().async { [weak self] in
+        guard let url = URL(string: imageUrl),
+              let data = try? Data(contentsOf: url),
+              let image = UIImage(data: data) else { return }
+        let resized = self?.resizeImage(image, to: CGSize(width: size, height: size))
+        DispatchQueue.main.async { [weak self] in
+          self?.userLocationImageData = image // Cache original, not resized
+          self?.customUserLocationMarker?.icon = resized
+        }
+      }
+    } else {
+      // Local asset
+      cachedUserLocationImageUrl = userLocationImage
+      if let image = UIImage(named: userLocationImage) {
+        let resized = resizeImage(image, to: CGSize(width: size, height: size))
+        userLocationImageData = image // Cache original
+        marker.icon = resized
+      }
+    }
+  }
+
+  func resizeImage(_ image: UIImage, to size: CGSize) -> UIImage {
+    let renderer = UIGraphicsImageRenderer(size: size)
+    return renderer.image { _ in
+      image.draw(in: CGRect(origin: .zero, size: size))
+    }
+  }
+
+  func centerOnUserLocation() {
+    guard let location = lastKnownUserLocation else { return }
+    let camera = GMSCameraPosition.camera(
+      withLatitude: location.coordinate.latitude,
+      longitude: location.coordinate.longitude,
+      zoom: gmsMapView.camera.zoom
+    )
+    CATransaction.begin()
+    CATransaction.setAnimationDuration(0.3)
+    gmsMapView.animate(to: camera)
+    CATransaction.commit()
+  }
+}