@lugg/maps 1.0.0-beta.3 → 1.0.0-beta.5

package/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt

@@ -1,10 +1,14 @@
 package com.luggmaps.core
 
 import android.annotation.SuppressLint
+import android.content.ComponentCallbacks2
 import android.content.Context
+import android.content.res.Configuration
 import android.view.View
 import android.widget.ImageView
 import androidx.core.graphics.createBitmap
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.google.android.gms.maps.CameraUpdateFactory
 import com.google.android.gms.maps.GoogleMap
@@ -14,13 +18,24 @@ import com.google.android.gms.maps.OnMapReadyCallback
 import com.google.android.gms.maps.model.AdvancedMarker
 import com.google.android.gms.maps.model.AdvancedMarkerOptions
 import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import com.google.android.gms.maps.model.Circle
+import com.google.android.gms.maps.model.CircleOptions
+import com.google.android.gms.maps.model.GroundOverlay
+import com.google.android.gms.maps.model.GroundOverlayOptions
 import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.LatLngBounds
 import com.google.android.gms.maps.model.MapColorScheme
 import com.google.android.gms.maps.model.Marker
 import com.google.android.gms.maps.model.Polygon
 import com.google.android.gms.maps.model.PolygonOptions
 import com.google.android.gms.maps.model.PolylineOptions
+import com.google.android.gms.maps.model.TileOverlayOptions
+import com.google.android.gms.maps.model.UrlTileProvider
 import com.luggmaps.LuggCalloutView
+import com.luggmaps.LuggCircleView
+import com.luggmaps.LuggCircleViewDelegate
+import com.luggmaps.LuggGroundOverlayView
+import com.luggmaps.LuggGroundOverlayViewDelegate
 import com.luggmaps.LuggMapWrapperView
 import com.luggmaps.LuggMarkerView
 import com.luggmaps.LuggMarkerViewDelegate
@@ -28,6 +43,13 @@ import com.luggmaps.LuggPolygonView
 import com.luggmaps.LuggPolygonViewDelegate
 import com.luggmaps.LuggPolylineView
 import com.luggmaps.LuggPolylineViewDelegate
+import com.luggmaps.LuggTileOverlayView
+import com.luggmaps.LuggTileOverlayViewDelegate
+import com.luggmaps.extensions.findViewByTag
+import java.net.URL
+import kotlin.math.atan
+import kotlin.math.pow
+import kotlin.math.sinh
 
 class GoogleMapProvider(private val context: Context) :
   MapProvider,
@@ -35,15 +57,21 @@ class GoogleMapProvider(private val context: Context) :
   LuggMarkerViewDelegate,
   LuggPolylineViewDelegate,
   LuggPolygonViewDelegate,
+  LuggCircleViewDelegate,
+  LuggGroundOverlayViewDelegate,
+  LuggTileOverlayViewDelegate,
   GoogleMap.OnCameraMoveStartedListener,
   GoogleMap.OnCameraMoveListener,
   GoogleMap.OnCameraIdleListener,
   GoogleMap.OnMapClickListener,
   GoogleMap.OnMapLongClickListener,
   GoogleMap.OnPolygonClickListener,
+  GoogleMap.OnCircleClickListener,
+  GoogleMap.OnGroundOverlayClickListener,
   GoogleMap.OnMarkerClickListener,
   GoogleMap.OnMarkerDragListener,
-  GoogleMap.InfoWindowAdapter {
+  GoogleMap.InfoWindowAdapter,
+  ComponentCallbacks2 {
 
   override var delegate: MapProviderDelegate? = null
   override val isMapReady: Boolean get() = _isMapReady
@@ -51,6 +79,7 @@ class GoogleMapProvider(private val context: Context) :
   var mapId: String = DEMO_MAP_ID
 
   private var wrapperView: LuggMapWrapperView? = null
+  private var currentNightMode: Int = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
   private var mapView: MapView? = null
   private var googleMap: GoogleMap? = null
   private var _isMapReady = false
@@ -58,8 +87,13 @@ class GoogleMapProvider(private val context: Context) :
   private val pendingMarkerViews = mutableSetOf<LuggMarkerView>()
   private val pendingPolylineViews = mutableSetOf<LuggPolylineView>()
   private val pendingPolygonViews = mutableSetOf<LuggPolygonView>()
+  private val pendingCircleViews = mutableSetOf<LuggCircleView>()
+  private val pendingGroundOverlayViews = mutableSetOf<LuggGroundOverlayView>()
+  private val pendingTileOverlayViews = mutableSetOf<LuggTileOverlayView>()
   private val polylineAnimators = mutableMapOf<LuggPolylineView, PolylineAnimator>()
   private val polygonToViewMap = mutableMapOf<Polygon, LuggPolygonView>()
+  private val circleToViewMap = mutableMapOf<Circle, LuggCircleView>()
+  private val groundOverlayToViewMap = mutableMapOf<GroundOverlay, LuggGroundOverlayView>()
   private val markerToViewMap = mutableMapOf<Marker, LuggMarkerView>()
   private val liveMarkerViews = mutableSetOf<LuggMarkerView>()
   private var activeNonBubbledMarker: Marker? = null
@@ -88,6 +122,10 @@ class GoogleMapProvider(private val context: Context) :
   // Edge Insets
   private var edgeInsets: EdgeInsets = EdgeInsets()
 
+  // Inset adjustment
+  private var insetAdjustment: String = "never"
+  private var systemInsets: EdgeInsets = EdgeInsets()
+
   // region MapProvider
 
   override fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float) {
@@ -100,6 +138,8 @@ class GoogleMapProvider(private val context: Context) :
     val wrapper = wrapperView as LuggMapWrapperView
     this.wrapperView = wrapper
 
+    context.applicationContext.registerComponentCallbacks(this)
+
     val options = GoogleMapOptions().mapId(mapId)
     mapView = MapView(context, options).also { view ->
       view.onCreate(null)
@@ -110,6 +150,8 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun destroy() {
+    detachWindowInsetsListener()
+    context.applicationContext.unregisterComponentCallbacks(this)
     dismissNonBubbledCallout()
     for (markerView in liveMarkerViews) {
       markerView.onUpdate = null
@@ -118,9 +160,14 @@ class GoogleMapProvider(private val context: Context) :
     pendingMarkerViews.clear()
     pendingPolylineViews.clear()
     pendingPolygonViews.clear()
+    pendingCircleViews.clear()
+    pendingGroundOverlayViews.clear()
+    pendingTileOverlayViews.clear()
     polylineAnimators.values.forEach { it.destroy() }
     polylineAnimators.clear()
     polygonToViewMap.clear()
+    circleToViewMap.clear()
+    groundOverlayToViewMap.clear()
     markerToViewMap.clear()
     wrapperView?.touchEventHandler = null
     wrapperView = null
@@ -130,6 +177,8 @@ class GoogleMapProvider(private val context: Context) :
     googleMap?.setOnMapClickListener(null)
     googleMap?.setOnMapLongClickListener(null)
     googleMap?.setOnPolygonClickListener(null)
+    googleMap?.setOnCircleClickListener(null)
+    googleMap?.setOnGroundOverlayClickListener(null)
     googleMap?.setOnMarkerClickListener(null)
     googleMap?.setOnMarkerDragListener(null)
     googleMap?.setInfoWindowAdapter(null)
@@ -154,6 +203,8 @@ class GoogleMapProvider(private val context: Context) :
     map.setOnMapClickListener(this)
     map.setOnMapLongClickListener(this)
     map.setOnPolygonClickListener(this)
+    map.setOnCircleClickListener(this)
+    map.setOnGroundOverlayClickListener(this)
     map.setOnMarkerClickListener(this)
     map.setOnMarkerDragListener(this)
     map.setInfoWindowAdapter(this)
@@ -167,11 +218,15 @@ class GoogleMapProvider(private val context: Context) :
     applyUiSettings()
     applyZoomLimits()
     applyEdgeInsets()
+    applyInsetAdjustment()
     applyTheme()
     applyUserLocation()
     processPendingMarkers()
     processPendingPolylines()
     processPendingPolygons()
+    processPendingCircles()
+    processPendingGroundOverlays()
+    processPendingTileOverlays()
 
     delegate?.mapProviderDidReady()
   }
@@ -227,6 +282,22 @@ class GoogleMapProvider(private val context: Context) :
     }
   }
 
+  override fun onCircleClick(circle: Circle) {
+    val circleView = circleToViewMap[circle]
+    if (circleView?.tappable == true) {
+      circleView.emitPressEvent()
+    } else {
+      onMapClick(tapLocation ?: return)
+    }
+  }
+
+  override fun onGroundOverlayClick(groundOverlay: GroundOverlay) {
+    val view = groundOverlayToViewMap[groundOverlay]
+    if (view?.tappable == true) {
+      view.emitPressEvent()
+    }
+  }
+
   override fun onMarkerClick(marker: Marker): Boolean {
     dismissNonBubbledCallout()
 
@@ -236,10 +307,17 @@ class GoogleMapProvider(private val context: Context) :
 
       val calloutView = view.calloutView
       if (calloutView != null && !calloutView.bubbled && calloutView.hasCustomContent) {
-        googleMap?.animateCamera(CameraUpdateFactory.newLatLng(marker.position))
+        if (view.centerOnPress) {
+          googleMap?.animateCamera(CameraUpdateFactory.newLatLng(marker.position))
+        }
         showNonBubbledCallout(marker, calloutView)
         return true
       }
+
+      if (!view.centerOnPress) {
+        marker.showInfoWindow()
+        return true
+      }
     }
     return false
   }
@@ -353,8 +431,8 @@ class GoogleMapProvider(private val context: Context) :
     val map = googleMap ?: return
 
     val point = map.projection.toScreenLocation(marker.position)
-    contentView.translationX = point.x - contentView.width * calloutView.anchorX
-    contentView.translationY = point.y - markerView.contentView.height * markerView.anchorY - contentView.height * calloutView.anchorY
+    contentView.translationX = point.x - contentView.width / 2f + calloutView.offsetX
+    contentView.translationY = point.y - markerView.scaledContentHeight * markerView.anchorY - contentView.height + calloutView.offsetY
   }
 
   // endregion
@@ -398,6 +476,15 @@ class GoogleMapProvider(private val context: Context) :
     googleMap?.uiSettings?.isMyLocationButtonEnabled = enabled
   }
 
+  override fun setMapType(value: String) {
+    googleMap?.mapType = when (value) {
+      "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
+      "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
+      "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
+      else -> GoogleMap.MAP_TYPE_NORMAL
+    }
+  }
+
   override fun setTheme(value: String) {
     theme = value
     applyTheme()
@@ -437,7 +524,7 @@ class GoogleMapProvider(private val context: Context) :
 
     if (map != null && oldInsets != edgeInsets) {
       val cameraUpdate = CameraUpdateFactory.newCameraPosition(map.cameraPosition)
-      applyEdgeInsets()
+      applyEdgeInsets(duration)
       when {
         duration < 0 -> map.animateCamera(cameraUpdate)
         duration > 0 -> map.animateCamera(cameraUpdate, duration, null)
@@ -448,6 +535,17 @@ class GoogleMapProvider(private val context: Context) :
     }
   }
 
+  override fun setInsetAdjustment(value: String) {
+    insetAdjustment = value
+    applyInsetAdjustment()
+  }
+
+  override fun setPoiEnabled(enabled: Boolean) {}
+
+  override fun setPoiFilterMode(mode: String) {}
+
+  override fun setPoiFilterCategories(categories: List<String>) {}
+
   // endregion
 
   // region MarkerViewDelegate
@@ -469,6 +567,30 @@ class GoogleMapProvider(private val context: Context) :
     syncMarkerView(markerView)
   }
 
+  override fun showCalloutForMarkerView(markerView: LuggMarkerView) {
+    val marker = markerView.marker ?: return
+    val calloutView = markerView.calloutView
+
+    if (calloutView != null && calloutView.hasCustomContent) {
+      dismissNonBubbledCallout()
+      if (calloutView.bubbled) {
+        marker.showInfoWindow()
+      } else {
+        showNonBubbledCallout(marker, calloutView)
+      }
+      return
+    }
+
+    if (!markerView.title.isNullOrEmpty()) {
+      marker.showInfoWindow()
+    }
+  }
+
+  override fun hideCalloutForMarkerView(markerView: LuggMarkerView) {
+    dismissNonBubbledCallout()
+    markerView.marker?.hideInfoWindow()
+  }
+
   // endregion
 
   // region PolylineViewDelegate
@@ -487,6 +609,30 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region CircleViewDelegate
+
+  override fun circleViewDidUpdate(circleView: LuggCircleView) {
+    syncCircleView(circleView)
+  }
+
+  // endregion
+
+  // region GroundOverlayViewDelegate
+
+  override fun groundOverlayViewDidUpdate(groundOverlayView: LuggGroundOverlayView) {
+    syncGroundOverlayView(groundOverlayView)
+  }
+
+  // endregion
+
+  // region TileOverlayViewDelegate
+
+  override fun tileOverlayViewDidUpdate(tileOverlayView: LuggTileOverlayView) {
+    syncTileOverlayView(tileOverlayView)
+  }
+
+  // endregion
+
   // region Marker Management
 
   override fun addMarkerView(markerView: LuggMarkerView) {
@@ -753,6 +899,218 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region Circle Management
+
+  override fun addCircleView(circleView: LuggCircleView) {
+    circleView.delegate = this
+    syncCircleView(circleView)
+  }
+
+  override fun removeCircleView(circleView: LuggCircleView) {
+    circleView.circle?.let { circleToViewMap.remove(it) }
+    circleView.circle?.remove()
+    circleView.circle = null
+  }
+
+  private fun syncCircleView(circleView: LuggCircleView) {
+    if (googleMap == null) {
+      pendingCircleViews.add(circleView)
+      return
+    }
+
+    if (circleView.circle == null) {
+      addCircleViewToMap(circleView)
+      return
+    }
+
+    circleView.circle?.apply {
+      center = circleView.center
+      radius = circleView.radius
+      fillColor = circleView.fillColor
+      strokeColor = circleView.strokeColor
+      strokeWidth = circleView.strokeWidth.dpToPx()
+      zIndex = circleView.zIndex
+      isClickable = true
+    }
+  }
+
+  private fun processPendingCircles() {
+    if (googleMap == null) return
+    pendingCircleViews.forEach { addCircleViewToMap(it) }
+    pendingCircleViews.clear()
+  }
+
+  private fun addCircleViewToMap(circleView: LuggCircleView) {
+    val map = googleMap ?: return
+
+    val options = CircleOptions()
+      .center(circleView.center)
+      .radius(circleView.radius)
+      .fillColor(circleView.fillColor)
+      .strokeColor(circleView.strokeColor)
+      .strokeWidth(circleView.strokeWidth.dpToPx())
+      .zIndex(circleView.zIndex)
+      .clickable(true)
+
+    val circle = map.addCircle(options)
+    circleView.circle = circle
+    circleToViewMap[circle] = circleView
+  }
+
+  // endregion
+
+  // region Ground Overlay Management
+
+  override fun addGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    groundOverlayView.delegate = this
+    syncGroundOverlayView(groundOverlayView)
+  }
+
+  override fun removeGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    groundOverlayView.delegate = null
+    groundOverlayView.groundOverlay?.let { groundOverlayToViewMap.remove(it) }
+    groundOverlayView.groundOverlay?.remove()
+    groundOverlayView.groundOverlay = null
+  }
+
+  private fun syncGroundOverlayView(groundOverlayView: LuggGroundOverlayView) {
+    if (googleMap == null) {
+      pendingGroundOverlayViews.add(groundOverlayView)
+      return
+    }
+
+    val imageUri = groundOverlayView.imageUri
+    if (imageUri.isEmpty()) return
+
+    // Remove old overlay
+    groundOverlayView.groundOverlay?.let { groundOverlayToViewMap.remove(it) }
+    groundOverlayView.groundOverlay?.remove()
+    groundOverlayView.groundOverlay = null
+
+    // Load image async and add overlay
+    Thread {
+      try {
+        val connection = URL(imageUri).openConnection() as java.net.HttpURLConnection
+        connection.instanceFollowRedirects = true
+        connection.connect()
+        val bitmap = android.graphics.BitmapFactory.decodeStream(connection.inputStream)
+        connection.disconnect()
+        if (bitmap != null) {
+          mapView?.post {
+            addGroundOverlayToMap(groundOverlayView, bitmap)
+          }
+        }
+      } catch (_: Exception) {}
+    }.start()
+  }
+
+  private fun addGroundOverlayToMap(groundOverlayView: LuggGroundOverlayView, bitmap: android.graphics.Bitmap) {
+    val map = googleMap ?: return
+
+    val bounds = LatLngBounds(groundOverlayView.southwest, groundOverlayView.northeast)
+    val options = GroundOverlayOptions()
+      .image(BitmapDescriptorFactory.fromBitmap(bitmap))
+      .positionFromBounds(bounds)
+      .transparency(1f - groundOverlayView.overlayOpacity)
+      .bearing(groundOverlayView.bearing)
+      .zIndex(groundOverlayView.zIndex)
+      .clickable(groundOverlayView.tappable)
+
+    val overlay = map.addGroundOverlay(options)
+    if (overlay != null) {
+      groundOverlayView.groundOverlay = overlay
+      groundOverlayToViewMap[overlay] = groundOverlayView
+    }
+  }
+
+  private fun processPendingGroundOverlays() {
+    if (googleMap == null) return
+    pendingGroundOverlayViews.forEach { syncGroundOverlayView(it) }
+    pendingGroundOverlayViews.clear()
+  }
+
+  // endregion
+
+  // region Tile Overlay Management
+
+  override fun addTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    tileOverlayView.delegate = this
+    syncTileOverlayView(tileOverlayView)
+  }
+
+  override fun removeTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    tileOverlayView.delegate = null
+    tileOverlayView.tileOverlay?.remove()
+    tileOverlayView.tileOverlay = null
+  }
+
+  private fun syncTileOverlayView(tileOverlayView: LuggTileOverlayView) {
+    if (googleMap == null) {
+      pendingTileOverlayViews.add(tileOverlayView)
+      return
+    }
+
+    val urlTemplate = tileOverlayView.urlTemplate
+    if (urlTemplate.isEmpty()) return
+
+    // Remove old overlay
+    tileOverlayView.tileOverlay?.remove()
+    tileOverlayView.tileOverlay = null
+
+    val tileSize = tileOverlayView.tileSize
+    val hasBounds = tileOverlayView.hasBounds
+    val swLat = tileOverlayView.boundsSwLat
+    val swLng = tileOverlayView.boundsSwLng
+    val neLat = tileOverlayView.boundsNeLat
+    val neLng = tileOverlayView.boundsNeLng
+
+    val tileProvider = object : UrlTileProvider(tileSize, tileSize) {
+      override fun getTileUrl(x: Int, y: Int, zoom: Int): URL? {
+        if (hasBounds) {
+          val n = 2.0.pow(zoom.toDouble())
+          val tileSWLat = Math.toDegrees(atan(sinh(Math.PI * (1 - 2.0 * (y + 1) / n))))
+          val tileNELat = Math.toDegrees(atan(sinh(Math.PI * (1 - 2.0 * y / n))))
+          val tileSWLng = x / n * 360.0 - 180.0
+          val tileNELng = (x + 1) / n * 360.0 - 180.0
+
+          if (tileNELat < swLat ||
+            tileSWLat > neLat ||
+            tileNELng < swLng ||
+            tileSWLng > neLng
+          ) {
+            return null
+          }
+        }
+
+        val url = urlTemplate
+          .replace("{x}", x.toString())
+          .replace("{y}", y.toString())
+          .replace("{z}", zoom.toString())
+        return try {
+          URL(url)
+        } catch (_: Exception) {
+          null
+        }
+      }
+    }
+
+    val options = TileOverlayOptions()
+      .tileProvider(tileProvider)
+      .transparency(1f - tileOverlayView.overlayOpacity)
+      .zIndex(tileOverlayView.zIndex)
+
+    val overlay = googleMap?.addTileOverlay(options)
+    tileOverlayView.tileOverlay = overlay
+  }
+
+  private fun processPendingTileOverlays() {
+    if (googleMap == null) return
+    pendingTileOverlayViews.forEach { syncTileOverlayView(it) }
+    pendingTileOverlayViews.clear()
+  }
+
+  // endregion
+
   // region Lifecycle
 
   override fun pauseAnimations() {
@@ -790,11 +1148,11 @@ class GoogleMapProvider(private val context: Context) :
     val map = googleMap ?: return
     if (coordinates.isEmpty()) return
 
-    val latLngs = coordinates.filterIsInstance<LatLng>()
-    if (latLngs.isEmpty()) return
+    val latLongs = coordinates.filterIsInstance<LatLng>()
+    if (latLongs.isEmpty()) return
 
-    val boundsBuilder = com.google.android.gms.maps.model.LatLngBounds.Builder()
-    latLngs.forEach { boundsBuilder.include(it) }
+    val boundsBuilder = LatLngBounds.Builder()
+    latLongs.forEach { boundsBuilder.include(it) }
     val bounds = boundsBuilder.build()
 
     val top = edgeInsetsTop.toFloat().dpToPx().toInt()
@@ -802,11 +1160,12 @@ class GoogleMapProvider(private val context: Context) :
     val bottom = edgeInsetsBottom.toFloat().dpToPx().toInt()
     val right = edgeInsetsRight.toFloat().dpToPx().toInt()
 
+    val combined = combinedEdgeInsets()
     map.setPadding(
-      edgeInsets.left + left,
-      edgeInsets.top + top,
-      edgeInsets.right + right,
-      edgeInsets.bottom + bottom
+      combined.left + left,
+      combined.top + top,
+      combined.right + right,
+      combined.bottom + bottom
     )
 
     val cameraUpdate = CameraUpdateFactory.newLatLngBounds(bounds, 0)
@@ -817,7 +1176,7 @@ class GoogleMapProvider(private val context: Context) :
       else -> map.moveCamera(cameraUpdate)
     }
 
-    map.setPadding(edgeInsets.left, edgeInsets.top, edgeInsets.right, edgeInsets.bottom)
+    map.setPadding(combined.left, combined.top, combined.right, combined.bottom)
   }
 
   // endregion
@@ -841,17 +1200,92 @@ class GoogleMapProvider(private val context: Context) :
     }
   }
 
-  private fun applyEdgeInsets() {
-    googleMap?.setPadding(edgeInsets.left, edgeInsets.top, edgeInsets.right, edgeInsets.bottom)
+  private fun applyInsetAdjustment() {
+    if (insetAdjustment == "automatic") {
+      attachWindowInsetsListener()
+    } else {
+      detachWindowInsetsListener()
+      systemInsets = EdgeInsets()
+    }
+    applyEdgeInsets()
+  }
+
+  private fun combinedEdgeInsets(): EdgeInsets =
+    if (insetAdjustment == "automatic") {
+      EdgeInsets(
+        edgeInsets.top + systemInsets.top,
+        edgeInsets.left + systemInsets.left,
+        edgeInsets.bottom + systemInsets.bottom,
+        edgeInsets.right + systemInsets.right
+      )
+    } else {
+      edgeInsets
+    }
+
+  private fun applyEdgeInsets(duration: Int = 0) {
+    val combined = combinedEdgeInsets()
+    googleMap?.setPadding(combined.left, combined.top, combined.right, combined.bottom)
+    applyWatermarkTranslation(combined, duration)
+  }
+
+  private fun applyWatermarkTranslation(insets: EdgeInsets, duration: Int = 0) {
+    val view = mapView ?: return
+    view.findViewByTag("GoogleWatermark")?.let { watermark ->
+      val targetY = -insets.bottom.toFloat()
+      val targetX = insets.left.toFloat()
+      if (duration > 0) {
+        watermark.animate()
+          .translationY(targetY)
+          .translationX(targetX)
+          .setDuration(duration.toLong())
+          .start()
+      } else if (duration < 0) {
+        watermark.animate()
+          .translationY(targetY)
+          .translationX(targetX)
+          .start()
+      } else {
+        watermark.translationY = targetY
+        watermark.translationX = targetX
+      }
+    }
+  }
+
+  private fun attachWindowInsetsListener() {
+    val view = mapView ?: return
+    ViewCompat.setOnApplyWindowInsetsListener(view) { _, windowInsets ->
+      val insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
+      systemInsets = EdgeInsets(insets.top, insets.left, insets.bottom, insets.right)
+      applyEdgeInsets()
+      windowInsets
+    }
+    ViewCompat.requestApplyInsets(view)
+  }
+
+  private fun detachWindowInsetsListener() {
+    mapView?.let { ViewCompat.setOnApplyWindowInsetsListener(it, null) }
+  }
+
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    val newNightMode = newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK
+    if (newNightMode != currentNightMode) {
+      currentNightMode = newNightMode
+      applyTheme()
+    }
   }
 
+  @Deprecated("Deprecated in Java")
+  override fun onLowMemory() {}
+
+  override fun onTrimMemory(level: Int) {}
+
   private fun applyTheme() {
     val colorScheme = when (theme) {
       "dark" -> MapColorScheme.DARK
       "light" -> MapColorScheme.LIGHT
       else -> MapColorScheme.FOLLOW_SYSTEM
     }
-    googleMap?.setMapColorScheme(colorScheme)
+    googleMap?.mapColorScheme = colorScheme
   }
 
   @SuppressLint("MissingPermission")