react-native-google-maps-plus 1.3.0 → 1.4.1-dev.1

package/android/build.gradle

@@ -28,7 +28,7 @@ apply from: "./fix-prefab.gradle"
 if (rootProject.name != "rngooglemapsplus.example") {
     apply plugin: "com.facebook.react"
 } else {
-    println("\u001B[33m⚠️  Skipping React Native Gradle plugin in library (example build detected)\u001B[0m")
+    println("\u001B[33mSkipping React Native Gradle plugin in library (example build detected)\u001B[0m")
 }
 
 def getExtOrIntegerDefault(name) {

package/android/src/main/java/com/rngooglemapsplus/GoogleMapsViewImpl.kt

@@ -2,7 +2,6 @@ package com.rngooglemapsplus
 
 import android.annotation.SuppressLint
 import android.graphics.Bitmap
-import android.location.Location
 import android.util.Base64
 import android.util.Size
 import android.widget.FrameLayout
@@ -11,7 +10,6 @@ import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.ThemedReactContext
-import com.google.android.gms.common.ConnectionResult
 import com.google.android.gms.maps.CameraUpdateFactory
 import com.google.android.gms.maps.GoogleMap
 import com.google.android.gms.maps.GoogleMapOptions
@@ -35,9 +33,15 @@ import com.google.android.gms.maps.model.TileOverlayOptions
 import com.google.maps.android.data.kml.KmlLayer
 import com.margelo.nitro.core.Promise
 import com.rngooglemapsplus.extensions.toGooglePriority
+import com.rngooglemapsplus.extensions.toLatLng
 import com.rngooglemapsplus.extensions.toLocationErrorCode
 import com.rngooglemapsplus.extensions.toRNIndoorBuilding
 import com.rngooglemapsplus.extensions.toRNIndoorLevel
+import com.rngooglemapsplus.extensions.toRNMapErrorCodeOrNull
+import com.rngooglemapsplus.extensions.toRnCamera
+import com.rngooglemapsplus.extensions.toRnLatLng
+import com.rngooglemapsplus.extensions.toRnLocation
+import com.rngooglemapsplus.extensions.toRnRegion
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -63,6 +67,7 @@ class GoogleMapsViewImpl(
   LifecycleEventListener {
   private var initialized = false
   private var mapReady = false
+  private var destroyed = false
   private var googleMap: GoogleMap? = null
   private var mapView: MapView? = null
 
@@ -81,58 +86,32 @@ class GoogleMapsViewImpl(
   private val kmlLayersById = mutableMapOf<String, KmlLayer>()
 
   private var cameraMoveReason = -1
-  private var lastSubmittedLocation: Location? = null
   private var lastSubmittedCameraPosition: CameraPosition? = null
 
   init {
     reactContext.addLifecycleEventListener(this)
   }
 
-  fun initMapView(
-    mapId: String?,
-    liteMode: Boolean?,
-    cameraPosition: CameraPosition?,
-  ) {
+  fun initMapView(googleMapsOptions: GoogleMapOptions) {
     if (initialized) return
     initialized = true
     val result = playServiceHandler.playServicesAvailability()
+    val errorCode = result.toRNMapErrorCodeOrNull()
 
-    when (result) {
-      ConnectionResult.SERVICE_MISSING -> {
-        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_MISSING)
-        return
-      }
+    if (errorCode != null) {
+      onMapError?.invoke(errorCode)
 
-      ConnectionResult.SERVICE_INVALID -> {
-        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_INVALID)
+      if (errorCode == RNMapErrorCode.PLAY_SERVICES_MISSING ||
+        errorCode == RNMapErrorCode.PLAY_SERVICES_INVALID
+      ) {
         return
       }
-
-      ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED ->
-        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_OUTDATED)
-
-      ConnectionResult.SERVICE_UPDATING ->
-        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICE_UPDATING)
-
-      ConnectionResult.SERVICE_DISABLED ->
-        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_DISABLED)
-
-      ConnectionResult.SUCCESS -> {}
-
-      else ->
-        onMapError?.invoke(RNMapErrorCode.UNKNOWN)
     }
 
     mapView =
       MapView(
         reactContext,
-        GoogleMapOptions().apply {
-          mapId?.let { mapId(it) }
-          liteMode?.let { liteMode(it) }
-          cameraPosition?.let {
-            camera(it)
-          }
-        },
+        googleMapsOptions,
       )
 
     super.addView(mapView)
@@ -151,8 +130,8 @@ class GoogleMapsViewImpl(
         googleMap?.setOnMapClickListener(this@GoogleMapsViewImpl)
         googleMap?.setOnMarkerDragListener(this@GoogleMapsViewImpl)
       }
+      applyProps()
       initLocationCallbacks()
-      applyPending()
       mapReady = true
       onMapReady?.invoke(true)
     }
@@ -168,21 +147,9 @@ class GoogleMapsViewImpl(
     }
     val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == reason
 
-    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
-    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
-
     onCameraChangeStart?.invoke(
-      RNRegion(
-        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
-        latitudeDelta = latDelta,
-        longitudeDelta = lngDelta,
-      ),
-      RNCamera(
-        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
-        zoom = cameraPosition.zoom.toDouble(),
-        bearing = cameraPosition.bearing.toDouble(),
-        tilt = cameraPosition.tilt.toDouble(),
-      ),
+      bounds.toRnRegion(),
+      cameraPosition.toRnCamera(),
       isGesture,
     )
   }
@@ -200,21 +167,9 @@ class GoogleMapsViewImpl(
 
     val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
 
-    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
-    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
-
-    onCameraChange?.invoke(
-      RNRegion(
-        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
-        latitudeDelta = latDelta,
-        longitudeDelta = lngDelta,
-      ),
-      RNCamera(
-        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
-        zoom = cameraPosition.zoom.toDouble(),
-        bearing = cameraPosition.bearing.toDouble(),
-        tilt = cameraPosition.tilt.toDouble(),
-      ),
+    onCameraChangeStart?.invoke(
+      bounds.toRnRegion(),
+      cameraPosition.toRnCamera(),
       isGesture,
     )
   }
@@ -228,39 +183,16 @@ class GoogleMapsViewImpl(
     }
     val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
 
-    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
-    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
-
-    onCameraChangeComplete?.invoke(
-      RNRegion(
-        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
-        latitudeDelta = latDelta,
-        longitudeDelta = lngDelta,
-      ),
-      RNCamera(
-        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
-        zoom = cameraPosition.zoom.toDouble(),
-        bearing = cameraPosition.bearing.toDouble(),
-        tilt = cameraPosition.tilt.toDouble(),
-      ),
+    onCameraChangeStart?.invoke(
+      bounds.toRnRegion(),
+      cameraPosition.toRnCamera(),
       isGesture,
     )
   }
 
   fun initLocationCallbacks() {
     locationHandler.onUpdate = { location ->
-      // / only the coordinated are relevant right now
-      if (lastSubmittedLocation?.latitude != location.latitude || lastSubmittedLocation?.longitude != location.longitude ||
-        lastSubmittedLocation?.bearing != location.bearing
-      ) {
-        onLocationUpdate?.invoke(
-          RNLocation(
-            RNLatLng(location.latitude, location.longitude),
-            location.bearing.toDouble(),
-          ),
-        )
-      }
-      lastSubmittedLocation = location
+      onLocationUpdate?.invoke(location.toRnLocation())
     }
 
     locationHandler.onError = { error ->
@@ -269,65 +201,18 @@ class GoogleMapsViewImpl(
     locationHandler.start()
   }
 
-  fun applyPending() {
-    onUi {
-      mapPadding?.let {
-        googleMap?.setPadding(
-          it.left.dpToPx().toInt(),
-          it.top.dpToPx().toInt(),
-          it.right.dpToPx().toInt(),
-          it.bottom.dpToPx().toInt(),
-        )
-      }
-
-      uiSettings?.let { v ->
-        googleMap?.uiSettings?.apply {
-          v.allGesturesEnabled?.let { setAllGesturesEnabled(it) }
-          v.compassEnabled?.let { isCompassEnabled = it }
-          v.indoorLevelPickerEnabled?.let { isIndoorLevelPickerEnabled = it }
-          v.mapToolbarEnabled?.let { isMapToolbarEnabled = it }
-          v.myLocationButtonEnabled?.let {
-            googleMap?.setLocationSource(locationHandler)
-            isMyLocationButtonEnabled = it
-          }
-          v.rotateEnabled?.let { isRotateGesturesEnabled = it }
-          v.scrollEnabled?.let { isScrollGesturesEnabled = it }
-          v.scrollDuringRotateOrZoomEnabled?.let {
-            isScrollGesturesEnabledDuringRotateOrZoom = it
-          }
-          v.tiltEnabled?.let { isTiltGesturesEnabled = it }
-          v.zoomControlsEnabled?.let { isZoomControlsEnabled = it }
-          v.zoomGesturesEnabled?.let { isZoomGesturesEnabled = it }
-        }
-      }
-
-      buildingEnabled?.let {
-        googleMap?.isBuildingsEnabled = it
-      }
-      trafficEnabled?.let {
-        googleMap?.isTrafficEnabled = it
-      }
-      indoorEnabled?.let {
-        googleMap?.isIndoorEnabled = it
-      }
-      googleMap?.setMapStyle(customMapStyle)
-      mapType?.let {
-        googleMap?.mapType = it
-      }
-      userInterfaceStyle?.let {
-        googleMap?.mapColorScheme = it
-      }
-      mapZoomConfig?.let {
-        googleMap?.setMinZoomPreference(it.min?.toFloat() ?: 2.0f)
-        googleMap?.setMaxZoomPreference(it.max?.toFloat() ?: 21.0f)
-      }
-    }
-
-    locationConfig?.let {
-      locationHandler.priority = it.android?.priority?.toGooglePriority()
-      locationHandler.interval = it.android?.interval?.toLong()
-      locationHandler.minUpdateInterval = it.android?.minUpdateInterval?.toLong()
-    }
+  fun applyProps() {
+    mapPadding = mapPadding
+    uiSettings = uiSettings
+    myLocationEnabled = myLocationEnabled
+    buildingEnabled = buildingEnabled
+    trafficEnabled = trafficEnabled
+    indoorEnabled = indoorEnabled
+    customMapStyle = customMapStyle
+    mapType = mapType
+    userInterfaceStyle = userInterfaceStyle
+    mapZoomConfig = mapZoomConfig
+    locationConfig = locationConfig
 
     if (pendingMarkers.isNotEmpty()) {
       pendingMarkers.forEach { (id, opts) ->
@@ -488,9 +373,11 @@ class GoogleMapsViewImpl(
   var locationConfig: RNLocationConfig? = null
     set(value) {
       field = value
-      locationHandler.priority = value?.android?.priority?.toGooglePriority()
-      locationHandler.interval = value?.android?.interval?.toLong()
-      locationHandler.minUpdateInterval = value?.android?.minUpdateInterval?.toLong()
+      locationHandler.updateConfig(
+        value?.android?.priority?.toGooglePriority(),
+        value?.android?.interval?.toLong(),
+        value?.android?.minUpdateInterval?.toLong(),
+      )
     }
 
   var onMapError: ((RNMapErrorCode) -> Unit)? = null
@@ -544,7 +431,7 @@ class GoogleMapsViewImpl(
     onUi {
       val builder = LatLngBounds.Builder()
       coordinates.forEach { coord ->
-        builder.include(LatLng(coord.latitude, coord.longitude))
+        builder.include(coord.toLatLng())
       }
       val bounds = builder.build()
 
@@ -927,7 +814,7 @@ class GoogleMapsViewImpl(
     onUi {
       heatmapsById.values.forEach { it.remove() }
     }
-    circlesById.clear()
+    heatmapsById.clear()
     pendingHeatmaps.clear()
   }
 
@@ -976,6 +863,8 @@ class GoogleMapsViewImpl(
   }
 
   fun destroyInternal() {
+    if (destroyed) return
+    destroyed = true
     onUi {
       locationHandler.stop()
       markerBuilder.cancelAllJobs()
@@ -1069,28 +958,28 @@ class GoogleMapsViewImpl(
 
   override fun onMapClick(coordinates: LatLng) {
     onMapPress?.invoke(
-      RNLatLng(coordinates.latitude, coordinates.longitude),
+      coordinates.toRnLatLng(),
     )
   }
 
   override fun onMarkerDragStart(marker: Marker) {
     onMarkerDragStart?.invoke(
       marker.tag?.toString(),
-      RNLatLng(marker.position.latitude, marker.position.longitude),
+      marker.position.toRnLatLng(),
     )
   }
 
   override fun onMarkerDrag(marker: Marker) {
     onMarkerDrag?.invoke(
       marker.tag?.toString(),
-      RNLatLng(marker.position.latitude, marker.position.longitude),
+      marker.position.toRnLatLng(),
     )
   }
 
   override fun onMarkerDragEnd(marker: Marker) {
     onMarkerDragEnd?.invoke(
       marker.tag?.toString(),
-      RNLatLng(marker.position.latitude, marker.position.longitude),
+      marker.position.toRnLatLng(),
     )
   }
 

package/android/src/main/java/com/rngooglemapsplus/LocationHandler.kt

@@ -35,30 +35,28 @@ class LocationHandler(
   private var listener: LocationSource.OnLocationChangedListener? = null
   private var locationRequest: LocationRequest? = null
   private var locationCallback: LocationCallback? = null
-
-  var priority: Int? = PRIORITY_DEFAULT
-    set(value) {
-      field = value ?: PRIORITY_DEFAULT
-      start()
-    }
-
-  var interval: Long? = INTERVAL_DEFAULT
-    set(value) {
-      field = value ?: INTERVAL_DEFAULT
-      buildLocationRequest()
-    }
-
-  var minUpdateInterval: Long? = MIN_UPDATE_INTERVAL
-    set(value) {
-      field = value ?: MIN_UPDATE_INTERVAL
-      buildLocationRequest()
-    }
+  private var priority: Int = PRIORITY_DEFAULT
+  private var interval: Long = INTERVAL_DEFAULT
+  private var minUpdateInterval: Long = MIN_UPDATE_INTERVAL
+  private var lastSubmittedLocation: Location? = null
+  private var isActive = false
 
   var onUpdate: ((Location) -> Unit)? = null
   var onError: ((RNLocationErrorCode) -> Unit)? = null
 
   init {
-    buildLocationRequest()
+    buildLocationRequest(priority, interval, minUpdateInterval)
+  }
+
+  fun updateConfig(
+    priority: Int? = null,
+    interval: Long? = null,
+    minUpdateInterval: Long? = null,
+  ) {
+    this.priority = priority ?: PRIORITY_DEFAULT
+    this.interval = interval ?: INTERVAL_DEFAULT
+    this.minUpdateInterval = minUpdateInterval ?: MIN_UPDATE_INTERVAL
+    buildLocationRequest(this.priority, this.interval, this.minUpdateInterval)
   }
 
   fun showLocationDialog() {
@@ -108,11 +106,11 @@ class LocationHandler(
   }
 
   @Suppress("deprecation")
-  private fun buildLocationRequest() {
-    val priority = priority ?: Priority.PRIORITY_BALANCED_POWER_ACCURACY
-    val interval = interval ?: INTERVAL_DEFAULT
-    val minUpdateInterval = minUpdateInterval ?: MIN_UPDATE_INTERVAL
-
+  private fun buildLocationRequest(
+    priority: Int,
+    interval: Long,
+    minUpdateInterval: Long,
+  ) {
     locationRequest =
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
         LocationRequest
@@ -126,11 +124,13 @@ class LocationHandler(
           .setInterval(interval)
           .setFastestInterval(minUpdateInterval)
       }
-    restartLocationUpdates()
   }
 
-  private fun restartLocationUpdates() {
-    stop()
+  @SuppressLint("MissingPermission")
+  fun start() {
+    if (isActive) return
+    isActive = true
+
     val playServicesStatus =
       GoogleApiAvailability
         .getInstance()
@@ -139,17 +139,13 @@ class LocationHandler(
       onError?.invoke(RNLocationErrorCode.PLAY_SERVICE_NOT_AVAILABLE)
       return
     }
-    start()
-  }
-
-  @SuppressLint("MissingPermission")
-  fun start() {
     try {
       fusedLocationClientProviderClient.lastLocation
         .addOnSuccessListener(
           OnSuccessListener { location ->
-            if (location != null) {
+            if (location != null && location != lastSubmittedLocation) {
               onUpdate?.invoke(location)
+              lastSubmittedLocation = location
             }
           },
         ).addOnFailureListener { e ->
@@ -161,8 +157,11 @@ class LocationHandler(
           override fun onLocationResult(locationResult: LocationResult) {
             val location = locationResult.lastLocation
             if (location != null) {
-              listener?.onLocationChanged(location)
-              onUpdate?.invoke(location)
+              if (location != lastSubmittedLocation) {
+                lastSubmittedLocation = location
+                listener?.onLocationChanged(location)
+                onUpdate?.invoke(location)
+              }
             } else {
               onError?.invoke(RNLocationErrorCode.POSITION_UNAVAILABLE)
             }
@@ -186,9 +185,11 @@ class LocationHandler(
   }
 
   fun stop() {
-    listener = null
+    if (!isActive) return
+    isActive = false
     if (locationCallback != null) {
       fusedLocationClientProviderClient.removeLocationUpdates(locationCallback!!)
+      fusedLocationClientProviderClient.flushLocations()
       locationCallback = null
     }
   }
@@ -199,6 +200,7 @@ class LocationHandler(
   }
 
   override fun deactivate() {
+    listener = null
     stop()
   }
 }

package/android/src/main/java/com/rngooglemapsplus/MapCircleBuilder.kt

@@ -4,13 +4,13 @@ import android.graphics.Color
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.google.android.gms.maps.model.Circle
 import com.google.android.gms.maps.model.CircleOptions
-import com.google.android.gms.maps.model.LatLng
 import com.rngooglemapsplus.extensions.toColor
+import com.rngooglemapsplus.extensions.toLatLng
 
 class MapCircleBuilder {
   fun build(circle: RNCircle): CircleOptions =
     CircleOptions().apply {
-      center(LatLng(circle.center.latitude, circle.center.longitude))
+      center(circle.center.toLatLng())
       radius(circle.radius)
       circle.strokeWidth?.let { strokeWidth(it.dpToPx()) }
       circle.strokeColor?.let { strokeColor(it.toColor()) }
@@ -20,14 +20,38 @@ class MapCircleBuilder {
     }
 
   fun update(
-    circle: Circle,
+    prev: RNCircle,
     next: RNCircle,
+    circle: Circle,
   ) {
-    circle.center = LatLng(next.center.latitude, next.center.longitude)
-    circle.radius = next.radius
-    circle.strokeWidth = next.strokeWidth?.dpToPx() ?: 1f
-    circle.strokeColor = next.strokeColor?.toColor() ?: Color.BLACK
-    circle.fillColor = next.fillColor?.toColor() ?: Color.TRANSPARENT
-    circle.zIndex = next.zIndex?.toFloat() ?: 0f
+    if (prev.center.latitude != next.center.latitude ||
+      prev.center.longitude != next.center.longitude
+    ) {
+      circle.center = next.center.toLatLng()
+    }
+
+    if (prev.radius != next.radius) {
+      circle.radius = next.radius
+    }
+
+    if (prev.strokeWidth != next.strokeWidth) {
+      circle.strokeWidth = next.strokeWidth?.dpToPx() ?: 1f
+    }
+
+    if (prev.strokeColor != next.strokeColor) {
+      circle.strokeColor = next.strokeColor?.toColor() ?: Color.BLACK
+    }
+
+    if (prev.fillColor != next.fillColor) {
+      circle.fillColor = next.fillColor?.toColor() ?: Color.TRANSPARENT
+    }
+
+    if (prev.pressable != next.pressable) {
+      circle.isClickable = next.pressable ?: false
+    }
+
+    if (prev.zIndex != next.zIndex) {
+      circle.zIndex = next.zIndex?.toFloat() ?: 0f
+    }
   }
 }

package/android/src/main/java/com/rngooglemapsplus/MapMarkerBuilder.kt

@@ -8,11 +8,11 @@ import com.caverock.androidsvg.SVG
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.google.android.gms.maps.model.BitmapDescriptor
 import com.google.android.gms.maps.model.BitmapDescriptorFactory
-import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps.model.Marker
 import com.google.android.gms.maps.model.MarkerOptions
 import com.rngooglemapsplus.extensions.markerStyleEquals
 import com.rngooglemapsplus.extensions.styleHash
+import com.rngooglemapsplus.extensions.toLatLng
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -40,43 +40,98 @@ class MapMarkerBuilder(
     icon: BitmapDescriptor?,
   ): MarkerOptions =
     MarkerOptions().apply {
-      position(LatLng(m.coordinate.latitude, m.coordinate.longitude))
+      position(m.coordinate.toLatLng())
       icon(icon)
       m.title?.let { title(it) }
       m.snippet?.let { snippet(it) }
       m.opacity?.let { alpha(it.toFloat()) }
       m.flat?.let { flat(it) }
       m.draggable?.let { draggable(it) }
+      m.rotation?.let { rotation(it.toFloat()) }
+      m.infoWindowAnchor?.let { infoWindowAnchor(it.x.toFloat(), it.y.toFloat()) }
       m.anchor?.let { anchor((m.anchor.x).toFloat(), (m.anchor.y).toFloat()) }
       m.zIndex?.let { zIndex(it.toFloat()) }
     }
 
   fun update(
-    marker: Marker,
     prev: RNMarker,
     next: RNMarker,
+    marker: Marker,
   ) {
-    marker.position =
-      LatLng(
-        next.coordinate.latitude,
-        next.coordinate.longitude,
-      )
+    if (prev.coordinate.latitude != next.coordinate.latitude ||
+      prev.coordinate.longitude != next.coordinate.longitude
+    ) {
+      marker.position = next.coordinate.toLatLng()
+    }
 
     if (!prev.markerStyleEquals(next)) {
       buildIconAsync(marker.id, next) { icon ->
         marker.setIcon(icon)
+        if (prev.infoWindowAnchor?.x != next.infoWindowAnchor?.x ||
+          prev.infoWindowAnchor?.y != next.infoWindowAnchor?.y
+        ) {
+          marker.setInfoWindowAnchor(
+            (next.infoWindowAnchor?.x ?: 0.5f).toFloat(),
+            (next.infoWindowAnchor?.y ?: 0f).toFloat(),
+          )
+        }
+
+        if (prev.anchor?.x != next.anchor?.x ||
+          prev.anchor?.y != next.anchor?.y
+        ) {
+          marker.setAnchor(
+            (next.anchor?.x ?: 0.5f).toFloat(),
+            (next.anchor?.y ?: 1.0f).toFloat(),
+          )
+        }
       }
+    } else {
+      if (prev.infoWindowAnchor?.x != next.infoWindowAnchor?.x ||
+        prev.infoWindowAnchor?.y != next.infoWindowAnchor?.y
+      ) {
+        marker.setInfoWindowAnchor(
+          (next.infoWindowAnchor?.x ?: 0.5f).toFloat(),
+          (next.infoWindowAnchor?.y ?: 0f).toFloat(),
+        )
+      }
+
+      if (prev.anchor?.x != next.anchor?.x ||
+        prev.anchor?.y != next.anchor?.y
+      ) {
+        marker.setAnchor(
+          (next.anchor?.x ?: 0.5f).toFloat(),
+          (next.anchor?.y ?: 1.0f).toFloat(),
+        )
+      }
+    }
+
+    if (prev.title != next.title) {
+      marker.title = next.title
+    }
+
+    if (prev.snippet != next.snippet) {
+      marker.snippet = next.snippet
+    }
+
+    if (prev.opacity != next.opacity) {
+      marker.alpha = next.opacity?.toFloat() ?: 1f
+    }
+
+    if (prev.flat != next.flat) {
+      marker.isFlat = next.flat ?: false
+    }
+
+    if (prev.draggable != next.draggable) {
+      marker.isDraggable = next.draggable ?: false
+    }
+
+    if (prev.rotation != next.rotation) {
+      marker.rotation = next.rotation?.toFloat() ?: 0f
+    }
+
+    if (prev.zIndex != next.zIndex) {
+      marker.zIndex = next.zIndex?.toFloat() ?: 0f
     }
-    marker.title = next.title
-    marker.snippet = next.snippet
-    marker.alpha = next.opacity?.toFloat() ?: 0f
-    marker.isFlat = next.flat ?: false
-    marker.isDraggable = next.draggable ?: false
-    marker.setAnchor(
-      (next.anchor?.x ?: 0.5).toFloat(),
-      (next.anchor?.y ?: 1.0).toFloat(),
-    )
-    marker.zIndex = next.zIndex?.toFloat() ?: 0f
   }
 
   fun buildIconAsync(