react-native-google-maps-plus 1.3.0-dev.7 → 1.3.0-dev.9

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
@@ -40,6 +39,7 @@ import com.rngooglemapsplus.extensions.toLocationErrorCode
 import com.rngooglemapsplus.extensions.toRNIndoorBuilding
 import com.rngooglemapsplus.extensions.toRNIndoorLevel
 import com.rngooglemapsplus.extensions.toRnLatLng
+import com.rngooglemapsplus.extensions.toRnLocation
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -65,6 +65,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
 
@@ -83,7 +84,6 @@ class GoogleMapsViewImpl(
   private val kmlLayersById = mutableMapOf<String, KmlLayer>()
 
   private var cameraMoveReason = -1
-  private var lastSubmittedLocation: Location? = null
   private var lastSubmittedCameraPosition: CameraPosition? = null
 
   init {
@@ -143,8 +143,8 @@ class GoogleMapsViewImpl(
         googleMap?.setOnMapClickListener(this@GoogleMapsViewImpl)
         googleMap?.setOnMarkerDragListener(this@GoogleMapsViewImpl)
       }
+      applyProps()
       initLocationCallbacks()
-      applyPending()
       mapReady = true
       onMapReady?.invoke(true)
     }
@@ -241,18 +241,7 @@ class GoogleMapsViewImpl(
 
   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 ->
@@ -261,65 +250,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) ->
@@ -480,9 +422,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
@@ -919,7 +863,7 @@ class GoogleMapsViewImpl(
     onUi {
       heatmapsById.values.forEach { it.remove() }
     }
-    circlesById.clear()
+    heatmapsById.clear()
     pendingHeatmaps.clear()
   }
 
@@ -968,6 +912,8 @@ class GoogleMapsViewImpl(
   }
 
   fun destroyInternal() {
+    if (destroyed) return
+    destroyed = true
     onUi {
       locationHandler.stop()
       markerBuilder.cancelAllJobs()

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

@@ -20,15 +20,38 @@ class MapCircleBuilder {
     }
 
   fun update(
-    circle: Circle,
+    prev: RNCircle,
     next: RNCircle,
+    circle: Circle,
   ) {
-    circle.center = next.center.toLatLng()
-    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.isClickable = next.pressable ?: false
-    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

@@ -54,33 +54,84 @@ class MapMarkerBuilder(
     }
 
   fun update(
-    marker: Marker,
     prev: RNMarker,
     next: RNMarker,
+    marker: Marker,
   ) {
-    marker.position =
-      next.coordinate.toLatLng()
+    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() ?: 1f
-    marker.isFlat = next.flat ?: false
-    marker.isDraggable = next.draggable ?: false
-    marker.rotation = next.rotation?.toFloat() ?: 0f
-    marker.setInfoWindowAnchor(
-      (next.infoWindowAnchor?.x ?: 0.5).toFloat(),
-      (next.infoWindowAnchor?.y ?: 0).toFloat(),
-    )
-    marker.setAnchor(
-      (next.anchor?.x ?: 0.5).toFloat(),
-      (next.anchor?.y ?: 1.0).toFloat(),
-    )
-    marker.zIndex = next.zIndex?.toFloat() ?: 0f
   }
 
   fun buildIconAsync(

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

@@ -27,21 +27,60 @@ class MapPolygonBuilder {
     }
 
   fun update(
-    poly: Polygon,
+    prev: RNPolygon,
     next: RNPolygon,
+    poly: Polygon,
   ) {
-    poly.points =
-      next.coordinates.map {
-        it.toLatLng()
-      }
-    poly.fillColor = next.fillColor?.toColor() ?: Color.TRANSPARENT
-    poly.strokeColor = next.strokeColor?.toColor() ?: Color.BLACK
-    poly.strokeWidth = next.strokeWidth?.dpToPx() ?: 1f
-    poly.isClickable = next.pressable ?: false
-    poly.isGeodesic = next.geodesic ?: false
-    poly.holes = next.holes?.map { hole ->
-      hole.coordinates.map { it.toLatLng() }
-    } ?: emptyList()
-    poly.zIndex = next.zIndex?.toFloat() ?: 0f
+    val coordsChanged =
+      prev.coordinates.size != next.coordinates.size ||
+        !prev.coordinates.zip(next.coordinates).all { (a, b) ->
+          a.latitude == b.latitude && a.longitude == b.longitude
+        }
+
+    if (coordsChanged) {
+      poly.points = next.coordinates.map { it.toLatLng() }
+    }
+
+    val prevHoles = prev.holes?.toList() ?: emptyList()
+    val nextHoles = next.holes?.toList() ?: emptyList()
+    val holesChanged =
+      prevHoles.size != nextHoles.size ||
+        !prevHoles.zip(nextHoles).all { (ha, hb) ->
+          ha.coordinates.size == hb.coordinates.size &&
+            ha.coordinates.zip(hb.coordinates).all { (a, b) ->
+              a.latitude == b.latitude && a.longitude == b.longitude
+            }
+        }
+
+    if (holesChanged) {
+      poly.holes =
+        nextHoles.map { hole ->
+          hole.coordinates.map { it.toLatLng() }
+        }
+    }
+
+    if (prev.fillColor != next.fillColor) {
+      poly.fillColor = next.fillColor?.toColor() ?: Color.TRANSPARENT
+    }
+
+    if (prev.strokeColor != next.strokeColor) {
+      poly.strokeColor = next.strokeColor?.toColor() ?: Color.BLACK
+    }
+
+    if (prev.strokeWidth != next.strokeWidth) {
+      poly.strokeWidth = next.strokeWidth?.dpToPx() ?: 1f
+    }
+
+    if (prev.pressable != next.pressable) {
+      poly.isClickable = next.pressable ?: false
+    }
+
+    if (prev.geodesic != next.geodesic) {
+      poly.isGeodesic = next.geodesic ?: false
+    }
+
+    if (prev.zIndex != next.zIndex) {
+      poly.zIndex = next.zIndex?.toFloat() ?: 0f
+    }
   }
 }

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

@@ -31,19 +31,52 @@ class MapPolylineBuilder {
     }
 
   fun update(
-    polyline: Polyline,
+    prev: RNPolyline,
     next: RNPolyline,
+    polyline: Polyline,
   ) {
-    polyline.points = next.coordinates.map { it.toLatLng() }
-    polyline.width = next.width?.dpToPx() ?: 1f
-    val cap = mapLineCap(next.lineCap ?: RNLineCapType.BUTT)
-    polyline.startCap = cap
-    polyline.endCap = cap
-    polyline.jointType = mapLineJoin(next.lineJoin ?: RNLineJoinType.MITER)
-    polyline.color = next.color?.toColor() ?: Color.BLACK
-    polyline.isClickable = next.pressable ?: false
-    polyline.isGeodesic = next.geodesic ?: false
-    polyline.zIndex = next.zIndex?.toFloat() ?: 0f
+    val coordsChanged =
+      prev.coordinates.size != next.coordinates.size ||
+        !prev.coordinates.zip(next.coordinates).all { (a, b) ->
+          a.latitude == b.latitude && a.longitude == b.longitude
+        }
+
+    if (coordsChanged) {
+      polyline.points = next.coordinates.map { it.toLatLng() }
+    }
+
+    if (prev.width != next.width) {
+      polyline.width = next.width?.dpToPx() ?: 1f
+    }
+
+    val newCap = mapLineCap(next.lineCap ?: RNLineCapType.BUTT)
+    val prevCap = mapLineCap(prev.lineCap ?: RNLineCapType.BUTT)
+    if (newCap != prevCap) {
+      polyline.startCap = newCap
+      polyline.endCap = newCap
+    }
+
+    val newJoin = mapLineJoin(next.lineJoin ?: RNLineJoinType.MITER)
+    val prevJoin = mapLineJoin(prev.lineJoin ?: RNLineJoinType.MITER)
+    if (newJoin != prevJoin) {
+      polyline.jointType = newJoin
+    }
+
+    if (prev.color != next.color) {
+      polyline.color = next.color?.toColor() ?: Color.BLACK
+    }
+
+    if (prev.pressable != next.pressable) {
+      polyline.isClickable = next.pressable ?: false
+    }
+
+    if (prev.geodesic != next.geodesic) {
+      polyline.isGeodesic = next.geodesic ?: false
+    }
+
+    if (prev.zIndex != next.zIndex) {
+      polyline.zIndex = next.zIndex?.toFloat() ?: 0f
+    }
   }
 
   private fun mapLineCap(type: RNLineCapType?): Cap =

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

@@ -157,7 +157,7 @@ class RNGoogleMapsPlusView(
         } else if (!prev.markerEquals(next)) {
           view.updateMarker(id) { marker ->
             onUi {
-              markerBuilder.update(marker, next, prev)
+              markerBuilder.update(prev, next, marker)
             }
           }
         }
@@ -181,7 +181,7 @@ class RNGoogleMapsPlusView(
         } else if (!prev.polylineEquals(next)) {
           view.updatePolyline(id) { polyline ->
             onUi {
-              polylineBuilder.update(polyline, next)
+              polylineBuilder.update(prev, next, polyline)
             }
           }
         }
@@ -205,7 +205,7 @@ class RNGoogleMapsPlusView(
           view.addPolygon(id, polygonBuilder.build(next))
         } else if (!prev.polygonEquals(next)) {
           view.updatePolygon(id) { polygon ->
-            onUi { polygonBuilder.update(polygon, next) }
+            onUi { polygonBuilder.update(prev, next, polygon) }
           }
         }
       }
@@ -229,7 +229,7 @@ class RNGoogleMapsPlusView(
         } else if (!prev.circleEquals(next)) {
           view.updateCircle(id) { circle ->
             onUi {
-              circleBuilder.update(circle, next)
+              circleBuilder.update(prev, next, circle)
             }
           }
         }

package/android/src/main/java/com/rngooglemapsplus/extensions/LocationExtension.kt

@@ -0,0 +1,59 @@
+package com.rngooglemapsplus.extensions
+
+import android.location.Location
+import android.os.Build
+import com.rngooglemapsplus.RNLatLng
+import com.rngooglemapsplus.RNLocation
+import com.rngooglemapsplus.RNLocationAndroid
+
+fun Location.toRnLocation(): RNLocation =
+  RNLocation(
+    center = RNLatLng(latitude, longitude),
+    altitude = altitude,
+    accuracy = accuracy.toDouble(),
+    bearing = bearing.toDouble(),
+    speed = speed.toDouble(),
+    time = time.toDouble(),
+    android =
+      RNLocationAndroid(
+        provider = provider,
+        elapsedRealtimeNanos = elapsedRealtimeNanos.toDouble(),
+        bearingAccuracyDegrees =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            bearingAccuracyDegrees.toDouble()
+          } else {
+            null
+          },
+        speedAccuracyMetersPerSecond =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            speedAccuracyMetersPerSecond.toDouble()
+          } else {
+            null
+          },
+        verticalAccuracyMeters =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            verticalAccuracyMeters.toDouble()
+          } else {
+            null
+          },
+        mslAltitudeMeters =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            mslAltitudeMeters
+          } else {
+            null
+          },
+        mslAltitudeAccuracyMeters =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            mslAltitudeAccuracyMeters.toDouble()
+          } else {
+            null
+          },
+        isMock =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            isMock
+          } else {
+            isFromMockProvider
+          },
+      ),
+    ios = null,
+  )