@lugg/maps 1.0.0-beta.0 → 1.0.0-beta.10

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

@@ -1,8 +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
@@ -11,12 +17,25 @@ import com.google.android.gms.maps.MapView
 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
@@ -24,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,
@@ -31,14 +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.OnMarkerDragListener,
+  GoogleMap.InfoWindowAdapter,
+  ComponentCallbacks2 {
 
   override var delegate: MapProviderDelegate? = null
   override val isMapReady: Boolean get() = _isMapReady
@@ -46,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
@@ -53,9 +87,16 @@ 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
   private var tapLocation: LatLng? = null
 
   // Initial camera settings
@@ -81,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) {
@@ -93,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)
@@ -103,12 +150,24 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun destroy() {
+    detachWindowInsetsListener()
+    context.applicationContext.unregisterComponentCallbacks(this)
+    dismissNonBubbledCallout()
+    for (markerView in liveMarkerViews) {
+      markerView.onUpdate = null
+    }
+    liveMarkerViews.clear()
     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
@@ -118,8 +177,11 @@ 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)
     googleMap?.clear()
     googleMap = null
     _isMapReady = false
@@ -141,8 +203,11 @@ 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)
 
     wrapperView?.touchEventHandler = { event ->
       if (event.action == android.view.MotionEvent.ACTION_DOWN) {
@@ -153,11 +218,15 @@ class GoogleMapProvider(private val context: Context) :
     applyUiSettings()
     applyZoomLimits()
     applyEdgeInsets()
+    applyInsetAdjustment()
     applyTheme()
     applyUserLocation()
     processPendingMarkers()
     processPendingPolylines()
     processPendingPolygons()
+    processPendingCircles()
+    processPendingGroundOverlays()
+    processPendingTileOverlays()
 
     delegate?.mapProviderDidReady()
   }
@@ -177,6 +246,8 @@ class GoogleMapProvider(private val context: Context) :
     val map = googleMap ?: return
     val position = map.cameraPosition
     delegate?.mapProviderDidMoveCamera(position.target.latitude, position.target.longitude, position.zoom, isDragging)
+    positionLiveMarkers()
+    positionNonBubbledCallout()
   }
 
   override fun onCameraIdle() {
@@ -190,6 +261,7 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun onMapClick(latLng: LatLng) {
+    dismissNonBubbledCallout()
     val map = googleMap ?: return
     val point = map.projection.toScreenLocation(latLng)
     delegate?.mapProviderDidPress(latLng.latitude, latLng.longitude, point.x.toFloat(), point.y.toFloat())
@@ -210,10 +282,42 @@ 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()
+
     markerToViewMap[marker]?.let { view ->
       val point = googleMap?.projection?.toScreenLocation(marker.position)
       view.emitPressEvent(point?.x?.toFloat() ?: 0f, point?.y?.toFloat() ?: 0f)
+
+      val calloutView = view.calloutView
+      if (calloutView != null && !calloutView.bubbled && calloutView.hasCustomContent) {
+        if (view.centerOnPress) {
+          googleMap?.animateCamera(CameraUpdateFactory.newLatLng(marker.position))
+        }
+        showNonBubbledCallout(marker, calloutView)
+        return true
+      }
+
+      if (!view.centerOnPress) {
+        marker.showInfoWindow()
+        return true
+      }
     }
     return false
   }
@@ -224,6 +328,7 @@ class GoogleMapProvider(private val context: Context) :
       view.setCoordinate(marker.position.latitude, marker.position.longitude)
       val point = googleMap?.projection?.toScreenLocation(marker.position)
       view.emitDragStartEvent(point?.x?.toFloat() ?: 0f, point?.y?.toFloat() ?: 0f)
+      if (!view.rasterize) positionLiveMarker(view)
     }
   }
 
@@ -232,6 +337,7 @@ class GoogleMapProvider(private val context: Context) :
       view.setCoordinate(marker.position.latitude, marker.position.longitude)
       val point = googleMap?.projection?.toScreenLocation(marker.position)
       view.emitDragChangeEvent(point?.x?.toFloat() ?: 0f, point?.y?.toFloat() ?: 0f)
+      if (!view.rasterize) positionLiveMarker(view)
     }
   }
 
@@ -241,7 +347,92 @@ class GoogleMapProvider(private val context: Context) :
       view.setCoordinate(marker.position.latitude, marker.position.longitude)
       val point = googleMap?.projection?.toScreenLocation(marker.position)
       view.emitDragEndEvent(point?.x?.toFloat() ?: 0f, point?.y?.toFloat() ?: 0f)
+      if (!view.rasterize) positionLiveMarker(view)
+    }
+  }
+
+  override fun getInfoWindow(marker: Marker): View? {
+    // Non-bubbled callouts are rendered as live views, not info windows
+    return null
+  }
+
+  override fun getInfoContents(marker: Marker): View? {
+    val markerView = markerToViewMap[marker] ?: return null
+    val calloutView = markerView.calloutView ?: return null
+    if (!calloutView.hasCustomContent || !calloutView.bubbled) return null
+
+    val bitmap = calloutView.createContentBitmap() ?: return null
+    return ImageView(context).apply { setImageBitmap(bitmap) }
+  }
+
+  private fun showNonBubbledCallout(marker: Marker, calloutView: LuggCalloutView) {
+    val wrapper = wrapperView ?: return
+    val contentView = calloutView.contentView
+
+    calloutView.onUpdate = {
+      layoutNonBubbledCallout()
+      positionNonBubbledCallout()
+    }
+
+    dismissInfoWindows()
+    wrapper.addView(contentView)
+    activeNonBubbledMarker = marker
+    layoutNonBubbledCallout()
+    positionNonBubbledCallout()
+  }
+
+  private fun dismissInfoWindows() {
+    for ((marker, _) in markerToViewMap) {
+      if (marker.isInfoWindowShown) {
+        marker.hideInfoWindow()
+      }
+    }
+  }
+
+  private fun dismissNonBubbledCallout() {
+    val marker = activeNonBubbledMarker ?: return
+    val markerView = markerToViewMap[marker] ?: return
+    val calloutView = markerView.calloutView ?: return
+    val contentView = calloutView.contentView
+
+    calloutView.onUpdate = null
+    (contentView.parent as? android.view.ViewGroup)?.removeView(contentView)
+    activeNonBubbledMarker = null
+  }
+
+  private fun layoutNonBubbledCallout() {
+    val marker = activeNonBubbledMarker ?: return
+    val markerView = markerToViewMap[marker] ?: return
+    val calloutView = markerView.calloutView ?: return
+    val contentView = calloutView.contentView
+
+    var contentWidth = 0
+    var contentHeight = 0
+    for (i in 0 until contentView.childCount) {
+      val child = contentView.getChildAt(i)
+      val childRight = child.left + child.width
+      val childBottom = child.top + child.height
+      if (childRight > contentWidth) contentWidth = childRight
+      if (childBottom > contentHeight) contentHeight = childBottom
     }
+
+    contentView.measure(
+      View.MeasureSpec.makeMeasureSpec(contentWidth, View.MeasureSpec.EXACTLY),
+      View.MeasureSpec.makeMeasureSpec(contentHeight, View.MeasureSpec.EXACTLY)
+    )
+    contentView.layout(0, 0, contentWidth, contentHeight)
+  }
+
+  private fun positionNonBubbledCallout() {
+    val marker = activeNonBubbledMarker ?: return
+    val markerView = markerToViewMap[marker] ?: return
+    val calloutView = markerView.calloutView ?: return
+    val contentView = calloutView.contentView
+    val map = googleMap ?: return
+
+    val point = map.projection.toScreenLocation(marker.position)
+    contentView.translationX = point.x - contentView.width / 2f + calloutView.offsetX
+    contentView.translationY = point.y - markerView.scaledContentHeight * markerView.anchorY - contentView.height + calloutView.offsetY
   }
 
   // endregion
@@ -285,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()
@@ -324,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)
@@ -335,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
@@ -356,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
@@ -374,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) {
@@ -382,6 +641,7 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun removeMarkerView(markerView: LuggMarkerView) {
+    removeLiveMarker(markerView)
     markerView.marker?.let { markerToViewMap.remove(it) }
     markerView.marker?.remove()
     markerView.marker = null
@@ -411,9 +671,14 @@ class GoogleMapProvider(private val context: Context) :
       isDraggable = markerView.draggable
     }
 
-    if (markerView.hasCustomView && markerView.scaleChanged) {
-      markerView.applyScaleToMarker()
-      markerView.clearScaleChanged()
+    if (markerView.hasCustomView) {
+      if (markerView.scaleChanged) {
+        markerView.applyScaleToMarker()
+        markerView.clearScaleChanged()
+      }
+      if (!markerView.rasterize) {
+        positionLiveMarker(markerView)
+      }
     }
   }
 
@@ -440,7 +705,64 @@ class GoogleMapProvider(private val context: Context) :
 
     markerView.marker = marker
     markerToViewMap[marker] = markerView
-    markerView.applyIconToMarker()
+
+    if (markerView.hasCustomView) {
+      if (markerView.rasterize) {
+        markerView.applyIconToMarker()
+      } else {
+        showLiveMarker(markerView)
+      }
+    }
+  }
+
+  // Workaround: AdvancedMarker.iconView is buggy on Android, so we manually add the custom
+  // content view to the wrapper and position it via screen projection instead. The underlying
+  // marker uses a transparent bitmap matching the content size so taps still trigger onMarkerClick.
+  private fun showLiveMarker(markerView: LuggMarkerView) {
+    val wrapper = wrapperView ?: return
+
+    markerView.onUpdate = {
+      updateLiveMarkerHitArea(markerView)
+      positionLiveMarker(markerView)
+    }
+
+    val contentView = markerView.contentView
+    contentView.pointerEvents = com.facebook.react.uimanager.PointerEvents.NONE
+    (contentView.parent as? android.view.ViewGroup)?.removeView(contentView)
+    wrapper.addView(contentView)
+    liveMarkerViews.add(markerView)
+    markerView.layoutContentView()
+    updateLiveMarkerHitArea(markerView)
+    positionLiveMarker(markerView)
+  }
+
+  private fun updateLiveMarkerHitArea(markerView: LuggMarkerView) {
+    val marker = markerView.marker ?: return
+    val contentView = markerView.contentView
+    val w = contentView.width.coerceAtLeast(1)
+    val h = contentView.height.coerceAtLeast(1)
+    marker.setIcon(BitmapDescriptorFactory.fromBitmap(createBitmap(w, h)))
+  }
+
+  private fun removeLiveMarker(markerView: LuggMarkerView) {
+    markerView.onUpdate = null
+    val contentView = markerView.contentView
+    (contentView.parent as? android.view.ViewGroup)?.removeView(contentView)
+    liveMarkerViews.remove(markerView)
+  }
+
+  private fun positionLiveMarkers() {
+    for (markerView in liveMarkerViews) {
+      positionLiveMarker(markerView)
+    }
+  }
+
+  private fun positionLiveMarker(markerView: LuggMarkerView) {
+    val map = googleMap ?: return
+    val contentView = markerView.contentView
+    val point = map.projection.toScreenLocation(LatLng(markerView.latitude, markerView.longitude))
+    contentView.translationX = point.x - contentView.width * markerView.anchorX
+    contentView.translationY = point.y - contentView.height * markerView.anchorY
   }
 
   // endregion
@@ -577,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() {
@@ -614,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()
@@ -626,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)
@@ -641,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
@@ -665,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")