react-native-google-maps-plus 1.7.0-dev.6 → 1.7.0-dev.8

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

@@ -8,7 +8,6 @@ import android.util.Size
 import android.widget.FrameLayout
 import androidx.core.graphics.scale
 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.maps.CameraUpdateFactory
@@ -34,6 +33,8 @@ import com.google.android.gms.maps.model.TileOverlay
 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.onUi
+import com.rngooglemapsplus.extensions.onUiSync
 import com.rngooglemapsplus.extensions.toGooglePriority
 import com.rngooglemapsplus.extensions.toLatLng
 import com.rngooglemapsplus.extensions.toLocationErrorCode
@@ -75,6 +76,7 @@ class GoogleMapsViewImpl(
   GoogleMap.OnMyLocationButtonClickListener,
   LifecycleEventListener {
   private var initialized = false
+  private var loaded = false
   private var destroyed = false
   private var googleMap: GoogleMap? = null
   private var mapView: MapView? = null
@@ -101,101 +103,102 @@ class GoogleMapsViewImpl(
     reactContext.addLifecycleEventListener(this)
   }
 
-  fun initMapView(googleMapsOptions: GoogleMapOptions) {
-    if (initialized) return
-    initialized = true
-    val result = playServiceHandler.playServicesAvailability()
-    val errorCode = result.toRNMapErrorCodeOrNull()
+  fun initMapView(googleMapsOptions: GoogleMapOptions) =
+    onUi {
+      if (initialized) return@onUi
+      initialized = true
 
-    if (errorCode != null) {
-      onMapError?.invoke(errorCode)
+      val result = playServiceHandler.playServicesAvailability()
+      val errorCode = result.toRNMapErrorCodeOrNull()
+      if (errorCode != null) {
+        onMapError?.invoke(errorCode)
+        if (errorCode == RNMapErrorCode.PLAY_SERVICES_MISSING ||
+          errorCode == RNMapErrorCode.PLAY_SERVICES_INVALID
+        ) {
+          return@onUi
+        }
+      }
 
-      if (errorCode == RNMapErrorCode.PLAY_SERVICES_MISSING ||
-        errorCode == RNMapErrorCode.PLAY_SERVICES_INVALID
-      ) {
-        return
+      mapView = MapView(reactContext, googleMapsOptions)
+      super.addView(mapView)
+
+      mapView?.onCreate(null)
+      mapView?.getMapAsync { map ->
+        googleMap = map
+        googleMap?.setOnMapLoadedCallback {
+          googleMap?.setOnCameraMoveStartedListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnCameraMoveListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnCameraIdleListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMarkerClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnPolylineClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnPolygonClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnCircleClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMapClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMapLongClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnPoiClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMarkerDragListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnInfoWindowClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnInfoWindowCloseListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnInfoWindowLongClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMyLocationClickListener(this@GoogleMapsViewImpl)
+          googleMap?.setOnMyLocationButtonClickListener(this@GoogleMapsViewImpl)
+          loaded = true
+          onMapLoaded?.invoke(
+            map.projection.visibleRegion.toRnRegion(),
+            map.cameraPosition.toRnCamera(),
+          )
+        }
+        applyProps()
+        initLocationCallbacks()
+        onMapReady?.invoke(true)
       }
     }
 
-    mapView =
-      MapView(
-        reactContext,
-        googleMapsOptions,
+  override fun onCameraMoveStarted(reason: Int) =
+    onUi {
+      if (!loaded) return@onUi
+      cameraMoveReason = reason
+      val visibleRegion = googleMap?.projection?.visibleRegion ?: return@onUi
+      val cameraPosition = googleMap?.cameraPosition ?: return@onUi
+      onCameraChangeStart?.invoke(
+        visibleRegion.toRnRegion(),
+        cameraPosition.toRnCamera(),
+        GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == reason,
       )
-
-    super.addView(mapView)
-
-    mapView?.onCreate(null)
-    mapView?.getMapAsync { map ->
-      googleMap = map
-      googleMap?.setOnMapLoadedCallback {
-        googleMap?.setOnCameraMoveStartedListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnCameraMoveListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnCameraIdleListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMarkerClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnPolylineClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnPolygonClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnCircleClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMapClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMapLongClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnPoiClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMarkerDragListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnInfoWindowClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnInfoWindowCloseListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnInfoWindowLongClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMyLocationClickListener(this@GoogleMapsViewImpl)
-        googleMap?.setOnMyLocationButtonClickListener(this@GoogleMapsViewImpl)
-        onMapLoaded?.invoke(true)
-      }
-      applyProps()
-      initLocationCallbacks()
-      onMapReady?.invoke(true)
     }
-  }
-
-  override fun onCameraMoveStarted(reason: Int) {
-    cameraMoveReason = reason
-    val visibleRegion = googleMap?.projection?.visibleRegion ?: return
-    val cameraPosition = googleMap?.cameraPosition ?: return
-
-    onCameraChangeStart?.invoke(
-      visibleRegion.toRnRegion(),
-      cameraPosition.toRnCamera(),
-      GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == reason,
-    )
-  }
-
-  override fun onCameraMove() {
-    val visibleRegion = googleMap?.projection?.visibleRegion ?: return
-    val cameraPosition = googleMap?.cameraPosition ?: return
-    val gesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
-
-    onCameraChange?.invoke(
-      visibleRegion.toRnRegion(),
-      cameraPosition.toRnCamera(),
-      gesture,
-    )
-  }
 
-  override fun onCameraIdle() {
-    val visibleRegion = googleMap?.projection?.visibleRegion ?: return
-    val cameraPosition = googleMap?.cameraPosition ?: return
-    val gesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
+  override fun onCameraMove() =
+    onUi {
+      if (!loaded) return@onUi
+      val visibleRegion = googleMap?.projection?.visibleRegion ?: return@onUi
+      val cameraPosition = googleMap?.cameraPosition ?: return@onUi
+      val gesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
+      onCameraChange?.invoke(
+        visibleRegion.toRnRegion(),
+        cameraPosition.toRnCamera(),
+        gesture,
+      )
+    }
 
-    onCameraChangeComplete?.invoke(
-      visibleRegion.toRnRegion(),
-      cameraPosition.toRnCamera(),
-      gesture,
-    )
-  }
+  override fun onCameraIdle() =
+    onUi {
+      if (!loaded) return@onUi
+      val visibleRegion = googleMap?.projection?.visibleRegion ?: return@onUi
+      val cameraPosition = googleMap?.cameraPosition ?: return@onUi
+      val gesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
+      onCameraChangeComplete?.invoke(
+        visibleRegion.toRnRegion(),
+        cameraPosition.toRnCamera(),
+        gesture,
+      )
+    }
 
   fun initLocationCallbacks() {
     locationHandler.onUpdate = { location ->
-      onLocationUpdate?.invoke(location.toRnLocation())
+      onUi { onLocationUpdate?.invoke(location.toRnLocation()) }
     }
-
     locationHandler.onError = { error ->
-      onLocationError?.invoke(error)
+      onUi { onLocationError?.invoke(error) }
     }
     locationHandler.start()
   }
@@ -214,57 +217,37 @@ class GoogleMapsViewImpl(
     locationConfig = locationConfig
 
     if (pendingMarkers.isNotEmpty()) {
-      pendingMarkers.forEach { (id, opts) ->
-        internalAddMarker(id, opts)
-      }
+      pendingMarkers.forEach { (id, opts) -> internalAddMarker(id, opts) }
       pendingMarkers.clear()
     }
-
     if (pendingPolylines.isNotEmpty()) {
-      pendingPolylines.forEach { (id, opts) ->
-        internalAddPolyline(id, opts)
-      }
+      pendingPolylines.forEach { (id, opts) -> internalAddPolyline(id, opts) }
       pendingPolylines.clear()
     }
-
     if (pendingPolygons.isNotEmpty()) {
-      pendingPolygons.forEach { (id, opts) ->
-        internalAddPolygon(id, opts)
-      }
+      pendingPolygons.forEach { (id, opts) -> internalAddPolygon(id, opts) }
       pendingPolygons.clear()
     }
-
     if (pendingCircles.isNotEmpty()) {
-      pendingCircles.forEach { (id, opts) ->
-        internalAddCircle(id, opts)
-      }
+      pendingCircles.forEach { (id, opts) -> internalAddCircle(id, opts) }
       pendingCircles.clear()
     }
-
     if (pendingHeatmaps.isNotEmpty()) {
-      pendingHeatmaps.forEach { (id, opts) ->
-        internalAddHeatmap(id, opts)
-      }
+      pendingHeatmaps.forEach { (id, opts) -> internalAddHeatmap(id, opts) }
       pendingHeatmaps.clear()
     }
-
     if (pendingKmlLayers.isNotEmpty()) {
-      pendingKmlLayers.forEach { (id, string) ->
-        internalAddKmlLayer(id, string)
-      }
+      pendingKmlLayers.forEach { (id, str) -> internalAddKmlLayer(id, str) }
       pendingKmlLayers.clear()
     }
-
     if (pendingUrlTilesOverlays.isNotEmpty()) {
-      pendingUrlTilesOverlays.forEach { (id, string) ->
-        internalAddUrlTileOverlay(id, string)
-      }
+      pendingUrlTilesOverlays.forEach { (id, opts) -> internalAddUrlTileOverlay(id, opts) }
       pendingUrlTilesOverlays.clear()
     }
   }
 
   val currentCamera: CameraPosition?
-    get() = googleMap?.cameraPosition
+    get() = onUiSync { googleMap?.cameraPosition }
 
   var initialProps: RNInitialProps? = null
 
@@ -300,8 +283,8 @@ class GoogleMapsViewImpl(
       onUi {
         try {
           googleMap?.isMyLocationEnabled = value ?: false
-        } catch (se: SecurityException) {
-          onLocationError?.invoke(RNLocationErrorCode.PERMISSION_DENIED)
+        } catch (_: SecurityException) {
+          onLocationError?.let { cb -> cb(RNLocationErrorCode.PERMISSION_DENIED) }
         } catch (ex: Exception) {
           val error = ex.toLocationErrorCode(context)
           onLocationError?.invoke(error)
@@ -312,41 +295,31 @@ class GoogleMapsViewImpl(
   var buildingEnabled: Boolean? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.isBuildingsEnabled = value ?: false
-      }
+      onUi { googleMap?.isBuildingsEnabled = value ?: false }
     }
 
   var trafficEnabled: Boolean? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.isTrafficEnabled = value ?: false
-      }
+      onUi { googleMap?.isTrafficEnabled = value ?: false }
     }
 
   var indoorEnabled: Boolean? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.isIndoorEnabled = value ?: false
-      }
+      onUi { googleMap?.isIndoorEnabled = value ?: false }
     }
 
   var customMapStyle: MapStyleOptions? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.setMapStyle(value)
-      }
+      onUi { googleMap?.setMapStyle(value) }
     }
 
   var userInterfaceStyle: Int? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.mapColorScheme = value ?: MapColorScheme.FOLLOW_SYSTEM
-      }
+      onUi { googleMap?.mapColorScheme = value ?: MapColorScheme.FOLLOW_SYSTEM }
     }
 
   var mapZoomConfig: RNMapZoomConfig? = null
@@ -374,9 +347,7 @@ class GoogleMapsViewImpl(
   var mapType: Int? = null
     set(value) {
       field = value
-      onUi {
-        googleMap?.mapType = value ?: 1
-      }
+      onUi { googleMap?.mapType = value ?: 1 }
     }
 
   var locationConfig: RNLocationConfig? = null
@@ -391,7 +362,7 @@ class GoogleMapsViewImpl(
 
   var onMapError: ((RNMapErrorCode) -> Unit)? = null
   var onMapReady: ((Boolean) -> Unit)? = null
-  var onMapLoaded: ((Boolean) -> Unit)? = null
+  var onMapLoaded: ((RNRegion, RNCamera) -> Unit)? = null
   var onLocationUpdate: ((RNLocation) -> Unit)? = null
   var onLocationError: ((RNLocationErrorCode) -> Unit)? = null
   var onMapPress: ((RNLatLng) -> Unit)? = null
@@ -419,15 +390,12 @@ class GoogleMapsViewImpl(
     cameraPosition: CameraPosition,
     animated: Boolean,
     durationMs: Int,
-  ) {
-    onUi {
-      val update = CameraUpdateFactory.newCameraPosition(cameraPosition)
-
-      if (animated) {
-        googleMap?.animateCamera(update, durationMs, null)
-      } else {
-        googleMap?.moveCamera(update)
-      }
+  ) = onUi {
+    val update = CameraUpdateFactory.newCameraPosition(cameraPosition)
+    if (animated) {
+      googleMap?.animateCamera(update, durationMs, null)
+    } else {
+      googleMap?.moveCamera(update)
     }
   }
 
@@ -436,93 +404,81 @@ class GoogleMapsViewImpl(
     padding: RNMapPadding,
     animated: Boolean,
     durationMs: Int,
-  ) {
-    if (coordinates.isEmpty()) {
-      return
-    }
-    onUi {
-      val builder = LatLngBounds.Builder()
-      coordinates.forEach { coord ->
-        builder.include(coord.toLatLng())
-      }
-      val bounds = builder.build()
-
-      val latSpan = bounds.northeast.latitude - bounds.southwest.latitude
-      val lngSpan = bounds.northeast.longitude - bounds.southwest.longitude
-
-      val latPerPixel = latSpan / (mapView?.height ?: 0)
-      val lngPerPixel = lngSpan / (mapView?.width ?: 0)
+  ) = onUi {
+    if (coordinates.isEmpty()) return@onUi
+    val builder = LatLngBounds.Builder()
+    coordinates.forEach { coord -> builder.include(coord.toLatLng()) }
+    val bounds = builder.build()
+
+    val latSpan = bounds.northeast.latitude - bounds.southwest.latitude
+    val lngSpan = bounds.northeast.longitude - bounds.southwest.longitude
+
+    val h = (mapView?.height ?: 0)
+    val w = (mapView?.width ?: 0)
+    val latPerPixel = if (h != 0) latSpan / h else 0.0
+    val lngPerPixel = if (w != 0) lngSpan / w else 0.0
+
+    builder.include(
+      LatLng(
+        bounds.northeast.latitude + (padding.top.dpToPx() * latPerPixel),
+        bounds.northeast.longitude,
+      ),
+    )
+    builder.include(
+      LatLng(
+        bounds.southwest.latitude - (padding.bottom.dpToPx() * latPerPixel),
+        bounds.southwest.longitude,
+      ),
+    )
+    builder.include(
+      LatLng(
+        bounds.northeast.latitude,
+        bounds.northeast.longitude + (padding.right.dpToPx() * lngPerPixel),
+      ),
+    )
+    builder.include(
+      LatLng(
+        bounds.southwest.latitude,
+        bounds.southwest.longitude - (padding.left.dpToPx() * lngPerPixel),
+      ),
+    )
 
-      builder.include(
-        LatLng(
-          bounds.northeast.latitude + (padding.top.dpToPx() * latPerPixel),
-          bounds.northeast.longitude,
-        ),
-      )
-      builder.include(
-        LatLng(
-          bounds.southwest.latitude - (padding.bottom.dpToPx() * latPerPixel),
-          bounds.southwest.longitude,
-        ),
+    val paddedBounds = builder.build()
+    val adjustedWidth =
+      (w - padding.left.dpToPx() - padding.right.dpToPx()).toInt().coerceAtLeast(0)
+    val adjustedHeight =
+      (h - padding.top.dpToPx() - padding.bottom.dpToPx()).toInt().coerceAtLeast(0)
+
+    val update =
+      CameraUpdateFactory.newLatLngBounds(
+        paddedBounds,
+        adjustedWidth,
+        adjustedHeight,
+        0,
       )
-      builder.include(
-        LatLng(
-          bounds.northeast.latitude,
-          bounds.northeast.longitude + (padding.right.dpToPx() * lngPerPixel),
-        ),
-      )
-      builder.include(
-        LatLng(
-          bounds.southwest.latitude,
-          bounds.southwest.longitude - (padding.left.dpToPx() * lngPerPixel),
-        ),
-      )
-
-      val paddedBounds = builder.build()
-
-      val adjustedWidth =
-        ((mapView?.width ?: 0) - padding.left.dpToPx() - padding.right.dpToPx()).toInt()
-      val adjustedHeight =
-        ((mapView?.height ?: 0) - padding.top.dpToPx() - padding.bottom.dpToPx()).toInt()
-
-      val update =
-        CameraUpdateFactory.newLatLngBounds(
-          paddedBounds,
-          adjustedWidth,
-          adjustedHeight,
-          0,
-        )
-      if (animated) {
-        googleMap?.animateCamera(update, durationMs, null)
-      } else {
-        googleMap?.moveCamera(update)
-      }
+    if (animated) {
+      googleMap?.animateCamera(update, durationMs, null)
+    } else {
+      googleMap?.moveCamera(update)
     }
   }
 
-  fun setCameraBounds(bounds: LatLngBounds?) {
+  fun setCameraBounds(bounds: LatLngBounds?) =
     onUi {
       googleMap?.setLatLngBoundsForCameraTarget(bounds)
     }
-  }
 
   fun animateToBounds(
     bounds: LatLngBounds,
     padding: Int,
     durationMs: Int,
     lockBounds: Boolean,
-  ) {
-    onUi {
-      if (lockBounds) {
-        googleMap?.setLatLngBoundsForCameraTarget(bounds)
-      }
-      val update =
-        CameraUpdateFactory.newLatLngBounds(
-          bounds,
-          padding,
-        )
-      googleMap?.animateCamera(update, durationMs, null)
+  ) = onUi {
+    if (lockBounds) {
+      googleMap?.setLatLngBoundsForCameraTarget(bounds)
     }
+    val update = CameraUpdateFactory.newLatLngBounds(bounds, padding)
+    googleMap?.animateCamera(update, durationMs, null)
   }
 
   fun snapshot(
@@ -540,12 +496,7 @@ class GoogleMapsViewImpl(
             promise.resolve(null)
             return@snapshot
           }
-
-          val scaledBitmap =
-            size?.let {
-              bitmap.scale(it.width, it.height)
-            } ?: bitmap
-
+          val scaledBitmap = size?.let { bitmap.scale(it.width, it.height) } ?: bitmap
           val output = ByteArrayOutputStream()
           scaledBitmap.compress(compressFormat, (quality * 100).toInt().coerceIn(0, 100), output)
           val bytes = output.toByteArray()
@@ -559,367 +510,288 @@ class GoogleMapsViewImpl(
             promise.resolve("data:image/$format;base64,$base64")
           }
 
-          if (scaledBitmap != bitmap) {
-            scaledBitmap.recycle()
-          }
+          if (scaledBitmap !== bitmap) scaledBitmap.recycle()
           bitmap.recycle()
-        } catch (e: Exception) {
+        } catch (_: Exception) {
           promise.resolve(null)
         }
       }
     }
-
     return promise
   }
 
   fun addMarker(
     id: String,
     opts: MarkerOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingMarkers.add(id to opts)
-      return
-    }
-
-    onUi {
-      markersById.remove(id)?.remove()
+      return@onUi
     }
+    markersById.remove(id)?.remove()
     internalAddMarker(id, opts)
   }
 
   private fun internalAddMarker(
     id: String,
     opts: MarkerOptions,
-  ) {
-    onUi {
-      val marker =
-        googleMap?.addMarker(opts).also {
-          it?.tag = id
-        }
-      if (marker != null) {
-        markersById[id] = marker
-      }
-    }
+  ) = onUi {
+    val marker = googleMap?.addMarker(opts).also { it?.tag = id }
+    if (marker != null) markersById[id] = marker
   }
 
   fun updateMarker(
     id: String,
     block: (Marker) -> Unit,
-  ) {
-    val marker = markersById[id] ?: return
-    onUi {
-      block(marker)
-    }
+  ) = onUi {
+    val marker = markersById[id] ?: return@onUi
+    block(marker)
   }
 
-  fun removeMarker(id: String) {
+  fun removeMarker(id: String) =
     onUi {
-      val marker = markersById.remove(id)
-      marker?.remove()
+      markersById.remove(id)?.remove()
     }
-  }
 
-  fun clearMarkers() {
+  fun clearMarkers() =
     onUi {
       markersById.values.forEach { it.remove() }
+      markersById.clear()
+      pendingMarkers.clear()
     }
-    markersById.clear()
-    pendingMarkers.clear()
-  }
 
   fun addPolyline(
     id: String,
     opts: PolylineOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingPolylines.add(id to opts)
-      return
-    }
-    onUi {
-      polylinesById.remove(id)?.remove()
+      return@onUi
     }
+    polylinesById.remove(id)?.remove()
     internalAddPolyline(id, opts)
   }
 
   private fun internalAddPolyline(
     id: String,
     opts: PolylineOptions,
-  ) {
-    onUi {
-      val polyline =
-        googleMap?.addPolyline(opts).also {
-          it?.tag = id
-        }
-      if (polyline != null) {
-        polylinesById[id] = polyline
-      }
-    }
+  ) = onUi {
+    val pl = googleMap?.addPolyline(opts).also { it?.tag = id }
+    if (pl != null) polylinesById[id] = pl
   }
 
   fun updatePolyline(
     id: String,
     block: (Polyline) -> Unit,
-  ) {
-    val pl = polylinesById[id] ?: return
-    onUi {
-      block(pl)
-    }
+  ) = onUi {
+    val pl = polylinesById[id] ?: return@onUi
+    block(pl)
   }
 
-  fun removePolyline(id: String) {
+  fun removePolyline(id: String) =
     onUi {
       polylinesById.remove(id)?.remove()
     }
-  }
 
-  fun clearPolylines() {
+  fun clearPolylines() =
     onUi {
       polylinesById.values.forEach { it.remove() }
+      polylinesById.clear()
+      pendingPolylines.clear()
     }
-    polylinesById.clear()
-    pendingPolylines.clear()
-  }
 
   fun addPolygon(
     id: String,
     opts: PolygonOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingPolygons.add(id to opts)
-      return
-    }
-
-    onUi {
-      polygonsById.remove(id)?.remove()
+      return@onUi
     }
+    polygonsById.remove(id)?.remove()
     internalAddPolygon(id, opts)
   }
 
   private fun internalAddPolygon(
     id: String,
     opts: PolygonOptions,
-  ) {
-    onUi {
-      val polygon =
-        googleMap?.addPolygon(opts).also {
-          it?.tag = id
-        }
-      if (polygon != null) {
-        polygonsById[id] = polygon
-      }
-    }
+  ) = onUi {
+    val polygon = googleMap?.addPolygon(opts).also { it?.tag = id }
+    if (polygon != null) polygonsById[id] = polygon
   }
 
   fun updatePolygon(
     id: String,
     block: (Polygon) -> Unit,
-  ) {
-    val polygon = polygonsById[id] ?: return
-    onUi {
-      block(polygon)
-    }
+  ) = onUi {
+    val polygon = polygonsById[id] ?: return@onUi
+    block(polygon)
   }
 
-  fun removePolygon(id: String) {
+  fun removePolygon(id: String) =
     onUi {
       polygonsById.remove(id)?.remove()
     }
-  }
 
-  fun clearPolygons() {
+  fun clearPolygons() =
     onUi {
       polygonsById.values.forEach { it.remove() }
+      polygonsById.clear()
+      pendingPolygons.clear()
     }
-    polygonsById.clear()
-    pendingPolygons.clear()
-  }
 
   fun addCircle(
     id: String,
     opts: CircleOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingCircles.add(id to opts)
-      return
-    }
-
-    onUi {
-      circlesById.remove(id)?.remove()
+      return@onUi
     }
+    circlesById.remove(id)?.remove()
     internalAddCircle(id, opts)
   }
 
   private fun internalAddCircle(
     id: String,
     opts: CircleOptions,
-  ) {
-    onUi {
-      val circle =
-        googleMap?.addCircle(opts).also {
-          it?.tag = id
-        }
-      if (circle != null) {
-        circlesById[id] = circle
-      }
-    }
+  ) = onUi {
+    val circle = googleMap?.addCircle(opts).also { it?.tag = id }
+    if (circle != null) circlesById[id] = circle
   }
 
   fun updateCircle(
     id: String,
     block: (Circle) -> Unit,
-  ) {
-    val circle = circlesById[id] ?: return
-    onUi {
-      block(circle)
-    }
+  ) = onUi {
+    val circle = circlesById[id] ?: return@onUi
+    block(circle)
   }
 
-  fun removeCircle(id: String) {
+  fun removeCircle(id: String) =
     onUi {
       circlesById.remove(id)?.remove()
     }
-  }
 
-  fun clearCircles() {
+  fun clearCircles() =
     onUi {
       circlesById.values.forEach { it.remove() }
+      circlesById.clear()
+      pendingCircles.clear()
     }
-    circlesById.clear()
-    pendingCircles.clear()
-  }
 
   fun addHeatmap(
     id: String,
     opts: TileOverlayOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingHeatmaps.add(id to opts)
-      return
-    }
-
-    onUi {
-      heatmapsById.remove(id)?.remove()
+      return@onUi
     }
+    heatmapsById.remove(id)?.remove()
     internalAddHeatmap(id, opts)
   }
 
   private fun internalAddHeatmap(
     id: String,
     opts: TileOverlayOptions,
-  ) {
-    onUi {
-      val heatmap =
-        googleMap?.addTileOverlay(opts)
-      if (heatmap != null) {
-        heatmapsById[id] = heatmap
-      }
-    }
+  ) = onUi {
+    val overlay = googleMap?.addTileOverlay(opts)
+    if (overlay != null) heatmapsById[id] = overlay
   }
 
-  fun removeHeatmap(id: String) {
+  fun removeHeatmap(id: String) =
     onUi {
-      heatmapsById.remove(id)?.remove()
+      heatmapsById.remove(id)?.let { heatMap ->
+        heatMap.clearTileCache()
+        heatMap.remove()
+      }
     }
-  }
 
-  fun clearHeatmaps() {
+  fun clearHeatmaps() =
     onUi {
       heatmapsById.values.forEach { it.remove() }
+      heatmapsById.clear()
+      pendingHeatmaps.clear()
     }
-    heatmapsById.clear()
-    pendingHeatmaps.clear()
-  }
 
   fun addKmlLayer(
     id: String,
     kmlString: String,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingKmlLayers.add(id to kmlString)
-      return
-    }
-    onUi {
-      kmlLayersById.remove(id)?.removeLayerFromMap()
+      return@onUi
     }
+    kmlLayersById.remove(id)?.removeLayerFromMap()
     internalAddKmlLayer(id, kmlString)
   }
 
   private fun internalAddKmlLayer(
     id: String,
     kmlString: String,
-  ) {
-    onUi {
-      try {
-        val inputStream = ByteArrayInputStream(kmlString.toByteArray(StandardCharsets.UTF_8))
-        val layer = KmlLayer(googleMap, inputStream, context)
-        kmlLayersById[id] = layer
-        layer.addLayerToMap()
-      } catch (e: Exception) {
-        // / ignore
-      }
+  ) = onUi {
+    try {
+      val inputStream = ByteArrayInputStream(kmlString.toByteArray(StandardCharsets.UTF_8))
+      val layer = KmlLayer(googleMap, inputStream, context)
+      kmlLayersById[id] = layer
+      layer.addLayerToMap()
+    } catch (_: Exception) {
+      // ignore
     }
   }
 
-  fun removeKmlLayer(id: String) {
+  fun removeKmlLayer(id: String) =
     onUi {
       kmlLayersById.remove(id)?.removeLayerFromMap()
     }
-  }
 
-  fun clearKmlLayer() {
+  fun clearKmlLayer() =
     onUi {
       kmlLayersById.values.forEach { it.removeLayerFromMap() }
+      kmlLayersById.clear()
+      pendingKmlLayers.clear()
     }
-    kmlLayersById.clear()
-    pendingKmlLayers.clear()
-  }
 
   fun addUrlTileOverlay(
     id: String,
     opts: TileOverlayOptions,
-  ) {
+  ) = onUi {
     if (googleMap == null) {
       pendingUrlTilesOverlays.add(id to opts)
-      return
-    }
-
-    onUi {
-      urlTileOverlaysById.remove(id)?.remove()
+      return@onUi
     }
+    urlTileOverlaysById.remove(id)?.remove()
     internalAddUrlTileOverlay(id, opts)
   }
 
   private fun internalAddUrlTileOverlay(
     id: String,
     opts: TileOverlayOptions,
-  ) {
-    onUi {
-      val urlTile =
-        googleMap?.addTileOverlay(opts)
-      if (urlTile != null) {
-        urlTileOverlaysById[id] = urlTile
-      }
-    }
+  ) = onUi {
+    val overlay = googleMap?.addTileOverlay(opts)
+    if (overlay != null) urlTileOverlaysById[id] = overlay
   }
 
-  fun removeUrlTileOverlay(id: String) {
+  fun removeUrlTileOverlay(id: String) =
     onUi {
-      urlTileOverlaysById.remove(id)?.remove()
+      urlTileOverlaysById.remove(id)?.let { urlTileOverlay ->
+        urlTileOverlay.clearTileCache()
+        urlTileOverlay.remove()
+      }
     }
-  }
 
-  fun clearUrlTileOverlays() {
+  fun clearUrlTileOverlays() =
     onUi {
       urlTileOverlaysById.values.forEach { it.remove() }
+      urlTileOverlaysById.clear()
+      pendingUrlTilesOverlays.clear()
     }
-    urlTileOverlaysById.clear()
-    pendingUrlTilesOverlays.clear()
-  }
 
-  fun destroyInternal() {
-    if (destroyed) return
-    destroyed = true
+  fun destroyInternal() =
     onUi {
+      if (destroyed) return@onUi
+      destroyed = true
       locationHandler.stop()
       markerBuilder.cancelAllJobs()
       clearMarkers()
@@ -958,7 +830,6 @@ class GoogleMapsViewImpl(
       reactContext.removeLifecycleEventListener(this)
       initialized = false
     }
-  }
 
   override fun requestLayout() {
     super.requestLayout()
@@ -972,130 +843,126 @@ class GoogleMapsViewImpl(
     }
   }
 
-  override fun onAttachedToWindow() {
-    super.onAttachedToWindow()
-    locationHandler.start()
-  }
+  override fun onAttachedToWindow() =
+    onUi {
+      super.onAttachedToWindow()
+      locationHandler.start()
+    }
 
-  override fun onDetachedFromWindow() {
-    super.onDetachedFromWindow()
-    locationHandler.stop()
-  }
+  override fun onDetachedFromWindow() =
+    onUi {
+      super.onDetachedFromWindow()
+      locationHandler.stop()
+    }
 
-  override fun onHostResume() {
+  override fun onHostResume() =
     onUi {
       locationHandler.start()
       mapView?.onResume()
     }
-  }
 
-  override fun onHostPause() {
+  override fun onHostPause() =
     onUi {
       locationHandler.stop()
       mapView?.onPause()
     }
-  }
 
   override fun onHostDestroy() {
     destroyInternal()
   }
 
   override fun onMarkerClick(marker: Marker): Boolean {
-    marker.showInfoWindow()
-    onMarkerPress?.invoke(marker.tag?.toString())
+    onUi {
+      marker.showInfoWindow()
+      onMarkerPress?.invoke(marker.tag?.toString())
+    }
     return false
   }
 
-  override fun onPolylineClick(polyline: Polyline) {
-    onPolylinePress?.invoke(polyline.tag?.toString())
-  }
+  override fun onPolylineClick(polyline: Polyline) =
+    onUi {
+      onPolylinePress?.invoke(polyline.tag?.toString())
+    }
 
-  override fun onPolygonClick(polygon: Polygon) {
-    onPolygonPress?.invoke(polygon.tag?.toString())
-  }
+  override fun onPolygonClick(polygon: Polygon) =
+    onUi {
+      onPolygonPress?.invoke(polygon.tag?.toString())
+    }
 
-  override fun onCircleClick(circle: Circle) {
-    onCirclePress?.invoke(circle.tag?.toString())
-  }
+  override fun onCircleClick(circle: Circle) =
+    onUi {
+      onCirclePress?.invoke(circle.tag?.toString())
+    }
 
-  override fun onMapClick(coordinates: LatLng) {
-    onMapPress?.invoke(
-      coordinates.toRnLatLng(),
-    )
-  }
+  override fun onMapClick(coordinates: LatLng) =
+    onUi {
+      onMapPress?.invoke(coordinates.toRnLatLng())
+    }
 
-  override fun onMapLongClick(coordinates: LatLng) {
-    onMapLongPress?.invoke(
-      coordinates.toRnLatLng(),
-    )
-  }
+  override fun onMapLongClick(coordinates: LatLng) =
+    onUi {
+      onMapLongPress?.invoke(coordinates.toRnLatLng())
+    }
 
-  override fun onMarkerDragStart(marker: Marker) {
-    onMarkerDragStart?.invoke(
-      marker.tag?.toString(),
-      marker.position.toRnLatLng(),
-    )
-  }
+  override fun onMarkerDragStart(marker: Marker) =
+    onUi {
+      onMarkerDragStart?.invoke(marker.tag?.toString(), marker.position.toRnLatLng())
+    }
 
-  override fun onMarkerDrag(marker: Marker) {
-    onMarkerDrag?.invoke(
-      marker.tag?.toString(),
-      marker.position.toRnLatLng(),
-    )
-  }
+  override fun onMarkerDrag(marker: Marker) =
+    onUi {
+      onMarkerDrag?.invoke(marker.tag?.toString(), marker.position.toRnLatLng())
+    }
 
-  override fun onMarkerDragEnd(marker: Marker) {
-    onMarkerDragEnd?.invoke(
-      marker.tag?.toString(),
-      marker.position.toRnLatLng(),
-    )
-  }
+  override fun onMarkerDragEnd(marker: Marker) =
+    onUi {
+      onMarkerDragEnd?.invoke(marker.tag?.toString(), marker.position.toRnLatLng())
+    }
 
-  override fun onIndoorBuildingFocused() {
-    val building = googleMap?.focusedBuilding ?: return
-    onIndoorBuildingFocused?.invoke(building.toRNIndoorBuilding())
-  }
+  override fun onIndoorBuildingFocused() =
+    onUi {
+      val building = googleMap?.focusedBuilding ?: return@onUi
+      onIndoorBuildingFocused?.invoke(building.toRNIndoorBuilding())
+    }
 
-  override fun onIndoorLevelActivated(indoorBuilding: IndoorBuilding) {
-    val activeLevel = indoorBuilding.levels.getOrNull(indoorBuilding.activeLevelIndex) ?: return
-    onIndoorLevelActivated?.invoke(
-      activeLevel.toRNIndoorLevel(
-        indoorBuilding.activeLevelIndex,
-        true,
-      ),
-    )
-  }
+  override fun onIndoorLevelActivated(indoorBuilding: IndoorBuilding) =
+    onUi {
+      val activeLevel =
+        indoorBuilding.levels.getOrNull(indoorBuilding.activeLevelIndex) ?: return@onUi
+      onIndoorLevelActivated?.invoke(
+        activeLevel.toRNIndoorLevel(indoorBuilding.activeLevelIndex, true),
+      )
+    }
 
-  override fun onPoiClick(poi: PointOfInterest) {
-    onPoiPress?.invoke(poi.placeId, poi.name, poi.latLng.toRnLatLng())
-  }
+  override fun onPoiClick(poi: PointOfInterest) =
+    onUi {
+      onPoiPress?.invoke(poi.placeId, poi.name, poi.latLng.toRnLatLng())
+    }
 
-  override fun onInfoWindowClick(marker: Marker) {
-    onInfoWindowPress?.invoke(marker.tag?.toString())
-  }
+  override fun onInfoWindowClick(marker: Marker) =
+    onUi {
+      onInfoWindowPress?.invoke(marker.tag?.toString())
+    }
 
-  override fun onInfoWindowClose(marker: Marker) {
-    onInfoWindowClose?.invoke(marker.tag?.toString())
-  }
+  override fun onInfoWindowClose(marker: Marker) =
+    onUi {
+      onInfoWindowClose?.invoke(marker.tag?.toString())
+    }
 
-  override fun onInfoWindowLongClick(marker: Marker) {
-    onInfoWindowLongPress?.invoke(marker.tag?.toString())
-  }
+  override fun onInfoWindowLongClick(marker: Marker) =
+    onUi {
+      onInfoWindowLongPress?.invoke(marker.tag?.toString())
+    }
 
-  override fun onMyLocationClick(location: Location) {
-    onMyLocationPress?.invoke(location.toRnLocation())
-  }
+  override fun onMyLocationClick(location: Location) =
+    onUi {
+      onMyLocationPress?.invoke(location.toRnLocation())
+    }
 
   override fun onMyLocationButtonClick(): Boolean {
-    onMyLocationButtonPress?.invoke(true)
+    onUi {
+      onMyLocationButtonPress?.invoke(true)
+    }
     return false
   }
 }
-
-private inline fun onUi(crossinline block: () -> Unit) {
-  if (UiThreadUtil.isOnUiThread()) {
-    block()
-  } else {
-    UiThreadUtil.runOnUiThread { block() }
-  }
-}